feat: add scribbles

- Add blake3_bench and sha512_bench parameters to map_stats RPC
- Track keylet hash input sizes in digest.h for performance analysis
- Implement comprehensive BLAKE3 test suite with real-world benchmarks
- Add performance comparison documentation for BLAKE3 vs SHA-512
- Include Gemini research on hash functions for small inputs

Benchmarks show BLAKE3 provides:
- 1.78x speedup for keylet operations (22-102 bytes)
- 1.35x speedup for leaf nodes (167 bytes avg)
- 1.20x speedup for inner nodes (516 bytes)
- Overall 10-13% reduction in validation time

The analysis reveals that while BLAKE3 offers measurable improvements,
the gains are modest rather than revolutionary due to:
- SHAMap traversal consuming ~47% of total time
- Diminishing returns as input size increases
- Architectural requirement for high-entropy keys

.git-blame-ignore-revs

@@ -2,7 +2,3 @@
 # To use it by default in git blame:
 # git config blame.ignoreRevsFile .git-blame-ignore-revs
 50760c693510894ca368e90369b0cc2dabfd07f3
-e2384885f5f630c8f0ffe4bf21a169b433a16858
-241b9ddde9e11beb7480600fd5ed90e1ef109b21
-760f16f56835663d9286bd29294d074de26a7ba6
-0eebe6a5f4246fced516d52b83ec4e7f47373edd

.githooks/pre-commit

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Pre-commit hook that runs the suspicious patterns check on staged files
+
+# Get the repository's root directory
+repo_root=$(git rev-parse --show-toplevel)
+
+# Run the suspicious patterns script in pre-commit mode
+"$repo_root/suspicious_patterns.sh" --pre-commit
+
+# Exit with the same code as the script
+exit $?

.githooks/setup.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+echo "Configuring git to use .githooks directory..."
+git config core.hooksPath .githooks

.github/pull_request_template.md

@@ -33,7 +33,6 @@ Please check [x] relevant options, delete irrelevant ones.
 - [ ] New feature (non-breaking change which adds functionality)
 - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
 - [ ] Refactor (non-breaking change that only restructures code)
-- [ ] Performance (increase or change in throughput and/or latency)
 - [ ] Tests (you added tests for code that already exists, or your new feature included in this PR)
 - [ ] Documentation update
 - [ ] Chore (no impact to binary, e.g. `.gitignore`, formatting, dropping support for older tooling)
@@ -59,12 +58,6 @@ Please check [x] relevant options, delete irrelevant ones.
 ## Before / After
 If relevant, use this section for an English description of the change at a technical level.
 If this change affects an API, examples should be included here.
-
-For performance-impacting changes, please provide these details:
-1. Is this a new feature, bug fix, or improvement to existing functionality?
-2. What behavior/functionality does the change impact?
-3. In what processing can the impact be measured? Be as specific as possible - e.g. RPC client call, payment transaction that involves LOB, AMM, caching, DB operations, etc.
-4. Does this change affect concurrent processing - e.g. does it involve acquiring locks, multi-threaded processing, or async processing?
 -->
 
 <!--

.github/workflows/checkpatterns.yml

@@ -1,20 +0,0 @@
-name: checkpatterns
-
-on: [push, pull_request]
-
-jobs:
-  checkpatterns:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Check for suspicious patterns
-        run: |
-          if [ -f "suspicious_patterns.sh" ]; then
-            bash suspicious_patterns.sh
-          else
-            echo "Warning: suspicious_patterns.sh not found, skipping check"
-            # Still exit with success for compatibility with dependent jobs
-            exit 0
-          fi

.gitignore

@@ -116,7 +116,3 @@ CMakeUserPresets.json
 bld.rippled/
 
 generated
-.vscode
-
-# Suggested in-tree build directory
-/.build/

API-CHANGELOG.md

@@ -1,199 +0,0 @@
-# API Changelog
-
-This changelog is intended to list all updates to the [public API methods](https://xrpl.org/public-api-methods.html).
-
-For info about how [API versioning](https://xrpl.org/request-formatting.html#api-versioning) works, including examples, please view the [XLS-22d spec](https://github.com/XRPLF/XRPL-Standards/discussions/54). For details about the implementation of API versioning, view the [implementation PR](https://github.com/XRPLF/rippled/pull/3155). API versioning ensures existing integrations and users continue to receive existing behavior, while those that request a higher API version will experience new behavior.
-
-The API version controls the API behavior you see. This includes what properties you see in responses, what parameters you're permitted to send in requests, and so on. You specify the API version in each of your requests. When a breaking change is introduced to the `rippled` API, a new version is released. To avoid breaking your code, you should set (or increase) your version when you're ready to upgrade.
-
-For a log of breaking changes, see the **API Version [number]** headings. In general, breaking changes are associated with a particular API Version number. For non-breaking changes, scroll to the **XRP Ledger version [x.y.z]** headings. Non-breaking changes are associated with a particular XRP Ledger (`rippled`) release.
-
-## API Version 1
-
-This version is supported by all `rippled` versions. At time of writing, it is the default API version, used when no `api_version` is specified. When a new API version is introduced, the command line interface will default to the latest API version. The command line is intended for ad-hoc usage by humans, not programs or automated scripts. The command line is not meant for use in production code.
-
-### Idiosyncrasies
-
-#### V1 account_info response
-
-In [the response to the `account_info` command](https://xrpl.org/account_info.html#response-format), there is `account_data` - which is supposed to be an `AccountRoot` object - and `signer_lists` is returned in this object. However, the docs say that `signer_lists` should be at the root level of the reponse.
-
-It makes sense for `signer_lists` to be at the root level because signer lists are not part of the AccountRoot object. (First reported in [xrpl-dev-portal#938](https://github.com/XRPLF/xrpl-dev-portal/issues/938).)
-
-In `api_version: 2`, the `signer_lists` field [will be moved](#modifications-to-account_info-response-in-v2) to the root level of the account_info response. (https://github.com/XRPLF/rippled/pull/3770)
-
-#### server_info - network_id
-
-The `network_id` field was added in the `server_info` response in version 1.5.0 (2019), but it is not returned in [reporting mode](https://xrpl.org/rippled-server-modes.html#reporting-mode).
-
-## XRP Ledger server version 2.0.0
-
-### Additions in 2.2
-
-Additions are intended to be non-breaking (because they are purely additive).
-
-- `feature`: A non-admin mode that uses the same formatting as admin RPC, but hides potentially-sensitive data.
-
-### Additions in 2.0
-
-Additions are intended to be non-breaking (because they are purely additive).
-
-- `server_definitions`: A new RPC that generates a `definitions.json`-like output that can be used in XRPL libraries.
-- In `Payment` transactions, `DeliverMax` has been added. This is a replacement for the `Amount` field, which should not be used. Typically, the `delivered_amount` (in transaction metadata) should be used. To ease the transition, `DeliverMax` is present regardless of API version, since adding a field is non-breaking.
-- API version 2 has been moved from beta to supported, meaning that it is generally available (regardless of the `beta_rpc_api` setting).
-
-## XRP Ledger server version 1.12.0
-
-[Version 1.12.0](https://github.com/XRPLF/rippled/releases/tag/1.12.0) was released on Sep 6, 2023.
-
-### Additions in 1.12
-
-Additions are intended to be non-breaking (because they are purely additive).
-
-- `server_info`: Added `ports`, an array which advertises the RPC and WebSocket ports. This information is also included in the `/crawl` endpoint (which calls `server_info` internally). `grpc` and `peer` ports are also included. (https://github.com/XRPLF/rippled/pull/4427)
-  - `ports` contains objects, each containing a `port` for the listening port (a number string), and a `protocol` array listing the supported protocols on that port.
-  - This allows crawlers to build a more detailed topology without needing to port-scan nodes.
-  - (For peers and other non-admin clients, the info about admin ports is excluded.)
-- Clawback: The following additions are gated by the Clawback amendment (`featureClawback`). (https://github.com/XRPLF/rippled/pull/4553)
-  - Adds an [AccountRoot flag](https://xrpl.org/accountroot.html#accountroot-flags) called `lsfAllowTrustLineClawback` (https://github.com/XRPLF/rippled/pull/4617)
-    - Adds the corresponding `asfAllowTrustLineClawback` [AccountSet Flag](https://xrpl.org/accountset.html#accountset-flags) as well.
-    - Clawback is disabled by default, so if an issuer desires the ability to claw back funds, they must use an `AccountSet` transaction to set the AllowTrustLineClawback flag. They must do this before creating any trust lines, offers, escrows, payment channels, or checks.
-  - Adds the [Clawback transaction type](https://github.com/XRPLF/XRPL-Standards/blob/master/XLS-39d-clawback/README.md#331-clawback-transaction), containing these fields:
-    - `Account`: The issuer of the asset being clawed back. Must also be the sender of the transaction.
-    - `Amount`: The amount being clawed back, with the `Amount.issuer` being the token holder's address.
-- Adds [AMM](https://github.com/XRPLF/XRPL-Standards/discussions/78) ([#4294](https://github.com/XRPLF/rippled/pull/4294), [#4626](https://github.com/XRPLF/rippled/pull/4626)) feature:
-  - Adds `amm_info` API to retrieve AMM information for a given tokens pair.
-  - Adds `AMMCreate` transaction type to create `AMM` instance.
-  - Adds `AMMDeposit` transaction type to deposit funds into `AMM` instance.
-  - Adds `AMMWithdraw` transaction type to withdraw funds from `AMM` instance.
-  - Adds `AMMVote` transaction type to vote for the trading fee of `AMM` instance.
-  - Adds `AMMBid` transaction type to bid for the Auction Slot of `AMM` instance.
-  - Adds `AMMDelete` transaction type to delete `AMM` instance.
-  - Adds `sfAMMID` to `AccountRoot` to indicate that the account is `AMM`'s account. `AMMID` is used to fetch `ltAMM`.
-  - Adds `lsfAMMNode` `TrustLine` flag to indicate that one side of the `TrustLine` is `AMM` account.
-  - Adds `tfLPToken`, `tfSingleAsset`, `tfTwoAsset`, `tfOneAssetLPToken`, `tfLimitLPToken`, `tfTwoAssetIfEmpty`,
-    `tfWithdrawAll`, `tfOneAssetWithdrawAll` which allow a trader to specify different fields combination
-    for `AMMDeposit` and `AMMWithdraw` transactions.
-  - Adds new transaction result codes:
-    - tecUNFUNDED_AMM: insufficient balance to fund AMM. The account does not have funds for liquidity provision.
-    - tecAMM_BALANCE: AMM has invalid balance. Calculated balances greater than the current pool balances.
-    - tecAMM_FAILED: AMM transaction failed. Fails due to a processing failure.
-    - tecAMM_INVALID_TOKENS: AMM invalid LP tokens. Invalid input values, format, or calculated values.
-    - tecAMM_EMPTY: AMM is in empty state. Transaction requires AMM in non-empty state (LP tokens > 0).
-    - tecAMM_NOT_EMPTY: AMM is not in empty state. Transaction requires AMM in empty state (LP tokens == 0).
-    - tecAMM_ACCOUNT: AMM account. Clawback of AMM account.
-    - tecINCOMPLETE: Some work was completed, but more submissions required to finish. AMMDelete partially deletes the trustlines.
-
-## XRP Ledger server version 1.11.0
-
-[Version 1.11.0](https://github.com/XRPLF/rippled/releases/tag/1.11.0) was released on Jun 20, 2023.
-
-### Breaking changes in 1.11
-
-- Added the ability to mark amendments as obsolete. For the `feature` admin API, there is a new possible value for the `vetoed` field. (https://github.com/XRPLF/rippled/pull/4291)
-  - The value of `vetoed` can now be `true`, `false`, or `"Obsolete"`.
-- Removed the acceptance of seeds or public keys in place of account addresses. (https://github.com/XRPLF/rippled/pull/4404)
-  - This simplifies the API and encourages better security practices (i.e. seeds should never be sent over the network).
-- For the `ledger_data` method, when all entries are filtered out, the `state` field of the response is now an empty list (in other words, an empty array, `[]`). (Previously, it would return `null`.) While this is technically a breaking change, the new behavior is consistent with the documentation, so this is considered only a bug fix. (https://github.com/XRPLF/rippled/pull/4398)
-- If and when the `fixNFTokenRemint` amendment activates, there will be a new AccountRoot field, `FirstNFTSequence`. This field is set to the current account sequence when the account issues their first NFT. If an account has not issued any NFTs, then the field is not set. ([#4406](https://github.com/XRPLF/rippled/pull/4406))
-  - There is a new account deletion restriction: an account can only be deleted if `FirstNFTSequence` + `MintedNFTokens` + `256` is less than the current ledger sequence.
-  - This is potentially a breaking change if clients have logic for determining whether an account can be deleted.
-- NetworkID
-  - For sidechains and networks with a network ID greater than 1024, there is a new [transaction common field](https://xrpl.org/transaction-common-fields.html), `NetworkID`. (https://github.com/XRPLF/rippled/pull/4370)
-    - This field helps to prevent replay attacks and is now required for chains whose network ID is 1025 or higher.
-    - The field must be omitted for Mainnet, so there is no change for Mainnet users.
-  - There are three new local error codes:
-    - `telNETWORK_ID_MAKES_TX_NON_CANONICAL`: a `NetworkID` is present but the chain's network ID is less than 1025. Remove the field from the transaction, and try again.
-    - `telREQUIRES_NETWORK_ID`: a `NetworkID` is required, but is not present. Add the field to the transaction, and try again.
-    - `telWRONG_NETWORK`: a `NetworkID` is specified, but it is for a different network. Submit the transaction to a different server which is connected to the correct network.
-
-### Additions and bug fixes in 1.11
-
-- Added `nftoken_id`, `nftoken_ids` and `offer_id` meta fields into NFT `tx` and `account_tx` responses. (https://github.com/XRPLF/rippled/pull/4447)
-- Added an `account_flags` object to the `account_info` method response. (https://github.com/XRPLF/rippled/pull/4459)
-- Added `NFTokenPages` to the `account_objects` RPC. (https://github.com/XRPLF/rippled/pull/4352)
-- Fixed: `marker` returned from the `account_lines` command would not work on subsequent commands. (https://github.com/XRPLF/rippled/pull/4361)
-
-## XRP Ledger server version 1.10.0
-
-[Version 1.10.0](https://github.com/XRPLF/rippled/releases/tag/1.10.0)
-was released on Mar 14, 2023.
-
-### Breaking changes in 1.10
-
-- If the `XRPFees` feature is enabled, the `fee_ref` field will be
-  removed from the [ledger subscription stream](https://xrpl.org/subscribe.html#ledger-stream), because it will no longer
-  have any meaning.
-
-## API Version 2
-
-API version 2 is introduced in `rippled` version 2.0. Users can request it explicitly by specifying `"api_version" : 2`.
-
-#### Removed methods
-
-In API version 2, the following deprecated methods are no longer available: (https://github.com/XRPLF/rippled/pull/4759)
-
-- `tx_history` - Instead, use other methods such as `account_tx` or `ledger` with the `transactions` field set to `true`.
-- `ledger_header` - Instead, use the `ledger` method.
-
-#### Modifications to JSON transaction element in V2
-
-In API version 2, JSON elements for transaction output have been changed and made consistent for all methods which output transactions. (https://github.com/XRPLF/rippled/pull/4775)
-This helps to unify the JSON serialization format of transactions. (https://github.com/XRPLF/clio/issues/722, https://github.com/XRPLF/rippled/issues/4727)
-
-- JSON transaction element is named `tx_json`
-- Binary transaction element is named `tx_blob`
-- JSON transaction metadata element is named `meta`
-- Binary transaction metadata element is named `meta_blob`
-
-Additionally, these elements are now consistently available next to `tx_json` (i.e. sibling elements), where possible:
-
-- `hash` - Transaction ID. This data was stored inside transaction output in API version 1, but in API version 2 is a sibling element.
-- `ledger_index` - Ledger index (only set on validated ledgers)
-- `ledger_hash` - Ledger hash (only set on closed or validated ledgers)
-- `close_time_iso` - Ledger close time expressed in ISO 8601 time format (only set on validated ledgers)
-- `validated` - Bool element set to `true` if the transaction is in a validated ledger, otherwise `false`
-
-This change affects the following methods:
-
-- `tx` - Transaction data moved into element `tx_json` (was inline inside `result`) or, if binary output was requested, moved from `tx` to `tx_blob`. Renamed binary transaction metadata element (if it was requested) from `meta` to `meta_blob`. Changed location of `hash` and added new elements
-- `account_tx` - Renamed transaction element from `tx` to `tx_json`. Renamed binary transaction metadata element (if it was requested) from `meta` to `meta_blob`. Changed location of `hash` and added new elements
-- `transaction_entry` - Renamed transaction metadata element from `metadata` to `meta`. Changed location of `hash` and added new elements
-- `subscribe` - Renamed transaction element from `transaction` to `tx_json`. Changed location of `hash` and added new elements
-- `sign`, `sign_for`, `submit` and `submit_multisigned` - Changed location of `hash` element.
-
-#### Modification to `Payment` transaction JSON schema
-
-When reading Payments, the `Amount` field should generally **not** be used. Instead, use [delivered_amount](https://xrpl.org/partial-payments.html#the-delivered_amount-field) to see the amount that the Payment delivered. To clarify its meaning, the `Amount` field is being renamed to `DeliverMax`. (https://github.com/XRPLF/rippled/pull/4733)
-
-- In `Payment` transaction type, JSON RPC field `Amount` is renamed to `DeliverMax`. To enable smooth client transition, `Amount` is still handled, as described below: (https://github.com/XRPLF/rippled/pull/4733)
-  - On JSON RPC input (e.g. `submit_multisigned` etc. methods), `Amount` is recognized as an alias to `DeliverMax` for both API version 1 and version 2 clients.
-  - On JSON RPC input, submitting both `Amount` and `DeliverMax` fields is allowed _only_ if they are identical; otherwise such input is rejected with `rpcINVALID_PARAMS` error.
-  - On JSON RPC output (e.g. `subscribe`, `account_tx` etc. methods), `DeliverMax` is present in both API version 1 and version 2.
-  - On JSON RPC output, `Amount` is only present in API version 1 and _not_ in version 2.
-
-#### Modifications to account_info response
-
-- `signer_lists` is returned in the root of the response. In API version 1, it was nested under `account_data`. (https://github.com/XRPLF/rippled/pull/3770)
-- When using an invalid `signer_lists` value, the API now returns an "invalidParams" error. (https://github.com/XRPLF/rippled/pull/4585)
-  - (`signer_lists` must be a boolean. In API version 1, strings were accepted and may return a normal response - i.e. as if `signer_lists` were `true`.)
-
-#### Modifications to [account_tx](https://xrpl.org/account_tx.html#account_tx) response
-
-- Using `ledger_index_min`, `ledger_index_max`, and `ledger_index` returns `invalidParams` because if you use `ledger_index_min` or `ledger_index_max`, then it does not make sense to also specify `ledger_index`. In API version 1, no error was returned. (https://github.com/XRPLF/rippled/pull/4571)
-  - The same applies for `ledger_index_min`, `ledger_index_max`, and `ledger_hash`. (https://github.com/XRPLF/rippled/issues/4545#issuecomment-1565065579)
-- Using a `ledger_index_min` or `ledger_index_max` beyond the range of ledgers that the server has:
-  - returns `lgrIdxMalformed` in API version 2. Previously, in API version 1, no error was returned. (https://github.com/XRPLF/rippled/issues/4288)
-- Attempting to use a non-boolean value (such as a string) for the `binary` or `forward` parameters returns `invalidParams` (`rpcINVALID_PARAMS`). Previously, in API version 1, no error was returned. (https://github.com/XRPLF/rippled/pull/4620)
-
-#### Modifications to [noripple_check](https://xrpl.org/noripple_check.html#noripple_check) response
-
-- Attempting to use a non-boolean value (such as a string) for the `transactions` parameter returns `invalidParams` (`rpcINVALID_PARAMS`). Previously, in API version 1, no error was returned. (https://github.com/XRPLF/rippled/pull/4620)
-
-# Unit tests for API changes
-
-The following information is useful to developers contributing to this project:
-
-The purpose of unit tests is to catch bugs and prevent regressions. In general, it often makes sense to create a test function when there is a breaking change to the API. For APIs that have changed in a new API version, the tests should be modified so that both the prior version and the new version are properly tested.
-
-To take one example: for `account_info` version 1, WebSocket and JSON-RPC behavior should be tested. The latest API version, i.e. API version 2, should be tested over WebSocket, JSON-RPC, and command line.

BUILD.md

@@ -1,7 +1,7 @@
-| :warning: **WARNING** :warning:
-|---|
-| These instructions assume you have a C++ development environment ready with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up on Linux, macOS, or Windows, [see this guide](./docs/build/environment.md). |
-
+> These instructions assume you have a C++ development environment ready
+> with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up
+> on Linux, macOS, or Windows, see [our guide](./docs/build/environment.md).
+>
 > These instructions also assume a basic familiarity with Conan and CMake.
 > If you are unfamiliar with Conan,
 > you can read our [crash course](./docs/build/conan.md)
@@ -29,12 +29,9 @@ branch.
 git checkout develop
 ```
 
+
 ## Minimum Requirements
 
-See [System Requirements](https://xrpl.org/system-requirements.html).
-
-Building rippled generally requires git, Python, Conan, CMake, and a C++ compiler. Some guidance on setting up such a [C++ development environment can be found here](./docs/build/environment.md).
-
 - [Python 3.7](https://www.python.org/downloads/)
 - [Conan 1.55](https://conan.io/downloads.html)
 - [CMake 3.16](https://cmake.org/download/)
@@ -44,118 +41,87 @@ The [minimum compiler versions][2] required are:
 
 | Compiler    | Version |
 |-------------|---------|
-| GCC         | 11      |
+| GCC         | 10      |
 | Clang       | 13      |
 | Apple Clang | 13.1.6  |
 | MSVC        | 19.23   |
 
-### Linux
+We don't recommend Windows for `rippled` production at this time. As of
+January 2023, Ubuntu has the highest level of quality assurance, testing,
+and support.
 
-The Ubuntu operating system has received the highest level of
-quality assurance, testing, and support.
+Windows developers should use Visual Studio 2019. `rippled` isn't
+compatible with [Boost](https://www.boost.org/) 1.78 or 1.79, and Conan
+can't build earlier Boost versions.
 
-Here are [sample instructions for setting up a C++ development environment on Linux](./docs/build/environment.md#linux).
+**Note:** 32-bit Windows development isn't supported.
 
-### Mac
-
-Many rippled engineers use macOS for development.
-
-Here are [sample instructions for setting up a C++ development environment on macOS](./docs/build/environment.md#macos).
-
-### Windows
-
-Windows is not recommended for production use at this time.
-
-- Additionally, 32-bit Windows development is not supported.
-- Visual Studio 2022 is not yet supported.
-  - rippled generally requires [Boost][] 1.77, which Conan cannot build with VS 2022.
-  - Until rippled is updated for compatibility with later versions of Boost, Windows developers may need to use Visual Studio 2019.
-
-[Boost]: https://www.boost.org/
 
 ## Steps
 
+
 ### Set Up Conan
 
-After you have a [C++ development environment](./docs/build/environment.md) ready with Git, Python, Conan, CMake, and a C++ compiler, you may need to set up your Conan profile.
-
-These instructions assume a basic familiarity with Conan and CMake.
-
-If you are unfamiliar with Conan, then please read [this crash course](./docs/build/conan.md) or the official [Getting Started][3] walkthrough.
-
-You'll need at least one Conan profile:
+1. (Optional) If you've never used Conan, use autodetect to set up a default profile.
 
    ```
    conan profile new default --detect
    ```
 
-Update the compiler settings:
+2. Update the compiler settings.
 
    ```
    conan profile update settings.compiler.cppstd=20 default
    ```
 
-**Linux** developers will commonly have a default Conan [profile][] that compiles
-with GCC and links with libstdc++.
-If you are linking with libstdc++ (see profile setting `compiler.libcxx`),
-then you will need to choose the `libstdc++11` ABI:
+   Linux developers will commonly have a default Conan [profile][] that compiles
+   with GCC and links with libstdc++.
+   If you are linking with libstdc++ (see profile setting `compiler.libcxx`),
+   then you will need to choose the `libstdc++11` ABI.
 
    ```
    conan profile update settings.compiler.libcxx=libstdc++11 default
    ```
 
-**Windows** developers may need to use the x64 native build tools.
-An easy way to do that is to run the shortcut "x64 Native Tools Command
-Prompt" for the version of Visual Studio that you have installed.
+   On Windows, you should use the x64 native build tools.
+   An easy way to do that is to run the shortcut "x64 Native Tools Command
+   Prompt" for the version of Visual Studio that you have installed.
 
    Windows developers must also build `rippled` and its dependencies for the x64
-   architecture:
+   architecture.
 
    ```
    conan profile update settings.arch=x86_64 default
    ```
 
-### Multiple compilers
+3. (Optional) If you have multiple compilers installed on your platform,
+   make sure that Conan and CMake select the one you want to use.
+   This setting will set the correct variables (`CMAKE_<LANG>_COMPILER`)
+   in the generated CMake toolchain file.
 
-When `/usr/bin/g++` exists on a platform, it is the default cpp compiler. This
-default works for some users.
+   ```
+   conan profile update 'conf.tools.build:compiler_executables={"c": "<path>", "cpp": "<path>"}' default
+   ```
 
-However, if this compiler cannot build rippled or its dependencies, then you can
-install another compiler and set Conan and CMake to use it.
-Update the `conf.tools.build:compiler_executables` setting in order to set the correct variables (`CMAKE_<LANG>_COMPILER`) in the
-generated CMake toolchain file.
-For example, on Ubuntu 20, you may have gcc at `/usr/bin/gcc` and g++ at `/usr/bin/g++`; if that is the case, you can select those compilers with:
-```
-conan profile update 'conf.tools.build:compiler_executables={"c": "/usr/bin/gcc", "cpp": "/usr/bin/g++"}' default
-```
+   It should choose the compiler for dependencies as well,
+   but not all of them have a Conan recipe that respects this setting (yet).
+   For the rest, you can set these environment variables:
 
-Replace `/usr/bin/gcc` and `/usr/bin/g++` with paths to the desired compilers.
+   ```
+   conan profile update env.CC=<path> default
+   conan profile update env.CXX=<path> default
+   ```
 
-It should choose the compiler for dependencies as well,
-but not all of them have a Conan recipe that respects this setting (yet).
-For the rest, you can set these environment variables.
-Replace `<path>` with paths to the desired compilers:
-
-- `conan profile update env.CC=<path> default`
-- `conan profile update env.CXX=<path> default`
-
-Export our [Conan recipe for Snappy](./external/snappy).
-It does not explicitly link the C++ standard library,
-which allows you to statically link it with GCC, if you want.
+4. Export our [Conan recipe for Snappy](./external/snappy).
+   It doesn't explicitly link the C++ standard library,
+   which allows you to statically link it with GCC, if you want.
 
    ```
    conan export external/snappy snappy/1.1.9@
    ```
 
-Export our [Conan recipe for RocksDB](./external/rocksdb).
-It does not override paths to dependencies when building with Visual Studio.
-
-   ```
-   conan export external/rocksdb rocksdb/6.29.5@
-   ```
-
-Export our [Conan recipe for SOCI](./external/soci).
-It patches their CMake to correctly import its dependencies.
+5. Export our [Conan recipe for SOCI](./external/soci).
+   It patches their CMake to correctly import its dependencies.
 
    ```
    conan export external/soci soci/4.0.3@
@@ -223,7 +189,7 @@ It patches their CMake to correctly import its dependencies.
     and make sure it matches the `build_type` setting you chose in the previous
     step.
 
-    Multi-config generators:
+    Multi-config gnerators:
 
     ```
     cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
@@ -269,72 +235,12 @@ It patches their CMake to correctly import its dependencies.
    generator. Pass `--help` to see the rest of the command line options.
 
 
-## Coverage report
-
-The coverage report is intended for developers using compilers GCC
-or Clang (including Apple Clang). It is generated by the build target `coverage`,
-which is only enabled when the `coverage` option is set, e.g. with
-`--options coverage=True` in `conan` or `-Dcoverage=ON` variable in `cmake`
-
-Prerequisites for the coverage report:
-
-- [gcovr tool][gcovr] (can be installed e.g. with [pip][python-pip])
-- `gcov` for GCC (installed with the compiler by default) or
-- `llvm-cov` for Clang (installed with the compiler by default)
-- `Debug` build type
-
-A coverage report is created when the following steps are completed, in order:
-
-1. `rippled` binary built with instrumentation data, enabled by the `coverage`
-   option mentioned above
-2. completed run of unit tests, which populates coverage capture data
-3. completed run of the `gcovr` tool (which internally invokes either `gcov` or `llvm-cov`)
-   to assemble both instrumentation data and the coverage capture data into a coverage report
-
-The above steps are automated into a single target `coverage`. The instrumented
-`rippled` binary can also be used for regular development or testing work, at
-the cost of extra disk space utilization and a small performance hit
-(to store coverage capture). In case of a spurious failure of unit tests, it is
-possible to re-run the `coverage` target without rebuilding the `rippled` binary
-(since it is simply a dependency of the coverage report target). It is also possible
-to select only specific tests for the purpose of the coverage report, by setting
-the `coverage_test` variable in `cmake`
-
-The default coverage report format is `html-details`, but the user
-can override it to any of the formats listed in `Builds/CMake/CodeCoverage.cmake`
-by setting the `coverage_format` variable in `cmake`. It is also possible
-to generate more than one format at a time by setting the `coverage_extra_args`
-variable in `cmake`. The specific command line used to run the `gcovr` tool will be
-displayed if the `CODE_COVERAGE_VERBOSE` variable is set.
-
-By default, the code coverage tool runs parallel unit tests with `--unittest-jobs`
- set to the number of available CPU cores. This may cause spurious test
-errors on Apple. Developers can override the number of unit test jobs with
-the `coverage_test_parallelism` variable in `cmake`.
-
-Example use with some cmake variables set:
-
-```
-cd .build
-conan install .. --output-folder . --build missing --settings build_type=Debug
-cmake -DCMAKE_BUILD_TYPE=Debug -Dcoverage=ON -Dcoverage_test_parallelism=2 -Dcoverage_format=html-details -Dcoverage_extra_args="--json coverage.json" -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
-cmake --build . --target coverage
-```
-
-After the `coverage` target is completed, the generated coverage report will be
-stored inside the build directory, as either of:
-
-- file named `coverage.`_extension_ , with a suitable extension for the report format, or
-- directory named `coverage`, with the `index.html` and other files inside, for the `html-details` or `html-nested` report formats.
-
-
 ## Options
 
 | Option | Default Value | Description |
 | --- | ---| ---|
 | `assert` | OFF | Enable assertions.
 | `reporting` | OFF | Build the reporting mode feature. |
-| `coverage` | OFF | Prepare the coverage report. |
 | `tests` | ON | Build tests. |
 | `unity` | ON | Configure a unity build. |
 | `san` | N/A | Enable a sanitizer with Clang. Choices are `thread` and `address`. |
@@ -524,10 +430,6 @@ but it is more convenient to put them in a [profile][profile].
 
 [1]: https://github.com/conan-io/conan-center-index/issues/13168
 [5]: https://en.wikipedia.org/wiki/Unity_build
-[6]: https://github.com/boostorg/beast/issues/2648
-[7]: https://github.com/boostorg/beast/issues/2661
-[gcovr]: https://gcovr.com/en/stable/getting-started.html
-[python-pip]: https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/
 [build_type]: https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
 [runtime]: https://cmake.org/cmake/help/latest/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html
 [toolchain]: https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html
@@ -537,3 +439,4 @@ but it is more convenient to put them in a [profile][profile].
 [search]: https://cmake.org/cmake/help/latest/command/find_package.html#search-procedure
 [prefix_path]: https://cmake.org/cmake/help/latest/variable/CMAKE_PREFIX_PATH.html
 [profile]: https://docs.conan.io/en/latest/reference/profiles.html
+

BUILD_LEDGER.md

@@ -0,0 +1,465 @@
+# Hash Migration Implementation via BuildLedger
+
+## Overview
+
+This document outlines the approach for implementing SHA-512 Half to BLAKE3 hash migration by performing the state map rekeying operation in the ledger building process, bypassing the metadata generation problem inherent in the transaction processing pipeline.
+
+## The Core Problem
+
+When switching from SHA-512 Half to BLAKE3, every object in the state map needs to be rekeyed because the hash (which IS the key in the SHAMap) changes. This would generate metadata showing:
+- Every object deleted at its old SHA-512 key
+- Every object created at its new BLAKE3 key
+- Total metadata size: 2× the entire state size (potentially gigabytes)
+
+## The Solution: Bypass Transaction Processing
+
+Instead of trying to rekey within the transaction processor (which tracks all changes for metadata), perform the rekeying AFTER transaction processing but BEFORE ledger finalization.
+
+## Implementation Location
+
+The key intervention point is in `buildLedgerImpl()` at line 63 of `BuildLedger.cpp`:
+
+```cpp
+// BuildLedger.cpp, lines 58-65
+{
+    OpenView accum(&*built);
+    assert(!accum.open());
+    applyTxs(accum, built);  // Apply transactions (including pseudo-txns)
+    accum.apply(*built);      // Apply accumulated changes to the ledger
+}
+// <-- INTERVENTION POINT HERE
+built->updateSkipList();
+```
+
+## Detailed Implementation
+
+### 1. Pseudo-Transaction Role (Simple Flag Setting)
+
+```cpp
+// In Change.cpp
+TER Change::applyHashMigration()
+{
+    // The pseudo-transaction just sets a flag
+    // The actual migration happens in BuildLedger
+    
+    JLOG(j_.warn()) << "Hash migration pseudo transaction triggered at ledger "
+                    << view().seq();
+    
+    // Create a migration flag object
+    auto migrationFlag = std::make_shared<SLE>(
+        keylet::hashMigrationFlag(
+            hash_options{view().seq(), KEYLET_MIGRATION_FLAG}));
+    
+    migrationFlag->setFieldU32(sfLedgerSequence, view().seq());
+    migrationFlag->setFieldU8(sfMigrationStatus, 1); // 1 = pending
+    
+    view().insert(migrationFlag);
+    
+    return tesSUCCESS;
+}
+```
+
+### 2. BuildLedger Modification
+
+```cpp
+// In BuildLedger.cpp, after line 63
+template <class ApplyTxs>
+std::shared_ptr<Ledger>
+buildLedgerImpl(
+    std::shared_ptr<Ledger const> const& parent,
+    NetClock::time_point closeTime,
+    const bool closeTimeCorrect,
+    NetClock::duration closeResolution,
+    Application& app,
+    beast::Journal j,
+    ApplyTxs&& applyTxs)
+{
+    auto built = std::make_shared<Ledger>(*parent, closeTime);
+
+    if (built->isFlagLedger() && built->rules().enabled(featureNegativeUNL))
+    {
+        built->updateNegativeUNL();
+    }
+
+    {
+        OpenView accum(&*built);
+        assert(!accum.open());
+        applyTxs(accum, built);
+        accum.apply(*built);
+    }
+    
+    // NEW: Check for hash migration flag
+    if (shouldPerformHashMigration(built, app, j))
+    {
+        performHashMigration(built, app, j);
+    }
+
+    built->updateSkipList();
+    // ... rest of function
+}
+
+// New helper functions
+bool shouldPerformHashMigration(
+    std::shared_ptr<Ledger> const& ledger,
+    Application& app,
+    beast::Journal j)
+{
+    // Check if we're in the migration window
+    constexpr LedgerIndex MIGRATION_START = 20'000'000;
+    constexpr LedgerIndex MIGRATION_END = 20'000'010;
+    
+    if (ledger->seq() < MIGRATION_START || ledger->seq() >= MIGRATION_END)
+        return false;
+    
+    // Check for migration flag
+    auto const flag = ledger->read(keylet::hashMigrationFlag(
+        hash_options{ledger->seq(), KEYLET_MIGRATION_FLAG}));
+    
+    if (!flag)
+        return false;
+    
+    return flag->getFieldU8(sfMigrationStatus) == 1; // 1 = pending
+}
+
+void performHashMigration(
+    std::shared_ptr<Ledger> const& ledger,
+    Application& app,
+    beast::Journal j)
+{
+    JLOG(j.warn()) << "PERFORMING HASH MIGRATION at ledger " << ledger->seq();
+    
+    auto& oldStateMap = ledger->stateMap();
+    
+    // Create new state map with BLAKE3 hashing
+    SHAMap newStateMap(SHAMapType::STATE, ledger->family());
+    newStateMap.setLedgerSeq(ledger->seq());
+    
+    // Track statistics
+    std::size_t objectCount = 0;
+    auto startTime = std::chrono::steady_clock::now();
+    
+    // Walk the entire state map and rekey everything
+    oldStateMap.visitLeaves([&](SHAMapItem const& item) {
+        try {
+            // Deserialize the ledger entry
+            SerialIter sit(item.slice());
+            auto sle = std::make_shared<SLE>(sit, item.key());
+            
+            // The new key would be calculated with BLAKE3
+            // For now, we'd need the actual BLAKE3 implementation
+            // uint256 newKey = calculateBlake3Key(sle);
+            
+            // For this example, let's assume we have a function that 
+            // computes the new key based on the SLE type and contents
+            uint256 newKey = computeNewHashKey(sle, ledger->seq());
+            
+            // Re-serialize the SLE
+            Serializer s;
+            sle->add(s);
+            
+            // Add to new map with new key
+            newStateMap.addGiveItem(
+                SHAMapNodeType::tnACCOUNT_STATE,
+                make_shamapitem(newKey, s.slice()));
+            
+            objectCount++;
+            
+            if (objectCount % 10000 == 0) {
+                JLOG(j.info()) << "Migration progress: " << objectCount 
+                              << " objects rekeyed";
+            }
+        }
+        catch (std::exception const& e) {
+            JLOG(j.error()) << "Failed to migrate object " << item.key()
+                           << ": " << e.what();
+            throw;
+        }
+    });
+    
+    auto endTime = std::chrono::steady_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
+        endTime - startTime);
+    
+    JLOG(j.warn()) << "Hash migration completed: " << objectCount 
+                   << " objects rekeyed in " << duration.count() << "ms";
+    
+    // Swap the state maps
+    oldStateMap = std::move(newStateMap);
+    
+    // Update the migration flag to completed
+    auto flag = ledger->peek(keylet::hashMigrationFlag(
+        hash_options{ledger->seq(), KEYLET_MIGRATION_FLAG}));
+    if (flag) {
+        flag->setFieldU8(sfMigrationStatus, 2); // 2 = completed
+        ledger->rawReplace(flag);
+    }
+}
+
+uint256 computeNewHashKey(
+    std::shared_ptr<SLE const> const& sle,
+    LedgerIndex ledgerSeq)
+{
+    // This would use BLAKE3 instead of SHA-512 Half
+    // Implementation depends on the BLAKE3 integration
+    // For now, this is a placeholder
+    
+    // The actual implementation would:
+    // 1. Determine the object type
+    // 2. Extract the identifying fields
+    // 3. Hash them with BLAKE3
+    // 4. Return the new key
+    
+    return uint256(); // Placeholder
+}
+```
+
+## Why This Approach Works
+
+### 1. No Metadata Explosion
+- The rekeying happens AFTER the `OpenView` is destroyed
+- No change tracking occurs during the rekeying
+- Only the migration flag generates metadata (minimal)
+
+### 2. Direct SHAMap Access
+- We have direct access to `built->stateMap()`
+- Can manipulate the raw data structure without going through ApplyView
+- Can create a new SHAMap and swap it in
+
+### 3. Clean Separation of Concerns
+- Pseudo-transaction: "Signal that migration should happen"
+- BuildLedger: "Actually perform the migration"
+- Transaction processor: Unchanged, doesn't need to handle massive rekeying
+
+### 4. Timing is Perfect
+- After all transactions are applied
+- Before the ledger is finalized
+- Before the skip list is updated
+- Before the SHAMap is flushed to disk
+
+## Files Referenced in This Analysis
+
+### Core Implementation Files
+- `src/ripple/app/ledger/impl/BuildLedger.cpp` - Main implementation location
+- `src/ripple/app/ledger/BuildLedger.h` - Header for build functions
+- `src/ripple/app/tx/impl/Change.cpp` - Pseudo-transaction handler
+- `src/ripple/app/tx/impl/Change.h` - Change transactor header
+
+### Transaction Processing Pipeline (analyzed but bypassed)
+- `src/ripple/app/tx/impl/Transactor.cpp` - Base transaction processor
+- `src/ripple/app/tx/impl/Transactor.h` - Transactor header
+- `src/ripple/app/tx/impl/apply.cpp` - Transaction application
+- `src/ripple/app/tx/impl/applySteps.cpp` - Transaction routing
+- `src/ripple/app/tx/impl/ApplyContext.h` - Application context
+
+### Ledger and View Classes
+- `src/ripple/app/ledger/Ledger.h` - Ledger class definition
+- `src/ripple/app/ledger/Ledger.cpp` - Ledger implementation
+- `src/ripple/ledger/ApplyView.h` - View interface
+- `src/ripple/ledger/ApplyViewImpl.h` - View implementation header
+- `src/ripple/ledger/impl/ApplyViewImpl.cpp` - View implementation
+- `src/ripple/ledger/impl/ApplyViewBase.cpp` - Base view implementation
+- `src/ripple/ledger/detail/ApplyViewBase.h` - Base view header
+- `src/ripple/ledger/OpenView.h` - Open ledger view
+- `src/ripple/ledger/RawView.h` - Raw view interface
+
+### SHAMap and Data Structures
+- `src/ripple/shamap/SHAMap.h` - SHAMap class definition
+
+### Metadata Generation
+- `src/ripple/protocol/TxMeta.h` - Transaction metadata header
+- `src/ripple/protocol/impl/TxMeta.cpp` - Metadata implementation
+
+### Consensus and Pseudo-Transaction Injection
+- `src/ripple/app/consensus/RCLConsensus.cpp` - Consensus implementation
+
+### Supporting Documents
+- `PSEUDO_TRANSACTIONS.md` - Documentation on pseudo-transactions
+- `HASH_MIGRATION_CONTEXT.md` - Context for hash migration work
+
+## Key Advantages
+
+1. **Architecturally Clean**: Works within existing ledger building framework
+2. **No Metadata Issues**: Completely bypasses the metadata generation problem
+3. **Atomic Operation**: Either the entire state is rekeyed or none of it is
+4. **Fail-Safe**: Can be wrapped in try-catch for error handling
+5. **Observable**: Can log progress for large state maps
+6. **Testable**: Can be tested independently of transaction processing
+
+## Challenges and Considerations
+
+1. **Performance**: Rekeying millions of objects will take time
+   - Solution: This happens during consensus, all nodes do it simultaneously
+   
+2. **Memory Usage**: Need to hold both old and new SHAMaps temporarily
+   - Solution: Could potentially do in-place updates with careful ordering
+   
+3. **Verification**: Need to ensure all nodes get the same result
+   - Solution: Deterministic rekeying based on ledger sequence
+
+4. **Rollback**: If migration fails, need to handle gracefully
+   - Solution: Keep old map until new map is fully built and verified
+
+## Conclusion
+
+By performing the hash migration at the ledger building level rather than within the transaction processing pipeline, we can successfully rekey the entire state map without generating massive metadata. This approach leverages the existing architecture's separation between transaction processing and ledger construction, providing a clean and efficient solution to what initially appeared to be an intractable problem.
+
+---
+
+## APPENDIX: Revised Implementation Following Ledger Pattern
+
+After reviewing the existing pattern in `BuildLedger.cpp`, it's clear that special ledger operations are implemented as methods on the `Ledger` class itself (e.g., `built->updateNegativeUNL()`). Following this pattern, the hash migration should be implemented as `Ledger::migrateToBlake3()`.
+
+### Updated BuildLedger.cpp Implementation
+
+```cpp
+// In BuildLedger.cpp, following the existing pattern
+template <class ApplyTxs>
+std::shared_ptr<Ledger>
+buildLedgerImpl(
+    std::shared_ptr<Ledger const> const& parent,
+    NetClock::time_point closeTime,
+    const bool closeTimeCorrect,
+    NetClock::duration closeResolution,
+    Application& app,
+    beast::Journal j,
+    ApplyTxs&& applyTxs)
+{
+    auto built = std::make_shared<Ledger>(*parent, closeTime);
+
+    if (built->isFlagLedger() && built->rules().enabled(featureNegativeUNL))
+    {
+        built->updateNegativeUNL();
+    }
+
+    {
+        OpenView accum(&*built);
+        assert(!accum.open());
+        applyTxs(accum, built);
+        accum.apply(*built);
+    }
+    
+    // NEW: Check and perform hash migration following the pattern
+    if (built->rules().enabled(featureBLAKE3Migration) && 
+        built->shouldMigrateToBlake3())
+    {
+        built->migrateToBlake3();
+    }
+
+    built->updateSkipList();
+    // ... rest of function
+}
+```
+
+### Ledger.h Addition
+
+```cpp
+// In src/ripple/app/ledger/Ledger.h
+class Ledger final : public std::enable_shared_from_this<Ledger>,
+                     public DigestAwareReadView,
+                     public TxsRawView,
+                     public CountedObject<Ledger>
+{
+public:
+    // ... existing methods ...
+
+    /** Update the Negative UNL ledger component. */
+    void
+    updateNegativeUNL();
+
+    /** Check if hash migration to BLAKE3 should be performed */
+    bool
+    shouldMigrateToBlake3() const;
+
+    /** Perform hash migration from SHA-512 Half to BLAKE3
+     *  This rekeys all objects in the state map with new BLAKE3 hashes.
+     *  Must be called after transactions are applied but before the
+     *  ledger is finalized.
+     */
+    void
+    migrateToBlake3();
+
+    // ... rest of class ...
+};
+```
+
+### Ledger.cpp Implementation
+
+```cpp
+// In src/ripple/app/ledger/Ledger.cpp
+
+bool
+Ledger::shouldMigrateToBlake3() const
+{
+    // Check if we're in the migration window
+    constexpr LedgerIndex MIGRATION_START = 20'000'000;
+    constexpr LedgerIndex MIGRATION_END = 20'000'010;
+    
+    if (seq() < MIGRATION_START || seq() >= MIGRATION_END)
+        return false;
+    
+    // Check for migration flag set by pseudo-transaction
+    auto const flag = read(keylet::hashMigrationFlag(
+        hash_options{seq(), KEYLET_MIGRATION_FLAG}));
+    
+    if (!flag)
+        return false;
+    
+    return flag->getFieldU8(sfMigrationStatus) == 1; // 1 = pending
+}
+
+void
+Ledger::migrateToBlake3()
+{
+    JLOG(j_.warn()) << "Performing BLAKE3 hash migration at ledger " << seq();
+    
+    // Create new state map with BLAKE3 hashing
+    SHAMap newStateMap(SHAMapType::STATE, stateMap_.family());
+    newStateMap.setLedgerSeq(seq());
+    
+    std::size_t objectCount = 0;
+    auto startTime = std::chrono::steady_clock::now();
+    
+    // Walk the entire state map and rekey everything
+    stateMap_.visitLeaves([&](SHAMapItem const& item) {
+        // Deserialize the ledger entry
+        SerialIter sit(item.slice());
+        auto sle = std::make_shared<SLE>(sit, item.key());
+        
+        // Calculate new BLAKE3-based key
+        // This would use the actual BLAKE3 implementation
+        uint256 newKey = computeBlake3Key(sle);
+        
+        // Re-serialize and add to new map
+        Serializer s;
+        sle->add(s);
+        
+        newStateMap.addGiveItem(
+            SHAMapNodeType::tnACCOUNT_STATE,
+            make_shamapitem(newKey, s.slice()));
+        
+        if (++objectCount % 10000 == 0) {
+            JLOG(j_.info()) << "Migration progress: " << objectCount 
+                          << " objects rekeyed";
+        }
+    });
+    
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::steady_clock::now() - startTime);
+    
+    JLOG(j_.warn()) << "BLAKE3 migration completed: " << objectCount 
+                   << " objects rekeyed in " << duration.count() << "ms";
+    
+    // Swap the state maps
+    stateMap_ = std::move(newStateMap);
+    
+    // Update the migration flag to completed
+    auto flag = peek(keylet::hashMigrationFlag(
+        hash_options{seq(), KEYLET_MIGRATION_FLAG}));
+    if (flag) {
+        flag->setFieldU8(sfMigrationStatus, 2); // 2 = completed
+        rawReplace(flag);
+    }
+}
+```
+
+This approach follows the established pattern in the codebase where special ledger operations are encapsulated as methods on the `Ledger` class itself, making the code more maintainable and consistent with the existing architecture.

Builds/CMake/CMakeFuncs.cmake

@@ -1,3 +1,4 @@
+
 macro(group_sources_in source_dir curdir)
   file(GLOB children RELATIVE ${source_dir}/${curdir}
     ${source_dir}/${curdir}/*)
@@ -28,8 +29,165 @@ macro (exclude_if_included target_)
   endif ()
 endmacro ()
 
+function (print_ep_logs _target)
+  ExternalProject_Get_Property (${_target} STAMP_DIR)
+  add_custom_command(TARGET ${_target} POST_BUILD
+    COMMENT "${_target} BUILD OUTPUT"
+    COMMAND ${CMAKE_COMMAND}
+      -DIN_FILE=${STAMP_DIR}/${_target}-build-out.log
+      -P ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/echo_file.cmake
+    COMMAND ${CMAKE_COMMAND}
+      -DIN_FILE=${STAMP_DIR}/${_target}-build-err.log
+      -P ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/echo_file.cmake)
+endfunction ()
+
+#[=========================================================[
+  This is a function override for one function in the
+  standard ExternalProject module. We want to change
+  the generated build script slightly to include printing
+  the build logs in the case of failure. Those modifications
+  have been made here. This function override could break
+  in the future if the ExternalProject module changes internal
+  function names or changes the way it generates the build
+  scripts.
+   See:
+    https://gitlab.kitware.com/cmake/cmake/blob/df1ddeec128d68cc636f2dde6c2acd87af5658b6/Modules/ExternalProject.cmake#L1855-1952
+#]=========================================================]
+
+function(_ep_write_log_script name step cmd_var)
+  ExternalProject_Get_Property(${name} stamp_dir)
+  set(command "${${cmd_var}}")
+
+  set(make "")
+  set(code_cygpath_make "")
+  if(command MATCHES "^\\$\\(MAKE\\)")
+    # GNU make recognizes the string "$(MAKE)" as recursive make, so
+    # ensure that it appears directly in the makefile.
+    string(REGEX REPLACE "^\\$\\(MAKE\\)" "\${make}" command "${command}")
+    set(make "-Dmake=$(MAKE)")
+
+    if(WIN32 AND NOT CYGWIN)
+      set(code_cygpath_make "
+if(\${make} MATCHES \"^/\")
+  execute_process(
+    COMMAND cygpath -w \${make}
+    OUTPUT_VARIABLE cygpath_make
+    ERROR_VARIABLE cygpath_make
+    RESULT_VARIABLE cygpath_error
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  if(NOT cygpath_error)
+    set(make \${cygpath_make})
+  endif()
+endif()
+")
+    endif()
+  endif()
+
+  set(config "")
+  if("${CMAKE_CFG_INTDIR}" MATCHES "^\\$")
+    string(REPLACE "${CMAKE_CFG_INTDIR}" "\${config}" command "${command}")
+    set(config "-Dconfig=${CMAKE_CFG_INTDIR}")
+  endif()
+
+  # Wrap multiple 'COMMAND' lines up into a second-level wrapper
+  # script so all output can be sent to one log file.
+  if(command MATCHES "(^|;)COMMAND;")
+    set(code_execute_process "
+${code_cygpath_make}
+execute_process(COMMAND \${command} RESULT_VARIABLE result)
+if(result)
+  set(msg \"Command failed (\${result}):\\n\")
+  foreach(arg IN LISTS command)
+    set(msg \"\${msg} '\${arg}'\")
+  endforeach()
+  message(FATAL_ERROR \"\${msg}\")
+endif()
+")
+    set(code "")
+    set(cmd "")
+    set(sep "")
+    foreach(arg IN LISTS command)
+      if("x${arg}" STREQUAL "xCOMMAND")
+        if(NOT "x${cmd}" STREQUAL "x")
+          string(APPEND code "set(command \"${cmd}\")${code_execute_process}")
+        endif()
+        set(cmd "")
+        set(sep "")
+      else()
+        string(APPEND cmd "${sep}${arg}")
+        set(sep ";")
+      endif()
+    endforeach()
+    string(APPEND code "set(command \"${cmd}\")${code_execute_process}")
+    file(GENERATE OUTPUT "${stamp_dir}/${name}-${step}-$<CONFIG>-impl.cmake" CONTENT "${code}")
+    set(command ${CMAKE_COMMAND} "-Dmake=\${make}" "-Dconfig=\${config}" -P ${stamp_dir}/${name}-${step}-$<CONFIG>-impl.cmake)
+  endif()
+
+  # Wrap the command in a script to log output to files.
+  set(script ${stamp_dir}/${name}-${step}-$<CONFIG>.cmake)
+  set(logbase ${stamp_dir}/${name}-${step})
+  set(code "
+${code_cygpath_make}
+function (_echo_file _fil)
+  file (READ \${_fil} _cont)
+  execute_process (COMMAND \${CMAKE_COMMAND} -E echo \"\${_cont}\")
+endfunction ()
+set(command \"${command}\")
+execute_process(
+  COMMAND \${command}
+  RESULT_VARIABLE result
+  OUTPUT_FILE \"${logbase}-out.log\"
+  ERROR_FILE \"${logbase}-err.log\"
+  )
+if(result)
+  set(msg \"Command failed: \${result}\\n\")
+  foreach(arg IN LISTS command)
+    set(msg \"\${msg} '\${arg}'\")
+  endforeach()
+  execute_process (COMMAND \${CMAKE_COMMAND} -E echo \"Build output for ${logbase} : \")
+  _echo_file (\"${logbase}-out.log\")
+  _echo_file (\"${logbase}-err.log\")
+  set(msg \"\${msg}\\nSee above\\n\")
+  message(FATAL_ERROR \"\${msg}\")
+else()
+  set(msg \"${name} ${step} command succeeded.  See also ${logbase}-*.log\")
+  message(STATUS \"\${msg}\")
+endif()
+")
+  file(GENERATE OUTPUT "${script}" CONTENT "${code}")
+  set(command ${CMAKE_COMMAND} ${make} ${config} -P ${script})
+  set(${cmd_var} "${command}" PARENT_SCOPE)
+endfunction()
+
 find_package(Git)
 
+# function that calls git log to get current hash
+function (git_hash hash_val)
+  # note: optional second extra string argument not in signature
+  if (NOT GIT_FOUND)
+    return ()
+  endif ()
+  set (_hash "")
+  set (_format "%H")
+  if (ARGC GREATER_EQUAL 2)
+    string (TOLOWER ${ARGV1} _short)
+    if (_short STREQUAL "short")
+      set (_format "%h")
+    endif ()
+  endif ()
+  execute_process (COMMAND ${GIT_EXECUTABLE} "log" "--pretty=${_format}" "-n1"
+                   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                   RESULT_VARIABLE _git_exit_code
+                   OUTPUT_VARIABLE _temp_hash
+                   OUTPUT_STRIP_TRAILING_WHITESPACE
+                   ERROR_QUIET)
+  if (_git_exit_code EQUAL 0)
+    set (_hash ${_temp_hash})
+  endif ()
+  set (${hash_val} "${_hash}" PARENT_SCOPE)
+endfunction ()
+
 function (git_branch branch_val)
   if (NOT GIT_FOUND)
     return ()
@@ -46,3 +204,4 @@ function (git_branch branch_val)
   endif ()
   set (${branch_val} "${_branch}" PARENT_SCOPE)
 endfunction ()
+

Builds/CMake/CMake_sqlite3.txt

@@ -0,0 +1,60 @@
+
+#[=========================================================[
+  SQLITE doesn't provide build files in the
+  standard source-only distribution. So we wrote
+  a simple cmake file and we copy it to the
+  external project folder so that we can use
+  this file to build the lib with ExternalProject
+#]=========================================================]
+
+add_library (sqlite3 STATIC sqlite3.c)
+#[=========================================================[
+   When compiled with SQLITE_THREADSAFE=1, SQLite operates
+   in serialized mode. In this mode, SQLite can be safely
+   used by multiple threads with no restriction.
+
+   NOTE: This implies a global mutex!
+
+   When compiled with SQLITE_THREADSAFE=2, SQLite can be
+   used in a multithreaded program so long as no two
+   threads attempt to use the same database connection at
+   the same time.
+
+   NOTE: This is the preferred threading model, but not
+   currently enabled because we need to investigate our
+   use-model and concurrency requirements.
+
+   TODO: consider whether any other options should be
+   used: https://www.sqlite.org/compile.html
+#]=========================================================]
+
+target_compile_definitions (sqlite3
+  PRIVATE
+    SQLITE_THREADSAFE=1
+    HAVE_USLEEP=1)
+target_compile_options (sqlite3
+  PRIVATE
+    $<$<BOOL:${MSVC}>:
+      -wd4100
+      -wd4127
+      -wd4232
+      -wd4244
+      -wd4701
+      -wd4706
+      -wd4996
+    >
+    $<$<NOT:$<BOOL:${MSVC}>>:-Wno-array-bounds>)
+install (
+  TARGETS
+    sqlite3
+  LIBRARY DESTINATION lib
+  ARCHIVE DESTINATION lib
+  RUNTIME DESTINATION bin
+  INCLUDES DESTINATION include)
+install (
+  FILES
+    sqlite3.h
+    sqlite3ext.h
+  DESTINATION include)
+
+

Builds/CMake/CodeCoverage.cmake

@@ -1,440 +0,0 @@
-# Copyright (c) 2012 - 2017, Lars Bilke
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without modification,
-# are permitted provided that the following conditions are met:
-#
-# 1. Redistributions of source code must retain the above copyright notice, this
-#    list of conditions and the following disclaimer.
-#
-# 2. Redistributions in binary form must reproduce the above copyright notice,
-#    this list of conditions and the following disclaimer in the documentation
-#    and/or other materials provided with the distribution.
-#
-# 3. Neither the name of the copyright holder nor the names of its contributors
-#    may be used to endorse or promote products derived from this software without
-#    specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-# CHANGES:
-#
-# 2012-01-31, Lars Bilke
-# - Enable Code Coverage
-#
-# 2013-09-17, Joakim Söderberg
-# - Added support for Clang.
-# - Some additional usage instructions.
-#
-# 2016-02-03, Lars Bilke
-# - Refactored functions to use named parameters
-#
-# 2017-06-02, Lars Bilke
-# - Merged with modified version from github.com/ufz/ogs
-#
-# 2019-05-06, Anatolii Kurotych
-# - Remove unnecessary --coverage flag
-#
-# 2019-12-13, FeRD (Frank Dana)
-# - Deprecate COVERAGE_LCOVR_EXCLUDES and COVERAGE_GCOVR_EXCLUDES lists in favor
-#   of tool-agnostic COVERAGE_EXCLUDES variable, or EXCLUDE setup arguments.
-# - CMake 3.4+: All excludes can be specified relative to BASE_DIRECTORY
-# - All setup functions: accept BASE_DIRECTORY, EXCLUDE list
-# - Set lcov basedir with -b argument
-# - Add automatic --demangle-cpp in lcovr, if 'c++filt' is available (can be
-#   overridden with NO_DEMANGLE option in setup_target_for_coverage_lcovr().)
-# - Delete output dir, .info file on 'make clean'
-# - Remove Python detection, since version mismatches will break gcovr
-# - Minor cleanup (lowercase function names, update examples...)
-#
-# 2019-12-19, FeRD (Frank Dana)
-# - Rename Lcov outputs, make filtered file canonical, fix cleanup for targets
-#
-# 2020-01-19, Bob Apthorpe
-# - Added gfortran support
-#
-# 2020-02-17, FeRD (Frank Dana)
-# - Make all add_custom_target()s VERBATIM to auto-escape wildcard characters
-#   in EXCLUDEs, and remove manual escaping from gcovr targets
-#
-# 2021-01-19, Robin Mueller
-# - Add CODE_COVERAGE_VERBOSE option which will allow to print out commands which are run
-# - Added the option for users to set the GCOVR_ADDITIONAL_ARGS variable to supply additional
-#   flags to the gcovr command
-#
-# 2020-05-04, Mihchael Davis
-#     - Add -fprofile-abs-path to make gcno files contain absolute paths
-#     - Fix BASE_DIRECTORY not working when defined
-#     - Change BYPRODUCT from folder to index.html to stop ninja from complaining about double defines
-#
-# 2021-05-10, Martin Stump
-#     - Check if the generator is multi-config before warning about non-Debug builds
-#
-# 2022-02-22, Marko Wehle
-#     - Change gcovr output from -o <filename> for --xml <filename> and --html <filename> output respectively.
-#       This will allow for Multiple Output Formats at the same time by making use of GCOVR_ADDITIONAL_ARGS, e.g. GCOVR_ADDITIONAL_ARGS "--txt".
-#
-# 2022-09-28, Sebastian Mueller
-#     - fix append_coverage_compiler_flags_to_target to correctly add flags
-#     - replace "-fprofile-arcs -ftest-coverage" with "--coverage" (equivalent)
-#
-# 2024-01-04, Bronek Kozicki
-#     - remove setup_target_for_coverage_lcov (slow) and setup_target_for_coverage_fastcov (no support for Clang)
-#     - fix Clang support by adding find_program( ... llvm-cov )
-#     - add Apple Clang support by adding execute_process( COMMAND xcrun -f llvm-cov ... )
-#     - add CODE_COVERAGE_GCOV_TOOL to explicitly select gcov tool and disable find_program
-#     - replace both functions setup_target_for_coverage_gcovr_* with a single setup_target_for_coverage_gcovr
-#     - add support for all gcovr output formats
-#
-# USAGE:
-#
-# 1. Copy this file into your cmake modules path.
-#
-# 2. Add the following line to your CMakeLists.txt (best inside an if-condition
-#    using a CMake option() to enable it just optionally):
-#      include(CodeCoverage)
-#
-# 3. Append necessary compiler flags for all supported source files:
-#      append_coverage_compiler_flags()
-#    Or for specific target:
-#      append_coverage_compiler_flags_to_target(YOUR_TARGET_NAME)
-#
-# 3.a (OPTIONAL) Set appropriate optimization flags, e.g. -O0, -O1 or -Og
-#
-# 4. If you need to exclude additional directories from the report, specify them
-#    using full paths in the COVERAGE_EXCLUDES variable before calling
-#    setup_target_for_coverage_*().
-#    Example:
-#      set(COVERAGE_EXCLUDES
-#          '${PROJECT_SOURCE_DIR}/src/dir1/*'
-#          '/path/to/my/src/dir2/*')
-#    Or, use the EXCLUDE argument to setup_target_for_coverage_*().
-#    Example:
-#      setup_target_for_coverage_gcovr(
-#          NAME coverage
-#          EXECUTABLE testrunner
-#          EXCLUDE "${PROJECT_SOURCE_DIR}/src/dir1/*" "/path/to/my/src/dir2/*")
-#
-# 4.a NOTE: With CMake 3.4+, COVERAGE_EXCLUDES or EXCLUDE can also be set
-#     relative to the BASE_DIRECTORY (default: PROJECT_SOURCE_DIR)
-#     Example:
-#       set(COVERAGE_EXCLUDES "dir1/*")
-#       setup_target_for_coverage_gcovr(
-#           NAME coverage
-#           EXECUTABLE testrunner
-#           FORMAT html-details
-#           BASE_DIRECTORY "${PROJECT_SOURCE_DIR}/src"
-#           EXCLUDE "dir2/*")
-#
-# 4.b If you need to pass specific options to gcovr, specify them in
-#     GCOVR_ADDITIONAL_ARGS variable.
-#     Example:
-#       set (GCOVR_ADDITIONAL_ARGS --exclude-throw-branches --exclude-noncode-lines -s)
-#       setup_target_for_coverage_gcovr(
-#           NAME coverage
-#           EXECUTABLE testrunner
-#           EXCLUDE "src/dir1" "src/dir2")
-#
-# 5. Use the functions described below to create a custom make target which
-#    runs your test executable and produces a code coverage report.
-#
-# 6. Build a Debug build:
-#      cmake -DCMAKE_BUILD_TYPE=Debug ..
-#      make
-#      make my_coverage_target
-
-include(CMakeParseArguments)
-
-option(CODE_COVERAGE_VERBOSE "Verbose information" FALSE)
-
-# Check prereqs
-find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
-
-if(DEFINED CODE_COVERAGE_GCOV_TOOL)
-  set(GCOV_TOOL "${CODE_COVERAGE_GCOV_TOOL}")
-elseif(DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
-  set(GCOV_TOOL "$ENV{CODE_COVERAGE_GCOV_TOOL}")
-elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
-  if(APPLE)
-    execute_process( COMMAND xcrun -f llvm-cov
-      OUTPUT_VARIABLE LLVMCOV_PATH
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-  else()
-    find_program( LLVMCOV_PATH llvm-cov )
-  endif()
-  if(LLVMCOV_PATH)
-    set(GCOV_TOOL "${LLVMCOV_PATH} gcov")
-  endif()
-elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
-  find_program( GCOV_PATH gcov )
-  set(GCOV_TOOL "${GCOV_PATH}")
-endif()
-
-# Check supported compiler (Clang, GNU and Flang)
-get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
-foreach(LANG ${LANGUAGES})
-  if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
-    if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
-      message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
-    endif()
-  elseif(NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU"
-         AND NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(LLVM)?[Ff]lang")
-    message(FATAL_ERROR "Compiler is not GNU or Flang! Aborting...")
-  endif()
-endforeach()
-
-set(COVERAGE_COMPILER_FLAGS "-g --coverage"
-    CACHE INTERNAL "")
-if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
-    include(CheckCXXCompilerFlag)
-    check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
-    if(HAVE_cxx_fprofile_abs_path)
-        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
-    endif()
-    include(CheckCCompilerFlag)
-    check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
-    if(HAVE_c_fprofile_abs_path)
-        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
-    endif()
-endif()
-
-set(CMAKE_Fortran_FLAGS_COVERAGE
-    ${COVERAGE_COMPILER_FLAGS}
-    CACHE STRING "Flags used by the Fortran compiler during coverage builds."
-    FORCE )
-set(CMAKE_CXX_FLAGS_COVERAGE
-    ${COVERAGE_COMPILER_FLAGS}
-    CACHE STRING "Flags used by the C++ compiler during coverage builds."
-    FORCE )
-set(CMAKE_C_FLAGS_COVERAGE
-    ${COVERAGE_COMPILER_FLAGS}
-    CACHE STRING "Flags used by the C compiler during coverage builds."
-    FORCE )
-set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
-    ""
-    CACHE STRING "Flags used for linking binaries during coverage builds."
-    FORCE )
-set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
-    ""
-    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
-    FORCE )
-mark_as_advanced(
-    CMAKE_Fortran_FLAGS_COVERAGE
-    CMAKE_CXX_FLAGS_COVERAGE
-    CMAKE_C_FLAGS_COVERAGE
-    CMAKE_EXE_LINKER_FLAGS_COVERAGE
-    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
-
-get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
-    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
-endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
-
-if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
-    link_libraries(gcov)
-endif()
-
-# Defines a target for running and collection code coverage information
-# Builds dependencies, runs the given executable and outputs reports.
-# NOTE! The executable should always have a ZERO as exit code otherwise
-# the coverage generation will not complete.
-#
-# setup_target_for_coverage_gcovr(
-#     NAME ctest_coverage                    # New target name
-#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
-#     DEPENDENCIES executable_target         # Dependencies to build first
-#     BASE_DIRECTORY "../"                   # Base directory for report
-#                                            #  (defaults to PROJECT_SOURCE_DIR)
-#     FORMAT "cobertura"                     # Output format, one of:
-#                                            #  xml cobertura sonarqube json-summary
-#                                            #  json-details coveralls csv txt
-#                                            #  html-single html-nested html-details
-#                                            #  (xml is an alias to cobertura;
-#                                            #  if no format is set, defaults to xml)
-#     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
-#                                            #  to BASE_DIRECTORY, with CMake 3.4+)
-# )
-# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
-# GCVOR command.
-function(setup_target_for_coverage_gcovr)
-    set(options NONE)
-    set(oneValueArgs BASE_DIRECTORY NAME FORMAT)
-    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
-    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-    if(NOT GCOV_TOOL)
-        message(FATAL_ERROR "Could not find gcov or llvm-cov tool! Aborting...")
-    endif()
-
-    if(NOT GCOVR_PATH)
-        message(FATAL_ERROR "Could not find gcovr tool! Aborting...")
-    endif()
-
-    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
-    if(DEFINED Coverage_BASE_DIRECTORY)
-        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
-    else()
-        set(BASEDIR ${PROJECT_SOURCE_DIR})
-    endif()
-
-    if(NOT DEFINED Coverage_FORMAT)
-        set(Coverage_FORMAT xml)
-    endif()
-
-    if("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
-        message(FATAL_ERROR "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting...")
-    else()
-        if((Coverage_FORMAT STREQUAL "html-details")
-            OR (Coverage_FORMAT STREQUAL "html-nested"))
-            set(GCOVR_OUTPUT_FILE ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html)
-            set(GCOVR_CREATE_FOLDER ${PROJECT_BINARY_DIR}/${Coverage_NAME})
-        elseif(Coverage_FORMAT STREQUAL "html-single")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.html)
-        elseif((Coverage_FORMAT STREQUAL "json-summary")
-            OR (Coverage_FORMAT STREQUAL "json-details")
-            OR (Coverage_FORMAT STREQUAL "coveralls"))
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.json)
-        elseif(Coverage_FORMAT STREQUAL "txt")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
-        elseif(Coverage_FORMAT STREQUAL "csv")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
-        else()
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
-        endif()
-    endif()
-
-    if((Coverage_FORMAT STREQUAL "cobertura")
-        OR (Coverage_FORMAT STREQUAL "xml"))
-        list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura "${GCOVR_OUTPUT_FILE}" )
-        list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura-pretty )
-        set(Coverage_FORMAT cobertura) # overwrite xml
-    elseif(Coverage_FORMAT STREQUAL "sonarqube")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}" )
-    elseif(Coverage_FORMAT STREQUAL "json-summary")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}" )
-        list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)
-    elseif(Coverage_FORMAT STREQUAL "json-details")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --json "${GCOVR_OUTPUT_FILE}" )
-        list(APPEND GCOVR_ADDITIONAL_ARGS --json-pretty)
-    elseif(Coverage_FORMAT STREQUAL "coveralls")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls "${GCOVR_OUTPUT_FILE}" )
-        list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls-pretty)
-    elseif(Coverage_FORMAT STREQUAL "csv")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --csv "${GCOVR_OUTPUT_FILE}" )
-    elseif(Coverage_FORMAT STREQUAL "txt")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --txt "${GCOVR_OUTPUT_FILE}" )
-    elseif(Coverage_FORMAT STREQUAL "html-single")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --html "${GCOVR_OUTPUT_FILE}" )
-        list(APPEND GCOVR_ADDITIONAL_ARGS --html-self-contained)
-    elseif(Coverage_FORMAT STREQUAL "html-nested")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --html-nested "${GCOVR_OUTPUT_FILE}" )
-    elseif(Coverage_FORMAT STREQUAL "html-details")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --html-details "${GCOVR_OUTPUT_FILE}" )
-    else()
-        message(FATAL_ERROR "Unsupported output style ${Coverage_FORMAT}! Aborting...")
-    endif()
-
-    # Collect excludes (CMake 3.4+: Also compute absolute paths)
-    set(GCOVR_EXCLUDES "")
-    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
-        if(CMAKE_VERSION VERSION_GREATER 3.4)
-            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
-        endif()
-        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
-    endforeach()
-    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
-
-    # Combine excludes to several -e arguments
-    set(GCOVR_EXCLUDE_ARGS "")
-    foreach(EXCLUDE ${GCOVR_EXCLUDES})
-        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
-        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
-    endforeach()
-
-    # Set up commands which will be run to generate coverage data
-    # Run tests
-    set(GCOVR_EXEC_TESTS_CMD
-        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
-    )
-
-    # Create folder
-    if(DEFINED GCOVR_CREATE_FOLDER)
-        set(GCOVR_FOLDER_CMD
-            ${CMAKE_COMMAND} -E make_directory ${GCOVR_CREATE_FOLDER})
-    else()
-        set(GCOVR_FOLDER_CMD echo) # dummy
-    endif()
-
-    # Running gcovr
-    set(GCOVR_CMD
-        ${GCOVR_PATH}
-        --gcov-executable ${GCOV_TOOL}
-        --gcov-ignore-parse-errors=negative_hits.warn_once_per_file
-        -r ${BASEDIR}
-        ${GCOVR_ADDITIONAL_ARGS}
-        ${GCOVR_EXCLUDE_ARGS}
-        --object-directory=${PROJECT_BINARY_DIR}
-    )
-
-    if(CODE_COVERAGE_VERBOSE)
-        message(STATUS "Executed command report")
-
-        message(STATUS "Command to run tests: ")
-        string(REPLACE ";" " " GCOVR_EXEC_TESTS_CMD_SPACED "${GCOVR_EXEC_TESTS_CMD}")
-        message(STATUS "${GCOVR_EXEC_TESTS_CMD_SPACED}")
-
-        if(NOT GCOVR_FOLDER_CMD STREQUAL "echo")
-            message(STATUS "Command to create a folder: ")
-            string(REPLACE ";" " " GCOVR_FOLDER_CMD_SPACED "${GCOVR_FOLDER_CMD}")
-            message(STATUS "${GCOVR_FOLDER_CMD_SPACED}")
-        endif()
-
-        message(STATUS "Command to generate gcovr coverage data: ")
-        string(REPLACE ";" " " GCOVR_CMD_SPACED "${GCOVR_CMD}")
-        message(STATUS "${GCOVR_CMD_SPACED}")
-    endif()
-
-    add_custom_target(${Coverage_NAME}
-        COMMAND ${GCOVR_EXEC_TESTS_CMD}
-        COMMAND ${GCOVR_FOLDER_CMD}
-        COMMAND ${GCOVR_CMD}
-
-        BYPRODUCTS ${GCOVR_OUTPUT_FILE}
-        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-        DEPENDS ${Coverage_DEPENDENCIES}
-        VERBATIM # Protect arguments to commands
-        COMMENT "Running gcovr to produce code coverage report."
-    )
-
-    # Show info where to find the report
-    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
-        COMMAND ;
-        COMMENT "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}"
-    )
-endfunction() # setup_target_for_coverage_gcovr
-
-function(append_coverage_compiler_flags)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
-    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
-    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
-endfunction() # append_coverage_compiler_flags
-
-# Setup coverage for specific library
-function(append_coverage_compiler_flags_to_target name)
-    separate_arguments(_flag_list NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}")
-    target_compile_options(${name} PRIVATE ${_flag_list})
-    if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
-        target_link_libraries(${name} PRIVATE gcov)
-    endif()
-endfunction()

Builds/CMake/RippledCompiler.cmake

@@ -130,16 +130,7 @@ else ()
       >)
 endif ()
 
-if (use_mold)
-  # use mold linker if available
-  execute_process (
-    COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version
-    ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
-  if ("${LD_VERSION}" MATCHES "mold")
-    target_link_libraries (common INTERFACE -fuse-ld=mold)
-  endif ()
-  unset (LD_VERSION)
-elseif (use_gold AND is_gcc)
+if (use_gold AND is_gcc)
   # use gold linker if available
   execute_process (
     COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version
@@ -171,7 +162,9 @@ elseif (use_gold AND is_gcc)
         $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>)
   endif ()
   unset (LD_VERSION)
-elseif (use_lld)
+endif ()
+
+if (use_lld)
   # use lld linker if available
   execute_process (
     COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version
@@ -182,7 +175,6 @@ elseif (use_lld)
   unset (LD_VERSION)
 endif()
 
-
 if (assert)
   foreach (var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
     STRING (REGEX REPLACE "[-/]DNDEBUG" "" ${var_} "${${var_}}")

Builds/CMake/RippledCore.cmake

@@ -3,53 +3,9 @@
    core functionality, useable by some client software perhaps
 #]===================================================================]
 
-include(target_protobuf_sources)
-
 file (GLOB_RECURSE rb_headers
-  src/ripple/beast/*.h)
-
-# Protocol buffers cannot participate in a unity build,
-# because all the generated sources
-# define a bunch of `static const` variables with the same names,
-# so we just build them as a separate library.
-add_library(xrpl.libpb)
-target_protobuf_sources(xrpl.libpb ripple/proto
-  LANGUAGE cpp
-  IMPORT_DIRS src/ripple/proto
-  PROTOS src/ripple/proto/ripple.proto
-)
-
-file(GLOB_RECURSE protos "src/ripple/proto/org/*.proto")
-target_protobuf_sources(xrpl.libpb ripple/proto
-  LANGUAGE cpp
-  IMPORT_DIRS src/ripple/proto
-  PROTOS "${protos}"
-)
-target_protobuf_sources(xrpl.libpb ripple/proto
-  LANGUAGE grpc
-  IMPORT_DIRS src/ripple/proto
-  PROTOS "${protos}"
-  PLUGIN protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
-  GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc
-)
-
-target_compile_options(xrpl.libpb
-  PUBLIC
-    $<$<BOOL:${MSVC}>:-wd4996>
-    $<$<BOOL:${XCODE}>:
-      --system-header-prefix="google/protobuf"
-      -Wno-deprecated-dynamic-exception-spec
-    >
-  PRIVATE
-    $<$<BOOL:${MSVC}>:-wd4065>
-    $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
-)
-
-target_link_libraries(xrpl.libpb
-  PUBLIC
-    protobuf::libprotobuf
-    gRPC::grpc++
-)
+  src/ripple/beast/*.h
+  src/ripple/beast/*.hpp)
 
 add_library (xrpl_core
   ${rb_headers}) ## headers added here for benefit of IDEs
@@ -71,15 +27,16 @@ add_library(libxrpl INTERFACE)
 target_link_libraries(libxrpl INTERFACE xrpl_core)
 add_library(xrpl::libxrpl ALIAS libxrpl)
 
+
 #[===============================[
     beast/legacy FILES:
     TODO: review these sources for removal or replacement
 #]===============================]
-# BEGIN LIBXRPL SOURCES
 target_sources (xrpl_core PRIVATE
   src/ripple/beast/clock/basic_seconds_clock.cpp
   src/ripple/beast/core/CurrentThreadName.cpp
   src/ripple/beast/core/SemanticVersion.cpp
+  src/ripple/beast/hash/impl/xxhash.cpp
   src/ripple/beast/insight/impl/Collector.cpp
   src/ripple/beast/insight/impl/Groups.cpp
   src/ripple/beast/insight/impl/Hook.cpp
@@ -99,23 +56,16 @@ target_sources (xrpl_core PRIVATE
 target_sources (xrpl_core PRIVATE
   #[===============================[
     main sources:
-      subdir: basics
+      subdir: basics (partial)
   #]===============================]
-  src/ripple/basics/impl/Archive.cpp
   src/ripple/basics/impl/base64.cpp
-  src/ripple/basics/impl/BasicConfig.cpp
   src/ripple/basics/impl/contract.cpp
   src/ripple/basics/impl/CountedObject.cpp
   src/ripple/basics/impl/FileUtilities.cpp
   src/ripple/basics/impl/IOUAmount.cpp
   src/ripple/basics/impl/Log.cpp
-  src/ripple/basics/impl/make_SSLContext.cpp
-  src/ripple/basics/impl/mulDiv.cpp
   src/ripple/basics/impl/Number.cpp
-  src/ripple/basics/impl/partitioned_unordered_map.cpp
-  src/ripple/basics/impl/ResolverAsio.cpp
   src/ripple/basics/impl/StringUtilities.cpp
-  src/ripple/basics/impl/UptimeClock.cpp
   #[===============================[
     main sources:
       subdir: json
@@ -134,7 +84,6 @@ target_sources (xrpl_core PRIVATE
       subdir: protocol
   #]===============================]
   src/ripple/protocol/impl/AccountID.cpp
-  src/ripple/protocol/impl/AMMCore.cpp
   src/ripple/protocol/impl/Book.cpp
   src/ripple/protocol/impl/BuildInfo.cpp
   src/ripple/protocol/impl/ErrorCodes.cpp
@@ -142,14 +91,10 @@ target_sources (xrpl_core PRIVATE
   src/ripple/protocol/impl/Indexes.cpp
   src/ripple/protocol/impl/InnerObjectFormats.cpp
   src/ripple/protocol/impl/Issue.cpp
-  src/ripple/protocol/impl/STIssue.cpp
   src/ripple/protocol/impl/Keylet.cpp
   src/ripple/protocol/impl/LedgerFormats.cpp
-  src/ripple/protocol/impl/LedgerHeader.cpp
   src/ripple/protocol/impl/PublicKey.cpp
   src/ripple/protocol/impl/Quality.cpp
-  src/ripple/protocol/impl/QualityFunction.cpp
-  src/ripple/protocol/impl/RPCErr.cpp
   src/ripple/protocol/impl/Rate2.cpp
   src/ripple/protocol/impl/Rules.cpp
   src/ripple/protocol/impl/SField.cpp
@@ -159,15 +104,12 @@ target_sources (xrpl_core PRIVATE
   src/ripple/protocol/impl/STArray.cpp
   src/ripple/protocol/impl/STBase.cpp
   src/ripple/protocol/impl/STBlob.cpp
-  src/ripple/protocol/impl/STCurrency.cpp
   src/ripple/protocol/impl/STInteger.cpp
   src/ripple/protocol/impl/STLedgerEntry.cpp
   src/ripple/protocol/impl/STObject.cpp
   src/ripple/protocol/impl/STParsedJSON.cpp
   src/ripple/protocol/impl/STPathSet.cpp
-  src/ripple/protocol/impl/STXChainBridge.cpp
   src/ripple/protocol/impl/STTx.cpp
-  src/ripple/protocol/impl/XChainAttestations.cpp
   src/ripple/protocol/impl/STValidation.cpp
   src/ripple/protocol/impl/STVar.cpp
   src/ripple/protocol/impl/STVector256.cpp
@@ -181,23 +123,6 @@ target_sources (xrpl_core PRIVATE
   src/ripple/protocol/impl/UintTypes.cpp
   src/ripple/protocol/impl/digest.cpp
   src/ripple/protocol/impl/tokens.cpp
-  src/ripple/protocol/impl/NFTSyntheticSerializer.cpp
-  src/ripple/protocol/impl/NFTokenID.cpp
-  src/ripple/protocol/impl/NFTokenOfferID.cpp
-  #[===============================[
-     main sources:
-       subdir: resource
-  #]===============================]
-  src/ripple/resource/impl/Charge.cpp
-  src/ripple/resource/impl/Consumer.cpp
-  src/ripple/resource/impl/Fees.cpp
-  src/ripple/resource/impl/ResourceManager.cpp
-  #[===============================[
-     main sources:
-       subdir: server
-  #]===============================]
-  src/ripple/server/impl/JSONRPCUtil.cpp
-  src/ripple/server/impl/Port.cpp
   #[===============================[
     main sources:
       subdir: crypto
@@ -205,7 +130,6 @@ target_sources (xrpl_core PRIVATE
   src/ripple/crypto/impl/RFC1751.cpp
   src/ripple/crypto/impl/csprng.cpp
   src/ripple/crypto/impl/secure_erase.cpp)
-# END LIBXRPL SOURCES
 
 add_library (Ripple::xrpl_core ALIAS xrpl_core)
 target_include_directories (xrpl_core
@@ -223,71 +147,45 @@ target_compile_options (xrpl_core
     $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>)
 target_link_libraries (xrpl_core
   PUBLIC
-    date::date
-    ed25519::ed25519
-    LibArchive::LibArchive
     OpenSSL::Crypto
     Ripple::boost
     wasmedge::wasmedge
-    Ripple::opts
     Ripple::syslibs
     secp256k1::secp256k1
-    xrpl.libpb
-    xxHash::xxhash)
+    ed25519::ed25519
+    BLAKE3::blake3
+    date::date
+    Ripple::opts)
 #[=================================[
    main/core headers installation
 #]=================================]
-# BEGIN LIBXRPL HEADERS
 install (
   FILES
-    src/ripple/basics/Archive.h
-    src/ripple/basics/BasicConfig.h
+    src/ripple/basics/base64.h
     src/ripple/basics/Blob.h
     src/ripple/basics/Buffer.h
-    src/ripple/basics/ByteUtilities.h
-    src/ripple/basics/CompressionAlgorithms.h
     src/ripple/basics/CountedObject.h
-    src/ripple/basics/DecayingSample.h
-    src/ripple/basics/Expected.h
-    src/ripple/basics/FeeUnits.h
     src/ripple/basics/FileUtilities.h
     src/ripple/basics/IOUAmount.h
-    src/ripple/basics/KeyCache.h
     src/ripple/basics/LocalValue.h
     src/ripple/basics/Log.h
     src/ripple/basics/MathUtilities.h
     src/ripple/basics/Number.h
-    src/ripple/basics/PerfLog.h
-    src/ripple/basics/README.md
-    src/ripple/basics/RangeSet.h
-    src/ripple/basics/Resolver.h
-    src/ripple/basics/ResolverAsio.h
-    src/ripple/basics/SHAMapHash.h
+    src/ripple/basics/safe_cast.h
     src/ripple/basics/Slice.h
+    src/ripple/basics/spinlock.h
     src/ripple/basics/StringUtilities.h
-    src/ripple/basics/TaggedCache.h
     src/ripple/basics/ThreadSafetyAnalysis.h
     src/ripple/basics/ToString.h
     src/ripple/basics/UnorderedContainers.h
-    src/ripple/basics/UptimeClock.h
     src/ripple/basics/XRPAmount.h
     src/ripple/basics/algorithm.h
-    src/ripple/basics/base64.h
     src/ripple/basics/base_uint.h
     src/ripple/basics/chrono.h
-    src/ripple/basics/comparators.h
     src/ripple/basics/contract.h
+    src/ripple/basics/FeeUnits.h
     src/ripple/basics/hardened_hash.h
-    src/ripple/basics/join.h
-    src/ripple/basics/make_SSLContext.h
-    src/ripple/basics/mulDiv.h
-    src/ripple/basics/partitioned_unordered_map.h
-    src/ripple/basics/random.h
-    src/ripple/basics/safe_cast.h
-    src/ripple/basics/scope.h
-    src/ripple/basics/spinlock.h
     src/ripple/basics/strHex.h
-    src/ripple/basics/tagged_integer.h
   DESTINATION include/ripple/basics)
 install (
   FILES
@@ -314,42 +212,25 @@ install (
 install (
   FILES
     src/ripple/protocol/AccountID.h
-    src/ripple/protocol/AMMCore.h
     src/ripple/protocol/AmountConversions.h
-    src/ripple/protocol/ApiVersion.h
     src/ripple/protocol/Book.h
     src/ripple/protocol/BuildInfo.h
     src/ripple/protocol/ErrorCodes.h
     src/ripple/protocol/Feature.h
-    src/ripple/protocol/Fees.h
     src/ripple/protocol/HashPrefix.h
     src/ripple/protocol/Indexes.h
     src/ripple/protocol/InnerObjectFormats.h
     src/ripple/protocol/Issue.h
-    src/ripple/protocol/json_get_or_throw.h
-    src/ripple/protocol/Keylet.h
     src/ripple/protocol/KeyType.h
+    src/ripple/protocol/Keylet.h
     src/ripple/protocol/KnownFormats.h
     src/ripple/protocol/LedgerFormats.h
-    src/ripple/protocol/LedgerHeader.h
-    src/ripple/protocol/MultiApiJson.h
-    src/ripple/protocol/NFTSyntheticSerializer.h
-    src/ripple/protocol/NFTokenID.h
-    src/ripple/protocol/NFTokenOfferID.h
-    src/ripple/protocol/NFTSyntheticSerializer.h
     src/ripple/protocol/Protocol.h
     src/ripple/protocol/PublicKey.h
     src/ripple/protocol/Quality.h
-    src/ripple/protocol/QualityFunction.h
     src/ripple/protocol/Rate.h
-    src/ripple/protocol/RPCErr.h
     src/ripple/protocol/Rules.h
-    src/ripple/protocol/SecretKey.h
-    src/ripple/protocol/Seed.h
-    src/ripple/protocol/SeqProxy.h
-    src/ripple/protocol/Serializer.h
     src/ripple/protocol/SField.h
-    src/ripple/protocol/Sign.h
     src/ripple/protocol/SOTemplate.h
     src/ripple/protocol/STAccount.h
     src/ripple/protocol/STAmount.h
@@ -357,10 +238,8 @@ install (
     src/ripple/protocol/STBase.h
     src/ripple/protocol/STBitString.h
     src/ripple/protocol/STBlob.h
-    src/ripple/protocol/STCurrency.h
     src/ripple/protocol/STExchange.h
     src/ripple/protocol/STInteger.h
-    src/ripple/protocol/STIssue.h
     src/ripple/protocol/STLedgerEntry.h
     src/ripple/protocol/STObject.h
     src/ripple/protocol/STParsedJSON.h
@@ -368,72 +247,27 @@ install (
     src/ripple/protocol/STTx.h
     src/ripple/protocol/STValidation.h
     src/ripple/protocol/STVector256.h
-    src/ripple/protocol/STXChainBridge.h
+    src/ripple/protocol/SecretKey.h
+    src/ripple/protocol/Seed.h
+    src/ripple/protocol/SeqProxy.h
+    src/ripple/protocol/Serializer.h
+    src/ripple/protocol/Sign.h
     src/ripple/protocol/SystemParameters.h
     src/ripple/protocol/TER.h
     src/ripple/protocol/TxFlags.h
     src/ripple/protocol/TxFormats.h
     src/ripple/protocol/TxMeta.h
     src/ripple/protocol/UintTypes.h
-    src/ripple/protocol/XChainAttestations.h
     src/ripple/protocol/digest.h
     src/ripple/protocol/jss.h
-    src/ripple/protocol/nft.h
-    src/ripple/protocol/nftPageMask.h
-    src/ripple/protocol/serialize.h
     src/ripple/protocol/tokens.h
   DESTINATION include/ripple/protocol)
 install (
   FILES
-  src/ripple/protocol/impl/STVar.h
-    src/ripple/protocol/impl/b58_utils.h
+    src/ripple/protocol/impl/STVar.h
     src/ripple/protocol/impl/secp256k1.h
-    src/ripple/protocol/impl/token_errors.h
   DESTINATION include/ripple/protocol/impl)
-install (
-  FILES
-    src/ripple/resource/Charge.h
-    src/ripple/resource/Consumer.h
-    src/ripple/resource/Disposition.h
-    src/ripple/resource/Fees.h
-    src/ripple/resource/Gossip.h
-    src/ripple/resource/ResourceManager.h
-    src/ripple/resource/Types.h
-  DESTINATION include/ripple/resource)
-install (
-  FILES
-    src/ripple/resource/impl/Entry.h
-    src/ripple/resource/impl/Import.h
-    src/ripple/resource/impl/Key.h
-    src/ripple/resource/impl/Kind.h
-    src/ripple/resource/impl/Logic.h
-    src/ripple/resource/impl/Tuning.h
-  DESTINATION include/ripple/resource/impl)
-install (
-  FILES
-    src/ripple/server/Handoff.h
-    src/ripple/server/Port.h
-    src/ripple/server/Server.h
-    src/ripple/server/Session.h
-    src/ripple/server/SimpleWriter.h
-    src/ripple/server/Writer.h
-    src/ripple/server/WSSession.h
-  DESTINATION include/ripple/server)
-install (
-  FILES
-    src/ripple/server/impl/BaseHTTPPeer.h
-    src/ripple/server/impl/BasePeer.h
-    src/ripple/server/impl/BaseWSPeer.h
-    src/ripple/server/impl/Door.h
-    src/ripple/server/impl/JSONRPCUtil.h
-    src/ripple/server/impl/LowestLayer.h
-    src/ripple/server/impl/PlainHTTPPeer.h
-    src/ripple/server/impl/PlainWSPeer.h
-    src/ripple/server/impl/ServerImpl.h
-    src/ripple/server/impl/SSLHTTPPeer.h
-    src/ripple/server/impl/SSLWSPeer.h
-    src/ripple/server/impl/io_list.h
-  DESTINATION include/ripple/server/impl)
+
 #[===================================[
    beast/legacy headers installation
 #]===================================]
@@ -445,7 +279,6 @@ install (
   DESTINATION include/ripple/beast/clock)
 install (
   FILES
-    src/ripple/beast/core/CurrentThreadName.h
     src/ripple/beast/core/LexicalCast.h
     src/ripple/beast/core/List.h
     src/ripple/beast/core/SemanticVersion.h
@@ -457,13 +290,8 @@ install (
     src/ripple/beast/hash/xxhasher.h
   DESTINATION include/ripple/beast/hash)
 install (
-  FILES
-    src/ripple/beast/net/IPAddress.h
-    src/ripple/beast/net/IPAddressConversion.h
-    src/ripple/beast/net/IPAddressV4.h
-    src/ripple/beast/net/IPAddressV6.h
-    src/ripple/beast/net/IPEndpoint.h
-  DESTINATION include/ripple/beast/net)
+  FILES src/ripple/beast/hash/impl/xxhash.h
+  DESTINATION include/ripple/beast/hash/impl)
 install (
   FILES
     src/ripple/beast/rfc2616.h
@@ -471,34 +299,37 @@ install (
     src/ripple/beast/unit_test.h
     src/ripple/beast/xor_shift_engine.h
   DESTINATION include/ripple/beast)
-install (
-  FILES
-    src/ripple/beast/unit_test/amount.h
-    src/ripple/beast/unit_test/dstream.h
-    src/ripple/beast/unit_test/global_suites.h
-    src/ripple/beast/unit_test/match.h
-    src/ripple/beast/unit_test/recorder.h
-    src/ripple/beast/unit_test/reporter.h
-    src/ripple/beast/unit_test/results.h
-    src/ripple/beast/unit_test/runner.h
-    src/ripple/beast/unit_test/suite_info.h
-    src/ripple/beast/unit_test/suite_list.h
-    src/ripple/beast/unit_test/suite.h
-    src/ripple/beast/unit_test/thread.h
-  DESTINATION include/ripple/beast/unit_test)
-install (
-  FILES
-    src/ripple/beast/unit_test/detail/const_container.h
-  DESTINATION include/ripple/beast/unit_test/detail)
 install (
   FILES
     src/ripple/beast/utility/Journal.h
     src/ripple/beast/utility/PropertyStream.h
-    src/ripple/beast/utility/WrappedSink.h
     src/ripple/beast/utility/Zero.h
     src/ripple/beast/utility/rngfill.h
   DESTINATION include/ripple/beast/utility)
-# END LIBXRPL HEADERS
+# WARNING!! -- horrible levelization ahead
+# (these files should be isolated or moved...but
+#  unfortunately unit_test.h above creates this dependency)
+if (tests)
+  install (
+    FILES
+      src/ripple/beast/unit_test/amount.hpp
+      src/ripple/beast/unit_test/dstream.hpp
+      src/ripple/beast/unit_test/global_suites.hpp
+      src/ripple/beast/unit_test/match.hpp
+      src/ripple/beast/unit_test/recorder.hpp
+      src/ripple/beast/unit_test/reporter.hpp
+      src/ripple/beast/unit_test/results.hpp
+      src/ripple/beast/unit_test/runner.hpp
+      src/ripple/beast/unit_test/suite.hpp
+      src/ripple/beast/unit_test/suite_info.hpp
+      src/ripple/beast/unit_test/suite_list.hpp
+      src/ripple/beast/unit_test/thread.hpp
+    DESTINATION include/ripple/beast/extras/unit_test)
+  install (
+    FILES
+      src/ripple/beast/unit_test/detail/const_container.hpp
+    DESTINATION include/ripple/beast/unit_test/detail)
+endif () #tests
 #[===================================================================[
    rippled executable
 #]===================================================================]
@@ -515,7 +346,6 @@ endif ()
 if (tests)
     target_compile_definitions(rippled PUBLIC ENABLE_TESTS)
 endif()
-# BEGIN XRPLD SOURCES
 target_sources (rippled PRIVATE
   #[===============================[
      main sources:
@@ -562,8 +392,6 @@ target_sources (rippled PRIVATE
   src/ripple/app/reporting/ReportingETL.cpp
   src/ripple/app/reporting/ETLSource.cpp
   src/ripple/app/reporting/P2pProxy.cpp
-  src/ripple/app/misc/impl/AMMHelpers.cpp
-  src/ripple/app/misc/impl/AMMUtils.cpp
   src/ripple/app/misc/CanonicalTXSet.cpp
   src/ripple/app/misc/FeeVoteImpl.cpp
   src/ripple/app/misc/HashRouter.cpp
@@ -574,7 +402,6 @@ target_sources (rippled PRIVATE
   src/ripple/app/misc/detail/impl/WorkSSL.cpp
   src/ripple/app/misc/impl/AccountTxPaging.cpp
   src/ripple/app/misc/impl/AmendmentTable.cpp
-  src/ripple/app/misc/impl/DeliverMax.cpp
   src/ripple/app/misc/impl/LoadFeeTrack.cpp
   src/ripple/app/misc/impl/Manifest.cpp
   src/ripple/app/misc/impl/Transaction.cpp
@@ -591,8 +418,6 @@ target_sources (rippled PRIVATE
   src/ripple/app/paths/RippleCalc.cpp
   src/ripple/app/paths/RippleLineCache.cpp
   src/ripple/app/paths/TrustLine.cpp
-  src/ripple/app/paths/impl/AMMLiquidity.cpp
-  src/ripple/app/paths/impl/AMMOffer.cpp
   src/ripple/app/paths/impl/BookStep.cpp
   src/ripple/app/paths/impl/DirectStep.cpp
   src/ripple/app/paths/impl/PaySteps.cpp
@@ -609,12 +434,6 @@ target_sources (rippled PRIVATE
   src/ripple/app/rdb/impl/UnitaryShard.cpp
   src/ripple/app/rdb/impl/Vacuum.cpp
   src/ripple/app/rdb/impl/Wallet.cpp
-  src/ripple/app/tx/impl/AMMBid.cpp
-  src/ripple/app/tx/impl/AMMCreate.cpp
-  src/ripple/app/tx/impl/AMMDelete.cpp
-  src/ripple/app/tx/impl/AMMDeposit.cpp
-  src/ripple/app/tx/impl/AMMVote.cpp
-  src/ripple/app/tx/impl/AMMWithdraw.cpp
   src/ripple/app/tx/impl/ApplyContext.cpp
   src/ripple/app/tx/impl/BookTip.cpp
   src/ripple/app/tx/impl/CancelCheck.cpp
@@ -627,9 +446,7 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/CreateOffer.cpp
   src/ripple/app/tx/impl/CreateTicket.cpp
   src/ripple/app/tx/impl/DeleteAccount.cpp
-  src/ripple/app/tx/impl/DeleteOracle.cpp
   src/ripple/app/tx/impl/DepositPreauth.cpp
-  src/ripple/app/tx/impl/DID.cpp
   src/ripple/app/tx/impl/Escrow.cpp
   src/ripple/app/tx/impl/GenesisMint.cpp
   src/ripple/app/tx/impl/Import.cpp
@@ -646,12 +463,10 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/Remit.cpp
   src/ripple/app/tx/impl/SetAccount.cpp
   src/ripple/app/tx/impl/SetHook.cpp
-  src/ripple/app/tx/impl/SetOracle.cpp
   src/ripple/app/tx/impl/SetRemarks.cpp
   src/ripple/app/tx/impl/SetRegularKey.cpp
   src/ripple/app/tx/impl/SetSignerList.cpp
   src/ripple/app/tx/impl/SetTrust.cpp
-  src/ripple/app/tx/impl/XChainBridge.cpp
   src/ripple/app/tx/impl/SignerEntries.cpp
   src/ripple/app/tx/impl/Taker.cpp
   src/ripple/app/tx/impl/Transactor.cpp
@@ -660,6 +475,17 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/applySteps.cpp
   src/ripple/app/hook/impl/applyHook.cpp
   src/ripple/app/tx/impl/details/NFTokenUtils.cpp
+  #[===============================[
+     main sources:
+       subdir: basics (partial)
+  #]===============================]
+  src/ripple/basics/impl/Archive.cpp
+  src/ripple/basics/impl/BasicConfig.cpp
+  src/ripple/basics/impl/ResolverAsio.cpp
+  src/ripple/basics/impl/UptimeClock.cpp
+  src/ripple/basics/impl/make_SSLContext.cpp
+  src/ripple/basics/impl/mulDiv.cpp
+  src/ripple/basics/impl/partitioned_unordered_map.cpp
   #[===============================[
      main sources:
        subdir: conditions
@@ -677,7 +503,9 @@ target_sources (rippled PRIVATE
   src/ripple/core/impl/JobQueue.cpp
   src/ripple/core/impl/LoadEvent.cpp
   src/ripple/core/impl/LoadMonitor.cpp
+  src/ripple/core/impl/SNTPClock.cpp
   src/ripple/core/impl/SociDB.cpp
+  src/ripple/core/impl/TimeKeeper.cpp
   src/ripple/core/impl/Workers.cpp
   src/ripple/core/Pg.cpp
   #[===============================[
@@ -711,6 +539,7 @@ target_sources (rippled PRIVATE
   src/ripple/net/impl/HTTPStream.cpp
   src/ripple/net/impl/InfoSub.cpp
   src/ripple/net/impl/RPCCall.cpp
+  src/ripple/net/impl/RPCErr.cpp
   src/ripple/net/impl/RPCSub.cpp
   src/ripple/net/impl/RegisterSSLCerts.cpp
   #[===============================[
@@ -762,6 +591,14 @@ target_sources (rippled PRIVATE
   src/ripple/peerfinder/impl/PeerfinderManager.cpp
   src/ripple/peerfinder/impl/SlotImp.cpp
   src/ripple/peerfinder/impl/SourceStrings.cpp
+  #[===============================[
+     main sources:
+       subdir: resource
+  #]===============================]
+  src/ripple/resource/impl/Charge.cpp
+  src/ripple/resource/impl/Consumer.cpp
+  src/ripple/resource/impl/Fees.cpp
+  src/ripple/resource/impl/ResourceManager.cpp
   #[===============================[
      main sources:
        subdir: rpc
@@ -774,7 +611,6 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/handlers/AccountOffers.cpp
   src/ripple/rpc/handlers/AccountNamespace.cpp
   src/ripple/rpc/handlers/AccountTx.cpp
-  src/ripple/rpc/handlers/AMMInfo.cpp
   src/ripple/rpc/handlers/BlackList.cpp
   src/ripple/rpc/handlers/BookOffers.cpp
   src/ripple/rpc/handlers/CanDelete.cpp
@@ -789,7 +625,6 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/handlers/FetchInfo.cpp
   src/ripple/rpc/handlers/GatewayBalances.cpp
   src/ripple/rpc/handlers/GetCounts.cpp
-  src/ripple/rpc/handlers/GetAggregatePrice.cpp
   src/ripple/rpc/handlers/LedgerAccept.cpp
   src/ripple/rpc/handlers/LedgerCleanerHandler.cpp
   src/ripple/rpc/handlers/LedgerClosed.cpp
@@ -803,6 +638,7 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/handlers/LogLevel.cpp
   src/ripple/rpc/handlers/LogRotate.cpp
   src/ripple/rpc/handlers/Manifest.cpp
+  src/ripple/rpc/handlers/MapStats.cpp
   src/ripple/rpc/handlers/NFTOffers.cpp
   src/ripple/rpc/handlers/NodeToShard.cpp
   src/ripple/rpc/handlers/NoRippleCheck.cpp
@@ -842,16 +678,26 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/impl/RPCHandler.cpp
   src/ripple/rpc/impl/RPCHelpers.cpp
   src/ripple/rpc/impl/Role.cpp
-  src/ripple/rpc/impl/ServerHandler.cpp
+  src/ripple/rpc/impl/ServerHandlerImp.cpp
   src/ripple/rpc/impl/ShardArchiveHandler.cpp
   src/ripple/rpc/impl/ShardVerificationScheduler.cpp
   src/ripple/rpc/impl/Status.cpp
   src/ripple/rpc/impl/TransactionSign.cpp
+  src/ripple/rpc/impl/NFTokenID.cpp
+  src/ripple/rpc/impl/NFTokenOfferID.cpp
+  src/ripple/rpc/impl/NFTSyntheticSerializer.cpp
   #[===============================[
      main sources:
        subdir: perflog
   #]===============================]
   src/ripple/perflog/impl/PerfLogImp.cpp
+
+  #[===============================[
+     main sources:
+       subdir: server
+  #]===============================]
+  src/ripple/server/impl/JSONRPCUtil.cpp
+  src/ripple/server/impl/Port.cpp
   #[===============================[
      main sources:
        subdir: shamap
@@ -865,7 +711,6 @@ target_sources (rippled PRIVATE
   src/ripple/shamap/impl/SHAMapSync.cpp
   src/ripple/shamap/impl/SHAMapTreeNode.cpp
   src/ripple/shamap/impl/ShardFamily.cpp)
-# END XRPLD SOURCES
 
   #[===============================[
      test sources:
@@ -876,9 +721,6 @@ if (tests)
     src/test/app/AccountDelete_test.cpp
     src/test/app/AccountTxPaging_test.cpp
     src/test/app/AmendmentTable_test.cpp
-    src/test/app/AMM_test.cpp
-    src/test/app/AMMCalc_test.cpp
-    src/test/app/AMMExtended_test.cpp
     src/test/app/BaseFee_test.cpp
     src/test/app/Check_test.cpp
     src/test/app/ClaimReward_test.cpp
@@ -887,7 +729,6 @@ if (tests)
     src/test/app/DeliverMin_test.cpp
     src/test/app/DepositAuth_test.cpp
     src/test/app/Discrepancy_test.cpp
-    src/test/app/DID_test.cpp
     src/test/app/DNS_test.cpp
     src/test/app/Escrow_test.cpp
     src/test/app/FeeVote_test.cpp
@@ -910,19 +751,17 @@ if (tests)
     src/test/app/NFTokenDir_test.cpp
     src/test/app/OfferStream_test.cpp
     src/test/app/Offer_test.cpp
-    src/test/app/Oracle_test.cpp
     src/test/app/OversizeMeta_test.cpp
     src/test/app/Path_test.cpp
     src/test/app/PayChan_test.cpp
     src/test/app/PayStrand_test.cpp
+    src/test/app/PreviousTxn_test.cpp
     src/test/app/PseudoTx_test.cpp
     src/test/app/RCLCensorshipDetector_test.cpp
     src/test/app/RCLValidations_test.cpp
-    src/test/app/ReducedOffer_test.cpp
     src/test/app/Regression_test.cpp
     src/test/app/Remit_test.cpp
     src/test/app/SHAMapStore_test.cpp
-    src/test/app/XChain_test.cpp
     src/test/app/SetAuth_test.cpp
     src/test/app/SetHook_test.cpp
     src/test/app/SetHookTSH_test.cpp
@@ -961,7 +800,6 @@ if (tests)
     src/test/basics/StringUtilities_test.cpp
     src/test/basics/TaggedCache_test.cpp
     src/test/basics/XRPAmount_test.cpp
-    src/test/basics/base58_test.cpp
     src/test/basics/base64_test.cpp
     src/test/basics/base_uint_test.cpp
     src/test/basics/contract_test.cpp
@@ -1040,24 +878,20 @@ if (tests)
     src/test/jtx/Env_test.cpp
     src/test/jtx/WSClient_test.cpp
     src/test/jtx/impl/Account.cpp
-    src/test/jtx/impl/AMM.cpp
-    src/test/jtx/impl/AMMTest.cpp
     src/test/jtx/impl/Env.cpp
     src/test/jtx/impl/JSONRPCClient.cpp
-    src/test/jtx/impl/Oracle.cpp
-    src/test/jtx/impl/TestHelpers.cpp
+    src/test/jtx/impl/ManualTimeKeeper.cpp
     src/test/jtx/impl/WSClient.cpp
     src/test/jtx/impl/hook.cpp
     src/test/jtx/impl/acctdelete.cpp
     src/test/jtx/impl/account_txn_id.cpp
     src/test/jtx/impl/amount.cpp
-    src/test/jtx/impl/attester.cpp
     src/test/jtx/impl/balance.cpp
     src/test/jtx/impl/check.cpp
     src/test/jtx/impl/delivermin.cpp
     src/test/jtx/impl/deposit.cpp
-    src/test/jtx/impl/did.cpp
     src/test/jtx/impl/envconfig.cpp
+    src/test/jtx/impl/escrow.cpp
     src/test/jtx/impl/fee.cpp
     src/test/jtx/impl/flags.cpp
     src/test/jtx/impl/genesis.cpp
@@ -1082,9 +916,9 @@ if (tests)
     src/test/jtx/impl/remit.cpp
     src/test/jtx/impl/sendmax.cpp
     src/test/jtx/impl/seq.cpp
-    src/test/jtx/impl/xchain_bridge.cpp
     src/test/jtx/impl/sig.cpp
     src/test/jtx/impl/tag.cpp
+    src/test/jtx/impl/TestHelpers.cpp
     src/test/jtx/impl/ticket.cpp
     src/test/jtx/impl/token.cpp
     src/test/jtx/impl/trust.cpp
@@ -1141,13 +975,12 @@ if (tests)
        test sources:
          subdir: protocol
     #]===============================]
-    src/test/protocol/ApiVersion_test.cpp
+    src/test/protocol/blake3_test.cpp
     src/test/protocol/BuildInfo_test.cpp
     src/test/protocol/InnerObjectFormats_test.cpp
     src/test/protocol/Issue_test.cpp
     src/test/protocol/Hooks_test.cpp
     src/test/protocol/Memo_test.cpp
-    src/test/protocol/MultiApiJson_test.cpp
     src/test/protocol/PublicKey_test.cpp
     src/test/protocol/Quality_test.cpp
     src/test/protocol/STAccount_test.cpp
@@ -1171,27 +1004,24 @@ if (tests)
     #]===============================]
     src/test/rpc/AccountCurrencies_test.cpp
     src/test/rpc/AccountInfo_test.cpp
-    src/test/rpc/AccountLines_test.cpp
+    src/test/rpc/AccountLinesRPC_test.cpp
     src/test/rpc/AccountObjects_test.cpp
     src/test/rpc/AccountOffers_test.cpp
     src/test/rpc/AccountNamespace_test.cpp
     src/test/rpc/AccountSet_test.cpp
     src/test/rpc/AccountTx_test.cpp
     src/test/rpc/AmendmentBlocked_test.cpp
-    src/test/rpc/AMMInfo_test.cpp
     src/test/rpc/Book_test.cpp
     src/test/rpc/Catalogue_test.cpp
     src/test/rpc/DepositAuthorized_test.cpp
     src/test/rpc/DeliveredAmount_test.cpp
     src/test/rpc/Feature_test.cpp
     src/test/rpc/GatewayBalances_test.cpp
-    src/test/rpc/GetAggregatePrice_test.cpp
     src/test/rpc/GetCounts_test.cpp
     src/test/rpc/JSONRPC_test.cpp
     src/test/rpc/KeyGeneration_test.cpp
     src/test/rpc/LedgerClosed_test.cpp
     src/test/rpc/LedgerData_test.cpp
-    src/test/rpc/LedgerHeader_test.cpp
     src/test/rpc/LedgerRPC_test.cpp
     src/test/rpc/LedgerRequestRPC_test.cpp
     src/test/rpc/ManifestRPC_test.cpp
@@ -1216,7 +1046,6 @@ if (tests)
     src/test/rpc/ValidatorInfo_test.cpp
     src/test/rpc/ValidatorRPC_test.cpp
     src/test/rpc/Version_test.cpp
-    src/test/rpc/Handler_test.cpp
     #[===============================[
        test sources:
          subdir: server
@@ -1242,6 +1071,9 @@ target_link_libraries (rippled
   Ripple::opts
   Ripple::libs
   Ripple::xrpl_core
+  BLAKE3::blake3
+  # Workaround for a Conan 1.x bug...
+  m
   )
 exclude_if_included (rippled)
 # define a macro for tests that might need to

Builds/CMake/RippledCov.cmake

@@ -2,37 +2,97 @@
    coverage report target
 #]===================================================================]
 
-if(NOT coverage)
-  message(FATAL_ERROR "Code coverage not enabled! Aborting ...")
-endif()
+if (coverage)
+  if (is_clang)
+    if (APPLE)
+      execute_process (COMMAND xcrun -f llvm-profdata
+        OUTPUT_VARIABLE LLVM_PROFDATA
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+    else ()
+      find_program (LLVM_PROFDATA llvm-profdata)
+    endif ()
+    if (NOT LLVM_PROFDATA)
+      message (WARNING "unable to find llvm-profdata - skipping coverage_report target")
+    endif ()
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-  message(WARNING "Code coverage on Windows is not supported, ignoring 'coverage' flag")
-  return()
-endif()
+    if (APPLE)
+      execute_process (COMMAND xcrun -f llvm-cov
+        OUTPUT_VARIABLE LLVM_COV
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+    else ()
+      find_program (LLVM_COV llvm-cov)
+    endif ()
+    if (NOT LLVM_COV)
+      message (WARNING "unable to find llvm-cov - skipping coverage_report target")
+    endif ()
 
-include(CodeCoverage)
+    set (extract_pattern "")
+    if (coverage_core_only)
+      set (extract_pattern "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/")
+    endif ()
 
-# The instructions for these commands come from the `CodeCoverage` module,
-# which was copied from https://github.com/bilke/cmake-modules, commit fb7d2a3,
-# then locally changed (see CHANGES: section in `CodeCoverage.cmake`)
+    if (LLVM_COV AND LLVM_PROFDATA)
+      add_custom_target (coverage_report
+        USES_TERMINAL
+        COMMAND ${CMAKE_COMMAND} -E echo "Generating coverage - results will be in ${CMAKE_BINARY_DIR}/coverage/index.html."
+        COMMAND ${CMAKE_COMMAND} -E echo "Running rippled tests."
+        COMMAND rippled --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --quiet --unittest-log
+        COMMAND ${LLVM_PROFDATA}
+          merge -sparse default.profraw -o rip.profdata
+        COMMAND ${CMAKE_COMMAND} -E echo "Summary of coverage:"
+        COMMAND ${LLVM_COV}
+          report -instr-profile=rip.profdata
+          $<TARGET_FILE:rippled> ${extract_pattern}
+        # generate html report
+        COMMAND ${LLVM_COV}
+          show -format=html -output-dir=${CMAKE_BINARY_DIR}/coverage
+          -instr-profile=rip.profdata
+          $<TARGET_FILE:rippled> ${extract_pattern}
+        BYPRODUCTS coverage/index.html)
+    endif ()
+  elseif (is_gcc)
+    find_program (LCOV lcov)
+    if (NOT LCOV)
+      message (WARNING "unable to find lcov - skipping coverage_report target")
+    endif ()
 
-set(GCOVR_ADDITIONAL_ARGS ${coverage_extra_args})
-if(NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
-  separate_arguments(GCOVR_ADDITIONAL_ARGS)
-endif()
+    find_program (GENHTML genhtml)
+    if (NOT GENHTML)
+      message (WARNING "unable to find genhtml - skipping coverage_report target")
+    endif ()
 
-list(APPEND GCOVR_ADDITIONAL_ARGS
-  --exclude-throw-branches
-  --exclude-noncode-lines
-  --exclude-unreachable-branches -s
-  -j ${coverage_test_parallelism})
+    set (extract_pattern "*")
+    if (coverage_core_only)
+      set (extract_pattern "*/src/ripple/*")
+    endif ()
 
-setup_target_for_coverage_gcovr(
-  NAME coverage
-  FORMAT ${coverage_format}
-  EXECUTABLE rippled
-  EXECUTABLE_ARGS --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --unittest-jobs ${coverage_test_parallelism} --quiet --unittest-log
-  EXCLUDE "src/test" "${CMAKE_BINARY_DIR}/proto_gen" "${CMAKE_BINARY_DIR}/proto_gen_grpc"
-  DEPENDENCIES rippled
-)
+    if (LCOV AND GENHTML)
+      add_custom_target (coverage_report
+        USES_TERMINAL
+        COMMAND ${CMAKE_COMMAND} -E echo "Generating coverage- results will be in ${CMAKE_BINARY_DIR}/coverage/index.html."
+        # create baseline info file
+        COMMAND ${LCOV}
+          --no-external -d "${CMAKE_CURRENT_SOURCE_DIR}" -c -d . -i -o baseline.info
+          | grep -v "ignoring data for external file"
+        # run tests
+        COMMAND ${CMAKE_COMMAND} -E echo "Running rippled tests for coverage report."
+        COMMAND rippled --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --quiet --unittest-log
+        # Create test coverage data file
+        COMMAND ${LCOV}
+          --no-external -d "${CMAKE_CURRENT_SOURCE_DIR}" -c -d . -o tests.info
+          | grep -v "ignoring data for external file"
+        # Combine baseline and test coverage data
+        COMMAND ${LCOV}
+          -a baseline.info -a tests.info -o lcov-all.info
+        # extract our files
+        COMMAND ${LCOV}
+          -e lcov-all.info "${extract_pattern}" -o lcov.info
+        COMMAND ${CMAKE_COMMAND} -E echo "Summary of coverage:"
+        COMMAND ${LCOV} --summary lcov.info
+        # generate HTML report
+        COMMAND ${GENHTML}
+          -o ${CMAKE_BINARY_DIR}/coverage lcov.info
+        BYPRODUCTS coverage/index.html)
+    endif ()
+  endif ()
+endif ()

Builds/CMake/RippledInstall.cmake

@@ -9,7 +9,6 @@ install (
     ripple_syslibs
     ripple_boost
     xrpl_core
-    xrpl.libpb
   EXPORT RippleExports
   LIBRARY DESTINATION lib
   ARCHIVE DESTINATION lib

Builds/CMake/RippledInterface.cmake

@@ -23,15 +23,15 @@ target_compile_options (opts
   INTERFACE
     $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
     $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-fprofile-arcs -ftest-coverage>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-fprofile-instr-generate -fcoverage-mapping>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
 target_link_libraries (opts
   INTERFACE
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-fprofile-arcs -ftest-coverage>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-fprofile-instr-generate -fcoverage-mapping>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 

Builds/CMake/RippledMultiConfig.cmake

@@ -14,7 +14,7 @@ if (is_multiconfig)
   file(GLOB md_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} CONFIGURE_DEPENDS
     *.md)
   LIST(APPEND all_sources ${md_files})
-  foreach (_target secp256k1::secp256k1 ed25519::ed25519 xrpl_core rippled)
+  foreach (_target secp256k1::secp256k1 ed25519::ed25519 pbufs xrpl_core rippled)
     get_target_property (_type ${_target} TYPE)
     if(_type STREQUAL "INTERFACE_LIBRARY")
       continue()

Builds/CMake/RippledSanity.cmake

@@ -2,8 +2,6 @@
    convenience variables and sanity checks
 #]===================================================================]
 
-include(ProcessorCount)
-
 if (NOT ep_procs)
   ProcessorCount(ep_procs)
   if (ep_procs GREATER 1)

Builds/CMake/RippledSettings.cmake

@@ -2,129 +2,121 @@
    declare user options/settings
 #]===================================================================]
 
-include(ProcessorCount)
+option (assert "Enables asserts, even in release builds" OFF)
 
-ProcessorCount(PROCESSOR_COUNT)
+option (reporting "Build rippled with reporting mode enabled" OFF)
 
-option(assert "Enables asserts, even in release builds" OFF)
+option (tests "Build tests" ON)
 
-option(reporting "Build rippled with reporting mode enabled" OFF)
-
-option(tests "Build tests" ON)
-
-option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
-if(unity)
-  if(NOT is_ci)
-    set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
-  endif()
-endif()
-if(is_gcc OR is_clang)
-  option(coverage "Generates coverage info." OFF)
-  option(profile "Add profiling flags" OFF)
-  set(coverage_test_parallelism "${PROCESSOR_COUNT}" CACHE STRING
-    "Unit tests parallelism for the purpose of coverage report.")
-  set(coverage_format "html-details" CACHE STRING
-    "Output format of the coverage report.")
-  set(coverage_extra_args "" CACHE STRING
-    "Additional arguments to pass to gcovr.")
-  set(coverage_test "" CACHE STRING
+option (unity "Creates a build using UNITY support in cmake. This is the default" ON)
+if (unity)
+  if (NOT is_ci)
+    set (CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
+  endif ()
+endif ()
+if (is_gcc OR is_clang)
+  option (coverage "Generates coverage info." OFF)
+  option (profile "Add profiling flags" OFF)
+  set (coverage_test "" CACHE STRING
     "On gcc & clang, the specific unit test(s) to run for coverage. Default is all tests.")
-  if(coverage_test AND NOT coverage)
-    set(coverage ON CACHE BOOL "gcc/clang only" FORCE)
-  endif()
-  option(wextra "compile with extra gcc/clang warnings enabled" ON)
-else()
-  set(profile OFF CACHE BOOL "gcc/clang only" FORCE)
-  set(coverage OFF CACHE BOOL "gcc/clang only" FORCE)
-  set(wextra OFF CACHE BOOL "gcc/clang only" FORCE)
-endif()
-if(is_linux)
-  option(BUILD_SHARED_LIBS "build shared ripple libraries" OFF)
-  option(static "link protobuf, openssl, libc++, and boost statically" ON)
-  option(perf "Enables flags that assist with perf recording" OFF)
-  option(use_gold "enables detection of gold (binutils) linker" ON)
-  option(use_mold "enables detection of mold (binutils) linker" ON)
-else()
+  if (coverage_test AND NOT coverage)
+    set (coverage ON CACHE BOOL "gcc/clang only" FORCE)
+  endif ()
+  option (coverage_core_only
+    "Include only src/ripple files when generating coverage report. \
+    Set to OFF to include all sources in coverage report."
+    ON)
+  option (wextra "compile with extra gcc/clang warnings enabled" ON)
+else ()
+  set (profile OFF CACHE BOOL "gcc/clang only" FORCE)
+  set (coverage OFF CACHE BOOL "gcc/clang only" FORCE)
+  set (wextra OFF CACHE BOOL "gcc/clang only" FORCE)
+endif ()
+if (is_linux)
+  option (BUILD_SHARED_LIBS "build shared ripple libraries" OFF)
+  option (static "link protobuf, openssl, libc++, and boost statically" ON)
+  option (perf "Enables flags that assist with perf recording" OFF)
+  option (use_gold "enables detection of gold (binutils) linker" ON)
+else ()
   # we are not ready to allow shared-libs on windows because it would require
   # export declarations. On macos it's more feasible, but static openssl
   # produces odd linker errors, thus we disable shared lib builds for now.
-  set(BUILD_SHARED_LIBS OFF CACHE BOOL "build shared ripple libraries - OFF for win/macos" FORCE)
-  set(static ON CACHE BOOL "static link, linux only. ON for WIN/macos" FORCE)
-  set(perf OFF CACHE BOOL "perf flags, linux only" FORCE)
-  set(use_gold OFF CACHE BOOL "gold linker, linux only" FORCE)
-  set(use_mold OFF CACHE BOOL "mold linker, linux only" FORCE)
-endif()
-if(is_clang)
-  option(use_lld "enables detection of lld linker" ON)
-else()
-  set(use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
-endif()
-option(jemalloc "Enables jemalloc for heap profiling" OFF)
-option(werr "treat warnings as errors" OFF)
-option(local_protobuf
+  set (BUILD_SHARED_LIBS OFF CACHE BOOL "build shared ripple libraries - OFF for win/macos" FORCE)
+  set (static ON CACHE BOOL "static link, linux only. ON for WIN/macos" FORCE)
+  set (perf OFF CACHE BOOL "perf flags, linux only" FORCE)
+  set (use_gold OFF CACHE BOOL "gold linker, linux only" FORCE)
+endif ()
+if (is_clang)
+  option (use_lld "enables detection of lld linker" ON)
+else ()
+  set (use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
+endif ()
+option (jemalloc "Enables jemalloc for heap profiling" OFF)
+option (werr "treat warnings as errors" OFF)
+option (local_protobuf
   "Force a local build of protobuf instead of looking for an installed version." OFF)
-option(local_grpc
+option (local_grpc
   "Force a local build of gRPC instead of looking for an installed version." OFF)
 
 # this one is a string and therefore can't be an option
-set(san "" CACHE STRING "On gcc & clang, add sanitizer instrumentation")
-set_property(CACHE san PROPERTY STRINGS ";undefined;memory;address;thread")
-if(san)
-  string(TOLOWER ${san} san)
-  set(SAN_FLAG "-fsanitize=${san}")
-  set(SAN_LIB "")
-  if(is_gcc)
-    if(san STREQUAL "address")
-      set(SAN_LIB "asan")
-    elseif(san STREQUAL "thread")
-      set(SAN_LIB "tsan")
-    elseif(san STREQUAL "memory")
-      set(SAN_LIB "msan")
-    elseif(san STREQUAL "undefined")
-      set(SAN_LIB "ubsan")
-    endif()
-  endif()
-  set(_saved_CRL ${CMAKE_REQUIRED_LIBRARIES})
-  set(CMAKE_REQUIRED_LIBRARIES "${SAN_FLAG};${SAN_LIB}")
-  check_cxx_compiler_flag(${SAN_FLAG} COMPILER_SUPPORTS_SAN)
-  set(CMAKE_REQUIRED_LIBRARIES ${_saved_CRL})
-  if(NOT COMPILER_SUPPORTS_SAN)
-    message(FATAL_ERROR "${san} sanitizer does not seem to be supported by your compiler")
-  endif()
-endif()
-set(container_label "" CACHE STRING "tag to use for package building containers")
-option(packages_only
+set (san "" CACHE STRING "On gcc & clang, add sanitizer instrumentation")
+set_property (CACHE san PROPERTY STRINGS ";undefined;memory;address;thread")
+if (san)
+  string (TOLOWER ${san} san)
+  set (SAN_FLAG "-fsanitize=${san}")
+  set (SAN_LIB "")
+  if (is_gcc)
+    if (san STREQUAL "address")
+      set (SAN_LIB "asan")
+    elseif (san STREQUAL "thread")
+      set (SAN_LIB "tsan")
+    elseif (san STREQUAL "memory")
+      set (SAN_LIB "msan")
+    elseif (san STREQUAL "undefined")
+      set (SAN_LIB "ubsan")
+    endif ()
+  endif ()
+  set (_saved_CRL ${CMAKE_REQUIRED_LIBRARIES})
+  set (CMAKE_REQUIRED_LIBRARIES "${SAN_FLAG};${SAN_LIB}")
+  check_cxx_compiler_flag (${SAN_FLAG} COMPILER_SUPPORTS_SAN)
+  set (CMAKE_REQUIRED_LIBRARIES ${_saved_CRL})
+  if (NOT COMPILER_SUPPORTS_SAN)
+    message (FATAL_ERROR "${san} sanitizer does not seem to be supported by your compiler")
+  endif ()
+endif ()
+set (container_label "" CACHE STRING "tag to use for package building containers")
+option (packages_only
   "ONLY generate package building targets. This is special use-case and almost \
    certainly not what you want. Use with caution as you won't be able to build \
    any compiled targets locally." OFF)
-option(have_package_container
+option (have_package_container
   "Sometimes you already have the tagged container you want to use for package \
    building and you don't want docker to rebuild it. This flag will detach the \
    dependency of the package build from the container build. It's an advanced \
    use case and most likely you should not be touching this flag." OFF)
 
 # the remaining options are obscure and rarely used
-option(beast_no_unit_test_inline
+option (beast_no_unit_test_inline
   "Prevents unit test definitions from being inserted into global table"
   OFF)
-option(single_io_service_thread
+option (single_io_service_thread
   "Restricts the number of threads calling io_service::run to one. \
   This can be useful when debugging."
   OFF)
-option(boost_show_deprecated
+option (boost_show_deprecated
   "Allow boost to fail on deprecated usage. Only useful if you're trying\
   to find deprecated calls."
   OFF)
-option(beast_hashers
+option (beast_hashers
   "Use local implementations for sha/ripemd hashes (experimental, not recommended)"
   OFF)
 
-if(WIN32)
-  option(beast_disable_autolink "Disables autolinking of system libraries on WIN32" OFF)
-else()
-  set(beast_disable_autolink OFF CACHE BOOL "WIN32 only" FORCE)
-endif()
-if(coverage)
-  message(STATUS "coverage build requested - forcing Debug build")
-  set(CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
-endif()
+if (WIN32)
+  option (beast_disable_autolink "Disables autolinking of system libraries on WIN32" OFF)
+else ()
+  set (beast_disable_autolink OFF CACHE BOOL "WIN32 only" FORCE)
+endif ()
+if (coverage)
+  message (STATUS "coverage build requested - forcing Debug build")
+  set (CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
+endif ()

Builds/CMake/RippledValidatorKeys.cmake

@@ -2,9 +2,9 @@ option (validator_keys "Enables building of validator-keys-tool as a separate ta
 
 if (validator_keys)
   git_branch (current_branch)
-  # default to tracking VK master branch unless we are on release
-  if (NOT (current_branch STREQUAL "release"))
-    set (current_branch "master")
+  # default to tracking VK develop branch unless we are on master/release
+  if (NOT (current_branch STREQUAL "master" OR current_branch STREQUAL "release"))
+    set (current_branch "develop")
   endif ()
   message (STATUS "tracking ValidatorKeys branch: ${current_branch}")
 

Builds/CMake/SociConfig.cmake.patched

@@ -0,0 +1,106 @@
+################################################################################
+# SociConfig.cmake - CMake build configuration of SOCI library
+################################################################################
+# Copyright (C) 2010 Mateusz Loskot <mateusz@loskot.net>
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+################################################################################
+
+include(CheckCXXSymbolExists)
+
+if(WIN32)
+  check_cxx_symbol_exists("_M_AMD64" "" SOCI_TARGET_ARCH_X64)
+  if(NOT RTC_ARCH_X64)
+    check_cxx_symbol_exists("_M_IX86" "" SOCI_TARGET_ARCH_X86)
+  endif(NOT RTC_ARCH_X64)
+  # add check for arm here
+  # see http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+else(WIN32)
+  check_cxx_symbol_exists("__i386__" "" SOCI_TARGET_ARCH_X86)
+  check_cxx_symbol_exists("__x86_64__" "" SOCI_TARGET_ARCH_X64)
+  check_cxx_symbol_exists("__arm__" "" SOCI_TARGET_ARCH_ARM)
+endif(WIN32)
+
+if(NOT DEFINED LIB_SUFFIX)
+  if(SOCI_TARGET_ARCH_X64)
+    set(_lib_suffix "64")
+  else()
+    set(_lib_suffix "")
+  endif()
+  set(LIB_SUFFIX ${_lib_suffix} CACHE STRING "Specifies suffix for the lib directory")
+endif()
+
+#
+# C++11 Option
+#
+
+if(NOT SOCI_CXX_C11)
+  set (SOCI_CXX_C11 OFF CACHE BOOL "Build to the C++11 standard")
+endif()
+
+#
+# Force compilation flags and set desired warnings level
+#
+
+if (MSVC)
+  add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
+  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+  add_definitions(-D_CRT_NONSTDC_NO_WARNING)
+  add_definitions(-D_SCL_SECURE_NO_WARNINGS)
+
+  if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /we4266")
+  endif()
+
+else()
+
+  set(SOCI_GCC_CLANG_COMMON_FLAGS "")
+    # "-pedantic -Werror -Wno-error=parentheses -Wall -Wextra -Wpointer-arith -Wcast-align -Wcast-qual -Wfloat-equal -Woverloaded-virtual -Wredundant-decls -Wno-long-long")
+
+
+  if (SOCI_CXX_C11)
+    set(SOCI_CXX_VERSION_FLAGS "-std=c++11")
+  else()
+    set(SOCI_CXX_VERSION_FLAGS "-std=gnu++98")
+  endif()
+
+  if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER}" MATCHES "clang")
+
+    if(NOT CMAKE_CXX_COMPILER_VERSION LESS 3.1 AND SOCI_ASAN)
+      set(SOCI_GCC_CLANG_COMMON_FLAGS "${SOCI_GCC_CLANG_COMMON_FLAGS} -fsanitize=address")
+    endif()
+
+    # enforce C++11 for Clang
+    set(SOCI_CXX_C11 ON)
+    set(SOCI_CXX_VERSION_FLAGS "-std=c++11")
+    add_definitions(-DCATCH_CONFIG_CPP11_NO_IS_ENUM)
+
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SOCI_GCC_CLANG_COMMON_FLAGS} ${SOCI_CXX_VERSION_FLAGS}")
+
+  elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
+
+    if(NOT CMAKE_CXX_COMPILER_VERSION LESS 4.8 AND SOCI_ASAN)
+      set(SOCI_GCC_CLANG_COMMON_FLAGS "${SOCI_GCC_CLANG_COMMON_FLAGS} -fsanitize=address")
+    endif()
+
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SOCI_GCC_CLANG_COMMON_FLAGS} ${SOCI_CXX_VERSION_FLAGS} ")
+    if (CMAKE_COMPILER_IS_GNUCXX)
+        if (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+        else()
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-variadic-macros")
+        endif()
+    endif()
+
+  else()
+	message(WARNING "Unknown toolset - using default flags to build SOCI")
+  endif()
+
+endif()
+
+# Set SOCI_HAVE_* variables for soci-config.h generator
+set(SOCI_HAVE_CXX_C11 ${SOCI_CXX_C11} CACHE INTERNAL "Enables C++11 support")

Builds/CMake/conan/Boost.cmake

@@ -6,7 +6,6 @@ find_package(Boost 1.83 REQUIRED
     coroutine
     date_time
     filesystem
-    json
     program_options
     regex
     system
@@ -30,7 +29,6 @@ target_link_libraries(ripple_boost
     Boost::coroutine
     Boost::date_time
     Boost::filesystem
-    Boost::json
     Boost::program_options
     Boost::regex
     Boost::system
@@ -51,4 +49,4 @@ if(san AND is_clang)
     INTERFACE
       # ignore boost headers for sanitizing
       -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
-endif()
+endif()

Builds/CMake/conan/Protobuf.cmake

@@ -0,0 +1,22 @@
+find_package(Protobuf 3.8)
+
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/proto_gen)
+set(ccbd ${CMAKE_CURRENT_BINARY_DIR})
+set(CMAKE_CURRENT_BINARY_DIR ${CMAKE_BINARY_DIR}/proto_gen)
+protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS src/ripple/proto/ripple.proto)
+set(CMAKE_CURRENT_BINARY_DIR ${ccbd})
+
+add_library(pbufs STATIC ${PROTO_SRCS} ${PROTO_HDRS})
+target_include_directories(pbufs SYSTEM PUBLIC
+  ${CMAKE_BINARY_DIR}/proto_gen
+  ${CMAKE_BINARY_DIR}/proto_gen/src/ripple/proto
+)
+target_link_libraries(pbufs protobuf::libprotobuf)
+target_compile_options(pbufs
+  PUBLIC
+    $<$<BOOL:${XCODE}>:
+      --system-header-prefix="google/protobuf"
+      -Wno-deprecated-dynamic-exception-spec
+    >
+)
+add_library(Ripple::pbufs ALIAS pbufs)

Builds/CMake/conan/gRPC.cmake

@@ -0,0 +1,62 @@
+find_package(gRPC 1.23)
+
+#[=================================[
+   generate protobuf sources for
+   grpc defs and bundle into a
+   static lib
+#]=================================]
+set(GRPC_GEN_DIR "${CMAKE_BINARY_DIR}/proto_gen_grpc")
+file(MAKE_DIRECTORY ${GRPC_GEN_DIR})
+set(GRPC_PROTO_SRCS)
+set(GRPC_PROTO_HDRS)
+set(GRPC_PROTO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/proto/org")
+file(GLOB_RECURSE GRPC_DEFINITION_FILES LIST_DIRECTORIES false "${GRPC_PROTO_ROOT}/*.proto")
+foreach(file ${GRPC_DEFINITION_FILES})
+  get_filename_component(_abs_file ${file} ABSOLUTE)
+  get_filename_component(_abs_dir ${_abs_file} DIRECTORY)
+  get_filename_component(_basename ${file} NAME_WE)
+  get_filename_component(_proto_inc ${GRPC_PROTO_ROOT} DIRECTORY) # updir one level
+  file(RELATIVE_PATH _rel_root_file ${_proto_inc} ${_abs_file})
+  get_filename_component(_rel_root_dir ${_rel_root_file} DIRECTORY)
+  file(RELATIVE_PATH _rel_dir ${CMAKE_CURRENT_SOURCE_DIR} ${_abs_dir})
+
+  set(src_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.cc")
+  set(src_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.cc")
+  set(hdr_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.h")
+  set(hdr_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.h")
+  add_custom_command(
+    OUTPUT ${src_1} ${src_2} ${hdr_1} ${hdr_2}
+    COMMAND protobuf::protoc
+    ARGS --grpc_out=${GRPC_GEN_DIR}
+         --cpp_out=${GRPC_GEN_DIR}
+         --plugin=protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
+         -I ${_proto_inc} -I ${_rel_dir}
+         ${_abs_file}
+    DEPENDS ${_abs_file} protobuf::protoc gRPC::grpc_cpp_plugin
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Running gRPC C++ protocol buffer compiler on ${file}"
+    VERBATIM)
+    set_source_files_properties(${src_1} ${src_2} ${hdr_1} ${hdr_2} PROPERTIES GENERATED TRUE)
+    list(APPEND GRPC_PROTO_SRCS ${src_1} ${src_2})
+    list(APPEND GRPC_PROTO_HDRS ${hdr_1} ${hdr_2})
+endforeach()
+
+add_library(grpc_pbufs STATIC ${GRPC_PROTO_SRCS} ${GRPC_PROTO_HDRS})
+#target_include_directories(grpc_pbufs PRIVATE src)
+target_include_directories(grpc_pbufs SYSTEM PUBLIC ${GRPC_GEN_DIR})
+target_link_libraries(grpc_pbufs
+  "gRPC::grpc++"
+  # libgrpc is missing references.
+  absl::random_random
+)
+target_compile_options(grpc_pbufs
+  PRIVATE
+    $<$<BOOL:${MSVC}>:-wd4065>
+    $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
+  PUBLIC
+    $<$<BOOL:${MSVC}>:-wd4996>
+    $<$<BOOL:${XCODE}>:
+      --system-header-prefix="google/protobuf"
+      -Wno-deprecated-dynamic-exception-spec
+    >)
+add_library(Ripple::grpc_pbufs ALIAS grpc_pbufs)

Builds/CMake/deps/Boost.cmake

@@ -54,7 +54,6 @@ find_package(Boost 1.86 REQUIRED
     coroutine
     date_time
     filesystem
-    json
     program_options
     regex
     system
@@ -78,7 +77,6 @@ target_link_libraries(ripple_boost
     Boost::coroutine
     Boost::date_time
     Boost::filesystem
-    Boost::json
     Boost::iostreams
     Boost::program_options
     Boost::regex

Builds/CMake/deps/Ed25519-donna.cmake

@@ -3,13 +3,13 @@
 #]===================================================================]
 
 add_library (ed25519-donna STATIC
-  external/ed25519-donna/ed25519.c)
+  src/ed25519-donna/ed25519.c)
 target_include_directories (ed25519-donna
   PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/external>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
     $<INSTALL_INTERFACE:include>
   PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/external/ed25519-donna)
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/ed25519-donna)
 #[=========================================================[
    NOTE for macos:
    https://github.com/floodyberry/ed25519-donna/issues/29
@@ -24,5 +24,5 @@ target_link_libraries (ripple_libs INTERFACE NIH::ed25519-donna)
 #]===========================]
 install (
   FILES
-    external/ed25519-donna/ed25519.h
+    src/ed25519-donna/ed25519.h
   DESTINATION include/ed25519-donna)

Builds/CMake/deps/Protobuf.cmake

@@ -129,28 +129,27 @@ else ()
   endif ()
 endif ()
 
-set(output_dir ${CMAKE_BINARY_DIR}/proto_gen)
-file(MAKE_DIRECTORY ${output_dir})
-set(ccbd ${CMAKE_CURRENT_BINARY_DIR})
-set(CMAKE_CURRENT_BINARY_DIR ${output_dir})
-protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS src/ripple/proto/ripple.proto)
-set(CMAKE_CURRENT_BINARY_DIR ${ccbd})
+file (MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/proto_gen)
+set (save_CBD ${CMAKE_CURRENT_BINARY_DIR})
+set (CMAKE_CURRENT_BINARY_DIR ${CMAKE_BINARY_DIR}/proto_gen)
+protobuf_generate_cpp (
+  PROTO_SRCS
+  PROTO_HDRS
+  src/ripple/proto/ripple.proto)
+set (CMAKE_CURRENT_BINARY_DIR ${save_CBD})
 
-target_include_directories(xrpl_core SYSTEM PUBLIC
-    # The generated implementation imports the header relative to the output
-    # directory.
-    $<BUILD_INTERFACE:${output_dir}>
-    $<BUILD_INTERFACE:${output_dir}/src>
-)
-target_sources(xrpl_core PRIVATE ${output_dir}/src/ripple/proto/ripple.pb.cc)
-install(
-  FILES ${output_dir}/src/ripple/proto/ripple.pb.h
-  DESTINATION include/ripple/proto)
-target_link_libraries(xrpl_core PUBLIC protobuf::libprotobuf)
-target_compile_options(xrpl_core
+add_library (pbufs STATIC ${PROTO_SRCS} ${PROTO_HDRS})
+
+target_include_directories (pbufs PRIVATE src)
+target_include_directories (pbufs
+  SYSTEM PUBLIC ${CMAKE_BINARY_DIR}/proto_gen)
+target_link_libraries (pbufs protobuf::libprotobuf)
+target_compile_options (pbufs
   PUBLIC
     $<$<BOOL:${is_xcode}>:
       --system-header-prefix="google/protobuf"
       -Wno-deprecated-dynamic-exception-spec
-    >
-)
+    >)
+add_library (Ripple::pbufs ALIAS pbufs)
+target_link_libraries (ripple_libs INTERFACE Ripple::pbufs)
+exclude_if_included (pbufs)

Builds/CMake/deps/Secp256k1.cmake

@@ -24,7 +24,7 @@ else()
   set(INSTALL_SECP256K1 true)
 
   add_library (secp256k1 STATIC
-    external/secp256k1/src/secp256k1.c)
+    src/secp256k1/src/secp256k1.c)
   target_compile_definitions (secp256k1
     PRIVATE
       USE_NUM_NONE
@@ -34,9 +34,9 @@ else()
       USE_SCALAR_INV_BUILTIN)
   target_include_directories (secp256k1
     PUBLIC
-      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/external>
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
       $<INSTALL_INTERFACE:include>
-    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/external/secp256k1)
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src/secp256k1)
   target_compile_options (secp256k1
     PRIVATE
       $<$<BOOL:${MSVC}>:-wd4319>
@@ -51,7 +51,7 @@ else()
 #]===========================]
   install (
     FILES
-      external/secp256k1/include/secp256k1.h
+      src/secp256k1/include/secp256k1.h
   DESTINATION include/secp256k1/include)
 
   add_library (NIH::secp256k1 ALIAS secp256k1)

Builds/CMake/deps/gRPC.cmake

@@ -314,33 +314,25 @@ endif ()
    grpc defs and bundle into a
    static lib
 #]=================================]
-set(output_dir "${CMAKE_BINARY_DIR}/proto_gen_grpc")
-set(GRPC_GEN_DIR "${output_dir}/ripple/proto")
-file(MAKE_DIRECTORY ${GRPC_GEN_DIR})
-set(GRPC_PROTO_SRCS)
-set(GRPC_PROTO_HDRS)
-set(GRPC_PROTO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/proto/org")
-file(GLOB_RECURSE GRPC_DEFINITION_FILES "${GRPC_PROTO_ROOT}/*.proto")
+set (GRPC_GEN_DIR "${CMAKE_BINARY_DIR}/proto_gen_grpc")
+file (MAKE_DIRECTORY ${GRPC_GEN_DIR})
+set (GRPC_PROTO_SRCS)
+set (GRPC_PROTO_HDRS)
+set (GRPC_PROTO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/proto/org")
+file(GLOB_RECURSE GRPC_DEFINITION_FILES LIST_DIRECTORIES false "${GRPC_PROTO_ROOT}/*.proto")
 foreach(file ${GRPC_DEFINITION_FILES})
-  # /home/user/rippled/src/ripple/proto/org/.../v1/get_ledger.proto
   get_filename_component(_abs_file ${file} ABSOLUTE)
-  # /home/user/rippled/src/ripple/proto/org/.../v1
   get_filename_component(_abs_dir ${_abs_file} DIRECTORY)
-  # get_ledger
   get_filename_component(_basename ${file} NAME_WE)
-  # /home/user/rippled/src/ripple/proto
   get_filename_component(_proto_inc ${GRPC_PROTO_ROOT} DIRECTORY) # updir one level
-  # org/.../v1/get_ledger.proto
   file(RELATIVE_PATH _rel_root_file ${_proto_inc} ${_abs_file})
-  # org/.../v1
   get_filename_component(_rel_root_dir ${_rel_root_file} DIRECTORY)
-  # src/ripple/proto/org/.../v1
   file(RELATIVE_PATH _rel_dir ${CMAKE_CURRENT_SOURCE_DIR} ${_abs_dir})
 
-  set(src_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.cc")
-  set(src_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.cc")
-  set(hdr_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.h")
-  set(hdr_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.h")
+  set (src_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.cc")
+  set (src_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.cc")
+  set (hdr_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.h")
+  set (hdr_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.h")
   add_custom_command(
     OUTPUT ${src_1} ${src_2} ${hdr_1} ${hdr_2}
     COMMAND protobuf::protoc
@@ -353,32 +345,16 @@ foreach(file ${GRPC_DEFINITION_FILES})
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     COMMENT "Running gRPC C++ protocol buffer compiler on ${file}"
     VERBATIM)
-    set_source_files_properties(${src_1} ${src_2} ${hdr_1} ${hdr_2} PROPERTIES
-      GENERATED TRUE
-      SKIP_UNITY_BUILD_INCLUSION ON
-    )
+    set_source_files_properties(${src_1} ${src_2} ${hdr_1} ${hdr_2} PROPERTIES GENERATED TRUE)
     list(APPEND GRPC_PROTO_SRCS ${src_1} ${src_2})
     list(APPEND GRPC_PROTO_HDRS ${hdr_1} ${hdr_2})
 endforeach()
 
-target_include_directories(xrpl_core SYSTEM PUBLIC
-  $<BUILD_INTERFACE:${output_dir}>
-  $<BUILD_INTERFACE:${output_dir}/ripple/proto>
-  # The generated sources include headers relative to this path. Fix it later.
-  $<INSTALL_INTERFACE:include/ripple/proto>
-)
-target_sources(xrpl_core PRIVATE ${GRPC_PROTO_SRCS})
-install(
-  DIRECTORY ${output_dir}/ripple
-  DESTINATION include/
-  FILES_MATCHING PATTERN "*.h"
-)
-target_link_libraries(xrpl_core PUBLIC
-  "gRPC::grpc++"
-  # libgrpc is missing references.
-  absl::random_random
-)
-target_compile_options(xrpl_core
+add_library (grpc_pbufs STATIC ${GRPC_PROTO_SRCS} ${GRPC_PROTO_HDRS})
+#target_include_directories (grpc_pbufs PRIVATE src)
+target_include_directories (grpc_pbufs SYSTEM PUBLIC ${GRPC_GEN_DIR})
+target_link_libraries (grpc_pbufs protobuf::libprotobuf "gRPC::grpc++${grpc_suffix}")
+target_compile_options (grpc_pbufs
   PRIVATE
     $<$<BOOL:${MSVC}>:-wd4065>
     $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
@@ -388,5 +364,6 @@ target_compile_options(xrpl_core
       --system-header-prefix="google/protobuf"
       -Wno-deprecated-dynamic-exception-spec
     >)
-# target_link_libraries (ripple_libs INTERFACE Ripple::grpc_pbufs)
-# exclude_if_included (grpc_pbufs)
+add_library (Ripple::grpc_pbufs ALIAS grpc_pbufs)
+target_link_libraries (ripple_libs INTERFACE Ripple::grpc_pbufs)
+exclude_if_included (grpc_pbufs)

Builds/CMake/echo_file.cmake

@@ -0,0 +1,17 @@
+#[=========================================================[
+  This is a CMake script file that is used to write
+  the contents of a file to stdout (using the cmake
+  echo command). The input file is passed via the
+  IN_FILE variable.
+#]=========================================================]
+
+if (EXISTS ${IN_FILE})
+  file (READ ${IN_FILE} contents)
+  ## only print files that actually have some text in them
+  if (contents MATCHES "[a-z0-9A-Z]+")
+    execute_process(
+      COMMAND
+        ${CMAKE_COMMAND} -E echo "${contents}")
+  endif ()
+endif ()
+

Builds/CMake/target_protobuf_sources.cmake

@@ -1,62 +0,0 @@
-find_package(Protobuf REQUIRED)
-
-# .proto files import each other like this:
-#
-# import "path/to/file.proto";
-#
-# For the protobuf compiler to find these imports,
-# the parent directory of "path" must be in the import path.
-#
-# When generating C++,
-# it turns into an include statement like this:
-#
-# #include "path/to/file.pb.h"
-#
-# and the header is generated at a path relative to the output directory
-# that matches the given .proto path relative to the source directory
-# minus the first matching prefix on the import path.
-#
-# In other words, a file `include/package/path/to/file.proto`
-# with import path [`include/package`, `include`]
-# will generate files `output/path/to/file.pb.{h,cc}`
-# with includes like `#include "path/to/file.pb.h".
-#
-# During build, the generated files can find each other if the output
-# directory is an include directory, but we want to install that directory
-# under our package's include directory (`include/package`), not as a sibling.
-# After install, they can find each other if that subdirectory is an include
-# directory.
-
-# Add protocol buffer sources to an existing library target.
-# target:
-#     The name of the library target.
-# prefix:
-#     The install prefix for headers relative to `CMAKE_INSTALL_INCLUDEDIR`.
-#     This prefix should appear at the start of all your consumer includes.
-# ARGN:
-#     A list of .proto files.
-function(target_protobuf_sources target prefix)
-  set(dir "${CMAKE_CURRENT_BINARY_DIR}/pb-${target}")
-  file(MAKE_DIRECTORY "${dir}/${prefix}")
-
-  protobuf_generate(
-    TARGET ${target}
-    PROTOC_OUT_DIR "${dir}/${prefix}"
-    "${ARGN}"
-  )
-  target_include_directories(${target} SYSTEM PUBLIC
-    # Allows #include <package/path/to/file.proto> used by consumer files.
-    $<BUILD_INTERFACE:${dir}>
-    # Allows #include "path/to/file.proto" used by generated files.
-    $<BUILD_INTERFACE:${dir}/${prefix}>
-    # Allows #include <package/path/to/file.proto> used by consumer files.
-    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-    # Allows #include "path/to/file.proto" used by generated files.
-    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${prefix}>
-  )
-  install(
-    DIRECTORY ${dir}/
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-    FILES_MATCHING PATTERN "*.h"
-  )
-endfunction()

Builds/README.md

@@ -0,0 +1 @@
+[Please see the BUILD instructions here](../BUILD.md)

Builds/levelization/results/ordering.txt

@@ -140,8 +140,6 @@ test.jtx > ripple.json
 test.jtx > ripple.ledger
 test.jtx > ripple.net
 test.jtx > ripple.protocol
-test.jtx > ripple.resource
-test.jtx > ripple.rpc
 test.jtx > ripple.server
 test.ledger > ripple.app
 test.ledger > ripple.basics
@@ -168,6 +166,7 @@ test.nodestore > test.unit_test
 test.overlay > ripple.app
 test.overlay > ripple.basics
 test.overlay > ripple.beast
+test.overlay > ripple.core
 test.overlay > ripple.overlay
 test.overlay > ripple.peerfinder
 test.overlay > ripple.protocol

CMakeLists.txt

@@ -24,7 +24,7 @@ set(Boost_NO_BOOST_CMAKE ON)
 # make GIT_COMMIT_HASH define available to all sources
 find_package(Git)
 if(Git_FOUND)
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git describe --always --abbrev=40
+    execute_process(COMMAND ${GIT_EXECUTABLE} describe --always --abbrev=40
         OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
     if(gch)
         set(GIT_COMMIT_HASH "${gch}")
@@ -59,6 +59,7 @@ include (CheckCXXCompilerFlag)
 include (FetchContent)
 include (ExternalProject)
 include (CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
+include (ProcessorCount)
 if (target)
   message (FATAL_ERROR "The target option has been removed - use native cmake options to control build")
 endif ()
@@ -82,10 +83,8 @@ include(RippledInterface)
 
 ###
 if (NOT USE_CONAN)
-  set(SECP256K1_INSTALL TRUE)
-  add_subdirectory(external/secp256k1)
-  add_library(secp256k1::secp256k1 ALIAS secp256k1)
-  add_subdirectory(external/ed25519-donna)
+  add_subdirectory(src/secp256k1)
+  add_subdirectory(src/ed25519-donna)
   include(deps/Boost)
   include(deps/OpenSSL)
   # include(deps/Secp256k1)
@@ -98,8 +97,8 @@ if (NOT USE_CONAN)
   include(deps/Rocksdb)
   include(deps/Nudb)
   include(deps/date)
-  # include(deps/Protobuf)
-  # include(deps/gRPC)
+  include(deps/Protobuf)
+  include(deps/gRPC)
   include(deps/cassandra)
   include(deps/Postgres)
   include(deps/WasmEdge)
@@ -109,11 +108,8 @@ else()
   set_target_properties(OpenSSL::SSL PROPERTIES
     INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
   )
-  set(SECP256K1_INSTALL TRUE)
-  add_subdirectory(external/secp256k1)
-  add_library(secp256k1::secp256k1 ALIAS secp256k1)
-  add_subdirectory(external/ed25519-donna)
-  find_package(gRPC REQUIRED)
+  add_subdirectory(src/secp256k1)
+  add_subdirectory(src/ed25519-donna)
   find_package(lz4 REQUIRED)
   # Target names with :: are not allowed in a generator expression.
   # We need to pull the include directories and imported location properties
@@ -133,7 +129,9 @@ else()
   endif()
   find_package(nudb REQUIRED)
   find_package(date REQUIRED)
-  find_package(xxHash REQUIRED)
+  find_package(BLAKE3 REQUIRED)
+  include(conan/Protobuf)
+  include(conan/gRPC)
     if(TARGET nudb::core)
     set(nudb nudb::core)
   elseif(TARGET NuDB::nudb)
@@ -153,29 +151,23 @@ else()
   endif()
   target_link_libraries(ripple_libs INTERFACE
     ed25519::ed25519
+    LibArchive::LibArchive
     lz4::lz4
     OpenSSL::Crypto
     OpenSSL::SSL
-    # Ripple::grpc_pbufs
-    # Ripple::pbufs
+    Ripple::grpc_pbufs
+    Ripple::pbufs
     secp256k1::secp256k1
     soci::soci
     SQLite::SQLite3
   )
 endif()
 
-if(coverage)
-  include(RippledCov)
-endif()
-
 ###
 
 include(RippledCore)
-if (NOT USE_CONAN)
-  include(deps/Protobuf)
-  include(deps/gRPC)
-endif()
 include(RippledInstall)
+include(RippledCov)
 include(RippledMultiConfig)
 include(RippledDocs)
 include(RippledValidatorKeys)

CONTRIBUTING.md

@@ -123,25 +123,6 @@ pip3 install pre-commit
 pre-commit install
 ```
 
-## Unit Tests
-To execute all unit tests:
-
-```rippled --unittest --unittest-jobs=<number of cores>```
-
-(Note: Using multiple cores on a Mac M1 can cause spurious test failures. The 
-cause is still under investigation. If you observe this problem, try specifying fewer jobs.)
-
-To run a specific set of test suites:
-
-```
-rippled --unittest TestSuiteName
-```
-Note: In this example, all tests with prefix `TestSuiteName` will be run, so if
-`TestSuiteName1` and `TestSuiteName2` both exist, then both tests will run. 
-Alternatively, if the unit test name finds an exact match, it will stop 
-doing partial matches, i.e. if a unit test with a title of `TestSuiteName` 
-exists, then no other unit test will be executed, apart from `TestSuiteName`.
-
 ## Avoid
 
 1. Proliferation of nearly identical code.
@@ -201,4 +182,4 @@ existing maintainer without a vote.
 
 
 [1]: https://docs.github.com/en/get-started/quickstart/contributing-to-projects
-[2]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/incorporating-changes-from-a-pull-request/about-pull-request-merges#squash-and-merge-your-commits
+[2]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/incorporating-changes-from-a-pull-request/about-pull-request-merges#squash-and-merge-your-commits

DISABLE_OLD_ENTRIES.md

@@ -0,0 +1,217 @@
+# Auto-Disable Strategy for Hash Migration
+
+## Core Concept
+Instead of trying to fix entries with hardcoded old keys, **automatically disable them** during migration. If it contains old keys, it's broken anyway - make that explicit.
+
+## The Algorithm
+
+### Phase 1: Build Complete Old Key Set
+```cpp
+std::unordered_set<uint256> all_old_keys;
+
+// Collect ALL SHA-512 keys from current state
+stateMap_.visitLeaves([&](SHAMapItem const& item) {
+    all_old_keys.insert(item.key());
+    
+    // Also collect keys from reference fields
+    SerialIter sit(item.slice());
+    auto sle = std::make_shared<SLE>(sit, item.key());
+    
+    // Collect from vector fields
+    if (sle->isFieldPresent(sfIndexes)) {
+        for (auto& key : sle->getFieldV256(sfIndexes)) {
+            all_old_keys.insert(key);
+        }
+    }
+    // ... check all other reference fields
+});
+```
+
+### Phase 2: Scan and Disable
+
+#### Hook Definitions (WASM Code)
+```cpp
+bool scanWASMForKeys(Blob const& wasm_code, std::unordered_set<uint256> const& keys) {
+    // Scan for 32-byte sequences matching known keys
+    for (size_t i = 0; i <= wasm_code.size() - 32; i++) {
+        uint256 potential_key = extract32Bytes(wasm_code, i);
+        if (keys.count(potential_key)) {
+            return true;  // Found hardcoded key!
+        }
+    }
+    return false;
+}
+
+// During migration
+for (auto& hookDef : allHookDefinitions) {
+    if (scanWASMForKeys(hookDef->getFieldBlob(sfCreateCode), all_old_keys)) {
+        hookDef->setFieldU32(sfFlags, hookDef->getFlags() | HOOK_DISABLED_OLD_KEYS);
+        disabled_hooks.push_back(hookDef->key());
+    }
+}
+```
+
+#### Hook State (Arbitrary Data)
+```cpp
+for (auto& hookState : allHookStates) {
+    auto data = hookState->getFieldBlob(sfHookStateData);
+    if (containsAnyKey(data, all_old_keys)) {
+        hookState->setFieldU32(sfFlags, STATE_INVALID_OLD_KEYS);
+        disabled_states.push_back(hookState->key());
+    }
+}
+```
+
+#### Other Vulnerable Entry Types
+```cpp
+void disableEntriesWithOldKeys(SLE& sle) {
+    switch(sle.getType()) {
+        case ltHOOK:
+            if (hasOldKeys(sle)) {
+                sle.setFlag(HOOK_DISABLED_MIGRATION);
+            }
+            break;
+            
+        case ltESCROW:
+            // Check if destination/condition contains old keys
+            if (containsOldKeyReferences(sle)) {
+                sle.setFlag(ESCROW_FROZEN_MIGRATION);
+            }
+            break;
+            
+        case ltPAYCHAN:
+            // Payment channels with old key references
+            if (hasOldKeyInFields(sle)) {
+                sle.setFlag(PAYCHAN_SUSPENDED_MIGRATION);
+            }
+            break;
+            
+        case ltHOOK_STATE:
+            // Already handled above
+            break;
+    }
+}
+```
+
+## Flag Definitions
+
+```cpp
+// New flags for migration-disabled entries
+constexpr uint32_t HOOK_DISABLED_OLD_KEYS     = 0x00100000;
+constexpr uint32_t STATE_INVALID_OLD_KEYS     = 0x00200000;
+constexpr uint32_t ESCROW_FROZEN_MIGRATION    = 0x00400000;
+constexpr uint32_t PAYCHAN_SUSPENDED_MIGRATION = 0x00800000;
+constexpr uint32_t ENTRY_BROKEN_MIGRATION     = 0x01000000;
+```
+
+## Execution Prevention
+
+```cpp
+// In transaction processing
+TER HookExecutor::executeHook(Hook const& hook) {
+    if (hook.isFieldPresent(sfFlags)) {
+        if (hook.getFlags() & HOOK_DISABLED_OLD_KEYS) {
+            return tecHOOK_DISABLED_MIGRATION;
+        }
+    }
+    // Normal execution
+}
+
+TER processEscrow(Escrow const& escrow) {
+    if (escrow.getFlags() & ESCROW_FROZEN_MIGRATION) {
+        return tecESCROW_FROZEN_MIGRATION;
+    }
+    // Normal processing
+}
+```
+
+## Re-enabling Process
+
+### For Hooks
+Developer must submit a new SetHook transaction with updated WASM:
+```cpp
+TER SetHook::doApply() {
+    // If hook was disabled for migration
+    if (oldHook->getFlags() & HOOK_DISABLED_OLD_KEYS) {
+        // Verify new WASM doesn't contain old keys
+        if (scanWASMForKeys(newWasm, all_old_keys)) {
+            return tecSTILL_CONTAINS_OLD_KEYS;
+        }
+        // Clear the disabled flag
+        newHook->clearFlag(HOOK_DISABLED_OLD_KEYS);
+    }
+}
+```
+
+### For Hook State
+Must be cleared and rebuilt:
+```cpp
+TER HookStateModify::doApply() {
+    if (state->getFlags() & STATE_INVALID_OLD_KEYS) {
+        // Can only delete, not modify
+        if (operation != DELETE) {
+            return tecSTATE_REQUIRES_REBUILD;
+        }
+    }
+}
+```
+
+## Migration Report
+
+```json
+{
+    "migration_ledger": 20000000,
+    "entries_scanned": 620000,
+    "entries_disabled": {
+        "hooks": 12,
+        "hook_definitions": 3,
+        "hook_states": 1847,
+        "escrows": 5,
+        "payment_channels": 2
+    },
+    "disabled_by_reason": {
+        "wasm_contains_keys": 3,
+        "state_contains_keys": 1847,
+        "reference_old_keys": 19
+    },
+    "action_required": [
+        {
+            "type": "HOOK_DEFINITION",
+            "key": "0xABCD...",
+            "owner": "rXXX...",
+            "reason": "WASM contains 3 hardcoded SHA-512 keys",
+            "action": "Recompile hook with new keys or remove hardcoding"
+        }
+    ]
+}
+```
+
+## Benefits
+
+1. **Safety**: Broken things explicitly disabled, not silently failing
+2. **Transparency**: Clear record of what was disabled and why
+3. **Natural Cleanup**: Abandoned entries stay disabled forever
+4. **Developer Responsibility**: Owners must actively fix and re-enable
+5. **No Silent Corruption**: Better to disable than corrupt
+6. **Audit Trail**: Complete record of migration casualties
+
+## Implementation Complexity
+
+- **Scanning**: O(n×m) where n=entries, m=data size
+- **Memory**: Need all old keys in memory (~40MB)
+- **False Positives**: Extremely unlikely (2^-256 probability)
+- **Recovery**: Clear path to re-enable fixed entries
+
+## The Nuclear Option
+
+If too many critical entries would be disabled:
+```cpp
+if (disabled_count > ACCEPTABLE_THRESHOLD) {
+    // Abort migration
+    return temMIGRATION_TOO_DESTRUCTIVE;
+}
+```
+
+## Summary
+
+Instead of attempting impossible fixes for hardcoded keys, acknowledge reality: **if it contains old keys, it's broken**. Make that brokenness explicit through disabling, forcing conscious action to repair and re-enable. This turns an impossible problem (fixing hardcoded keys in WASM) into a manageable one (identifying and disabling broken entries).

HASH_MIGRATION_CONTEXT.md

@@ -0,0 +1,663 @@
+# Hash Migration to Blake3 - Work Context
+
+## Build Commands
+- **To build**: `ninja -C build`
+- **To count errors**: `ninja -C build 2>&1 | grep "error:" | wc -l`
+- **To see failed files**: `ninja -C build 2>&1 | grep "^FAILED:" | head -20`
+- **DO NOT USE**: `cmake --build` or `make`
+
+## Test Compilation of Single Files
+
+### Quick Method (basic errors only)
+```bash
+clang++ -std=c++20 -I/Users/nicholasdudfield/projects/xahaud-worktrees/xahaud-map-stats-rpc/src \
+  -c src/test/app/NFToken_test.cpp -o /tmp/test.o 2>&1 | head -50
+```
+
+### Full Compilation Command (from compile_commands.json)
+Extract the exact compilation command for any file:
+```bash
+# For any specific file:
+jq -r '.[] | select(.file | endswith("NFToken_test.cpp")) | .command' build/compile_commands.json
+
+# Or simplified with just the file path:
+FILE="src/test/app/NFToken_test.cpp"
+jq -r --arg file "$FILE" '.[] | select(.file | endswith($file)) | .command' build/compile_commands.json
+```
+
+### compile_commands.json location
+- **Location**: `build/compile_commands.json`
+- Contains exact compilation commands with all include paths and flags for each source file
+- Generated by CMake during configuration
+
+## Objective
+Modify Xahaud to pass ledger_index through all hash functions to enable switching from SHA512-Half to Blake3 at a specific ledger index.
+
+## Current Approach
+Using a `hash_options` struct containing `ledger_index` that must be passed to all hash functions.
+
+## Structure Added
+```cpp
+struct hash_options {
+    std::uint32_t ledger_index;
+    explicit hash_options(std::uint32_t li) : ledger_index(li) {}
+};
+```
+
+## CRITICAL: Hash Function Classification Required
+
+### The Historical Ledger Problem
+**EVERY** hash operation needs proper classification because even "content hashing" (like transaction IDs, validator manifests, signatures) depends on WHEN it was created:
+- Transaction from ledger 10M (pre-transition) → Must use SHA-512 Half
+- Transaction from ledger 20M (post-transition) → Must use BLAKE3
+- You cannot mix hash algorithms for the same ledger - it's all or nothing
+
+### Classification Constants (to be added to digest.h)
+As an interim step, introduce classification constants to make intent explicit:
+```cpp
+// Special ledger_index values for hash operations
+constexpr uint32_t LEDGER_INDEX_UNKNOWN = 0;  // DANGEROUS - avoid!
+constexpr uint32_t LEDGER_INDEX_TEST_ONLY = std::numeric_limits<uint32_t>::max();
+constexpr uint32_t LEDGER_INDEX_NETWORK_PROTOCOL = std::numeric_limits<uint32_t>::max() - 1;
+constexpr uint32_t LEDGER_INDEX_CURRENT = std::numeric_limits<uint32_t>::max() - 2;  // Use current ledger
+```
+
+### Classification Categories
+
+1. **Ledger Object Indexing** (MUST use actual ledger_index)
+   - All `indexHash()` calls determining WHERE objects live
+   - All keylet functions creating/finding ledger objects
+   - SHAMap node hashing (builds the Merkle tree)
+
+2. **Historical Content Hashing** (MUST use ledger_index from when it was created)
+   - Transaction IDs (use ledger where tx was included)
+   - Validator manifests (use ledger when signed)
+   - Hook code hashing (use ledger when deployed)
+   - Signatures referencing ledger data
+
+3. **Test Code** (use LEDGER_INDEX_TEST_ONLY)
+   - Unit tests
+   - Mock objects
+   - Test fixtures
+
+4. **Network Protocol** (special handling needed)
+   - Peer handshakes
+   - Protocol messages
+   - May need to support both algorithms during transition
+
+### Why hash_options{0} is Dangerous
+Using `hash_options{0}` assumes everything is pre-transition (SHA-512 Half forever), which breaks after the transition point. Every usage must be classified and given the appropriate context.
+
+## SHAMap Hash Architecture Analysis
+
+### Current State
+- SHAMap stores `ledgerSeq_` and knows which ledger it represents
+- Nodes compute hashes WITHOUT ledger context (just use sha512Half directly)
+- Nodes can be SHARED between SHAMaps via canonicalization/caching
+- Node's `hash_` member stores only ONE hash value
+
+### The Fundamental Problem: Node Sharing vs Hash Migration
+
+When nodes are shared between ledgers through canonicalization:
+- A node from ledger 19,999,999 (SHA-512) has hash H1
+- Same node referenced by ledger 20,000,000 (BLAKE3) needs hash H2
+- **Cannot store both hashes without major memory overhead**
+
+### Merkle Tree Constraint
+The Merkle tree structure requires homogeneous hashing:
+```
+Root (BLAKE3)
+├── Child1 (BLAKE3) ✓
+└── Child2 (SHA-512) ✗ IMPOSSIBLE - breaks tree integrity
+```
+You cannot mix hash algorithms within a single tree - all nodes must use the same algorithm.
+
+### Migration Strategies Considered
+
+#### Option 1: Lazy/Gradual Migration ✗
+- Store both SHA-512 and BLAKE3 hashes in each node
+- Problems:
+  - Double memory usage per node
+  - Complex cache invalidation logic  
+  - Still can't mix algorithms in same tree
+  - Node sharing between ledgers becomes impossible
+
+#### Option 2: Big Bang Migration ✓ (Recommended)
+- At transition ledger:
+  - Invalidate ALL cached/stored nodes
+  - Rebuild entire state with new hash algorithm
+  - Maintain separate caches for pre/post transition
+- Benefits:
+  - Clean separation of hash epochs
+  - Easier to reason about
+  - No memory overhead
+  - Maintains tree integrity
+
+### Implementation Requirements for Big Bang
+
+1. **Pass ledger_index through all hash operations:**
+   ```cpp
+   void updateHash(std::uint32_t ledgerSeq);
+   SHAMapHash getHash(std::uint32_t ledgerSeq) const;
+   ```
+
+2. **Separate node caches by hash epoch:**
+   - Pre-transition: SHA-512 node cache
+   - Post-transition: BLAKE3 node cache
+   - Never share nodes between epochs
+
+3. **Critical functions needing updates:**
+   - `SHAMapInnerNode::updateHash()`
+   - `SHAMapInnerNode::updateHashDeep()`
+   - All `SHAMapLeafNode` subclass hash computations
+   - `SHAMap::flushDirty()` and `walkSubTree()`
+
+### Why Big Bang is Preferred
+- **Correctness**: Guarantees Merkle tree integrity
+- **Simplicity**: No complex dual-hash logic
+- **Performance**: No overhead of maintaining multiple hashes
+- **Clear boundaries**: Pre-transition and post-transition are completely separate
+
+The transition point becomes a hard boundary where the entire ledger state is rehashed with the new algorithm.
+
+### Alternative: Heterogeneous Tree - Deep Dive
+
+After deeper analysis, heterogeneous trees are more complex but potentially viable. Here's a comprehensive examination:
+
+#### The Core Insight: Hash Values Are Algorithm-Agnostic
+
+When `SHAMapInnerNode::updateHash()` computes a hash:
+```cpp
+void updateHash(hash_options const& opts) {
+    sha512_half_hasher h(opts);  
+    hash_append(h, HashPrefix::innerNode);
+    iterChildren([&](SHAMapHash const& hh) { hash_append(h, hh); });
+    // Parent hashes the HASH VALUES of children, not the raw data
+}
+```
+
+**Key realization**: Parent nodes hash their children's hash values (256-bit numbers), NOT the children's data. This means a BLAKE3 parent can hash SHA-512 child hashes without issue.
+
+#### How Heterogeneous Trees Would Work
+
+Post-transition rule: **Any NEW hash uses BLAKE3**
+
+```
+Ledger 19,999,999 (SHA-512):
+Root_SHA512
+├── Child1_SHA512
+└── Child2_SHA512
+
+Ledger 20,000,000 (BLAKE3) - Child1 modified:
+Root_BLAKE3 = BLAKE3(Child1_BLAKE3_hash || Child2_SHA512_hash)
+├── Child1_BLAKE3 (NEW hash due to modification)
+└── Child2_SHA512 (unchanged, keeps old hash)
+```
+
+#### The Canonical Structure Ensures Determinism
+
+**Critical insight**: SHAMap trees are **canonical** - the structure is deterministic based on keys:
+- Alice's account always goes in the same tree position
+- Bob's account always goes in the same position
+- Tree shape is fully determined by the set of keys
+
+Therefore:
+- Same modifications → Same tree structure
+- Same tree structure → Same nodes get rehashed
+- Same rehashing → Same final root hash
+- **Consensus is maintained!**
+
+#### The "NEW vs OLD" Detection Problem
+
+The killer issue: How do you know if you're computing a NEW hash vs verifying an OLD one?
+
+```cpp
+void updateHash(hash_options const& opts) {
+    // Am I computing a NEW hash (use BLAKE3)?
+    // Or verifying an OLD hash (could be SHA-512)?
+    // This function doesn't know WHY it was called!
+}
+```
+
+Without explicit context about NEW vs OLD:
+- Loading from DB: Don't know if it's SHA-512 or BLAKE3
+- Modifying a node: Should use BLAKE3
+- Verifying from network: Could be either
+
+Potential solutions:
+1. **Try-both approach**: Verify with BLAKE3, fallback to SHA-512
+2. **Version tracking**: Store algorithm version with each node
+3. **Context passing**: Thread NEW/OLD context through all calls
+
+#### Canonical Nodes (cowid=0) - A Complication
+
+Canonical nodes are immutable and shared, BUT:
+- They ARE verified when loaded from DB or network
+- The verification needs to compute the hash to check integrity
+- This means we need to know WHICH algorithm was used
+- Can't just trust the hash - must verify data matches
+
+This actually makes heterogeneous trees HARDER because:
+```cpp
+// When loading a canonical node from DB:
+auto node = SHAMapTreeNode::makeFromPrefix(data, hash);
+// Need to verify: does hash(data) == provided_hash?
+// But which hash function? SHA-512 or BLAKE3?
+// Must try both, adding complexity and ambiguity
+```
+
+#### System-Wide Implications
+
+##### Database Layer
+- Heterogeneous: Same data might have 2 entries (SHA-512 and BLAKE3 versions)
+- Big Bang: Clean cutover, old entries become invalid
+
+##### Network Sync
+- Heterogeneous: Ambiguous - "I need node 0xABC..." (which algorithm?)
+- Big Bang: Clear - algorithm determined by ledger context
+
+##### Consensus
+- Heterogeneous: Works IF all validators make same NEW/OLD decisions
+- Big Bang: Simple - everyone uses same algorithm
+
+##### External Proof Verification
+- Heterogeneous: Complex - mixed algorithms in Merkle paths
+- Big Bang: Simple - "before ledger X use SHA-512, after use BLAKE3"
+
+##### Performance
+- Heterogeneous: Double verification attempts for old nodes
+- Big Bang: One-time rehash cost
+
+#### Gradual Migration Pattern
+
+With heterogeneous trees, migration happens naturally:
+```
+Ledger 20,000,000: 5% BLAKE3, 95% SHA512
+Ledger 20,001,000: 30% BLAKE3, 70% SHA512  
+Ledger 20,010,000: 60% BLAKE3, 40% SHA512
+Ledger 20,100,000: 90% BLAKE3, 10% SHA512
+Eventually: ~100% BLAKE3 (dormant nodes may remain SHA-512)
+```
+
+#### Remaining Challenges
+
+1. **Context Plumbing**: Need to distinguish NEW vs OLD operations everywhere
+2. **Verification Ambiguity**: Failures could be corruption OR wrong algorithm
+3. **Testing Complexity**: Many more edge cases to test
+4. **Protocol Complexity**: Merkle proofs need algorithm information
+5. **Developer Cognitive Load**: Harder to reason about
+
+### Conclusion: Trade-offs
+
+**Heterogeneous Trees**:
+- ✅ No "big bang" transition
+- ✅ Natural, incremental migration
+- ✅ Maintains consensus (with careful implementation)
+- ❌ Permanent complexity throughout codebase
+- ❌ Ambiguous verification
+- ❌ Complex testing
+
+**Big Bang Migration**:
+- ✅ Clean, simple mental model
+- ✅ Clear algorithm boundaries
+- ✅ Easier testing and debugging
+- ❌ One-time massive performance hit
+- ❌ Requires careful coordination
+- ❌ Can't easily roll back
+
+The heterogeneous approach is **theoretically viable** but adds significant permanent complexity. Big Bang is simpler but has a painful transition. The choice depends on whether you prefer one-time pain (Big Bang) or permanent complexity (heterogeneous).
+
+## Files Modified So Far
+1. `src/ripple/protocol/digest.h` - Added hash_options struct and modified sha512Half signatures
+2. `src/ripple/protocol/impl/Indexes.cpp` - Updated indexHash and all keylet functions to accept hash_options
+3. `src/ripple/protocol/Indexes.h` - Updated all function declarations to include hash_options
+
+## Current Status
+- Core hash functions modified with backward-compatible overloads
+- All keylet functions updated to require hash_options
+- Propagating hash_options through codebase - MASSIVE undertaking
+- 91+ compilation errors remaining after fixing ~20 files
+- Every fix exposes more errors as headers propagate changes
+
+## SHAMap Node Factory Methods - Missing Ledger Context
+
+### The Problem with makeFromWire and makeFromPrefix
+These factory methods create SHAMap nodes from serialized data but **don't have ledger context**:
+
+```cpp
+// Called when receiving nodes from peers over network
+SHAMapTreeNode::makeFromWire(Slice rawNode)  
+
+// Called when loading nodes from database
+SHAMapTreeNode::makeFromPrefix(Slice rawNode, SHAMapHash const& hash)
+```
+
+These methods:
+- Parse serialized node data (from network or database)
+- Create `SHAMapInnerNode` or leaf nodes
+- Need to call `updateHash()` if hash isn't provided
+- **BUT** don't know which ledger they're building for!
+
+### Why This Is Critical
+When a node is loaded from database or received from network:
+1. The serialized data doesn't include ledger_index
+2. The node might be shared across multiple ledgers (pre-transition)
+3. After transition, we need to know if this node uses SHA-512 or BLAKE3
+4. Currently using `LEDGER_INDEX_UNKNOWN` as placeholder
+
+### Implications for P2P Protocol
+The network protocol would need changes:
+- `TMGetLedger` messages would need to specify ledger_index
+- Node responses would need hash algorithm version
+- Database storage would need to track which hash was used
+
+This reinforces why **Big Bang migration** is simpler - no protocol changes needed!
+
+## Next Steps
+1. Add hash_options{0} to all keylet call sites (using 0 as placeholder ledger_index)
+2. Get the code compiling first
+3. Later: Thread actual ledger_index values through from Views/transactions
+4. Eventually: Add Blake3 switching logic based on ledger_index threshold
+
+## Key Insight
+Every place that creates a ledger key needs to know what ledger it's operating on. This is a massive change touching:
+- All View classes
+- All transaction processors
+- All RPC handlers  
+- All tests
+- Consensus code
+
+## Compilation Strategy
+NEVER use hash_options{0} - always use proper classification from the HashContext enum in digest.h!
+
+## Quick Reference for Fixing Test Files
+
+### Essential Files to Reference
+1. **@src/ripple/protocol/digest.h** - Lines 37-107 contain the HashContext enum with ALL valid classifiers
+2. **@src/ripple/protocol/Indexes.h** - Shows all keylet function signatures that need hash_options
+
+### Keylet Function Mapping to HashContext
+When you see a keylet function, use the corresponding KEYLET_* enum value:
+```cpp
+keylet::account()        → KEYLET_ACCOUNT
+keylet::amendments()     → KEYLET_AMENDMENTS  
+keylet::book()          → KEYLET_BOOK
+keylet::check()         → KEYLET_CHECK
+keylet::child()         → KEYLET_CHILD
+keylet::depositPreauth() → KEYLET_DEPOSIT_PREAUTH
+keylet::dirPage()       → KEYLET_DIR_PAGE
+keylet::emittedDir()    → KEYLET_EMITTED_DIR
+keylet::emittedTxn()    → KEYLET_EMITTED_TXN
+keylet::escrow()        → KEYLET_ESCROW
+keylet::fees()          → KEYLET_FEES
+keylet::hook()          → KEYLET_HOOK
+keylet::hookDefinition() → KEYLET_HOOK_DEFINITION
+keylet::hookState()     → KEYLET_HOOK_STATE
+keylet::hookStateDir()  → KEYLET_HOOK_STATE_DIR
+keylet::importVLSeq()   → KEYLET_IMPORT_VLSEQ
+keylet::negativeUNL()   → KEYLET_NEGATIVE_UNL
+keylet::nftBuys()       → KEYLET_NFT_BUYS
+keylet::nftOffer()      → KEYLET_NFT_OFFER
+keylet::nftPage()       → KEYLET_NFT_PAGE
+keylet::nftSells()      → KEYLET_NFT_SELLS
+keylet::offer()         → KEYLET_OFFER
+keylet::ownerDir()      → KEYLET_OWNER_DIR
+keylet::payChan()       → KEYLET_PAYCHAN
+keylet::signers()       → KEYLET_SIGNERS
+keylet::skip()          → KEYLET_SKIP_LIST
+keylet::ticket()        → KEYLET_TICKET
+keylet::trustline()     → KEYLET_TRUSTLINE
+keylet::unchecked()     → KEYLET_UNCHECKED
+keylet::UNLReport()     → KEYLET_UNL_REPORT
+keylet::uriToken()      → KEYLET_URI_TOKEN
+```
+
+### Non-Keylet Hash Classifications
+```cpp
+sha512Half() for validator data     → VALIDATOR_LIST_HASH
+sha512Half() for hook code          → HOOK_DEFINITION or LEDGER_INDEX_UNNEEDED
+sha512Half() for signatures         → CRYPTO_SIGNATURE_HASH
+sha512Half() for network protocol   → NETWORK_HANDSHAKE_HASH
+sha512Half_s() for secure hashing   → Same rules apply
+```
+
+## Key Insights
+
+### The Scale Problem
+Every place that creates a ledger key needs to know what ledger it's operating on:
+- All View classes
+- All transaction processors (50+ files)
+- All RPC handlers (30+ files)  
+- All tests (hundreds of files)
+- Consensus code
+- Path finding code
+- Payment processing pipelines
+
+### Why This Is Hard
+1. **Cascading changes**: Fixing one header file exposes dozens of new errors
+2. **Deep call chains**: Ledger index must be threaded through multiple layers
+3. **Protocol implications**: Network messages would need to include ledger sequences
+4. **No gradual migration**: Can't mix hash algorithms - it's all or nothing
+5. **Testing nightmare**: Every test that creates mock ledger objects needs updating
+
+### The Fundamental Challenge
+The hash function is so deeply embedded in the architecture that changing it is like replacing the foundation of a building while people are living in it. This is why most blockchains never change their hash functions after launch.
+
+## Key Learnings - Where to Get ledger_index
+
+### 1. ReadView/ApplyView Classes
+- `view.seq()` returns the LedgerIndex (found in ReadView.h:193)
+- ReadView has `info()` method that returns LedgerInfo struct
+- LedgerInfo contains `seq` field which is the ledger sequence number
+- Cast to uint32_t: `static_cast<std::uint32_t>(view.seq())`
+
+### 2. Common Patterns Found
+- Functions that take `ReadView const& view` can access `view.seq()`
+- Functions that take `ApplyView& view` can also access `view.seq()` (ApplyView inherits from ReadView)
+
+### 3. Files That Need Updates
+- View.h - DONE - all 6 keylet calls updated to use view.seq()
+- Any file with keylet:: namespace calls
+- Transaction processors that create/lookup ledger objects
+
+### 4. Progress Log
+
+#### Stats (Updated: 2025-09-09)
+- Total files with keylet:: calls: 126
+- Files fixed so far: **100+** (including all core files, transaction processors, RPC handlers, and most tests)
+- Started with 7 errors, peaked at 105+ as fixes propagate through headers  
+- **Currently down to 113 errors across 11 test files** (from hundreds of files!)
+- ALL keylet function signatures updated to require hash_options
+- Pattern emerging: Every transaction processor, every RPC handler, every test needs updating
+
+#### Major Milestone Achieved
+- Successfully fixed ALL non-test source files
+- Fixed majority of test files using parallel agents
+- Demonstrated that the hash migration IS possible despite being a massive undertaking
+
+#### Major Files Fixed
+- All core ledger files (View.cpp, ApplyView.cpp, ReadView.cpp, etc.)
+- Most transaction processors (Payment, Escrow, CreateOffer, NFToken*, etc.)
+- Hook implementation files (applyHook.cpp, SetHook.cpp)
+- Infrastructure files (Transactor.cpp, BookDirs.cpp, Directory.cpp)
+
+#### Key Milestone
+- Updated ALL keylet function signatures in Indexes.h/cpp to require hash_options
+- Even functions that take pre-existing uint256 keys now require hash_options for consistency
+- This causes massive cascading compilation errors but ensures consistency
+
+#### Files Fixed So Far
+1. **View.h** - Fixed using `view.seq()`
+2. **Ledger.cpp** - Fixed using `info_.seq` in constructor, `seq()` in methods
+3. **LocalTxs.cpp** - Fixed using `view.seq()`
+4. **NegativeUNLVote.cpp** - Fixed using `prevLedger->seq()`
+5. **TxQ.cpp** - Fixed 5 calls using `view.seq()`
+6. **SkipListAcquire.cpp** - Fixed (with protocol issue on line 90)
+7. **LedgerReplayMsgHandler.cpp** - Fixed using `info.seq`
+8. **RCLValidations.cpp** - Fixed using `ledger->seq()`
+9. **Credit.cpp** - Fixed using `view.seq()`
+10. **StepChecks.h** - Fixed using `view.seq()`
+11. **BookTip.cpp** - Fixed using `view.seq()`
+12. **XRPEndpointStep.cpp** - Fixed using `ctx.view.seq()`
+13. **DirectStep.cpp** - Fixed using `sb.seq()` and `ctx.view.seq()`
+14. **BookStep.cpp** - Fixed using `afView.seq()` and `view.seq()`
+15. **CancelCheck.cpp** - Fixed using `ctx.view.seq()` and `view().seq()`
+16. **Pathfinder.cpp** - Fixed using `mLedger->seq()`
+17. More coming...
+
+#### Common Patterns Found
+- **ReadView/ApplyView**: Use `.seq()`
+- **Ledger pointer**: Use `->seq()`
+- **Transactor classes**: Use `view().seq()`
+- **PaymentSandbox**: Use `sb.seq()`
+- **StrandContext**: Use `ctx.view.seq()`
+- **LedgerInfo struct**: Use `.seq` field directly
+
+### 5. Architectural Questions
+
+#### Keylets with pre-existing keys
+- Functions like `keylet::check(uint256 const& key)` just wrap an existing key
+- They don't compute a new hash, just interpret the key as a specific ledger type
+- **Question**: Do these really need hash_options? 
+- **Current approach**: Include hash_options for consistency, might store ledger_index in Keylet for future use
+- **Note**: This could be revisited - might be unnecessary overhead for simple key wrapping
+
+### 6. Known Issues
+- SkipListAcquire.cpp line 90: Requesting skip list by hash without knowing ledger seq yet
+  - Can't know the sequence until we GET the ledger
+  - Using hash_options{0} as placeholder 
+  - Would need to refactor to fetch ledger first, THEN request skip list with proper seq
+  - Or protocol change to handle "skip list for whatever ledger this hash is"
+
+### 7. Network Protocol Has Ledger Sequence!
+
+**Critical Discovery**: The protobuf definitions show that network messages DO carry ledger sequence in many places:
+
+#### TMLedgerData (what InboundLedger::processData receives):
+```protobuf
+message TMLedgerData {
+    required bytes ledgerHash       = 1;
+    required uint32 ledgerSeq       = 2;  // <-- HAS THE SEQUENCE!
+    required TMLedgerInfoType type  = 3;
+    repeated TMLedgerNode nodes     = 4;
+}
+```
+
+#### TMGetLedger (the request):
+```protobuf
+message TMGetLedger {
+    optional uint32 ledgerSeq       = 4;  // Can request by sequence
+}
+```
+
+#### TMIndexedObject (per-object context):
+```protobuf
+message TMIndexedObject {
+    optional uint32 ledgerSeq   = 5;  // Per-object sequence!
+}
+```
+
+**Implications**:
+- The protocol already has infrastructure for ledger context
+- `InboundLedger` can use `packet.ledgerseq()` from TMLedgerData
+- Network sync might be solvable WITHOUT major protocol changes
+- The ledger sequence just needs to be threaded through to hash functions
+
+**Key Flow**:
+```cpp
+InboundLedger::processData(protocol::TMLedgerData& packet)
+    packet.ledgerseq()  // <-- Extract sequence from protocol message
+    <- SHAMap::addKnownNode(..., ledgerSeq)
+      <- SHAMapTreeNode::makeFromWire(data, ledgerSeq)
+        <- updateHash(hash_options{ledgerSeq})
+```
+
+This solves a major piece of the puzzle - the network layer CAN provide context for hash verification!
+
+### 8. Test File Patterns
+
+**Key Discovery**: Tests should use actual ledger sequences, NOT placeholders!
+
+#### Getting Ledger Sequence in Tests
+Tests typically use `test::jtx::Env` which provides access to ledger context:
+- `env.current()` - Returns a ReadView pointer
+- `env.current()->seq()` - Gets the current ledger sequence (already uint32_t)
+
+#### Common Test Patterns
+
+##### Pattern 1: Direct keylet calls
+```cpp
+// OLD
+env.le(keylet::line(alice, bob, currency));
+
+// NEW
+env.le(keylet::line(hash_options{env.current()->seq(), KEYLET_TRUSTLINE}, alice, bob, currency));
+```
+
+##### Pattern 2: Helper functions need env parameter
+```cpp
+// OLD
+static uint256 getCheckIndex(AccountID const& account, uint32_t seq) {
+    return keylet::check(account, seq).key;
+}
+// Called as: getCheckIndex(alice, seq)
+
+// NEW
+static uint256 getCheckIndex(test::jtx::Env& env, AccountID const& account, uint32_t seq) {
+    return keylet::check(hash_options{env.current()->seq(), KEYLET_CHECK}, account, seq).key;
+}
+// Called as: getCheckIndex(env, alice, seq)
+```
+
+##### Pattern 3: Fee calculations
+```cpp
+// Uses env.current() to get fee information
+XRPAmount const baseFeeDrops{env.current()->fees().base};
+```
+
+#### Test Files Status
+- **Total test files needing fixes**: ~12-15
+- **Pattern**: All test files that create or look up ledger objects need updating
+- **Common test files**:
+  - Check_test.cpp - PARTIALLY FIXED
+  - AccountDelete_test.cpp
+  - Escrow_test.cpp  
+  - NFToken_test.cpp
+  - Flow_test.cpp
+  - Import_test.cpp
+  - etc.
+
+#### Why NOT to use placeholders in tests
+- Tests verify actual ledger behavior
+- Using `hash_options{0}` would test wrong behavior after transition
+- Tests need to work both pre and post hash migration
+- `env.current()->seq()` gives the actual test ledger sequence
+
+### 6. Ways to Get Ledger Sequence
+
+#### From Application (app_):
+- `app_.getLedgerMaster()` gives you LedgerMaster
+
+#### From LedgerMaster:
+- `getLedgerByHash(hash)` - Get ledger by hash, then call `->seq()` on it
+- `getLedgerBySeq(index)` - Get ledger by sequence directly
+- `getCurrentLedger()` - Current open ledger, call `->seq()`
+- `getClosedLedger()` - Last closed ledger, call `->seq()`
+- `getValidatedLedger()` - Last validated ledger, call `->seq()`
+- `getPublishedLedger()` - Last published ledger, call `->seq()`
+- `getCurrentLedgerIndex()` - Direct sequence number
+- `getValidLedgerIndex()` - Direct sequence number
+- `walkHashBySeq()` - Walk ledger chain to find hash by sequence
+
+#### From Ledger object:
+- `ledger->seq()` - Direct method
+- `ledger->info().seq` - Through LedgerInfo
+
+#### From ReadView/OpenView/ApplyView:
+- `view.seq()` - All views have this method
+- `view.info().seq` - Through LedgerInfo
+
+#### Special Case - SkipListAcquire:
+- Line 67: `app_.getLedgerMaster().getLedgerByHash(hash_)` 
+- If ledger exists locally, we get it and can use its seq()
+- If not, we're requesting it from peers - don't know seq yet!

LAST_TESTAMENT.md

@@ -0,0 +1,108 @@
+# Last Testament: SHA-512 to BLAKE3 Migration Deep Dive
+
+## The Journey
+Started with "just change the hash function" - ended up discovering why hash functions are permanent blockchain decisions.
+
+## Key Discoveries
+
+### 1. Ledger Implementation Added
+- `Ledger::shouldMigrateToBlake3()` - checks migration window/flags
+- `Ledger::migrateToBlake3()` - placeholder for actual migration
+- Hook in `BuildLedger.cpp` after transaction processing
+- Migration happens OUTSIDE transaction pipeline to avoid metadata explosion
+
+### 2. The Rekeying Nightmare (REKEYING_ISSUES.md)
+Every object key changes SHA512→BLAKE3, but keys are EVERYWHERE:
+- **DirectoryNode.sfIndexes** - vectors of keys
+- **sfPreviousTxnID, sfIndexNext, sfIndexPrevious** - direct key refs  
+- **Order books** - sorted by key value (order changes!)
+- **Hook state** - arbitrary blobs with embedded keys
+- **620k objects** with millions of interconnected references
+
+### 3. The LUT Approach
+```cpp
+// Build lookup table: old_key → new_key (40MB for 620k entries)
+// O(n) to build, O(n×m) to update all fields
+// Must check EVERY uint256 field in EVERY object
+```
+**Problems:**
+- LUT check on EVERY lookup forever (performance tax)
+- Can't know if key is old/new without checking
+- Might need bidirectional LUT (80MB)
+- Can NEVER remove it (WASM has hardcoded keys!)
+
+### 4. The WASM Hook Bomb
+Hook code can hardcode keys in compiled WASM:
+- Can't modify without changing hook hash
+- Changing hash breaks all references to hook
+- Literally unfixable without breaking hooks
+
+### 5. MapStats Enhancement
+Added ledger entry type tracking:
+- Count, total bytes, avg size per type
+- Uses `LedgerFormats::getInstance().findByType()` for names
+- Shows 124k HookState entries (potential key references!)
+
+### 6. Current Ledger Stats
+- 620k total objects, 98MB total
+- 117k DirectoryNodes (full of references)
+- 124k HookState entries (arbitrary data)
+- 80 HookDefinitions (WASM code)
+- Millions of internal key references
+
+## Why It's Impossible
+
+### The Lookup Problem
+```cpp
+auto key = keylet::account(Alice).key;
+// Which hash function? SHA512 or BLAKE3?
+// NO WAY TO KNOW without timestamp/LUT/double-lookup
+```
+
+### The Fundamental Issues
+1. **No key timestamp** - Can't tell if key is pre/post migration
+2. **Embedded references everywhere** - sfIndexes, hook state, WASM code
+3. **Permanent LUT required** - Check on every operation forever
+4. **Performance death** - 2x lookups or LUT check on everything
+5. **Dual-key SHAMap impossible** - Breaks ordering/structure
+
+### The "Solutions" That Don't Work
+- **Lazy migration**: LUT forever, complexity forever
+- **Big bang**: Still need permanent LUT for old references  
+- **Heterogeneous tree**: Can't mix hash functions in Merkle tree
+- **Binary search-replace**: Could corrupt data, no validation
+- **Import to v2 chain**: Same reference update problems
+
+## The Verdict
+
+After threading ledger_index through 1000+ functions for hash context, the migration faces insurmountable challenges:
+
+1. **WASM hooks** contain unfixable hardcoded keys
+2. **Every lookup** needs LUT check forever (performance tax)
+3. **Can't determine key age** from identifier alone
+4. **Millions of references** need perfect updating
+5. **One mistake** = corrupted ledger, lost funds
+
+**Conclusion**: This is a "v2 blockchain" problem, not a migration problem. SHA-512 is forever.
+
+## Lessons Learned
+
+- Hash functions are THE fundamental addressing system
+- Deeper than consensus, deeper than data structures
+- Once chosen, essentially permanent
+- The attempt revealed the true complexity of blockchain internals
+- Even 98MB of data has millions of interconnected references
+- WASM hooks make any migration effectively impossible
+
+**Final Status**: Technically possible with permanent LUT and massive complexity. Practically impossible due to hooks, performance, and risk. SHA-512 until heat death of universe.
+
+## Code Artifacts
+
+- Hash classification system in `digest.h`
+- `hash_options` threaded through Indexes/keylets
+- Ledger migration methods (placeholder)
+- MapStats with entry type breakdown
+- REKEYING_ISSUES.md with full analysis
+- 100+ files modified to thread ledger context
+
+The migration died not from lack of effort, but from the discovery that some architectural decisions are truly permanent.

LEDGER_INDEX_PREVIOUS.md

@@ -0,0 +1,71 @@
+Yes! You’re onto something quite elegant there. Let me break it down:
+
+---
+
+### 🔑 LedgerEntry “PriorKey” field
+
+If each SLE carried an **optional `LedgerIndexPriorSha512`** (or whatever name), then:
+
+* When you rekey at cutover, you don’t lose continuity.
+* Anyone walking the ledger can trivially build the old→new LUT on the fly.
+* For “day-to-day” operations, the node only needs the canonical keys.
+
+This basically lets you say:
+
+* **Canonical view** = new Blake3 keys.
+* **Continuity view** = traverse new keys, but if you need to resolve old references, follow the `LedgerIndexPriorSha512` link.
+
+---
+
+### 📊 For analysis and data science
+
+You can now reconstruct historical continuity without keeping a giant external LUT file. Just walk the ledger and collect `(old, new)` pairs from the entries.
+
+This means explorers, forensic tools, compliance, etc. can:
+
+* Map old keys to new at any point.
+* Handle partially migrated networks (some ledgers pre-cutover, some post).
+
+---
+
+### 🟢 Operational benefits
+
+* Validators don’t need to bloat memory with a global LUT — it’s **distributed inside the ledger itself**.
+* New ledgers “just work” for CRUD.
+* Old references (hooks, weird integrations) can be handled until people migrate.
+
+---
+
+### ⚠️ Caveats
+
+1. **Storage overhead**: each SLE gets \~32 bytes extra. But given only \~600k objects in the state tree, that’s trivial compared to the win.
+2. **Hardcoded keys in hooks/wasm**: still a landmine — if someone has *literally baked in* the old canonical key, they’ll need the LUT or breakage handling at ApplyView.
+3. **Consensus rules**: adding this field changes serialization — so it’s an amendment, not just an operator convenience.
+
+---
+
+### 🔄 Proposal workflow
+
+1. Cutover ledger → during bookkeeping, every object is rekeyed into the new canonical tree.
+2. At the same time, each new object gets `LedgerIndexPriorSha512 = old_key`.
+3. From then on, **every ledger post-cutover contains the LUT implicitly**.
+4. After some deprecation period, once nobody references `LedgerIndexPriorSha512`, you can prune support.
+
+---
+
+So in practice:
+
+* **Validators** only care about the canonical map.
+* **Explorers, auditors, backward-compat systems** can lazily reconstruct the LUT.
+* You don’t poison `succ()` or iteration with mixed domains.
+
+---
+
+This actually solves both your goals:
+
+* Day-to-day simplicity (Blake-only canonical).
+* Historical continuity (walk the field if you need).
+
+---
+
+Want me to sketch how `ReadView::read(Keylet)` could transparently try `LUT` lookups only if the canonical miss happens, using that new field? That would make it zero-effort for old call sites.

REKEYING_ISSUES.md

@@ -0,0 +1,332 @@
+# Hash Migration Rekeying Issues
+
+## The Fundamental Problem
+
+When migrating from SHA-512 Half to BLAKE3, we're not just changing a hash function - we're changing the **keys** that identify every object in the ledger's state map. Since the hash IS the key in the SHAMap, every object needs a new address.
+
+## What Needs to be Rekeyed
+
+### 1. Primary Ledger Objects
+Every SLE (STLedgerEntry) in the state map has its key computed from:
+- Its type (Account, Offer, RippleState, etc.)
+- Its identifying data (AccountID, offer sequence, etc.)
+
+When we change the hash function, EVERY object gets a new key.
+
+### 2. Directory Structures
+Directories are ledger objects that contain **lists of other objects' keys**:
+
+#### Owner Directories (`keylet::ownerDir`)
+- Contains keys of all objects owned by an account
+- Every offer, escrow, check, payment channel, etc. key stored here
+- When those objects are rekeyed, ALL these references must be updated
+
+#### Order Book Directories (`keylet::book`, `keylet::quality`)
+- Contains keys of offers at specific quality levels
+- All offer keys must be updated to their new BLAKE3 values
+
+#### NFT Directories (`keylet::nft_buys`, `keylet::nft_sells`)
+- Contains keys of NFT offers
+- All NFT offer keys must be updated
+
+#### Hook State Directories (`keylet::hookStateDir`)
+- Contains keys of hook state entries
+- All hook state keys must be updated
+
+### 3. Cross-References Between Objects
+Many objects contain direct references to other objects:
+
+#### Account Objects
+- `sfNFTokenPage` - References to NFT page keys
+- Previous/Next links in directory pages
+
+#### Directory Pages
+- `sfIndexes` - Vector of object keys
+- `sfPreviousTxnID` - Transaction hash references
+- `sfIndexPrevious`/`sfIndexNext` - Links to other directory pages
+
+#### NFT Pages
+- References to previous/next pages in the chain
+
+## The Cascade Effect
+
+Re-keying isn't a simple one-pass operation:
+
+```
+1. Rekey Account A (SHA512 → BLAKE3)
+   ↓
+2. Update Account A's owner directory
+   ↓
+3. Rekey the owner directory itself
+   ↓
+4. Update all objects IN the directory with new keys
+   ↓
+5. Update any directories THOSE objects appear in
+   ↓
+6. Continue cascading...
+```
+
+## Implementation Challenges
+
+### Challenge 1: Directory Entry Updates
+```cpp
+// Current directory structure
+STVector256 indexes = directory->getFieldV256(sfIndexes);
+// Contains: [sha512_key1, sha512_key2, sha512_key3, ...]
+
+// After migration needs to be:
+// [blake3_key1, blake3_key2, blake3_key3, ...]
+```
+
+### Challenge 2: Finding All References
+There's no reverse index - given an object's key, you can't easily find all directories that reference it. You'd need to:
+1. Walk the entire state map
+2. Check every directory's `sfIndexes` field
+3. Update any matching keys
+
+### Challenge 3: Maintaining Consistency
+During migration, you need to ensure:
+- No orphaned references (keys pointing to non-existent objects)
+- No duplicate entries
+- Proper ordering in sorted structures (offer books)
+
+### Challenge 4: Page Links
+Directory pages link to each other:
+```cpp
+uint256 prevPage = dir->getFieldU256(sfIndexPrevious);
+uint256 nextPage = dir->getFieldU256(sfIndexNext);
+```
+These links are also keys that need updating!
+
+## Why This Makes Migration Complex
+
+### Option A: Big Bang Migration
+- Must update EVERYTHING atomically
+- Need to track old→new key mappings for entire ledger
+- Memory requirements: ~2x the state size for mapping table
+- Risk: Any missed reference breaks the ledger
+
+### Option B: Heterogeneous Tree
+- Old nodes keep SHA-512 keys
+- New/modified nodes use BLAKE3
+- Problem: How do you know which hash to use for lookups?
+- Problem: Directory contains mix of old and new keys?
+
+### Option C: Double Storage
+- Store objects under BOTH keys temporarily
+- Gradually migrate references
+- Problem: Massive storage overhead
+- Problem: Synchronization between copies
+
+## Example: Rekeying an Offer
+
+Consider rekeying a single offer:
+
+1. **The Offer Itself**
+   - Old key: `sha512Half(OFFER, account, sequence)`
+   - New key: `blake3(OFFER, account, sequence)`
+
+2. **Owner Directory**
+   - Must update `sfIndexes` to replace old offer key with new
+
+3. **Order Book Directory**
+   - Must update `sfIndexes` in the quality directory
+   - May need to update multiple quality levels if offer moved
+
+4. **Account Object**
+   - Update offer count/reserve tracking if needed
+
+5. **The Directories Themselves**
+   - Owner directory key: `sha512Half(OWNER_DIR, account, page)`
+   - New key: `blake3(OWNER_DIR, account, page)`
+   - Order book key: `sha512Half(BOOK_DIR, ...)`
+   - New key: `blake3(BOOK_DIR, ...)`
+
+## Potential Solutions
+
+### 1. Migration Ledger Object
+Create a temporary "migration map" ledger object:
+```cpp
+sfOldKey → sfNewKey mappings
+```
+But this could be gigabytes for millions of objects.
+
+### 2. Deterministic Rekeying
+Since we can determine an object's type from its `LedgerEntryType`, we could:
+1. Load each SLE
+2. Determine its type
+3. Recompute its key with BLAKE3
+4. Track the mapping
+
+But we still need to update all references.
+
+### 3. Lazy Migration
+Only rekey objects when they're modified:
+- Pro: Spreads migration over time
+- Con: Permanent complexity in codebase
+- Con: Must support both hash types forever
+
+### 4. New State Structure
+Instead of migrating in-place, build an entirely new state map:
+1. Create new empty BLAKE3 SHAMap
+2. Walk old map, inserting with new keys
+3. Update all references during copy
+4. Atomically swap maps
+
+This is essentially what BUILD_LEDGER.md suggests, but the reference updating remains complex.
+
+## The Lookup Table Approach
+
+After further analysis, a lookup table (LUT) based approach might actually be feasible:
+
+### Algorithm Overview
+
+#### Phase 1: Build the LUT (O(n))
+```cpp
+std::unordered_map<uint256, uint256> old_to_new;
+
+stateMap_.visitLeaves([&](SHAMapItem const& item) {
+    SerialIter sit(item.slice());
+    auto sle = std::make_shared<SLE>(sit, item.key());
+    
+    // Determine type from the SLE
+    LedgerEntryType type = sle->getType();
+    
+    // Recompute key with BLAKE3 based on type
+    uint256 newKey = computeBlake3Key(sle, type);
+    old_to_new[item.key()] = newKey;
+});
+// Results in ~620k entries in the LUT
+```
+
+#### Phase 2: Update ALL uint256 Fields (O(n × m))
+Walk every object and check every uint256 field against the LUT:
+
+```cpp
+stateMap_.visitLeaves([&](SHAMapItem& item) {
+    SerialIter sit(item.slice());
+    auto sle = std::make_shared<SLE>(sit, item.key());
+    bool modified = false;
+    
+    // Check every possible uint256 field
+    modified |= updateField(sle, sfPreviousTxnID, old_to_new);
+    modified |= updateField(sle, sfIndexPrevious, old_to_new);
+    modified |= updateField(sle, sfIndexNext, old_to_new);
+    modified |= updateField(sle, sfBookNode, old_to_new);
+    
+    // Vector fields
+    modified |= updateVector(sle, sfIndexes, old_to_new);
+    modified |= updateVector(sle, sfHashes, old_to_new);
+    modified |= updateVector(sle, sfAmendments, old_to_new);
+    modified |= updateVector(sle, sfNFTokenOffers, old_to_new);
+    
+    if (modified) {
+        // Re-serialize with updated references
+        Serializer s;
+        sle->add(s);
+        // Create new item with new key
+        item = make_shamapitem(old_to_new[item.key()], s.slice());
+    }
+});
+```
+
+### Complexity Analysis
+- **Phase 1**: O(n) where n = number of objects (~620k)
+- **Phase 2**: O(n × m) where m = average fields per object
+- **Hash lookups**: O(1) average case
+- **Total**: Linear in the number of objects!
+
+### Memory Requirements
+- LUT size: 620k entries × (32 bytes + 32 bytes) = ~40 MB
+- Reasonable to keep in memory during migration
+
+### Implementation Challenges
+
+#### 1. Comprehensive Field Coverage
+Must check EVERY field that could contain a key:
+```cpp
+// Singleton uint256 fields
+sfPreviousTxnID, sfIndexPrevious, sfIndexNext, sfBookNode,
+sfNFTokenID, sfEmitParentTxnID, sfHookOn, sfHookStateKey...
+
+// Vector256 fields  
+sfIndexes, sfHashes, sfAmendments, sfNFTokenOffers,
+sfHookNamespaces, sfURITokenIDs...
+
+// Nested structures
+STArray fields containing STObjects with uint256 fields
+```
+
+#### 2. False Positive Risk
+Any uint256 that happens to match a key would be updated:
+- Could corrupt data if a non-key field matches
+- Mitigation: Only update known reference fields
+- Risk: Missing custom fields added by hooks
+
+#### 3. Order Book Sorting
+Order books are sorted by key value. After rekeying:
+- Sort order changes completely
+- Need to rebuild book directories
+- Quality levels might shift
+
+### Alternative: Persistent Migration Map
+
+Instead of one-time migration, store the mapping permanently:
+
+```cpp
+// Special ledger entries (one per ~1000 mappings)
+MigrationMap_0000: {
+    sfOldKeys: [old_hash_0, old_hash_1, ...],
+    sfNewKeys: [new_hash_0, new_hash_1, ...]
+}
+MigrationMap_0001: { ... }
+// ~620 of these objects
+```
+
+Pros:
+- Can verify historical references
+- Debugging is easier
+- Can be pruned later if needed
+
+Cons:
+- Permanent state bloat (~40MB)
+- Must be loaded on every node forever
+- Lookup overhead for historical operations
+
+### The Nuclear Option: Binary Search-Replace
+
+For maximum chaos (don't actually do this):
+```cpp
+// Build LUT
+std::map<std::array<uint8_t, 32>, std::array<uint8_t, 32>> binary_lut;
+
+// Scan serialized blobs and replace
+for (auto& node : shamap) {
+    auto data = node.getData();
+    for (size_t i = 0; i <= data.size() - 32; i++) {
+        if (binary_lut.count(data[i..i+31])) {
+            memcpy(&data[i], binary_lut[data[i..i+31]], 32);
+        }
+    }
+}
+```
+
+Why this is insane:
+- False positives would corrupt data
+- No validation of what you're replacing
+- Breaks all checksums and signatures
+- Impossible to debug when it goes wrong
+
+## Conclusion
+
+The rekeying problem is not just about changing hash functions - it's about maintaining referential integrity across millions of interlinked objects. Every key change cascades through the reference graph, making this one of the most complex migrations possible in a blockchain system.
+
+The lookup table approach makes it algorithmically feasible (linear time rather than quadratic), but the implementation complexity and risk remain enormous. You need to:
+1. Find every single field that could contain a key
+2. Update them all correctly
+3. Handle sorting changes in order books
+4. Avoid false positives
+5. Deal with custom fields from hooks
+6. Maintain consistency across the entire state
+
+This is likely why most blockchains never change their hash functions after genesis - even with an efficient algorithm, the complexity and risk are enormous.

RELEASENOTES.md

@@ -7,129 +7,6 @@ This document contains the release notes for `rippled`, the reference server imp
  
 Have new ideas? Need help with setting up your node? [Please open an issue here](https://github.com/xrplf/rippled/issues/new/choose).
 
-# Introducing XRP Ledger version 1.12.0
-
-Version 1.12.0 of `rippled`, the reference server implementation of the XRP Ledger protocol, is now available. This release adds new features and bug fixes, and introduces these amendments:
-
-- `AMM`
-- `Clawback`
-- `fixReducedOffersV1`
-
-[Sign Up for Future Release Announcements](https://groups.google.com/g/ripple-server)
-
-<!-- BREAK -->
-
-## Action Required
-
-Three new amendments are now open for voting according to the XRP Ledger's [amendment process](https://xrpl.org/amendments.html), which enables protocol changes following two weeks of >80% support from trusted validators.
-
-If you operate an XRP Ledger server, upgrade to version 1.12.0 by September 20, 2023 to ensure service continuity. The exact time that protocol changes take effect depends on the voting decisions of the decentralized network.
-
-
-## Install / Upgrade
-
-On supported platforms, see the [instructions on installing or updating `rippled`](https://xrpl.org/install-rippled.html).
-
-The XRPL Foundation publishes portable binaries, which are drop-in replacements for the `rippled` daemon. [See information and downloads for the portable binaries](https://github.com/XRPLF/rippled-portable-builds#portable-builds-of-the-rippled-server). This will work on most distributions, including Ubuntu 16.04, 18.04, 20.04, and 22.04; CentOS; and others. Please test and open issues on GitHub if there are problems.
-
-
-## Changelog
-
-### Amendments, New Features, and Changes
-(These are changes which may impact or be useful to end users. For example, you may be able to update your code/workflow to take advantage of these changes.)
-
-- **`AMM`**: Introduces an automated market maker (AMM) protocol to the XRP Ledger's decentralized exchange, enabling you to trade assets without a counterparty. For more information about AMMs, see: [Automated Market Maker](https://opensource.ripple.com/docs/xls-30d-amm/amm-uc/). [#4294](https://github.com/XRPLF/rippled/pull/4294)
-
-- **`Clawback`**: Adds a setting, *Allow Clawback*, which lets an issuer recover, or _claw back_, tokens that they previously issued. Issuers cannot enable this setting if they have issued tokens already. For additional documentation on this feature, see: [#4553](https://github.com/XRPLF/rippled/pull/4553).
-
-- **`fixReducedOffersV1`**: Reduces the occurrence of order books that are blocked by reduced offers. [#4512](https://github.com/XRPLF/rippled/pull/4512)
-
-- Added WebSocket and RPC port info to `server_info` responses. [#4427](https://github.com/XRPLF/rippled/pull/4427)
-
-- Removed the deprecated `accepted`, `seqNum`, `hash`, and `totalCoins` fields from the `ledger` method. [#4244](https://github.com/XRPLF/rippled/pull/4244)
-
-
-### Bug Fixes and Performance Improvements
-(These are behind-the-scenes improvements, such as internal changes to the code, which are not expected to impact end users.)
-
-- Added a pre-commit hook that runs the clang-format linter locally before committing changes. To install this feature, see: [CONTRIBUTING](https://github.com/XRPLF/xrpl-dev-portal/blob/master/CONTRIBUTING.md). [#4599](https://github.com/XRPLF/rippled/pull/4599)
-
-- In order to make it more straightforward to catch and handle overflows: changed the output type of the `mulDiv()` function from `std::pair<bool, uint64_t>` to `std::optional`. [#4243](https://github.com/XRPLF/rippled/pull/4243)
-
-- Updated `Handler::Condition` enum values to make the code less brittle. [#4239](https://github.com/XRPLF/rippled/pull/4239)
-
-- Renamed `ServerHandlerImp` to `ServerHandler`. [#4516](https://github.com/XRPLF/rippled/pull/4516), [#4592](https://github.com/XRPLF/rippled/pull/4592)
-
-- Replaced hand-rolled code with `std::from_chars` for better maintainability. [#4473](https://github.com/XRPLF/rippled/pull/4473)
-
-- Removed an unused `TypedField` move constructor. [#4567](https://github.com/XRPLF/rippled/pull/4567)
-
-
-### Docs and Build System
-
-- Updated checkout versions to resolve warnings during GitHub jobs. [#4598](https://github.com/XRPLF/rippled/pull/4598)
-
-- Fixed an issue with the Debian package build. [#4591](https://github.com/XRPLF/rippled/pull/4591)
-
-- Updated build instructions with additional steps to take after updating dependencies. [#4623](https://github.com/XRPLF/rippled/pull/4623)
-
-- Updated contributing doc to clarify that beta releases should also be pushed to the `release` branch. [#4589](https://github.com/XRPLF/rippled/pull/4589)
-
-- Enabled the `BETA_RPC_API` flag in the default unit tests config, making the API v2 (beta) available to unit tests. [#4573](https://github.com/XRPLF/rippled/pull/4573)
-
-- Conan dependency management.
-  - Fixed package definitions for Conan. [#4485](https://github.com/XRPLF/rippled/pull/4485)
-  - Updated build dependencies to the most recent versions in Conan Center. [#4595](https://github.com/XRPLF/rippled/pull/4595)
-  - Updated Conan recipe for NuDB. [#4615](https://github.com/XRPLF/rippled/pull/4615)
-
-- Added binary hardening and linker flags to enhance security during the build process. [#4603](https://github.com/XRPLF/rippled/pull/4603)
-
-- Added an Artifactory to the `nix` workflow to improve build times. [#4556](https://github.com/XRPLF/rippled/pull/4556)
-
-- Added quality-of-life improvements to workflows, using new [concurrency control](https://docs.github.com/en/actions/using-jobs/using-concurrency) features. [#4597](https://github.com/XRPLF/rippled/pull/4597)
-
-
-[Full Commit Log](https://github.com/XRPLF/rippled/compare/1.11.0...1.12.0)
-
-
-### GitHub
-
-The public source code repository for `rippled` is hosted on GitHub at <https://github.com/XRPLF/rippled>.
-
-We welcome all contributions and invite everyone to join the community of XRP Ledger developers to help build the Internet of Value.
-
-
-## Credits
-
-The following people contributed directly to this release:
-
-- Alphonse N. Mousse <39067955+a-noni-mousse@users.noreply.github.com>
-- Arihant Kothari <arihantkothari17@gmail.com>
-- Chenna Keshava B S <21219765+ckeshava@users.noreply.github.com>
-- Denis Angell <dangell@transia.co>
-- Ed Hennis <ed@ripple.com>
-- Elliot Lee <github.public@intelliot.com>
-- Gregory Tsipenyuk <gregtatcam@users.noreply.github.com>
-- Howard Hinnant <howard.hinnant@gmail.com>
-- Ikko Eltociear Ashimine <eltociear@gmail.com>
-- John Freeman <jfreeman08@gmail.com>
-- Manoj Doshi <mdoshi@ripple.com>
-- Mark Travis <mtravis@ripple.com>
-- Mayukha Vadari <mvadari@gmail.com>
-- Michael Legleux <legleux@users.noreply.github.com>
-- Peter Chen <34582813+PeterChen13579@users.noreply.github.com>
-- RichardAH <richard.holland@starstone.co.nz>
-- Rome Reginelli <rome@ripple.com>
-- Scott Schurr <scott@ripple.com>
-- Shawn Xie <35279399+shawnxie999@users.noreply.github.com>
-- drlongle <drlongle@gmail.com>
-
-Bug Bounties and Responsible Disclosures:
-
-We welcome reviews of the rippled code and urge researchers to responsibly disclose any issues they may find.
-
-To report a bug, please send a detailed report to: <bugs@xrpl.org>
-
 
 # Introducing XRP Ledger version 1.11.0
 

TEST_FILES_TO_FIX.md

@@ -0,0 +1,179 @@
+# Test Files That Need hash_options Fixes
+
+## How to Check Compilation Errors
+
+Use the `compile_single_v2.py` script to check individual files:
+```bash
+# Check compilation errors for a specific file
+./compile_single_v2.py src/test/app/SomeFile_test.cpp -e 3 --errors-only
+
+# Get just the last few lines to see if it compiled successfully
+./compile_single_v2.py src/test/app/SomeFile_test.cpp 2>&1 | tail -5
+```
+
+## Originally Fixed Files (11 files)
+
+1. **src/test/app/Import_test.cpp**
+   - Status: Needs fixing
+   - Errors: keylet functions missing hash_options
+
+2. **src/test/app/LedgerReplay_test.cpp**
+   - Status: Needs fixing
+   - Errors: keylet functions missing hash_options
+
+3. **src/test/app/Offer_test.cpp**
+   - Status: Needs fixing
+   - Errors: keylet functions missing hash_options
+
+4. **src/test/app/SetHook_test.cpp**
+   - Status: Needs fixing
+   - Errors: keylet functions missing hash_options
+
+5. **src/test/app/SetHookTSH_test.cpp**
+   - Status: Needs fixing
+   - Errors: keylet functions missing hash_options
+
+6. **src/test/app/ValidatorList_test.cpp**
+   - Status: Needs fixing
+   - Errors: keylet functions missing hash_options
+
+7. **src/test/app/XahauGenesis_test.cpp**
+   - Status: Needs fixing
+   - Errors: keylet functions missing hash_options, keylet::fees() needs hash_options
+
+8. **src/test/consensus/NegativeUNL_test.cpp**
+   - Status: Needs fixing
+   - Errors: keylet functions missing hash_options
+
+9. **src/test/consensus/UNLReport_test.cpp**
+   - Status: Needs fixing
+   - Errors: keylet functions missing hash_options
+
+10. **src/test/jtx/impl/balance.cpp**
+    - Status: Needs fixing
+    - Errors: keylet functions missing hash_options
+
+11. **src/test/jtx/impl/Env.cpp**
+    - Status: Needs fixing
+    - Errors: keylet functions missing hash_options
+
+## Fix Strategy
+
+Each file needs:
+1. keylet function calls updated to include hash_options{ledger_seq, classifier}
+2. The ledger_seq typically comes from env.current()->seq() or view.seq()
+3. The classifier matches the keylet type (e.g., KEYLET_ACCOUNT, KEYLET_FEES, etc.)
+
+## Progress Tracking
+
+- [x] Import_test.cpp - FIXED
+- [x] LedgerReplay_test.cpp - FIXED
+- [x] Offer_test.cpp - FIXED
+- [x] SetHook_test.cpp - FIXED
+- [x] SetHookTSH_test.cpp - FIXED
+- [x] ValidatorList_test.cpp - FIXED (sha512Half calls updated with VALIDATOR_LIST_HASH classifier)
+- [x] XahauGenesis_test.cpp - FIXED (removed duplicate hash_options parameters)
+- [x] NegativeUNL_test.cpp - FIXED
+- [x] UNLReport_test.cpp - FIXED
+- [x] balance.cpp - FIXED
+- [x] Env.cpp - FIXED
+
+## All original 11 files have been successfully fixed!
+
+## Remaining Files Still Needing Fixes (9 files)
+
+### Status: NOT STARTED
+These files still have compilation errors and need hash_options fixes:
+
+1. **src/test/jtx/impl/uritoken.cpp**
+   - Status: Needs fixing
+   - Check errors: `./compile_single_v2.py src/test/jtx/impl/uritoken.cpp -e 3 --errors-only`
+
+2. **src/test/jtx/impl/utility.cpp**
+   - Status: Needs fixing
+   - Check errors: `./compile_single_v2.py src/test/jtx/impl/utility.cpp -e 3 --errors-only`
+
+3. **src/test/ledger/Directory_test.cpp**
+   - Status: Needs fixing
+   - Check errors: `./compile_single_v2.py src/test/ledger/Directory_test.cpp -e 3 --errors-only`
+
+4. **src/test/ledger/Invariants_test.cpp**
+   - Status: Needs fixing
+   - Check errors: `./compile_single_v2.py src/test/ledger/Invariants_test.cpp -e 3 --errors-only`
+
+5. **src/test/overlay/compression_test.cpp**
+   - Status: Needs fixing
+   - Check errors: `./compile_single_v2.py src/test/overlay/compression_test.cpp -e 3 --errors-only`
+
+6. **src/test/rpc/AccountSet_test.cpp**
+   - Status: Needs fixing
+   - Check errors: `./compile_single_v2.py src/test/rpc/AccountSet_test.cpp -e 3 --errors-only`
+
+7. **src/test/rpc/AccountTx_test.cpp**
+   - Status: Needs fixing
+   - Check errors: `./compile_single_v2.py src/test/rpc/AccountTx_test.cpp -e 3 --errors-only`
+
+8. **src/test/rpc/Book_test.cpp**
+   - Status: Needs fixing
+   - Check errors: `./compile_single_v2.py src/test/rpc/Book_test.cpp -e 3 --errors-only`
+
+9. **src/test/rpc/Catalogue_test.cpp**
+   - Status: Needs fixing
+   - Check errors: `./compile_single_v2.py src/test/rpc/Catalogue_test.cpp -e 3 --errors-only`
+
+## CRITICAL INSTRUCTIONS FOR FIXING
+
+### 1. Read the HashContext enum from digest.h
+**ALWAYS** check @src/ripple/protocol/digest.h lines 37-107 for the complete HashContext enum.
+This enum defines ALL the valid classifiers you can use in hash_options.
+
+### 2. Understanding hash_options constructor
+The hash_options struct (lines 110-126 in digest.h) has TWO constructors:
+- `hash_options(HashContext ctx)` - classifier only, no ledger index
+- `hash_options(std::uint32_t li, HashContext ctx)` - ledger index AND classifier
+
+### 3. How to classify each hash operation
+
+#### For keylet functions:
+- Match the keylet function name to the KEYLET_* enum value
+- Examples:
+  - `keylet::account()` → use `KEYLET_ACCOUNT`
+  - `keylet::fees()` → use `KEYLET_FEES`
+  - `keylet::trustline()` → use `KEYLET_TRUSTLINE`
+  - `keylet::negativeUNL()` → use `KEYLET_NEGATIVE_UNL`
+  - `keylet::UNLReport()` → use `KEYLET_UNL_REPORT`
+  - `keylet::hook()` → use `KEYLET_HOOK`
+  - `keylet::uriToken()` → use `KEYLET_URI_TOKEN`
+
+#### For sha512Half calls:
+- Validator manifests/lists → use `VALIDATOR_LIST_HASH`
+- Hook code hashing → use `HOOK_DEFINITION` or `LEDGER_INDEX_UNNEEDED`
+- Network protocol → use appropriate context from enum
+
+#### For test environments:
+- Use `env.current()->seq()` to get ledger sequence (it's already uint32_t, NO CAST NEEDED)
+- Use `ledger->seq()` for Ledger pointers
+- Use `view.seq()` for ReadView/ApplyView references
+
+### 4. IMPORTANT: Read the entire file first!
+When fixing a file, ALWAYS:
+1. Read the ENTIRE file first (or at least 500+ lines) to understand the context
+2. Look for patterns of how the test is structured
+3. Check what types of ledger objects are being tested
+4. Then fix ALL occurrences systematically
+
+### 5. Common patterns to fix:
+
+```cpp
+// OLD - missing hash_options
+env.le(keylet::account(alice));
+
+// NEW - with proper classification  
+env.le(keylet::account(hash_options{env.current()->seq(), KEYLET_ACCOUNT}, alice));
+
+// OLD - sha512Half without context
+auto hash = sha512Half(data);
+
+// NEW - with proper classification
+auto hash = sha512Half(hash_options{VALIDATOR_LIST_HASH}, data);
+```

analyze_keylet_calls.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+
+import re
+import os
+from pathlib import Path
+from collections import defaultdict
+from typing import Set, Dict, List, Tuple
+
+def find_keylet_calls(root_dir: str) -> Dict[str, List[Tuple[str, int, str]]]:
+    """
+    Find all keylet:: function calls with hash_options as first parameter.
+    Returns a dict mapping keylet function names to list of (file, line, full_match) tuples.
+    """
+    # Pattern to match keylet::<function>(hash_options{...}, ...) calls
+    # This captures:
+    # 1. The keylet function name
+    # 2. The entire first argument (hash_options{...})
+    # 3. The content inside hash_options{...}
+    pattern = re.compile(
+        r'keylet::(\w+)\s*\(\s*(hash_options\s*\{([^}]*)\})',
+        re.MULTILINE | re.DOTALL
+    )
+    
+    results = defaultdict(list)
+    unique_first_args = set()
+    
+    # Walk through all C++ source files
+    for root, dirs, files in os.walk(Path(root_dir) / "src" / "ripple"):
+        # Skip certain directories
+        dirs[:] = [d for d in dirs if d not in ['.git', 'build', '__pycache__']]
+        
+        for file in files:
+            if file.endswith(('.cpp', '.h', '.hpp')):
+                filepath = os.path.join(root, file)
+                try:
+                    with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+                        content = f.read()
+                        
+                    # Find all matches in this file
+                    for match in pattern.finditer(content):
+                        func_name = match.group(1)
+                        full_first_arg = match.group(2)
+                        inner_content = match.group(3).strip()
+                        
+                        # Get line number
+                        line_num = content[:match.start()].count('\n') + 1
+                        
+                        # Store the result
+                        rel_path = os.path.relpath(filepath, root_dir)
+                        results[func_name].append((rel_path, line_num, full_first_arg))
+                        unique_first_args.add(inner_content)
+                        
+                except Exception as e:
+                    print(f"Error reading {filepath}: {e}")
+    
+    return results, unique_first_args
+
+def analyze_hash_options_content(unique_args: Set[str]) -> Dict[str, int]:
+    """Analyze the content of hash_options{...} arguments."""
+    categories = {
+        'literal_0': 0,
+        'literal_number': 0,
+        'view_seq': 0,
+        'ledger_seq': 0,
+        'info_seq': 0,
+        'ctx_view_seq': 0,
+        'sb_seq': 0,
+        'env_current_seq': 0,
+        'other': 0
+    }
+    
+    other_patterns = []
+    
+    for arg in unique_args:
+        arg_clean = arg.strip()
+        
+        if arg_clean == '0':
+            categories['literal_0'] += 1
+        elif arg_clean.isdigit():
+            categories['literal_number'] += 1
+        elif 'view.seq()' in arg_clean or 'view().seq()' in arg_clean:
+            categories['view_seq'] += 1
+        elif 'ledger->seq()' in arg_clean or 'ledger.seq()' in arg_clean:
+            categories['ledger_seq'] += 1
+        elif 'info.seq' in arg_clean or 'info_.seq' in arg_clean:
+            categories['info_seq'] += 1
+        elif 'ctx.view.seq()' in arg_clean:
+            categories['ctx_view_seq'] += 1
+        elif 'sb.seq()' in arg_clean:
+            categories['sb_seq'] += 1
+        elif 'env.current()->seq()' in arg_clean:
+            categories['env_current_seq'] += 1
+        else:
+            categories['other'] += 1
+            other_patterns.append(arg_clean)
+    
+    return categories, other_patterns
+
+def print_report(results: Dict[str, List], unique_args: Set[str]):
+    """Print a detailed report of findings."""
+    print("=" * 80)
+    print("KEYLET FUNCTION CALL ANALYSIS")
+    print("=" * 80)
+    
+    # Summary
+    total_calls = sum(len(calls) for calls in results.values())
+    print(f"\nTotal keylet calls found: {total_calls}")
+    print(f"Unique keylet functions: {len(results)}")
+    print(f"Unique hash_options arguments: {len(unique_args)}")
+    
+    # Function frequency
+    print("\n" + "=" * 80)
+    print("KEYLET FUNCTIONS BY FREQUENCY:")
+    print("=" * 80)
+    
+    sorted_funcs = sorted(results.items(), key=lambda x: len(x[1]), reverse=True)
+    for func_name, calls in sorted_funcs[:20]:  # Top 20
+        print(f"  {func_name:30} {len(calls):4} calls")
+    
+    if len(sorted_funcs) > 20:
+        print(f"  ... and {len(sorted_funcs) - 20} more functions")
+    
+    # Analyze hash_options content
+    print("\n" + "=" * 80)
+    print("HASH_OPTIONS ARGUMENT PATTERNS:")
+    print("=" * 80)
+    
+    categories, other_patterns = analyze_hash_options_content(unique_args)
+    
+    for category, count in sorted(categories.items(), key=lambda x: x[1], reverse=True):
+        if count > 0:
+            print(f"  {category:25} {count:4} occurrences")
+    
+    if other_patterns:
+        print("\n" + "=" * 80)
+        print("OTHER PATTERNS (need review):")
+        print("=" * 80)
+        for i, pattern in enumerate(sorted(set(other_patterns))[:10], 1):
+            # Truncate long patterns
+            display = pattern if len(pattern) <= 60 else pattern[:57] + "..."
+            print(f"  {i:2}. {display}")
+    
+    # Sample calls for most common functions
+    print("\n" + "=" * 80)
+    print("SAMPLE CALLS (top 5 functions):")
+    print("=" * 80)
+    
+    for func_name, calls in sorted_funcs[:5]:
+        print(f"\n{func_name}:")
+        for filepath, line_num, arg in calls[:3]:  # Show first 3 examples
+            print(f"  {filepath}:{line_num}")
+            print(f"    {arg}")
+        if len(calls) > 3:
+            print(f"  ... and {len(calls) - 3} more")
+
+def generate_replacement_script(results: Dict[str, List], unique_args: Set[str]):
+    """Generate a script to help with replacements."""
+    print("\n" + "=" * 80)
+    print("SUGGESTED MIGRATION STRATEGY:")
+    print("=" * 80)
+    
+    print("""
+The goal is to migrate from:
+  keylet::func(hash_options{ledger_seq})
+  
+To either:
+  keylet::func(hash_options{ledger_seq, KEYLET_CLASSIFIER})
+  
+Where KEYLET_CLASSIFIER would be a specific HashContext enum value
+based on the keylet function type.
+
+Suggested mappings:
+  - keylet::account()     -> LEDGER_HEADER_HASH (or new KEYLET_ACCOUNT)
+  - keylet::line()        -> LEDGER_HEADER_HASH (or new KEYLET_TRUSTLINE)
+  - keylet::offer()       -> LEDGER_HEADER_HASH (or new KEYLET_OFFER)
+  - keylet::ownerDir()    -> LEDGER_HEADER_HASH (or new KEYLET_OWNER_DIR)
+  - keylet::page()        -> LEDGER_HEADER_HASH (or new KEYLET_DIR_PAGE)
+  - keylet::fees()        -> LEDGER_HEADER_HASH (or new KEYLET_FEES)
+  - keylet::amendments()  -> LEDGER_HEADER_HASH (or new KEYLET_AMENDMENTS)
+  - keylet::check()       -> LEDGER_HEADER_HASH (or new KEYLET_CHECK)
+  - keylet::escrow()      -> LEDGER_HEADER_HASH (or new KEYLET_ESCROW)
+  - keylet::payChan()     -> LEDGER_HEADER_HASH (or new KEYLET_PAYCHAN)
+  - keylet::signers()     -> LEDGER_HEADER_HASH (or new KEYLET_SIGNERS)
+  - keylet::ticket()      -> LEDGER_HEADER_HASH (or new KEYLET_TICKET)
+  - keylet::nftpage_*()   -> LEDGER_HEADER_HASH (or new KEYLET_NFT_PAGE)
+  - keylet::nftoffer()    -> LEDGER_HEADER_HASH (or new KEYLET_NFT_OFFER)
+  - keylet::depositPreauth() -> LEDGER_HEADER_HASH (or new KEYLET_DEPOSIT_PREAUTH)
+""")
+
+if __name__ == "__main__":
+    # Get the project root directory
+    project_root = "/Users/nicholasdudfield/projects/xahaud-worktrees/xahaud-map-stats-rpc"
+    
+    print(f"Analyzing keylet calls in: {project_root}")
+    print("This may take a moment...\n")
+    
+    # Find all keylet calls
+    results, unique_args = find_keylet_calls(project_root)
+    
+    # Print the report
+    print_report(results, unique_args)
+    
+    # Generate replacement suggestions
+    generate_replacement_script(results, unique_args)

cfg/rippled-example.cfg

@@ -283,14 +283,12 @@
 #       ssl_cert
 #
 #           Specifies the path to the SSL certificate file in PEM format.
-#           This is not needed if the chain includes it. Use ssl_chain if
-#           your certificate includes one or more intermediates.
+#           This is not needed if the chain includes it.
 #
 #       ssl_chain
 #
 #           If you need a certificate chain, specify the path to the
 #           certificate chain here. The chain may include the end certificate.
-#           This must be used if the certificate includes intermediates.
 #
 #   ssl_ciphers = <cipherlist>
 #
@@ -389,21 +387,6 @@
 #
 #
 #
-# [compression]
-#
-#   true or false
-#
-#   true - enables compression
-#   false - disables compression [default].
-#
-#   The rippled server can save bandwidth by compressing its peer-to-peer communications, 
-#   at a cost of greater CPU usage. If you enable link compression, 
-#   the server automatically compresses communications with peer servers
-#   that also have link compression enabled.
-#   https://xrpl.org/enable-link-compression.html
-#
-#
-#
 # [ips]
 #
 #   List of hostnames or ips where the Ripple protocol is served.  A default
@@ -478,6 +461,19 @@
 #
 #
 #
+# [sntp_servers]
+#
+#   IP address or domain of NTP servers to use for time synchronization.
+#
+#   These NTP servers are suitable for rippled servers located in the United
+#   States:
+#      time.windows.com
+#      time.apple.com
+#      time.nist.gov
+#      pool.ntp.org
+#
+#
+#
 # [max_transactions]
 #
 #   Configure the maximum number of transactions to have in the job queue
@@ -1653,7 +1649,6 @@ port = 6006
 ip = 127.0.0.1
 admin = 127.0.0.1
 protocol = ws
-send_queue_limit = 500
 
 [port_grpc]
 port = 50051
@@ -1664,7 +1659,6 @@ secure_gateway = 127.0.0.1
 #port = 6005
 #ip = 127.0.0.1
 #protocol = wss
-#send_queue_limit = 500
 
 #-------------------------------------------------------------------------------
 
@@ -1720,6 +1714,12 @@ advisory_delete=0
 [debug_logfile]
 /var/log/rippled/debug.log
 
+[sntp_servers]
+time.windows.com
+time.apple.com
+time.nist.gov
+pool.ntp.org
+
 # To use the XRP test network
 # (see https://xrpl.org/connect-your-rippled-to-the-xrp-test-net.html),
 # use the following [ips] section:

cfg/rippled-reporting.cfg

@@ -450,6 +450,19 @@
 #
 #
 #
+# [sntp_servers]
+#
+#   IP address or domain of NTP servers to use for time synchronization.
+#
+#   These NTP servers are suitable for rippled servers located in the United
+#   States:
+#      time.windows.com
+#      time.apple.com
+#      time.nist.gov
+#      pool.ntp.org
+#
+#
+#
 # [max_transactions]
 #
 #   Configure the maximum number of transactions to have in the job queue
@@ -1649,6 +1662,12 @@ advisory_delete=0
 [debug_logfile]
 /var/log/rippled-reporting/debug.log
 
+[sntp_servers]
+time.windows.com
+time.apple.com
+time.nist.gov
+pool.ntp.org
+
 # To use the XRP test network
 # (see https://xrpl.org/connect-your-rippled-to-the-xrp-test-net.html),
 # use the following [ips] section:

compile_single.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""
+Compile a single file using commands from compile_commands.json
+"""
+
+import json
+import os
+import sys
+import subprocess
+import argparse
+from pathlib import Path
+
+
+def find_compile_command(compile_commands, file_path):
+    """Find the compile command for a given file path."""
+    # Normalize the input path
+    abs_path = os.path.abspath(file_path)
+    
+    for entry in compile_commands:
+        # Check if this entry matches our file
+        entry_file = os.path.abspath(entry['file'])
+        if entry_file == abs_path:
+            return entry
+    
+    # Try relative path matching as fallback
+    for entry in compile_commands:
+        if entry['file'].endswith(file_path) or file_path.endswith(entry['file']):
+            return entry
+    
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Compile a single file using compile_commands.json'
+    )
+    parser.add_argument(
+        'file',
+        help='Path to the source file to compile'
+    )
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        help='Show the compile command being executed'
+    )
+    parser.add_argument(
+        '--dump-output', '-d',
+        action='store_true',
+        help='Dump the full output from the compiler'
+    )
+    parser.add_argument(
+        '--compile-db',
+        default='build/compile_commands.json',
+        help='Path to compile_commands.json (default: build/compile_commands.json)'
+    )
+    
+    args = parser.parse_args()
+    
+    # Check if compile_commands.json exists
+    if not os.path.exists(args.compile_db):
+        print(f"Error: {args.compile_db} not found", file=sys.stderr)
+        print("Make sure you've run cmake with -DCMAKE_EXPORT_COMPILE_COMMANDS=ON", file=sys.stderr)
+        sys.exit(1)
+    
+    # Load compile commands
+    try:
+        with open(args.compile_db, 'r') as f:
+            compile_commands = json.load(f)
+    except json.JSONDecodeError as e:
+        print(f"Error parsing {args.compile_db}: {e}", file=sys.stderr)
+        sys.exit(1)
+    
+    # Find the compile command for the requested file
+    entry = find_compile_command(compile_commands, args.file)
+    
+    if not entry:
+        print(f"Error: No compile command found for {args.file}", file=sys.stderr)
+        print(f"Available files in {args.compile_db}:", file=sys.stderr)
+        # Show first 10 files as examples
+        for i, cmd in enumerate(compile_commands[:10]):
+            print(f"  {cmd['file']}", file=sys.stderr)
+        if len(compile_commands) > 10:
+            print(f"  ... and {len(compile_commands) - 10} more", file=sys.stderr)
+        sys.exit(1)
+    
+    # Extract the command and directory
+    command = entry['command']
+    directory = entry.get('directory', '.')
+    
+    if args.verbose:
+        print(f"Directory: {directory}", file=sys.stderr)
+        print(f"Command: {command}", file=sys.stderr)
+        print("-" * 80, file=sys.stderr)
+    
+    # Execute the compile command
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            cwd=directory,
+            capture_output=not args.dump_output,
+            text=True
+        )
+        
+        if args.dump_output:
+            # Output was already printed to stdout/stderr
+            pass
+        else:
+            # Only show output if there were errors or warnings
+            if result.stderr:
+                print(result.stderr, file=sys.stderr)
+            if result.stdout:
+                print(result.stdout)
+        
+        # Exit with the same code as the compiler
+        sys.exit(result.returncode)
+        
+    except subprocess.SubprocessError as e:
+        print(f"Error executing compile command: {e}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nCompilation interrupted", file=sys.stderr)
+        sys.exit(130)
+
+
+if __name__ == '__main__':
+    main()

compile_single_v2.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""
+Compile a single file using commands from compile_commands.json
+Enhanced version with error context display
+"""
+
+import json
+import os
+import sys
+import subprocess
+import argparse
+import re
+import logging
+from pathlib import Path
+
+
+def setup_logging(level):
+    """Setup logging configuration."""
+    numeric_level = getattr(logging, level.upper(), None)
+    if not isinstance(numeric_level, int):
+        raise ValueError(f'Invalid log level: {level}')
+    
+    logging.basicConfig(
+        level=numeric_level,
+        format='[%(levelname)s] %(message)s',
+        stream=sys.stderr
+    )
+
+
+def find_compile_command(compile_commands, file_path):
+    """Find the compile command for a given file path."""
+    # Normalize the input path
+    abs_path = os.path.abspath(file_path)
+    logging.debug(f"Looking for compile command for: {abs_path}")
+    
+    for entry in compile_commands:
+        # Check if this entry matches our file
+        entry_file = os.path.abspath(entry['file'])
+        if entry_file == abs_path:
+            logging.debug(f"Found exact match: {entry_file}")
+            return entry
+    
+    # Try relative path matching as fallback
+    for entry in compile_commands:
+        if entry['file'].endswith(file_path) or file_path.endswith(entry['file']):
+            logging.debug(f"Found relative match: {entry['file']}")
+            return entry
+    
+    logging.debug("No compile command found")
+    return None
+
+
+def extract_errors_with_context(output, file_path, context_lines=3):
+    """Extract error messages with context from compiler output."""
+    lines = output.split('\n')
+    errors = []
+    
+    logging.debug(f"Parsing {len(lines)} lines of compiler output")
+    logging.debug(f"Looking for errors in file: {file_path}")
+    
+    # Pattern to match error lines from clang/gcc
+    # Matches: filename:line:col: error: message
+    # Also handle color codes
+    error_pattern = re.compile(r'([^:]+):(\d+):(\d+):\s*(?:\x1b\[[0-9;]*m)?\s*(error|warning):\s*(?:\x1b\[[0-9;]*m)?\s*(.*?)(?:\x1b\[[0-9;]*m)?$')
+    
+    for i, line in enumerate(lines):
+        # Strip ANSI color codes for pattern matching
+        clean_line = re.sub(r'\x1b\[[0-9;]*m', '', line)
+        match = error_pattern.search(clean_line)
+        
+        if match:
+            filename = match.group(1)
+            line_num = int(match.group(2))
+            col_num = int(match.group(3))
+            error_type = match.group(4)
+            message = match.group(5)
+            
+            logging.debug(f"Found {error_type} at {filename}:{line_num}:{col_num}")
+            
+            # Check if this error is from the file we're compiling
+            # Be more flexible with path matching
+            if (file_path in filename or 
+                filename.endswith(os.path.basename(file_path)) or
+                os.path.basename(filename) == os.path.basename(file_path)):
+                
+                logging.debug(f"  -> Including {error_type}: {message[:50]}...")
+                
+                error_info = {
+                    'line': line_num,
+                    'col': col_num,
+                    'type': error_type,
+                    'message': message,
+                    'full_line': line,  # Keep original line with colors
+                    'context_before': [],
+                    'context_after': []
+                }
+                
+                # Get context lines from compiler output
+                for j in range(max(0, i - context_lines), i):
+                    error_info['context_before'].append(lines[j])
+                
+                for j in range(i + 1, min(len(lines), i + context_lines + 1)):
+                    error_info['context_after'].append(lines[j])
+                
+                errors.append(error_info)
+            else:
+                logging.debug(f"  -> Skipping (different file: {filename})")
+    
+    logging.info(f"Found {len(errors)} errors/warnings")
+    return errors
+
+
+def read_source_context(file_path, line_num, context_lines=3):
+    """Read context from the source file around a specific line."""
+    try:
+        with open(file_path, 'r') as f:
+            lines = f.readlines()
+        
+        start = max(0, line_num - context_lines - 1)
+        end = min(len(lines), line_num + context_lines)
+        
+        context = []
+        for i in range(start, end):
+            line_marker = '>>> ' if i == line_num - 1 else '    '
+            context.append(f"{i+1:4d}:{line_marker}{lines[i].rstrip()}")
+        
+        return '\n'.join(context)
+    except Exception as e:
+        logging.warning(f"Could not read source context: {e}")
+        return None
+
+
+def format_error_with_context(error, file_path, show_source_context=False):
+    """Format an error with its context."""
+    output = []
+    output.append(f"\n{'='*80}")
+    output.append(f"Error at line {error['line']}, column {error['col']}:")
+    output.append(f"  {error['message']}")
+    
+    if show_source_context:
+        source_context = read_source_context(file_path, error['line'], 3)
+        if source_context:
+            output.append("\nSource context:")
+            output.append(source_context)
+    
+    if error['context_before'] or error['context_after']:
+        output.append("\nCompiler output context:")
+        for line in error['context_before']:
+            output.append(f"  {line}")
+        output.append(f">>> {error['full_line']}")
+        for line in error['context_after']:
+            output.append(f"  {line}")
+    
+    return '\n'.join(output)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Compile a single file using compile_commands.json with enhanced error display'
+    )
+    parser.add_argument(
+        'file',
+        help='Path to the source file to compile'
+    )
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        help='Show the compile command being executed'
+    )
+    parser.add_argument(
+        '--dump-output', '-d',
+        action='store_true',
+        help='Dump the full output from the compiler'
+    )
+    parser.add_argument(
+        '--show-error-context', '-e',
+        type=int,
+        metavar='N',
+        help='Show N lines of context around each error (implies capturing output)'
+    )
+    parser.add_argument(
+        '--show-source-context', '-s',
+        action='store_true',
+        help='Show source file context around errors'
+    )
+    parser.add_argument(
+        '--errors-only',
+        action='store_true',
+        help='Only show errors, not warnings'
+    )
+    parser.add_argument(
+        '--compile-db',
+        default='build/compile_commands.json',
+        help='Path to compile_commands.json (default: build/compile_commands.json)'
+    )
+    parser.add_argument(
+        '--log-level', '-l',
+        default='WARNING',
+        choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'],
+        help='Set logging level (default: WARNING)'
+    )
+    
+    args = parser.parse_args()
+    
+    # Setup logging
+    setup_logging(args.log_level)
+    
+    # Check if compile_commands.json exists
+    if not os.path.exists(args.compile_db):
+        print(f"Error: {args.compile_db} not found", file=sys.stderr)
+        print("Make sure you've run cmake with -DCMAKE_EXPORT_COMPILE_COMMANDS=ON", file=sys.stderr)
+        sys.exit(1)
+    
+    # Load compile commands
+    try:
+        with open(args.compile_db, 'r') as f:
+            compile_commands = json.load(f)
+        logging.info(f"Loaded {len(compile_commands)} compile commands")
+    except json.JSONDecodeError as e:
+        print(f"Error parsing {args.compile_db}: {e}", file=sys.stderr)
+        sys.exit(1)
+    
+    # Find the compile command for the requested file
+    entry = find_compile_command(compile_commands, args.file)
+    
+    if not entry:
+        print(f"Error: No compile command found for {args.file}", file=sys.stderr)
+        print(f"Available files in {args.compile_db}:", file=sys.stderr)
+        # Show first 10 files as examples
+        for i, cmd in enumerate(compile_commands[:10]):
+            print(f"  {cmd['file']}", file=sys.stderr)
+        if len(compile_commands) > 10:
+            print(f"  ... and {len(compile_commands) - 10} more", file=sys.stderr)
+        sys.exit(1)
+    
+    # Extract the command and directory
+    command = entry['command']
+    directory = entry.get('directory', '.')
+    source_file = entry['file']
+    
+    if args.verbose:
+        print(f"Directory: {directory}", file=sys.stderr)
+        print(f"Command: {command}", file=sys.stderr)
+        print("-" * 80, file=sys.stderr)
+    
+    logging.info(f"Compiling {source_file}")
+    logging.debug(f"Working directory: {directory}")
+    logging.debug(f"Command: {command}")
+    
+    # Execute the compile command
+    try:
+        # If we need to show error context, we must capture output
+        capture = not args.dump_output or args.show_error_context is not None
+        
+        logging.debug(f"Running compiler (capture={capture})")
+        result = subprocess.run(
+            command,
+            shell=True,
+            cwd=directory,
+            capture_output=capture,
+            text=True
+        )
+        
+        logging.info(f"Compiler returned code: {result.returncode}")
+        
+        if args.dump_output and not args.show_error_context:
+            # Output was already printed to stdout/stderr
+            pass
+        elif args.show_error_context is not None:
+            # Parse and display errors with context
+            all_output = result.stderr + "\n" + result.stdout
+            
+            # Log first few lines of output for debugging
+            output_lines = all_output.split('\n')[:10]
+            for line in output_lines:
+                logging.debug(f"Output: {line}")
+            
+            errors = extract_errors_with_context(all_output, args.file, args.show_error_context)
+            
+            if args.errors_only:
+                errors = [e for e in errors if e['type'] == 'error']
+                logging.info(f"Filtered to {len(errors)} errors only")
+            
+            print(f"\nFound {len(errors)} {'error' if args.errors_only else 'error/warning'}(s) in {args.file}:\n")
+            
+            for error in errors:
+                print(format_error_with_context(error, source_file, args.show_source_context))
+            
+            if errors:
+                print(f"\n{'='*80}")
+                print(f"Total: {len(errors)} {'error' if args.errors_only else 'error/warning'}(s)")
+        else:
+            # Default behavior - show output if there were errors or warnings
+            if result.stderr:
+                print(result.stderr, file=sys.stderr)
+            if result.stdout:
+                print(result.stdout)
+        
+        # Exit with the same code as the compiler
+        sys.exit(result.returncode)
+        
+    except subprocess.SubprocessError as e:
+        print(f"Error executing compile command: {e}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nCompilation interrupted", file=sys.stderr)
+        sys.exit(130)
+
+
+if __name__ == '__main__':
+    main()

conanfile.py

@@ -24,26 +24,22 @@ class Xrpl(ConanFile):
     }
 
     requires = [
+        'blake3/1.5.0@xahaud/stable',
         'boost/1.86.0',
         'date/3.0.1',
         'libarchive/3.6.0',
         'lz4/1.9.3',
         'grpc/1.50.1',
         'nudb/2.0.8',
-        'openssl/1.1.1u',
+        'openssl/3.3.2',
         'protobuf/3.21.9',
         'snappy/1.1.10',
         'soci/4.0.3',
         'sqlite3/3.42.0',
-        'zlib/1.2.13',
-        'xxhash/0.8.2',
+        'zlib/1.3.1',
         'wasmedge/0.11.2',
     ]
 
-    tool_requires = [
-        'protobuf/3.21.9',
-    ]
-
     default_options = {
         'assertions': False,
         'coverage': False,
@@ -56,6 +52,7 @@ class Xrpl(ConanFile):
         'tests': True,
         'unity': False,
 
+        'blake3:simd': False,  # Disable SIMD for testing
         'cassandra-cpp-driver:shared': False,
         'date:header_only': True,
         'grpc:shared': False,
@@ -91,7 +88,6 @@ class Xrpl(ConanFile):
         'soci:shared': False,
         'soci:with_sqlite3': True,
         'soci:with_boost': True,
-        'xxhash:shared': False,
     }
 
     def set_version(self):
@@ -116,7 +112,7 @@ class Xrpl(ConanFile):
             self.requires('rocksdb/6.27.3')
 
     exports_sources = (
-        'CMakeLists.txt', 'Builds/*', 'bin/getRippledInfo', 'src/*', 'cfg/*', 'external/*'
+        'CMakeLists.txt', 'Builds/*', 'bin/getRippledInfo', 'src/*', 'cfg/*'
     )
 
     def layout(self):
@@ -153,18 +149,9 @@ class Xrpl(ConanFile):
     def package_info(self):
         libxrpl = self.cpp_info.components['libxrpl']
         libxrpl.libs = [
-            'xrpl_core',
-            'xrpl.libpb',
-            'ed25519',
-            'secp256k1',
-        ]
-        # TODO: Fix the protobufs to include each other relative to
-        # `include/`, not `include/ripple/proto/`.
-        libxrpl.includedirs = ['include', 'include/ripple/proto']
-        libxrpl.requires = [
-            'boost::boost',
-            'openssl::crypto',
-            'date::date',
-            'grpc::grpc++',
-            'xxhash::xxhash',
+            'libxrpl_core.a',
+            'libed25519.a',
+            'libsecp256k1.a',
         ]
+        libxrpl.includedirs = ['include']
+        libxrpl.requires = ['boost::boost']

external/README.md

@@ -1,11 +0,0 @@
-The subdirectories in this directory contain either copies or Conan recipes
-of external libraries used by rippled.
-The Conan recipes include patches we have not yet pushed upstream.
-
-| Folder          | Upstream                                     | Description |
-|:----------------|:---------------------------------------------|:------------|
-| `ed25519-donna` | [Project](https://github.com/floodyberry/ed25519-donna) | [Ed25519](http://ed25519.cr.yp.to/) digital signatures |
-| `rocksdb`       | [Recipe](https://github.com/conan-io/conan-center-index/tree/master/recipes/rocksdb) | Fast key/value database. (Supports rotational disks better than NuDB.) |
-| `secp256k1`     | [Project](https://github.com/bitcoin-core/secp256k1)    | ECDSA digital signatures using the **secp256k1** curve |
-| `snappy`        | [Recipe](https://github.com/conan-io/conan-center-index/tree/master/recipes/snappy)  | "Snappy" lossless compression algorithm. |
-| `soci`          | [Recipe](https://github.com/conan-io/conan-center-index/tree/master/recipes/soci)    | Abstraction layer for database access. |

external/blake3/conandata.yml

@@ -0,0 +1,10 @@
+sources:
+  "1.5.0":
+    url: "https://github.com/BLAKE3-team/BLAKE3/archive/refs/tags/1.5.0.tar.gz"
+    sha256: "f506140bc3af41d3432a4ce18b3b83b08eaa240e94ef161eb72b2e57cdc94c69"
+  "1.4.1":
+    url: "https://github.com/BLAKE3-team/BLAKE3/archive/refs/tags/1.4.1.tar.gz"
+    sha256: "33020ac83a8169b2e847cc6fb1dd38806ffab6efe79fe6c320e322154a3bea2c"
+  "1.4.0":
+    url: "https://github.com/BLAKE3-team/BLAKE3/archive/refs/tags/1.4.0.tar.gz"
+    sha256: "658e1c75e2d9bbed9f426385f02d2a188dc19978a39e067ba93e837861e5fe58"

external/blake3/conanfile.py

@@ -0,0 +1,115 @@
+from conan import ConanFile
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+from conan.tools.files import copy, get
+from conan.tools.scm import Version
+import os
+
+required_conan_version = ">=1.54.0"
+
+
+class Blake3Conan(ConanFile):
+    name = "blake3"
+    version = "1.5.0"
+    description = "BLAKE3 cryptographic hash function"
+    topics = ("blake3", "hash", "cryptography")
+    url = "https://github.com/BLAKE3-team/BLAKE3"
+    homepage = "https://github.com/BLAKE3-team/BLAKE3"
+    license = "CC0-1.0 OR Apache-2.0"
+    
+    package_type = "library"
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "simd": [True, False],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "simd": False,  # Default to NO SIMD for testing
+    }
+
+    def config_options(self):
+        if self.settings.os == 'Windows':
+            del self.options.fPIC
+
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+        # BLAKE3 is C code
+        self.settings.rm_safe("compiler.cppstd")
+        self.settings.rm_safe("compiler.libcxx")
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        # BLAKE3's CMake options
+        tc.variables["BUILD_SHARED_LIBS"] = self.options.shared
+        if not self.options.simd:
+            # For v1.5.0, we'll need to manually patch the CMakeLists.txt
+            # These flags don't work with the old CMake
+            tc.preprocessor_definitions["BLAKE3_USE_NEON"] = "0"
+        tc.generate()
+
+    def build(self):
+        # Patch CMakeLists.txt if SIMD is disabled
+        if not self.options.simd:
+            cmake_file = os.path.join(self.source_folder, "c", "CMakeLists.txt")
+            # Read the file
+            with open(cmake_file, 'r') as f:
+                content = f.read()
+            # Replace the ARM detection line to never match
+            content = content.replace(
+                'elseif(CMAKE_SYSTEM_PROCESSOR IN_LIST BLAKE3_ARMv8_NAMES',
+                'elseif(FALSE  # Disabled by conan simd=False'
+            )
+            # Write it back
+            with open(cmake_file, 'w') as f:
+                f.write(content)
+                
+        cmake = CMake(self)
+        # BLAKE3's C implementation has its CMakeLists.txt in the c/ subdirectory
+        cmake.configure(build_script_folder=os.path.join(self.source_folder, "c"))
+        cmake.build()
+
+    def package(self):
+        # Copy license files
+        copy(self, "LICENSE*", src=self.source_folder, 
+             dst=os.path.join(self.package_folder, "licenses"))
+        # Copy header
+        copy(self, "blake3.h", 
+             src=os.path.join(self.source_folder, "c"),
+             dst=os.path.join(self.package_folder, "include"))
+        # Copy library
+        copy(self, "*.a", src=self.build_folder, 
+             dst=os.path.join(self.package_folder, "lib"), keep_path=False)
+        copy(self, "*.lib", src=self.build_folder, 
+             dst=os.path.join(self.package_folder, "lib"), keep_path=False)
+        copy(self, "*.dylib", src=self.build_folder, 
+             dst=os.path.join(self.package_folder, "lib"), keep_path=False)
+        copy(self, "*.so*", src=self.build_folder, 
+             dst=os.path.join(self.package_folder, "lib"), keep_path=False)
+        copy(self, "*.dll", src=self.build_folder, 
+             dst=os.path.join(self.package_folder, "bin"), keep_path=False)
+
+    def package_info(self):
+        self.cpp_info.set_property("cmake_file_name", "BLAKE3")
+        self.cpp_info.set_property("cmake_target_name", "BLAKE3::blake3")
+        
+        # IMPORTANT: Explicitly set include directories to fix Conan CMakeDeps generation
+        self.cpp_info.includedirs = ["include"]
+        self.cpp_info.libs = ["blake3"]
+        
+        # System libraries
+        if self.settings.os in ["Linux", "FreeBSD"]:
+            self.cpp_info.system_libs.append("m")
+            self.cpp_info.system_libs.append("pthread")
+        
+        # TODO: to remove in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.names["cmake_find_package"] = "BLAKE3"
+        self.cpp_info.names["cmake_find_package_multi"] = "BLAKE3"

external/rocksdb/conandata.yml

@@ -1,27 +0,0 @@
-sources:
-  "6.29.5":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.29.5.tar.gz"
-    sha256: "ddbf84791f0980c0bbce3902feb93a2c7006f6f53bfd798926143e31d4d756f0"
-  "6.27.3":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.27.3.tar.gz"
-    sha256: "ee29901749b9132692b26f0a6c1d693f47d1a9ed8e3771e60556afe80282bf58"
-  "6.20.3":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.20.3.tar.gz"
-    sha256: "c6502c7aae641b7e20fafa6c2b92273d935d2b7b2707135ebd9a67b092169dca"
-  "8.8.1":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v8.8.1.tar.gz"
-    sha256: "056c7e21ad8ae36b026ac3b94b9d6e0fcc60e1d937fc80330921e4181be5c36e"
-patches:
-  "6.29.5":
-    - patch_file: "patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch"
-      patch_description: "Fix build with gcc 13 by including cstdint"
-      patch_type: "portability"
-      patch_source: "https://github.com/facebook/rocksdb/pull/11118"
-    - patch_file: "patches/6.29.5-0002-exclude-thirdparty.patch"
-      patch_description: "Do not include thirdparty.inc"
-      patch_type: "portability"
-  "6.27.3":
-    - patch_file: "patches/6.27.3-0001-add-include-cstdint-for-gcc-13.patch"
-      patch_description: "Fix build with gcc 13 by including cstdint"
-      patch_type: "portability"
-      patch_source: "https://github.com/facebook/rocksdb/pull/11118"

external/rocksdb/conanfile.py

@@ -1,233 +1,193 @@
 import os
-import glob
 import shutil
+from conans import ConanFile, CMake
+from conan.tools import microsoft as ms
 
-from conan import ConanFile
-from conan.errors import ConanInvalidConfiguration
-from conan.tools.build import check_min_cppstd
-from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
-from conan.tools.files import apply_conandata_patches, collect_libs, copy, export_conandata_patches, get, rm, rmdir
-from conan.tools.microsoft import check_min_vs, is_msvc, is_msvc_static_runtime
-from conan.tools.scm import Version
+class RocksDB(ConanFile):
+    name = 'rocksdb'
+    version = '6.27.3'
 
-required_conan_version = ">=1.53.0"
+    license = ('GPL-2.0-only', 'Apache-2.0')
+    url = 'https://github.com/conan-io/conan-center-index'
+    description = 'A library that provides an embeddable, persistent key-value store for fast storage'
+    topics = ('rocksdb', 'database', 'leveldb', 'facebook', 'key-value')
 
-
-class RocksDBConan(ConanFile):
-    name = "rocksdb"
-    homepage = "https://github.com/facebook/rocksdb"
-    license = ("GPL-2.0-only", "Apache-2.0")
-    url = "https://github.com/conan-io/conan-center-index"
-    description = "A library that provides an embeddable, persistent key-value store for fast storage"
-    topics = ("database", "leveldb", "facebook", "key-value")
-    package_type = "library"
-    settings = "os", "arch", "compiler", "build_type"
+    settings = 'os', 'compiler', 'build_type', 'arch'
     options = {
-        "shared": [True, False],
-        "fPIC": [True, False],
-        "lite": [True, False],
-        "with_gflags": [True, False],
-        "with_snappy": [True, False],
-        "with_lz4": [True, False],
-        "with_zlib": [True, False],
-        "with_zstd": [True, False],
-        "with_tbb": [True, False],
-        "with_jemalloc": [True, False],
-        "enable_sse": [False, "sse42", "avx2"],
-        "use_rtti": [True, False],
+        'enable_sse': [False, 'sse42', 'avx2'],
+        'fPIC': [True, False],
+        'lite': [True, False],
+        'shared': [True, False],
+        'use_rtti': [True, False],
+        'with_gflags': [True, False],
+        'with_jemalloc': [True, False],
+        'with_lz4': [True, False],
+        'with_snappy': [True, False],
+        'with_tbb': [True, False],
+        'with_zlib': [True, False],
+        'with_zstd': [True, False],
     }
     default_options = {
-        "shared": False,
-        "fPIC": True,
-        "lite": False,
-        "with_snappy": False,
-        "with_lz4": False,
-        "with_zlib": False,
-        "with_zstd": False,
-        "with_gflags": False,
-        "with_tbb": False,
-        "with_jemalloc": False,
-        "enable_sse": False,
-        "use_rtti": False,
+        'enable_sse': False,
+        'fPIC': True,
+        'lite': False,
+        'shared': False,
+        'use_rtti': False,
+        'with_gflags': False,
+        'with_jemalloc': False,
+        'with_lz4': False,
+        'with_snappy': False,
+        'with_tbb': False,
+        'with_zlib': False,
+        'with_zstd': False,
     }
 
-    @property
-    def _min_cppstd(self):
-        return "11" if Version(self.version) < "8.8.1" else "17"
-
-    @property
-    def _compilers_minimum_version(self):
-        return {} if self._min_cppstd == "11" else {
-                "apple-clang": "10",
-                "clang": "7",
-                "gcc": "7",
-                "msvc": "191",
-                "Visual Studio": "15",
-            }
-
-    def export_sources(self):
-        export_conandata_patches(self)
-
-    def config_options(self):
-        if self.settings.os == "Windows":
-            del self.options.fPIC
-        if self.settings.arch != "x86_64":
-            del self.options.with_tbb
-        if self.settings.build_type == "Debug":
-            self.options.use_rtti = True  # Rtti are used in asserts for debug mode...
-
-    def configure(self):
-        if self.options.shared:
-            self.options.rm_safe("fPIC")
-
-    def layout(self):
-        cmake_layout(self, src_folder="src")
-
     def requirements(self):
         if self.options.with_gflags:
-            self.requires("gflags/2.2.2")
-        if self.options.with_snappy:
-            self.requires("snappy/1.1.10")
+            self.requires('gflags/2.2.2')
+        if self.options.with_jemalloc:
+            self.requires('jemalloc/5.2.1')
         if self.options.with_lz4:
-            self.requires("lz4/1.9.4")
+            self.requires('lz4/1.9.3')
+        if self.options.with_snappy:
+            self.requires('snappy/1.1.9')
+        if self.options.with_tbb:
+            self.requires('onetbb/2020.3')
         if self.options.with_zlib:
-            self.requires("zlib/[>=1.2.11 <2]")
+            self.requires('zlib/1.2.11')
         if self.options.with_zstd:
-            self.requires("zstd/1.5.5")
-        if self.options.get_safe("with_tbb"):
-            self.requires("onetbb/2021.10.0")
-        if self.options.with_jemalloc:
-            self.requires("jemalloc/5.3.0")
+            self.requires('zstd/1.5.2')
 
-    def validate(self):
-        if self.settings.compiler.get_safe("cppstd"):
-            check_min_cppstd(self, self._min_cppstd)
+    def config_options(self):
+        if self.settings.os == 'Windows':
+            del self.options.fPIC
 
-        minimum_version = self._compilers_minimum_version.get(str(self.settings.compiler), False)
-        if minimum_version and Version(self.settings.compiler.version) < minimum_version:
-            raise ConanInvalidConfiguration(
-                f"{self.ref} requires C++{self._min_cppstd}, which your compiler does not support."
+    def configure(self):
+        if self.options.shared:
+            del self.options.fPIC
+
+    generators = 'cmake', 'cmake_find_package'
+
+    scm = {
+        'type': 'git',
+        'url': 'https://github.com/facebook/rocksdb.git',
+        'revision': 'v6.27.3',
+    }
+
+    exports_sources = 'thirdparty.inc'
+    # For out-of-source build.
+    no_copy_source = True
+
+    _cmake = None
+
+    def _configure_cmake(self):
+        if self._cmake:
+            return
+
+        self._cmake = CMake(self)
+
+        self._cmake.definitions['CMAKE_POSITION_INDEPENDENT_CODE'] = True
+
+        self._cmake.definitions['DISABLE_STALL_NOTIF'] = False
+        self._cmake.definitions['FAIL_ON_WARNINGS'] = False
+        self._cmake.definitions['OPTDBG'] = True
+        self._cmake.definitions['WITH_TESTS'] = False
+        self._cmake.definitions['WITH_TOOLS'] = False
+
+        self._cmake.definitions['WITH_GFLAGS'] = self.options.with_gflags
+        self._cmake.definitions['WITH_JEMALLOC'] = self.options.with_jemalloc
+        self._cmake.definitions['WITH_LZ4'] = self.options.with_lz4
+        self._cmake.definitions['WITH_SNAPPY'] = self.options.with_snappy
+        self._cmake.definitions['WITH_TBB'] = self.options.with_tbb
+        self._cmake.definitions['WITH_ZLIB'] = self.options.with_zlib
+        self._cmake.definitions['WITH_ZSTD'] = self.options.with_zstd
+
+        self._cmake.definitions['USE_RTTI'] = self.options.use_rtti
+        self._cmake.definitions['ROCKSDB_LITE'] = self.options.lite
+        self._cmake.definitions['ROCKSDB_INSTALL_ON_WINDOWS'] = (
+            self.settings.os == 'Windows'
+        )
+
+        if not self.options.enable_sse:
+            self._cmake.definitions['PORTABLE'] = True
+            self._cmake.definitions['FORCE_SSE42'] = False
+        elif self.options.enable_sse == 'sse42':
+            self._cmake.definitions['PORTABLE'] = True
+            self._cmake.definitions['FORCE_SSE42'] = True
+        elif self.options.enable_sse == 'avx2':
+            self._cmake.definitions['PORTABLE'] = False
+            self._cmake.definitions['FORCE_SSE42'] = False
+
+        self._cmake.definitions['WITH_ASAN'] = False
+        self._cmake.definitions['WITH_BZ2'] = False
+        self._cmake.definitions['WITH_JNI'] = False
+        self._cmake.definitions['WITH_LIBRADOS'] = False
+        if ms.is_msvc(self):
+            self._cmake.definitions['WITH_MD_LIBRARY'] = (
+                ms.msvc_runtime_flag(self).startswith('MD')
             )
+            self._cmake.definitions['WITH_RUNTIME_DEBUG'] = (
+                ms.msvc_runtime_flag(self).endswith('d')
+            )
+        self._cmake.definitions['WITH_NUMA'] = False
+        self._cmake.definitions['WITH_TSAN'] = False
+        self._cmake.definitions['WITH_UBSAN'] = False
+        self._cmake.definitions['WITH_WINDOWS_UTF8_FILENAMES'] = False
+        self._cmake.definitions['WITH_XPRESS'] = False
+        self._cmake.definitions['WITH_FALLOCATE'] = True
 
-        if self.settings.arch not in ["x86_64", "ppc64le", "ppc64", "mips64", "armv8"]:
-            raise ConanInvalidConfiguration("Rocksdb requires 64 bits")
-
-        check_min_vs(self, "191")
-
-        if self.version == "6.20.3" and \
-           self.settings.os == "Linux" and \
-           self.settings.compiler == "gcc" and \
-           Version(self.settings.compiler.version) < "5":
-            raise ConanInvalidConfiguration("Rocksdb 6.20.3 is not compilable with gcc <5.") # See https://github.com/facebook/rocksdb/issues/3522
-
-    def source(self):
-        get(self, **self.conan_data["sources"][self.version], strip_root=True)
-
-    def generate(self):
-        tc = CMakeToolchain(self)
-        tc.variables["FAIL_ON_WARNINGS"] = False
-        tc.variables["WITH_TESTS"] = False
-        tc.variables["WITH_TOOLS"] = False
-        tc.variables["WITH_CORE_TOOLS"] = False
-        tc.variables["WITH_BENCHMARK_TOOLS"] = False
-        tc.variables["WITH_FOLLY_DISTRIBUTED_MUTEX"] = False
-        if is_msvc(self):
-            tc.variables["WITH_MD_LIBRARY"] = not is_msvc_static_runtime(self)
-        tc.variables["ROCKSDB_INSTALL_ON_WINDOWS"] = self.settings.os == "Windows"
-        tc.variables["ROCKSDB_LITE"] = self.options.lite
-        tc.variables["WITH_GFLAGS"] = self.options.with_gflags
-        tc.variables["WITH_SNAPPY"] = self.options.with_snappy
-        tc.variables["WITH_LZ4"] = self.options.with_lz4
-        tc.variables["WITH_ZLIB"] = self.options.with_zlib
-        tc.variables["WITH_ZSTD"] = self.options.with_zstd
-        tc.variables["WITH_TBB"] = self.options.get_safe("with_tbb", False)
-        tc.variables["WITH_JEMALLOC"] = self.options.with_jemalloc
-        tc.variables["ROCKSDB_BUILD_SHARED"] = self.options.shared
-        tc.variables["ROCKSDB_LIBRARY_EXPORTS"] = self.settings.os == "Windows" and self.options.shared
-        tc.variables["ROCKSDB_DLL" ] = self.settings.os == "Windows" and self.options.shared
-        tc.variables["USE_RTTI"] = self.options.use_rtti
-        if not bool(self.options.enable_sse):
-            tc.variables["PORTABLE"] = True
-            tc.variables["FORCE_SSE42"] = False
-        elif self.options.enable_sse == "sse42":
-            tc.variables["PORTABLE"] = True
-            tc.variables["FORCE_SSE42"] = True
-        elif self.options.enable_sse == "avx2":
-            tc.variables["PORTABLE"] = False
-            tc.variables["FORCE_SSE42"] = False
-        # not available yet in CCI
-        tc.variables["WITH_NUMA"] = False
-        tc.generate()
-
-        deps = CMakeDeps(self)
-        if self.options.with_jemalloc:
-            deps.set_property("jemalloc", "cmake_file_name", "JeMalloc")
-            deps.set_property("jemalloc", "cmake_target_name", "JeMalloc::JeMalloc")
-        deps.generate()
 
     def build(self):
-        apply_conandata_patches(self)
-        cmake = CMake(self)
-        cmake.configure()
-        cmake.build()
-
-    def _remove_static_libraries(self):
-        rm(self, "rocksdb.lib", os.path.join(self.package_folder, "lib"))
-        for lib in glob.glob(os.path.join(self.package_folder, "lib", "*.a")):
-            if not lib.endswith(".dll.a"):
-                os.remove(lib)
-
-    def _remove_cpp_headers(self):
-        for path in glob.glob(os.path.join(self.package_folder, "include", "rocksdb", "*")):
-            if path != os.path.join(self.package_folder, "include", "rocksdb", "c.h"):
-                if os.path.isfile(path):
-                    os.remove(path)
-                else:
-                    shutil.rmtree(path)
+        if ms.is_msvc(self):
+            file = os.path.join(
+                self.recipe_folder, '..', 'export_source', 'thirdparty.inc'
+            )
+            shutil.copy(file, self.build_folder)
+        self._configure_cmake()
+        self._cmake.configure()
+        self._cmake.build()
 
     def package(self):
-        copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
-        copy(self, "LICENSE*", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
-        cmake = CMake(self)
-        cmake.install()
-        if self.options.shared:
-            self._remove_static_libraries()
-            self._remove_cpp_headers() # Force stable ABI for shared libraries
-        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
-        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
+        self._configure_cmake()
+        self._cmake.install()
 
     def package_info(self):
-        cmake_target = "rocksdb-shared" if self.options.shared else "rocksdb"
-        self.cpp_info.set_property("cmake_file_name", "RocksDB")
-        self.cpp_info.set_property("cmake_target_name", f"RocksDB::{cmake_target}")
-        # TODO: back to global scope in conan v2 once cmake_find_package* generators removed
-        self.cpp_info.components["librocksdb"].libs = collect_libs(self)
+        self.cpp_info.filenames['cmake_find_package'] = 'RocksDB'
+        self.cpp_info.filenames['cmake_find_package_multi'] = 'RocksDB'
+        self.cpp_info.set_property('cmake_file_name', 'RocksDB')
+
+        self.cpp_info.names['cmake_find_package'] = 'RocksDB'
+        self.cpp_info.names['cmake_find_package_multi'] = 'RocksDB'
+
+        self.cpp_info.components['librocksdb'].names['cmake_find_package'] = 'rocksdb'
+        self.cpp_info.components['librocksdb'].names['cmake_find_package_multi'] = 'rocksdb'
+        self.cpp_info.components['librocksdb'].set_property(
+            'cmake_target_name', 'RocksDB::rocksdb'
+        )
+
+        self.cpp_info.components['librocksdb'].libs = ['rocksdb']
+
         if self.settings.os == "Windows":
             self.cpp_info.components["librocksdb"].system_libs = ["shlwapi", "rpcrt4"]
             if self.options.shared:
                 self.cpp_info.components["librocksdb"].defines = ["ROCKSDB_DLL"]
         elif self.settings.os in ["Linux", "FreeBSD"]:
             self.cpp_info.components["librocksdb"].system_libs = ["pthread", "m"]
+
         if self.options.lite:
             self.cpp_info.components["librocksdb"].defines.append("ROCKSDB_LITE")
 
-        # TODO: to remove in conan v2 once cmake_find_package* generators removed
-        self.cpp_info.names["cmake_find_package"] = "RocksDB"
-        self.cpp_info.names["cmake_find_package_multi"] = "RocksDB"
-        self.cpp_info.components["librocksdb"].names["cmake_find_package"] = cmake_target
-        self.cpp_info.components["librocksdb"].names["cmake_find_package_multi"] = cmake_target
-        self.cpp_info.components["librocksdb"].set_property("cmake_target_name", f"RocksDB::{cmake_target}")
         if self.options.with_gflags:
             self.cpp_info.components["librocksdb"].requires.append("gflags::gflags")
-        if self.options.with_snappy:
-            self.cpp_info.components["librocksdb"].requires.append("snappy::snappy")
+        if self.options.with_jemalloc:
+            self.cpp_info.components["librocksdb"].requires.append("jemalloc::jemalloc")
         if self.options.with_lz4:
             self.cpp_info.components["librocksdb"].requires.append("lz4::lz4")
+        if self.options.with_snappy:
+            self.cpp_info.components["librocksdb"].requires.append("snappy::snappy")
+        if self.options.with_tbb:
+            self.cpp_info.components["librocksdb"].requires.append("onetbb::onetbb")
         if self.options.with_zlib:
             self.cpp_info.components["librocksdb"].requires.append("zlib::zlib")
         if self.options.with_zstd:
             self.cpp_info.components["librocksdb"].requires.append("zstd::zstd")
-        if self.options.get_safe("with_tbb"):
-            self.cpp_info.components["librocksdb"].requires.append("onetbb::onetbb")
-        if self.options.with_jemalloc:
-            self.cpp_info.components["librocksdb"].requires.append("jemalloc::jemalloc")

external/rocksdb/patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch

@@ -1,30 +0,0 @@
---- a/include/rocksdb/utilities/checkpoint.h
-+++ b/include/rocksdb/utilities/checkpoint.h
-@@ -8,6 +8,7 @@
- #pragma once
- #ifndef ROCKSDB_LITE
- 
-+#include <cstdint>
- #include <string>
- #include <vector>
- #include "rocksdb/status.h"
---- a/table/block_based/data_block_hash_index.h
-+++ b/table/block_based/data_block_hash_index.h
-@@ -5,6 +5,7 @@
- 
- #pragma once
- 
-+#include <cstdint>
- #include <string>
- #include <vector>
- 
---- a/util/string_util.h
-+++ b/util/string_util.h
-@@ -6,6 +6,7 @@
- 
- #pragma once
- 
-+#include <cstdint>
- #include <sstream>
- #include <string>
- #include <unordered_map>

external/rocksdb/patches/6.29.5-0002-exclude-thirdparty.patch

@@ -1,16 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index ec59d4491..35577c998 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -101 +100,0 @@ if(MSVC)
--  option(WITH_GFLAGS "build with GFlags" OFF)
-@@ -103,2 +102,2 @@ if(MSVC)
--  include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
--else()
-+endif()
-+
-@@ -117 +116 @@ else()
--  if(MINGW)
-+  if(MINGW OR MSVC)
-@@ -183 +181,0 @@ else()
--endif()

external/secp256k1/.cirrus.yml

@@ -1,409 +0,0 @@
-env:
-  ### cirrus config
-  CIRRUS_CLONE_DEPTH: 1
-  ### compiler options
-  HOST:
-  WRAPPER_CMD:
-  # Specific warnings can be disabled with -Wno-error=foo.
-  # -pedantic-errors is not equivalent to -Werror=pedantic and thus not implied by -Werror according to the GCC manual.
-  WERROR_CFLAGS: -Werror -pedantic-errors
-  MAKEFLAGS: -j4
-  BUILD: check
-  ### secp256k1 config
-  ECMULTWINDOW: auto
-  ECMULTGENPRECISION: auto
-  ASM: no
-  WIDEMUL: auto
-  WITH_VALGRIND: yes
-  EXTRAFLAGS:
-  ### secp256k1 modules
-  EXPERIMENTAL: no
-  ECDH: no
-  RECOVERY: no
-  SCHNORRSIG: no
-  ### test options
-  SECP256K1_TEST_ITERS:
-  BENCH: yes
-  SECP256K1_BENCH_ITERS: 2
-  CTIMETESTS: yes
-  # Compile and run the tests
-  EXAMPLES: yes
-
-# https://cirrus-ci.org/pricing/#compute-credits
-credits_snippet: &CREDITS
-  # Don't use any credits for now.
-  use_compute_credits: false
-
-cat_logs_snippet: &CAT_LOGS
-  always:
-    cat_tests_log_script:
-      - cat tests.log || true
-    cat_noverify_tests_log_script:
-      - cat noverify_tests.log || true
-    cat_exhaustive_tests_log_script:
-      - cat exhaustive_tests.log || true
-    cat_ctime_tests_log_script:
-      - cat ctime_tests.log || true
-    cat_bench_log_script:
-      - cat bench.log || true
-    cat_config_log_script:
-      - cat config.log || true
-    cat_test_env_script:
-      - cat test_env.log || true
-    cat_ci_env_script:
-      - env
-
-merge_base_script_snippet: &MERGE_BASE
-  merge_base_script:
-    - if [ "$CIRRUS_PR" = "" ]; then exit 0; fi
-    - git fetch --depth=1 $CIRRUS_REPO_CLONE_URL "pull/${CIRRUS_PR}/merge"
-    - git checkout FETCH_HEAD  # Use merged changes to detect silent merge conflicts
-
-linux_container_snippet: &LINUX_CONTAINER
-  container:
-    dockerfile: ci/linux-debian.Dockerfile
-    # Reduce number of CPUs to be able to do more builds in parallel.
-    cpu: 1
-    # Gives us more CPUs for free if they're available.
-    greedy: true
-    # More than enough for our scripts.
-    memory: 1G
-
-task:
-  name: "x86_64: Linux (Debian stable)"
-  << : *LINUX_CONTAINER
-  matrix: &ENV_MATRIX
-    - env: {WIDEMUL:  int64,  RECOVERY: yes}
-    - env: {WIDEMUL:  int64,                 ECDH: yes, SCHNORRSIG: yes}
-    - env: {WIDEMUL: int128}
-    - env: {WIDEMUL: int128_struct}
-    - env: {WIDEMUL: int128,  RECOVERY: yes,            SCHNORRSIG: yes}
-    - env: {WIDEMUL: int128,                 ECDH: yes, SCHNORRSIG: yes}
-    - env: {WIDEMUL: int128,  ASM: x86_64}
-    - env: {                  RECOVERY: yes,            SCHNORRSIG: yes}
-    - env: {CTIMETESTS: no,    RECOVERY: yes, ECDH: yes, SCHNORRSIG: yes, CPPFLAGS: -DVERIFY}
-    - env: {BUILD: distcheck, WITH_VALGRIND: no, CTIMETESTS: no, BENCH: no}
-    - env: {CPPFLAGS: -DDETERMINISTIC}
-    - env: {CFLAGS: -O0, CTIMETESTS: no}
-    - env: { ECMULTGENPRECISION: 2, ECMULTWINDOW: 2 }
-    - env: { ECMULTGENPRECISION: 8, ECMULTWINDOW: 4 }
-  matrix:
-    - env:
-        CC: gcc
-    - env:
-        CC: clang
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "i686: Linux (Debian stable)"
-  << : *LINUX_CONTAINER
-  env:
-    HOST: i686-linux-gnu
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-  matrix:
-    - env:
-        CC: i686-linux-gnu-gcc
-    - env:
-        CC: clang --target=i686-pc-linux-gnu -isystem /usr/i686-linux-gnu/include
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "arm64: macOS Ventura"
-  macos_instance:
-    image: ghcr.io/cirruslabs/macos-ventura-base:latest
-  env:
-    HOMEBREW_NO_AUTO_UPDATE: 1
-    HOMEBREW_NO_INSTALL_CLEANUP: 1
-    # Cirrus gives us a fixed number of 4 virtual CPUs. Not that we even have that many jobs at the moment...
-    MAKEFLAGS: -j5
-  matrix:
-    << : *ENV_MATRIX
-  env:
-    ASM: no
-    WITH_VALGRIND: no
-    CTIMETESTS: no
-  matrix:
-    - env:
-        CC: gcc
-    - env:
-        CC: clang
-  brew_script:
-    - brew install automake libtool gcc
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-  << : *CREDITS
-
-task:
-  name: "s390x (big-endian): Linux (Debian stable, QEMU)"
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: qemu-s390x
-    SECP256K1_TEST_ITERS: 16
-    HOST: s390x-linux-gnu
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  << : *MERGE_BASE
-  test_script:
-    # https://sourceware.org/bugzilla/show_bug.cgi?id=27008
-    - rm /etc/ld.so.cache
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "ARM32: Linux (Debian stable, QEMU)"
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: qemu-arm
-    SECP256K1_TEST_ITERS: 16
-    HOST: arm-linux-gnueabihf
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  matrix:
-    - env: {}
-    - env: {EXPERIMENTAL: yes, ASM: arm32}
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "ARM64: Linux (Debian stable, QEMU)"
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: qemu-aarch64
-    SECP256K1_TEST_ITERS: 16
-    HOST: aarch64-linux-gnu
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "ppc64le: Linux (Debian stable, QEMU)"
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: qemu-ppc64le
-    SECP256K1_TEST_ITERS: 16
-    HOST: powerpc64le-linux-gnu
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: wine
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  matrix:
-    - name: "x86_64 (mingw32-w64): Windows (Debian stable, Wine)"
-      env:
-        HOST: x86_64-w64-mingw32
-    - name: "i686 (mingw32-w64): Windows (Debian stable, Wine)"
-      env:
-        HOST: i686-w64-mingw32
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: wine
-    WERROR_CFLAGS: -WX
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    EXPERIMENTAL: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-    # Use a MinGW-w64 host to tell ./configure we're building for Windows.
-    # This will detect some MinGW-w64 tools but then make will need only
-    # the MSVC tools CC, AR and NM as specified below.
-    HOST: x86_64-w64-mingw32
-    CC: /opt/msvc/bin/x64/cl
-    AR: /opt/msvc/bin/x64/lib
-    NM: /opt/msvc/bin/x64/dumpbin -symbols -headers
-    # Set non-essential options that affect the CLI messages here.
-    # (They depend on the user's taste, so we don't want to set them automatically in configure.ac.)
-    CFLAGS: -nologo -diagnostics:caret
-    LDFLAGS: -Xlinker -Xlinker -Xlinker -nologo
-  matrix:
-    - name: "x86_64 (MSVC): Windows (Debian stable, Wine)"
-    - name: "x86_64 (MSVC): Windows (Debian stable, Wine, int128_struct)"
-      env:
-        WIDEMUL: int128_struct
-    - name: "x86_64 (MSVC): Windows (Debian stable, Wine, int128_struct with __(u)mulh)"
-      env:
-        WIDEMUL: int128_struct
-        CPPFLAGS: -DSECP256K1_MSVC_MULH_TEST_OVERRIDE
-    - name: "i686 (MSVC): Windows (Debian stable, Wine)"
-      env:
-        HOST: i686-w64-mingw32
-        CC: /opt/msvc/bin/x86/cl
-        AR: /opt/msvc/bin/x86/lib
-        NM: /opt/msvc/bin/x86/dumpbin -symbols -headers
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-# Sanitizers
-task:
-  << : *LINUX_CONTAINER
-  env:
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  matrix:
-    - name: "Valgrind (memcheck)"
-      container:
-        cpu: 2
-      env:
-        # The `--error-exitcode` is required to make the test fail if valgrind found errors, otherwise it'll return 0 (https://www.valgrind.org/docs/manual/manual-core.html)
-        WRAPPER_CMD: "valgrind --error-exitcode=42"
-        SECP256K1_TEST_ITERS: 2
-    - name: "UBSan, ASan, LSan"
-      container:
-        memory: 2G
-      env:
-        CFLAGS: "-fsanitize=undefined,address -g"
-        UBSAN_OPTIONS: "print_stacktrace=1:halt_on_error=1"
-        ASAN_OPTIONS: "strict_string_checks=1:detect_stack_use_after_return=1:detect_leaks=1"
-        LSAN_OPTIONS: "use_unaligned=1"
-        SECP256K1_TEST_ITERS: 32
-  # Try to cover many configurations with just a tiny matrix.
-  matrix:
-    - env:
-        ASM: auto
-    - env:
-        ASM: no
-        ECMULTGENPRECISION: 2
-        ECMULTWINDOW: 2
-  matrix:
-    - env:
-        CC: clang
-    - env:
-        HOST: i686-linux-gnu
-        CC: i686-linux-gnu-gcc
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-# Memory sanitizers
-task:
-  << : *LINUX_CONTAINER
-  name: "MSan"
-  env:
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: yes
-    CC: clang
-    SECP256K1_TEST_ITERS: 32
-    ASM: no
-    WITH_VALGRIND: no
-  container:
-    memory: 2G
-  matrix:
-    - env:
-        CFLAGS: "-fsanitize=memory -g"
-    - env:
-        ECMULTGENPRECISION: 2
-        ECMULTWINDOW: 2
-        CFLAGS: "-fsanitize=memory -g -O3"
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "C++ -fpermissive (entire project)"
-  << : *LINUX_CONTAINER
-  env:
-    CC: g++
-    CFLAGS: -fpermissive -g
-    CPPFLAGS: -DSECP256K1_CPLUSPLUS_TEST_OVERRIDE
-    WERROR_CFLAGS:
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "C++ (public headers)"
-  << : *LINUX_CONTAINER
-  test_script:
-    - g++ -Werror include/*.h
-    - clang -Werror -x c++-header include/*.h
-    - /opt/msvc/bin/x64/cl.exe -c -WX -TP include/*.h
-
-task:
-  name: "sage prover"
-  << : *LINUX_CONTAINER
-  test_script:
-    - cd sage
-    - sage prove_group_implementations.sage
-
-task:
-  name: "x86_64: Windows (VS 2022)"
-  windows_container:
-    image: cirrusci/windowsservercore:visualstudio2022
-    cpu: 4
-    memory: 3840MB
-  env:
-    PATH: '%CIRRUS_WORKING_DIR%\build\src\RelWithDebInfo;%PATH%'
-    x64_NATIVE_TOOLS: '"C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Auxiliary\Build\vcvars64.bat"'
-    # Ignore MSBuild warning MSB8029.
-    # See: https://learn.microsoft.com/en-us/visualstudio/msbuild/errors/msb8029?view=vs-2022
-    IgnoreWarnIntDirInTempDetected: 'true'
-  merge_script:
-    - PowerShell -NoLogo -Command if ($env:CIRRUS_PR -ne $null) { git fetch $env:CIRRUS_REPO_CLONE_URL pull/$env:CIRRUS_PR/merge; git reset --hard FETCH_HEAD; }
-  configure_script:
-    - '%x64_NATIVE_TOOLS%'
-    - cmake -E env CFLAGS="/WX" cmake -G "Visual Studio 17 2022" -A x64 -S . -B build -DSECP256K1_ENABLE_MODULE_RECOVERY=ON -DSECP256K1_BUILD_EXAMPLES=ON
-  build_script:
-    - '%x64_NATIVE_TOOLS%'
-    - cmake --build build --config RelWithDebInfo -- -property:UseMultiToolTask=true;CL_MPcount=5
-  check_script:
-    - '%x64_NATIVE_TOOLS%'
-    - ctest -C RelWithDebInfo --test-dir build -j 5
-    - build\src\RelWithDebInfo\bench_ecmult.exe
-    - build\src\RelWithDebInfo\bench_internal.exe
-    - build\src\RelWithDebInfo\bench.exe

external/secp256k1/.gitattributes

@@ -1,2 +0,0 @@
-src/precomputed_ecmult.c linguist-generated
-src/precomputed_ecmult_gen.c linguist-generated

external/secp256k1/CHANGELOG.md

@@ -1,93 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [0.3.2] - 2023-05-13
-We strongly recommend updating to 0.3.2 if you use or plan to use GCC >=13 to compile libsecp256k1. When in doubt, check the GCC version using `gcc -v`.
-
-#### Security
- - Module `ecdh`: Fix "constant-timeness" issue with GCC 13.1 (and potentially future versions of GCC) that could leave applications using libsecp256k1's ECDH module vulnerable to a timing side-channel attack. The fix avoids secret-dependent control flow during ECDH computations when libsecp256k1 is compiled with GCC 13.1.
-
-#### Fixed
- - Fixed an old bug that permitted compilers to potentially output bad assembly code on x86_64. In theory, it could lead to a crash or a read of unrelated memory, but this has never been observed on any compilers so far.
-
-#### Changed
- - Various improvements and changes to CMake builds. CMake builds remain experimental.
-   - Made API versioning consistent with GNU Autotools builds.
-   - Switched to `BUILD_SHARED_LIBS` variable for controlling whether to build a static or a shared library.
-   - Added `SECP256K1_INSTALL` variable for the controlling whether to install the build artefacts.
- - Renamed asm build option `arm` to `arm32`. Use `--with-asm=arm32` instead of `--with-asm=arm` (GNU Autotools), and `-DSECP256K1_ASM=arm32` instead of `-DSECP256K1_ASM=arm` (CMake).
-
-#### ABI Compatibility
-The ABI is compatible with versions 0.3.0 and 0.3.1.
-
-## [0.3.1] - 2023-04-10
-We strongly recommend updating to 0.3.1 if you use or plan to use Clang >=14 to compile libsecp256k1, e.g., Xcode >=14 on macOS has Clang >=14. When in doubt, check the Clang version using `clang -v`.
-
-#### Security
- - Fix "constant-timeness" issue with Clang >=14 that could leave applications using libsecp256k1 vulnerable to a timing side-channel attack. The fix avoids secret-dependent control flow and secret-dependent memory accesses in conditional moves of memory objects when libsecp256k1 is compiled with Clang >=14.
-
-#### Added
-  - Added tests against [Project Wycheproof's](https://github.com/google/wycheproof/) set of ECDSA test vectors (Bitcoin "low-S" variant), a fixed set of test cases designed to trigger various edge cases.
-
-#### Changed
- - Increased minimum required CMake version to 3.13. CMake builds remain experimental.
-
-#### ABI Compatibility
-The ABI is compatible with version 0.3.0.
-
-## [0.3.0] - 2023-03-08
-
-#### Added
- - Added experimental support for CMake builds. Traditional GNU Autotools builds (`./configure` and `make`) remain fully supported.
- - Usage examples: Added a recommended method for securely clearing sensitive data, e.g., secret keys, from memory.
- - Tests: Added a new test binary `noverify_tests`. This binary runs the tests without some additional checks present in the ordinary `tests` binary and is thereby closer to production binaries. The `noverify_tests` binary is automatically run as part of the `make check` target.
-
-#### Fixed
- - Fixed declarations of API variables for MSVC (`__declspec(dllimport)`). This fixes MSVC builds of programs which link against a libsecp256k1 DLL dynamically and use API variables (and not only API functions). Unfortunately, the MSVC linker now will emit warning `LNK4217` when trying to link against libsecp256k1 statically. Pass `/ignore:4217` to the linker to suppress this warning.
-
-#### Changed
- - Forbade cloning or destroying `secp256k1_context_static`. Create a new context instead of cloning the static context. (If this change breaks your code, your code is probably wrong.)
- - Forbade randomizing (copies of) `secp256k1_context_static`. Randomizing a copy of `secp256k1_context_static` did not have any effect and did not provide defense-in-depth protection against side-channel attacks. Create a new context if you want to benefit from randomization.
-
-#### Removed
- - Removed the configuration header `src/libsecp256k1-config.h`. We recommend passing flags to `./configure` or `cmake` to set configuration options (see `./configure --help` or `cmake -LH`). If you cannot or do not want to use one of the supported build systems, pass configuration flags such as `-DSECP256K1_ENABLE_MODULE_SCHNORRSIG` manually to the compiler (see the file `configure.ac` for supported flags).
-
-#### ABI Compatibility
-Due to changes in the API regarding `secp256k1_context_static` described above, the ABI is *not* compatible with previous versions.
-
-## [0.2.0] - 2022-12-12
-
-#### Added
- - Added usage examples for common use cases in a new `examples/` directory.
- - Added `secp256k1_selftest`, to be used in conjunction with `secp256k1_context_static`.
- - Added support for 128-bit wide multiplication on MSVC for x86_64 and arm64, giving roughly a 20% speedup on those platforms.
-
-#### Changed
- - Enabled modules `schnorrsig`, `extrakeys` and `ecdh` by default in `./configure`.
- - The `secp256k1_nonce_function_rfc6979` nonce function, used by default by `secp256k1_ecdsa_sign`, now reduces the message hash modulo the group order to match the specification. This only affects improper use of ECDSA signing API.
-
-#### Deprecated
- - Deprecated context flags `SECP256K1_CONTEXT_VERIFY` and `SECP256K1_CONTEXT_SIGN`. Use `SECP256K1_CONTEXT_NONE` instead.
- - Renamed `secp256k1_context_no_precomp` to `secp256k1_context_static`.
- - Module `schnorrsig`: renamed `secp256k1_schnorrsig_sign` to `secp256k1_schnorrsig_sign32`.
-
-#### ABI Compatibility
-Since this is the first release, we do not compare application binary interfaces.
-However, there are earlier unreleased versions of libsecp256k1 that are *not* ABI compatible with this version.
-
-## [0.1.0] - 2013-03-05 to 2021-12-25
-
-This version was in fact never released.
-The number was given by the build system since the introduction of autotools in Jan 2014 (ea0fe5a5bf0c04f9cc955b2966b614f5f378c6f6).
-Therefore, this version number does not uniquely identify a set of source files.
-
-[unreleased]: https://github.com/bitcoin-core/secp256k1/compare/v0.3.2...HEAD
-[0.3.2]: https://github.com/bitcoin-core/secp256k1/compare/v0.3.1...v0.3.2
-[0.3.1]: https://github.com/bitcoin-core/secp256k1/compare/v0.3.0...v0.3.1
-[0.3.0]: https://github.com/bitcoin-core/secp256k1/compare/v0.2.0...v0.3.0
-[0.2.0]: https://github.com/bitcoin-core/secp256k1/compare/423b6d19d373f1224fd671a982584d7e7900bc93..v0.2.0
-[0.1.0]: https://github.com/bitcoin-core/secp256k1/commit/423b6d19d373f1224fd671a982584d7e7900bc93

external/secp256k1/CMakeLists.txt

@@ -1,331 +0,0 @@
-cmake_minimum_required(VERSION 3.13)
-
-if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.15)
-  # MSVC runtime library flags are selected by the CMAKE_MSVC_RUNTIME_LIBRARY abstraction.
-  cmake_policy(SET CMP0091 NEW)
-  # MSVC warning flags are not in CMAKE_<LANG>_FLAGS by default.
-  cmake_policy(SET CMP0092 NEW)
-endif()
-
-project(libsecp256k1
-  # The package (a.k.a. release) version is based on semantic versioning 2.0.0 of
-  # the API. All changes in experimental modules are treated as
-  # backwards-compatible and therefore at most increase the minor version.
-  VERSION 0.3.2
-  DESCRIPTION "Optimized C library for ECDSA signatures and secret/public key operations on curve secp256k1."
-  HOMEPAGE_URL "https://github.com/bitcoin-core/secp256k1"
-  LANGUAGES C
-)
-
-if(CMAKE_VERSION VERSION_LESS 3.21)
-  get_directory_property(parent_directory PARENT_DIRECTORY)
-  if(parent_directory)
-    set(PROJECT_IS_TOP_LEVEL OFF CACHE INTERNAL "Emulates CMake 3.21+ behavior.")
-    set(${PROJECT_NAME}_IS_TOP_LEVEL OFF CACHE INTERNAL "Emulates CMake 3.21+ behavior.")
-  else()
-    set(PROJECT_IS_TOP_LEVEL ON CACHE INTERNAL "Emulates CMake 3.21+ behavior.")
-    set(${PROJECT_NAME}_IS_TOP_LEVEL ON CACHE INTERNAL "Emulates CMake 3.21+ behavior.")
-  endif()
-  unset(parent_directory)
-endif()
-
-# The library version is based on libtool versioning of the ABI. The set of
-# rules for updating the version can be found here:
-# https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
-# All changes in experimental modules are treated as if they don't affect the
-# interface and therefore only increase the revision.
-set(${PROJECT_NAME}_LIB_VERSION_CURRENT 2)
-set(${PROJECT_NAME}_LIB_VERSION_REVISION 2)
-set(${PROJECT_NAME}_LIB_VERSION_AGE 0)
-
-set(CMAKE_C_STANDARD 90)
-set(CMAKE_C_EXTENSIONS OFF)
-
-list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
-
-option(BUILD_SHARED_LIBS "Build shared libraries." ON)
-option(SECP256K1_DISABLE_SHARED "Disable shared library. Overrides BUILD_SHARED_LIBS." OFF)
-if(SECP256K1_DISABLE_SHARED)
-  set(BUILD_SHARED_LIBS OFF)
-endif()
-
-option(SECP256K1_INSTALL "Enable installation." ${PROJECT_IS_TOP_LEVEL})
-
-option(SECP256K1_ENABLE_MODULE_ECDH "Enable ECDH module." ON)
-if(SECP256K1_ENABLE_MODULE_ECDH)
-  add_compile_definitions(ENABLE_MODULE_ECDH=1)
-endif()
-
-option(SECP256K1_ENABLE_MODULE_RECOVERY "Enable ECDSA pubkey recovery module." OFF)
-if(SECP256K1_ENABLE_MODULE_RECOVERY)
-  add_compile_definitions(ENABLE_MODULE_RECOVERY=1)
-endif()
-
-option(SECP256K1_ENABLE_MODULE_EXTRAKEYS "Enable extrakeys module." ON)
-option(SECP256K1_ENABLE_MODULE_SCHNORRSIG "Enable schnorrsig module." ON)
-if(SECP256K1_ENABLE_MODULE_SCHNORRSIG)
-  set(SECP256K1_ENABLE_MODULE_EXTRAKEYS ON)
-  add_compile_definitions(ENABLE_MODULE_SCHNORRSIG=1)
-endif()
-if(SECP256K1_ENABLE_MODULE_EXTRAKEYS)
-  add_compile_definitions(ENABLE_MODULE_EXTRAKEYS=1)
-endif()
-
-option(SECP256K1_USE_EXTERNAL_DEFAULT_CALLBACKS "Enable external default callback functions." OFF)
-if(SECP256K1_USE_EXTERNAL_DEFAULT_CALLBACKS)
-  add_compile_definitions(USE_EXTERNAL_DEFAULT_CALLBACKS=1)
-endif()
-
-set(SECP256K1_ECMULT_WINDOW_SIZE "AUTO" CACHE STRING "Window size for ecmult precomputation for verification, specified as integer in range [2..24]. \"AUTO\" is a reasonable setting for desktop machines (currently 15). [default=AUTO]")
-set_property(CACHE SECP256K1_ECMULT_WINDOW_SIZE PROPERTY STRINGS "AUTO" 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24)
-include(CheckStringOptionValue)
-check_string_option_value(SECP256K1_ECMULT_WINDOW_SIZE)
-if(SECP256K1_ECMULT_WINDOW_SIZE STREQUAL "AUTO")
-  set(SECP256K1_ECMULT_WINDOW_SIZE 15)
-endif()
-add_compile_definitions(ECMULT_WINDOW_SIZE=${SECP256K1_ECMULT_WINDOW_SIZE})
-
-set(SECP256K1_ECMULT_GEN_PREC_BITS "AUTO" CACHE STRING "Precision bits to tune the precomputed table size for signing, specified as integer 2, 4 or 8. \"AUTO\" is a reasonable setting for desktop machines (currently 4). [default=AUTO]")
-set_property(CACHE SECP256K1_ECMULT_GEN_PREC_BITS PROPERTY STRINGS "AUTO" 2 4 8)
-check_string_option_value(SECP256K1_ECMULT_GEN_PREC_BITS)
-if(SECP256K1_ECMULT_GEN_PREC_BITS STREQUAL "AUTO")
-  set(SECP256K1_ECMULT_GEN_PREC_BITS 4)
-endif()
-add_compile_definitions(ECMULT_GEN_PREC_BITS=${SECP256K1_ECMULT_GEN_PREC_BITS})
-
-set(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY "OFF" CACHE STRING "Test-only override of the (autodetected by the C code) \"widemul\" setting. Legal values are: \"OFF\", \"int128_struct\", \"int128\" or \"int64\". [default=OFF]")
-set_property(CACHE SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY PROPERTY STRINGS "OFF" "int128_struct" "int128" "int64")
-check_string_option_value(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY)
-if(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY)
-  string(TOUPPER "${SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY}" widemul_upper_value)
-  add_compile_definitions(USE_FORCE_WIDEMUL_${widemul_upper_value}=1)
-endif()
-mark_as_advanced(FORCE SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY)
-
-set(SECP256K1_ASM "AUTO" CACHE STRING "Assembly optimizations to use: \"AUTO\", \"OFF\", \"x86_64\" or \"arm32\" (experimental). [default=AUTO]")
-set_property(CACHE SECP256K1_ASM PROPERTY STRINGS "AUTO" "OFF" "x86_64" "arm32")
-check_string_option_value(SECP256K1_ASM)
-if(SECP256K1_ASM STREQUAL "arm32")
-  enable_language(ASM)
-  include(CheckArm32Assembly)
-  check_arm32_assembly()
-  if(HAVE_ARM32_ASM)
-    add_compile_definitions(USE_EXTERNAL_ASM=1)
-  else()
-    message(FATAL_ERROR "ARM32 assembly optimization requested but not available.")
-  endif()
-elseif(SECP256K1_ASM)
-  include(CheckX86_64Assembly)
-  check_x86_64_assembly()
-  if(HAVE_X86_64_ASM)
-    set(SECP256K1_ASM "x86_64")
-    add_compile_definitions(USE_ASM_X86_64=1)
-  elseif(SECP256K1_ASM STREQUAL "AUTO")
-    set(SECP256K1_ASM "OFF")
-  else()
-    message(FATAL_ERROR "x86_64 assembly optimization requested but not available.")
-  endif()
-endif()
-
-option(SECP256K1_EXPERIMENTAL "Allow experimental configuration options." OFF)
-if(NOT SECP256K1_EXPERIMENTAL)
-  if(SECP256K1_ASM STREQUAL "arm32")
-    message(FATAL_ERROR "ARM32 assembly optimization is experimental. Use -DSECP256K1_EXPERIMENTAL=ON to allow.")
-  endif()
-endif()
-
-set(SECP256K1_VALGRIND "AUTO" CACHE STRING "Build with extra checks for running inside Valgrind. [default=AUTO]")
-set_property(CACHE SECP256K1_VALGRIND PROPERTY STRINGS "AUTO" "OFF" "ON")
-check_string_option_value(SECP256K1_VALGRIND)
-if(SECP256K1_VALGRIND)
-  find_package(Valgrind MODULE)
-  if(Valgrind_FOUND)
-    set(SECP256K1_VALGRIND ON)
-    include_directories(${Valgrind_INCLUDE_DIR})
-    add_compile_definitions(VALGRIND)
-  elseif(SECP256K1_VALGRIND STREQUAL "AUTO")
-    set(SECP256K1_VALGRIND OFF)
-  else()
-    message(FATAL_ERROR "Valgrind support requested but valgrind/memcheck.h header not available.")
-  endif()
-endif()
-
-option(SECP256K1_BUILD_BENCHMARK "Build benchmarks." ON)
-option(SECP256K1_BUILD_TESTS "Build tests." ON)
-option(SECP256K1_BUILD_EXHAUSTIVE_TESTS "Build exhaustive tests." ON)
-option(SECP256K1_BUILD_CTIME_TESTS "Build constant-time tests." ${SECP256K1_VALGRIND})
-option(SECP256K1_BUILD_EXAMPLES "Build examples." OFF)
-
-# Redefine configuration flags.
-# We leave assertions on, because they are only used in the examples, and we want them always on there.
-if(MSVC)
-  string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
-  string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
-  string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}")
-else()
-  string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
-  string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
-  string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}")
-  # Prefer -O2 optimization level. (-O3 is CMake's default for Release for many compilers.)
-  string(REGEX REPLACE "-O3[ \t\r\n]*" "-O2" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
-endif()
-
-# Define custom "Coverage" build type.
-set(CMAKE_C_FLAGS_COVERAGE "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O0 -DCOVERAGE=1 --coverage" CACHE STRING
-  "Flags used by the C compiler during \"Coverage\" builds."
-  FORCE
-)
-set(CMAKE_EXE_LINKER_FLAGS_COVERAGE "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} --coverage" CACHE STRING
-  "Flags used for linking binaries during \"Coverage\" builds."
-  FORCE
-)
-set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} --coverage" CACHE STRING
-  "Flags used by the shared libraries linker during \"Coverage\" builds."
-  FORCE
-)
-mark_as_advanced(
-  CMAKE_C_FLAGS_COVERAGE
-  CMAKE_EXE_LINKER_FLAGS_COVERAGE
-  CMAKE_SHARED_LINKER_FLAGS_COVERAGE
-)
-
-get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-set(default_build_type "RelWithDebInfo")
-if(is_multi_config)
-  set(CMAKE_CONFIGURATION_TYPES "${default_build_type}" "Release" "Debug" "MinSizeRel" "Coverage" CACHE STRING
-    "Supported configuration types."
-    FORCE
-  )
-else()
-  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY
-    STRINGS "${default_build_type}" "Release" "Debug" "MinSizeRel" "Coverage"
-  )
-  if(NOT CMAKE_BUILD_TYPE)
-    message(STATUS "Setting build type to \"${default_build_type}\" as none was specified")
-    set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE STRING
-      "Choose the type of build."
-      FORCE
-    )
-  endif()
-endif()
-
-include(TryAppendCFlags)
-if(MSVC)
-  # Keep the following commands ordered lexicographically.
-  try_append_c_flags(/W2) # Moderate warning level.
-  try_append_c_flags(/wd4146) # Disable warning C4146 "unary minus operator applied to unsigned type, result still unsigned".
-else()
-  # Keep the following commands ordered lexicographically.
-  try_append_c_flags(-pedantic)
-  try_append_c_flags(-Wall) # GCC >= 2.95 and probably many other compilers.
-  try_append_c_flags(-Wcast-align) # GCC >= 2.95.
-  try_append_c_flags(-Wcast-align=strict) # GCC >= 8.0.
-  try_append_c_flags(-Wconditional-uninitialized) # Clang >= 3.0 only.
-  try_append_c_flags(-Wextra) # GCC >= 3.4, this is the newer name of -W, which we don't use because older GCCs will warn about unused functions.
-  try_append_c_flags(-Wnested-externs)
-  try_append_c_flags(-Wno-long-long) # GCC >= 3.0, -Wlong-long is implied by -pedantic.
-  try_append_c_flags(-Wno-overlength-strings) # GCC >= 4.2, -Woverlength-strings is implied by -pedantic.
-  try_append_c_flags(-Wno-unused-function) # GCC >= 3.0, -Wunused-function is implied by -Wall.
-  try_append_c_flags(-Wreserved-identifier) # Clang >= 13.0 only.
-  try_append_c_flags(-Wshadow)
-  try_append_c_flags(-Wstrict-prototypes)
-  try_append_c_flags(-Wundef)
-endif()
-
-set(CMAKE_C_VISIBILITY_PRESET hidden)
-
-# Ask CTest to create a "check" target (e.g., make check) as alias for the "test" target.
-# CTEST_TEST_TARGET_ALIAS is not documented but supposed to be user-facing.
-# See: https://gitlab.kitware.com/cmake/cmake/-/commit/816c9d1aa1f2b42d40c81a991b68c96eb12b6d2
-set(CTEST_TEST_TARGET_ALIAS check)
-include(CTest)
-# We do not use CTest's BUILD_TESTING because a single toggle for all tests is too coarse for our needs.
-mark_as_advanced(BUILD_TESTING)
-if(SECP256K1_BUILD_BENCHMARK OR SECP256K1_BUILD_TESTS OR SECP256K1_BUILD_EXHAUSTIVE_TESTS OR SECP256K1_BUILD_CTIME_TESTS OR SECP256K1_BUILD_EXAMPLES)
-  enable_testing()
-endif()
-
-add_subdirectory(src)
-if(SECP256K1_BUILD_EXAMPLES)
-  add_subdirectory(examples)
-endif()
-
-message("\n")
-message("secp256k1 configure summary")
-message("===========================")
-message("Build artifacts:")
-if(BUILD_SHARED_LIBS)
-  set(library_type "Shared")
-else()
-  set(library_type "Static")
-endif()
-
-message("  library type ........................ ${library_type}")
-message("Optional modules:")
-message("  ECDH ................................ ${SECP256K1_ENABLE_MODULE_ECDH}")
-message("  ECDSA pubkey recovery ............... ${SECP256K1_ENABLE_MODULE_RECOVERY}")
-message("  extrakeys ........................... ${SECP256K1_ENABLE_MODULE_EXTRAKEYS}")
-message("  schnorrsig .......................... ${SECP256K1_ENABLE_MODULE_SCHNORRSIG}")
-message("Parameters:")
-message("  ecmult window size .................. ${SECP256K1_ECMULT_WINDOW_SIZE}")
-message("  ecmult gen precision bits ........... ${SECP256K1_ECMULT_GEN_PREC_BITS}")
-message("Optional features:")
-message("  assembly optimization ............... ${SECP256K1_ASM}")
-message("  external callbacks .................. ${SECP256K1_USE_EXTERNAL_DEFAULT_CALLBACKS}")
-if(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY)
-  message("  wide multiplication (test-only) ..... ${SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY}")
-endif()
-message("Optional binaries:")
-message("  benchmark ........................... ${SECP256K1_BUILD_BENCHMARK}")
-message("  noverify_tests ...................... ${SECP256K1_BUILD_TESTS}")
-set(tests_status "${SECP256K1_BUILD_TESTS}")
-if(CMAKE_BUILD_TYPE STREQUAL "Coverage")
-  set(tests_status OFF)
-endif()
-message("  tests ............................... ${tests_status}")
-message("  exhaustive tests .................... ${SECP256K1_BUILD_EXHAUSTIVE_TESTS}")
-message("  ctime_tests ......................... ${SECP256K1_BUILD_CTIME_TESTS}")
-message("  examples ............................ ${SECP256K1_BUILD_EXAMPLES}")
-message("")
-if(CMAKE_CROSSCOMPILING)
-  set(cross_status "TRUE, for ${CMAKE_SYSTEM_NAME}, ${CMAKE_SYSTEM_PROCESSOR}")
-else()
-  set(cross_status "FALSE")
-endif()
-message("Cross compiling ....................... ${cross_status}")
-message("Valgrind .............................. ${SECP256K1_VALGRIND}")
-get_directory_property(definitions COMPILE_DEFINITIONS)
-string(REPLACE ";" " " definitions "${definitions}")
-message("Preprocessor defined macros ........... ${definitions}")
-message("C compiler ............................ ${CMAKE_C_COMPILER}")
-message("CFLAGS ................................ ${CMAKE_C_FLAGS}")
-get_directory_property(compile_options COMPILE_OPTIONS)
-string(REPLACE ";" " " compile_options "${compile_options}")
-message("Compile options ....................... " ${compile_options})
-if(NOT is_multi_config)
-  message("Build type:")
-  message(" - CMAKE_BUILD_TYPE ................... ${CMAKE_BUILD_TYPE}")
-  string(TOUPPER "${CMAKE_BUILD_TYPE}" build_type)
-  message(" - CFLAGS ............................. ${CMAKE_C_FLAGS_${build_type}}")
-  message(" - LDFLAGS for executables ............ ${CMAKE_EXE_LINKER_FLAGS_${build_type}}")
-  message(" - LDFLAGS for shared libraries ....... ${CMAKE_SHARED_LINKER_FLAGS_${build_type}}")
-else()
-  message("Supported configurations .............. ${CMAKE_CONFIGURATION_TYPES}")
-  message("RelWithDebInfo configuration:")
-  message(" - CFLAGS ............................. ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
-  message(" - LDFLAGS for executables ............ ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO}")
-  message(" - LDFLAGS for shared libraries ....... ${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO}")
-  message("Debug configuration:")
-  message(" - CFLAGS ............................. ${CMAKE_C_FLAGS_DEBUG}")
-  message(" - LDFLAGS for executables ............ ${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
-  message(" - LDFLAGS for shared libraries ....... ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
-endif()
-message("\n")
-if(SECP256K1_EXPERIMENTAL)
-  message(
-    "  ******\n"
-    "  WARNING: experimental build\n"
-    "  Experimental features do not have stable APIs or properties, and may not be safe for production use.\n"
-    "  ******\n"
-  )
-endif()

external/secp256k1/CMakePresets.json

@@ -1,19 +0,0 @@
-{
-  "cmakeMinimumRequired": {"major": 3, "minor": 21, "patch": 0}, 
-  "version": 3,
-  "configurePresets": [
-    {
-      "name": "dev-mode",
-      "displayName": "Development mode (intended only for developers of the library)",
-      "cacheVariables": {
-        "SECP256K1_EXPERIMENTAL": "ON",
-        "SECP256K1_ENABLE_MODULE_RECOVERY": "ON",
-        "SECP256K1_BUILD_EXAMPLES": "ON"
-      },
-      "warnings": {
-        "dev": true,
-        "uninitialized": true
-      }
-    }
-  ]
-}

external/secp256k1/Makefile.am

@@ -1,269 +0,0 @@
-ACLOCAL_AMFLAGS = -I build-aux/m4
-
-# AM_CFLAGS will be automatically prepended to CFLAGS by Automake when compiling some foo
-# which does not have an explicit foo_CFLAGS variable set.
-AM_CFLAGS = $(SECP_CFLAGS)
-
-lib_LTLIBRARIES = libsecp256k1.la
-include_HEADERS = include/secp256k1.h
-include_HEADERS += include/secp256k1_preallocated.h
-noinst_HEADERS =
-noinst_HEADERS += src/scalar.h
-noinst_HEADERS += src/scalar_4x64.h
-noinst_HEADERS += src/scalar_8x32.h
-noinst_HEADERS += src/scalar_low.h
-noinst_HEADERS += src/scalar_impl.h
-noinst_HEADERS += src/scalar_4x64_impl.h
-noinst_HEADERS += src/scalar_8x32_impl.h
-noinst_HEADERS += src/scalar_low_impl.h
-noinst_HEADERS += src/group.h
-noinst_HEADERS += src/group_impl.h
-noinst_HEADERS += src/ecdsa.h
-noinst_HEADERS += src/ecdsa_impl.h
-noinst_HEADERS += src/eckey.h
-noinst_HEADERS += src/eckey_impl.h
-noinst_HEADERS += src/ecmult.h
-noinst_HEADERS += src/ecmult_impl.h
-noinst_HEADERS += src/ecmult_compute_table.h
-noinst_HEADERS += src/ecmult_compute_table_impl.h
-noinst_HEADERS += src/ecmult_const.h
-noinst_HEADERS += src/ecmult_const_impl.h
-noinst_HEADERS += src/ecmult_gen.h
-noinst_HEADERS += src/ecmult_gen_impl.h
-noinst_HEADERS += src/ecmult_gen_compute_table.h
-noinst_HEADERS += src/ecmult_gen_compute_table_impl.h
-noinst_HEADERS += src/field_10x26.h
-noinst_HEADERS += src/field_10x26_impl.h
-noinst_HEADERS += src/field_5x52.h
-noinst_HEADERS += src/field_5x52_impl.h
-noinst_HEADERS += src/field_5x52_int128_impl.h
-noinst_HEADERS += src/field_5x52_asm_impl.h
-noinst_HEADERS += src/modinv32.h
-noinst_HEADERS += src/modinv32_impl.h
-noinst_HEADERS += src/modinv64.h
-noinst_HEADERS += src/modinv64_impl.h
-noinst_HEADERS += src/precomputed_ecmult.h
-noinst_HEADERS += src/precomputed_ecmult_gen.h
-noinst_HEADERS += src/assumptions.h
-noinst_HEADERS += src/checkmem.h
-noinst_HEADERS += src/util.h
-noinst_HEADERS += src/int128.h
-noinst_HEADERS += src/int128_impl.h
-noinst_HEADERS += src/int128_native.h
-noinst_HEADERS += src/int128_native_impl.h
-noinst_HEADERS += src/int128_struct.h
-noinst_HEADERS += src/int128_struct_impl.h
-noinst_HEADERS += src/scratch.h
-noinst_HEADERS += src/scratch_impl.h
-noinst_HEADERS += src/selftest.h
-noinst_HEADERS += src/testrand.h
-noinst_HEADERS += src/testrand_impl.h
-noinst_HEADERS += src/hash.h
-noinst_HEADERS += src/hash_impl.h
-noinst_HEADERS += src/field.h
-noinst_HEADERS += src/field_impl.h
-noinst_HEADERS += src/bench.h
-noinst_HEADERS += src/wycheproof/ecdsa_secp256k1_sha256_bitcoin_test.h
-noinst_HEADERS += contrib/lax_der_parsing.h
-noinst_HEADERS += contrib/lax_der_parsing.c
-noinst_HEADERS += contrib/lax_der_privatekey_parsing.h
-noinst_HEADERS += contrib/lax_der_privatekey_parsing.c
-noinst_HEADERS += examples/examples_util.h
-
-PRECOMPUTED_LIB = libsecp256k1_precomputed.la
-noinst_LTLIBRARIES = $(PRECOMPUTED_LIB)
-libsecp256k1_precomputed_la_SOURCES =  src/precomputed_ecmult.c src/precomputed_ecmult_gen.c
-# We need `-I$(top_srcdir)/src` in VPATH builds if libsecp256k1_precomputed_la_SOURCES have been recreated in the build tree.
-# This helps users and packagers who insist on recreating the precomputed files (e.g., Gentoo).
-libsecp256k1_precomputed_la_CPPFLAGS = -I$(top_srcdir)/src $(SECP_CONFIG_DEFINES)
-
-if USE_EXTERNAL_ASM
-COMMON_LIB = libsecp256k1_common.la
-else
-COMMON_LIB =
-endif
-noinst_LTLIBRARIES += $(COMMON_LIB)
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = libsecp256k1.pc
-
-if USE_EXTERNAL_ASM
-if USE_ASM_ARM
-libsecp256k1_common_la_SOURCES = src/asm/field_10x26_arm.s
-endif
-endif
-
-libsecp256k1_la_SOURCES = src/secp256k1.c
-libsecp256k1_la_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-libsecp256k1_la_LIBADD = $(COMMON_LIB) $(PRECOMPUTED_LIB)
-libsecp256k1_la_LDFLAGS = -no-undefined -version-info $(LIB_VERSION_CURRENT):$(LIB_VERSION_REVISION):$(LIB_VERSION_AGE)
-
-noinst_PROGRAMS =
-if USE_BENCHMARK
-noinst_PROGRAMS += bench bench_internal bench_ecmult
-bench_SOURCES = src/bench.c
-bench_LDADD = libsecp256k1.la
-bench_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-bench_internal_SOURCES = src/bench_internal.c
-bench_internal_LDADD = $(COMMON_LIB) $(PRECOMPUTED_LIB)
-bench_internal_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-bench_ecmult_SOURCES = src/bench_ecmult.c
-bench_ecmult_LDADD = $(COMMON_LIB) $(PRECOMPUTED_LIB)
-bench_ecmult_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-endif
-
-TESTS =
-if USE_TESTS
-TESTS += noverify_tests
-noinst_PROGRAMS += noverify_tests
-noverify_tests_SOURCES = src/tests.c
-noverify_tests_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-noverify_tests_LDADD = $(COMMON_LIB) $(PRECOMPUTED_LIB)
-noverify_tests_LDFLAGS = -static
-if !ENABLE_COVERAGE
-TESTS += tests
-noinst_PROGRAMS += tests
-tests_SOURCES  = $(noverify_tests_SOURCES)
-tests_CPPFLAGS = $(noverify_tests_CPPFLAGS) -DVERIFY
-tests_LDADD    = $(noverify_tests_LDADD)
-tests_LDFLAGS  = $(noverify_tests_LDFLAGS)
-endif
-endif
-
-if USE_CTIME_TESTS
-noinst_PROGRAMS += ctime_tests
-ctime_tests_SOURCES = src/ctime_tests.c
-ctime_tests_LDADD = libsecp256k1.la
-ctime_tests_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-endif
-
-if USE_EXHAUSTIVE_TESTS
-noinst_PROGRAMS += exhaustive_tests
-exhaustive_tests_SOURCES = src/tests_exhaustive.c
-exhaustive_tests_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-if !ENABLE_COVERAGE
-exhaustive_tests_CPPFLAGS += -DVERIFY
-endif
-# Note: do not include $(PRECOMPUTED_LIB) in exhaustive_tests (it uses runtime-generated tables).
-exhaustive_tests_LDADD = $(COMMON_LIB)
-exhaustive_tests_LDFLAGS = -static
-TESTS += exhaustive_tests
-endif
-
-if USE_EXAMPLES
-noinst_PROGRAMS += ecdsa_example
-ecdsa_example_SOURCES = examples/ecdsa.c
-ecdsa_example_CPPFLAGS = -I$(top_srcdir)/include
-ecdsa_example_LDADD = libsecp256k1.la
-ecdsa_example_LDFLAGS = -static
-if BUILD_WINDOWS
-ecdsa_example_LDFLAGS += -lbcrypt
-endif
-TESTS += ecdsa_example
-if ENABLE_MODULE_ECDH
-noinst_PROGRAMS += ecdh_example
-ecdh_example_SOURCES = examples/ecdh.c
-ecdh_example_CPPFLAGS = -I$(top_srcdir)/include
-ecdh_example_LDADD = libsecp256k1.la
-ecdh_example_LDFLAGS = -static
-if BUILD_WINDOWS
-ecdh_example_LDFLAGS += -lbcrypt
-endif
-TESTS += ecdh_example
-endif
-if ENABLE_MODULE_SCHNORRSIG
-noinst_PROGRAMS += schnorr_example
-schnorr_example_SOURCES = examples/schnorr.c
-schnorr_example_CPPFLAGS = -I$(top_srcdir)/include
-schnorr_example_LDADD = libsecp256k1.la
-schnorr_example_LDFLAGS = -static
-if BUILD_WINDOWS
-schnorr_example_LDFLAGS += -lbcrypt
-endif
-TESTS += schnorr_example
-endif
-endif
-
-### Precomputed tables
-EXTRA_PROGRAMS = precompute_ecmult precompute_ecmult_gen
-CLEANFILES = $(EXTRA_PROGRAMS)
-
-precompute_ecmult_SOURCES = src/precompute_ecmult.c
-precompute_ecmult_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-precompute_ecmult_LDADD = $(COMMON_LIB)
-
-precompute_ecmult_gen_SOURCES = src/precompute_ecmult_gen.c
-precompute_ecmult_gen_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-precompute_ecmult_gen_LDADD = $(COMMON_LIB)
-
-# See Automake manual, Section "Errors with distclean".
-# We don't list any dependencies for the prebuilt files here because
-# otherwise make's decision whether to rebuild them (even in the first
-# build by a normal user) depends on mtimes, and thus is very fragile.
-# This means that rebuilds of the prebuilt files always need to be
-# forced by deleting them.
-src/precomputed_ecmult.c:
-	$(MAKE) $(AM_MAKEFLAGS) precompute_ecmult$(EXEEXT)
-	./precompute_ecmult$(EXEEXT)
-src/precomputed_ecmult_gen.c:
-	$(MAKE) $(AM_MAKEFLAGS) precompute_ecmult_gen$(EXEEXT)
-	./precompute_ecmult_gen$(EXEEXT)
-
-PRECOMP = src/precomputed_ecmult_gen.c src/precomputed_ecmult.c
-precomp: $(PRECOMP)
-
-# Ensure the prebuilt files will be build first (only if they don't exist,
-# e.g., after `make maintainer-clean`).
-BUILT_SOURCES = $(PRECOMP)
-
-.PHONY: clean-precomp
-clean-precomp:
-	rm -f $(PRECOMP)
-maintainer-clean-local: clean-precomp
-
-### Pregenerated test vectors
-### (see the comments in the previous section for detailed rationale)
-TESTVECTORS = src/wycheproof/ecdsa_secp256k1_sha256_bitcoin_test.h
-
-src/wycheproof/ecdsa_secp256k1_sha256_bitcoin_test.h:
-	mkdir -p $(@D)
-	python3 $(top_srcdir)/tools/tests_wycheproof_generate.py $(top_srcdir)/src/wycheproof/ecdsa_secp256k1_sha256_bitcoin_test.json > $@
-
-testvectors: $(TESTVECTORS)
-
-BUILT_SOURCES += $(TESTVECTORS)
-
-.PHONY: clean-testvectors
-clean-testvectors:
-	rm -f $(TESTVECTORS)
-maintainer-clean-local: clean-testvectors
-
-### Additional files to distribute
-EXTRA_DIST = autogen.sh CHANGELOG.md SECURITY.md
-EXTRA_DIST += doc/release-process.md doc/safegcd_implementation.md
-EXTRA_DIST += examples/EXAMPLES_COPYING
-EXTRA_DIST += sage/gen_exhaustive_groups.sage
-EXTRA_DIST += sage/gen_split_lambda_constants.sage
-EXTRA_DIST += sage/group_prover.sage
-EXTRA_DIST += sage/prove_group_implementations.sage
-EXTRA_DIST += sage/secp256k1_params.sage
-EXTRA_DIST += sage/weierstrass_prover.sage
-EXTRA_DIST += src/wycheproof/WYCHEPROOF_COPYING
-EXTRA_DIST += src/wycheproof/ecdsa_secp256k1_sha256_bitcoin_test.json
-EXTRA_DIST += tools/tests_wycheproof_generate.py
-
-if ENABLE_MODULE_ECDH
-include src/modules/ecdh/Makefile.am.include
-endif
-
-if ENABLE_MODULE_RECOVERY
-include src/modules/recovery/Makefile.am.include
-endif
-
-if ENABLE_MODULE_EXTRAKEYS
-include src/modules/extrakeys/Makefile.am.include
-endif
-
-if ENABLE_MODULE_SCHNORRSIG
-include src/modules/schnorrsig/Makefile.am.include
-endif

external/secp256k1/README.md

@@ -1,157 +0,0 @@
-libsecp256k1
-============
-
-[![Build Status](https://api.cirrus-ci.com/github/bitcoin-core/secp256k1.svg?branch=master)](https://cirrus-ci.com/github/bitcoin-core/secp256k1)
-![Dependencies: None](https://img.shields.io/badge/dependencies-none-success)
-[![irc.libera.chat #secp256k1](https://img.shields.io/badge/irc.libera.chat-%23secp256k1-success)](https://web.libera.chat/#secp256k1)
-
-Optimized C library for ECDSA signatures and secret/public key operations on curve secp256k1.
-
-This library is intended to be the highest quality publicly available library for cryptography on the secp256k1 curve. However, the primary focus of its development has been for usage in the Bitcoin system and usage unlike Bitcoin's may be less well tested, verified, or suffer from a less well thought out interface. Correct usage requires some care and consideration that the library is fit for your application's purpose.
-
-Features:
-* secp256k1 ECDSA signing/verification and key generation.
-* Additive and multiplicative tweaking of secret/public keys.
-* Serialization/parsing of secret keys, public keys, signatures.
-* Constant time, constant memory access signing and public key generation.
-* Derandomized ECDSA (via RFC6979 or with a caller provided function.)
-* Very efficient implementation.
-* Suitable for embedded systems.
-* No runtime dependencies.
-* Optional module for public key recovery.
-* Optional module for ECDH key exchange.
-* Optional module for Schnorr signatures according to [BIP-340](https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki).
-
-Implementation details
-----------------------
-
-* General
-  * No runtime heap allocation.
-  * Extensive testing infrastructure.
-  * Structured to facilitate review and analysis.
-  * Intended to be portable to any system with a C89 compiler and uint64_t support.
-  * No use of floating types.
-  * Expose only higher level interfaces to minimize the API surface and improve application security. ("Be difficult to use insecurely.")
-* Field operations
-  * Optimized implementation of arithmetic modulo the curve's field size (2^256 - 0x1000003D1).
-    * Using 5 52-bit limbs (including hand-optimized assembly for x86_64, by Diederik Huys).
-    * Using 10 26-bit limbs (including hand-optimized assembly for 32-bit ARM, by Wladimir J. van der Laan).
-      * This is an experimental feature that has not received enough scrutiny to satisfy the standard of quality of this library but is made available for testing and review by the community.
-* Scalar operations
-  * Optimized implementation without data-dependent branches of arithmetic modulo the curve's order.
-    * Using 4 64-bit limbs (relying on __int128 support in the compiler).
-    * Using 8 32-bit limbs.
-* Modular inverses (both field elements and scalars) based on [safegcd](https://gcd.cr.yp.to/index.html) with some modifications, and a variable-time variant (by Peter Dettman).
-* Group operations
-  * Point addition formula specifically simplified for the curve equation (y^2 = x^3 + 7).
-  * Use addition between points in Jacobian and affine coordinates where possible.
-  * Use a unified addition/doubling formula where necessary to avoid data-dependent branches.
-  * Point/x comparison without a field inversion by comparison in the Jacobian coordinate space.
-* Point multiplication for verification (a*P + b*G).
-  * Use wNAF notation for point multiplicands.
-  * Use a much larger window for multiples of G, using precomputed multiples.
-  * Use Shamir's trick to do the multiplication with the public key and the generator simultaneously.
-  * Use secp256k1's efficiently-computable endomorphism to split the P multiplicand into 2 half-sized ones.
-* Point multiplication for signing
-  * Use a precomputed table of multiples of powers of 16 multiplied with the generator, so general multiplication becomes a series of additions.
-  * Intended to be completely free of timing sidechannels for secret-key operations (on reasonable hardware/toolchains)
-    * Access the table with branch-free conditional moves so memory access is uniform.
-    * No data-dependent branches
-  * Optional runtime blinding which attempts to frustrate differential power analysis.
-  * The precomputed tables add and eventually subtract points for which no known scalar (secret key) is known, preventing even an attacker with control over the secret key used to control the data internally.
-
-Building with Autotools
------------------------
-
-    $ ./autogen.sh
-    $ ./configure
-    $ make
-    $ make check  # run the test suite
-    $ sudo make install  # optional
-
-To compile optional modules (such as Schnorr signatures), you need to run `./configure` with additional flags (such as `--enable-module-schnorrsig`). Run `./configure --help` to see the full list of available flags.
-
-Building with CMake (experimental)
-----------------------------------
-
-To maintain a pristine source tree, CMake encourages to perform an out-of-source build by using a separate dedicated build tree.
-
-### Building on POSIX systems
-
-    $ mkdir build && cd build
-    $ cmake ..
-    $ make
-    $ make check  # run the test suite
-    $ sudo make install  # optional
-
-To compile optional modules (such as Schnorr signatures), you need to run `cmake` with additional flags (such as `-DSECP256K1_ENABLE_MODULE_SCHNORRSIG=ON`). Run `cmake .. -LH` to see the full list of available flags.
-
-### Cross compiling
-
-To alleviate issues with cross compiling, preconfigured toolchain files are available in the `cmake` directory.
-For example, to cross compile for Windows:
-
-    $ cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/x86_64-w64-mingw32.toolchain.cmake
-
-To cross compile for Android with [NDK](https://developer.android.com/ndk/guides/cmake) (using NDK's toolchain file, and assuming the `ANDROID_NDK_ROOT` environment variable has been set):
-
-    $ cmake .. -DCMAKE_TOOLCHAIN_FILE="${ANDROID_NDK_ROOT}/build/cmake/android.toolchain.cmake" -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=28
-
-### Building on Windows
-
-To build on Windows with Visual Studio, a proper [generator](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html#visual-studio-generators) must be specified for a new build tree.
-
-The following example assumes using of Visual Studio 2022 and CMake v3.21+.
-
-In "Developer Command Prompt for VS 2022":
-
-    >cmake -G "Visual Studio 17 2022" -A x64 -S . -B build
-    >cmake --build build --config RelWithDebInfo
-
-Usage examples
------------
-Usage examples can be found in the [examples](examples) directory. To compile them you need to configure with `--enable-examples`.
-  * [ECDSA example](examples/ecdsa.c)
-  * [Schnorr signatures example](examples/schnorr.c)
-  * [Deriving a shared secret (ECDH) example](examples/ecdh.c)
-
-To compile the Schnorr signature and ECDH examples, you also need to configure with `--enable-module-schnorrsig` and `--enable-module-ecdh`.
-
-Test coverage
------------
-
-This library aims to have full coverage of the reachable lines and branches.
-
-To create a test coverage report, configure with `--enable-coverage` (use of GCC is necessary):
-
-    $ ./configure --enable-coverage
-
-Run the tests:
-
-    $ make check
-
-To create a report, `gcovr` is recommended, as it includes branch coverage reporting:
-
-    $ gcovr --exclude 'src/bench*' --print-summary
-
-To create a HTML report with coloured and annotated source code:
-
-    $ mkdir -p coverage
-    $ gcovr --exclude 'src/bench*' --html --html-details -o coverage/coverage.html
-
-Benchmark
-------------
-If configured with `--enable-benchmark` (which is the default), binaries for benchmarking the libsecp256k1 functions will be present in the root directory after the build.
-
-To print the benchmark result to the command line:
-
-    $ ./bench_name
-
-To create a CSV file for the benchmark result :
-
-    $ ./bench_name | sed '2d;s/ \{1,\}//g' > bench_name.csv
-
-Reporting a vulnerability
-------------
-
-See [SECURITY.md](SECURITY.md)

external/secp256k1/SECURITY.md

@@ -1,15 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-To report security issues send an email to secp256k1-security@bitcoincore.org (not for support).
-
-The following keys may be used to communicate sensitive information to developers:
-
-| Name | Fingerprint |
-|------|-------------|
-| Pieter Wuille | 133E AC17 9436 F14A 5CF1  B794 860F EB80 4E66 9320 |
-| Jonas Nick | 36C7 1A37 C9D9 88BD E825  08D9 B1A7 0E4F 8DCD 0366 |
-| Tim Ruffing | 09E0 3F87 1092 E40E 106E  902B 33BC 86AB 80FF 5516 |
-
-You can import a key by running the following command with that individual’s fingerprint: `gpg --keyserver hkps://keys.openpgp.org --recv-keys "<fingerprint>"` Ensure that you put quotes around fingerprints containing spaces.

external/secp256k1/build-aux/m4/bitcoin_secp.m4

@@ -1,75 +0,0 @@
-dnl escape "$0x" below using the m4 quadrigaph @S|@, and escape it again with a \ for the shell.
-AC_DEFUN([SECP_X86_64_ASM_CHECK],[
-AC_MSG_CHECKING(for x86_64 assembly availability)
-AC_LINK_IFELSE([AC_LANG_PROGRAM([[
-  #include <stdint.h>]],[[
-  uint64_t a = 11, tmp;
-  __asm__ __volatile__("movq \@S|@0x100000000,%1; mulq %%rsi" : "+a"(a) : "S"(tmp) : "cc", "%rdx");
-  ]])], [has_x86_64_asm=yes], [has_x86_64_asm=no])
-AC_MSG_RESULT([$has_x86_64_asm])
-])
-
-AC_DEFUN([SECP_ARM32_ASM_CHECK], [
-  AC_MSG_CHECKING(for ARM32 assembly availability)
-  SECP_ARM32_ASM_CHECK_CFLAGS_saved_CFLAGS="$CFLAGS"
-  CFLAGS="-x assembler"
-  AC_LINK_IFELSE([AC_LANG_SOURCE([[
-    .syntax unified
-    .eabi_attribute 24, 1
-    .eabi_attribute 25, 1
-    .text
-    .global main
-    main:
-      ldr r0, =0x002A
-      mov r7, #1
-      swi 0   
-    ]])], [has_arm32_asm=yes], [has_arm32_asm=no])
-  AC_MSG_RESULT([$has_arm32_asm])
-  CFLAGS="$SECP_ARM32_ASM_CHECK_CFLAGS_saved_CFLAGS"
-])
-
-AC_DEFUN([SECP_VALGRIND_CHECK],[
-AC_MSG_CHECKING([for valgrind support])
-if test x"$has_valgrind" != x"yes"; then
-  CPPFLAGS_TEMP="$CPPFLAGS"
-  CPPFLAGS="$VALGRIND_CPPFLAGS $CPPFLAGS"
-  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-    #include <valgrind/memcheck.h>
-  ]], [[
-    #if defined(NVALGRIND)
-    #  error "Valgrind does not support this platform."
-    #endif
-  ]])], [has_valgrind=yes])
-  CPPFLAGS="$CPPFLAGS_TEMP"
-fi
-AC_MSG_RESULT($has_valgrind)
-])
-
-dnl SECP_TRY_APPEND_CFLAGS(flags, VAR)
-dnl Append flags to VAR if CC accepts them.
-AC_DEFUN([SECP_TRY_APPEND_CFLAGS], [
-  AC_MSG_CHECKING([if ${CC} supports $1])
-  SECP_TRY_APPEND_CFLAGS_saved_CFLAGS="$CFLAGS"
-  CFLAGS="$1 $CFLAGS"
-  AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])], [flag_works=yes], [flag_works=no])
-  AC_MSG_RESULT($flag_works)
-  CFLAGS="$SECP_TRY_APPEND_CFLAGS_saved_CFLAGS"
-  if test x"$flag_works" = x"yes"; then
-    $2="$$2 $1"
-  fi
-  unset flag_works
-  AC_SUBST($2)
-])
-
-dnl SECP_SET_DEFAULT(VAR, default, default-dev-mode)
-dnl Set VAR to default or default-dev-mode, depending on whether dev mode is enabled
-AC_DEFUN([SECP_SET_DEFAULT], [
-  if test "${enable_dev_mode+set}" != set; then
-    AC_MSG_ERROR([[Set enable_dev_mode before calling SECP_SET_DEFAULT]])
-  fi
-  if test x"$enable_dev_mode" = x"yes"; then
-    $1="$3"
-  else
-    $1="$2"
-  fi
-])

external/secp256k1/ci/cirrus.sh

@@ -1,118 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-export LC_ALL=C
-
-# Print relevant CI environment to allow reproducing the job outside of CI.
-print_environment() {
-    # Turn off -x because it messes up the output
-    set +x
-    # There are many ways to print variable names and their content. This one
-    # does not rely on bash.
-    for var in WERROR_CFLAGS MAKEFLAGS BUILD \
-            ECMULTWINDOW ECMULTGENPRECISION ASM WIDEMUL WITH_VALGRIND EXTRAFLAGS \
-            EXPERIMENTAL ECDH RECOVERY SCHNORRSIG \
-            SECP256K1_TEST_ITERS BENCH SECP256K1_BENCH_ITERS CTIMETESTS\
-            EXAMPLES \
-            HOST WRAPPER_CMD \
-            CC CFLAGS CPPFLAGS AR NM
-    do
-        eval "isset=\${$var+x}"
-        if [ -n "$isset" ]; then
-            eval "val=\${$var}"
-            # shellcheck disable=SC2154
-            printf '%s="%s" ' "$var" "$val"
-        fi
-    done
-    echo "$0"
-    set -x
-}
-print_environment
-
-# Start persistent wineserver if necessary.
-# This speeds up jobs with many invocations of wine (e.g., ./configure with MSVC) tremendously.
-case "$WRAPPER_CMD" in
-    *wine*)
-        # Make sure to shutdown wineserver whenever we exit.
-        trap "wineserver -k || true" EXIT INT HUP
-        # This is apparently only reliable when we run a dummy command such as "hh.exe" afterwards.
-        wineserver -p && wine hh.exe
-        ;;
-esac
-
-env >> test_env.log
-
-if [ -n "${CC+x}" ]; then
-    # The MSVC compiler "cl" doesn't understand "-v"
-    $CC -v || true
-fi
-if [ "$WITH_VALGRIND" = "yes" ]; then
-    valgrind --version
-fi
-if [ -n "$WRAPPER_CMD" ]; then
-    $WRAPPER_CMD --version
-fi
-
-./autogen.sh
-
-./configure \
-    --enable-experimental="$EXPERIMENTAL" \
-    --with-test-override-wide-multiply="$WIDEMUL" --with-asm="$ASM" \
-    --with-ecmult-window="$ECMULTWINDOW" \
-    --with-ecmult-gen-precision="$ECMULTGENPRECISION" \
-    --enable-module-ecdh="$ECDH" --enable-module-recovery="$RECOVERY" \
-    --enable-module-schnorrsig="$SCHNORRSIG" \
-    --enable-examples="$EXAMPLES" \
-    --enable-ctime-tests="$CTIMETESTS" \
-    --with-valgrind="$WITH_VALGRIND" \
-    --host="$HOST" $EXTRAFLAGS
-
-# We have set "-j<n>" in MAKEFLAGS.
-make
-
-# Print information about binaries so that we can see that the architecture is correct
-file *tests* || true
-file bench* || true
-file .libs/* || true
-
-# This tells `make check` to wrap test invocations.
-export LOG_COMPILER="$WRAPPER_CMD"
-
-make "$BUILD"
-
-# Using the local `libtool` because on macOS the system's libtool has nothing to do with GNU libtool
-EXEC='./libtool --mode=execute'
-if [ -n "$WRAPPER_CMD" ]
-then
-    EXEC="$EXEC $WRAPPER_CMD"
-fi
-
-if [ "$BENCH" = "yes" ]
-then
-    {
-        $EXEC ./bench_ecmult
-        $EXEC ./bench_internal
-        $EXEC ./bench
-    } >> bench.log 2>&1
-fi
-
-if [ "$CTIMETESTS" = "yes" ]
-then
-    if [ "$WITH_VALGRIND" = "yes" ]; then
-        ./libtool --mode=execute valgrind --error-exitcode=42 ./ctime_tests > ctime_tests.log 2>&1
-    else
-        $EXEC ./ctime_tests > ctime_tests.log 2>&1
-    fi
-fi
-
-# Rebuild precomputed files (if not cross-compiling).
-if [ -z "$HOST" ]
-then
-    make clean-precomp clean-testvectors
-    make precomp testvectors
-fi
-
-# Check that no repo files have been modified by the build.
-# (This fails for example if the precomp files need to be updated in the repo.)
-git diff --exit-code

external/secp256k1/ci/linux-debian.Dockerfile

@@ -1,37 +0,0 @@
-FROM debian:stable
-
-RUN dpkg --add-architecture i386 && \
-    dpkg --add-architecture s390x && \
-    dpkg --add-architecture armhf && \
-    dpkg --add-architecture arm64 && \
-    dpkg --add-architecture ppc64el
-
-# dkpg-dev: to make pkg-config work in cross-builds
-# llvm: for llvm-symbolizer, which is used by clang's UBSan for symbolized stack traces
-RUN apt-get update && apt-get install --no-install-recommends -y \
-        git ca-certificates \
-        make automake libtool pkg-config dpkg-dev valgrind qemu-user \
-        gcc clang llvm libc6-dbg \
-        g++ \
-        gcc-i686-linux-gnu libc6-dev-i386-cross libc6-dbg:i386 libubsan1:i386 libasan6:i386 \
-        gcc-s390x-linux-gnu libc6-dev-s390x-cross libc6-dbg:s390x \
-        gcc-arm-linux-gnueabihf libc6-dev-armhf-cross libc6-dbg:armhf \
-        gcc-aarch64-linux-gnu libc6-dev-arm64-cross libc6-dbg:arm64 \
-        gcc-powerpc64le-linux-gnu libc6-dev-ppc64el-cross libc6-dbg:ppc64el \
-        gcc-mingw-w64-x86-64-win32 wine64 wine \
-        gcc-mingw-w64-i686-win32 wine32 \
-        sagemath
-
-WORKDIR /root
-# The "wine" package provides a convience wrapper that we need
-RUN apt-get update && apt-get install --no-install-recommends -y \
-        git ca-certificates wine64 wine python3-simplejson python3-six msitools winbind procps && \
-    git clone https://github.com/mstorsjo/msvc-wine && \
-    mkdir /opt/msvc && \
-    python3 msvc-wine/vsdownload.py --accept-license --dest /opt/msvc Microsoft.VisualStudio.Workload.VCTools && \
-    msvc-wine/install.sh /opt/msvc
-
-# Initialize the wine environment. Wait until the wineserver process has
-# exited before closing the session, to avoid corrupting the wine prefix.
-RUN wine64 wineboot --init && \
-    while (ps -A | grep wineserver) > /dev/null; do sleep 1; done

external/secp256k1/cmake/CheckArm32Assembly.cmake

@@ -1,6 +0,0 @@
-function(check_arm32_assembly)
-  try_compile(HAVE_ARM32_ASM
-    ${CMAKE_BINARY_DIR}/check_arm32_assembly
-    SOURCES ${CMAKE_SOURCE_DIR}/cmake/source_arm32.s
-  )
-endfunction()

external/secp256k1/cmake/CheckStringOptionValue.cmake

@@ -1,10 +0,0 @@
-function(check_string_option_value option)
-  get_property(expected_values CACHE ${option} PROPERTY STRINGS)
-  if(expected_values)
-    if(${option} IN_LIST expected_values)
-      return()
-    endif()
-    message(FATAL_ERROR "${option} value is \"${${option}}\", but must be one of ${expected_values}.")
-  endif()
-  message(AUTHOR_WARNING "The STRINGS property must be set before invoking `check_string_option_value' function.")
-endfunction()

external/secp256k1/cmake/CheckX86_64Assembly.cmake

@@ -1,14 +0,0 @@
-include(CheckCSourceCompiles)
-
-function(check_x86_64_assembly)
-  check_c_source_compiles("
-    #include <stdint.h>
-
-    int main()
-    {
-      uint64_t a = 11, tmp;
-      __asm__ __volatile__(\"movq $0x100000000,%1; mulq %%rsi\" : \"+a\"(a) : \"S\"(tmp) : \"cc\", \"%rdx\");
-    }
-  " HAVE_X86_64_ASM)
-  set(HAVE_X86_64_ASM ${HAVE_X86_64_ASM} PARENT_SCOPE)
-endfunction()

external/secp256k1/cmake/FindValgrind.cmake

@@ -1,41 +0,0 @@
-if(CMAKE_HOST_APPLE)
-  find_program(BREW_COMMAND brew)
-  execute_process(
-    COMMAND ${BREW_COMMAND} --prefix valgrind
-    OUTPUT_VARIABLE valgrind_brew_prefix
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-  )
-endif()
-
-set(hints_paths)
-if(valgrind_brew_prefix)
-  set(hints_paths ${valgrind_brew_prefix}/include)
-endif()
-
-find_path(Valgrind_INCLUDE_DIR
-  NAMES valgrind/memcheck.h
-  HINTS ${hints_paths}
-)
-
-if(Valgrind_INCLUDE_DIR)
-  include(CheckCSourceCompiles)
-  set(CMAKE_REQUIRED_INCLUDES ${Valgrind_INCLUDE_DIR})
-  check_c_source_compiles("
-    #include <valgrind/memcheck.h>
-    #if defined(NVALGRIND)
-    #  error \"Valgrind does not support this platform.\"
-    #endif
-
-    int main() {}
-  " Valgrind_WORKS)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Valgrind
-  REQUIRED_VARS Valgrind_INCLUDE_DIR Valgrind_WORKS
-)
-
-mark_as_advanced(
-  Valgrind_INCLUDE_DIR
-)

external/secp256k1/cmake/TryAppendCFlags.cmake

@@ -1,24 +0,0 @@
-include(CheckCCompilerFlag)
-
-function(secp256k1_check_c_flags_internal flags output)
-  string(MAKE_C_IDENTIFIER "${flags}" result)
-  string(TOUPPER "${result}" result)
-  set(result "C_SUPPORTS_${result}")
-  if(NOT MSVC)
-    set(CMAKE_REQUIRED_FLAGS "-Werror")
-  endif()
-
-  # This avoids running a linker.
-  set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
-  check_c_compiler_flag("${flags}" ${result})
-
-  set(${output} ${${result}} PARENT_SCOPE)
-endfunction()
-
-# Append flags to the COMPILE_OPTIONS directory property if CC accepts them.
-macro(try_append_c_flags)
-  secp256k1_check_c_flags_internal("${ARGV}" result)
-  if(result)
-    add_compile_options(${ARGV})
-  endif()
-endmacro()

external/secp256k1/cmake/arm-linux-gnueabihf.toolchain.cmake

@@ -1,3 +0,0 @@
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR arm)
-set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)

external/secp256k1/cmake/config.cmake.in

@@ -1,5 +0,0 @@
-@PACKAGE_INIT@
-
-include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake")
-
-check_required_components(@PROJECT_NAME@)

external/secp256k1/cmake/source_arm32.s

@@ -1,9 +0,0 @@
-.syntax unified
-.eabi_attribute 24, 1
-.eabi_attribute 25, 1
-.text
-.global main
-main:
-	ldr	r0, =0x002A
-	mov	r7, #1
-	swi	0   

external/secp256k1/cmake/x86_64-w64-mingw32.toolchain.cmake

@@ -1,3 +0,0 @@
-set(CMAKE_SYSTEM_NAME Windows)
-set(CMAKE_SYSTEM_PROCESSOR x86_64)
-set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc)

external/secp256k1/configure.ac

@@ -1,477 +0,0 @@
-AC_PREREQ([2.60])
-
-# The package (a.k.a. release) version is based on semantic versioning 2.0.0 of
-# the API. All changes in experimental modules are treated as
-# backwards-compatible and therefore at most increase the minor version.
-define(_PKG_VERSION_MAJOR, 0)
-define(_PKG_VERSION_MINOR, 3)
-define(_PKG_VERSION_PATCH, 2)
-define(_PKG_VERSION_IS_RELEASE, true)
-
-# The library version is based on libtool versioning of the ABI. The set of
-# rules for updating the version can be found here:
-# https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
-# All changes in experimental modules are treated as if they don't affect the
-# interface and therefore only increase the revision.
-define(_LIB_VERSION_CURRENT, 2)
-define(_LIB_VERSION_REVISION, 2)
-define(_LIB_VERSION_AGE, 0)
-
-AC_INIT([libsecp256k1],m4_join([.], _PKG_VERSION_MAJOR, _PKG_VERSION_MINOR, _PKG_VERSION_PATCH)m4_if(_PKG_VERSION_IS_RELEASE, [true], [], [-dev]),[https://github.com/bitcoin-core/secp256k1/issues],[libsecp256k1],[https://github.com/bitcoin-core/secp256k1])
-
-AC_CONFIG_AUX_DIR([build-aux])
-AC_CONFIG_MACRO_DIR([build-aux/m4])
-AC_CANONICAL_HOST
-
-# Require Automake 1.11.2 for AM_PROG_AR
-AM_INIT_AUTOMAKE([1.11.2 foreign subdir-objects])
-
-# Make the compilation flags quiet unless V=1 is used.
-m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
-
-if test "${CFLAGS+set}" = "set"; then
-  CFLAGS_overridden=yes
-else
-  CFLAGS_overridden=no
-fi
-AC_PROG_CC
-AM_PROG_AS
-AM_PROG_AR
-
-# Clear some cache variables as a workaround for a bug that appears due to a bad
-# interaction between AM_PROG_AR and LT_INIT when combining MSVC's archiver lib.exe.
-# https://debbugs.gnu.org/cgi/bugreport.cgi?bug=54421
-AS_UNSET(ac_cv_prog_AR)
-AS_UNSET(ac_cv_prog_ac_ct_AR)
-LT_INIT([win32-dll])
-
-build_windows=no
-
-case $host_os in
-  *darwin*)
-     if  test x$cross_compiling != xyes; then
-       AC_CHECK_PROG([BREW], brew, brew)
-       if test x$BREW = xbrew; then
-         # These Homebrew packages may be keg-only, meaning that they won't be found
-         # in expected paths because they may conflict with system files. Ask
-         # Homebrew where each one is located, then adjust paths accordingly.
-         if $BREW list --versions valgrind >/dev/null; then
-           valgrind_prefix=$($BREW --prefix valgrind 2>/dev/null)
-           VALGRIND_CPPFLAGS="-I$valgrind_prefix/include"
-         fi
-       else
-         AC_CHECK_PROG([PORT], port, port)
-         # If homebrew isn't installed and macports is, add the macports default paths
-         # as a last resort.
-         if test x$PORT = xport; then
-           CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
-           LDFLAGS="$LDFLAGS -L/opt/local/lib"
-         fi
-       fi
-     fi
-   ;;
-   cygwin*|mingw*)
-     build_windows=yes
-   ;;
-esac
-
-# Try if some desirable compiler flags are supported and append them to SECP_CFLAGS.
-#
-# These are our own flags, so we append them to our own SECP_CFLAGS variable (instead of CFLAGS) as
-# recommended in the automake manual (Section "Flag Variables Ordering"). CFLAGS belongs to the user
-# and we are not supposed to touch it. In the Makefile, we will need to ensure that SECP_CFLAGS
-# is prepended to CFLAGS when invoking the compiler so that the user always has the last word (flag).
-#
-# Another advantage of not touching CFLAGS is that the contents of CFLAGS will be picked up by
-# libtool for compiling helper executables. For example, when compiling for Windows, libtool will
-# generate entire wrapper executables (instead of simple wrapper scripts as on Unix) to ensure
-# proper operation of uninstalled programs linked by libtool against the uninstalled shared library.
-# These executables are compiled from C source file for which our flags may not be appropriate,
-# e.g., -std=c89 flag has lead to undesirable warnings in the past.
-#
-# TODO We should analogously not touch CPPFLAGS and LDFLAGS but currently there are no issues.
-AC_DEFUN([SECP_TRY_APPEND_DEFAULT_CFLAGS], [
-    # GCC and compatible (incl. clang)
-    if test "x$GCC" = "xyes"; then
-      # Try to append -Werror to CFLAGS temporarily. Otherwise checks for some unsupported
-      # flags will succeed.
-      # Note that failure to append -Werror does not necessarily mean that -Werror is not
-      # supported. The compiler may already be warning about something unrelated, for example
-      # about some path issue. If that is the case, -Werror cannot be used because all
-      # of those warnings would be turned into errors.
-      SECP_TRY_APPEND_DEFAULT_CFLAGS_saved_CFLAGS="$CFLAGS"
-      SECP_TRY_APPEND_CFLAGS([-Werror], CFLAGS)
-
-      SECP_TRY_APPEND_CFLAGS([-std=c89 -pedantic -Wno-long-long -Wnested-externs -Wshadow -Wstrict-prototypes -Wundef], $1) # GCC >= 3.0, -Wlong-long is implied by -pedantic.
-      SECP_TRY_APPEND_CFLAGS([-Wno-overlength-strings], $1) # GCC >= 4.2, -Woverlength-strings is implied by -pedantic.
-      SECP_TRY_APPEND_CFLAGS([-Wall], $1) # GCC >= 2.95 and probably many other compilers
-      SECP_TRY_APPEND_CFLAGS([-Wno-unused-function], $1) # GCC >= 3.0, -Wunused-function is implied by -Wall.
-      SECP_TRY_APPEND_CFLAGS([-Wextra], $1) # GCC >= 3.4, this is the newer name of -W, which we don't use because older GCCs will warn about unused functions.
-      SECP_TRY_APPEND_CFLAGS([-Wcast-align], $1) # GCC >= 2.95
-      SECP_TRY_APPEND_CFLAGS([-Wcast-align=strict], $1) # GCC >= 8.0
-      SECP_TRY_APPEND_CFLAGS([-Wconditional-uninitialized], $1) # Clang >= 3.0 only
-      SECP_TRY_APPEND_CFLAGS([-Wreserved-identifier], $1) # Clang >= 13.0 only
-      SECP_TRY_APPEND_CFLAGS([-fvisibility=hidden], $1) # GCC >= 4.0
-
-      CFLAGS="$SECP_TRY_APPEND_DEFAULT_CFLAGS_saved_CFLAGS"
-    fi
-
-    # MSVC
-    # Assume MSVC if we're building for Windows but not with GCC or compatible;
-    # libtool makes the same assumption internally.
-    # Note that "/opt" and "-opt" are equivalent for MSVC; we use "-opt" because "/opt" looks like a path.
-    if test x"$GCC" != x"yes" && test x"$build_windows" = x"yes"; then
-      SECP_TRY_APPEND_CFLAGS([-W2 -wd4146], $1) # Moderate warning level, disable warning C4146 "unary minus operator applied to unsigned type, result still unsigned"
-      # We pass -ignore:4217 to the MSVC linker to suppress warning 4217 when
-      # importing variables from a statically linked secp256k1.
-      # (See the libtool manual, section "Windows DLLs" for background.)
-      # Unfortunately, libtool tries to be too clever and strips "-Xlinker arg"
-      # into "arg", so this will be " -Xlinker -ignore:4217" after stripping.
-      LDFLAGS="-Xlinker -Xlinker -Xlinker -ignore:4217 $LDFLAGS" 
-    fi
-])
-SECP_TRY_APPEND_DEFAULT_CFLAGS(SECP_CFLAGS)
-
-###
-### Define config arguments
-###
-
-# In dev mode, we enable all binaries and modules by default but individual options can still be overridden explicitly.
-# Check for dev mode first because SECP_SET_DEFAULT needs enable_dev_mode set.
-AC_ARG_ENABLE(dev_mode, [], [],
-    [enable_dev_mode=no])
-
-AC_ARG_ENABLE(benchmark,
-    AS_HELP_STRING([--enable-benchmark],[compile benchmark [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_benchmark], [yes], [yes])])
-
-AC_ARG_ENABLE(coverage,
-    AS_HELP_STRING([--enable-coverage],[enable compiler flags to support kcov coverage analysis [default=no]]), [],
-    [SECP_SET_DEFAULT([enable_coverage], [no], [no])])
-
-AC_ARG_ENABLE(tests,
-    AS_HELP_STRING([--enable-tests],[compile tests [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_tests], [yes], [yes])])
-
-AC_ARG_ENABLE(ctime_tests,
-    AS_HELP_STRING([--enable-ctime-tests],[compile constant-time tests [default=yes if valgrind enabled]]), [],
-    [SECP_SET_DEFAULT([enable_ctime_tests], [auto], [auto])])
-
-AC_ARG_ENABLE(experimental,
-    AS_HELP_STRING([--enable-experimental],[allow experimental configure options [default=no]]), [],
-    [SECP_SET_DEFAULT([enable_experimental], [no], [yes])])
-
-AC_ARG_ENABLE(exhaustive_tests,
-    AS_HELP_STRING([--enable-exhaustive-tests],[compile exhaustive tests [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_exhaustive_tests], [yes], [yes])])
-
-AC_ARG_ENABLE(examples,
-    AS_HELP_STRING([--enable-examples],[compile the examples [default=no]]), [],
-    [SECP_SET_DEFAULT([enable_examples], [no], [yes])])
-
-AC_ARG_ENABLE(module_ecdh,
-    AS_HELP_STRING([--enable-module-ecdh],[enable ECDH module [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_module_ecdh], [yes], [yes])])
-
-AC_ARG_ENABLE(module_recovery,
-    AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module [default=no]]), [],
-    [SECP_SET_DEFAULT([enable_module_recovery], [no], [yes])])
-
-AC_ARG_ENABLE(module_extrakeys,
-    AS_HELP_STRING([--enable-module-extrakeys],[enable extrakeys module [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_module_extrakeys], [yes], [yes])])
-
-AC_ARG_ENABLE(module_schnorrsig,
-    AS_HELP_STRING([--enable-module-schnorrsig],[enable schnorrsig module [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_module_schnorrsig], [yes], [yes])])
-
-AC_ARG_ENABLE(external_default_callbacks,
-    AS_HELP_STRING([--enable-external-default-callbacks],[enable external default callback functions [default=no]]), [],
-    [SECP_SET_DEFAULT([enable_external_default_callbacks], [no], [no])])
-
-# Test-only override of the (autodetected by the C code) "widemul" setting.
-# Legal values are:
-#  * int64 (for [u]int64_t),
-#  * int128 (for [unsigned] __int128),
-#  * int128_struct (for int128 implemented as a structure),
-#  *  and auto (the default).
-AC_ARG_WITH([test-override-wide-multiply], [] ,[set_widemul=$withval], [set_widemul=auto])
-
-AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|arm32|no|auto],
-[assembly optimizations to use (experimental: arm32) [default=auto]])],[req_asm=$withval], [req_asm=auto])
-
-AC_ARG_WITH([ecmult-window], [AS_HELP_STRING([--with-ecmult-window=SIZE|auto],
-[window size for ecmult precomputation for verification, specified as integer in range [2..24].]
-[Larger values result in possibly better performance at the cost of an exponentially larger precomputed table.]
-[The table will store 2^(SIZE-1) * 64 bytes of data but can be larger in memory due to platform-specific padding and alignment.]
-[A window size larger than 15 will require you delete the prebuilt precomputed_ecmult.c file so that it can be rebuilt.]
-[For very large window sizes, use "make -j 1" to reduce memory use during compilation.]
-["auto" is a reasonable setting for desktop machines (currently 15). [default=auto]]
-)],
-[req_ecmult_window=$withval], [req_ecmult_window=auto])
-
-AC_ARG_WITH([ecmult-gen-precision], [AS_HELP_STRING([--with-ecmult-gen-precision=2|4|8|auto],
-[Precision bits to tune the precomputed table size for signing.]
-[The size of the table is 32kB for 2 bits, 64kB for 4 bits, 512kB for 8 bits of precision.]
-[A larger table size usually results in possible faster signing.]
-["auto" is a reasonable setting for desktop machines (currently 4). [default=auto]]
-)],
-[req_ecmult_gen_precision=$withval], [req_ecmult_gen_precision=auto])
-
-AC_ARG_WITH([valgrind], [AS_HELP_STRING([--with-valgrind=yes|no|auto],
-[Build with extra checks for running inside Valgrind [default=auto]]
-)],
-[req_valgrind=$withval], [req_valgrind=auto])
-
-###
-### Handle config options (except for modules)
-###
-
-if test x"$req_valgrind" = x"no"; then
-  enable_valgrind=no
-else
-  SECP_VALGRIND_CHECK
-  if test x"$has_valgrind" != x"yes"; then
-    if test x"$req_valgrind" = x"yes"; then
-      AC_MSG_ERROR([Valgrind support explicitly requested but valgrind/memcheck.h header not available])
-    fi
-    enable_valgrind=no
-  else
-    enable_valgrind=yes
-  fi
-fi
-
-if test x"$enable_ctime_tests" = x"auto"; then
-    enable_ctime_tests=$enable_valgrind
-fi
-
-if test x"$enable_coverage" = x"yes"; then
-    SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DCOVERAGE=1"
-    SECP_CFLAGS="-O0 --coverage $SECP_CFLAGS"
-    # If coverage is enabled, and the user has not overridden CFLAGS,
-    # override Autoconf's value "-g -O2" with "-g". Otherwise we'd end up
-    # with "-O0 --coverage -g -O2".
-    if test "$CFLAGS_overridden" = "no"; then
-      CFLAGS="-g"
-    fi
-    LDFLAGS="--coverage $LDFLAGS"
-else
-    # Most likely the CFLAGS already contain -O2 because that is autoconf's default.
-    # We still add it here because passing it twice is not an issue, and handling
-    # this case would just add unnecessary complexity (see #896).
-    SECP_CFLAGS="-O2 $SECP_CFLAGS"
-fi
-
-if test x"$req_asm" = x"auto"; then
-  SECP_X86_64_ASM_CHECK
-  if test x"$has_x86_64_asm" = x"yes"; then
-    set_asm=x86_64
-  fi
-  if test x"$set_asm" = x; then
-    set_asm=no
-  fi
-else
-  set_asm=$req_asm
-  case $set_asm in
-  x86_64)
-    SECP_X86_64_ASM_CHECK
-    if test x"$has_x86_64_asm" != x"yes"; then
-      AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
-    fi
-    ;;
-  arm32)
-    SECP_ARM32_ASM_CHECK
-    if test x"$has_arm32_asm" != x"yes"; then
-      AC_MSG_ERROR([ARM32 assembly optimization requested but not available])
-    fi
-    ;;
-  no)
-    ;;
-  *)
-    AC_MSG_ERROR([invalid assembly optimization selection])
-    ;;
-  esac
-fi
-
-# Select assembly optimization
-enable_external_asm=no
-
-case $set_asm in
-x86_64)
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_ASM_X86_64=1"
-  ;;
-arm32)
-  enable_external_asm=yes
-  ;;
-no)
-  ;;
-*)
-  AC_MSG_ERROR([invalid assembly optimizations])
-  ;;
-esac
-
-if test x"$enable_external_asm" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_EXTERNAL_ASM=1"
-fi
-
-
-# Select wide multiplication implementation
-case $set_widemul in
-int128_struct)
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_FORCE_WIDEMUL_INT128_STRUCT=1"
-  ;;
-int128)
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_FORCE_WIDEMUL_INT128=1"
-  ;;
-int64)
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_FORCE_WIDEMUL_INT64=1"
-  ;;
-auto)
-  ;;
-*)
-  AC_MSG_ERROR([invalid wide multiplication implementation])
-  ;;
-esac
-
-# Set ecmult window size
-if test x"$req_ecmult_window" = x"auto"; then
-  set_ecmult_window=15
-else
-  set_ecmult_window=$req_ecmult_window
-fi
-
-error_window_size=['window size for ecmult precomputation not an integer in range [2..24] or "auto"']
-case $set_ecmult_window in
-''|*[[!0-9]]*)
-  # no valid integer
-  AC_MSG_ERROR($error_window_size)
-  ;;
-*)
-  if test "$set_ecmult_window" -lt 2 -o "$set_ecmult_window" -gt 24 ; then
-    # not in range
-    AC_MSG_ERROR($error_window_size)
-  fi
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DECMULT_WINDOW_SIZE=$set_ecmult_window"
-  ;;
-esac
-
-# Set ecmult gen precision
-if test x"$req_ecmult_gen_precision" = x"auto"; then
-  set_ecmult_gen_precision=4
-else
-  set_ecmult_gen_precision=$req_ecmult_gen_precision
-fi
-
-case $set_ecmult_gen_precision in
-2|4|8)
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DECMULT_GEN_PREC_BITS=$set_ecmult_gen_precision"
-  ;;
-*)
-  AC_MSG_ERROR(['ecmult gen precision not 2, 4, 8 or "auto"'])
-  ;;
-esac
-
-if test x"$enable_valgrind" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES $VALGRIND_CPPFLAGS -DVALGRIND"
-fi
-
-# Add -Werror and similar flags passed from the outside (for testing, e.g., in CI).
-# We don't want to set the user variable CFLAGS in CI because this would disable
-# autoconf's logic for setting default CFLAGS, which we would like to test in CI.
-SECP_CFLAGS="$SECP_CFLAGS $WERROR_CFLAGS"
-
-###
-### Handle module options
-###
-
-if test x"$enable_module_ecdh" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_ECDH=1"
-fi
-
-if test x"$enable_module_recovery" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_RECOVERY=1"
-fi
-
-if test x"$enable_module_schnorrsig" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_SCHNORRSIG=1"
-  enable_module_extrakeys=yes
-fi
-
-# Test if extrakeys is set after the schnorrsig module to allow the schnorrsig
-# module to set enable_module_extrakeys=yes
-if test x"$enable_module_extrakeys" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_EXTRAKEYS=1"
-fi
-
-if test x"$enable_external_default_callbacks" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_EXTERNAL_DEFAULT_CALLBACKS=1"
-fi
-
-###
-### Check for --enable-experimental if necessary
-###
-
-if test x"$enable_experimental" = x"yes"; then
-  AC_MSG_NOTICE([******])
-  AC_MSG_NOTICE([WARNING: experimental build])
-  AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
-  AC_MSG_NOTICE([******])
-else
-  if test x"$set_asm" = x"arm32"; then
-    AC_MSG_ERROR([ARM32 assembly optimization is experimental. Use --enable-experimental to allow.])
-  fi
-fi
-
-###
-### Generate output
-###
-
-AC_CONFIG_FILES([Makefile libsecp256k1.pc])
-AC_SUBST(SECP_CFLAGS)
-AC_SUBST(SECP_CONFIG_DEFINES)
-AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
-AM_CONDITIONAL([USE_TESTS], [test x"$enable_tests" != x"no"])
-AM_CONDITIONAL([USE_CTIME_TESTS], [test x"$enable_ctime_tests" = x"yes"])
-AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$enable_exhaustive_tests" != x"no"])
-AM_CONDITIONAL([USE_EXAMPLES], [test x"$enable_examples" != x"no"])
-AM_CONDITIONAL([USE_BENCHMARK], [test x"$enable_benchmark" = x"yes"])
-AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
-AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
-AM_CONDITIONAL([ENABLE_MODULE_EXTRAKEYS], [test x"$enable_module_extrakeys" = x"yes"])
-AM_CONDITIONAL([ENABLE_MODULE_SCHNORRSIG], [test x"$enable_module_schnorrsig" = x"yes"])
-AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$enable_external_asm" = x"yes"])
-AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm32"])
-AM_CONDITIONAL([BUILD_WINDOWS], [test "$build_windows" = "yes"])
-AC_SUBST(LIB_VERSION_CURRENT, _LIB_VERSION_CURRENT)
-AC_SUBST(LIB_VERSION_REVISION, _LIB_VERSION_REVISION)
-AC_SUBST(LIB_VERSION_AGE, _LIB_VERSION_AGE)
-
-AC_OUTPUT
-
-echo
-echo "Build Options:"
-echo "  with external callbacks = $enable_external_default_callbacks"
-echo "  with benchmarks         = $enable_benchmark"
-echo "  with tests              = $enable_tests"
-echo "  with ctime tests        = $enable_ctime_tests"
-echo "  with coverage           = $enable_coverage"
-echo "  with examples           = $enable_examples"
-echo "  module ecdh             = $enable_module_ecdh"
-echo "  module recovery         = $enable_module_recovery"
-echo "  module extrakeys        = $enable_module_extrakeys"
-echo "  module schnorrsig       = $enable_module_schnorrsig"
-echo
-echo "  asm                     = $set_asm"
-echo "  ecmult window size      = $set_ecmult_window"
-echo "  ecmult gen prec. bits   = $set_ecmult_gen_precision"
-# Hide test-only options unless they're used.
-if test x"$set_widemul" != xauto; then
-echo "  wide multiplication     = $set_widemul"
-fi
-echo
-echo "  valgrind                = $enable_valgrind"
-echo "  CC                      = $CC"
-echo "  CPPFLAGS                = $CPPFLAGS"
-echo "  SECP_CFLAGS             = $SECP_CFLAGS"
-echo "  CFLAGS                  = $CFLAGS"
-echo "  LDFLAGS                 = $LDFLAGS"

external/secp256k1/doc/release-process.md

@@ -1,61 +0,0 @@
-# Release Process
-
-This document outlines the process for releasing versions of the form `$MAJOR.$MINOR.$PATCH`.
-
-We distinguish between two types of releases: *regular* and *maintenance* releases.
-Regular releases are releases of a new major or minor version as well as patches of the most recent release.
-Maintenance releases, on the other hand, are required for patches of older releases.
-
-You should coordinate with the other maintainers on the release date, if possible.
-This date will be part of the release entry in [CHANGELOG.md](../CHANGELOG.md) and it should match the dates of the remaining steps in the release process (including the date of the tag and the GitHub release).
-It is best if the maintainers are present during the release, so they can help ensure that the process is followed correctly and, in the case of a regular release, they are aware that they should not modify the master branch between merging the PR in step 1 and the PR in step 3.
-
-This process also assumes that there will be no minor releases for old major releases.
-
-## Regular release
-
-1. Open a PR to the master branch with a commit (using message `"release: prepare for $MAJOR.$MINOR.$PATCH"`, for example) that
-   * finalizes the release notes in [CHANGELOG.md](../CHANGELOG.md) (make sure to include an entry for `### ABI Compatibility`),
-   * sets `_PKG_VERSION_IS_RELEASE` to `true` in `configure.ac`, and
-   * if this is not a patch release
-       * updates `_PKG_VERSION_*` and `_LIB_VERSION_*`  in `configure.ac` and
-       * updates `project(libsecp256k1 VERSION ...)` and `${PROJECT_NAME}_LIB_VERSION_*` in `CMakeLists.txt`.
-2. After the PR is merged, tag the commit and push it:
-   ```
-   RELEASE_COMMIT=<merge commit of step 1>
-   git tag -s v$MAJOR.$MINOR.$PATCH -m "libsecp256k1 $MAJOR.$MINOR.$PATCH" $RELEASE_COMMIT
-   git push git@github.com:bitcoin-core/secp256k1.git v$MAJOR.$MINOR.$PATCH
-   ```
-3. Open a PR to the master branch with a commit (using message `"release cleanup: bump version after $MAJOR.$MINOR.$PATCH"`, for example) that
-   * sets `_PKG_VERSION_IS_RELEASE` to `false` and increments `_PKG_VERSION_PATCH` and `_LIB_VERSION_REVISION` in `configure.ac`, and
-   * increments the `$PATCH` component of `project(libsecp256k1 VERSION ...)` and `${PROJECT_NAME}_LIB_VERSION_REVISION` in `CMakeLists.txt`.
-
-   If other maintainers are not present to approve the PR, it can be merged without ACKs.
-4. Create a new GitHub release with a link to the corresponding entry in [CHANGELOG.md](../CHANGELOG.md).
-
-## Maintenance release
-
-Note that bugfixes only need to be backported to releases for which no compatible release without the bug exists.
-
-1. If `$PATCH = 1`, create maintenance branch `$MAJOR.$MINOR`:
-   ```
-   git checkout -b $MAJOR.$MINOR v$MAJOR.$MINOR.0
-   git push git@github.com:bitcoin-core/secp256k1.git $MAJOR.$MINOR
-   ```
-2. Open a pull request to the `$MAJOR.$MINOR` branch that
-   * includes the bugfixes,
-   * finalizes the release notes,
-   * increments `_PKG_VERSION_PATCH` and `_LIB_VERSION_REVISION` in `configure.ac`
-     and the `$PATCH` component of `project(libsecp256k1 VERSION ...)` and `${PROJECT_NAME}_LIB_VERSION_REVISION` in `CMakeLists.txt`
-     (with commit message `"release: bump versions for $MAJOR.$MINOR.$PATCH"`, for example).
-3. After the PRs are merged, update the release branch and tag the commit:
-   ```
-   git checkout $MAJOR.$MINOR && git pull
-   git tag -s v$MAJOR.$MINOR.$PATCH -m "libsecp256k1 $MAJOR.$MINOR.$PATCH"
-   ```
-4. Push tag:
-   ```
-   git push git@github.com:bitcoin-core/secp256k1.git v$MAJOR.$MINOR.$PATCH
-   ```
-5. Create a new GitHub release with a link to the corresponding entry in [CHANGELOG.md](../CHANGELOG.md).
-6. Open PR to the master branch that includes a commit (with commit message `"release notes: add $MAJOR.$MINOR.$PATCH"`, for example) that adds release notes to [CHANGELOG.md](../CHANGELOG.md).

external/secp256k1/doc/safegcd_implementation.md

@@ -1,819 +0,0 @@
-# The safegcd implementation in libsecp256k1 explained
-
-This document explains the modular inverse and Jacobi symbol implementations in the `src/modinv*.h` files.
-It is based on the paper
-["Fast constant-time gcd computation and modular inversion"](https://gcd.cr.yp.to/papers.html#safegcd)
-by Daniel J. Bernstein and Bo-Yin Yang. The references below are for the Date: 2019.04.13 version.
-
-The actual implementation is in C of course, but for demonstration purposes Python3 is used here.
-Most implementation aspects and optimizations are explained, except those that depend on the specific
-number representation used in the C code.
-
-## 1. Computing the Greatest Common Divisor (GCD) using divsteps
-
-The algorithm from the paper (section 11), at a very high level, is this:
-
-```python
-def gcd(f, g):
-    """Compute the GCD of an odd integer f and another integer g."""
-    assert f & 1  # require f to be odd
-    delta = 1     # additional state variable
-    while g != 0:
-        assert f & 1  # f will be odd in every iteration
-        if delta > 0 and g & 1:
-            delta, f, g = 1 - delta, g, (g - f) // 2
-        elif g & 1:
-            delta, f, g = 1 + delta, f, (g + f) // 2
-        else:
-            delta, f, g = 1 + delta, f, (g    ) // 2
-    return abs(f)
-```
-
-It computes the greatest common divisor of an odd integer *f* and any integer *g*. Its inner loop
-keeps rewriting the variables *f* and *g* alongside a state variable *δ* that starts at *1*, until
-*g=0* is reached. At that point, *|f|* gives the GCD. Each of the transitions in the loop is called a
-"division step" (referred to as divstep in what follows).
-
-For example, *gcd(21, 14)* would be computed as:
-- Start with *δ=1 f=21 g=14*
-- Take the third branch: *δ=2 f=21 g=7*
-- Take the first branch: *δ=-1 f=7 g=-7*
-- Take the second branch: *δ=0 f=7 g=0*
-- The answer *|f| = 7*.
-
-Why it works:
-- Divsteps can be decomposed into two steps (see paragraph 8.2 in the paper):
-  - (a) If *g* is odd, replace *(f,g)* with *(g,g-f)* or (f,g+f), resulting in an even *g*.
-  - (b) Replace *(f,g)* with *(f,g/2)* (where *g* is guaranteed to be even).
-- Neither of those two operations change the GCD:
-  - For (a), assume *gcd(f,g)=c*, then it must be the case that *f=a c* and *g=b c* for some integers *a*
-    and *b*. As *(g,g-f)=(b c,(b-a)c)* and *(f,f+g)=(a c,(a+b)c)*, the result clearly still has
-    common factor *c*. Reasoning in the other direction shows that no common factor can be added by
-    doing so either.
-  - For (b), we know that *f* is odd, so *gcd(f,g)* clearly has no factor *2*, and we can remove
-    it from *g*.
-- The algorithm will eventually converge to *g=0*. This is proven in the paper (see theorem G.3).
-- It follows that eventually we find a final value *f'* for which *gcd(f,g) = gcd(f',0)*. As the
-  gcd of *f'* and *0* is *|f'|* by definition, that is our answer.
-
-Compared to more [traditional GCD algorithms](https://en.wikipedia.org/wiki/Euclidean_algorithm), this one has the property of only ever looking at
-the low-order bits of the variables to decide the next steps, and being easy to make
-constant-time (in more low-level languages than Python). The *δ* parameter is necessary to
-guide the algorithm towards shrinking the numbers' magnitudes without explicitly needing to look
-at high order bits.
-
-Properties that will become important later:
-- Performing more divsteps than needed is not a problem, as *f* does not change anymore after *g=0*.
-- Only even numbers are divided by *2*. This means that when reasoning about it algebraically we
-  do not need to worry about rounding.
-- At every point during the algorithm's execution the next *N* steps only depend on the bottom *N*
-  bits of *f* and *g*, and on *δ*.
-
-
-## 2. From GCDs to modular inverses
-
-We want an algorithm to compute the inverse *a* of *x* modulo *M*, i.e. the number a such that *a x=1
-mod M*. This inverse only exists if the GCD of *x* and *M* is *1*, but that is always the case if *M* is
-prime and *0 < x < M*. In what follows, assume that the modular inverse exists.
-It turns out this inverse can be computed as a side effect of computing the GCD by keeping track
-of how the internal variables can be written as linear combinations of the inputs at every step
-(see the [extended Euclidean algorithm](https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm)).
-Since the GCD is *1*, such an algorithm will compute numbers *a* and *b* such that a&thinsp;x + b&thinsp;M = 1*.
-Taking that expression *mod M* gives *a&thinsp;x mod M = 1*, and we see that *a* is the modular inverse of *x
-mod M*.
-
-A similar approach can be used to calculate modular inverses using the divsteps-based GCD
-algorithm shown above, if the modulus *M* is odd. To do so, compute *gcd(f=M,g=x)*, while keeping
-track of extra variables *d* and *e*, for which at every step *d = f/x (mod M)* and *e = g/x (mod M)*.
-*f/x* here means the number which multiplied with *x* gives *f mod M*. As *f* and *g* are initialized to *M*
-and *x* respectively, *d* and *e* just start off being *0* (*M/x mod M = 0/x mod M = 0*) and *1* (*x/x mod M
-= 1*).
-
-```python
-def div2(M, x):
-    """Helper routine to compute x/2 mod M (where M is odd)."""
-    assert M & 1
-    if x & 1: # If x is odd, make it even by adding M.
-        x += M
-    # x must be even now, so a clean division by 2 is possible.
-    return x // 2
-
-def modinv(M, x):
-    """Compute the inverse of x mod M (given that it exists, and M is odd)."""
-    assert M & 1
-    delta, f, g, d, e = 1, M, x, 0, 1
-    while g != 0:
-        # Note that while division by two for f and g is only ever done on even inputs, this is
-        # not true for d and e, so we need the div2 helper function.
-        if delta > 0 and g & 1:
-            delta, f, g, d, e = 1 - delta, g, (g - f) // 2, e, div2(M, e - d)
-        elif g & 1:
-            delta, f, g, d, e = 1 + delta, f, (g + f) // 2, d, div2(M, e + d)
-        else:
-            delta, f, g, d, e = 1 + delta, f, (g    ) // 2, d, div2(M, e    )
-        # Verify that the invariants d=f/x mod M, e=g/x mod M are maintained.
-        assert f % M == (d * x) % M
-        assert g % M == (e * x) % M
-    assert f == 1 or f == -1  # |f| is the GCD, it must be 1
-    # Because of invariant d = f/x (mod M), 1/x = d/f (mod M). As |f|=1, d/f = d*f.
-    return (d * f) % M
-```
-
-Also note that this approach to track *d* and *e* throughout the computation to determine the inverse
-is different from the paper. There (see paragraph 12.1 in the paper) a transition matrix for the
-entire computation is determined (see section 3 below) and the inverse is computed from that.
-The approach here avoids the need for 2x2 matrix multiplications of various sizes, and appears to
-be faster at the level of optimization we're able to do in C.
-
-
-## 3. Batching multiple divsteps
-
-Every divstep can be expressed as a matrix multiplication, applying a transition matrix *(1/2 t)*
-to both vectors *[f, g]* and *[d, e]* (see paragraph 8.1 in the paper):
-
-```
-  t = [ u,  v ]
-      [ q,  r ]
-
-  [ out_f ] = (1/2 * t) * [ in_f ]
-  [ out_g ] =             [ in_g ]
-
-  [ out_d ] = (1/2 * t) * [ in_d ]  (mod M)
-  [ out_e ]               [ in_e ]
-```
-
-where *(u, v, q, r)* is *(0, 2, -1, 1)*, *(2, 0, 1, 1)*, or *(2, 0, 0, 1)*, depending on which branch is
-taken. As above, the resulting *f* and *g* are always integers.
-
-Performing multiple divsteps corresponds to a multiplication with the product of all the
-individual divsteps' transition matrices. As each transition matrix consists of integers
-divided by *2*, the product of these matrices will consist of integers divided by *2<sup>N</sup>* (see also
-theorem 9.2 in the paper). These divisions are expensive when updating *d* and *e*, so we delay
-them: we compute the integer coefficients of the combined transition matrix scaled by *2<sup>N</sup>*, and
-do one division by *2<sup>N</sup>* as a final step:
-
-```python
-def divsteps_n_matrix(delta, f, g):
-    """Compute delta and transition matrix t after N divsteps (multiplied by 2^N)."""
-    u, v, q, r = 1, 0, 0, 1 # start with identity matrix
-    for _ in range(N):
-        if delta > 0 and g & 1:
-            delta, f, g, u, v, q, r = 1 - delta, g, (g - f) // 2, 2*q, 2*r, q-u, r-v
-        elif g & 1:
-            delta, f, g, u, v, q, r = 1 + delta, f, (g + f) // 2, 2*u, 2*v, q+u, r+v
-        else:
-            delta, f, g, u, v, q, r = 1 + delta, f, (g    ) // 2, 2*u, 2*v, q  , r
-    return delta, (u, v, q, r)
-```
-
-As the branches in the divsteps are completely determined by the bottom *N* bits of *f* and *g*, this
-function to compute the transition matrix only needs to see those bottom bits. Furthermore all
-intermediate results and outputs fit in *(N+1)*-bit numbers (unsigned for *f* and *g*; signed for *u*, *v*,
-*q*, and *r*) (see also paragraph 8.3 in the paper). This means that an implementation using 64-bit
-integers could set *N=62* and compute the full transition matrix for 62 steps at once without any
-big integer arithmetic at all. This is the reason why this algorithm is efficient: it only needs
-to update the full-size *f*, *g*, *d*, and *e* numbers once every *N* steps.
-
-We still need functions to compute:
-
-```
-  [ out_f ] = (1/2^N * [ u,  v ]) * [ in_f ]
-  [ out_g ]   (        [ q,  r ])   [ in_g ]
-
-  [ out_d ] = (1/2^N * [ u,  v ]) * [ in_d ]  (mod M)
-  [ out_e ]   (        [ q,  r ])   [ in_e ]
-```
-
-Because the divsteps transformation only ever divides even numbers by two, the result of *t&thinsp;[f,g]* is always even. When *t* is a composition of *N* divsteps, it follows that the resulting *f*
-and *g* will be multiple of *2<sup>N</sup>*, and division by *2<sup>N</sup>* is simply shifting them down:
-
-```python
-def update_fg(f, g, t):
-    """Multiply matrix t/2^N with [f, g]."""
-    u, v, q, r = t
-    cf, cg = u*f + v*g, q*f + r*g
-    # (t / 2^N) should cleanly apply to [f,g] so the result of t*[f,g] should have N zero
-    # bottom bits.
-    assert cf % 2**N == 0
-    assert cg % 2**N == 0
-    return cf >> N, cg >> N
-```
-
-The same is not true for *d* and *e*, and we need an equivalent of the `div2` function for division by *2<sup>N</sup> mod M*.
-This is easy if we have precomputed *1/M mod 2<sup>N</sup>* (which always exists for odd *M*):
-
-```python
-def div2n(M, Mi, x):
-    """Compute x/2^N mod M, given Mi = 1/M mod 2^N."""
-    assert (M * Mi) % 2**N == 1
-    # Find a factor m such that m*M has the same bottom N bits as x. We want:
-    #     (m * M) mod 2^N = x mod 2^N
-    # <=> m mod 2^N = (x / M) mod 2^N
-    # <=> m mod 2^N = (x * Mi) mod 2^N
-    m = (Mi * x) % 2**N
-    # Subtract that multiple from x, cancelling its bottom N bits.
-    x -= m * M
-    # Now a clean division by 2^N is possible.
-    assert x % 2**N == 0
-    return (x >> N) % M
-
-def update_de(d, e, t, M, Mi):
-    """Multiply matrix t/2^N with [d, e], modulo M."""
-    u, v, q, r = t
-    cd, ce = u*d + v*e, q*d + r*e
-    return div2n(M, Mi, cd), div2n(M, Mi, ce)
-```
-
-With all of those, we can write a version of `modinv` that performs *N* divsteps at once:
-
-```python3
-def modinv(M, Mi, x):
-    """Compute the modular inverse of x mod M, given Mi=1/M mod 2^N."""
-    assert M & 1
-    delta, f, g, d, e = 1, M, x, 0, 1
-    while g != 0:
-        # Compute the delta and transition matrix t for the next N divsteps (this only needs
-        # (N+1)-bit signed integer arithmetic).
-        delta, t = divsteps_n_matrix(delta, f % 2**N, g % 2**N)
-        # Apply the transition matrix t to [f, g]:
-        f, g = update_fg(f, g, t)
-        # Apply the transition matrix t to [d, e]:
-        d, e = update_de(d, e, t, M, Mi)
-    return (d * f) % M
-```
-
-This means that in practice we'll always perform a multiple of *N* divsteps. This is not a problem
-because once *g=0*, further divsteps do not affect *f*, *g*, *d*, or *e* anymore (only *&delta;* keeps
-increasing). For variable time code such excess iterations will be mostly optimized away in later
-sections.
-
-
-## 4. Avoiding modulus operations
-
-So far, there are two places where we compute a remainder of big numbers modulo *M*: at the end of
-`div2n` in every `update_de`, and at the very end of `modinv` after potentially negating *d* due to the
-sign of *f*. These are relatively expensive operations when done generically.
-
-To deal with the modulus operation in `div2n`, we simply stop requiring *d* and *e* to be in range
-*[0,M)* all the time. Let's start by inlining `div2n` into `update_de`, and dropping the modulus
-operation at the end:
-
-```python
-def update_de(d, e, t, M, Mi):
-    """Multiply matrix t/2^N with [d, e] mod M, given Mi=1/M mod 2^N."""
-    u, v, q, r = t
-    cd, ce = u*d + v*e, q*d + r*e
-    # Cancel out bottom N bits of cd and ce.
-    md = -((Mi * cd) % 2**N)
-    me = -((Mi * ce) % 2**N)
-    cd += md * M
-    ce += me * M
-    # And cleanly divide by 2**N.
-    return cd >> N, ce >> N
-```
-
-Let's look at bounds on the ranges of these numbers. It can be shown that *|u|+|v|* and *|q|+|r|*
-never exceed *2<sup>N</sup>* (see paragraph 8.3 in the paper), and thus a multiplication with *t* will have
-outputs whose absolute values are at most *2<sup>N</sup>* times the maximum absolute input value. In case the
-inputs *d* and *e* are in *(-M,M)*, which is certainly true for the initial values *d=0* and *e=1* assuming
-*M > 1*, the multiplication results in numbers in range *(-2<sup>N</sup>M,2<sup>N</sup>M)*. Subtracting less than *2<sup>N</sup>*
-times *M* to cancel out *N* bits brings that up to *(-2<sup>N+1</sup>M,2<sup>N</sup>M)*, and
-dividing by *2<sup>N</sup>* at the end takes it to *(-2M,M)*. Another application of `update_de` would take that
-to *(-3M,2M)*, and so forth. This progressive expansion of the variables' ranges can be
-counteracted by incrementing *d* and *e* by *M* whenever they're negative:
-
-```python
-    ...
-    if d < 0:
-        d += M
-    if e < 0:
-        e += M
-    cd, ce = u*d + v*e, q*d + r*e
-    # Cancel out bottom N bits of cd and ce.
-    ...
-```
-
-With inputs in *(-2M,M)*, they will first be shifted into range *(-M,M)*, which means that the
-output will again be in *(-2M,M)*, and this remains the case regardless of how many `update_de`
-invocations there are. In what follows, we will try to make this more efficient.
-
-Note that increasing *d* by *M* is equal to incrementing *cd* by *u&thinsp;M* and *ce* by *q&thinsp;M*. Similarly,
-increasing *e* by *M* is equal to incrementing *cd* by *v&thinsp;M* and *ce* by *r&thinsp;M*. So we could instead write:
-
-```python
-    ...
-    cd, ce = u*d + v*e, q*d + r*e
-    # Perform the equivalent of incrementing d, e by M when they're negative.
-    if d < 0:
-        cd += u*M
-        ce += q*M
-    if e < 0:
-        cd += v*M
-        ce += r*M
-    # Cancel out bottom N bits of cd and ce.
-    md = -((Mi * cd) % 2**N)
-    me = -((Mi * ce) % 2**N)
-    cd += md * M
-    ce += me * M
-    ...
-```
-
-Now note that we have two steps of corrections to *cd* and *ce* that add multiples of *M*: this
-increment, and the decrement that cancels out bottom bits. The second one depends on the first
-one, but they can still be efficiently combined by only computing the bottom bits of *cd* and *ce*
-at first, and using that to compute the final *md*, *me* values:
-
-```python
-def update_de(d, e, t, M, Mi):
-    """Multiply matrix t/2^N with [d, e], modulo M."""
-    u, v, q, r = t
-    md, me = 0, 0
-    # Compute what multiples of M to add to cd and ce.
-    if d < 0:
-        md += u
-        me += q
-    if e < 0:
-        md += v
-        me += r
-    # Compute bottom N bits of t*[d,e] + M*[md,me].
-    cd, ce = (u*d + v*e + md*M) % 2**N, (q*d + r*e + me*M) % 2**N
-    # Correct md and me such that the bottom N bits of t*[d,e] + M*[md,me] are zero.
-    md -= (Mi * cd) % 2**N
-    me -= (Mi * ce) % 2**N
-    # Do the full computation.
-    cd, ce = u*d + v*e + md*M, q*d + r*e + me*M
-    # And cleanly divide by 2**N.
-    return cd >> N, ce >> N
-```
-
-One last optimization: we can avoid the *md&thinsp;M* and *me&thinsp;M* multiplications in the bottom bits of *cd*
-and *ce* by moving them to the *md* and *me* correction:
-
-```python
-    ...
-    # Compute bottom N bits of t*[d,e].
-    cd, ce = (u*d + v*e) % 2**N, (q*d + r*e) % 2**N
-    # Correct md and me such that the bottom N bits of t*[d,e]+M*[md,me] are zero.
-    # Note that this is not the same as {md = (-Mi * cd) % 2**N} etc. That would also result in N
-    # zero bottom bits, but isn't guaranteed to be a reduction of [0,2^N) compared to the
-    # previous md and me values, and thus would violate our bounds analysis.
-    md -= (Mi*cd + md) % 2**N
-    me -= (Mi*ce + me) % 2**N
-    ...
-```
-
-The resulting function takes *d* and *e* in range *(-2M,M)* as inputs, and outputs values in the same
-range. That also means that the *d* value at the end of `modinv` will be in that range, while we want
-a result in *[0,M)*. To do that, we need a normalization function. It's easy to integrate the
-conditional negation of *d* (based on the sign of *f*) into it as well:
-
-```python
-def normalize(sign, v, M):
-    """Compute sign*v mod M, where v is in range (-2*M,M); output in [0,M)."""
-    assert sign == 1 or sign == -1
-    # v in (-2*M,M)
-    if v < 0:
-        v += M
-    # v in (-M,M). Now multiply v with sign (which can only be 1 or -1).
-    if sign == -1:
-        v = -v
-    # v in (-M,M)
-    if v < 0:
-        v += M
-    # v in [0,M)
-    return v
-```
-
-And calling it in `modinv` is simply:
-
-```python
-   ...
-   return normalize(f, d, M)
-```
-
-
-## 5. Constant-time operation
-
-The primary selling point of the algorithm is fast constant-time operation. What code flow still
-depends on the input data so far?
-
-- the number of iterations of the while *g &ne; 0* loop in `modinv`
-- the branches inside `divsteps_n_matrix`
-- the sign checks in `update_de`
-- the sign checks in `normalize`
-
-To make the while loop in `modinv` constant time it can be replaced with a constant number of
-iterations. The paper proves (Theorem 11.2) that *741* divsteps are sufficient for any *256*-bit
-inputs, and [safegcd-bounds](https://github.com/sipa/safegcd-bounds) shows that the slightly better bound *724* is
-sufficient even. Given that every loop iteration performs *N* divsteps, it will run a total of
-*&lceil;724/N&rceil;* times.
-
-To deal with the branches in `divsteps_n_matrix` we will replace them with constant-time bitwise
-operations (and hope the C compiler isn't smart enough to turn them back into branches; see
-`ctime_tests.c` for automated tests that this isn't the case). To do so, observe that a
-divstep can be written instead as (compare to the inner loop of `gcd` in section 1).
-
-```python
-    x = -f if delta > 0 else f         # set x equal to (input) -f or f
-    if g & 1:
-        g += x                         # set g to (input) g-f or g+f
-        if delta > 0:
-            delta = -delta
-            f += g                     # set f to (input) g (note that g was set to g-f before)
-    delta += 1
-    g >>= 1
-```
-
-To convert the above to bitwise operations, we rely on a trick to negate conditionally: per the
-definition of negative numbers in two's complement, (*-v == ~v + 1*) holds for every number *v*. As
-*-1* in two's complement is all *1* bits, bitflipping can be expressed as xor with *-1*. It follows
-that *-v == (v ^ -1) - (-1)*. Thus, if we have a variable *c* that takes on values *0* or *-1*, then
-*(v ^ c) - c* is *v* if *c=0* and *-v* if *c=-1*.
-
-Using this we can write:
-
-```python
-    x = -f if delta > 0 else f
-```
-
-in constant-time form as:
-
-```python
-    c1 = (-delta) >> 63
-    # Conditionally negate f based on c1:
-    x = (f ^ c1) - c1
-```
-
-To use that trick, we need a helper mask variable *c1* that resolves the condition *&delta;>0* to *-1*
-(if true) or *0* (if false). We compute *c1* using right shifting, which is equivalent to dividing by
-the specified power of *2* and rounding down (in Python, and also in C under the assumption of a typical two's complement system; see
-`assumptions.h` for tests that this is the case). Right shifting by *63* thus maps all
-numbers in range *[-2<sup>63</sup>,0)* to *-1*, and numbers in range *[0,2<sup>63</sup>)* to *0*.
-
-Using the facts that *x&0=0* and *x&(-1)=x* (on two's complement systems again), we can write:
-
-```python
-    if g & 1:
-        g += x
-```
-
-as:
-
-```python
-    # Compute c2=0 if g is even and c2=-1 if g is odd.
-    c2 = -(g & 1)
-    # This masks out x if g is even, and leaves x be if g is odd.
-    g += x & c2
-```
-
-Using the conditional negation trick again we can write:
-
-```python
-    if g & 1:
-        if delta > 0:
-            delta = -delta
-```
-
-as:
-
-```python
-    # Compute c3=-1 if g is odd and delta>0, and 0 otherwise.
-    c3 = c1 & c2
-    # Conditionally negate delta based on c3:
-    delta = (delta ^ c3) - c3
-```
-
-Finally:
-
-```python
-    if g & 1:
-        if delta > 0:
-            f += g
-```
-
-becomes:
-
-```python
-    f += g & c3
-```
-
-It turns out that this can be implemented more efficiently by applying the substitution
-*&eta;=-&delta;*. In this representation, negating *&delta;* corresponds to negating *&eta;*, and incrementing
-*&delta;* corresponds to decrementing *&eta;*. This allows us to remove the negation in the *c1*
-computation:
-
-```python
-    # Compute a mask c1 for eta < 0, and compute the conditional negation x of f:
-    c1 = eta >> 63
-    x = (f ^ c1) - c1
-    # Compute a mask c2 for odd g, and conditionally add x to g:
-    c2 = -(g & 1)
-    g += x & c2
-    # Compute a mask c for (eta < 0) and odd (input) g, and use it to conditionally negate eta,
-    # and add g to f:
-    c3 = c1 & c2
-    eta = (eta ^ c3) - c3
-    f += g & c3
-    # Incrementing delta corresponds to decrementing eta.
-    eta -= 1
-    g >>= 1
-```
-
-A variant of divsteps with better worst-case performance can be used instead: starting *&delta;* at
-*1/2* instead of *1*. This reduces the worst case number of iterations to *590* for *256*-bit inputs
-(which can be shown using convex hull analysis). In this case, the substitution *&zeta;=-(&delta;+1/2)*
-is used instead to keep the variable integral. Incrementing *&delta;* by *1* still translates to
-decrementing *&zeta;* by *1*, but negating *&delta;* now corresponds to going from *&zeta;* to *-(&zeta;+1)*, or
-*~&zeta;*. Doing that conditionally based on *c3* is simply:
-
-```python
-    ...
-    c3 = c1 & c2
-    zeta ^= c3
-    ...
-```
-
-By replacing the loop in `divsteps_n_matrix` with a variant of the divstep code above (extended to
-also apply all *f* operations to *u*, *v* and all *g* operations to *q*, *r*), a constant-time version of
-`divsteps_n_matrix` is obtained. The full code will be in section 7.
-
-These bit fiddling tricks can also be used to make the conditional negations and additions in
-`update_de` and `normalize` constant-time.
-
-
-## 6. Variable-time optimizations
-
-In section 5, we modified the `divsteps_n_matrix` function (and a few others) to be constant time.
-Constant time operations are only necessary when computing modular inverses of secret data. In
-other cases, it slows down calculations unnecessarily. In this section, we will construct a
-faster non-constant time `divsteps_n_matrix` function.
-
-To do so, first consider yet another way of writing the inner loop of divstep operations in
-`gcd` from section 1. This decomposition is also explained in the paper in section 8.2. We use
-the original version with initial *&delta;=1* and *&eta;=-&delta;* here.
-
-```python
-for _ in range(N):
-    if g & 1 and eta < 0:
-        eta, f, g = -eta, g, -f
-    if g & 1:
-        g += f
-    eta -= 1
-    g >>= 1
-```
-
-Whenever *g* is even, the loop only shifts *g* down and decreases *&eta;*. When *g* ends in multiple zero
-bits, these iterations can be consolidated into one step. This requires counting the bottom zero
-bits efficiently, which is possible on most platforms; it is abstracted here as the function
-`count_trailing_zeros`.
-
-```python
-def count_trailing_zeros(v):
-    """
-    When v is zero, consider all N zero bits as "trailing".
-    For a non-zero value v, find z such that v=(d<<z) for some odd d.
-    """
-    if v == 0:
-        return N
-    else:
-        return (v & -v).bit_length() - 1
-
-i = N # divsteps left to do
-while True:
-    # Get rid of all bottom zeros at once. In the first iteration, g may be odd and the following
-    # lines have no effect (until "if eta < 0").
-    zeros = min(i, count_trailing_zeros(g))
-    eta -= zeros
-    g >>= zeros
-    i -= zeros
-    if i == 0:
-        break
-    # We know g is odd now
-    if eta < 0:
-        eta, f, g = -eta, g, -f
-    g += f
-    # g is even now, and the eta decrement and g shift will happen in the next loop.
-```
-
-We can now remove multiple bottom *0* bits from *g* at once, but still need a full iteration whenever
-there is a bottom *1* bit. In what follows, we will get rid of multiple *1* bits simultaneously as
-well.
-
-Observe that as long as *&eta; &geq; 0*, the loop does not modify *f*. Instead, it cancels out bottom
-bits of *g* and shifts them out, and decreases *&eta;* and *i* accordingly - interrupting only when *&eta;*
-becomes negative, or when *i* reaches *0*. Combined, this is equivalent to adding a multiple of *f* to
-*g* to cancel out multiple bottom bits, and then shifting them out.
-
-It is easy to find what that multiple is: we want a number *w* such that *g+w&thinsp;f* has a few bottom
-zero bits. If that number of bits is *L*, we want *g+w&thinsp;f mod 2<sup>L</sup> = 0*, or *w = -g/f mod 2<sup>L</sup>*. Since *f*
-is odd, such a *w* exists for any *L*. *L* cannot be more than *i* steps (as we'd finish the loop before
-doing more) or more than *&eta;+1* steps (as we'd run `eta, f, g = -eta, g, -f` at that point), but
-apart from that, we're only limited by the complexity of computing *w*.
-
-This code demonstrates how to cancel up to 4 bits per step:
-
-```python
-NEGINV16 = [15, 5, 3, 9, 7, 13, 11, 1] # NEGINV16[n//2] = (-n)^-1 mod 16, for odd n
-i = N
-while True:
-    zeros = min(i, count_trailing_zeros(g))
-    eta -= zeros
-    g >>= zeros
-    i -= zeros
-    if i == 0:
-        break
-    # We know g is odd now
-    if eta < 0:
-        eta, f, g = -eta, g, -f
-    # Compute limit on number of bits to cancel
-    limit = min(min(eta + 1, i), 4)
-    # Compute w = -g/f mod 2**limit, using the table value for -1/f mod 2**4. Note that f is
-    # always odd, so its inverse modulo a power of two always exists.
-    w = (g * NEGINV16[(f & 15) // 2]) % (2**limit)
-    # As w = -g/f mod (2**limit), g+w*f mod 2**limit = 0 mod 2**limit.
-    g += w * f
-    assert g % (2**limit) == 0
-    # The next iteration will now shift out at least limit bottom zero bits from g.
-```
-
-By using a bigger table more bits can be cancelled at once. The table can also be implemented
-as a formula. Several formulas are known for computing modular inverses modulo powers of two;
-some can be found in Hacker's Delight second edition by Henry S. Warren, Jr. pages 245-247.
-Here we need the negated modular inverse, which is a simple transformation of those:
-
-- Instead of a 3-bit table:
-  - *-f* or *f ^ 6*
-- Instead of a 4-bit table:
-  - *1 - f(f + 1)*
-  - *-(f + (((f + 1) & 4) << 1))*
-- For larger tables the following technique can be used: if *w=-1/f mod 2<sup>L</sup>*, then *w(w&thinsp;f+2)* is
-  *-1/f mod 2<sup>2L</sup>*. This allows extending the previous formulas (or tables). In particular we
-  have this 6-bit function (based on the 3-bit function above):
-  - *f(f<sup>2</sup> - 2)*
-
-This loop, again extended to also handle *u*, *v*, *q*, and *r* alongside *f* and *g*, placed in
-`divsteps_n_matrix`, gives a significantly faster, but non-constant time version.
-
-
-## 7. Final Python version
-
-All together we need the following functions:
-
-- A way to compute the transition matrix in constant time, using the `divsteps_n_matrix` function
-  from section 2, but with its loop replaced by a variant of the constant-time divstep from
-  section 5, extended to handle *u*, *v*, *q*, *r*:
-
-```python
-def divsteps_n_matrix(zeta, f, g):
-    """Compute zeta and transition matrix t after N divsteps (multiplied by 2^N)."""
-    u, v, q, r = 1, 0, 0, 1 # start with identity matrix
-    for _ in range(N):
-        c1 = zeta >> 63
-        # Compute x, y, z as conditionally-negated versions of f, u, v.
-        x, y, z = (f ^ c1) - c1, (u ^ c1) - c1, (v ^ c1) - c1
-        c2 = -(g & 1)
-        # Conditionally add x, y, z to g, q, r.
-        g, q, r = g + (x & c2), q + (y & c2), r + (z & c2)
-        c1 &= c2                     # reusing c1 here for the earlier c3 variable
-        zeta = (zeta ^ c1) - 1       # inlining the unconditional zeta decrement here
-        # Conditionally add g, q, r to f, u, v.
-        f, u, v = f + (g & c1), u + (q & c1), v + (r & c1)
-        # When shifting g down, don't shift q, r, as we construct a transition matrix multiplied
-        # by 2^N. Instead, shift f's coefficients u and v up.
-        g, u, v = g >> 1, u << 1, v << 1
-    return zeta, (u, v, q, r)
-```
-
-- The functions to update *f* and *g*, and *d* and *e*, from section 2 and section 4, with the constant-time
-  changes to `update_de` from section 5:
-
-```python
-def update_fg(f, g, t):
-    """Multiply matrix t/2^N with [f, g]."""
-    u, v, q, r = t
-    cf, cg = u*f + v*g, q*f + r*g
-    return cf >> N, cg >> N
-
-def update_de(d, e, t, M, Mi):
-    """Multiply matrix t/2^N with [d, e], modulo M."""
-    u, v, q, r = t
-    d_sign, e_sign = d >> 257, e >> 257
-    md, me = (u & d_sign) + (v & e_sign), (q & d_sign) + (r & e_sign)
-    cd, ce = (u*d + v*e) % 2**N, (q*d + r*e) % 2**N
-    md -= (Mi*cd + md) % 2**N
-    me -= (Mi*ce + me) % 2**N
-    cd, ce = u*d + v*e + M*md, q*d + r*e + M*me
-    return cd >> N, ce >> N
-```
-
-- The `normalize` function from section 4, made constant time as well:
-
-```python
-def normalize(sign, v, M):
-    """Compute sign*v mod M, where v in (-2*M,M); output in [0,M)."""
-    v_sign = v >> 257
-    # Conditionally add M to v.
-    v += M & v_sign
-    c = (sign - 1) >> 1
-    # Conditionally negate v.
-    v = (v ^ c) - c
-    v_sign = v >> 257
-    # Conditionally add M to v again.
-    v += M & v_sign
-    return v
-```
-
-- And finally the `modinv` function too, adapted to use *&zeta;* instead of *&delta;*, and using the fixed
-  iteration count from section 5:
-
-```python
-def modinv(M, Mi, x):
-    """Compute the modular inverse of x mod M, given Mi=1/M mod 2^N."""
-    zeta, f, g, d, e = -1, M, x, 0, 1
-    for _ in range((590 + N - 1) // N):
-        zeta, t = divsteps_n_matrix(zeta, f % 2**N, g % 2**N)
-        f, g = update_fg(f, g, t)
-        d, e = update_de(d, e, t, M, Mi)
-    return normalize(f, d, M)
-```
-
-- To get a variable time version, replace the `divsteps_n_matrix` function with one that uses the
-  divsteps loop from section 5, and a `modinv` version that calls it without the fixed iteration
-  count:
-
-```python
-NEGINV16 = [15, 5, 3, 9, 7, 13, 11, 1] # NEGINV16[n//2] = (-n)^-1 mod 16, for odd n
-def divsteps_n_matrix_var(eta, f, g):
-    """Compute eta and transition matrix t after N divsteps (multiplied by 2^N)."""
-    u, v, q, r = 1, 0, 0, 1
-    i = N
-    while True:
-        zeros = min(i, count_trailing_zeros(g))
-        eta, i = eta - zeros, i - zeros
-        g, u, v = g >> zeros, u << zeros, v << zeros
-        if i == 0:
-            break
-        if eta < 0:
-            eta, f, u, v, g, q, r = -eta, g, q, r, -f, -u, -v
-        limit = min(min(eta + 1, i), 4)
-        w = (g * NEGINV16[(f & 15) // 2]) % (2**limit)
-        g, q, r = g + w*f, q + w*u, r + w*v
-    return eta, (u, v, q, r)
-
-def modinv_var(M, Mi, x):
-    """Compute the modular inverse of x mod M, given Mi = 1/M mod 2^N."""
-    eta, f, g, d, e = -1, M, x, 0, 1
-    while g != 0:
-        eta, t = divsteps_n_matrix_var(eta, f % 2**N, g % 2**N)
-        f, g = update_fg(f, g, t)
-        d, e = update_de(d, e, t, M, Mi)
-    return normalize(f, d, Mi)
-```
-
-## 8. From GCDs to Jacobi symbol
-
-We can also use a similar approach to calculate Jacobi symbol *(x | M)* by keeping track of an
-extra variable *j*, for which at every step *(x | M) = j (g | f)*. As we update *f* and *g*, we
-make corresponding updates to *j* using
-[properties of the Jacobi symbol](https://en.wikipedia.org/wiki/Jacobi_symbol#Properties):
-* *((g/2) | f)* is either *(g | f)* or *-(g | f)*, depending on the value of *f mod 8* (negating if it's *3* or *5*).
-* *(f | g)* is either *(g | f)* or *-(g | f)*, depending on *f mod 4* and *g mod 4* (negating if both are *3*).
-
-These updates depend only on the values of *f* and *g* modulo *4* or *8*, and can thus be applied
-very quickly, as long as we keep track of a few additional bits of *f* and *g*. Overall, this
-calculation is slightly simpler than the one for the modular inverse because we no longer need to
-keep track of *d* and *e*.
-
-However, one difficulty of this approach is that the Jacobi symbol *(a | n)* is only defined for
-positive odd integers *n*, whereas in the original safegcd algorithm, *f, g* can take negative
-values. We resolve this by using the following modified steps:
-
-```python
-        # Before
-        if delta > 0 and g & 1:
-            delta, f, g = 1 - delta, g, (g - f) // 2
-
-        # After
-        if delta > 0 and g & 1:
-            delta, f, g = 1 - delta, g, (g + f) // 2
-```
-
-The algorithm is still correct, since the changed divstep, called a "posdivstep" (see section 8.4
-and E.5 in the paper) preserves *gcd(f, g)*. However, there's no proof that the modified algorithm
-will converge. The justification for posdivsteps is completely empirical: in practice, it appears
-that the vast majority of nonzero inputs converge to *f=g=gcd(f<sub>0</sub>, g<sub>0</sub>)* in a
-number of steps proportional to their logarithm.
-
-Note that:
-- We require inputs to satisfy *gcd(x, M) = 1*, as otherwise *f=1* is not reached.
-- We require inputs *x &neq; 0*, because applying posdivstep with *g=0* has no effect.
-- We need to update the termination condition from *g=0* to *f=1*.
-
-We account for the possibility of nonconvergence by only performing a bounded number of
-posdivsteps, and then falling back to square-root based Jacobi calculation if a solution has not
-yet been found.
-
-The optimizations in sections 3-7 above are described in the context of the original divsteps, but
-in the C implementation we also adapt most of them (not including "avoiding modulus operations",
-since it's not necessary to track *d, e*, and "constant-time operation", since we never calculate
-Jacobi symbols for secret data) to the posdivsteps version.

external/secp256k1/examples/CMakeLists.txt

@@ -1,27 +0,0 @@
-add_library(example INTERFACE)
-target_include_directories(example INTERFACE
-  ${PROJECT_SOURCE_DIR}/include
-)
-target_link_libraries(example INTERFACE
-  secp256k1
-  $<$<PLATFORM_ID:Windows>:bcrypt>
-)
-if(NOT BUILD_SHARED_LIBS AND MSVC)
-  target_link_options(example INTERFACE /IGNORE:4217)
-endif()
-
-add_executable(ecdsa_example ecdsa.c)
-target_link_libraries(ecdsa_example example)
-add_test(NAME ecdsa_example COMMAND ecdsa_example)
-
-if(SECP256K1_ENABLE_MODULE_ECDH)
-  add_executable(ecdh_example ecdh.c)
-  target_link_libraries(ecdh_example example)
-  add_test(NAME ecdh_example COMMAND ecdh_example)
-endif()
-
-if(SECP256K1_ENABLE_MODULE_SCHNORRSIG)
-  add_executable(schnorr_example schnorr.c)
-  target_link_libraries(schnorr_example example)
-  add_test(NAME schnorr_example COMMAND schnorr_example)
-endif()

external/secp256k1/examples/EXAMPLES_COPYING

@@ -1,121 +0,0 @@
-Creative Commons Legal Code
-
-CC0 1.0 Universal
-
-    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
-    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
-    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
-    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
-    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
-    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
-    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
-    HEREUNDER.
-
-Statement of Purpose
-
-The laws of most jurisdictions throughout the world automatically confer
-exclusive Copyright and Related Rights (defined below) upon the creator
-and subsequent owner(s) (each and all, an "owner") of an original work of
-authorship and/or a database (each, a "Work").
-
-Certain owners wish to permanently relinquish those rights to a Work for
-the purpose of contributing to a commons of creative, cultural and
-scientific works ("Commons") that the public can reliably and without fear
-of later claims of infringement build upon, modify, incorporate in other
-works, reuse and redistribute as freely as possible in any form whatsoever
-and for any purposes, including without limitation commercial purposes.
-These owners may contribute to the Commons to promote the ideal of a free
-culture and the further production of creative, cultural and scientific
-works, or to gain reputation or greater distribution for their Work in
-part through the use and efforts of others.
-
-For these and/or other purposes and motivations, and without any
-expectation of additional consideration or compensation, the person
-associating CC0 with a Work (the "Affirmer"), to the extent that he or she
-is an owner of Copyright and Related Rights in the Work, voluntarily
-elects to apply CC0 to the Work and publicly distribute the Work under its
-terms, with knowledge of his or her Copyright and Related Rights in the
-Work and the meaning and intended legal effect of CC0 on those rights.
-
-1. Copyright and Related Rights. A Work made available under CC0 may be
-protected by copyright and related or neighboring rights ("Copyright and
-Related Rights"). Copyright and Related Rights include, but are not
-limited to, the following:
-
-  i. the right to reproduce, adapt, distribute, perform, display,
-     communicate, and translate a Work;
- ii. moral rights retained by the original author(s) and/or performer(s);
-iii. publicity and privacy rights pertaining to a person's image or
-     likeness depicted in a Work;
- iv. rights protecting against unfair competition in regards to a Work,
-     subject to the limitations in paragraph 4(a), below;
-  v. rights protecting the extraction, dissemination, use and reuse of data
-     in a Work;
- vi. database rights (such as those arising under Directive 96/9/EC of the
-     European Parliament and of the Council of 11 March 1996 on the legal
-     protection of databases, and under any national implementation
-     thereof, including any amended or successor version of such
-     directive); and
-vii. other similar, equivalent or corresponding rights throughout the
-     world based on applicable law or treaty, and any national
-     implementations thereof.
-
-2. Waiver. To the greatest extent permitted by, but not in contravention
-of, applicable law, Affirmer hereby overtly, fully, permanently,
-irrevocably and unconditionally waives, abandons, and surrenders all of
-Affirmer's Copyright and Related Rights and associated claims and causes
-of action, whether now known or unknown (including existing as well as
-future claims and causes of action), in the Work (i) in all territories
-worldwide, (ii) for the maximum duration provided by applicable law or
-treaty (including future time extensions), (iii) in any current or future
-medium and for any number of copies, and (iv) for any purpose whatsoever,
-including without limitation commercial, advertising or promotional
-purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
-member of the public at large and to the detriment of Affirmer's heirs and
-successors, fully intending that such Waiver shall not be subject to
-revocation, rescission, cancellation, termination, or any other legal or
-equitable action to disrupt the quiet enjoyment of the Work by the public
-as contemplated by Affirmer's express Statement of Purpose.
-
-3. Public License Fallback. Should any part of the Waiver for any reason
-be judged legally invalid or ineffective under applicable law, then the
-Waiver shall be preserved to the maximum extent permitted taking into
-account Affirmer's express Statement of Purpose. In addition, to the
-extent the Waiver is so judged Affirmer hereby grants to each affected
-person a royalty-free, non transferable, non sublicensable, non exclusive,
-irrevocable and unconditional license to exercise Affirmer's Copyright and
-Related Rights in the Work (i) in all territories worldwide, (ii) for the
-maximum duration provided by applicable law or treaty (including future
-time extensions), (iii) in any current or future medium and for any number
-of copies, and (iv) for any purpose whatsoever, including without
-limitation commercial, advertising or promotional purposes (the
-"License"). The License shall be deemed effective as of the date CC0 was
-applied by Affirmer to the Work. Should any part of the License for any
-reason be judged legally invalid or ineffective under applicable law, such
-partial invalidity or ineffectiveness shall not invalidate the remainder
-of the License, and in such case Affirmer hereby affirms that he or she
-will not (i) exercise any of his or her remaining Copyright and Related
-Rights in the Work or (ii) assert any associated claims and causes of
-action with respect to the Work, in either case contrary to Affirmer's
-express Statement of Purpose.
-
-4. Limitations and Disclaimers.
-
- a. No trademark or patent rights held by Affirmer are waived, abandoned,
-    surrendered, licensed or otherwise affected by this document.
- b. Affirmer offers the Work as-is and makes no representations or
-    warranties of any kind concerning the Work, express, implied,
-    statutory or otherwise, including without limitation warranties of
-    title, merchantability, fitness for a particular purpose, non
-    infringement, or the absence of latent or other defects, accuracy, or
-    the present or absence of errors, whether or not discoverable, all to
-    the greatest extent permissible under applicable law.
- c. Affirmer disclaims responsibility for clearing rights of other persons
-    that may apply to the Work or any use thereof, including without
-    limitation any person's Copyright and Related Rights in the Work.
-    Further, Affirmer disclaims responsibility for obtaining any necessary
-    consents, permissions or other rights required for any use of the
-    Work.
- d. Affirmer understands and acknowledges that Creative Commons is not a
-    party to this document and has no duty or obligation with respect to
-    this CC0 or use of the Work.

external/secp256k1/examples/ecdh.c

@@ -1,122 +0,0 @@
-/*************************************************************************
- * Written in 2020-2022 by Elichai Turkel                                *
- * To the extent possible under law, the author(s) have dedicated all    *
- * copyright and related and neighboring rights to the software in this  *
- * file to the public domain worldwide. This software is distributed     *
- * without any warranty. For the CC0 Public Domain Dedication, see       *
- * EXAMPLES_COPYING or https://creativecommons.org/publicdomain/zero/1.0 *
- *************************************************************************/
-
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-
-#include <secp256k1.h>
-#include <secp256k1_ecdh.h>
-
-#include "examples_util.h"
-
-int main(void) {
-    unsigned char seckey1[32];
-    unsigned char seckey2[32];
-    unsigned char compressed_pubkey1[33];
-    unsigned char compressed_pubkey2[33];
-    unsigned char shared_secret1[32];
-    unsigned char shared_secret2[32];
-    unsigned char randomize[32];
-    int return_val;
-    size_t len;
-    secp256k1_pubkey pubkey1;
-    secp256k1_pubkey pubkey2;
-
-    /* Before we can call actual API functions, we need to create a "context". */
-    secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
-    if (!fill_random(randomize, sizeof(randomize))) {
-        printf("Failed to generate randomness\n");
-        return 1;
-    }
-    /* Randomizing the context is recommended to protect against side-channel
-     * leakage See `secp256k1_context_randomize` in secp256k1.h for more
-     * information about it. This should never fail. */
-    return_val = secp256k1_context_randomize(ctx, randomize);
-    assert(return_val);
-
-    /*** Key Generation ***/
-
-    /* If the secret key is zero or out of range (bigger than secp256k1's
-     * order), we try to sample a new key. Note that the probability of this
-     * happening is negligible. */
-    while (1) {
-        if (!fill_random(seckey1, sizeof(seckey1)) || !fill_random(seckey2, sizeof(seckey2))) {
-            printf("Failed to generate randomness\n");
-            return 1;
-        }
-        if (secp256k1_ec_seckey_verify(ctx, seckey1) && secp256k1_ec_seckey_verify(ctx, seckey2)) {
-            break;
-        }
-    }
-
-    /* Public key creation using a valid context with a verified secret key should never fail */
-    return_val = secp256k1_ec_pubkey_create(ctx, &pubkey1, seckey1);
-    assert(return_val);
-    return_val = secp256k1_ec_pubkey_create(ctx, &pubkey2, seckey2);
-    assert(return_val);
-
-    /* Serialize pubkey1 in a compressed form (33 bytes), should always return 1 */
-    len = sizeof(compressed_pubkey1);
-    return_val = secp256k1_ec_pubkey_serialize(ctx, compressed_pubkey1, &len, &pubkey1, SECP256K1_EC_COMPRESSED);
-    assert(return_val);
-    /* Should be the same size as the size of the output, because we passed a 33 byte array. */
-    assert(len == sizeof(compressed_pubkey1));
-
-    /* Serialize pubkey2 in a compressed form (33 bytes) */
-    len = sizeof(compressed_pubkey2);
-    return_val = secp256k1_ec_pubkey_serialize(ctx, compressed_pubkey2, &len, &pubkey2, SECP256K1_EC_COMPRESSED);
-    assert(return_val);
-    /* Should be the same size as the size of the output, because we passed a 33 byte array. */
-    assert(len == sizeof(compressed_pubkey2));
-
-    /*** Creating the shared secret ***/
-
-    /* Perform ECDH with seckey1 and pubkey2. Should never fail with a verified
-     * seckey and valid pubkey */
-    return_val = secp256k1_ecdh(ctx, shared_secret1, &pubkey2, seckey1, NULL, NULL);
-    assert(return_val);
-
-    /* Perform ECDH with seckey2 and pubkey1. Should never fail with a verified
-     * seckey and valid pubkey */
-    return_val = secp256k1_ecdh(ctx, shared_secret2, &pubkey1, seckey2, NULL, NULL);
-    assert(return_val);
-
-    /* Both parties should end up with the same shared secret */
-    return_val = memcmp(shared_secret1, shared_secret2, sizeof(shared_secret1));
-    assert(return_val == 0);
-
-    printf("Secret Key1: ");
-    print_hex(seckey1, sizeof(seckey1));
-    printf("Compressed Pubkey1: ");
-    print_hex(compressed_pubkey1, sizeof(compressed_pubkey1));
-    printf("\nSecret Key2: ");
-    print_hex(seckey2, sizeof(seckey2));
-    printf("Compressed Pubkey2: ");
-    print_hex(compressed_pubkey2, sizeof(compressed_pubkey2));
-    printf("\nShared Secret: ");
-    print_hex(shared_secret1, sizeof(shared_secret1));
-
-    /* This will clear everything from the context and free the memory */
-    secp256k1_context_destroy(ctx);
-
-    /* It's best practice to try to clear secrets from memory after using them.
-     * This is done because some bugs can allow an attacker to leak memory, for
-     * example through "out of bounds" array access (see Heartbleed), Or the OS
-     * swapping them to disk. Hence, we overwrite the secret key buffer with zeros.
-     *
-     * Here we are preventing these writes from being optimized out, as any good compiler
-     * will remove any writes that aren't used. */
-    secure_erase(seckey1, sizeof(seckey1));
-    secure_erase(seckey2, sizeof(seckey2));
-    secure_erase(shared_secret1, sizeof(shared_secret1));
-    secure_erase(shared_secret2, sizeof(shared_secret2));
-
-    return 0;
-}

external/secp256k1/examples/ecdsa.c

@@ -1,139 +0,0 @@
-/*************************************************************************
- * Written in 2020-2022 by Elichai Turkel                                *
- * To the extent possible under law, the author(s) have dedicated all    *
- * copyright and related and neighboring rights to the software in this  *
- * file to the public domain worldwide. This software is distributed     *
- * without any warranty. For the CC0 Public Domain Dedication, see       *
- * EXAMPLES_COPYING or https://creativecommons.org/publicdomain/zero/1.0 *
- *************************************************************************/
-
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-
-#include <secp256k1.h>
-
-#include "examples_util.h"
-
-int main(void) {
-    /* Instead of signing the message directly, we must sign a 32-byte hash.
-     * Here the message is "Hello, world!" and the hash function was SHA-256.
-     * An actual implementation should just call SHA-256, but this example
-     * hardcodes the output to avoid depending on an additional library.
-     * See https://bitcoin.stackexchange.com/questions/81115/if-someone-wanted-to-pretend-to-be-satoshi-by-posting-a-fake-signature-to-defrau/81116#81116 */
-    unsigned char msg_hash[32] = {
-        0x31, 0x5F, 0x5B, 0xDB, 0x76, 0xD0, 0x78, 0xC4,
-        0x3B, 0x8A, 0xC0, 0x06, 0x4E, 0x4A, 0x01, 0x64,
-        0x61, 0x2B, 0x1F, 0xCE, 0x77, 0xC8, 0x69, 0x34,
-        0x5B, 0xFC, 0x94, 0xC7, 0x58, 0x94, 0xED, 0xD3,
-    };
-    unsigned char seckey[32];
-    unsigned char randomize[32];
-    unsigned char compressed_pubkey[33];
-    unsigned char serialized_signature[64];
-    size_t len;
-    int is_signature_valid, is_signature_valid2;
-    int return_val;
-    secp256k1_pubkey pubkey;
-    secp256k1_ecdsa_signature sig;
-    /* Before we can call actual API functions, we need to create a "context". */
-    secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
-    if (!fill_random(randomize, sizeof(randomize))) {
-        printf("Failed to generate randomness\n");
-        return 1;
-    }
-    /* Randomizing the context is recommended to protect against side-channel
-     * leakage See `secp256k1_context_randomize` in secp256k1.h for more
-     * information about it. This should never fail. */
-    return_val = secp256k1_context_randomize(ctx, randomize);
-    assert(return_val);
-
-    /*** Key Generation ***/
-
-    /* If the secret key is zero or out of range (bigger than secp256k1's
-     * order), we try to sample a new key. Note that the probability of this
-     * happening is negligible. */
-    while (1) {
-        if (!fill_random(seckey, sizeof(seckey))) {
-            printf("Failed to generate randomness\n");
-            return 1;
-        }
-        if (secp256k1_ec_seckey_verify(ctx, seckey)) {
-            break;
-        }
-    }
-
-    /* Public key creation using a valid context with a verified secret key should never fail */
-    return_val = secp256k1_ec_pubkey_create(ctx, &pubkey, seckey);
-    assert(return_val);
-
-    /* Serialize the pubkey in a compressed form(33 bytes). Should always return 1. */
-    len = sizeof(compressed_pubkey);
-    return_val = secp256k1_ec_pubkey_serialize(ctx, compressed_pubkey, &len, &pubkey, SECP256K1_EC_COMPRESSED);
-    assert(return_val);
-    /* Should be the same size as the size of the output, because we passed a 33 byte array. */
-    assert(len == sizeof(compressed_pubkey));
-
-    /*** Signing ***/
-
-    /* Generate an ECDSA signature `noncefp` and `ndata` allows you to pass a
-     * custom nonce function, passing `NULL` will use the RFC-6979 safe default.
-     * Signing with a valid context, verified secret key
-     * and the default nonce function should never fail. */
-    return_val = secp256k1_ecdsa_sign(ctx, &sig, msg_hash, seckey, NULL, NULL);
-    assert(return_val);
-
-    /* Serialize the signature in a compact form. Should always return 1
-     * according to the documentation in secp256k1.h. */
-    return_val = secp256k1_ecdsa_signature_serialize_compact(ctx, serialized_signature, &sig);
-    assert(return_val);
-
-
-    /*** Verification ***/
-
-    /* Deserialize the signature. This will return 0 if the signature can't be parsed correctly. */
-    if (!secp256k1_ecdsa_signature_parse_compact(ctx, &sig, serialized_signature)) {
-        printf("Failed parsing the signature\n");
-        return 1;
-    }
-
-    /* Deserialize the public key. This will return 0 if the public key can't be parsed correctly. */
-    if (!secp256k1_ec_pubkey_parse(ctx, &pubkey, compressed_pubkey, sizeof(compressed_pubkey))) {
-        printf("Failed parsing the public key\n");
-        return 1;
-    }
-
-    /* Verify a signature. This will return 1 if it's valid and 0 if it's not. */
-    is_signature_valid = secp256k1_ecdsa_verify(ctx, &sig, msg_hash, &pubkey);
-
-    printf("Is the signature valid? %s\n", is_signature_valid ? "true" : "false");
-    printf("Secret Key: ");
-    print_hex(seckey, sizeof(seckey));
-    printf("Public Key: ");
-    print_hex(compressed_pubkey, sizeof(compressed_pubkey));
-    printf("Signature: ");
-    print_hex(serialized_signature, sizeof(serialized_signature));
-
-    /* This will clear everything from the context and free the memory */
-    secp256k1_context_destroy(ctx);
-
-    /* Bonus example: if all we need is signature verification (and no key
-       generation or signing), we don't need to use a context created via
-       secp256k1_context_create(). We can simply use the static (i.e., global)
-       context secp256k1_context_static. See its description in
-       include/secp256k1.h for details. */
-    is_signature_valid2 = secp256k1_ecdsa_verify(secp256k1_context_static,
-                                                 &sig, msg_hash, &pubkey);
-    assert(is_signature_valid2 == is_signature_valid);
-
-    /* It's best practice to try to clear secrets from memory after using them.
-     * This is done because some bugs can allow an attacker to leak memory, for
-     * example through "out of bounds" array access (see Heartbleed), Or the OS
-     * swapping them to disk. Hence, we overwrite the secret key buffer with zeros.
-     *
-     * Here we are preventing these writes from being optimized out, as any good compiler
-     * will remove any writes that aren't used. */
-    secure_erase(seckey, sizeof(seckey));
-
-    return 0;
-}

external/secp256k1/examples/examples_util.h

@@ -1,108 +0,0 @@
-/*************************************************************************
- * Copyright (c) 2020-2021 Elichai Turkel                                *
- * Distributed under the CC0 software license, see the accompanying file *
- * EXAMPLES_COPYING or https://creativecommons.org/publicdomain/zero/1.0 *
- *************************************************************************/
-
-/*
- * This file is an attempt at collecting best practice methods for obtaining randomness with different operating systems.
- * It may be out-of-date. Consult the documentation of the operating system before considering to use the methods below.
- *
- * Platform randomness sources:
- * Linux   -> `getrandom(2)`(`sys/random.h`), if not available `/dev/urandom` should be used. http://man7.org/linux/man-pages/man2/getrandom.2.html, https://linux.die.net/man/4/urandom
- * macOS   -> `getentropy(2)`(`sys/random.h`), if not available `/dev/urandom` should be used. https://www.unix.com/man-page/mojave/2/getentropy, https://opensource.apple.com/source/xnu/xnu-517.12.7/bsd/man/man4/random.4.auto.html
- * FreeBSD -> `getrandom(2)`(`sys/random.h`), if not available `kern.arandom` should be used. https://www.freebsd.org/cgi/man.cgi?query=getrandom, https://www.freebsd.org/cgi/man.cgi?query=random&sektion=4
- * OpenBSD -> `getentropy(2)`(`unistd.h`), if not available `/dev/urandom` should be used. https://man.openbsd.org/getentropy, https://man.openbsd.org/urandom
- * Windows -> `BCryptGenRandom`(`bcrypt.h`). https://docs.microsoft.com/en-us/windows/win32/api/bcrypt/nf-bcrypt-bcryptgenrandom
- */
-
-#if defined(_WIN32)
-/*
- * The defined WIN32_NO_STATUS macro disables return code definitions in
- * windows.h, which avoids "macro redefinition" MSVC warnings in ntstatus.h.
- */
-#define WIN32_NO_STATUS
-#include <windows.h>
-#undef WIN32_NO_STATUS
-#include <ntstatus.h>
-#include <bcrypt.h>
-#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
-#include <sys/random.h>
-#elif defined(__OpenBSD__)
-#include <unistd.h>
-#else
-#error "Couldn't identify the OS"
-#endif
-
-#include <stddef.h>
-#include <limits.h>
-#include <stdio.h>
-
-
-/* Returns 1 on success, and 0 on failure. */
-static int fill_random(unsigned char* data, size_t size) {
-#if defined(_WIN32)
-    NTSTATUS res = BCryptGenRandom(NULL, data, size, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
-    if (res != STATUS_SUCCESS || size > ULONG_MAX) {
-        return 0;
-    } else {
-        return 1;
-    }
-#elif defined(__linux__) || defined(__FreeBSD__)
-    /* If `getrandom(2)` is not available you should fallback to /dev/urandom */
-    ssize_t res = getrandom(data, size, 0);
-    if (res < 0 || (size_t)res != size ) {
-        return 0;
-    } else {
-        return 1;
-    }
-#elif defined(__APPLE__) || defined(__OpenBSD__)
-    /* If `getentropy(2)` is not available you should fallback to either
-     * `SecRandomCopyBytes` or /dev/urandom */
-    int res = getentropy(data, size);
-    if (res == 0) {
-        return 1;
-    } else {
-        return 0;
-    }
-#endif
-    return 0;
-}
-
-static void print_hex(unsigned char* data, size_t size) {
-    size_t i;
-    printf("0x");
-    for (i = 0; i < size; i++) {
-        printf("%02x", data[i]);
-    }
-    printf("\n");
-}
-
-#if defined(_MSC_VER)
-// For SecureZeroMemory
-#include <Windows.h>
-#endif
-/* Cleanses memory to prevent leaking sensitive info. Won't be optimized out. */
-static void secure_erase(void *ptr, size_t len) {
-#if defined(_MSC_VER)
-    /* SecureZeroMemory is guaranteed not to be optimized out by MSVC. */
-    SecureZeroMemory(ptr, len);
-#elif defined(__GNUC__)
-    /* We use a memory barrier that scares the compiler away from optimizing out the memset.
-     *
-     * Quoting Adam Langley <agl@google.com> in commit ad1907fe73334d6c696c8539646c21b11178f20f
-     * in BoringSSL (ISC License):
-     *    As best as we can tell, this is sufficient to break any optimisations that
-     *    might try to eliminate "superfluous" memsets.
-     * This method used in memzero_explicit() the Linux kernel, too. Its advantage is that it is
-     * pretty efficient, because the compiler can still implement the memset() efficently,
-     * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by
-     * Yang et al. (USENIX Security 2017) for more background.
-     */
-    memset(ptr, 0, len);
-    __asm__ __volatile__("" : : "r"(ptr) : "memory");
-#else
-    void *(*volatile const volatile_memset)(void *, int, size_t) = memset;
-    volatile_memset(ptr, 0, len);
-#endif
-}

external/secp256k1/examples/schnorr.c

@@ -1,156 +0,0 @@
-/*************************************************************************
- * Written in 2020-2022 by Elichai Turkel                                *
- * To the extent possible under law, the author(s) have dedicated all    *
- * copyright and related and neighboring rights to the software in this  *
- * file to the public domain worldwide. This software is distributed     *
- * without any warranty. For the CC0 Public Domain Dedication, see       *
- * EXAMPLES_COPYING or https://creativecommons.org/publicdomain/zero/1.0 *
- *************************************************************************/
-
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-
-#include <secp256k1.h>
-#include <secp256k1_extrakeys.h>
-#include <secp256k1_schnorrsig.h>
-
-#include "examples_util.h"
-
-int main(void) {
-    unsigned char msg[12] = "Hello World!";
-    unsigned char msg_hash[32];
-    unsigned char tag[17] = "my_fancy_protocol";
-    unsigned char seckey[32];
-    unsigned char randomize[32];
-    unsigned char auxiliary_rand[32];
-    unsigned char serialized_pubkey[32];
-    unsigned char signature[64];
-    int is_signature_valid, is_signature_valid2;
-    int return_val;
-    secp256k1_xonly_pubkey pubkey;
-    secp256k1_keypair keypair;
-    /* Before we can call actual API functions, we need to create a "context". */
-    secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
-    if (!fill_random(randomize, sizeof(randomize))) {
-        printf("Failed to generate randomness\n");
-        return 1;
-    }
-    /* Randomizing the context is recommended to protect against side-channel
-     * leakage See `secp256k1_context_randomize` in secp256k1.h for more
-     * information about it. This should never fail. */
-    return_val = secp256k1_context_randomize(ctx, randomize);
-    assert(return_val);
-
-    /*** Key Generation ***/
-
-    /* If the secret key is zero or out of range (bigger than secp256k1's
-     * order), we try to sample a new key. Note that the probability of this
-     * happening is negligible. */
-    while (1) {
-        if (!fill_random(seckey, sizeof(seckey))) {
-            printf("Failed to generate randomness\n");
-            return 1;
-        }
-        /* Try to create a keypair with a valid context, it should only fail if
-         * the secret key is zero or out of range. */
-        if (secp256k1_keypair_create(ctx, &keypair, seckey)) {
-            break;
-        }
-    }
-
-    /* Extract the X-only public key from the keypair. We pass NULL for
-     * `pk_parity` as the parity isn't needed for signing or verification.
-     * `secp256k1_keypair_xonly_pub` supports returning the parity for
-     * other use cases such as tests or verifying Taproot tweaks.
-     * This should never fail with a valid context and public key. */
-    return_val = secp256k1_keypair_xonly_pub(ctx, &pubkey, NULL, &keypair);
-    assert(return_val);
-
-    /* Serialize the public key. Should always return 1 for a valid public key. */
-    return_val = secp256k1_xonly_pubkey_serialize(ctx, serialized_pubkey, &pubkey);
-    assert(return_val);
-
-    /*** Signing ***/
-
-    /* Instead of signing (possibly very long) messages directly, we sign a
-     * 32-byte hash of the message in this example.
-     *
-     * We use secp256k1_tagged_sha256 to create this hash. This function expects
-     * a context-specific "tag", which restricts the context in which the signed
-     * messages should be considered valid. For example, if protocol A mandates
-     * to use the tag "my_fancy_protocol" and protocol B mandates to use the tag
-     * "my_boring_protocol", then signed messages from protocol A will never be
-     * valid in protocol B (and vice versa), even if keys are reused across
-     * protocols. This implements "domain separation", which is considered good
-     * practice. It avoids attacks in which users are tricked into signing a
-     * message that has intended consequences in the intended context (e.g.,
-     * protocol A) but would have unintended consequences if it were valid in
-     * some other context (e.g., protocol B). */
-    return_val = secp256k1_tagged_sha256(ctx, msg_hash, tag, sizeof(tag), msg, sizeof(msg));
-    assert(return_val);
-
-    /* Generate 32 bytes of randomness to use with BIP-340 schnorr signing. */
-    if (!fill_random(auxiliary_rand, sizeof(auxiliary_rand))) {
-        printf("Failed to generate randomness\n");
-        return 1;
-    }
-
-    /* Generate a Schnorr signature.
-     *
-     * We use the secp256k1_schnorrsig_sign32 function that provides a simple
-     * interface for signing 32-byte messages (which in our case is a hash of
-     * the actual message). BIP-340 recommends passing 32 bytes of randomness
-     * to the signing function to improve security against side-channel attacks.
-     * Signing with a valid context, a 32-byte message, a verified keypair, and
-     * any 32 bytes of auxiliary random data should never fail. */
-    return_val = secp256k1_schnorrsig_sign32(ctx, signature, msg_hash, &keypair, auxiliary_rand);
-    assert(return_val);
-
-    /*** Verification ***/
-
-    /* Deserialize the public key. This will return 0 if the public key can't
-     * be parsed correctly */
-    if (!secp256k1_xonly_pubkey_parse(ctx, &pubkey, serialized_pubkey)) {
-        printf("Failed parsing the public key\n");
-        return 1;
-    }
-
-    /* Compute the tagged hash on the received messages using the same tag as the signer. */
-    return_val = secp256k1_tagged_sha256(ctx, msg_hash, tag, sizeof(tag), msg, sizeof(msg));
-    assert(return_val);
-
-    /* Verify a signature. This will return 1 if it's valid and 0 if it's not. */
-    is_signature_valid = secp256k1_schnorrsig_verify(ctx, signature, msg_hash, 32, &pubkey);
-
-
-    printf("Is the signature valid? %s\n", is_signature_valid ? "true" : "false");
-    printf("Secret Key: ");
-    print_hex(seckey, sizeof(seckey));
-    printf("Public Key: ");
-    print_hex(serialized_pubkey, sizeof(serialized_pubkey));
-    printf("Signature: ");
-    print_hex(signature, sizeof(signature));
-
-    /* This will clear everything from the context and free the memory */
-    secp256k1_context_destroy(ctx);
-
-    /* Bonus example: if all we need is signature verification (and no key
-       generation or signing), we don't need to use a context created via
-       secp256k1_context_create(). We can simply use the static (i.e., global)
-       context secp256k1_context_static. See its description in
-       include/secp256k1.h for details. */
-    is_signature_valid2 = secp256k1_schnorrsig_verify(secp256k1_context_static,
-                                                      signature, msg_hash, 32, &pubkey);
-    assert(is_signature_valid2 == is_signature_valid);
-
-    /* It's best practice to try to clear secrets from memory after using them.
-     * This is done because some bugs can allow an attacker to leak memory, for
-     * example through "out of bounds" array access (see Heartbleed), Or the OS
-     * swapping them to disk. Hence, we overwrite the secret key buffer with zeros.
-     *
-     * Here we are preventing these writes from being optimized out, as any good compiler
-     * will remove any writes that aren't used. */
-    secure_erase(seckey, sizeof(seckey));
-    return 0;
-}

external/secp256k1/include/secp256k1.h

@@ -1,902 +0,0 @@
-#ifndef SECP256K1_H
-#define SECP256K1_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stddef.h>
-
-/** Unless explicitly stated all pointer arguments must not be NULL.
- *
- * The following rules specify the order of arguments in API calls:
- *
- * 1. Context pointers go first, followed by output arguments, combined
- *    output/input arguments, and finally input-only arguments.
- * 2. Array lengths always immediately follow the argument whose length
- *    they describe, even if this violates rule 1.
- * 3. Within the OUT/OUTIN/IN groups, pointers to data that is typically generated
- *    later go first. This means: signatures, public nonces, secret nonces,
- *    messages, public keys, secret keys, tweaks.
- * 4. Arguments that are not data pointers go last, from more complex to less
- *    complex: function pointers, algorithm names, messages, void pointers,
- *    counts, flags, booleans.
- * 5. Opaque data pointers follow the function pointer they are to be passed to.
- */
-
-/** Opaque data structure that holds context information
- *
- *  The primary purpose of context objects is to store randomization data for
- *  enhanced protection against side-channel leakage. This protection is only
- *  effective if the context is randomized after its creation. See
- *  secp256k1_context_create for creation of contexts and
- *  secp256k1_context_randomize for randomization.
- *
- *  A secondary purpose of context objects is to store pointers to callback
- *  functions that the library will call when certain error states arise. See
- *  secp256k1_context_set_error_callback as well as
- *  secp256k1_context_set_illegal_callback for details. Future library versions
- *  may use context objects for additional purposes.
- *
- *  A constructed context can safely be used from multiple threads
- *  simultaneously, but API calls that take a non-const pointer to a context
- *  need exclusive access to it. In particular this is the case for
- *  secp256k1_context_destroy, secp256k1_context_preallocated_destroy,
- *  and secp256k1_context_randomize.
- *
- *  Regarding randomization, either do it once at creation time (in which case
- *  you do not need any locking for the other calls), or use a read-write lock.
- */
-typedef struct secp256k1_context_struct secp256k1_context;
-
-/** Opaque data structure that holds rewritable "scratch space"
- *
- *  The purpose of this structure is to replace dynamic memory allocations,
- *  because we target architectures where this may not be available. It is
- *  essentially a resizable (within specified parameters) block of bytes,
- *  which is initially created either by memory allocation or TODO as a pointer
- *  into some fixed rewritable space.
- *
- *  Unlike the context object, this cannot safely be shared between threads
- *  without additional synchronization logic.
- */
-typedef struct secp256k1_scratch_space_struct secp256k1_scratch_space;
-
-/** Opaque data structure that holds a parsed and valid public key.
- *
- *  The exact representation of data inside is implementation defined and not
- *  guaranteed to be portable between different platforms or versions. It is
- *  however guaranteed to be 64 bytes in size, and can be safely copied/moved.
- *  If you need to convert to a format suitable for storage or transmission,
- *  use secp256k1_ec_pubkey_serialize and secp256k1_ec_pubkey_parse. To
- *  compare keys, use secp256k1_ec_pubkey_cmp.
- */
-typedef struct {
-    unsigned char data[64];
-} secp256k1_pubkey;
-
-/** Opaque data structured that holds a parsed ECDSA signature.
- *
- *  The exact representation of data inside is implementation defined and not
- *  guaranteed to be portable between different platforms or versions. It is
- *  however guaranteed to be 64 bytes in size, and can be safely copied/moved.
- *  If you need to convert to a format suitable for storage, transmission, or
- *  comparison, use the secp256k1_ecdsa_signature_serialize_* and
- *  secp256k1_ecdsa_signature_parse_* functions.
- */
-typedef struct {
-    unsigned char data[64];
-} secp256k1_ecdsa_signature;
-
-/** A pointer to a function to deterministically generate a nonce.
- *
- * Returns: 1 if a nonce was successfully generated. 0 will cause signing to fail.
- * Out:     nonce32:   pointer to a 32-byte array to be filled by the function.
- * In:      msg32:     the 32-byte message hash being verified (will not be NULL)
- *          key32:     pointer to a 32-byte secret key (will not be NULL)
- *          algo16:    pointer to a 16-byte array describing the signature
- *                     algorithm (will be NULL for ECDSA for compatibility).
- *          data:      Arbitrary data pointer that is passed through.
- *          attempt:   how many iterations we have tried to find a nonce.
- *                     This will almost always be 0, but different attempt values
- *                     are required to result in a different nonce.
- *
- * Except for test cases, this function should compute some cryptographic hash of
- * the message, the algorithm, the key and the attempt.
- */
-typedef int (*secp256k1_nonce_function)(
-    unsigned char *nonce32,
-    const unsigned char *msg32,
-    const unsigned char *key32,
-    const unsigned char *algo16,
-    void *data,
-    unsigned int attempt
-);
-
-# if !defined(SECP256K1_GNUC_PREREQ)
-#  if defined(__GNUC__)&&defined(__GNUC_MINOR__)
-#   define SECP256K1_GNUC_PREREQ(_maj,_min) \
- ((__GNUC__<<16)+__GNUC_MINOR__>=((_maj)<<16)+(_min))
-#  else
-#   define SECP256K1_GNUC_PREREQ(_maj,_min) 0
-#  endif
-# endif
-
-/*  When this header is used at build-time the SECP256K1_BUILD define needs to be set
- *  to correctly setup export attributes and nullness checks.  This is normally done
- *  by secp256k1.c but to guard against this header being included before secp256k1.c
- *  has had a chance to set the define (e.g. via test harnesses that just includes
- *  secp256k1.c) we set SECP256K1_NO_BUILD when this header is processed without the
- *  BUILD define so this condition can be caught.
- */
-#ifndef SECP256K1_BUILD
-# define SECP256K1_NO_BUILD
-#endif
-
-/* Symbol visibility. See libtool manual, section "Windows DLLs". */
-#if defined(_WIN32) && !defined(__GNUC__)
-# ifdef SECP256K1_BUILD
-#  ifdef DLL_EXPORT
-#   define SECP256K1_API            __declspec (dllexport)
-#   define SECP256K1_API_VAR extern __declspec (dllexport)
-#  endif
-# elif defined _MSC_VER
-#  define SECP256K1_API
-#  define SECP256K1_API_VAR  extern __declspec (dllimport)
-# elif defined DLL_EXPORT
-#  define SECP256K1_API             __declspec (dllimport)
-#  define SECP256K1_API_VAR  extern __declspec (dllimport)
-# endif
-#endif
-#ifndef SECP256K1_API
-# if defined(__GNUC__) && (__GNUC__ >= 4) && defined(SECP256K1_BUILD)
-#  define SECP256K1_API             __attribute__ ((visibility ("default")))
-#  define SECP256K1_API_VAR  extern __attribute__ ((visibility ("default")))
-# else
-#  define SECP256K1_API
-#  define SECP256K1_API_VAR  extern
-# endif
-#endif
-
-/* Warning attributes
- * NONNULL is not used if SECP256K1_BUILD is set to avoid the compiler optimizing out
- * some paranoid null checks. */
-# if defined(__GNUC__) && SECP256K1_GNUC_PREREQ(3, 4)
-#  define SECP256K1_WARN_UNUSED_RESULT __attribute__ ((__warn_unused_result__))
-# else
-#  define SECP256K1_WARN_UNUSED_RESULT
-# endif
-# if !defined(SECP256K1_BUILD) && defined(__GNUC__) && SECP256K1_GNUC_PREREQ(3, 4)
-#  define SECP256K1_ARG_NONNULL(_x)  __attribute__ ((__nonnull__(_x)))
-# else
-#  define SECP256K1_ARG_NONNULL(_x)
-# endif
-
-/* Attribute for marking functions, types, and variables as deprecated */
-#if !defined(SECP256K1_BUILD) && defined(__has_attribute)
-# if __has_attribute(__deprecated__)
-#  define SECP256K1_DEPRECATED(_msg) __attribute__ ((__deprecated__(_msg)))
-# else
-#  define SECP256K1_DEPRECATED(_msg)
-# endif
-#else
-# define SECP256K1_DEPRECATED(_msg)
-#endif
-
-/* All flags' lower 8 bits indicate what they're for. Do not use directly. */
-#define SECP256K1_FLAGS_TYPE_MASK ((1 << 8) - 1)
-#define SECP256K1_FLAGS_TYPE_CONTEXT (1 << 0)
-#define SECP256K1_FLAGS_TYPE_COMPRESSION (1 << 1)
-/* The higher bits contain the actual data. Do not use directly. */
-#define SECP256K1_FLAGS_BIT_CONTEXT_VERIFY (1 << 8)
-#define SECP256K1_FLAGS_BIT_CONTEXT_SIGN (1 << 9)
-#define SECP256K1_FLAGS_BIT_CONTEXT_DECLASSIFY (1 << 10)
-#define SECP256K1_FLAGS_BIT_COMPRESSION (1 << 8)
-
-/** Context flags to pass to secp256k1_context_create, secp256k1_context_preallocated_size, and
- *  secp256k1_context_preallocated_create. */
-#define SECP256K1_CONTEXT_NONE (SECP256K1_FLAGS_TYPE_CONTEXT)
-
-/** Deprecated context flags. These flags are treated equivalent to SECP256K1_CONTEXT_NONE. */
-#define SECP256K1_CONTEXT_VERIFY (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_VERIFY)
-#define SECP256K1_CONTEXT_SIGN (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_SIGN)
-
-/* Testing flag. Do not use. */
-#define SECP256K1_CONTEXT_DECLASSIFY (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_DECLASSIFY)
-
-/** Flag to pass to secp256k1_ec_pubkey_serialize. */
-#define SECP256K1_EC_COMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION | SECP256K1_FLAGS_BIT_COMPRESSION)
-#define SECP256K1_EC_UNCOMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION)
-
-/** Prefix byte used to tag various encoded curvepoints for specific purposes */
-#define SECP256K1_TAG_PUBKEY_EVEN 0x02
-#define SECP256K1_TAG_PUBKEY_ODD 0x03
-#define SECP256K1_TAG_PUBKEY_UNCOMPRESSED 0x04
-#define SECP256K1_TAG_PUBKEY_HYBRID_EVEN 0x06
-#define SECP256K1_TAG_PUBKEY_HYBRID_ODD 0x07
-
-/** A built-in constant secp256k1 context object with static storage duration, to be
- *  used in conjunction with secp256k1_selftest.
- *
- *  This context object offers *only limited functionality* , i.e., it cannot be used
- *  for API functions that perform computations involving secret keys, e.g., signing
- *  and public key generation. If this restriction applies to a specific API function,
- *  it is mentioned in its documentation. See secp256k1_context_create if you need a
- *  full context object that supports all functionality offered by the library.
- *
- *  It is highly recommended to call secp256k1_selftest before using this context.
- */
-SECP256K1_API_VAR const secp256k1_context *secp256k1_context_static;
-
-/** Deprecated alias for secp256k1_context_static. */
-SECP256K1_API_VAR const secp256k1_context *secp256k1_context_no_precomp
-SECP256K1_DEPRECATED("Use secp256k1_context_static instead");
-
-/** Perform basic self tests (to be used in conjunction with secp256k1_context_static)
- *
- *  This function performs self tests that detect some serious usage errors and
- *  similar conditions, e.g., when the library is compiled for the wrong endianness.
- *  This is a last resort measure to be used in production. The performed tests are
- *  very rudimentary and are not intended as a replacement for running the test
- *  binaries.
- *
- *  It is highly recommended to call this before using secp256k1_context_static.
- *  It is not necessary to call this function before using a context created with
- *  secp256k1_context_create (or secp256k1_context_preallocated_create), which will
- *  take care of performing the self tests.
- *
- *  If the tests fail, this function will call the default error handler to abort the
- *  program (see secp256k1_context_set_error_callback).
- */
-SECP256K1_API void secp256k1_selftest(void);
-
-
-/** Create a secp256k1 context object (in dynamically allocated memory).
- *
- *  This function uses malloc to allocate memory. It is guaranteed that malloc is
- *  called at most once for every call of this function. If you need to avoid dynamic
- *  memory allocation entirely, see secp256k1_context_static and the functions in
- *  secp256k1_preallocated.h.
- *
- *  Returns: a newly created context object.
- *  In:      flags: Always set to SECP256K1_CONTEXT_NONE (see below).
- *
- *  The only valid non-deprecated flag in recent library versions is
- *  SECP256K1_CONTEXT_NONE, which will create a context sufficient for all functionality
- *  offered by the library. All other (deprecated) flags will be treated as equivalent
- *  to the SECP256K1_CONTEXT_NONE flag. Though the flags parameter primarily exists for
- *  historical reasons, future versions of the library may introduce new flags.
- *
- *  If the context is intended to be used for API functions that perform computations
- *  involving secret keys, e.g., signing and public key generation, then it is highly
- *  recommended to call secp256k1_context_randomize on the context before calling
- *  those API functions. This will provide enhanced protection against side-channel
- *  leakage, see secp256k1_context_randomize for details.
- *
- *  Do not create a new context object for each operation, as construction and
- *  randomization can take non-negligible time.
- */
-SECP256K1_API secp256k1_context *secp256k1_context_create(
-    unsigned int flags
-) SECP256K1_WARN_UNUSED_RESULT;
-
-/** Copy a secp256k1 context object (into dynamically allocated memory).
- *
- *  This function uses malloc to allocate memory. It is guaranteed that malloc is
- *  called at most once for every call of this function. If you need to avoid dynamic
- *  memory allocation entirely, see the functions in secp256k1_preallocated.h.
- *
- *  Cloning secp256k1_context_static is not possible, and should not be emulated by
- *  the caller (e.g., using memcpy). Create a new context instead.
- *
- *  Returns: a newly created context object.
- *  Args:    ctx: an existing context to copy (not secp256k1_context_static)
- */
-SECP256K1_API secp256k1_context *secp256k1_context_clone(
-    const secp256k1_context *ctx
-) SECP256K1_ARG_NONNULL(1) SECP256K1_WARN_UNUSED_RESULT;
-
-/** Destroy a secp256k1 context object (created in dynamically allocated memory).
- *
- *  The context pointer may not be used afterwards.
- *
- *  The context to destroy must have been created using secp256k1_context_create
- *  or secp256k1_context_clone. If the context has instead been created using
- *  secp256k1_context_preallocated_create or secp256k1_context_preallocated_clone, the
- *  behaviour is undefined. In that case, secp256k1_context_preallocated_destroy must
- *  be used instead.
- *
- *  Args:   ctx: an existing context to destroy, constructed using
- *               secp256k1_context_create or secp256k1_context_clone
- *               (i.e., not secp256k1_context_static).
- */
-SECP256K1_API void secp256k1_context_destroy(
-    secp256k1_context *ctx
-) SECP256K1_ARG_NONNULL(1);
-
-/** Set a callback function to be called when an illegal argument is passed to
- *  an API call. It will only trigger for violations that are mentioned
- *  explicitly in the header.
- *
- *  The philosophy is that these shouldn't be dealt with through a
- *  specific return value, as calling code should not have branches to deal with
- *  the case that this code itself is broken.
- *
- *  On the other hand, during debug stage, one would want to be informed about
- *  such mistakes, and the default (crashing) may be inadvisable.
- *  When this callback is triggered, the API function called is guaranteed not
- *  to cause a crash, though its return value and output arguments are
- *  undefined.
- *
- *  When this function has not been called (or called with fn==NULL), then the
- *  default handler will be used. The library provides a default handler which
- *  writes the message to stderr and calls abort. This default handler can be
- *  replaced at link time if the preprocessor macro
- *  USE_EXTERNAL_DEFAULT_CALLBACKS is defined, which is the case if the build
- *  has been configured with --enable-external-default-callbacks. Then the
- *  following two symbols must be provided to link against:
- *   - void secp256k1_default_illegal_callback_fn(const char *message, void *data);
- *   - void secp256k1_default_error_callback_fn(const char *message, void *data);
- *  The library can call these default handlers even before a proper callback data
- *  pointer could have been set using secp256k1_context_set_illegal_callback or
- *  secp256k1_context_set_error_callback, e.g., when the creation of a context
- *  fails. In this case, the corresponding default handler will be called with
- *  the data pointer argument set to NULL.
- *
- *  Args: ctx:  an existing context object.
- *  In:   fun:  a pointer to a function to call when an illegal argument is
- *              passed to the API, taking a message and an opaque pointer.
- *              (NULL restores the default handler.)
- *        data: the opaque pointer to pass to fun above, must be NULL for the default handler.
- *
- *  See also secp256k1_context_set_error_callback.
- */
-SECP256K1_API void secp256k1_context_set_illegal_callback(
-    secp256k1_context *ctx,
-    void (*fun)(const char *message, void *data),
-    const void *data
-) SECP256K1_ARG_NONNULL(1);
-
-/** Set a callback function to be called when an internal consistency check
- *  fails.
- *
- *  The default callback writes an error message to stderr and calls abort
- *  to abort the program.
- *
- *  This can only trigger in case of a hardware failure, miscompilation,
- *  memory corruption, serious bug in the library, or other error would can
- *  otherwise result in undefined behaviour. It will not trigger due to mere
- *  incorrect usage of the API (see secp256k1_context_set_illegal_callback
- *  for that). After this callback returns, anything may happen, including
- *  crashing.
- *
- *  Args: ctx:  an existing context object.
- *  In:   fun:  a pointer to a function to call when an internal error occurs,
- *              taking a message and an opaque pointer (NULL restores the
- *              default handler, see secp256k1_context_set_illegal_callback
- *              for details).
- *        data: the opaque pointer to pass to fun above, must be NULL for the default handler.
- *
- *  See also secp256k1_context_set_illegal_callback.
- */
-SECP256K1_API void secp256k1_context_set_error_callback(
-    secp256k1_context *ctx,
-    void (*fun)(const char *message, void *data),
-    const void *data
-) SECP256K1_ARG_NONNULL(1);
-
-/** Create a secp256k1 scratch space object.
- *
- *  Returns: a newly created scratch space.
- *  Args: ctx:  an existing context object.
- *  In:   size: amount of memory to be available as scratch space. Some extra
- *              (<100 bytes) will be allocated for extra accounting.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT secp256k1_scratch_space *secp256k1_scratch_space_create(
-    const secp256k1_context *ctx,
-    size_t size
-) SECP256K1_ARG_NONNULL(1);
-
-/** Destroy a secp256k1 scratch space.
- *
- *  The pointer may not be used afterwards.
- *  Args:       ctx: a secp256k1 context object.
- *          scratch: space to destroy
- */
-SECP256K1_API void secp256k1_scratch_space_destroy(
-    const secp256k1_context *ctx,
-    secp256k1_scratch_space *scratch
-) SECP256K1_ARG_NONNULL(1);
-
-/** Parse a variable-length public key into the pubkey object.
- *
- *  Returns: 1 if the public key was fully valid.
- *           0 if the public key could not be parsed or is invalid.
- *  Args: ctx:      a secp256k1 context object.
- *  Out:  pubkey:   pointer to a pubkey object. If 1 is returned, it is set to a
- *                  parsed version of input. If not, its value is undefined.
- *  In:   input:    pointer to a serialized public key
- *        inputlen: length of the array pointed to by input
- *
- *  This function supports parsing compressed (33 bytes, header byte 0x02 or
- *  0x03), uncompressed (65 bytes, header byte 0x04), or hybrid (65 bytes, header
- *  byte 0x06 or 0x07) format public keys.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_parse(
-    const secp256k1_context *ctx,
-    secp256k1_pubkey *pubkey,
-    const unsigned char *input,
-    size_t inputlen
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Serialize a pubkey object into a serialized byte sequence.
- *
- *  Returns: 1 always.
- *  Args:   ctx:        a secp256k1 context object.
- *  Out:    output:     a pointer to a 65-byte (if compressed==0) or 33-byte (if
- *                      compressed==1) byte array to place the serialized key
- *                      in.
- *  In/Out: outputlen:  a pointer to an integer which is initially set to the
- *                      size of output, and is overwritten with the written
- *                      size.
- *  In:     pubkey:     a pointer to a secp256k1_pubkey containing an
- *                      initialized public key.
- *          flags:      SECP256K1_EC_COMPRESSED if serialization should be in
- *                      compressed format, otherwise SECP256K1_EC_UNCOMPRESSED.
- */
-SECP256K1_API int secp256k1_ec_pubkey_serialize(
-    const secp256k1_context *ctx,
-    unsigned char *output,
-    size_t *outputlen,
-    const secp256k1_pubkey *pubkey,
-    unsigned int flags
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Compare two public keys using lexicographic (of compressed serialization) order
- *
- *  Returns: <0 if the first public key is less than the second
- *           >0 if the first public key is greater than the second
- *           0 if the two public keys are equal
- *  Args: ctx:      a secp256k1 context object.
- *  In:   pubkey1:  first public key to compare
- *        pubkey2:  second public key to compare
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_cmp(
-    const secp256k1_context *ctx,
-    const secp256k1_pubkey *pubkey1,
-    const secp256k1_pubkey *pubkey2
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Parse an ECDSA signature in compact (64 bytes) format.
- *
- *  Returns: 1 when the signature could be parsed, 0 otherwise.
- *  Args: ctx:      a secp256k1 context object
- *  Out:  sig:      a pointer to a signature object
- *  In:   input64:  a pointer to the 64-byte array to parse
- *
- *  The signature must consist of a 32-byte big endian R value, followed by a
- *  32-byte big endian S value. If R or S fall outside of [0..order-1], the
- *  encoding is invalid. R and S with value 0 are allowed in the encoding.
- *
- *  After the call, sig will always be initialized. If parsing failed or R or
- *  S are zero, the resulting sig value is guaranteed to fail verification for
- *  any message and public key.
- */
-SECP256K1_API int secp256k1_ecdsa_signature_parse_compact(
-    const secp256k1_context *ctx,
-    secp256k1_ecdsa_signature *sig,
-    const unsigned char *input64
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Parse a DER ECDSA signature.
- *
- *  Returns: 1 when the signature could be parsed, 0 otherwise.
- *  Args: ctx:      a secp256k1 context object
- *  Out:  sig:      a pointer to a signature object
- *  In:   input:    a pointer to the signature to be parsed
- *        inputlen: the length of the array pointed to be input
- *
- *  This function will accept any valid DER encoded signature, even if the
- *  encoded numbers are out of range.
- *
- *  After the call, sig will always be initialized. If parsing failed or the
- *  encoded numbers are out of range, signature verification with it is
- *  guaranteed to fail for every message and public key.
- */
-SECP256K1_API int secp256k1_ecdsa_signature_parse_der(
-    const secp256k1_context *ctx,
-    secp256k1_ecdsa_signature *sig,
-    const unsigned char *input,
-    size_t inputlen
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Serialize an ECDSA signature in DER format.
- *
- *  Returns: 1 if enough space was available to serialize, 0 otherwise
- *  Args:   ctx:       a secp256k1 context object
- *  Out:    output:    a pointer to an array to store the DER serialization
- *  In/Out: outputlen: a pointer to a length integer. Initially, this integer
- *                     should be set to the length of output. After the call
- *                     it will be set to the length of the serialization (even
- *                     if 0 was returned).
- *  In:     sig:       a pointer to an initialized signature object
- */
-SECP256K1_API int secp256k1_ecdsa_signature_serialize_der(
-    const secp256k1_context *ctx,
-    unsigned char *output,
-    size_t *outputlen,
-    const secp256k1_ecdsa_signature *sig
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Serialize an ECDSA signature in compact (64 byte) format.
- *
- *  Returns: 1
- *  Args:   ctx:       a secp256k1 context object
- *  Out:    output64:  a pointer to a 64-byte array to store the compact serialization
- *  In:     sig:       a pointer to an initialized signature object
- *
- *  See secp256k1_ecdsa_signature_parse_compact for details about the encoding.
- */
-SECP256K1_API int secp256k1_ecdsa_signature_serialize_compact(
-    const secp256k1_context *ctx,
-    unsigned char *output64,
-    const secp256k1_ecdsa_signature *sig
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Verify an ECDSA signature.
- *
- *  Returns: 1: correct signature
- *           0: incorrect or unparseable signature
- *  Args:    ctx:       a secp256k1 context object.
- *  In:      sig:       the signature being verified.
- *           msghash32: the 32-byte message hash being verified.
- *                      The verifier must make sure to apply a cryptographic
- *                      hash function to the message by itself and not accept an
- *                      msghash32 value directly. Otherwise, it would be easy to
- *                      create a "valid" signature without knowledge of the
- *                      secret key. See also
- *                      https://bitcoin.stackexchange.com/a/81116/35586 for more
- *                      background on this topic.
- *           pubkey:    pointer to an initialized public key to verify with.
- *
- * To avoid accepting malleable signatures, only ECDSA signatures in lower-S
- * form are accepted.
- *
- * If you need to accept ECDSA signatures from sources that do not obey this
- * rule, apply secp256k1_ecdsa_signature_normalize to the signature prior to
- * verification, but be aware that doing so results in malleable signatures.
- *
- * For details, see the comments for that function.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_verify(
-    const secp256k1_context *ctx,
-    const secp256k1_ecdsa_signature *sig,
-    const unsigned char *msghash32,
-    const secp256k1_pubkey *pubkey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Convert a signature to a normalized lower-S form.
- *
- *  Returns: 1 if sigin was not normalized, 0 if it already was.
- *  Args: ctx:    a secp256k1 context object
- *  Out:  sigout: a pointer to a signature to fill with the normalized form,
- *                or copy if the input was already normalized. (can be NULL if
- *                you're only interested in whether the input was already
- *                normalized).
- *  In:   sigin:  a pointer to a signature to check/normalize (can be identical to sigout)
- *
- *  With ECDSA a third-party can forge a second distinct signature of the same
- *  message, given a single initial signature, but without knowing the key. This
- *  is done by negating the S value modulo the order of the curve, 'flipping'
- *  the sign of the random point R which is not included in the signature.
- *
- *  Forgery of the same message isn't universally problematic, but in systems
- *  where message malleability or uniqueness of signatures is important this can
- *  cause issues. This forgery can be blocked by all verifiers forcing signers
- *  to use a normalized form.
- *
- *  The lower-S form reduces the size of signatures slightly on average when
- *  variable length encodings (such as DER) are used and is cheap to verify,
- *  making it a good choice. Security of always using lower-S is assured because
- *  anyone can trivially modify a signature after the fact to enforce this
- *  property anyway.
- *
- *  The lower S value is always between 0x1 and
- *  0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
- *  inclusive.
- *
- *  No other forms of ECDSA malleability are known and none seem likely, but
- *  there is no formal proof that ECDSA, even with this additional restriction,
- *  is free of other malleability. Commonly used serialization schemes will also
- *  accept various non-unique encodings, so care should be taken when this
- *  property is required for an application.
- *
- *  The secp256k1_ecdsa_sign function will by default create signatures in the
- *  lower-S form, and secp256k1_ecdsa_verify will not accept others. In case
- *  signatures come from a system that cannot enforce this property,
- *  secp256k1_ecdsa_signature_normalize must be called before verification.
- */
-SECP256K1_API int secp256k1_ecdsa_signature_normalize(
-    const secp256k1_context *ctx,
-    secp256k1_ecdsa_signature *sigout,
-    const secp256k1_ecdsa_signature *sigin
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(3);
-
-/** An implementation of RFC6979 (using HMAC-SHA256) as nonce generation function.
- * If a data pointer is passed, it is assumed to be a pointer to 32 bytes of
- * extra entropy.
- */
-SECP256K1_API_VAR const secp256k1_nonce_function secp256k1_nonce_function_rfc6979;
-
-/** A default safe nonce generation function (currently equal to secp256k1_nonce_function_rfc6979). */
-SECP256K1_API_VAR const secp256k1_nonce_function secp256k1_nonce_function_default;
-
-/** Create an ECDSA signature.
- *
- *  Returns: 1: signature created
- *           0: the nonce generation function failed, or the secret key was invalid.
- *  Args:    ctx:       pointer to a context object (not secp256k1_context_static).
- *  Out:     sig:       pointer to an array where the signature will be placed.
- *  In:      msghash32: the 32-byte message hash being signed.
- *           seckey:    pointer to a 32-byte secret key.
- *           noncefp:   pointer to a nonce generation function. If NULL,
- *                      secp256k1_nonce_function_default is used.
- *           ndata:     pointer to arbitrary data used by the nonce generation function
- *                      (can be NULL). If it is non-NULL and
- *                      secp256k1_nonce_function_default is used, then ndata must be a
- *                      pointer to 32-bytes of additional data.
- *
- * The created signature is always in lower-S form. See
- * secp256k1_ecdsa_signature_normalize for more details.
- */
-SECP256K1_API int secp256k1_ecdsa_sign(
-    const secp256k1_context *ctx,
-    secp256k1_ecdsa_signature *sig,
-    const unsigned char *msghash32,
-    const unsigned char *seckey,
-    secp256k1_nonce_function noncefp,
-    const void *ndata
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Verify an ECDSA secret key.
- *
- *  A secret key is valid if it is not 0 and less than the secp256k1 curve order
- *  when interpreted as an integer (most significant byte first). The
- *  probability of choosing a 32-byte string uniformly at random which is an
- *  invalid secret key is negligible.
- *
- *  Returns: 1: secret key is valid
- *           0: secret key is invalid
- *  Args:    ctx: pointer to a context object.
- *  In:      seckey: pointer to a 32-byte secret key.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_seckey_verify(
-    const secp256k1_context *ctx,
-    const unsigned char *seckey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
-
-/** Compute the public key for a secret key.
- *
- *  Returns: 1: secret was valid, public key stores.
- *           0: secret was invalid, try again.
- *  Args:    ctx:    pointer to a context object (not secp256k1_context_static).
- *  Out:     pubkey: pointer to the created public key.
- *  In:      seckey: pointer to a 32-byte secret key.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_create(
-    const secp256k1_context *ctx,
-    secp256k1_pubkey *pubkey,
-    const unsigned char *seckey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Negates a secret key in place.
- *
- *  Returns: 0 if the given secret key is invalid according to
- *           secp256k1_ec_seckey_verify. 1 otherwise
- *  Args:   ctx:    pointer to a context object
- *  In/Out: seckey: pointer to the 32-byte secret key to be negated. If the
- *                  secret key is invalid according to
- *                  secp256k1_ec_seckey_verify, this function returns 0 and
- *                  seckey will be set to some unspecified value.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_seckey_negate(
-    const secp256k1_context *ctx,
-    unsigned char *seckey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
-
-/** Same as secp256k1_ec_seckey_negate, but DEPRECATED. Will be removed in
- *  future versions. */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_negate(
-    const secp256k1_context *ctx,
-    unsigned char *seckey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2)
-  SECP256K1_DEPRECATED("Use secp256k1_ec_seckey_negate instead");
-
-/** Negates a public key in place.
- *
- *  Returns: 1 always
- *  Args:   ctx:        pointer to a context object
- *  In/Out: pubkey:     pointer to the public key to be negated.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_negate(
-    const secp256k1_context *ctx,
-    secp256k1_pubkey *pubkey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
-
-/** Tweak a secret key by adding tweak to it.
- *
- *  Returns: 0 if the arguments are invalid or the resulting secret key would be
- *           invalid (only when the tweak is the negation of the secret key). 1
- *           otherwise.
- *  Args:    ctx:   pointer to a context object.
- *  In/Out: seckey: pointer to a 32-byte secret key. If the secret key is
- *                  invalid according to secp256k1_ec_seckey_verify, this
- *                  function returns 0. seckey will be set to some unspecified
- *                  value if this function returns 0.
- *  In:    tweak32: pointer to a 32-byte tweak. If the tweak is invalid according to
- *                  secp256k1_ec_seckey_verify, this function returns 0. For
- *                  uniformly random 32-byte arrays the chance of being invalid
- *                  is negligible (around 1 in 2^128).
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_seckey_tweak_add(
-    const secp256k1_context *ctx,
-    unsigned char *seckey,
-    const unsigned char *tweak32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Same as secp256k1_ec_seckey_tweak_add, but DEPRECATED. Will be removed in
- *  future versions. */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_add(
-    const secp256k1_context *ctx,
-    unsigned char *seckey,
-    const unsigned char *tweak32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3)
-  SECP256K1_DEPRECATED("Use secp256k1_ec_seckey_tweak_add instead");
-
-/** Tweak a public key by adding tweak times the generator to it.
- *
- *  Returns: 0 if the arguments are invalid or the resulting public key would be
- *           invalid (only when the tweak is the negation of the corresponding
- *           secret key). 1 otherwise.
- *  Args:    ctx:   pointer to a context object.
- *  In/Out: pubkey: pointer to a public key object. pubkey will be set to an
- *                  invalid value if this function returns 0.
- *  In:    tweak32: pointer to a 32-byte tweak. If the tweak is invalid according to
- *                  secp256k1_ec_seckey_verify, this function returns 0. For
- *                  uniformly random 32-byte arrays the chance of being invalid
- *                  is negligible (around 1 in 2^128).
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_tweak_add(
-    const secp256k1_context *ctx,
-    secp256k1_pubkey *pubkey,
-    const unsigned char *tweak32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Tweak a secret key by multiplying it by a tweak.
- *
- *  Returns: 0 if the arguments are invalid. 1 otherwise.
- *  Args:   ctx:    pointer to a context object.
- *  In/Out: seckey: pointer to a 32-byte secret key. If the secret key is
- *                  invalid according to secp256k1_ec_seckey_verify, this
- *                  function returns 0. seckey will be set to some unspecified
- *                  value if this function returns 0.
- *  In:    tweak32: pointer to a 32-byte tweak. If the tweak is invalid according to
- *                  secp256k1_ec_seckey_verify, this function returns 0. For
- *                  uniformly random 32-byte arrays the chance of being invalid
- *                  is negligible (around 1 in 2^128).
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_seckey_tweak_mul(
-    const secp256k1_context *ctx,
-    unsigned char *seckey,
-    const unsigned char *tweak32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Same as secp256k1_ec_seckey_tweak_mul, but DEPRECATED. Will be removed in
- *  future versions. */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_mul(
-    const secp256k1_context *ctx,
-    unsigned char *seckey,
-    const unsigned char *tweak32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3)
-  SECP256K1_DEPRECATED("Use secp256k1_ec_seckey_tweak_mul instead");
-
-/** Tweak a public key by multiplying it by a tweak value.
- *
- *  Returns: 0 if the arguments are invalid. 1 otherwise.
- *  Args:    ctx:   pointer to a context object.
- *  In/Out: pubkey: pointer to a public key object. pubkey will be set to an
- *                  invalid value if this function returns 0.
- *  In:    tweak32: pointer to a 32-byte tweak. If the tweak is invalid according to
- *                  secp256k1_ec_seckey_verify, this function returns 0. For
- *                  uniformly random 32-byte arrays the chance of being invalid
- *                  is negligible (around 1 in 2^128).
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_tweak_mul(
-    const secp256k1_context *ctx,
-    secp256k1_pubkey *pubkey,
-    const unsigned char *tweak32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Randomizes the context to provide enhanced protection against side-channel leakage.
- *
- *  Returns: 1: randomization successful
- *           0: error
- *  Args:    ctx:       pointer to a context object (not secp256k1_context_static).
- *  In:      seed32:    pointer to a 32-byte random seed (NULL resets to initial state).
- *
- * While secp256k1 code is written and tested to be constant-time no matter what
- * secret values are, it is possible that a compiler may output code which is not,
- * and also that the CPU may not emit the same radio frequencies or draw the same
- * amount of power for all values. Randomization of the context shields against
- * side-channel observations which aim to exploit secret-dependent behaviour in
- * certain computations which involve secret keys.
- *
- * It is highly recommended to call this function on contexts returned from
- * secp256k1_context_create or secp256k1_context_clone (or from the corresponding
- * functions in secp256k1_preallocated.h) before using these contexts to call API
- * functions that perform computations involving secret keys, e.g., signing and
- * public key generation. It is possible to call this function more than once on
- * the same context, and doing so before every few computations involving secret
- * keys is recommended as a defense-in-depth measure. Randomization of the static
- * context secp256k1_context_static is not supported.
- *
- * Currently, the random seed is mainly used for blinding multiplications of a
- * secret scalar with the elliptic curve base point. Multiplications of this
- * kind are performed by exactly those API functions which are documented to
- * require a context that is not secp256k1_context_static. As a rule of thumb,
- * these are all functions which take a secret key (or a keypair) as an input.
- * A notable exception to that rule is the ECDH module, which relies on a different
- * kind of elliptic curve point multiplication and thus does not benefit from
- * enhanced protection against side-channel leakage currently.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_context_randomize(
-    secp256k1_context *ctx,
-    const unsigned char *seed32
-) SECP256K1_ARG_NONNULL(1);
-
-/** Add a number of public keys together.
- *
- *  Returns: 1: the sum of the public keys is valid.
- *           0: the sum of the public keys is not valid.
- *  Args:   ctx:        pointer to a context object.
- *  Out:    out:        pointer to a public key object for placing the resulting public key.
- *  In:     ins:        pointer to array of pointers to public keys.
- *          n:          the number of public keys to add together (must be at least 1).
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_combine(
-    const secp256k1_context *ctx,
-    secp256k1_pubkey *out,
-    const secp256k1_pubkey * const *ins,
-    size_t n
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Compute a tagged hash as defined in BIP-340.
- *
- *  This is useful for creating a message hash and achieving domain separation
- *  through an application-specific tag. This function returns
- *  SHA256(SHA256(tag)||SHA256(tag)||msg). Therefore, tagged hash
- *  implementations optimized for a specific tag can precompute the SHA256 state
- *  after hashing the tag hashes.
- *
- *  Returns: 1 always.
- *  Args:    ctx: pointer to a context object
- *  Out:  hash32: pointer to a 32-byte array to store the resulting hash
- *  In:      tag: pointer to an array containing the tag
- *        taglen: length of the tag array
- *           msg: pointer to an array containing the message
- *        msglen: length of the message array
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_tagged_sha256(
-    const secp256k1_context *ctx,
-    unsigned char *hash32,
-    const unsigned char *tag,
-    size_t taglen,
-    const unsigned char *msg,
-    size_t msglen
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(5);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SECP256K1_H */

external/secp256k1/include/secp256k1_ecdh.h

@@ -1,63 +0,0 @@
-#ifndef SECP256K1_ECDH_H
-#define SECP256K1_ECDH_H
-
-#include "secp256k1.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** A pointer to a function that hashes an EC point to obtain an ECDH secret
- *
- *  Returns: 1 if the point was successfully hashed.
- *           0 will cause secp256k1_ecdh to fail and return 0.
- *           Other return values are not allowed, and the behaviour of
- *           secp256k1_ecdh is undefined for other return values.
- *  Out:     output:     pointer to an array to be filled by the function
- *  In:      x32:        pointer to a 32-byte x coordinate
- *           y32:        pointer to a 32-byte y coordinate
- *           data:       arbitrary data pointer that is passed through
- */
-typedef int (*secp256k1_ecdh_hash_function)(
-  unsigned char *output,
-  const unsigned char *x32,
-  const unsigned char *y32,
-  void *data
-);
-
-/** An implementation of SHA256 hash function that applies to compressed public key.
- * Populates the output parameter with 32 bytes. */
-SECP256K1_API_VAR const secp256k1_ecdh_hash_function secp256k1_ecdh_hash_function_sha256;
-
-/** A default ECDH hash function (currently equal to secp256k1_ecdh_hash_function_sha256).
- * Populates the output parameter with 32 bytes. */
-SECP256K1_API_VAR const secp256k1_ecdh_hash_function secp256k1_ecdh_hash_function_default;
-
-/** Compute an EC Diffie-Hellman secret in constant time
- *
- *  Returns: 1: exponentiation was successful
- *           0: scalar was invalid (zero or overflow) or hashfp returned 0
- *  Args:    ctx:        pointer to a context object.
- *  Out:     output:     pointer to an array to be filled by hashfp.
- *  In:      pubkey:     a pointer to a secp256k1_pubkey containing an initialized public key.
- *           seckey:     a 32-byte scalar with which to multiply the point.
- *           hashfp:     pointer to a hash function. If NULL,
- *                       secp256k1_ecdh_hash_function_sha256 is used
- *                       (in which case, 32 bytes will be written to output).
- *           data:       arbitrary data pointer that is passed through to hashfp
- *                       (can be NULL for secp256k1_ecdh_hash_function_sha256).
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdh(
-  const secp256k1_context *ctx,
-  unsigned char *output,
-  const secp256k1_pubkey *pubkey,
-  const unsigned char *seckey,
-  secp256k1_ecdh_hash_function hashfp,
-  void *data
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SECP256K1_ECDH_H */

external/secp256k1/include/secp256k1_extrakeys.h

@@ -1,249 +0,0 @@
-#ifndef SECP256K1_EXTRAKEYS_H
-#define SECP256K1_EXTRAKEYS_H
-
-#include "secp256k1.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** Opaque data structure that holds a parsed and valid "x-only" public key.
- *  An x-only pubkey encodes a point whose Y coordinate is even. It is
- *  serialized using only its X coordinate (32 bytes). See BIP-340 for more
- *  information about x-only pubkeys.
- *
- *  The exact representation of data inside is implementation defined and not
- *  guaranteed to be portable between different platforms or versions. It is
- *  however guaranteed to be 64 bytes in size, and can be safely copied/moved.
- *  If you need to convert to a format suitable for storage, transmission, use
- *  use secp256k1_xonly_pubkey_serialize and secp256k1_xonly_pubkey_parse. To
- *  compare keys, use secp256k1_xonly_pubkey_cmp.
- */
-typedef struct {
-    unsigned char data[64];
-} secp256k1_xonly_pubkey;
-
-/** Opaque data structure that holds a keypair consisting of a secret and a
- *  public key.
- *
- *  The exact representation of data inside is implementation defined and not
- *  guaranteed to be portable between different platforms or versions. It is
- *  however guaranteed to be 96 bytes in size, and can be safely copied/moved.
- */
-typedef struct {
-    unsigned char data[96];
-} secp256k1_keypair;
-
-/** Parse a 32-byte sequence into a xonly_pubkey object.
- *
- *  Returns: 1 if the public key was fully valid.
- *           0 if the public key could not be parsed or is invalid.
- *
- *  Args:   ctx: a secp256k1 context object.
- *  Out: pubkey: pointer to a pubkey object. If 1 is returned, it is set to a
- *               parsed version of input. If not, it's set to an invalid value.
- *  In: input32: pointer to a serialized xonly_pubkey.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_xonly_pubkey_parse(
-    const secp256k1_context *ctx,
-    secp256k1_xonly_pubkey *pubkey,
-    const unsigned char *input32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Serialize an xonly_pubkey object into a 32-byte sequence.
- *
- *  Returns: 1 always.
- *
- *  Args:     ctx: a secp256k1 context object.
- *  Out: output32: a pointer to a 32-byte array to place the serialized key in.
- *  In:    pubkey: a pointer to a secp256k1_xonly_pubkey containing an initialized public key.
- */
-SECP256K1_API int secp256k1_xonly_pubkey_serialize(
-    const secp256k1_context *ctx,
-    unsigned char *output32,
-    const secp256k1_xonly_pubkey *pubkey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Compare two x-only public keys using lexicographic order
- *
- *  Returns: <0 if the first public key is less than the second
- *           >0 if the first public key is greater than the second
- *           0 if the two public keys are equal
- *  Args: ctx:      a secp256k1 context object.
- *  In:   pubkey1:  first public key to compare
- *        pubkey2:  second public key to compare
- */
-SECP256K1_API int secp256k1_xonly_pubkey_cmp(
-    const secp256k1_context *ctx,
-    const secp256k1_xonly_pubkey *pk1,
-    const secp256k1_xonly_pubkey *pk2
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Converts a secp256k1_pubkey into a secp256k1_xonly_pubkey.
- *
- *  Returns: 1 always.
- *
- *  Args:         ctx: pointer to a context object.
- *  Out: xonly_pubkey: pointer to an x-only public key object for placing the converted public key.
- *          pk_parity: Ignored if NULL. Otherwise, pointer to an integer that
- *                     will be set to 1 if the point encoded by xonly_pubkey is
- *                     the negation of the pubkey and set to 0 otherwise.
- *  In:        pubkey: pointer to a public key that is converted.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_xonly_pubkey_from_pubkey(
-    const secp256k1_context *ctx,
-    secp256k1_xonly_pubkey *xonly_pubkey,
-    int *pk_parity,
-    const secp256k1_pubkey *pubkey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(4);
-
-/** Tweak an x-only public key by adding the generator multiplied with tweak32
- *  to it.
- *
- *  Note that the resulting point can not in general be represented by an x-only
- *  pubkey because it may have an odd Y coordinate. Instead, the output_pubkey
- *  is a normal secp256k1_pubkey.
- *
- *  Returns: 0 if the arguments are invalid or the resulting public key would be
- *           invalid (only when the tweak is the negation of the corresponding
- *           secret key). 1 otherwise.
- *
- *  Args:           ctx: pointer to a context object.
- *  Out:  output_pubkey: pointer to a public key to store the result. Will be set
- *                       to an invalid value if this function returns 0.
- *  In: internal_pubkey: pointer to an x-only pubkey to apply the tweak to.
- *              tweak32: pointer to a 32-byte tweak. If the tweak is invalid
- *                       according to secp256k1_ec_seckey_verify, this function
- *                       returns 0. For uniformly random 32-byte arrays the
- *                       chance of being invalid is negligible (around 1 in 2^128).
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_xonly_pubkey_tweak_add(
-    const secp256k1_context *ctx,
-    secp256k1_pubkey *output_pubkey,
-    const secp256k1_xonly_pubkey *internal_pubkey,
-    const unsigned char *tweak32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Checks that a tweaked pubkey is the result of calling
- *  secp256k1_xonly_pubkey_tweak_add with internal_pubkey and tweak32.
- *
- *  The tweaked pubkey is represented by its 32-byte x-only serialization and
- *  its pk_parity, which can both be obtained by converting the result of
- *  tweak_add to a secp256k1_xonly_pubkey.
- *
- *  Note that this alone does _not_ verify that the tweaked pubkey is a
- *  commitment. If the tweak is not chosen in a specific way, the tweaked pubkey
- *  can easily be the result of a different internal_pubkey and tweak.
- *
- *  Returns: 0 if the arguments are invalid or the tweaked pubkey is not the
- *           result of tweaking the internal_pubkey with tweak32. 1 otherwise.
- *  Args:            ctx: pointer to a context object.
- *  In: tweaked_pubkey32: pointer to a serialized xonly_pubkey.
- *     tweaked_pk_parity: the parity of the tweaked pubkey (whose serialization
- *                        is passed in as tweaked_pubkey32). This must match the
- *                        pk_parity value that is returned when calling
- *                        secp256k1_xonly_pubkey with the tweaked pubkey, or
- *                        this function will fail.
- *       internal_pubkey: pointer to an x-only public key object to apply the tweak to.
- *               tweak32: pointer to a 32-byte tweak.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_xonly_pubkey_tweak_add_check(
-    const secp256k1_context *ctx,
-    const unsigned char *tweaked_pubkey32,
-    int tweaked_pk_parity,
-    const secp256k1_xonly_pubkey *internal_pubkey,
-    const unsigned char *tweak32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(4) SECP256K1_ARG_NONNULL(5);
-
-/** Compute the keypair for a secret key.
- *
- *  Returns: 1: secret was valid, keypair is ready to use
- *           0: secret was invalid, try again with a different secret
- *  Args:    ctx: pointer to a context object (not secp256k1_context_static).
- *  Out: keypair: pointer to the created keypair.
- *  In:   seckey: pointer to a 32-byte secret key.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_keypair_create(
-    const secp256k1_context *ctx,
-    secp256k1_keypair *keypair,
-    const unsigned char *seckey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Get the secret key from a keypair.
- *
- *  Returns: 1 always.
- *  Args:   ctx: pointer to a context object.
- *  Out: seckey: pointer to a 32-byte buffer for the secret key.
- *  In: keypair: pointer to a keypair.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_keypair_sec(
-    const secp256k1_context *ctx,
-    unsigned char *seckey,
-    const secp256k1_keypair *keypair
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Get the public key from a keypair.
- *
- *  Returns: 1 always.
- *  Args:    ctx: pointer to a context object.
- *  Out: pubkey: pointer to a pubkey object. If 1 is returned, it is set to
- *               the keypair public key. If not, it's set to an invalid value.
- *  In: keypair: pointer to a keypair.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_keypair_pub(
-    const secp256k1_context *ctx,
-    secp256k1_pubkey *pubkey,
-    const secp256k1_keypair *keypair
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Get the x-only public key from a keypair.
- *
- *  This is the same as calling secp256k1_keypair_pub and then
- *  secp256k1_xonly_pubkey_from_pubkey.
- *
- *  Returns: 1 always.
- *  Args:   ctx: pointer to a context object.
- *  Out: pubkey: pointer to an xonly_pubkey object. If 1 is returned, it is set
- *               to the keypair public key after converting it to an
- *               xonly_pubkey. If not, it's set to an invalid value.
- *    pk_parity: Ignored if NULL. Otherwise, pointer to an integer that will be set to the
- *               pk_parity argument of secp256k1_xonly_pubkey_from_pubkey.
- *  In: keypair: pointer to a keypair.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_keypair_xonly_pub(
-    const secp256k1_context *ctx,
-    secp256k1_xonly_pubkey *pubkey,
-    int *pk_parity,
-    const secp256k1_keypair *keypair
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(4);
-
-/** Tweak a keypair by adding tweak32 to the secret key and updating the public
- *  key accordingly.
- *
- *  Calling this function and then secp256k1_keypair_pub results in the same
- *  public key as calling secp256k1_keypair_xonly_pub and then
- *  secp256k1_xonly_pubkey_tweak_add.
- *
- *  Returns: 0 if the arguments are invalid or the resulting keypair would be
- *           invalid (only when the tweak is the negation of the keypair's
- *           secret key). 1 otherwise.
- *
- *  Args:       ctx: pointer to a context object.
- *  In/Out: keypair: pointer to a keypair to apply the tweak to. Will be set to
- *                   an invalid value if this function returns 0.
- *  In:     tweak32: pointer to a 32-byte tweak. If the tweak is invalid according
- *                   to secp256k1_ec_seckey_verify, this function returns 0. For
- *                   uniformly random 32-byte arrays the chance of being invalid
- *                   is negligible (around 1 in 2^128).
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_keypair_xonly_tweak_add(
-    const secp256k1_context *ctx,
-    secp256k1_keypair *keypair,
-    const unsigned char *tweak32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SECP256K1_EXTRAKEYS_H */

external/secp256k1/include/secp256k1_preallocated.h

@@ -1,134 +0,0 @@
-#ifndef SECP256K1_PREALLOCATED_H
-#define SECP256K1_PREALLOCATED_H
-
-#include "secp256k1.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* The module provided by this header file is intended for settings in which it
- * is not possible or desirable to rely on dynamic memory allocation. It provides
- * functions for creating, cloning, and destroying secp256k1 context objects in a
- * contiguous fixed-size block of memory provided by the caller.
- *
- * Context objects created by functions in this module can be used like contexts
- * objects created by functions in secp256k1.h, i.e., they can be passed to any
- * API function that expects a context object (see secp256k1.h for details). The
- * only exception is that context objects created by functions in this module
- * must be destroyed using secp256k1_context_preallocated_destroy (in this
- * module) instead of secp256k1_context_destroy (in secp256k1.h).
- *
- * It is guaranteed that functions in this module will not call malloc or its
- * friends realloc, calloc, and free.
- */
-
-/** Determine the memory size of a secp256k1 context object to be created in
- *  caller-provided memory.
- *
- *  The purpose of this function is to determine how much memory must be provided
- *  to secp256k1_context_preallocated_create.
- *
- *  Returns: the required size of the caller-provided memory block
- *  In:      flags:    which parts of the context to initialize.
- */
-SECP256K1_API size_t secp256k1_context_preallocated_size(
-    unsigned int flags
-) SECP256K1_WARN_UNUSED_RESULT;
-
-/** Create a secp256k1 context object in caller-provided memory.
- *
- *  The caller must provide a pointer to a rewritable contiguous block of memory
- *  of size at least secp256k1_context_preallocated_size(flags) bytes, suitably
- *  aligned to hold an object of any type.
- *
- *  The block of memory is exclusively owned by the created context object during
- *  the lifetime of this context object, which begins with the call to this
- *  function and ends when a call to secp256k1_context_preallocated_destroy
- *  (which destroys the context object again) returns. During the lifetime of the
- *  context object, the caller is obligated not to access this block of memory,
- *  i.e., the caller may not read or write the memory, e.g., by copying the memory
- *  contents to a different location or trying to create a second context object
- *  in the memory. In simpler words, the prealloc pointer (or any pointer derived
- *  from it) should not be used during the lifetime of the context object.
- *
- *  Returns: a newly created context object.
- *  In:      prealloc: a pointer to a rewritable contiguous block of memory of
- *                     size at least secp256k1_context_preallocated_size(flags)
- *                     bytes, as detailed above.
- *           flags:    which parts of the context to initialize.
- *
- *  See secp256k1_context_create (in secp256k1.h) for further details.
- *
- *  See also secp256k1_context_randomize (in secp256k1.h)
- *  and secp256k1_context_preallocated_destroy.
- */
-SECP256K1_API secp256k1_context *secp256k1_context_preallocated_create(
-    void *prealloc,
-    unsigned int flags
-) SECP256K1_ARG_NONNULL(1) SECP256K1_WARN_UNUSED_RESULT;
-
-/** Determine the memory size of a secp256k1 context object to be copied into
- *  caller-provided memory.
- *
- *  Returns: the required size of the caller-provided memory block.
- *  In:      ctx: an existing context to copy.
- */
-SECP256K1_API size_t secp256k1_context_preallocated_clone_size(
-    const secp256k1_context *ctx
-) SECP256K1_ARG_NONNULL(1) SECP256K1_WARN_UNUSED_RESULT;
-
-/** Copy a secp256k1 context object into caller-provided memory.
- *
- *  The caller must provide a pointer to a rewritable contiguous block of memory
- *  of size at least secp256k1_context_preallocated_size(flags) bytes, suitably
- *  aligned to hold an object of any type.
- *
- *  The block of memory is exclusively owned by the created context object during
- *  the lifetime of this context object, see the description of
- *  secp256k1_context_preallocated_create for details.
- *
- *  Cloning secp256k1_context_static is not possible, and should not be emulated by
- *  the caller (e.g., using memcpy). Create a new context instead.
- *
- *  Returns: a newly created context object.
- *  Args:    ctx:      an existing context to copy (not secp256k1_context_static).
- *  In:      prealloc: a pointer to a rewritable contiguous block of memory of
- *                     size at least secp256k1_context_preallocated_size(flags)
- *                     bytes, as detailed above.
- */
-SECP256K1_API secp256k1_context *secp256k1_context_preallocated_clone(
-    const secp256k1_context *ctx,
-    void *prealloc
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_WARN_UNUSED_RESULT;
-
-/** Destroy a secp256k1 context object that has been created in
- *  caller-provided memory.
- *
- *  The context pointer may not be used afterwards.
- *
- *  The context to destroy must have been created using
- *  secp256k1_context_preallocated_create or secp256k1_context_preallocated_clone.
- *  If the context has instead been created using secp256k1_context_create or
- *  secp256k1_context_clone, the behaviour is undefined. In that case,
- *  secp256k1_context_destroy must be used instead.
- *
- *  If required, it is the responsibility of the caller to deallocate the block
- *  of memory properly after this function returns, e.g., by calling free on the
- *  preallocated pointer given to secp256k1_context_preallocated_create or
- *  secp256k1_context_preallocated_clone.
- *
- *  Args:   ctx: an existing context to destroy, constructed using
- *               secp256k1_context_preallocated_create or
- *               secp256k1_context_preallocated_clone
- *               (i.e., not secp256k1_context_static).
- */
-SECP256K1_API void secp256k1_context_preallocated_destroy(
-    secp256k1_context *ctx
-) SECP256K1_ARG_NONNULL(1);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SECP256K1_PREALLOCATED_H */

external/secp256k1/include/secp256k1_schnorrsig.h

@@ -1,190 +0,0 @@
-#ifndef SECP256K1_SCHNORRSIG_H
-#define SECP256K1_SCHNORRSIG_H
-
-#include "secp256k1.h"
-#include "secp256k1_extrakeys.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** This module implements a variant of Schnorr signatures compliant with
- *  Bitcoin Improvement Proposal 340 "Schnorr Signatures for secp256k1"
- *  (https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki).
- */
-
-/** A pointer to a function to deterministically generate a nonce.
- *
- *  Same as secp256k1_nonce function with the exception of accepting an
- *  additional pubkey argument and not requiring an attempt argument. The pubkey
- *  argument can protect signature schemes with key-prefixed challenge hash
- *  inputs against reusing the nonce when signing with the wrong precomputed
- *  pubkey.
- *
- *  Returns: 1 if a nonce was successfully generated. 0 will cause signing to
- *           return an error.
- *  Out:  nonce32: pointer to a 32-byte array to be filled by the function
- *  In:       msg: the message being verified. Is NULL if and only if msglen
- *                 is 0.
- *         msglen: the length of the message
- *          key32: pointer to a 32-byte secret key (will not be NULL)
- *     xonly_pk32: the 32-byte serialized xonly pubkey corresponding to key32
- *                 (will not be NULL)
- *           algo: pointer to an array describing the signature
- *                 algorithm (will not be NULL)
- *        algolen: the length of the algo array
- *           data: arbitrary data pointer that is passed through
- *
- *  Except for test cases, this function should compute some cryptographic hash of
- *  the message, the key, the pubkey, the algorithm description, and data.
- */
-typedef int (*secp256k1_nonce_function_hardened)(
-    unsigned char *nonce32,
-    const unsigned char *msg,
-    size_t msglen,
-    const unsigned char *key32,
-    const unsigned char *xonly_pk32,
-    const unsigned char *algo,
-    size_t algolen,
-    void *data
-);
-
-/** An implementation of the nonce generation function as defined in Bitcoin
- *  Improvement Proposal 340 "Schnorr Signatures for secp256k1"
- *  (https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki).
- *
- *  If a data pointer is passed, it is assumed to be a pointer to 32 bytes of
- *  auxiliary random data as defined in BIP-340. If the data pointer is NULL,
- *  the nonce derivation procedure follows BIP-340 by setting the auxiliary
- *  random data to zero. The algo argument must be non-NULL, otherwise the
- *  function will fail and return 0. The hash will be tagged with algo.
- *  Therefore, to create BIP-340 compliant signatures, algo must be set to
- *  "BIP0340/nonce" and algolen to 13.
- */
-SECP256K1_API_VAR const secp256k1_nonce_function_hardened secp256k1_nonce_function_bip340;
-
-/** Data structure that contains additional arguments for schnorrsig_sign_custom.
- *
- *  A schnorrsig_extraparams structure object can be initialized correctly by
- *  setting it to SECP256K1_SCHNORRSIG_EXTRAPARAMS_INIT.
- *
- *  Members:
- *      magic: set to SECP256K1_SCHNORRSIG_EXTRAPARAMS_MAGIC at initialization
- *             and has no other function than making sure the object is
- *             initialized.
- *    noncefp: pointer to a nonce generation function. If NULL,
- *             secp256k1_nonce_function_bip340 is used
- *      ndata: pointer to arbitrary data used by the nonce generation function
- *             (can be NULL). If it is non-NULL and
- *             secp256k1_nonce_function_bip340 is used, then ndata must be a
- *             pointer to 32-byte auxiliary randomness as per BIP-340.
- */
-typedef struct {
-    unsigned char magic[4];
-    secp256k1_nonce_function_hardened noncefp;
-    void *ndata;
-} secp256k1_schnorrsig_extraparams;
-
-#define SECP256K1_SCHNORRSIG_EXTRAPARAMS_MAGIC { 0xda, 0x6f, 0xb3, 0x8c }
-#define SECP256K1_SCHNORRSIG_EXTRAPARAMS_INIT {\
-    SECP256K1_SCHNORRSIG_EXTRAPARAMS_MAGIC,\
-    NULL,\
-    NULL\
-}
-
-/** Create a Schnorr signature.
- *
- *  Does _not_ strictly follow BIP-340 because it does not verify the resulting
- *  signature. Instead, you can manually use secp256k1_schnorrsig_verify and
- *  abort if it fails.
- *
- *  This function only signs 32-byte messages. If you have messages of a
- *  different size (or the same size but without a context-specific tag
- *  prefix), it is recommended to create a 32-byte message hash with
- *  secp256k1_tagged_sha256 and then sign the hash. Tagged hashing allows
- *  providing an context-specific tag for domain separation. This prevents
- *  signatures from being valid in multiple contexts by accident.
- *
- *  Returns 1 on success, 0 on failure.
- *  Args:    ctx: pointer to a context object (not secp256k1_context_static).
- *  Out:   sig64: pointer to a 64-byte array to store the serialized signature.
- *  In:    msg32: the 32-byte message being signed.
- *       keypair: pointer to an initialized keypair.
- *    aux_rand32: 32 bytes of fresh randomness. While recommended to provide
- *                this, it is only supplemental to security and can be NULL. A
- *                NULL argument is treated the same as an all-zero one. See
- *                BIP-340 "Default Signing" for a full explanation of this
- *                argument and for guidance if randomness is expensive.
- */
-SECP256K1_API int secp256k1_schnorrsig_sign32(
-    const secp256k1_context *ctx,
-    unsigned char *sig64,
-    const unsigned char *msg32,
-    const secp256k1_keypair *keypair,
-    const unsigned char *aux_rand32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Same as secp256k1_schnorrsig_sign32, but DEPRECATED. Will be removed in
- *  future versions. */
-SECP256K1_API int secp256k1_schnorrsig_sign(
-    const secp256k1_context *ctx,
-    unsigned char *sig64,
-    const unsigned char *msg32,
-    const secp256k1_keypair *keypair,
-    const unsigned char *aux_rand32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4)
-  SECP256K1_DEPRECATED("Use secp256k1_schnorrsig_sign32 instead");
-
-/** Create a Schnorr signature with a more flexible API.
- *
- *  Same arguments as secp256k1_schnorrsig_sign except that it allows signing
- *  variable length messages and accepts a pointer to an extraparams object that
- *  allows customizing signing by passing additional arguments.
- *
- *  Equivalent to secp256k1_schnorrsig_sign32(..., aux_rand32) if msglen is 32
- *  and extraparams is initialized as follows:
- *  ```
- *  secp256k1_schnorrsig_extraparams extraparams = SECP256K1_SCHNORRSIG_EXTRAPARAMS_INIT;
- *  extraparams.ndata = (unsigned char*)aux_rand32;
- *  ```
- *
- *  Returns 1 on success, 0 on failure.
- *  Args:   ctx: pointer to a context object (not secp256k1_context_static).
- *  Out:  sig64: pointer to a 64-byte array to store the serialized signature.
- *  In:     msg: the message being signed. Can only be NULL if msglen is 0.
- *       msglen: length of the message.
- *      keypair: pointer to an initialized keypair.
- *  extraparams: pointer to an extraparams object (can be NULL).
- */
-SECP256K1_API int secp256k1_schnorrsig_sign_custom(
-    const secp256k1_context *ctx,
-    unsigned char *sig64,
-    const unsigned char *msg,
-    size_t msglen,
-    const secp256k1_keypair *keypair,
-    secp256k1_schnorrsig_extraparams *extraparams
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(5);
-
-/** Verify a Schnorr signature.
- *
- *  Returns: 1: correct signature
- *           0: incorrect signature
- *  Args:    ctx: a secp256k1 context object.
- *  In:    sig64: pointer to the 64-byte signature to verify.
- *           msg: the message being verified. Can only be NULL if msglen is 0.
- *        msglen: length of the message
- *        pubkey: pointer to an x-only public key to verify with (cannot be NULL)
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_schnorrsig_verify(
-    const secp256k1_context *ctx,
-    const unsigned char *sig64,
-    const unsigned char *msg,
-    size_t msglen,
-    const secp256k1_xonly_pubkey *pubkey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(5);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SECP256K1_SCHNORRSIG_H */

external/secp256k1/sage/gen_exhaustive_groups.sage

@@ -1,156 +0,0 @@
-load("secp256k1_params.sage")
-
-MAX_ORDER = 1000
-
-# Set of (curve) orders we have encountered so far.
-orders_done = set()
-
-# Map from (subgroup) orders to [b, int(gen.x), int(gen.y), gen, lambda] for those subgroups.
-solutions = {}
-
-# Iterate over curves of the form y^2 = x^3 + B.
-for b in range(1, P):
-    # There are only 6 curves (up to isomorphism) of the form y^2 = x^3 + B. Stop once we have tried all.
-    if len(orders_done) == 6:
-        break
-
-    E = EllipticCurve(F, [0, b])
-    print("Analyzing curve y^2 = x^3 + %i" % b)
-    n = E.order()
-
-    # Skip curves with an order we've already tried
-    if n in orders_done:
-        print("- Isomorphic to earlier curve")
-        print()
-        continue
-    orders_done.add(n)
-
-    # Skip curves isomorphic to the real secp256k1
-    if n.is_pseudoprime():
-        assert E.is_isomorphic(C)
-        print("- Isomorphic to secp256k1")
-        print()
-        continue
-
-    print("- Finding prime subgroups")
-
-    # Map from group_order to a set of independent generators for that order.
-    curve_gens = {}
-
-    for g in E.gens():
-        # Find what prime subgroups of group generated by g exist.
-        g_order = g.order()
-        for f, _ in g.order().factor():
-            # Skip subgroups that have bad size.
-            if f < 4:
-                print(f"  - Subgroup of size {f}: too small")
-                continue
-            if f > MAX_ORDER:
-                print(f"  - Subgroup of size {f}: too large")
-                continue
-
-            # Construct a generator for that subgroup.
-            gen = g * (g_order // f)
-            assert(gen.order() == f)
-
-            # Add to set the minimal multiple of gen.
-            curve_gens.setdefault(f, set()).add(min([j*gen for j in range(1, f)]))
-            print(f"  - Subgroup of size {f}: ok")
-
-    for f in sorted(curve_gens.keys()):
-        print(f"- Constructing group of order {f}")
-        cbrts = sorted([int(c) for c in Integers(f)(1).nth_root(3, all=true) if c != 1])
-        gens = list(curve_gens[f])
-        sol_count = 0
-        no_endo_count = 0
-
-        # Consider all non-zero linear combinations of the independent generators.
-        for j in range(1, f**len(gens)):
-            gen = sum(gens[k] * ((j // f**k) % f) for k in range(len(gens)))
-            assert not gen.is_zero()
-            assert (f*gen).is_zero()
-
-            # Find lambda for endomorphism. Skip if none can be found.
-            lam = None
-            for l in cbrts:
-                if l*gen == E(BETA*gen[0], gen[1]):
-                    lam = l
-                    break
-
-            if lam is None:
-                no_endo_count += 1
-            else:
-                sol_count += 1
-                solutions.setdefault(f, []).append((b, int(gen[0]), int(gen[1]), gen, lam))
-
-        print(f"  - Found {sol_count} generators (plus {no_endo_count} without endomorphism)")
-
-    print()
-
-def output_generator(g, name):
-    print(f"#define {name} SECP256K1_GE_CONST(\\")
-    print("    0x%08x, 0x%08x, 0x%08x, 0x%08x,\\" % tuple((int(g[0]) >> (32 * (7 - i))) & 0xffffffff for i in range(4)))
-    print("    0x%08x, 0x%08x, 0x%08x, 0x%08x,\\" % tuple((int(g[0]) >> (32 * (7 - i))) & 0xffffffff for i in range(4, 8)))
-    print("    0x%08x, 0x%08x, 0x%08x, 0x%08x,\\" % tuple((int(g[1]) >> (32 * (7 - i))) & 0xffffffff for i in range(4)))
-    print("    0x%08x, 0x%08x, 0x%08x, 0x%08x\\" % tuple((int(g[1]) >> (32 * (7 - i))) & 0xffffffff for i in range(4, 8)))
-    print(")")
-
-def output_b(b):
-    print(f"#define SECP256K1_B {int(b)}")
-
-print()
-print("To be put in src/group_impl.h:")
-print()
-print("/* Begin of section generated by sage/gen_exhaustive_groups.sage. */")
-for f in sorted(solutions.keys()):
-    # Use as generator/2 the one with lowest b, and lowest (x, y) generator (interpreted as non-negative integers).
-    b, _, _, HALF_G, lam = min(solutions[f])
-    output_generator(2 * HALF_G, f"SECP256K1_G_ORDER_{f}")
-print("/** Generator for secp256k1, value 'g' defined in")
-print(" *  \"Standards for Efficient Cryptography\" (SEC2) 2.7.1.")
-print(" */")
-output_generator(G, "SECP256K1_G")
-print("/* These exhaustive group test orders and generators are chosen such that:")
-print(" * - The field size is equal to that of secp256k1, so field code is the same.")
-print(" * - The curve equation is of the form y^2=x^3+B for some small constant B.")
-print(" * - The subgroup has a generator 2*P, where P.x is as small as possible.")
-print(f" * - The subgroup has size less than {MAX_ORDER} to permit exhaustive testing.")
-print(" * - The subgroup admits an endomorphism of the form lambda*(x,y) == (beta*x,y).")
-print(" */")
-print("#if defined(EXHAUSTIVE_TEST_ORDER)")
-first = True
-for f in sorted(solutions.keys()):
-    b, _, _, _, lam = min(solutions[f])
-    print(f"#  {'if' if first else 'elif'} EXHAUSTIVE_TEST_ORDER == {f}")
-    first = False
-    print()
-    print(f"static const secp256k1_ge secp256k1_ge_const_g = SECP256K1_G_ORDER_{f};")
-    output_b(b)
-    print()
-print("#  else")
-print("#    error No known generator for the specified exhaustive test group order.")
-print("#  endif")
-print("#else")
-print()
-print("static const secp256k1_ge secp256k1_ge_const_g = SECP256K1_G;")
-output_b(7)
-print()
-print("#endif")
-print("/* End of section generated by sage/gen_exhaustive_groups.sage. */")
-
-
-print()
-print()
-print("To be put in src/scalar_impl.h:")
-print()
-print("/* Begin of section generated by sage/gen_exhaustive_groups.sage. */")
-first = True
-for f in sorted(solutions.keys()):
-    _, _, _, _, lam = min(solutions[f])
-    print("#  %s EXHAUSTIVE_TEST_ORDER == %i" % ("if" if first else "elif", f))
-    first = False
-    print("#    define EXHAUSTIVE_TEST_LAMBDA %i" % lam)
-print("#  else")
-print("#    error No known lambda for the specified exhaustive test group order.")
-print("#  endif")
-print("/* End of section generated by sage/gen_exhaustive_groups.sage. */")

external/secp256k1/sage/gen_split_lambda_constants.sage

@@ -1,114 +0,0 @@
-""" Generates the constants used in secp256k1_scalar_split_lambda.
-
-See the comments for secp256k1_scalar_split_lambda in src/scalar_impl.h for detailed explanations.
-"""
-
-load("secp256k1_params.sage")
-
-def inf_norm(v):
-    """Returns the infinity norm of a vector."""
-    return max(map(abs, v))
-
-def gauss_reduction(i1, i2):
-    v1, v2 = i1.copy(), i2.copy()
-    while True:
-        if inf_norm(v2) < inf_norm(v1):
-            v1, v2 = v2, v1
-        # This is essentially
-        #    m = round((v1[0]*v2[0] + v1[1]*v2[1]) / (inf_norm(v1)**2))
-        # (rounding to the nearest integer) without relying on floating point arithmetic.
-        m = ((v1[0]*v2[0] + v1[1]*v2[1]) + (inf_norm(v1)**2) // 2) // (inf_norm(v1)**2)
-        if m == 0:
-            return v1, v2
-        v2[0] -= m*v1[0]
-        v2[1] -= m*v1[1]
-
-def find_split_constants_gauss():
-    """Find constants for secp256k1_scalar_split_lamdba using gauss reduction."""
-    (v11, v12), (v21, v22) = gauss_reduction([0, N], [1, int(LAMBDA)])
-
-    # We use related vectors in secp256k1_scalar_split_lambda.
-    A1, B1 = -v21, -v11
-    A2, B2 = v22, -v21
-
-    return A1, B1, A2, B2
-
-def find_split_constants_explicit_tof():
-    """Find constants for secp256k1_scalar_split_lamdba using the trace of Frobenius.
-
-    See Benjamin Smith: "Easy scalar decompositions for efficient scalar multiplication on
-    elliptic curves and genus 2 Jacobians" (https://eprint.iacr.org/2013/672), Example 2
-    """
-    assert P % 3 == 1 # The paper says P % 3 == 2 but that appears to be a mistake, see [10].
-    assert C.j_invariant() == 0
-
-    t = C.trace_of_frobenius()
-
-    c = Integer(sqrt((4*P - t**2)/3))
-    A1 = Integer((t - c)/2 - 1)
-    B1 = c
-
-    A2 = Integer((t + c)/2 - 1)
-    B2 = Integer(1 - (t - c)/2)
-
-    # We use a negated b values in secp256k1_scalar_split_lambda.
-    B1, B2 = -B1, -B2
-
-    return A1, B1, A2, B2
-
-A1, B1, A2, B2 = find_split_constants_explicit_tof()
-
-# For extra fun, use an independent method to recompute the constants.
-assert (A1, B1, A2, B2) == find_split_constants_gauss()
-
-# PHI : Z[l] -> Z_n where phi(a + b*l) == a + b*lambda mod n.
-def PHI(a,b):
-    return Z(a + LAMBDA*b)
-
-# Check that (A1, B1) and (A2, B2) are in the kernel of PHI.
-assert PHI(A1, B1) == Z(0)
-assert PHI(A2, B2) == Z(0)
-
-# Check that the parallelogram generated by (A1, A2) and (B1, B2)
-# is a fundamental domain by containing exactly N points.
-# Since the LHS is the determinant and N != 0, this also checks that
-# (A1, A2) and (B1, B2) are linearly independent. By the previous
-# assertions, (A1, A2) and (B1, B2) are a basis of the kernel.
-assert A1*B2 - B1*A2 == N
-
-# Check that their components are short enough.
-assert (A1 + A2)/2 < sqrt(N)
-assert B1 < sqrt(N)
-assert B2 < sqrt(N)
-
-G1 = round((2**384)*B2/N)
-G2 = round((2**384)*(-B1)/N)
-
-def rnddiv2(v):
-    if v & 1:
-        v += 1
-    return v >> 1
-
-def scalar_lambda_split(k):
-    """Equivalent to secp256k1_scalar_lambda_split()."""
-    c1 = rnddiv2((k * G1) >> 383)
-    c2 = rnddiv2((k * G2) >> 383)
-    c1 = (c1 * -B1) % N
-    c2 = (c2 * -B2) % N
-    r2 = (c1 + c2) % N
-    r1 = (k + r2 * -LAMBDA) % N
-    return (r1, r2)
-
-# The result of scalar_lambda_split can depend on the representation of k (mod n).
-SPECIAL = (2**383) // G2 + 1
-assert scalar_lambda_split(SPECIAL) != scalar_lambda_split(SPECIAL + N)
-
-print('  A1     =', hex(A1))
-print(' -B1     =', hex(-B1))
-print('  A2     =', hex(A2))
-print(' -B2     =', hex(-B2))
-print('         =', hex(Z(-B2)))
-print(' -LAMBDA =', hex(-LAMBDA))
-
-print('  G1     =', hex(G1))
-print('  G2     =', hex(G2))

external/secp256k1/sage/secp256k1_params.sage

@@ -1,39 +0,0 @@
-"""Prime order of finite field underlying secp256k1 (2^256 - 2^32 - 977)"""
-P = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
-
-"""Finite field underlying secp256k1"""
-F = FiniteField(P)
-
-"""Elliptic curve secp256k1: y^2 = x^3 + 7"""
-C = EllipticCurve([F(0), F(7)])
-
-"""Base point of secp256k1"""
-G = C.lift_x(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
-if int(G[1]) & 1:
-    # G.y is even
-    G = -G
-
-"""Prime order of secp256k1"""
-N = C.order()
-
-"""Finite field of scalars of secp256k1"""
-Z = FiniteField(N)
-
-""" Beta value of secp256k1 non-trivial endomorphism: lambda * (x, y) = (beta * x, y)"""
-BETA = F(2)^((P-1)/3)
-
-""" Lambda value of secp256k1 non-trivial endomorphism: lambda * (x, y) = (beta * x, y)"""
-LAMBDA = Z(3)^((N-1)/3)
-
-assert is_prime(P)
-assert is_prime(N)
-
-assert BETA != F(1)
-assert BETA^3 == F(1)
-assert BETA^2 + BETA + 1 == 0
-
-assert LAMBDA != Z(1)
-assert LAMBDA^3 == Z(1)
-assert LAMBDA^2 + LAMBDA + 1 == 0
-
-assert Integer(LAMBDA)*G == C(BETA*G[0], G[1])

external/secp256k1/src/CMakeLists.txt

@@ -1,169 +0,0 @@
-# Must be included before CMAKE_INSTALL_INCLUDEDIR is used.
-include(GNUInstallDirs)
-
-add_library(secp256k1_precomputed OBJECT EXCLUDE_FROM_ALL
-  precomputed_ecmult.c
-  precomputed_ecmult_gen.c
-)
-
-# Add objects explicitly rather than linking to the object libs to keep them
-# from being exported.
-add_library(secp256k1 secp256k1.c $<TARGET_OBJECTS:secp256k1_precomputed>)
-
-add_library(secp256k1_asm INTERFACE)
-if(SECP256K1_ASM STREQUAL "arm32")
-  add_library(secp256k1_asm_arm OBJECT EXCLUDE_FROM_ALL)
-  target_sources(secp256k1_asm_arm PUBLIC
-    asm/field_10x26_arm.s
-  )
-  target_sources(secp256k1 PRIVATE $<TARGET_OBJECTS:secp256k1_asm_arm>)
-  target_link_libraries(secp256k1_asm INTERFACE secp256k1_asm_arm)
-endif()
-
-# Define our export symbol only for Win32 and only for shared libs.
-# This matches libtool's usage of DLL_EXPORT
-if(WIN32)
-  set_target_properties(secp256k1 PROPERTIES DEFINE_SYMBOL "DLL_EXPORT")
-endif()
-
-# Object libs don't know if they're being built for a shared or static lib.
-# Grab the PIC property from secp256k1 which knows.
-get_target_property(use_pic secp256k1 POSITION_INDEPENDENT_CODE)
-set_target_properties(secp256k1_precomputed PROPERTIES POSITION_INDEPENDENT_CODE ${use_pic})
-
-target_include_directories(secp256k1 INTERFACE
-  # Add the include path for parent projects so that they don't have to manually add it.
-  $<BUILD_INTERFACE:$<$<NOT:$<BOOL:${PROJECT_IS_TOP_LEVEL}>>:${PROJECT_SOURCE_DIR}/include>>
-  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-)
-
-# This emulates Libtool to make sure Libtool and CMake agree on the ABI version,
-# see below "Calculate the version variables" in build-aux/ltmain.sh.
-math(EXPR ${PROJECT_NAME}_soversion "${${PROJECT_NAME}_LIB_VERSION_CURRENT} - ${${PROJECT_NAME}_LIB_VERSION_AGE}")
-set_target_properties(secp256k1 PROPERTIES
-  SOVERSION ${${PROJECT_NAME}_soversion}
-)
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-  set_target_properties(secp256k1 PROPERTIES
-    VERSION ${${PROJECT_NAME}_soversion}.${${PROJECT_NAME}_LIB_VERSION_AGE}.${${PROJECT_NAME}_LIB_VERSION_REVISION}
-  )
-elseif(APPLE)
-  if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.17)
-    math(EXPR ${PROJECT_NAME}_compatibility_version "${${PROJECT_NAME}_LIB_VERSION_CURRENT} + 1")
-    set_target_properties(secp256k1 PROPERTIES
-      MACHO_COMPATIBILITY_VERSION ${${PROJECT_NAME}_compatibility_version}
-      MACHO_CURRENT_VERSION ${${PROJECT_NAME}_compatibility_version}.${${PROJECT_NAME}_LIB_VERSION_REVISION}
-    )
-    unset(${PROJECT_NAME}_compatibility_version)
-  elseif(BUILD_SHARED_LIBS)
-    message(WARNING
-      "The 'compatibility version' and 'current version' values of the DYLIB "
-      "will diverge from the values set by the GNU Libtool. To ensure "
-      "compatibility, it is recommended to upgrade CMake to at least version 3.17."
-    )
-  endif()
-elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
-  set(${PROJECT_NAME}_windows "secp256k1")
-  # This step is commented out from the original. It is bad practice to change
-  # the binary base name depending on the platform. CMake already manipulates
-  # the base name into a final name that fits the conventions of the platform.
-  # Linkers accept base names on the command line and then look for
-  # conventional names on disk. This way, developers can use base names
-  # everywhere (in the CMake and Conan they write) and the tools will do the
-  # right thing.
-  # if(MSVC)
-  #   set(${PROJECT_NAME}_windows "${PROJECT_NAME}")
-  # endif()
-  set_target_properties(secp256k1 PROPERTIES
-    ARCHIVE_OUTPUT_NAME "${${PROJECT_NAME}_windows}"
-    RUNTIME_OUTPUT_NAME "${${PROJECT_NAME}_windows}-${${PROJECT_NAME}_soversion}"
-  )
-  unset(${PROJECT_NAME}_windows)
-endif()
-unset(${PROJECT_NAME}_soversion)
-
-if(SECP256K1_BUILD_BENCHMARK)
-  add_executable(bench bench.c)
-  target_link_libraries(bench secp256k1)
-  add_executable(bench_internal bench_internal.c)
-  target_link_libraries(bench_internal secp256k1_precomputed secp256k1_asm)
-  add_executable(bench_ecmult bench_ecmult.c)
-  target_link_libraries(bench_ecmult secp256k1_precomputed secp256k1_asm)
-endif()
-
-if(SECP256K1_BUILD_TESTS)
-  add_executable(noverify_tests tests.c)
-  target_link_libraries(noverify_tests secp256k1_precomputed secp256k1_asm)
-  add_test(NAME noverify_tests COMMAND noverify_tests)
-  if(NOT CMAKE_BUILD_TYPE STREQUAL "Coverage")
-    add_executable(tests tests.c)
-    target_compile_definitions(tests PRIVATE VERIFY)
-    target_link_libraries(tests secp256k1_precomputed secp256k1_asm)
-    add_test(NAME tests COMMAND tests)
-  endif()
-endif()
-
-if(SECP256K1_BUILD_EXHAUSTIVE_TESTS)
-  # Note: do not include secp256k1_precomputed in exhaustive_tests (it uses runtime-generated tables).
-  add_executable(exhaustive_tests tests_exhaustive.c)
-  target_link_libraries(exhaustive_tests secp256k1_asm)
-  target_compile_definitions(exhaustive_tests PRIVATE $<$<NOT:$<CONFIG:Coverage>>:VERIFY>)
-  add_test(NAME exhaustive_tests COMMAND exhaustive_tests)
-endif()
-
-if(SECP256K1_BUILD_CTIME_TESTS)
-  add_executable(ctime_tests ctime_tests.c)
-  target_link_libraries(ctime_tests secp256k1)
-endif()
-
-if(SECP256K1_INSTALL)
-  install(TARGETS secp256k1
-    EXPORT ${PROJECT_NAME}-targets
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-  )
-  set(${PROJECT_NAME}_headers
-    "${PROJECT_SOURCE_DIR}/include/secp256k1.h"
-    "${PROJECT_SOURCE_DIR}/include/secp256k1_preallocated.h"
-  )
-  if(SECP256K1_ENABLE_MODULE_ECDH)
-    list(APPEND ${PROJECT_NAME}_headers "${PROJECT_SOURCE_DIR}/include/secp256k1_ecdh.h")
-  endif()
-  if(SECP256K1_ENABLE_MODULE_RECOVERY)
-    list(APPEND ${PROJECT_NAME}_headers "${PROJECT_SOURCE_DIR}/include/secp256k1_recovery.h")
-  endif()
-  if(SECP256K1_ENABLE_MODULE_EXTRAKEYS)
-    list(APPEND ${PROJECT_NAME}_headers "${PROJECT_SOURCE_DIR}/include/secp256k1_extrakeys.h")
-  endif()
-  if(SECP256K1_ENABLE_MODULE_SCHNORRSIG)
-    list(APPEND ${PROJECT_NAME}_headers "${PROJECT_SOURCE_DIR}/include/secp256k1_schnorrsig.h")
-  endif()
-  install(FILES ${${PROJECT_NAME}_headers}
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-  )
-
-  install(EXPORT ${PROJECT_NAME}-targets
-    FILE ${PROJECT_NAME}-targets.cmake
-    NAMESPACE ${PROJECT_NAME}::
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
-  )
-
-  include(CMakePackageConfigHelpers)
-  configure_package_config_file(
-    ${PROJECT_SOURCE_DIR}/cmake/config.cmake.in
-    ${PROJECT_NAME}-config.cmake
-    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
-    NO_SET_AND_CHECK_MACRO
-  )
-  write_basic_package_version_file(${PROJECT_NAME}-config-version.cmake
-    COMPATIBILITY SameMinorVersion
-  )
-
-  install(
-    FILES
-      ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake
-      ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
-)
-endif()

external/secp256k1/src/assumptions.h

@@ -1,83 +0,0 @@
-/***********************************************************************
- * Copyright (c) 2020 Pieter Wuille                                    *
- * Distributed under the MIT software license, see the accompanying    *
- * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
- ***********************************************************************/
-
-#ifndef SECP256K1_ASSUMPTIONS_H
-#define SECP256K1_ASSUMPTIONS_H
-
-#include <limits.h>
-
-#include "util.h"
-#if defined(SECP256K1_INT128_NATIVE)
-#include "int128_native.h"
-#endif
-
-/* This library, like most software, relies on a number of compiler implementation defined (but not undefined)
-   behaviours. Although the behaviours we require are essentially universal we test them specifically here to
-   reduce the odds of experiencing an unwelcome surprise.
-*/
-
-struct secp256k1_assumption_checker {
-    /* This uses a trick to implement a static assertion in C89: a type with an array of negative size is not
-       allowed. */
-    int dummy_array[(
-        /* Bytes are 8 bits. */
-        (CHAR_BIT == 8) &&
-
-        /* No integer promotion for uint32_t. This ensures that we can multiply uintXX_t values where XX >= 32
-           without signed overflow, which would be undefined behaviour. */
-        (UINT_MAX <= UINT32_MAX) &&
-
-        /* Conversions from unsigned to signed outside of the bounds of the signed type are
-           implementation-defined. Verify that they function as reinterpreting the lower
-           bits of the input in two's complement notation. Do this for conversions:
-           - from uint(N)_t to int(N)_t with negative result
-           - from uint(2N)_t to int(N)_t with negative result
-           - from int(2N)_t to int(N)_t with negative result
-           - from int(2N)_t to int(N)_t with positive result */
-
-        /* To int8_t. */
-        ((int8_t)(uint8_t)0xAB == (int8_t)-(int8_t)0x55) &&
-        ((int8_t)(uint16_t)0xABCD == (int8_t)-(int8_t)0x33) &&
-        ((int8_t)(int16_t)(uint16_t)0xCDEF == (int8_t)(uint8_t)0xEF) &&
-        ((int8_t)(int16_t)(uint16_t)0x9234 == (int8_t)(uint8_t)0x34) &&
-
-        /* To int16_t. */
-        ((int16_t)(uint16_t)0xBCDE == (int16_t)-(int16_t)0x4322) &&
-        ((int16_t)(uint32_t)0xA1B2C3D4 == (int16_t)-(int16_t)0x3C2C) &&
-        ((int16_t)(int32_t)(uint32_t)0xC1D2E3F4 == (int16_t)(uint16_t)0xE3F4) &&
-        ((int16_t)(int32_t)(uint32_t)0x92345678 == (int16_t)(uint16_t)0x5678) &&
-
-        /* To int32_t. */
-        ((int32_t)(uint32_t)0xB2C3D4E5 == (int32_t)-(int32_t)0x4D3C2B1B) &&
-        ((int32_t)(uint64_t)0xA123B456C789D012ULL == (int32_t)-(int32_t)0x38762FEE) &&
-        ((int32_t)(int64_t)(uint64_t)0xC1D2E3F4A5B6C7D8ULL == (int32_t)(uint32_t)0xA5B6C7D8) &&
-        ((int32_t)(int64_t)(uint64_t)0xABCDEF0123456789ULL == (int32_t)(uint32_t)0x23456789) &&
-
-        /* To int64_t. */
-        ((int64_t)(uint64_t)0xB123C456D789E012ULL == (int64_t)-(int64_t)0x4EDC3BA928761FEEULL) &&
-#if defined(SECP256K1_INT128_NATIVE)
-        ((int64_t)(((uint128_t)0xA1234567B8901234ULL << 64) + 0xC5678901D2345678ULL) == (int64_t)-(int64_t)0x3A9876FE2DCBA988ULL) &&
-        (((int64_t)(int128_t)(((uint128_t)0xB1C2D3E4F5A6B7C8ULL << 64) + 0xD9E0F1A2B3C4D5E6ULL)) == (int64_t)(uint64_t)0xD9E0F1A2B3C4D5E6ULL) &&
-        (((int64_t)(int128_t)(((uint128_t)0xABCDEF0123456789ULL << 64) + 0x0123456789ABCDEFULL)) == (int64_t)(uint64_t)0x0123456789ABCDEFULL) &&
-
-        /* To int128_t. */
-        ((int128_t)(((uint128_t)0xB1234567C8901234ULL << 64) + 0xD5678901E2345678ULL) == (int128_t)(-(int128_t)0x8E1648B3F50E80DCULL * 0x8E1648B3F50E80DDULL + 0x5EA688D5482F9464ULL)) &&
-#endif
-
-        /* Right shift on negative signed values is implementation defined. Verify that it
-           acts as a right shift in two's complement with sign extension (i.e duplicating
-           the top bit into newly added bits). */
-        ((((int8_t)0xE8) >> 2) == (int8_t)(uint8_t)0xFA) &&
-        ((((int16_t)0xE9AC) >> 4) == (int16_t)(uint16_t)0xFE9A) &&
-        ((((int32_t)0x937C918A) >> 9) == (int32_t)(uint32_t)0xFFC9BE48) &&
-        ((((int64_t)0xA8B72231DF9CF4B9ULL) >> 19) == (int64_t)(uint64_t)0xFFFFF516E4463BF3ULL) &&
-#if defined(SECP256K1_INT128_NATIVE)
-        ((((int128_t)(((uint128_t)0xCD833A65684A0DBCULL << 64) + 0xB349312F71EA7637ULL)) >> 39) == (int128_t)(((uint128_t)0xFFFFFFFFFF9B0674ULL << 64) + 0xCAD0941B79669262ULL)) &&
-#endif
-    1) * 2 - 1];
-};
-
-#endif /* SECP256K1_ASSUMPTIONS_H */

external/secp256k1/src/bench.c

@@ -1,223 +0,0 @@
-/***********************************************************************
- * Copyright (c) 2014 Pieter Wuille                                    *
- * Distributed under the MIT software license, see the accompanying    *
- * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
- ***********************************************************************/
-
-#include <stdio.h>
-#include <string.h>
-
-#include "../include/secp256k1.h"
-#include "util.h"
-#include "bench.h"
-
-static void help(int default_iters) {
-    printf("Benchmarks the following algorithms:\n");
-    printf("    - ECDSA signing/verification\n");
-
-#ifdef ENABLE_MODULE_ECDH
-    printf("    - ECDH key exchange (optional module)\n");
-#endif
-
-#ifdef ENABLE_MODULE_RECOVERY
-    printf("    - Public key recovery (optional module)\n");
-#endif
-
-#ifdef ENABLE_MODULE_SCHNORRSIG
-    printf("    - Schnorr signatures (optional module)\n");
-#endif
-
-    printf("\n");
-    printf("The default number of iterations for each benchmark is %d. This can be\n", default_iters);
-    printf("customized using the SECP256K1_BENCH_ITERS environment variable.\n");
-    printf("\n");
-    printf("Usage: ./bench [args]\n");
-    printf("By default, all benchmarks will be run.\n");
-    printf("args:\n");
-    printf("    help              : display this help and exit\n");
-    printf("    ecdsa             : all ECDSA algorithms--sign, verify, recovery (if enabled)\n");
-    printf("    ecdsa_sign        : ECDSA siging algorithm\n");
-    printf("    ecdsa_verify      : ECDSA verification algorithm\n");
-
-#ifdef ENABLE_MODULE_RECOVERY
-    printf("    ecdsa_recover     : ECDSA public key recovery algorithm\n");
-#endif
-
-#ifdef ENABLE_MODULE_ECDH
-    printf("    ecdh              : ECDH key exchange algorithm\n");
-#endif
-
-#ifdef ENABLE_MODULE_SCHNORRSIG
-    printf("    schnorrsig        : all Schnorr signature algorithms (sign, verify)\n");
-    printf("    schnorrsig_sign   : Schnorr sigining algorithm\n");
-    printf("    schnorrsig_verify : Schnorr verification algorithm\n");
-#endif
-
-    printf("\n");
-}
-
-typedef struct {
-    secp256k1_context *ctx;
-    unsigned char msg[32];
-    unsigned char key[32];
-    unsigned char sig[72];
-    size_t siglen;
-    unsigned char pubkey[33];
-    size_t pubkeylen;
-} bench_data;
-
-static void bench_verify(void* arg, int iters) {
-    int i;
-    bench_data* data = (bench_data*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_pubkey pubkey;
-        secp256k1_ecdsa_signature sig;
-        data->sig[data->siglen - 1] ^= (i & 0xFF);
-        data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
-        data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
-        CHECK(secp256k1_ec_pubkey_parse(data->ctx, &pubkey, data->pubkey, data->pubkeylen) == 1);
-        CHECK(secp256k1_ecdsa_signature_parse_der(data->ctx, &sig, data->sig, data->siglen) == 1);
-        CHECK(secp256k1_ecdsa_verify(data->ctx, &sig, data->msg, &pubkey) == (i == 0));
-        data->sig[data->siglen - 1] ^= (i & 0xFF);
-        data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
-        data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
-    }
-}
-
-static void bench_sign_setup(void* arg) {
-    int i;
-    bench_data *data = (bench_data*)arg;
-
-    for (i = 0; i < 32; i++) {
-        data->msg[i] = i + 1;
-    }
-    for (i = 0; i < 32; i++) {
-        data->key[i] = i + 65;
-    }
-}
-
-static void bench_sign_run(void* arg, int iters) {
-    int i;
-    bench_data *data = (bench_data*)arg;
-
-    unsigned char sig[74];
-    for (i = 0; i < iters; i++) {
-        size_t siglen = 74;
-        int j;
-        secp256k1_ecdsa_signature signature;
-        CHECK(secp256k1_ecdsa_sign(data->ctx, &signature, data->msg, data->key, NULL, NULL));
-        CHECK(secp256k1_ecdsa_signature_serialize_der(data->ctx, sig, &siglen, &signature));
-        for (j = 0; j < 32; j++) {
-            data->msg[j] = sig[j];
-            data->key[j] = sig[j + 32];
-        }
-    }
-}
-
-#ifdef ENABLE_MODULE_ECDH
-# include "modules/ecdh/bench_impl.h"
-#endif
-
-#ifdef ENABLE_MODULE_RECOVERY
-# include "modules/recovery/bench_impl.h"
-#endif
-
-#ifdef ENABLE_MODULE_SCHNORRSIG
-# include "modules/schnorrsig/bench_impl.h"
-#endif
-
-int main(int argc, char** argv) {
-    int i;
-    secp256k1_pubkey pubkey;
-    secp256k1_ecdsa_signature sig;
-    bench_data data;
-
-    int d = argc == 1;
-    int default_iters = 20000;
-    int iters = get_iters(default_iters);
-
-    /* Check for invalid user arguments */
-    char* valid_args[] = {"ecdsa", "verify", "ecdsa_verify", "sign", "ecdsa_sign", "ecdh", "recover",
-                         "ecdsa_recover", "schnorrsig", "schnorrsig_verify", "schnorrsig_sign"};
-    size_t valid_args_size = sizeof(valid_args)/sizeof(valid_args[0]);
-    int invalid_args = have_invalid_args(argc, argv, valid_args, valid_args_size);
-
-    if (argc > 1) {
-        if (have_flag(argc, argv, "-h")
-           || have_flag(argc, argv, "--help")
-           || have_flag(argc, argv, "help")) {
-            help(default_iters);
-            return 0;
-        } else if (invalid_args) {
-            fprintf(stderr, "./bench: unrecognized argument.\n\n");
-            help(default_iters);
-            return 1;
-        }
-    }
-
-/* Check if the user tries to benchmark optional module without building it */
-#ifndef ENABLE_MODULE_ECDH
-    if (have_flag(argc, argv, "ecdh")) {
-        fprintf(stderr, "./bench: ECDH module not enabled.\n");
-        fprintf(stderr, "Use ./configure --enable-module-ecdh.\n\n");
-        return 1;
-    }
-#endif
-
-#ifndef ENABLE_MODULE_RECOVERY
-    if (have_flag(argc, argv, "recover") || have_flag(argc, argv, "ecdsa_recover")) {
-        fprintf(stderr, "./bench: Public key recovery module not enabled.\n");
-        fprintf(stderr, "Use ./configure --enable-module-recovery.\n\n");
-        return 1;
-    }
-#endif
-
-#ifndef ENABLE_MODULE_SCHNORRSIG
-    if (have_flag(argc, argv, "schnorrsig") || have_flag(argc, argv, "schnorrsig_sign") || have_flag(argc, argv, "schnorrsig_verify")) {
-        fprintf(stderr, "./bench: Schnorr signatures module not enabled.\n");
-        fprintf(stderr, "Use ./configure --enable-module-schnorrsig.\n\n");
-        return 1;
-    }
-#endif
-
-    /* ECDSA benchmark */
-    data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
-
-    for (i = 0; i < 32; i++) {
-        data.msg[i] = 1 + i;
-    }
-    for (i = 0; i < 32; i++) {
-        data.key[i] = 33 + i;
-    }
-    data.siglen = 72;
-    CHECK(secp256k1_ecdsa_sign(data.ctx, &sig, data.msg, data.key, NULL, NULL));
-    CHECK(secp256k1_ecdsa_signature_serialize_der(data.ctx, data.sig, &data.siglen, &sig));
-    CHECK(secp256k1_ec_pubkey_create(data.ctx, &pubkey, data.key));
-    data.pubkeylen = 33;
-    CHECK(secp256k1_ec_pubkey_serialize(data.ctx, data.pubkey, &data.pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED) == 1);
-
-    print_output_table_header_row();
-    if (d || have_flag(argc, argv, "ecdsa") || have_flag(argc, argv, "verify") || have_flag(argc, argv, "ecdsa_verify")) run_benchmark("ecdsa_verify", bench_verify, NULL, NULL, &data, 10, iters);
-
-    if (d || have_flag(argc, argv, "ecdsa") || have_flag(argc, argv, "sign") || have_flag(argc, argv, "ecdsa_sign")) run_benchmark("ecdsa_sign", bench_sign_run, bench_sign_setup, NULL, &data, 10, iters);
-
-    secp256k1_context_destroy(data.ctx);
-
-#ifdef ENABLE_MODULE_ECDH
-    /* ECDH benchmarks */
-    run_ecdh_bench(iters, argc, argv);
-#endif
-
-#ifdef ENABLE_MODULE_RECOVERY
-    /* ECDSA recovery benchmarks */
-    run_recovery_bench(iters, argc, argv);
-#endif
-
-#ifdef ENABLE_MODULE_SCHNORRSIG
-    /* Schnorr signature benchmarks */
-    run_schnorrsig_bench(iters, argc, argv);
-#endif
-
-    return 0;
-}

external/secp256k1/src/bench.h

@@ -1,188 +0,0 @@
-/***********************************************************************
- * Copyright (c) 2014 Pieter Wuille                                    *
- * Distributed under the MIT software license, see the accompanying    *
- * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
- ***********************************************************************/
-
-#ifndef SECP256K1_BENCH_H
-#define SECP256K1_BENCH_H
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-
-#if (defined(_MSC_VER) && _MSC_VER >= 1900)
-#  include <time.h>
-#else
-#  include <sys/time.h>
-#endif
-
-static int64_t gettime_i64(void) {
-#if (defined(_MSC_VER) && _MSC_VER >= 1900)
-    /* C11 way to get wallclock time */
-    struct timespec tv;
-    if (!timespec_get(&tv, TIME_UTC)) {
-        fputs("timespec_get failed!", stderr);
-        exit(1);
-    }
-    return (int64_t)tv.tv_nsec / 1000 + (int64_t)tv.tv_sec * 1000000LL;
-#else
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    return (int64_t)tv.tv_usec + (int64_t)tv.tv_sec * 1000000LL;
-#endif
-}
-
-#define FP_EXP (6)
-#define FP_MULT (1000000LL)
-
-/* Format fixed point number. */
-static void print_number(const int64_t x) {
-    int64_t x_abs, y;
-    int c, i, rounding, g; /* g = integer part size, c = fractional part size */
-    size_t ptr;
-    char buffer[30];
-
-    if (x == INT64_MIN) {
-        /* Prevent UB. */
-        printf("ERR");
-        return;
-    }
-    x_abs = x < 0 ? -x : x;
-
-    /* Determine how many decimals we want to show (more than FP_EXP makes no
-     * sense). */
-    y = x_abs;
-    c = 0;
-    while (y > 0LL && y < 100LL * FP_MULT && c < FP_EXP) {
-        y *= 10LL;
-        c++;
-    }
-
-    /* Round to 'c' decimals. */
-    y = x_abs;
-    rounding = 0;
-    for (i = c; i < FP_EXP; ++i) {
-        rounding = (y % 10) >= 5;
-        y /= 10;
-    }
-    y += rounding;
-
-    /* Format and print the number. */
-    ptr = sizeof(buffer) - 1;
-    buffer[ptr] = 0;
-    g = 0;
-    if (c != 0) { /* non zero fractional part */
-        for (i = 0; i < c; ++i) {
-            buffer[--ptr] = '0' + (y % 10);
-            y /= 10;
-        }
-    } else if (c == 0) { /* fractional part is 0 */
-        buffer[--ptr] = '0'; 
-    }
-    buffer[--ptr] = '.';
-    do {
-        buffer[--ptr] = '0' + (y % 10);
-        y /= 10;
-        g++;
-    } while (y != 0);
-    if (x < 0) {
-        buffer[--ptr] = '-';
-        g++;
-    }
-    printf("%5.*s", g, &buffer[ptr]); /* Prints integer part */
-    printf("%-*s", FP_EXP, &buffer[ptr + g]); /* Prints fractional part */
-}
-
-static void run_benchmark(char *name, void (*benchmark)(void*, int), void (*setup)(void*), void (*teardown)(void*, int), void* data, int count, int iter) {
-    int i;
-    int64_t min = INT64_MAX;
-    int64_t sum = 0;
-    int64_t max = 0;
-    for (i = 0; i < count; i++) {
-        int64_t begin, total;
-        if (setup != NULL) {
-            setup(data);
-        }
-        begin = gettime_i64();
-        benchmark(data, iter);
-        total = gettime_i64() - begin;
-        if (teardown != NULL) {
-            teardown(data, iter);
-        }
-        if (total < min) {
-            min = total;
-        }
-        if (total > max) {
-            max = total;
-        }
-        sum += total;
-    }
-    /* ',' is used as a column delimiter */
-    printf("%-30s, ", name);
-    print_number(min * FP_MULT / iter);
-    printf("   , ");
-    print_number(((sum * FP_MULT) / count) / iter);
-    printf("   , ");
-    print_number(max * FP_MULT / iter);
-    printf("\n");
-}
-
-static int have_flag(int argc, char** argv, char *flag) {
-    char** argm = argv + argc;
-    argv++;
-    while (argv != argm) {
-        if (strcmp(*argv, flag) == 0) {
-            return 1;
-        }
-        argv++;
-    }
-    return 0;
-}
-
-/* takes an array containing the arguments that the user is allowed to enter on the command-line
-   returns:
-      - 1 if the user entered an invalid argument
-      - 0 if all the user entered arguments are valid */
-static int have_invalid_args(int argc, char** argv, char** valid_args, size_t n) {
-    size_t i;
-    int found_valid;
-    char** argm = argv + argc;
-    argv++;
-
-    while (argv != argm) {
-        found_valid = 0;
-        for (i = 0; i < n; i++) {
-            if (strcmp(*argv, valid_args[i]) == 0) {
-                found_valid = 1; /* user entered a valid arg from the list */
-                break;
-            }
-        }
-        if (found_valid == 0) {
-            return 1; /* invalid arg found */
-        }
-        argv++;
-    }
-    return 0;
-}
-
-static int get_iters(int default_iters) {
-    char* env = getenv("SECP256K1_BENCH_ITERS");
-    if (env) {
-        return strtol(env, NULL, 0);
-    } else {
-        return default_iters;
-    }
-}
-
-static void print_output_table_header_row(void) {
-    char* bench_str = "Benchmark";     /* left justified */
-    char* min_str = "    Min(us)    "; /* center alignment */
-    char* avg_str = "    Avg(us)    ";
-    char* max_str = "    Max(us)    ";
-    printf("%-30s,%-15s,%-15s,%-15s\n", bench_str, min_str, avg_str, max_str);
-    printf("\n");
-}
-
-#endif /* SECP256K1_BENCH_H */

external/secp256k1/src/bench_ecmult.c

@@ -1,370 +0,0 @@
-/***********************************************************************
- * Copyright (c) 2017 Pieter Wuille                                    *
- * Distributed under the MIT software license, see the accompanying    *
- * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
- ***********************************************************************/
-#include <stdio.h>
-
-#include "secp256k1.c"
-#include "../include/secp256k1.h"
-
-#include "util.h"
-#include "hash_impl.h"
-#include "field_impl.h"
-#include "group_impl.h"
-#include "scalar_impl.h"
-#include "ecmult_impl.h"
-#include "bench.h"
-
-#define POINTS 32768
-
-static void help(char **argv) {
-    printf("Benchmark EC multiplication algorithms\n");
-    printf("\n");
-    printf("Usage: %s <help|pippenger_wnaf|strauss_wnaf|simple>\n", argv[0]);
-    printf("The output shows the number of multiplied and summed points right after the\n");
-    printf("function name. The letter 'g' indicates that one of the points is the generator.\n");
-    printf("The benchmarks are divided by the number of points.\n");
-    printf("\n");
-    printf("default (ecmult_multi): picks pippenger_wnaf or strauss_wnaf depending on the\n");
-    printf("                        batch size\n");
-    printf("pippenger_wnaf:         for all batch sizes\n");
-    printf("strauss_wnaf:           for all batch sizes\n");
-    printf("simple:                 multiply and sum each point individually\n");
-}
-
-typedef struct {
-    /* Setup once in advance */
-    secp256k1_context* ctx;
-    secp256k1_scratch_space* scratch;
-    secp256k1_scalar* scalars;
-    secp256k1_ge* pubkeys;
-    secp256k1_gej* pubkeys_gej;
-    secp256k1_scalar* seckeys;
-    secp256k1_gej* expected_output;
-    secp256k1_ecmult_multi_func ecmult_multi;
-
-    /* Changes per benchmark */
-    size_t count;
-    int includes_g;
-
-    /* Changes per benchmark iteration, used to pick different scalars and pubkeys
-     * in each run. */
-    size_t offset1;
-    size_t offset2;
-
-    /* Benchmark output. */
-    secp256k1_gej* output;
-} bench_data;
-
-/* Hashes x into [0, POINTS) twice and store the result in offset1 and offset2. */
-static void hash_into_offset(bench_data* data, size_t x) {
-    data->offset1 = (x * 0x537b7f6f + 0x8f66a481) % POINTS;
-    data->offset2 = (x * 0x7f6f537b + 0x6a1a8f49) % POINTS;
-}
-
-/* Check correctness of the benchmark by computing
- * sum(outputs) ?= (sum(scalars_gen) + sum(seckeys)*sum(scalars))*G */
-static void bench_ecmult_teardown_helper(bench_data* data, size_t* seckey_offset, size_t* scalar_offset, size_t* scalar_gen_offset, int iters) {
-    int i;
-    secp256k1_gej sum_output, tmp;
-    secp256k1_scalar sum_scalars;
-
-    secp256k1_gej_set_infinity(&sum_output);
-    secp256k1_scalar_clear(&sum_scalars);
-    for (i = 0; i < iters; ++i) {
-        secp256k1_gej_add_var(&sum_output, &sum_output, &data->output[i], NULL);
-        if (scalar_gen_offset != NULL) {
-            secp256k1_scalar_add(&sum_scalars, &sum_scalars, &data->scalars[(*scalar_gen_offset+i) % POINTS]);
-        }
-        if (seckey_offset != NULL) {
-            secp256k1_scalar s = data->seckeys[(*seckey_offset+i) % POINTS];
-            secp256k1_scalar_mul(&s, &s, &data->scalars[(*scalar_offset+i) % POINTS]);
-            secp256k1_scalar_add(&sum_scalars, &sum_scalars, &s);
-        }
-    }
-    secp256k1_ecmult_gen(&data->ctx->ecmult_gen_ctx, &tmp, &sum_scalars);
-    CHECK(secp256k1_gej_eq_var(&tmp, &sum_output));
-}
-
-static void bench_ecmult_setup(void* arg) {
-    bench_data* data = (bench_data*)arg;
-    /* Re-randomize offset to ensure that we're using different scalars and
-     * group elements in each run. */
-    hash_into_offset(data, data->offset1);
-}
-
-static void bench_ecmult_gen(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    int i;
-
-    for (i = 0; i < iters; ++i) {
-        secp256k1_ecmult_gen(&data->ctx->ecmult_gen_ctx, &data->output[i], &data->scalars[(data->offset1+i) % POINTS]);
-    }
-}
-
-static void bench_ecmult_gen_teardown(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    bench_ecmult_teardown_helper(data, NULL, NULL, &data->offset1, iters);
-}
-
-static void bench_ecmult_const(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    int i;
-
-    for (i = 0; i < iters; ++i) {
-        secp256k1_ecmult_const(&data->output[i], &data->pubkeys[(data->offset1+i) % POINTS], &data->scalars[(data->offset2+i) % POINTS]);
-    }
-}
-
-static void bench_ecmult_const_teardown(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    bench_ecmult_teardown_helper(data, &data->offset1, &data->offset2, NULL, iters);
-}
-
-static void bench_ecmult_1p(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    int i;
-
-    for (i = 0; i < iters; ++i) {
-        secp256k1_ecmult(&data->output[i], &data->pubkeys_gej[(data->offset1+i) % POINTS], &data->scalars[(data->offset2+i) % POINTS], NULL);
-    }
-}
-
-static void bench_ecmult_1p_teardown(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    bench_ecmult_teardown_helper(data, &data->offset1, &data->offset2, NULL, iters);
-}
-
-static void bench_ecmult_0p_g(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    secp256k1_scalar zero;
-    int i;
-
-    secp256k1_scalar_set_int(&zero, 0);
-    for (i = 0; i < iters; ++i) {
-        secp256k1_ecmult(&data->output[i], NULL, &zero, &data->scalars[(data->offset1+i) % POINTS]);
-    }
-}
-
-static void bench_ecmult_0p_g_teardown(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    bench_ecmult_teardown_helper(data, NULL, NULL, &data->offset1, iters);
-}
-
-static void bench_ecmult_1p_g(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    int i;
-
-    for (i = 0; i < iters/2; ++i) {
-        secp256k1_ecmult(&data->output[i], &data->pubkeys_gej[(data->offset1+i) % POINTS], &data->scalars[(data->offset2+i) % POINTS], &data->scalars[(data->offset1+i) % POINTS]);
-    }
-}
-
-static void bench_ecmult_1p_g_teardown(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    bench_ecmult_teardown_helper(data, &data->offset1, &data->offset2, &data->offset1, iters/2);
-}
-
-static void run_ecmult_bench(bench_data* data, int iters) {
-    char str[32];
-    sprintf(str, "ecmult_gen");
-    run_benchmark(str, bench_ecmult_gen, bench_ecmult_setup, bench_ecmult_gen_teardown, data, 10, iters);
-    sprintf(str, "ecmult_const");
-    run_benchmark(str, bench_ecmult_const, bench_ecmult_setup, bench_ecmult_const_teardown, data, 10, iters);
-    /* ecmult with non generator point */
-    sprintf(str, "ecmult_1p");
-    run_benchmark(str, bench_ecmult_1p, bench_ecmult_setup, bench_ecmult_1p_teardown, data, 10, iters);
-    /* ecmult with generator point */
-    sprintf(str, "ecmult_0p_g");
-    run_benchmark(str, bench_ecmult_0p_g, bench_ecmult_setup, bench_ecmult_0p_g_teardown, data, 10, iters);
-    /* ecmult with generator and non-generator point. The reported time is per point. */
-    sprintf(str, "ecmult_1p_g");
-    run_benchmark(str, bench_ecmult_1p_g, bench_ecmult_setup, bench_ecmult_1p_g_teardown, data, 10, 2*iters);
-}
-
-static int bench_ecmult_multi_callback(secp256k1_scalar* sc, secp256k1_ge* ge, size_t idx, void* arg) {
-    bench_data* data = (bench_data*)arg;
-    if (data->includes_g) ++idx;
-    if (idx == 0) {
-        *sc = data->scalars[data->offset1];
-        *ge = secp256k1_ge_const_g;
-    } else {
-        *sc = data->scalars[(data->offset1 + idx) % POINTS];
-        *ge = data->pubkeys[(data->offset2 + idx - 1) % POINTS];
-    }
-    return 1;
-}
-
-static void bench_ecmult_multi(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-
-    int includes_g = data->includes_g;
-    int iter;
-    int count = data->count;
-    iters = iters / data->count;
-
-    for (iter = 0; iter < iters; ++iter) {
-        data->ecmult_multi(&data->ctx->error_callback, data->scratch, &data->output[iter], data->includes_g ? &data->scalars[data->offset1] : NULL, bench_ecmult_multi_callback, arg, count - includes_g);
-        data->offset1 = (data->offset1 + count) % POINTS;
-        data->offset2 = (data->offset2 + count - 1) % POINTS;
-    }
-}
-
-static void bench_ecmult_multi_setup(void* arg) {
-    bench_data* data = (bench_data*)arg;
-    hash_into_offset(data, data->count);
-}
-
-static void bench_ecmult_multi_teardown(void* arg, int iters) {
-    bench_data* data = (bench_data*)arg;
-    int iter;
-    iters = iters / data->count;
-    /* Verify the results in teardown, to avoid doing comparisons while benchmarking. */
-    for (iter = 0; iter < iters; ++iter) {
-        secp256k1_gej tmp;
-        secp256k1_gej_add_var(&tmp, &data->output[iter], &data->expected_output[iter], NULL);
-        CHECK(secp256k1_gej_is_infinity(&tmp));
-    }
-}
-
-static void generate_scalar(uint32_t num, secp256k1_scalar* scalar) {
-    secp256k1_sha256 sha256;
-    unsigned char c[10] = {'e', 'c', 'm', 'u', 'l', 't', 0, 0, 0, 0};
-    unsigned char buf[32];
-    int overflow = 0;
-    c[6] = num;
-    c[7] = num >> 8;
-    c[8] = num >> 16;
-    c[9] = num >> 24;
-    secp256k1_sha256_initialize(&sha256);
-    secp256k1_sha256_write(&sha256, c, sizeof(c));
-    secp256k1_sha256_finalize(&sha256, buf);
-    secp256k1_scalar_set_b32(scalar, buf, &overflow);
-    CHECK(!overflow);
-}
-
-static void run_ecmult_multi_bench(bench_data* data, size_t count, int includes_g, int num_iters) {
-    char str[32];
-    static const secp256k1_scalar zero = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
-    size_t iters = 1 + num_iters / count;
-    size_t iter;
-
-    data->count = count;
-    data->includes_g = includes_g;
-
-    /* Compute (the negation of) the expected results directly. */
-    hash_into_offset(data, data->count);
-    for (iter = 0; iter < iters; ++iter) {
-        secp256k1_scalar tmp;
-        secp256k1_scalar total = data->scalars[(data->offset1++) % POINTS];
-        size_t i = 0;
-        for (i = 0; i + 1 < count; ++i) {
-            secp256k1_scalar_mul(&tmp, &data->seckeys[(data->offset2++) % POINTS], &data->scalars[(data->offset1++) % POINTS]);
-            secp256k1_scalar_add(&total, &total, &tmp);
-        }
-        secp256k1_scalar_negate(&total, &total);
-        secp256k1_ecmult(&data->expected_output[iter], NULL, &zero, &total);
-    }
-
-    /* Run the benchmark. */
-    if (includes_g) {
-        sprintf(str, "ecmult_multi_%ip_g", (int)count - 1);
-    } else {
-        sprintf(str, "ecmult_multi_%ip", (int)count);
-    }
-    run_benchmark(str, bench_ecmult_multi, bench_ecmult_multi_setup, bench_ecmult_multi_teardown, data, 10, count * iters);
-}
-
-int main(int argc, char **argv) {
-    bench_data data;
-    int i, p;
-    size_t scratch_size;
-
-    int iters = get_iters(10000);
-
-    data.ecmult_multi = secp256k1_ecmult_multi_var;
-
-    if (argc > 1) {
-        if(have_flag(argc, argv, "-h")
-           || have_flag(argc, argv, "--help")
-           || have_flag(argc, argv, "help")) {
-            help(argv);
-            return 0;
-        } else if(have_flag(argc, argv, "pippenger_wnaf")) {
-            printf("Using pippenger_wnaf:\n");
-            data.ecmult_multi = secp256k1_ecmult_pippenger_batch_single;
-        } else if(have_flag(argc, argv, "strauss_wnaf")) {
-            printf("Using strauss_wnaf:\n");
-            data.ecmult_multi = secp256k1_ecmult_strauss_batch_single;
-        } else if(have_flag(argc, argv, "simple")) {
-            printf("Using simple algorithm:\n");
-        } else {
-            fprintf(stderr, "%s: unrecognized argument '%s'.\n\n", argv[0], argv[1]);
-            help(argv);
-            return 1;
-        }
-    }
-
-    data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
-    scratch_size = secp256k1_strauss_scratch_size(POINTS) + STRAUSS_SCRATCH_OBJECTS*16;
-    if (!have_flag(argc, argv, "simple")) {
-        data.scratch = secp256k1_scratch_space_create(data.ctx, scratch_size);
-    } else {
-        data.scratch = NULL;
-    }
-
-    /* Allocate stuff */
-    data.scalars = malloc(sizeof(secp256k1_scalar) * POINTS);
-    data.seckeys = malloc(sizeof(secp256k1_scalar) * POINTS);
-    data.pubkeys = malloc(sizeof(secp256k1_ge) * POINTS);
-    data.pubkeys_gej = malloc(sizeof(secp256k1_gej) * POINTS);
-    data.expected_output = malloc(sizeof(secp256k1_gej) * (iters + 1));
-    data.output = malloc(sizeof(secp256k1_gej) * (iters + 1));
-
-    /* Generate a set of scalars, and private/public keypairs. */
-    secp256k1_gej_set_ge(&data.pubkeys_gej[0], &secp256k1_ge_const_g);
-    secp256k1_scalar_set_int(&data.seckeys[0], 1);
-    for (i = 0; i < POINTS; ++i) {
-        generate_scalar(i, &data.scalars[i]);
-        if (i) {
-            secp256k1_gej_double_var(&data.pubkeys_gej[i], &data.pubkeys_gej[i - 1], NULL);
-            secp256k1_scalar_add(&data.seckeys[i], &data.seckeys[i - 1], &data.seckeys[i - 1]);
-        }
-    }
-    secp256k1_ge_set_all_gej_var(data.pubkeys, data.pubkeys_gej, POINTS);
-
-
-    print_output_table_header_row();
-    /* Initialize offset1 and offset2 */
-    hash_into_offset(&data, 0);
-    run_ecmult_bench(&data, iters);
-
-    for (i = 1; i <= 8; ++i) {
-        run_ecmult_multi_bench(&data, i, 1, iters);
-    }
-
-    /* This is disabled with low count of iterations because the loop runs 77 times even with iters=1
-    * and the higher it goes the longer the computation takes(more points)
-    * So we don't run this benchmark with low iterations to prevent slow down */
-     if (iters > 2) {
-        for (p = 0; p <= 11; ++p) {
-            for (i = 9; i <= 16; ++i) {
-                run_ecmult_multi_bench(&data, i << p, 1, iters);
-            }
-        }
-    }
-
-    if (data.scratch != NULL) {
-        secp256k1_scratch_space_destroy(data.ctx, data.scratch);
-    }
-    secp256k1_context_destroy(data.ctx);
-    free(data.scalars);
-    free(data.pubkeys);
-    free(data.pubkeys_gej);
-    free(data.seckeys);
-    free(data.output);
-    free(data.expected_output);
-
-    return(0);
-}

external/secp256k1/src/bench_internal.c

@@ -1,407 +0,0 @@
-/***********************************************************************
- * Copyright (c) 2014-2015 Pieter Wuille                               *
- * Distributed under the MIT software license, see the accompanying    *
- * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
- ***********************************************************************/
-#include <stdio.h>
-
-#include "secp256k1.c"
-#include "../include/secp256k1.h"
-
-#include "assumptions.h"
-#include "util.h"
-#include "hash_impl.h"
-#include "field_impl.h"
-#include "group_impl.h"
-#include "scalar_impl.h"
-#include "ecmult_const_impl.h"
-#include "ecmult_impl.h"
-#include "bench.h"
-
-typedef struct {
-    secp256k1_scalar scalar[2];
-    secp256k1_fe fe[4];
-    secp256k1_ge ge[2];
-    secp256k1_gej gej[2];
-    unsigned char data[64];
-    int wnaf[256];
-} bench_inv;
-
-static void bench_setup(void* arg) {
-    bench_inv *data = (bench_inv*)arg;
-
-    static const unsigned char init[4][32] = {
-        /* Initializer for scalar[0], fe[0], first half of data, the X coordinate of ge[0],
-           and the (implied affine) X coordinate of gej[0]. */
-        {
-            0x02, 0x03, 0x05, 0x07, 0x0b, 0x0d, 0x11, 0x13,
-            0x17, 0x1d, 0x1f, 0x25, 0x29, 0x2b, 0x2f, 0x35,
-            0x3b, 0x3d, 0x43, 0x47, 0x49, 0x4f, 0x53, 0x59,
-            0x61, 0x65, 0x67, 0x6b, 0x6d, 0x71, 0x7f, 0x83
-        },
-        /* Initializer for scalar[1], fe[1], first half of data, the X coordinate of ge[1],
-           and the (implied affine) X coordinate of gej[1]. */
-        {
-            0x82, 0x83, 0x85, 0x87, 0x8b, 0x8d, 0x81, 0x83,
-            0x97, 0xad, 0xaf, 0xb5, 0xb9, 0xbb, 0xbf, 0xc5,
-            0xdb, 0xdd, 0xe3, 0xe7, 0xe9, 0xef, 0xf3, 0xf9,
-            0x11, 0x15, 0x17, 0x1b, 0x1d, 0xb1, 0xbf, 0xd3
-        },
-        /* Initializer for fe[2] and the Z coordinate of gej[0]. */
-        {
-            0x3d, 0x2d, 0xef, 0xf4, 0x25, 0x98, 0x4f, 0x5d,
-            0xe2, 0xca, 0x5f, 0x41, 0x3f, 0x3f, 0xce, 0x44,
-            0xaa, 0x2c, 0x53, 0x8a, 0xc6, 0x59, 0x1f, 0x38,
-            0x38, 0x23, 0xe4, 0x11, 0x27, 0xc6, 0xa0, 0xe7
-        },
-        /* Initializer for fe[3] and the Z coordinate of gej[1]. */
-        {
-            0xbd, 0x21, 0xa5, 0xe1, 0x13, 0x50, 0x73, 0x2e,
-            0x52, 0x98, 0xc8, 0x9e, 0xab, 0x00, 0xa2, 0x68,
-            0x43, 0xf5, 0xd7, 0x49, 0x80, 0x72, 0xa7, 0xf3,
-            0xd7, 0x60, 0xe6, 0xab, 0x90, 0x92, 0xdf, 0xc5
-        }
-    };
-
-    secp256k1_scalar_set_b32(&data->scalar[0], init[0], NULL);
-    secp256k1_scalar_set_b32(&data->scalar[1], init[1], NULL);
-    secp256k1_fe_set_b32_limit(&data->fe[0], init[0]);
-    secp256k1_fe_set_b32_limit(&data->fe[1], init[1]);
-    secp256k1_fe_set_b32_limit(&data->fe[2], init[2]);
-    secp256k1_fe_set_b32_limit(&data->fe[3], init[3]);
-    CHECK(secp256k1_ge_set_xo_var(&data->ge[0], &data->fe[0], 0));
-    CHECK(secp256k1_ge_set_xo_var(&data->ge[1], &data->fe[1], 1));
-    secp256k1_gej_set_ge(&data->gej[0], &data->ge[0]);
-    secp256k1_gej_rescale(&data->gej[0], &data->fe[2]);
-    secp256k1_gej_set_ge(&data->gej[1], &data->ge[1]);
-    secp256k1_gej_rescale(&data->gej[1], &data->fe[3]);
-    memcpy(data->data, init[0], 32);
-    memcpy(data->data + 32, init[1], 32);
-}
-
-static void bench_scalar_add(void* arg, int iters) {
-    int i, j = 0;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        j += secp256k1_scalar_add(&data->scalar[0], &data->scalar[0], &data->scalar[1]);
-    }
-    CHECK(j <= iters);
-}
-
-static void bench_scalar_negate(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_scalar_negate(&data->scalar[0], &data->scalar[0]);
-    }
-}
-
-static void bench_scalar_mul(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_scalar_mul(&data->scalar[0], &data->scalar[0], &data->scalar[1]);
-    }
-}
-
-static void bench_scalar_split(void* arg, int iters) {
-    int i, j = 0;
-    bench_inv *data = (bench_inv*)arg;
-    secp256k1_scalar tmp;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_scalar_split_lambda(&tmp, &data->scalar[1], &data->scalar[0]);
-        j += secp256k1_scalar_add(&data->scalar[0], &tmp, &data->scalar[1]);
-    }
-    CHECK(j <= iters);
-}
-
-static void bench_scalar_inverse(void* arg, int iters) {
-    int i, j = 0;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_scalar_inverse(&data->scalar[0], &data->scalar[0]);
-        j += secp256k1_scalar_add(&data->scalar[0], &data->scalar[0], &data->scalar[1]);
-    }
-    CHECK(j <= iters);
-}
-
-static void bench_scalar_inverse_var(void* arg, int iters) {
-    int i, j = 0;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_scalar_inverse_var(&data->scalar[0], &data->scalar[0]);
-        j += secp256k1_scalar_add(&data->scalar[0], &data->scalar[0], &data->scalar[1]);
-    }
-    CHECK(j <= iters);
-}
-
-static void bench_field_half(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_fe_half(&data->fe[0]);
-    }
-}
-
-static void bench_field_normalize(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_fe_normalize(&data->fe[0]);
-    }
-}
-
-static void bench_field_normalize_weak(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_fe_normalize_weak(&data->fe[0]);
-    }
-}
-
-static void bench_field_mul(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_fe_mul(&data->fe[0], &data->fe[0], &data->fe[1]);
-    }
-}
-
-static void bench_field_sqr(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_fe_sqr(&data->fe[0], &data->fe[0]);
-    }
-}
-
-static void bench_field_inverse(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_fe_inv(&data->fe[0], &data->fe[0]);
-        secp256k1_fe_add(&data->fe[0], &data->fe[1]);
-    }
-}
-
-static void bench_field_inverse_var(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_fe_inv_var(&data->fe[0], &data->fe[0]);
-        secp256k1_fe_add(&data->fe[0], &data->fe[1]);
-    }
-}
-
-static void bench_field_sqrt(void* arg, int iters) {
-    int i, j = 0;
-    bench_inv *data = (bench_inv*)arg;
-    secp256k1_fe t;
-
-    for (i = 0; i < iters; i++) {
-        t = data->fe[0];
-        j += secp256k1_fe_sqrt(&data->fe[0], &t);
-        secp256k1_fe_add(&data->fe[0], &data->fe[1]);
-    }
-    CHECK(j <= iters);
-}
-
-static void bench_field_is_square_var(void* arg, int iters) {
-    int i, j = 0;
-    bench_inv *data = (bench_inv*)arg;
-    secp256k1_fe t = data->fe[0];
-
-    for (i = 0; i < iters; i++) {
-        j += secp256k1_fe_is_square_var(&t);
-        secp256k1_fe_add(&t, &data->fe[1]);
-        secp256k1_fe_normalize_var(&t);
-    }
-    CHECK(j <= iters);
-}
-
-static void bench_group_double_var(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_gej_double_var(&data->gej[0], &data->gej[0], NULL);
-    }
-}
-
-static void bench_group_add_var(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_gej_add_var(&data->gej[0], &data->gej[0], &data->gej[1], NULL);
-    }
-}
-
-static void bench_group_add_affine(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_gej_add_ge(&data->gej[0], &data->gej[0], &data->ge[1]);
-    }
-}
-
-static void bench_group_add_affine_var(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_gej_add_ge_var(&data->gej[0], &data->gej[0], &data->ge[1], NULL);
-    }
-}
-
-static void bench_group_add_zinv_var(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_gej_add_zinv_var(&data->gej[0], &data->gej[0], &data->ge[1], &data->gej[0].y);
-    }
-}
-
-static void bench_group_to_affine_var(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; ++i) {
-        secp256k1_ge_set_gej_var(&data->ge[1], &data->gej[0]);
-        /* Use the output affine X/Y coordinates to vary the input X/Y/Z coordinates.
-           Note that the resulting coordinates will generally not correspond to a point
-           on the curve, but this is not a problem for the code being benchmarked here.
-           Adding and normalizing have less overhead than EC operations (which could
-           guarantee the point remains on the curve). */
-        secp256k1_fe_add(&data->gej[0].x, &data->ge[1].y);
-        secp256k1_fe_add(&data->gej[0].y, &data->fe[2]);
-        secp256k1_fe_add(&data->gej[0].z, &data->ge[1].x);
-        secp256k1_fe_normalize_var(&data->gej[0].x);
-        secp256k1_fe_normalize_var(&data->gej[0].y);
-        secp256k1_fe_normalize_var(&data->gej[0].z);
-    }
-}
-
-static void bench_ecmult_wnaf(void* arg, int iters) {
-    int i, bits = 0, overflow = 0;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        bits += secp256k1_ecmult_wnaf(data->wnaf, 256, &data->scalar[0], WINDOW_A);
-        overflow += secp256k1_scalar_add(&data->scalar[0], &data->scalar[0], &data->scalar[1]);
-    }
-    CHECK(overflow >= 0);
-    CHECK(bits <= 256*iters);
-}
-
-static void bench_wnaf_const(void* arg, int iters) {
-    int i, bits = 0, overflow = 0;
-    bench_inv *data = (bench_inv*)arg;
-
-    for (i = 0; i < iters; i++) {
-        bits += secp256k1_wnaf_const(data->wnaf, &data->scalar[0], WINDOW_A, 256);
-        overflow += secp256k1_scalar_add(&data->scalar[0], &data->scalar[0], &data->scalar[1]);
-    }
-    CHECK(overflow >= 0);
-    CHECK(bits <= 256*iters);
-}
-
-static void bench_sha256(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-    secp256k1_sha256 sha;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_sha256_initialize(&sha);
-        secp256k1_sha256_write(&sha, data->data, 32);
-        secp256k1_sha256_finalize(&sha, data->data);
-    }
-}
-
-static void bench_hmac_sha256(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-    secp256k1_hmac_sha256 hmac;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_hmac_sha256_initialize(&hmac, data->data, 32);
-        secp256k1_hmac_sha256_write(&hmac, data->data, 32);
-        secp256k1_hmac_sha256_finalize(&hmac, data->data);
-    }
-}
-
-static void bench_rfc6979_hmac_sha256(void* arg, int iters) {
-    int i;
-    bench_inv *data = (bench_inv*)arg;
-    secp256k1_rfc6979_hmac_sha256 rng;
-
-    for (i = 0; i < iters; i++) {
-        secp256k1_rfc6979_hmac_sha256_initialize(&rng, data->data, 64);
-        secp256k1_rfc6979_hmac_sha256_generate(&rng, data->data, 32);
-    }
-}
-
-static void bench_context(void* arg, int iters) {
-    int i;
-    (void)arg;
-    for (i = 0; i < iters; i++) {
-        secp256k1_context_destroy(secp256k1_context_create(SECP256K1_CONTEXT_NONE));
-    }
-}
-
-int main(int argc, char **argv) {
-    bench_inv data;
-    int iters = get_iters(20000);
-    int d = argc == 1; /* default */
-    print_output_table_header_row();
-
-    if (d || have_flag(argc, argv, "scalar") || have_flag(argc, argv, "add")) run_benchmark("scalar_add", bench_scalar_add, bench_setup, NULL, &data, 10, iters*100);
-    if (d || have_flag(argc, argv, "scalar") || have_flag(argc, argv, "negate")) run_benchmark("scalar_negate", bench_scalar_negate, bench_setup, NULL, &data, 10, iters*100);
-    if (d || have_flag(argc, argv, "scalar") || have_flag(argc, argv, "mul")) run_benchmark("scalar_mul", bench_scalar_mul, bench_setup, NULL, &data, 10, iters*10);
-    if (d || have_flag(argc, argv, "scalar") || have_flag(argc, argv, "split")) run_benchmark("scalar_split", bench_scalar_split, bench_setup, NULL, &data, 10, iters);
-    if (d || have_flag(argc, argv, "scalar") || have_flag(argc, argv, "inverse")) run_benchmark("scalar_inverse", bench_scalar_inverse, bench_setup, NULL, &data, 10, iters);
-    if (d || have_flag(argc, argv, "scalar") || have_flag(argc, argv, "inverse")) run_benchmark("scalar_inverse_var", bench_scalar_inverse_var, bench_setup, NULL, &data, 10, iters);
-
-    if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "half")) run_benchmark("field_half", bench_field_half, bench_setup, NULL, &data, 10, iters*100);
-    if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "normalize")) run_benchmark("field_normalize", bench_field_normalize, bench_setup, NULL, &data, 10, iters*100);
-    if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "normalize")) run_benchmark("field_normalize_weak", bench_field_normalize_weak, bench_setup, NULL, &data, 10, iters*100);
-    if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "sqr")) run_benchmark("field_sqr", bench_field_sqr, bench_setup, NULL, &data, 10, iters*10);
-    if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "mul")) run_benchmark("field_mul", bench_field_mul, bench_setup, NULL, &data, 10, iters*10);
-    if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "inverse")) run_benchmark("field_inverse", bench_field_inverse, bench_setup, NULL, &data, 10, iters);
-    if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "inverse")) run_benchmark("field_inverse_var", bench_field_inverse_var, bench_setup, NULL, &data, 10, iters);
-    if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "issquare")) run_benchmark("field_is_square_var", bench_field_is_square_var, bench_setup, NULL, &data, 10, iters);
-    if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "sqrt")) run_benchmark("field_sqrt", bench_field_sqrt, bench_setup, NULL, &data, 10, iters);
-
-    if (d || have_flag(argc, argv, "group") || have_flag(argc, argv, "double")) run_benchmark("group_double_var", bench_group_double_var, bench_setup, NULL, &data, 10, iters*10);
-    if (d || have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_var", bench_group_add_var, bench_setup, NULL, &data, 10, iters*10);
-    if (d || have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_affine", bench_group_add_affine, bench_setup, NULL, &data, 10, iters*10);
-    if (d || have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_affine_var", bench_group_add_affine_var, bench_setup, NULL, &data, 10, iters*10);
-    if (d || have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_zinv_var", bench_group_add_zinv_var, bench_setup, NULL, &data, 10, iters*10);
-    if (d || have_flag(argc, argv, "group") || have_flag(argc, argv, "to_affine")) run_benchmark("group_to_affine_var", bench_group_to_affine_var, bench_setup, NULL, &data, 10, iters);
-
-    if (d || have_flag(argc, argv, "ecmult") || have_flag(argc, argv, "wnaf")) run_benchmark("wnaf_const", bench_wnaf_const, bench_setup, NULL, &data, 10, iters);
-    if (d || have_flag(argc, argv, "ecmult") || have_flag(argc, argv, "wnaf")) run_benchmark("ecmult_wnaf", bench_ecmult_wnaf, bench_setup, NULL, &data, 10, iters);
-
-    if (d || have_flag(argc, argv, "hash") || have_flag(argc, argv, "sha256")) run_benchmark("hash_sha256", bench_sha256, bench_setup, NULL, &data, 10, iters);
-    if (d || have_flag(argc, argv, "hash") || have_flag(argc, argv, "hmac")) run_benchmark("hash_hmac_sha256", bench_hmac_sha256, bench_setup, NULL, &data, 10, iters);
-    if (d || have_flag(argc, argv, "hash") || have_flag(argc, argv, "rng6979")) run_benchmark("hash_rfc6979_hmac_sha256", bench_rfc6979_hmac_sha256, bench_setup, NULL, &data, 10, iters);
-
-    if (d || have_flag(argc, argv, "context")) run_benchmark("context_create", bench_context, bench_setup, NULL, &data, 10, iters);
-
-    return 0;
-}