Re-install python3 after removal to solve unmet dependencies

This causes the Serai node to compile and run again.

.github/actions/bitcoin/action.yml

@@ -12,7 +12,7 @@ runs:
   steps:
     - name: Bitcoin Daemon Cache
       id: cache-bitcoind
-      uses: actions/cache@13aacd865c20de90d75de3b17ebe84f7a17d57d2
+      uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809
       with:
         path: bitcoin.tar.gz
         key: bitcoind-${{ runner.os }}-${{ runner.arch }}-${{ inputs.version }}

.github/actions/build-dependencies/action.yml

@@ -7,13 +7,15 @@ runs:
     - name: Remove unused packages
       shell: bash
       run: |
-        sudo apt remove -y "*msbuild*" "*powershell*" "*nuget*" "*bazel*" "*ansible*" "*terraform*" "*heroku*" "*aws*" azure-cli
+        sudo apt remove -y "*powershell*" "*nuget*" "*bazel*" "*ansible*" "*terraform*" "*heroku*" "*aws*" azure-cli
         sudo apt remove -y "*nodejs*" "*npm*" "*yarn*" "*java*" "*kotlin*" "*golang*" "*swift*" "*julia*" "*fortran*" "*android*"
         sudo apt remove -y "*apache2*" "*nginx*" "*firefox*" "*chromium*" "*chrome*" "*edge*"
+
+        sudo apt remove -y --allow-remove-essential -f shim-signed *python3*
+        # This removal command requires the prior removals due to unmet dependencies otherwise
         sudo apt remove -y "*qemu*" "*sql*" "*texinfo*" "*imagemagick*"
-        sudo apt autoremove -y
-        sudo apt clean
-        docker system prune -a --volumes
+        # Reinstall python3 as a general dependency of a functional operating system
+        sudo apt install python3
       if: runner.os == 'Linux'
 
     - name: Remove unused packages
@@ -41,9 +43,34 @@ runs:
     - name: Install solc
       shell: bash
       run: |
-        cargo install svm-rs
+        cargo +1.89 install svm-rs --version =0.5.18
         svm install 0.8.25
         svm use 0.8.25
 
+    - name: Remove preinstalled Docker
+      shell: bash
+      run: |
+        docker system prune -a --volumes
+        sudo apt remove -y *docker*
+        # Install uidmap which will be required for the explicitly installed Docker
+        sudo apt install uidmap
+      if: runner.os == 'Linux'
+
+    - name: Update system dependencies
+      shell: bash
+      run: |
+        sudo apt update -y
+        sudo apt upgrade -y
+        sudo apt autoremove -y
+        sudo apt clean
+      if: runner.os == 'Linux'
+
+    - name: Install rootless Docker
+      uses: docker/setup-docker-action@b60f85385d03ac8acfca6d9996982511d8620a19
+      with:
+        rootless: true
+        set-host: true
+      if: runner.os == 'Linux'
+
     # - name: Cache Rust
     #   uses: Swatinem/rust-cache@a95ba195448af2da9b00fb742d14ffaaf3c21f43

.github/actions/monero-wallet-rpc/action.yml

@@ -12,7 +12,7 @@ runs:
   steps:
     - name: Monero Wallet RPC Cache
       id: cache-monero-wallet-rpc
-      uses: actions/cache@13aacd865c20de90d75de3b17ebe84f7a17d57d2
+      uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809
       with:
         path: monero-wallet-rpc
         key: monero-wallet-rpc-${{ runner.os }}-${{ runner.arch }}-${{ inputs.version }}

.github/actions/monero/action.yml

@@ -12,7 +12,7 @@ runs:
   steps:
     - name: Monero Daemon Cache
       id: cache-monerod
-      uses: actions/cache@13aacd865c20de90d75de3b17ebe84f7a17d57d2
+      uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809
       with:
         path: /usr/bin/monerod
         key: monerod-${{ runner.os }}-${{ runner.arch }}-${{ inputs.version }}

.github/nightly-version

@@ -1 +1 @@
-nightly-2024-07-01
+nightly-2025-08-01

.github/workflows/daily-deny.yml

@@ -12,13 +12,13 @@ jobs:
       - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac
 
       - name: Advisory Cache
-        uses: actions/cache@13aacd865c20de90d75de3b17ebe84f7a17d57d2
+        uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809
         with:
           path: ~/.cargo/advisory-db
           key: rust-advisory-db
 
       - name: Install cargo deny
-        run: cargo install --locked cargo-deny
+        run: cargo +1.89 install cargo-deny --version =0.18.3
 
       - name: Run cargo deny
-        run: cargo deny -L error --all-features check
+        run: cargo deny -L error --all-features check --hide-inclusion-graph

.github/workflows/lint.yml

@@ -26,7 +26,7 @@ jobs:
         uses: ./.github/actions/build-dependencies
 
       - name: Install nightly rust
-        run: rustup toolchain install ${{ steps.nightly.outputs.version }} --profile minimal -t wasm32-unknown-unknown -c clippy
+        run: rustup toolchain install ${{ steps.nightly.outputs.version }} --profile minimal -t wasm32v1-none -c rust-src -c clippy
 
       - name: Run Clippy
         run: cargo +${{ steps.nightly.outputs.version }} clippy --all-features --all-targets -- -D warnings -A clippy::items_after_test_module
@@ -46,16 +46,16 @@ jobs:
       - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac
 
       - name: Advisory Cache
-        uses: actions/cache@13aacd865c20de90d75de3b17ebe84f7a17d57d2
+        uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809
         with:
           path: ~/.cargo/advisory-db
           key: rust-advisory-db
 
       - name: Install cargo deny
-        run: cargo install --locked cargo-deny
+        run: cargo +1.89 install cargo-deny --version =0.18.3
 
       - name: Run cargo deny
-        run: cargo deny -L error --all-features check
+        run: cargo deny -L error --all-features check --hide-inclusion-graph
 
   fmt:
     runs-on: ubuntu-latest
@@ -79,5 +79,5 @@ jobs:
       - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac
       - name: Verify all dependencies are in use
         run: |
-          cargo install cargo-machete
-          cargo machete
+          cargo +1.89 install cargo-machete --version =0.8.0
+          cargo +1.89 machete

.github/workflows/monero-tests.yaml

@@ -1,77 +0,0 @@
-name: Monero Tests
-
-on:
-  push:
-    branches:
-      - develop
-    paths:
-      - "networks/monero/**"
-      - "processor/**"
-
-  pull_request:
-    paths:
-      - "networks/monero/**"
-      - "processor/**"
-
-  workflow_dispatch:
-
-jobs:
-  # Only run these once since they will be consistent regardless of any node
-  unit-tests:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac
-
-      - name: Test Dependencies
-        uses: ./.github/actions/test-dependencies
-
-      - name: Run Unit Tests Without Features
-        run: |
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-io --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-generators --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-primitives --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-mlsag --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-clsag --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-borromean --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-bulletproofs --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-serai --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-rpc --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-simple-request-rpc --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-address --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-wallet --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-seed --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package polyseed --lib
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-wallet-util --lib
-
-      # Doesn't run unit tests with features as the tests workflow will
-
-  integration-tests:
-    runs-on: ubuntu-latest
-    # Test against all supported protocol versions
-    strategy:
-      matrix:
-        version: [v0.17.3.2, v0.18.3.4]
-
-    steps:
-      - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac
-
-      - name: Test Dependencies
-        uses: ./.github/actions/test-dependencies
-        with:
-          monero-version: ${{ matrix.version }}
-
-      - name: Run Integration Tests Without Features
-        run: |
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-serai --test '*'
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-simple-request-rpc --test '*'
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-wallet --test '*'
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-wallet-util --test '*'
-
-      - name: Run Integration Tests
-        # Don't run if the the tests workflow also will
-        if: ${{ matrix.version != 'v0.18.3.4' }}
-        run: |
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-serai --all-features --test '*'
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-simple-request-rpc --test '*'
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-wallet --all-features --test '*'
-          GITHUB_CI=true RUST_BACKTRACE=1 cargo test --package monero-wallet-util --all-features --test '*'

.github/workflows/networks-tests.yml

@@ -33,19 +33,3 @@ jobs:
             -p alloy-simple-request-transport \
             -p ethereum-serai \
             -p serai-ethereum-relayer \
-            -p monero-io \
-            -p monero-generators \
-            -p monero-primitives \
-            -p monero-mlsag \
-            -p monero-clsag \
-            -p monero-borromean \
-            -p monero-bulletproofs \
-            -p monero-serai \
-            -p monero-rpc \
-            -p monero-simple-request-rpc \
-            -p monero-address \
-            -p monero-wallet \
-            -p monero-seed \
-            -p polyseed \
-            -p monero-wallet-util \
-            -p monero-serai-verify-chain

.github/workflows/pages.yml

@@ -1,6 +1,7 @@
 # MIT License
 #
 # Copyright (c) 2022 just-the-docs
+# Copyright (c) 2022-2024 Luke Parker
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -20,31 +21,21 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-
-# Sample workflow for building and deploying a Jekyll site to GitHub Pages
-name: Deploy Jekyll site to Pages
+name: Deploy Rust docs and Jekyll site to Pages
 
 on:
   push:
     branches:
       - "develop"
-    paths:
-      - "docs/**"
 
-  # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
-# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
 permissions:
   contents: read
   pages: write
   id-token: write
 
-# Allow one concurrent deployment
+# Only allow one concurrent deployment
 concurrency:
   group: "pages"
   cancel-in-progress: true
@@ -53,9 +44,6 @@ jobs:
   # Build job
   build:
     runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: docs
     steps:
       - name: Checkout
         uses: actions/checkout@v3
@@ -69,11 +57,24 @@ jobs:
         id: pages
         uses: actions/configure-pages@v3
       - name: Build with Jekyll
-        run: bundle exec jekyll build --baseurl "${{ steps.pages.outputs.base_path }}"
+        run: cd ${{ github.workspace }}/docs && bundle exec jekyll build --baseurl "${{ steps.pages.outputs.base_path }}"
         env:
           JEKYLL_ENV: production
+
+      - name: Get nightly version to use
+        id: nightly
+        shell: bash
+        run: echo "version=$(cat .github/nightly-version)" >> $GITHUB_OUTPUT
+      - name: Build Dependencies
+        uses: ./.github/actions/build-dependencies
+      - name: Buld Rust docs
+        run: |
+          rustup toolchain install ${{ steps.nightly.outputs.version }} --profile minimal -t wasm32v1-none -c rust-docs
+          RUSTDOCFLAGS="--cfg docsrs" cargo +${{ steps.nightly.outputs.version }} doc --workspace --all-features
+          mv target/doc docs/_site/rust
+
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v1
+        uses: actions/upload-pages-artifact@v3
         with:
           path: "docs/_site/"
 
@@ -87,4 +88,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v2
+        uses: actions/deploy-pages@v4

Cargo.toml

@@ -43,23 +43,6 @@ members = [
   "networks/ethereum",
   "networks/ethereum/relayer",
 
-  "networks/monero/io",
-  "networks/monero/generators",
-  "networks/monero/primitives",
-  "networks/monero/ringct/mlsag",
-  "networks/monero/ringct/clsag",
-  "networks/monero/ringct/borromean",
-  "networks/monero/ringct/bulletproofs",
-  "networks/monero",
-  "networks/monero/rpc",
-  "networks/monero/rpc/simple-request",
-  "networks/monero/wallet/address",
-  "networks/monero/wallet",
-  "networks/monero/wallet/seed",
-  "networks/monero/wallet/polyseed",
-  "networks/monero/wallet/util",
-  "networks/monero/verify-chain",
-
   "message-queue",
 
   "processor/messages",
@@ -129,12 +112,20 @@ minimal-ed448 = { opt-level = 3 }
 
 multiexp = { opt-level = 3 }
 
-monero-serai = { opt-level = 3 }
+monero-oxide = { opt-level = 3 }
 
 [profile.release]
 panic = "unwind"
+overflow-checks = true
 
 [patch.crates-io]
+# Dependencies from monero-oxide which originate from within our own tree
+std-shims = { path = "common/std-shims" }
+simple-request = { path = "common/request" }
+dalek-ff-group = { path = "crypto/dalek-ff-group" }
+flexible-transcript = { path = "crypto/transcript" }
+modular-frost = { path = "crypto/frost" }
+
 # https://github.com/rust-lang-nursery/lazy-static.rs/issues/201
 lazy_static = { git = "https://github.com/rust-lang-nursery/lazy-static.rs", rev = "5735630d46572f1e5377c8f2ba0f79d18f53b10c" }
 
@@ -144,6 +135,9 @@ parking_lot = { path = "patches/parking_lot" }
 zstd = { path = "patches/zstd" }
 # Needed for WAL compression
 rocksdb = { path = "patches/rocksdb" }
+# 1.0.1 was yanked due to a breaking change (an extra field)
+# 2.0 has fewer dependencies and still works within our tree
+tiny-bip39 = { path = "patches/tiny-bip39" }
 
 # is-terminal now has an std-based solution with an equivalent API
 is-terminal = { path = "patches/is-terminal" }
@@ -158,11 +152,9 @@ matches = { path = "patches/matches" }
 option-ext = { path = "patches/option-ext" }
 directories-next = { path = "patches/directories-next" }
 
-# https://github.com/alloy-rs/core/issues/717
-alloy-sol-type-parser = { git = "https://github.com/alloy-rs/core", rev = "446b9d2fbce12b88456152170709a3eaac929af0" }
-
 [workspace.lints.clippy]
 unwrap_or_default = "allow"
+manual_is_multiple_of = "allow"
 borrow_as_ptr = "deny"
 cast_lossless = "deny"
 cast_possible_truncation = "deny"
@@ -187,14 +179,14 @@ large_stack_arrays = "deny"
 linkedlist = "deny"
 macro_use_imports = "deny"
 manual_instant_elapsed = "deny"
-manual_let_else = "deny"
+# TODO manual_let_else = "deny"
 manual_ok_or = "deny"
 manual_string_new = "deny"
 map_unwrap_or = "deny"
 match_bool = "deny"
 match_same_arms = "deny"
 missing_fields_in_debug = "deny"
-needless_continue = "deny"
+# TODO needless_continue = "deny"
 needless_pass_by_value = "deny"
 ptr_cast_constness = "deny"
 range_minus_one = "deny"
@@ -211,3 +203,20 @@ unnested_or_patterns = "deny"
 unused_async = "deny"
 unused_self = "deny"
 zero_sized_map_values = "deny"
+
+# TODO: These were incurred when updating Rust as necessary for compilation, yet aren't being fixed
+# at this time due to the impacts it'd have throughout the repository (when this isn't actively the
+# primary branch, `next` is)
+needless_continue = "allow"
+needless_lifetimes = "allow"
+useless_conversion = "allow"
+empty_line_after_doc_comments = "allow"
+manual_div_ceil = "allow"
+manual_let_else = "allow"
+unnecessary_map_or = "allow"
+result_large_err = "allow"
+unneeded_struct_pattern = "allow"
+[workspace.lints.rust]
+mismatched_lifetime_syntaxes = "allow"
+unused_attributes = "allow"
+unused-parens = "allow"

LICENSE

@@ -5,4 +5,4 @@ a full copy of the AGPL-3.0 License is included in the root of this repository
 as a reference text. This copy should be provided with any distribution of a
 crate licensed under the AGPL-3.0, as per its terms.
 
-The GitHub actions (`.github/actions`) are licensed under the MIT license.
+The GitHub actions/workflows (`.github`) are licensed under the MIT license.

README.md

@@ -59,7 +59,6 @@ issued at the discretion of the Immunefi program managers.
 - [Website](https://serai.exchange/): https://serai.exchange/
 - [Immunefi](https://immunefi.com/bounty/serai/): https://immunefi.com/bounty/serai/
 - [Twitter](https://twitter.com/SeraiDEX): https://twitter.com/SeraiDEX
-- [Mastodon](https://cryptodon.lol/@serai): https://cryptodon.lol/@serai
 - [Discord](https://discord.gg/mpEUtJR3vz): https://discord.gg/mpEUtJR3vz
 - [Matrix](https://matrix.to/#/#serai:matrix.org): https://matrix.to/#/#serai:matrix.org
 - [Reddit](https://www.reddit.com/r/SeraiDEX/): https://www.reddit.com/r/SeraiDEX/

common/std-shims/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "std-shims"
-version = "0.1.1"
+version = "0.1.2"
 description = "A series of std shims to make alloc more feasible"
 license = "MIT"
 repository = "https://github.com/serai-dex/serai/tree/develop/common/std-shims"
 authors = ["Luke Parker <lukeparker5132@gmail.com>"]
 keywords = ["nostd", "no_std", "alloc", "io"]
 edition = "2021"
-rust-version = "1.70"
+rust-version = "1.80"
 
 [package.metadata.docs.rs]
 all-features = true

coordinator/src/cosign_evaluator.rs

@@ -12,9 +12,9 @@ use tokio::{
 use borsh::BorshSerialize;
 use sp_application_crypto::RuntimePublic;
 use serai_client::{
-  primitives::{NETWORKS, NetworkId, Signature},
-  validator_sets::primitives::{Session, ValidatorSet},
-  SeraiError, TemporalSerai, Serai,
+  primitives::{ExternalNetworkId, Signature, EXTERNAL_NETWORKS},
+  validator_sets::primitives::{ExternalValidatorSet, Session},
+  Serai, SeraiError, TemporalSerai,
 };
 
 use serai_db::{Get, DbTxn, Db, create_db};
@@ -28,17 +28,17 @@ use crate::{
 
 create_db! {
   CosignDb {
-    ReceivedCosign: (set: ValidatorSet, block: [u8; 32]) -> CosignedBlock,
-    LatestCosign: (network: NetworkId) -> CosignedBlock,
-    DistinctChain: (set: ValidatorSet) -> (),
+    ReceivedCosign: (set: ExternalValidatorSet, block: [u8; 32]) -> CosignedBlock,
+    LatestCosign: (network: ExternalNetworkId) -> CosignedBlock,
+    DistinctChain: (set: ExternalValidatorSet) -> (),
   }
 }
 
 pub struct CosignEvaluator<D: Db> {
   db: Mutex<D>,
   serai: Arc<Serai>,
-  stakes: RwLock<Option<HashMap<NetworkId, u64>>>,
-  latest_cosigns: RwLock<HashMap<NetworkId, CosignedBlock>>,
+  stakes: RwLock<Option<HashMap<ExternalNetworkId, u64>>>,
+  latest_cosigns: RwLock<HashMap<ExternalNetworkId, CosignedBlock>>,
 }
 
 impl<D: Db> CosignEvaluator<D> {
@@ -79,7 +79,7 @@ impl<D: Db> CosignEvaluator<D> {
     let serai = self.serai.as_of_latest_finalized_block().await?;
 
     let mut stakes = HashMap::new();
-    for network in NETWORKS {
+    for network in EXTERNAL_NETWORKS {
       // Use if this network has published a Batch for a short-circuit of if they've ever set a key
       let set_key = serai.in_instructions().last_batch_for_network(network).await?.is_some();
       if set_key {
@@ -87,7 +87,7 @@ impl<D: Db> CosignEvaluator<D> {
           network,
           serai
             .validator_sets()
-            .total_allocated_stake(network)
+            .total_allocated_stake(network.into())
             .await?
             .expect("network which published a batch didn't have a stake set")
             .0,
@@ -126,9 +126,9 @@ impl<D: Db> CosignEvaluator<D> {
 
     async fn set_with_keys_fn(
       serai: &TemporalSerai<'_>,
-      network: NetworkId,
-    ) -> Result<Option<ValidatorSet>, SeraiError> {
-      let Some(latest_session) = serai.validator_sets().session(network).await? else {
+      network: ExternalNetworkId,
+    ) -> Result<Option<ExternalValidatorSet>, SeraiError> {
+      let Some(latest_session) = serai.validator_sets().session(network.into()).await? else {
         log::warn!("received cosign from {:?}, which doesn't yet have a session", network);
         return Ok(None);
       };
@@ -136,13 +136,13 @@ impl<D: Db> CosignEvaluator<D> {
       Ok(Some(
         if serai
           .validator_sets()
-          .keys(ValidatorSet { network, session: prior_session })
+          .keys(ExternalValidatorSet { network, session: prior_session })
           .await?
           .is_some()
         {
-          ValidatorSet { network, session: prior_session }
+          ExternalValidatorSet { network, session: prior_session }
         } else {
-          ValidatorSet { network, session: latest_session }
+          ExternalValidatorSet { network, session: latest_session }
         },
       ))
     }
@@ -204,16 +204,12 @@ impl<D: Db> CosignEvaluator<D> {
 
       let mut total_stake = 0;
       let mut total_on_distinct_chain = 0;
-      for network in NETWORKS {
-        if network == NetworkId::Serai {
-          continue;
-        }
-
+      for network in EXTERNAL_NETWORKS {
         // Get the current set for this network
         let set_with_keys = {
           let mut res;
           while {
-            res = set_with_keys_fn(&serai, cosign.network).await;
+            res = set_with_keys_fn(&serai, network).await;
             res.is_err()
           } {
             log::error!(
@@ -231,7 +227,8 @@ impl<D: Db> CosignEvaluator<D> {
           let stake = {
             let mut res;
             while {
-              res = serai.validator_sets().total_allocated_stake(set_with_keys.network).await;
+              res =
+                serai.validator_sets().total_allocated_stake(set_with_keys.network.into()).await;
               res.is_err()
             } {
               log::error!(
@@ -271,7 +268,7 @@ impl<D: Db> CosignEvaluator<D> {
   #[allow(clippy::new_ret_no_self)]
   pub fn new<P: P2p>(db: D, p2p: P, serai: Arc<Serai>) -> mpsc::UnboundedSender<CosignedBlock> {
     let mut latest_cosigns = HashMap::new();
-    for network in NETWORKS {
+    for network in EXTERNAL_NETWORKS {
       if let Some(cosign) = LatestCosign::get(&db, network) {
         latest_cosigns.insert(network, cosign);
       }

coordinator/src/db.rs

@@ -6,9 +6,9 @@ use blake2::{
 use scale::Encode;
 use borsh::{BorshSerialize, BorshDeserialize};
 use serai_client::{
-  primitives::NetworkId,
-  validator_sets::primitives::{Session, ValidatorSet},
   in_instructions::primitives::{Batch, SignedBatch},
+  primitives::ExternalNetworkId,
+  validator_sets::primitives::{ExternalValidatorSet, Session},
 };
 
 pub use serai_db::*;
@@ -18,21 +18,21 @@ use crate::tributary::{TributarySpec, Transaction, scanner::RecognizedIdType};
 
 create_db!(
   MainDb {
-    HandledMessageDb: (network: NetworkId) -> u64,
+    HandledMessageDb: (network: ExternalNetworkId) -> u64,
     ActiveTributaryDb: () -> Vec<u8>,
-    RetiredTributaryDb: (set: ValidatorSet) -> (),
+    RetiredTributaryDb: (set: ExternalValidatorSet) -> (),
     FirstPreprocessDb: (
-      network: NetworkId,
+      network: ExternalNetworkId,
       id_type: RecognizedIdType,
       id: &[u8]
     ) -> Vec<Vec<u8>>,
-    LastReceivedBatchDb: (network: NetworkId) -> u32,
-    ExpectedBatchDb: (network: NetworkId, id: u32) -> [u8; 32],
-    BatchDb: (network: NetworkId, id: u32)  -> SignedBatch,
-    LastVerifiedBatchDb: (network: NetworkId) -> u32,
-    HandoverBatchDb: (set: ValidatorSet) -> u32,
-    LookupHandoverBatchDb: (network: NetworkId, batch: u32) -> Session,
-    QueuedBatchesDb: (set: ValidatorSet) -> Vec<u8>
+    LastReceivedBatchDb: (network: ExternalNetworkId) -> u32,
+    ExpectedBatchDb: (network: ExternalNetworkId, id: u32) -> [u8; 32],
+    BatchDb: (network: ExternalNetworkId, id: u32)  -> SignedBatch,
+    LastVerifiedBatchDb: (network: ExternalNetworkId) -> u32,
+    HandoverBatchDb: (set: ExternalValidatorSet) -> u32,
+    LookupHandoverBatchDb: (network: ExternalNetworkId, batch: u32) -> Session,
+    QueuedBatchesDb: (set: ExternalValidatorSet) -> Vec<u8>
   }
 );
 
@@ -61,7 +61,7 @@ impl ActiveTributaryDb {
     ActiveTributaryDb::set(txn, &existing_bytes);
   }
 
-  pub fn retire_tributary(txn: &mut impl DbTxn, set: ValidatorSet) {
+  pub fn retire_tributary(txn: &mut impl DbTxn, set: ExternalValidatorSet) {
     let mut active = Self::active_tributaries(txn).1;
     for i in 0 .. active.len() {
       if active[i].set() == set {
@@ -82,7 +82,7 @@ impl ActiveTributaryDb {
 impl FirstPreprocessDb {
   pub fn save_first_preprocess(
     txn: &mut impl DbTxn,
-    network: NetworkId,
+    network: ExternalNetworkId,
     id_type: RecognizedIdType,
     id: &[u8],
     preprocess: &Vec<Vec<u8>>,
@@ -108,19 +108,19 @@ impl ExpectedBatchDb {
 }
 
 impl HandoverBatchDb {
-  pub fn set_handover_batch(txn: &mut impl DbTxn, set: ValidatorSet, batch: u32) {
+  pub fn set_handover_batch(txn: &mut impl DbTxn, set: ExternalValidatorSet, batch: u32) {
     Self::set(txn, set, &batch);
     LookupHandoverBatchDb::set(txn, set.network, batch, &set.session);
   }
 }
 impl QueuedBatchesDb {
-  pub fn queue(txn: &mut impl DbTxn, set: ValidatorSet, batch: &Transaction) {
+  pub fn queue(txn: &mut impl DbTxn, set: ExternalValidatorSet, batch: &Transaction) {
     let mut batches = Self::get(txn, set).unwrap_or_default();
     batch.write(&mut batches).unwrap();
     Self::set(txn, set, &batches);
   }
 
-  pub fn take(txn: &mut impl DbTxn, set: ValidatorSet) -> Vec<Transaction> {
+  pub fn take(txn: &mut impl DbTxn, set: ExternalValidatorSet) -> Vec<Transaction> {
     let batches_vec = Self::get(txn, set).unwrap_or_default();
     txn.del(Self::key(set));
 

coordinator/src/main.rs

@@ -23,8 +23,8 @@ use serai_db::{DbTxn, Db};
 use scale::Encode;
 use borsh::BorshSerialize;
 use serai_client::{
-  primitives::NetworkId,
-  validator_sets::primitives::{Session, ValidatorSet, KeyPair},
+  primitives::ExternalNetworkId,
+  validator_sets::primitives::{ExternalValidatorSet, KeyPair, Session},
   Public, Serai, SeraiInInstructions,
 };
 
@@ -79,7 +79,7 @@ pub struct ActiveTributary<D: Db, P: P2p> {
 #[derive(Clone)]
 pub enum TributaryEvent<D: Db, P: P2p> {
   NewTributary(ActiveTributary<D, P>),
-  TributaryRetired(ValidatorSet),
+  TributaryRetired(ExternalValidatorSet),
 }
 
 // Creates a new tributary and sends it to all listeners.
@@ -145,7 +145,7 @@ async fn handle_processor_message<D: Db, P: P2p>(
   p2p: &P,
   cosign_channel: &mpsc::UnboundedSender<CosignedBlock>,
   tributaries: &HashMap<Session, ActiveTributary<D, P>>,
-  network: NetworkId,
+  network: ExternalNetworkId,
   msg: &processors::Message,
 ) -> bool {
   #[allow(clippy::nonminimal_bool)]
@@ -193,7 +193,8 @@ async fn handle_processor_message<D: Db, P: P2p>(
           .iter()
           .map(|plan| plan.session)
           .filter(|session| {
-            RetiredTributaryDb::get(&txn, ValidatorSet { network, session: *session }).is_none()
+            RetiredTributaryDb::get(&txn, ExternalValidatorSet { network, session: *session })
+              .is_none()
           })
           .collect::<HashSet<_>>();
 
@@ -265,7 +266,7 @@ async fn handle_processor_message<D: Db, P: P2p>(
       }
       // This causes an action on Substrate yet not on any Tributary
       coordinator::ProcessorMessage::SignedSlashReport { session, signature } => {
-        let set = ValidatorSet { network, session: *session };
+        let set = ExternalValidatorSet { network, session: *session };
         let signature: &[u8] = signature.as_ref();
         let signature = serai_client::Signature(signature.try_into().unwrap());
 
@@ -393,7 +394,7 @@ async fn handle_processor_message<D: Db, P: P2p>(
   if let Some(relevant_tributary_value) = relevant_tributary {
     if RetiredTributaryDb::get(
       &txn,
-      ValidatorSet { network: msg.network, session: relevant_tributary_value },
+      ExternalValidatorSet { network: msg.network, session: relevant_tributary_value },
     )
     .is_some()
     {
@@ -782,7 +783,7 @@ async fn handle_processor_messages<D: Db, Pro: Processors, P: P2p>(
   processors: Pro,
   p2p: P,
   cosign_channel: mpsc::UnboundedSender<CosignedBlock>,
-  network: NetworkId,
+  network: ExternalNetworkId,
   mut tributary_event: mpsc::UnboundedReceiver<TributaryEvent<D, P>>,
 ) {
   let mut tributaries = HashMap::new();
@@ -831,7 +832,7 @@ async fn handle_processor_messages<D: Db, Pro: Processors, P: P2p>(
 #[allow(clippy::too_many_arguments)]
 async fn handle_cosigns_and_batch_publication<D: Db, P: P2p>(
   mut db: D,
-  network: NetworkId,
+  network: ExternalNetworkId,
   mut tributary_event: mpsc::UnboundedReceiver<TributaryEvent<D, P>>,
 ) {
   let mut tributaries = HashMap::new();
@@ -905,7 +906,7 @@ async fn handle_cosigns_and_batch_publication<D: Db, P: P2p>(
         for batch in start_id ..= last_id {
           let is_pre_handover = LookupHandoverBatchDb::get(&txn, network, batch + 1);
           if let Some(session) = is_pre_handover {
-            let set = ValidatorSet { network, session };
+            let set = ExternalValidatorSet { network, session };
             let mut queued = QueuedBatchesDb::take(&mut txn, set);
             // is_handover_batch is only set for handover `Batch`s we're participating in, making
             // this safe
@@ -923,7 +924,8 @@ async fn handle_cosigns_and_batch_publication<D: Db, P: P2p>(
 
           let is_handover = LookupHandoverBatchDb::get(&txn, network, batch);
           if let Some(session) = is_handover {
-            for queued in QueuedBatchesDb::take(&mut txn, ValidatorSet { network, session }) {
+            for queued in QueuedBatchesDb::take(&mut txn, ExternalValidatorSet { network, session })
+            {
               to_publish.push((session, queued));
             }
           }
@@ -970,10 +972,7 @@ pub async fn handle_processors<D: Db, Pro: Processors, P: P2p>(
   mut tributary_event: broadcast::Receiver<TributaryEvent<D, P>>,
 ) {
   let mut channels = HashMap::new();
-  for network in serai_client::primitives::NETWORKS {
-    if network == NetworkId::Serai {
-      continue;
-    }
+  for network in serai_client::primitives::EXTERNAL_NETWORKS {
     let (processor_send, processor_recv) = mpsc::unbounded_channel();
     tokio::spawn(handle_processor_messages(
       db.clone(),
@@ -1195,7 +1194,7 @@ pub async fn run<D: Db, Pro: Processors, P: P2p>(
       }
     });
 
-    move |set: ValidatorSet, genesis, id_type, id: Vec<u8>| {
+    move |set: ExternalValidatorSet, genesis, id_type, id: Vec<u8>| {
       log::debug!("recognized ID {:?} {}", id_type, hex::encode(&id));
       let mut raw_db = raw_db.clone();
       let key = key.clone();

coordinator/src/p2p.rs

@@ -11,7 +11,9 @@ use rand_core::{RngCore, OsRng};
 
 use scale::{Decode, Encode};
 use borsh::{BorshSerialize, BorshDeserialize};
-use serai_client::{primitives::NetworkId, validator_sets::primitives::ValidatorSet, Serai};
+use serai_client::{
+  primitives::ExternalNetworkId, validator_sets::primitives::ExternalValidatorSet, Serai,
+};
 
 use serai_db::Db;
 
@@ -69,7 +71,7 @@ const BLOCKS_PER_BATCH: usize = BLOCKS_PER_MINUTE + 1;
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, BorshSerialize, BorshDeserialize)]
 pub struct CosignedBlock {
-  pub network: NetworkId,
+  pub network: ExternalNetworkId,
   pub block_number: u64,
   pub block: [u8; 32],
   pub signature: [u8; 64],
@@ -208,8 +210,8 @@ pub struct HeartbeatBatch {
 pub trait P2p: Send + Sync + Clone + fmt::Debug + TributaryP2p {
   type Id: Send + Sync + Clone + Copy + fmt::Debug;
 
-  async fn subscribe(&self, set: ValidatorSet, genesis: [u8; 32]);
-  async fn unsubscribe(&self, set: ValidatorSet, genesis: [u8; 32]);
+  async fn subscribe(&self, set: ExternalValidatorSet, genesis: [u8; 32]);
+  async fn unsubscribe(&self, set: ExternalValidatorSet, genesis: [u8; 32]);
 
   async fn send_raw(&self, to: Self::Id, msg: Vec<u8>);
   async fn broadcast_raw(&self, kind: P2pMessageKind, msg: Vec<u8>);
@@ -309,7 +311,7 @@ struct Behavior {
 #[allow(clippy::type_complexity)]
 #[derive(Clone)]
 pub struct LibP2p {
-  subscribe: Arc<Mutex<mpsc::UnboundedSender<(bool, ValidatorSet, [u8; 32])>>>,
+  subscribe: Arc<Mutex<mpsc::UnboundedSender<(bool, ExternalValidatorSet, [u8; 32])>>>,
   send: Arc<Mutex<mpsc::UnboundedSender<(PeerId, Vec<u8>)>>>,
   broadcast: Arc<Mutex<mpsc::UnboundedSender<(P2pMessageKind, Vec<u8>)>>>,
   receive: Arc<Mutex<mpsc::UnboundedReceiver<Message<Self>>>>,
@@ -397,7 +399,7 @@ impl LibP2p {
     let (receive_send, receive_recv) = mpsc::unbounded_channel();
     let (subscribe_send, mut subscribe_recv) = mpsc::unbounded_channel();
 
-    fn topic_for_set(set: ValidatorSet) -> IdentTopic {
+    fn topic_for_set(set: ExternalValidatorSet) -> IdentTopic {
       IdentTopic::new(format!("{LIBP2P_TOPIC}-{}", hex::encode(set.encode())))
     }
 
@@ -407,7 +409,8 @@ impl LibP2p {
     // The addrs we're currently dialing, and the networks associated with them
     let dialing_peers = Arc::new(RwLock::new(HashMap::new()));
     // The peers we're currently connected to, and the networks associated with them
-    let connected_peers = Arc::new(RwLock::new(HashMap::<Multiaddr, HashSet<NetworkId>>::new()));
+    let connected_peers =
+      Arc::new(RwLock::new(HashMap::<Multiaddr, HashSet<ExternalNetworkId>>::new()));
 
     // Find and connect to peers
     let (connect_to_network_send, mut connect_to_network_recv) =
@@ -420,7 +423,7 @@ impl LibP2p {
       let connect_to_network_send = connect_to_network_send.clone();
       async move {
         loop {
-          let connect = |network: NetworkId, addr: Multiaddr| {
+          let connect = |network: ExternalNetworkId, addr: Multiaddr| {
             let dialing_peers = dialing_peers.clone();
             let connected_peers = connected_peers.clone();
             let to_dial_send = to_dial_send.clone();
@@ -507,7 +510,7 @@ impl LibP2p {
             connect_to_network_networks.insert(network);
           }
           for network in connect_to_network_networks {
-            if let Ok(mut nodes) = serai.p2p_validators(network).await {
+            if let Ok(mut nodes) = serai.p2p_validators(network.into()).await {
               // If there's an insufficient amount of nodes known, connect to all yet add it
               // back and break
               if nodes.len() < TARGET_PEERS {
@@ -557,7 +560,7 @@ impl LibP2p {
 
             // Subscribe to any new topics
             set = subscribe_recv.recv() => {
-              let (subscribe, set, genesis): (_, ValidatorSet, [u8; 32]) =
+              let (subscribe, set, genesis): (_, ExternalValidatorSet, [u8; 32]) =
                 set.expect("subscribe_recv closed. are we shutting down?");
               let topic = topic_for_set(set);
               if subscribe {
@@ -776,7 +779,7 @@ impl LibP2p {
 impl P2p for LibP2p {
   type Id = PeerId;
 
-  async fn subscribe(&self, set: ValidatorSet, genesis: [u8; 32]) {
+  async fn subscribe(&self, set: ExternalValidatorSet, genesis: [u8; 32]) {
     self
       .subscribe
       .lock()
@@ -785,7 +788,7 @@ impl P2p for LibP2p {
       .expect("subscribe_send closed. are we shutting down?");
   }
 
-  async fn unsubscribe(&self, set: ValidatorSet, genesis: [u8; 32]) {
+  async fn unsubscribe(&self, set: ExternalValidatorSet, genesis: [u8; 32]) {
     self
       .subscribe
       .lock()

coordinator/src/processors.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use serai_client::primitives::NetworkId;
+use serai_client::primitives::ExternalNetworkId;
 use processor_messages::{ProcessorMessage, CoordinatorMessage};
 
 use message_queue::{Service, Metadata, client::MessageQueue};
@@ -8,27 +8,27 @@ use message_queue::{Service, Metadata, client::MessageQueue};
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Message {
   pub id: u64,
-  pub network: NetworkId,
+  pub network: ExternalNetworkId,
   pub msg: ProcessorMessage,
 }
 
 #[async_trait::async_trait]
 pub trait Processors: 'static + Send + Sync + Clone {
-  async fn send(&self, network: NetworkId, msg: impl Send + Into<CoordinatorMessage>);
-  async fn recv(&self, network: NetworkId) -> Message;
+  async fn send(&self, network: ExternalNetworkId, msg: impl Send + Into<CoordinatorMessage>);
+  async fn recv(&self, network: ExternalNetworkId) -> Message;
   async fn ack(&self, msg: Message);
 }
 
 #[async_trait::async_trait]
 impl Processors for Arc<MessageQueue> {
-  async fn send(&self, network: NetworkId, msg: impl Send + Into<CoordinatorMessage>) {
+  async fn send(&self, network: ExternalNetworkId, msg: impl Send + Into<CoordinatorMessage>) {
     let msg: CoordinatorMessage = msg.into();
     let metadata =
       Metadata { from: self.service, to: Service::Processor(network), intent: msg.intent() };
     let msg = borsh::to_vec(&msg).unwrap();
     self.queue(metadata, msg).await;
   }
-  async fn recv(&self, network: NetworkId) -> Message {
+  async fn recv(&self, network: ExternalNetworkId) -> Message {
     let msg = self.next(Service::Processor(network)).await;
     assert_eq!(msg.from, Service::Processor(network));
 

coordinator/src/substrate/cosign.rs

@@ -19,9 +19,9 @@ use ciphersuite::{Ciphersuite, Ristretto};
 use borsh::{BorshSerialize, BorshDeserialize};
 
 use serai_client::{
-  SeraiError, Serai,
-  primitives::NetworkId,
-  validator_sets::primitives::{Session, ValidatorSet},
+  primitives::ExternalNetworkId,
+  validator_sets::primitives::{ExternalValidatorSet, Session},
+  Serai, SeraiError,
 };
 
 use serai_db::*;
@@ -70,13 +70,18 @@ impl LatestCosignedBlock {
 
 db_channel! {
   SubstrateDbChannels {
-    CosignTransactions: (network: NetworkId) -> (Session, u64, [u8; 32]),
+    CosignTransactions: (network: ExternalNetworkId) -> (Session, u64, [u8; 32]),
   }
 }
 
 impl CosignTransactions {
   // Append a cosign transaction.
-  pub fn append_cosign(txn: &mut impl DbTxn, set: ValidatorSet, number: u64, hash: [u8; 32]) {
+  pub fn append_cosign(
+    txn: &mut impl DbTxn,
+    set: ExternalValidatorSet,
+    number: u64,
+    hash: [u8; 32],
+  ) {
     CosignTransactions::send(txn, set.network, &(set.session, number, hash))
   }
 }
@@ -256,22 +261,22 @@ async fn advance_cosign_protocol_inner(
       // Using the keys of the prior block ensures this deadlock isn't reached
       let serai = serai.as_of(actual_block.header.parent_hash.into());
 
-      for network in serai_client::primitives::NETWORKS {
+      for network in serai_client::primitives::EXTERNAL_NETWORKS {
         // Get the latest session to have set keys
         let set_with_keys = {
-          let Some(latest_session) = serai.validator_sets().session(network).await? else {
+          let Some(latest_session) = serai.validator_sets().session(network.into()).await? else {
             continue;
           };
           let prior_session = Session(latest_session.0.saturating_sub(1));
           if serai
             .validator_sets()
-            .keys(ValidatorSet { network, session: prior_session })
+            .keys(ExternalValidatorSet { network, session: prior_session })
             .await?
             .is_some()
           {
-            ValidatorSet { network, session: prior_session }
+            ExternalValidatorSet { network, session: prior_session }
           } else {
-            let set = ValidatorSet { network, session: latest_session };
+            let set = ExternalValidatorSet { network, session: latest_session };
             if serai.validator_sets().keys(set).await?.is_none() {
               continue;
             }
@@ -280,7 +285,7 @@ async fn advance_cosign_protocol_inner(
         };
 
         log::debug!("{:?} will be cosigning {block}", set_with_keys.network);
-        cosigning.push((set_with_keys, in_set(key, &serai, set_with_keys).await?.unwrap()));
+        cosigning.push((set_with_keys, in_set(key, &serai, set_with_keys.into()).await?.unwrap()));
       }
 
       break;

coordinator/src/substrate/db.rs

@@ -1,4 +1,4 @@
-use serai_client::primitives::NetworkId;
+use serai_client::primitives::ExternalNetworkId;
 
 pub use serai_db::*;
 
@@ -9,7 +9,7 @@ mod inner_db {
     SubstrateDb {
       NextBlock: () -> u64,
       HandledEvent: (block: [u8; 32]) -> u32,
-      BatchInstructionsHashDb: (network: NetworkId, id: u32) -> [u8; 32]
+      BatchInstructionsHashDb: (network: ExternalNetworkId, id: u32) -> [u8; 32]
     }
   );
 }

coordinator/src/substrate/mod.rs

@@ -9,11 +9,14 @@ use zeroize::Zeroizing;
 use ciphersuite::{group::GroupEncoding, Ciphersuite, Ristretto};
 
 use serai_client::{
-  SeraiError, Block, Serai, TemporalSerai,
-  primitives::{BlockHash, NetworkId},
-  validator_sets::{primitives::ValidatorSet, ValidatorSetsEvent},
-  in_instructions::InInstructionsEvent,
   coins::CoinsEvent,
+  in_instructions::InInstructionsEvent,
+  primitives::{BlockHash, ExternalNetworkId},
+  validator_sets::{
+    primitives::{ExternalValidatorSet, ValidatorSet},
+    ValidatorSetsEvent,
+  },
+  Block, Serai, SeraiError, TemporalSerai,
 };
 
 use serai_db::DbTxn;
@@ -52,9 +55,9 @@ async fn handle_new_set<D: Db>(
   new_tributary_spec: &mpsc::UnboundedSender<TributarySpec>,
   serai: &Serai,
   block: &Block,
-  set: ValidatorSet,
+  set: ExternalValidatorSet,
 ) -> Result<(), SeraiError> {
-  if in_set(key, &serai.as_of(block.hash()), set)
+  if in_set(key, &serai.as_of(block.hash()), set.into())
     .await?
     .expect("NewSet for set which doesn't exist")
   {
@@ -64,7 +67,7 @@ async fn handle_new_set<D: Db>(
       let serai = serai.as_of(block.hash());
       let serai = serai.validator_sets();
       let set_participants =
-        serai.participants(set.network).await?.expect("NewSet for set which doesn't exist");
+        serai.participants(set.network.into()).await?.expect("NewSet for set which doesn't exist");
 
       set_participants.into_iter().map(|(k, w)| (k, u16::try_from(w).unwrap())).collect::<Vec<_>>()
     };
@@ -131,7 +134,7 @@ async fn handle_batch_and_burns<Pro: Processors>(
   };
 
   let mut batch_block = HashMap::new();
-  let mut batches = HashMap::<NetworkId, Vec<u32>>::new();
+  let mut batches = HashMap::<ExternalNetworkId, Vec<u32>>::new();
   let mut burns = HashMap::new();
 
   let serai = serai.as_of(block.hash());
@@ -205,8 +208,8 @@ async fn handle_block<D: Db, Pro: Processors>(
   db: &mut D,
   key: &Zeroizing<<Ristretto as Ciphersuite>::F>,
   new_tributary_spec: &mpsc::UnboundedSender<TributarySpec>,
-  perform_slash_report: &mpsc::UnboundedSender<ValidatorSet>,
-  tributary_retired: &mpsc::UnboundedSender<ValidatorSet>,
+  perform_slash_report: &mpsc::UnboundedSender<ExternalValidatorSet>,
+  tributary_retired: &mpsc::UnboundedSender<ExternalValidatorSet>,
   processors: &Pro,
   serai: &Serai,
   block: Block,
@@ -226,12 +229,8 @@ async fn handle_block<D: Db, Pro: Processors>(
       panic!("NewSet event wasn't NewSet: {new_set:?}");
     };
 
-    // If this is Serai, do nothing
     // We only coordinate/process external networks
-    if set.network == NetworkId::Serai {
-      continue;
-    }
-
+    let Ok(set) = ExternalValidatorSet::try_from(set) else { continue };
     if HandledEvent::is_unhandled(db, hash, event_id) {
       log::info!("found fresh new set event {:?}", new_set);
       let mut txn = db.txn();
@@ -286,10 +285,7 @@ async fn handle_block<D: Db, Pro: Processors>(
       panic!("AcceptedHandover event wasn't AcceptedHandover: {accepted_handover:?}");
     };
 
-    if set.network == NetworkId::Serai {
-      continue;
-    }
-
+    let Ok(set) = ExternalValidatorSet::try_from(set) else { continue };
     if HandledEvent::is_unhandled(db, hash, event_id) {
       log::info!("found fresh accepted handover event {:?}", accepted_handover);
       // TODO: This isn't atomic with the event handling
@@ -307,10 +303,7 @@ async fn handle_block<D: Db, Pro: Processors>(
       panic!("SetRetired event wasn't SetRetired: {retired_set:?}");
     };
 
-    if set.network == NetworkId::Serai {
-      continue;
-    }
-
+    let Ok(set) = ExternalValidatorSet::try_from(set) else { continue };
     if HandledEvent::is_unhandled(db, hash, event_id) {
       log::info!("found fresh set retired event {:?}", retired_set);
       let mut txn = db.txn();
@@ -340,8 +333,8 @@ async fn handle_new_blocks<D: Db, Pro: Processors>(
   db: &mut D,
   key: &Zeroizing<<Ristretto as Ciphersuite>::F>,
   new_tributary_spec: &mpsc::UnboundedSender<TributarySpec>,
-  perform_slash_report: &mpsc::UnboundedSender<ValidatorSet>,
-  tributary_retired: &mpsc::UnboundedSender<ValidatorSet>,
+  perform_slash_report: &mpsc::UnboundedSender<ExternalValidatorSet>,
+  tributary_retired: &mpsc::UnboundedSender<ExternalValidatorSet>,
   processors: &Pro,
   serai: &Serai,
   next_block: &mut u64,
@@ -395,8 +388,8 @@ pub async fn scan_task<D: Db, Pro: Processors>(
   processors: Pro,
   serai: Arc<Serai>,
   new_tributary_spec: mpsc::UnboundedSender<TributarySpec>,
-  perform_slash_report: mpsc::UnboundedSender<ValidatorSet>,
-  tributary_retired: mpsc::UnboundedSender<ValidatorSet>,
+  perform_slash_report: mpsc::UnboundedSender<ExternalValidatorSet>,
+  tributary_retired: mpsc::UnboundedSender<ExternalValidatorSet>,
 ) {
   log::info!("scanning substrate");
   let mut next_substrate_block = NextBlock::get(&db).unwrap_or_default();
@@ -494,9 +487,12 @@ pub async fn scan_task<D: Db, Pro: Processors>(
 /// retry.
 pub(crate) async fn expected_next_batch(
   serai: &Serai,
-  network: NetworkId,
+  network: ExternalNetworkId,
 ) -> Result<u32, SeraiError> {
-  async fn expected_next_batch_inner(serai: &Serai, network: NetworkId) -> Result<u32, SeraiError> {
+  async fn expected_next_batch_inner(
+    serai: &Serai,
+    network: ExternalNetworkId,
+  ) -> Result<u32, SeraiError> {
     let serai = serai.as_of_latest_finalized_block().await?;
     let last = serai.in_instructions().last_batch_for_network(network).await?;
     Ok(if let Some(last) = last { last + 1 } else { 0 })
@@ -519,7 +515,7 @@ pub(crate) async fn expected_next_batch(
 /// This is deemed fine.
 pub(crate) async fn verify_published_batches<D: Db>(
   txn: &mut D::Transaction<'_>,
-  network: NetworkId,
+  network: ExternalNetworkId,
   optimistic_up_to: u32,
 ) -> Option<u32> {
   // TODO: Localize from MainDb to SubstrateDb

coordinator/src/tests/mod.rs

@@ -4,7 +4,7 @@ use std::{
   collections::{VecDeque, HashSet, HashMap},
 };
 
-use serai_client::{primitives::NetworkId, validator_sets::primitives::ValidatorSet};
+use serai_client::{primitives::ExternalNetworkId, validator_sets::primitives::ExternalValidatorSet};
 
 use processor_messages::CoordinatorMessage;
 
@@ -20,7 +20,7 @@ use crate::{
 pub mod tributary;
 
 #[derive(Clone)]
-pub struct MemProcessors(pub Arc<RwLock<HashMap<NetworkId, VecDeque<CoordinatorMessage>>>>);
+pub struct MemProcessors(pub Arc<RwLock<HashMap<ExternalNetworkId, VecDeque<CoordinatorMessage>>>>);
 impl MemProcessors {
   #[allow(clippy::new_without_default)]
   pub fn new() -> MemProcessors {
@@ -30,12 +30,12 @@ impl MemProcessors {
 
 #[async_trait::async_trait]
 impl Processors for MemProcessors {
-  async fn send(&self, network: NetworkId, msg: impl Send + Into<CoordinatorMessage>) {
+  async fn send(&self, network: ExternalNetworkId, msg: impl Send + Into<CoordinatorMessage>) {
     let mut processors = self.0.write().await;
     let processor = processors.entry(network).or_insert_with(VecDeque::new);
     processor.push_back(msg.into());
   }
-  async fn recv(&self, _: NetworkId) -> Message {
+  async fn recv(&self, _: ExternalNetworkId) -> Message {
     todo!()
   }
   async fn ack(&self, _: Message) {
@@ -65,8 +65,8 @@ impl LocalP2p {
 impl P2p for LocalP2p {
   type Id = usize;
 
-  async fn subscribe(&self, _set: ValidatorSet, _genesis: [u8; 32]) {}
-  async fn unsubscribe(&self, _set: ValidatorSet, _genesis: [u8; 32]) {}
+  async fn subscribe(&self, _set: ExternalValidatorSet, _genesis: [u8; 32]) {}
+  async fn unsubscribe(&self, _set: ExternalValidatorSet, _genesis: [u8; 32]) {}
 
   async fn send_raw(&self, to: Self::Id, msg: Vec<u8>) {
     let mut msg_ref = msg.as_slice();

coordinator/src/tests/tributary/chain.rs

@@ -15,8 +15,8 @@ use ciphersuite::{
 use sp_application_crypto::sr25519;
 use borsh::BorshDeserialize;
 use serai_client::{
-  primitives::NetworkId,
-  validator_sets::primitives::{Session, ValidatorSet},
+  primitives::ExternalNetworkId,
+  validator_sets::primitives::{ExternalValidatorSet, Session},
 };
 
 use tokio::time::sleep;
@@ -50,7 +50,7 @@ pub fn new_spec<R: RngCore + CryptoRng>(
 
   let start_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs();
 
-  let set = ValidatorSet { session: Session(0), network: NetworkId::Bitcoin };
+  let set = ExternalValidatorSet { session: Session(0), network: ExternalNetworkId::Bitcoin };
 
   let set_participants = keys
     .iter()

coordinator/src/tests/tributary/dkg.rs

@@ -10,7 +10,7 @@ use frost::Participant;
 use sp_runtime::traits::Verify;
 use serai_client::{
   primitives::{SeraiAddress, Signature},
-  validator_sets::primitives::{ValidatorSet, KeyPair},
+  validator_sets::primitives::{ExternalValidatorSet, KeyPair},
 };
 
 use tokio::time::sleep;
@@ -350,7 +350,7 @@ async fn dkg_test() {
     async fn publish_set_keys(
       &self,
       _db: &(impl Sync + Get),
-      set: ValidatorSet,
+      set: ExternalValidatorSet,
       removed: Vec<SeraiAddress>,
       key_pair: KeyPair,
       signature: Signature,
@@ -362,7 +362,7 @@ async fn dkg_test() {
         &*serai_client::validator_sets::primitives::set_keys_message(&set, &[], &key_pair),
         &serai_client::Public(
           frost::dkg::musig::musig_key::<Ristretto>(
-            &serai_client::validator_sets::primitives::musig_context(set),
+            &serai_client::validator_sets::primitives::musig_context(set.into()),
             &self.spec.validators().into_iter().map(|(validator, _)| validator).collect::<Vec<_>>()
           )
           .unwrap()

coordinator/src/tests/tributary/mod.rs

@@ -7,7 +7,7 @@ use ciphersuite::{group::Group, Ciphersuite, Ristretto};
 use scale::{Encode, Decode};
 use serai_client::{
   primitives::{SeraiAddress, Signature},
-  validator_sets::primitives::{MAX_KEY_SHARES_PER_SET, ValidatorSet, KeyPair},
+  validator_sets::primitives::{ExternalValidatorSet, KeyPair, MAX_KEY_SHARES_PER_SET},
 };
 use processor_messages::coordinator::SubstrateSignableId;
 
@@ -31,7 +31,7 @@ impl PublishSeraiTransaction for () {
   async fn publish_set_keys(
     &self,
     _db: &(impl Sync + serai_db::Get),
-    _set: ValidatorSet,
+    _set: ExternalValidatorSet,
     _removed: Vec<SeraiAddress>,
     _key_pair: KeyPair,
     _signature: Signature,

coordinator/src/tributary/db.rs

@@ -6,7 +6,7 @@ use borsh::{BorshSerialize, BorshDeserialize};
 use ciphersuite::{group::GroupEncoding, Ciphersuite, Ristretto};
 use frost::Participant;
 
-use serai_client::validator_sets::primitives::{KeyPair, ValidatorSet};
+use serai_client::validator_sets::primitives::{KeyPair, ExternalValidatorSet};
 
 use processor_messages::coordinator::SubstrateSignableId;
 
@@ -46,7 +46,7 @@ pub enum Accumulation {
 create_db!(
   Tributary {
     SeraiBlockNumber: (hash: [u8; 32]) -> u64,
-    SeraiDkgCompleted: (spec: ValidatorSet) -> [u8; 32],
+    SeraiDkgCompleted: (spec: ExternalValidatorSet) -> [u8; 32],
 
     TributaryBlockNumber: (block: [u8; 32]) -> u32,
     LastHandledBlock: (genesis: [u8; 32]) -> [u8; 32],
@@ -80,7 +80,7 @@ create_db!(
     SlashReports: (genesis: [u8; 32], signer: [u8; 32]) -> Vec<u32>,
     SlashReported: (genesis: [u8; 32]) -> u16,
     SlashReportCutOff: (genesis: [u8; 32]) -> u64,
-    SlashReport: (set: ValidatorSet) -> Vec<([u8; 32], u32)>,
+    SlashReport: (set: ExternalValidatorSet) -> Vec<([u8; 32], u32)>,
   }
 );
 

coordinator/src/tributary/mod.rs

@@ -1,6 +1,6 @@
 use ciphersuite::{group::GroupEncoding, Ciphersuite, Ristretto};
 
-use serai_client::validator_sets::primitives::ValidatorSet;
+use serai_client::validator_sets::primitives::ExternalValidatorSet;
 
 use tributary::{
   ReadWrite,
@@ -40,7 +40,7 @@ pub fn removed_as_of_dkg_attempt(
 
 pub fn removed_as_of_set_keys(
   getter: &impl Get,
-  set: ValidatorSet,
+  set: ExternalValidatorSet,
   genesis: [u8; 32],
 ) -> Option<Vec<<Ristretto as Ciphersuite>::G>> {
   // SeraiDkgCompleted has the key placed on-chain.

coordinator/src/tributary/scanner.rs

@@ -10,7 +10,7 @@ use tokio::sync::broadcast;
 use scale::{Encode, Decode};
 use serai_client::{
   primitives::{SeraiAddress, Signature},
-  validator_sets::primitives::{KeyPair, ValidatorSet},
+  validator_sets::primitives::{ExternalValidatorSet, KeyPair},
   Serai,
 };
 
@@ -38,7 +38,7 @@ pub enum RecognizedIdType {
 pub trait RIDTrait {
   async fn recognized_id(
     &self,
-    set: ValidatorSet,
+    set: ExternalValidatorSet,
     genesis: [u8; 32],
     kind: RecognizedIdType,
     id: Vec<u8>,
@@ -47,12 +47,12 @@ pub trait RIDTrait {
 #[async_trait::async_trait]
 impl<
     FRid: Send + Future<Output = ()>,
-    F: Sync + Fn(ValidatorSet, [u8; 32], RecognizedIdType, Vec<u8>) -> FRid,
+    F: Sync + Fn(ExternalValidatorSet, [u8; 32], RecognizedIdType, Vec<u8>) -> FRid,
   > RIDTrait for F
 {
   async fn recognized_id(
     &self,
-    set: ValidatorSet,
+    set: ExternalValidatorSet,
     genesis: [u8; 32],
     kind: RecognizedIdType,
     id: Vec<u8>,
@@ -66,7 +66,7 @@ pub trait PublishSeraiTransaction {
   async fn publish_set_keys(
     &self,
     db: &(impl Sync + Get),
-    set: ValidatorSet,
+    set: ExternalValidatorSet,
     removed: Vec<SeraiAddress>,
     key_pair: KeyPair,
     signature: Signature,
@@ -86,7 +86,7 @@ mod impl_pst_for_serai {
       async fn publish(
         serai: &Serai,
         db: &impl Get,
-        set: ValidatorSet,
+        set: ExternalValidatorSet,
         tx: serai_client::Transaction,
         meta: $Meta,
       ) -> bool {
@@ -128,7 +128,7 @@ mod impl_pst_for_serai {
     async fn publish_set_keys(
       &self,
       db: &(impl Sync + Get),
-      set: ValidatorSet,
+      set: ExternalValidatorSet,
       removed: Vec<SeraiAddress>,
       key_pair: KeyPair,
       signature: Signature,
@@ -140,7 +140,7 @@ mod impl_pst_for_serai {
         key_pair,
         signature,
       );
-      async fn check(serai: SeraiValidatorSets<'_>, set: ValidatorSet, (): ()) -> bool {
+      async fn check(serai: SeraiValidatorSets<'_>, set: ExternalValidatorSet, (): ()) -> bool {
         if matches!(serai.keys(set).await, Ok(Some(_))) {
           log::info!("another coordinator set key pair for {:?}", set);
           return true;

coordinator/src/tributary/signing_protocol.rs

@@ -119,7 +119,7 @@ impl<T: DbTxn, C: Encode> SigningProtocol<'_, T, C> {
 
     let algorithm = Schnorrkel::new(b"substrate");
     let keys: ThresholdKeys<Ristretto> =
-      musig(&musig_context(self.spec.set()), self.key, participants)
+      musig(&musig_context(self.spec.set().into()), self.key, participants)
         .expect("signing for a set we aren't in/validator present multiple times")
         .into();
 

coordinator/src/tributary/spec.rs

@@ -9,7 +9,7 @@ use frost::Participant;
 use scale::Encode;
 use borsh::{BorshSerialize, BorshDeserialize};
 
-use serai_client::{primitives::PublicKey, validator_sets::primitives::ValidatorSet};
+use serai_client::{primitives::PublicKey, validator_sets::primitives::ExternalValidatorSet};
 
 fn borsh_serialize_validators<W: io::Write>(
   validators: &Vec<(<Ristretto as Ciphersuite>::G, u16)>,
@@ -43,7 +43,7 @@ fn borsh_deserialize_validators<R: io::Read>(
 pub struct TributarySpec {
   serai_block: [u8; 32],
   start_time: u64,
-  set: ValidatorSet,
+  set: ExternalValidatorSet,
   #[borsh(
     serialize_with = "borsh_serialize_validators",
     deserialize_with = "borsh_deserialize_validators"
@@ -55,7 +55,7 @@ impl TributarySpec {
   pub fn new(
     serai_block: [u8; 32],
     start_time: u64,
-    set: ValidatorSet,
+    set: ExternalValidatorSet,
     set_participants: Vec<(PublicKey, u16)>,
   ) -> TributarySpec {
     let mut validators = vec![];
@@ -68,7 +68,7 @@ impl TributarySpec {
     Self { serai_block, start_time, set, validators }
   }
 
-  pub fn set(&self) -> ValidatorSet {
+  pub fn set(&self) -> ExternalValidatorSet {
     self.set
   }
 

crypto/dalek-ff-group/src/field.rs

@@ -244,7 +244,16 @@ impl FieldElement {
             res *= res;
           }
         }
-        res *= table[usize::from(bits)];
+
+        let mut scale_by = FieldElement::ONE;
+        #[allow(clippy::needless_range_loop)]
+        for i in 0 .. 16 {
+          #[allow(clippy::cast_possible_truncation)] // Safe since 0 .. 16
+          {
+            scale_by = <_>::conditional_select(&scale_by, &table[i], bits.ct_eq(&(i as u8)));
+          }
+        }
+        res *= scale_by;
         bits = 0;
       }
     }

crypto/dalek-ff-group/src/lib.rs

@@ -208,7 +208,16 @@ impl Scalar {
             res *= res;
           }
         }
-        res *= table[usize::from(bits)];
+
+        let mut scale_by = Scalar::ONE;
+        #[allow(clippy::needless_range_loop)]
+        for i in 0 .. 16 {
+          #[allow(clippy::cast_possible_truncation)] // Safe since 0 .. 16
+          {
+            scale_by = <_>::conditional_select(&scale_by, &table[i], bits.ct_eq(&(i as u8)));
+          }
+        }
+        res *= scale_by;
         bits = 0;
       }
     }

crypto/ed448/src/backend.rs

@@ -161,7 +161,16 @@ macro_rules! field {
                 res *= res;
               }
             }
-            res *= table[usize::from(bits)];
+
+            let mut scale_by = $FieldName(Residue::ONE);
+            #[allow(clippy::needless_range_loop)]
+            for i in 0 .. 16 {
+              #[allow(clippy::cast_possible_truncation)] // Safe since 0 .. 16
+              {
+                scale_by = <_>::conditional_select(&scale_by, &table[i], bits.ct_eq(&(i as u8)));
+              }
+            }
+            res *= scale_by;
             bits = 0;
           }
         }

crypto/ed448/src/point.rs

@@ -242,7 +242,16 @@ impl Mul<Scalar> for Point {
             res = res.double();
           }
         }
-        res += table[usize::from(bits)];
+
+        let mut add_by = Point::identity();
+        #[allow(clippy::needless_range_loop)]
+        for i in 0 .. 16 {
+          #[allow(clippy::cast_possible_truncation)] // Safe since 0 .. 16
+          {
+            add_by = <_>::conditional_select(&add_by, &table[i], bits.ct_eq(&(i as u8)));
+          }
+        }
+        res += add_by;
         bits = 0;
       }
     }

crypto/frost/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "modular-frost"
-version = "0.8.1"
+version = "0.9.0"
 description = "Modular implementation of FROST over ff/group"
 license = "MIT"
 repository = "https://github.com/serai-dex/serai/tree/develop/crypto/frost"
 authors = ["Luke Parker <lukeparker5132@gmail.com>"]
 keywords = ["frost", "multisig", "threshold"]
 edition = "2021"
-rust-version = "1.79"
+rust-version = "1.80"
 
 [package.metadata.docs.rs]
 all-features = true

crypto/frost/src/algorithm.rs

@@ -25,7 +25,7 @@ pub trait Addendum: Send + Sync + Clone + PartialEq + Debug + WriteAddendum {}
 impl<A: Send + Sync + Clone + PartialEq + Debug + WriteAddendum> Addendum for A {}
 
 /// Algorithm trait usable by the FROST signing machine to produce signatures..
-pub trait Algorithm<C: Curve>: Send + Sync + Clone {
+pub trait Algorithm<C: Curve>: Send + Sync {
   /// The transcript format this algorithm uses. This likely should NOT be the IETF-compatible
   /// transcript included in this crate.
   type Transcript: Sync + Clone + Debug + Transcript;

crypto/frost/src/sign.rs

@@ -47,7 +47,7 @@ impl<T: Writable> Writable for Vec<T> {
 }
 
 // Pairing of an Algorithm with a ThresholdKeys instance.
-#[derive(Clone, Zeroize)]
+#[derive(Zeroize)]
 struct Params<C: Curve, A: Algorithm<C>> {
   // Skips the algorithm due to being too large a bound to feasibly enforce on users
   #[zeroize(skip)]
@@ -193,7 +193,7 @@ impl<C: Curve> SignatureShare<C> {
 /// Trait for the second machine of a two-round signing protocol.
 pub trait SignMachine<S>: Send + Sync + Sized {
   /// Params used to instantiate this machine which can be used to rebuild from a cache.
-  type Params: Clone;
+  type Params;
   /// Keys used for signing operations.
   type Keys;
   /// Preprocess message for this machine.
@@ -397,7 +397,7 @@ impl<C: Curve, A: Algorithm<C>> SignMachine<A::Signature> for AlgorithmSignMachi
 
     Ok((
       AlgorithmSignatureMachine {
-        params: self.params.clone(),
+        params: self.params,
         view,
         B,
         Rs,

crypto/frost/src/tests/mod.rs

@@ -37,10 +37,10 @@ pub fn clone_without<K: Clone + core::cmp::Eq + core::hash::Hash, V: Clone>(
 }
 
 /// Spawn algorithm machines for a random selection of signers, each executing the given algorithm.
-pub fn algorithm_machines<R: RngCore, C: Curve, A: Algorithm<C>>(
+pub fn algorithm_machines_without_clone<R: RngCore, C: Curve, A: Algorithm<C>>(
   rng: &mut R,
-  algorithm: &A,
   keys: &HashMap<Participant, ThresholdKeys<C>>,
+  machines: HashMap<Participant, AlgorithmMachine<C, A>>,
 ) -> HashMap<Participant, AlgorithmMachine<C, A>> {
   let mut included = vec![];
   while included.len() < usize::from(keys[&Participant::new(1).unwrap()].params().t()) {
@@ -54,18 +54,28 @@ pub fn algorithm_machines<R: RngCore, C: Curve, A: Algorithm<C>>(
     included.push(n);
   }
 
-  keys
-    .iter()
-    .filter_map(|(i, keys)| {
-      if included.contains(i) {
-        Some((*i, AlgorithmMachine::new(algorithm.clone(), keys.clone())))
-      } else {
-        None
-      }
-    })
+  machines
+    .into_iter()
+    .filter_map(|(i, machine)| if included.contains(&i) { Some((i, machine)) } else { None })
     .collect()
 }
 
+/// Spawn algorithm machines for a random selection of signers, each executing the given algorithm.
+pub fn algorithm_machines<R: RngCore, C: Curve, A: Clone + Algorithm<C>>(
+  rng: &mut R,
+  algorithm: &A,
+  keys: &HashMap<Participant, ThresholdKeys<C>>,
+) -> HashMap<Participant, AlgorithmMachine<C, A>> {
+  algorithm_machines_without_clone(
+    rng,
+    keys,
+    keys
+      .values()
+      .map(|keys| (keys.params().i(), AlgorithmMachine::new(algorithm.clone(), keys.clone())))
+      .collect(),
+  )
+}
+
 // Run the preprocess step
 pub(crate) fn preprocess<
   R: RngCore + CryptoRng,
@@ -165,10 +175,10 @@ pub fn sign_without_caching<R: RngCore + CryptoRng, M: PreprocessMachine>(
 
 /// Execute the signing protocol, randomly caching various machines to ensure they can cache
 /// successfully.
-pub fn sign<R: RngCore + CryptoRng, M: PreprocessMachine>(
+pub fn sign_without_clone<R: RngCore + CryptoRng, M: PreprocessMachine>(
   rng: &mut R,
-  params: &<M::SignMachine as SignMachine<M::Signature>>::Params,
   mut keys: HashMap<Participant, <M::SignMachine as SignMachine<M::Signature>>::Keys>,
+  mut params: HashMap<Participant, <M::SignMachine as SignMachine<M::Signature>>::Params>,
   machines: HashMap<Participant, M>,
   msg: &[u8],
 ) -> M::Signature {
@@ -183,7 +193,8 @@ pub fn sign<R: RngCore + CryptoRng, M: PreprocessMachine>(
           let cache = machines.remove(&i).unwrap().cache();
           machines.insert(
             i,
-            M::SignMachine::from_cache(params.clone(), keys.remove(&i).unwrap(), cache).0,
+            M::SignMachine::from_cache(params.remove(&i).unwrap(), keys.remove(&i).unwrap(), cache)
+              .0,
           );
         }
       }
@@ -192,6 +203,22 @@ pub fn sign<R: RngCore + CryptoRng, M: PreprocessMachine>(
   )
 }
 
+/// Execute the signing protocol, randomly caching various machines to ensure they can cache
+/// successfully.
+pub fn sign<
+  R: RngCore + CryptoRng,
+  M: PreprocessMachine<SignMachine: SignMachine<M::Signature, Params: Clone>>,
+>(
+  rng: &mut R,
+  params: &<M::SignMachine as SignMachine<M::Signature>>::Params,
+  keys: HashMap<Participant, <M::SignMachine as SignMachine<M::Signature>>::Keys>,
+  machines: HashMap<Participant, M>,
+  msg: &[u8],
+) -> M::Signature {
+  let params = keys.keys().map(|i| (*i, params.clone())).collect();
+  sign_without_clone(rng, keys, params, machines, msg)
+}
+
 /// Test a basic Schnorr signature with the provided keys.
 pub fn test_schnorr_with_keys<R: RngCore + CryptoRng, C: Curve, H: Hram<C>>(
   rng: &mut R,

crypto/schnorrkel/Cargo.toml

@@ -26,7 +26,7 @@ group = "0.13"
 
 ciphersuite = { path = "../ciphersuite", version = "^0.4.1", features = ["std", "ristretto"] }
 schnorr = { package = "schnorr-signatures", path = "../schnorr", version = "^0.5.1" }
-frost = { path = "../frost", package = "modular-frost", version = "^0.8.1", features = ["ristretto"] }
+frost = { path = "../frost", package = "modular-frost", version = "^0.9.0", features = ["ristretto"] }
 
 schnorrkel = { version = "0.11" }
 

deny.toml

@@ -92,7 +92,10 @@ license-files = [
 multiple-versions = "warn"
 wildcards = "warn"
 highlight = "all"
-deny = [ { name = "serde_derive", version = ">=1.0.172, <1.0.185" } ]
+deny = [
+  { name = "serde_derive", version = ">=1.0.172, <1.0.185" },
+  { name = "hashbrown", version = ">=0.15" },
+]
 
 [sources]
 unknown-registry = "deny"
@@ -100,7 +103,8 @@ unknown-git = "deny"
 allow-registry = ["https://github.com/rust-lang/crates.io-index"]
 allow-git = [
   "https://github.com/rust-lang-nursery/lazy-static.rs",
+  "https://github.com/monero-oxide/monero-oxide",
   "https://github.com/serai-dex/substrate-bip39",
   "https://github.com/serai-dex/substrate",
-  "https://github.com/alloy-rs/core",
+  "https://github.com/serai-dex/polkadot-sdk",
 ]

docs/Gemfile.lock

@@ -5,20 +5,20 @@ GEM
       public_suffix (>= 2.0.2, < 7.0)
     bigdecimal (3.1.8)
     colorator (1.1.0)
-    concurrent-ruby (1.3.3)
+    concurrent-ruby (1.3.4)
     em-websocket (0.5.3)
       eventmachine (>= 0.12.9)
       http_parser.rb (~> 0)
     eventmachine (1.2.7)
     ffi (1.17.0-x86_64-linux-gnu)
     forwardable-extended (2.6.0)
-    google-protobuf (4.27.3-x86_64-linux)
+    google-protobuf (4.28.2-x86_64-linux)
       bigdecimal
       rake (>= 13)
     http_parser.rb (0.8.0)
-    i18n (1.14.5)
+    i18n (1.14.6)
       concurrent-ruby (~> 1.0)
-    jekyll (4.3.3)
+    jekyll (4.3.4)
       addressable (~> 2.4)
       colorator (~> 1.0)
       em-websocket (~> 0.5)
@@ -63,17 +63,15 @@ GEM
     rb-fsevent (0.11.2)
     rb-inotify (0.11.1)
       ffi (~> 1.0)
-    rexml (3.3.4)
-      strscan
-    rouge (4.3.0)
+    rexml (3.3.7)
+    rouge (4.4.0)
     safe_yaml (1.0.5)
-    sass-embedded (1.77.8-x86_64-linux-gnu)
-      google-protobuf (~> 4.26)
-    strscan (3.1.0)
+    sass-embedded (1.79.3-x86_64-linux-gnu)
+      google-protobuf (~> 4.27)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
-    unicode-display_width (2.5.0)
-    webrick (1.8.1)
+    unicode-display_width (2.6.0)
+    webrick (1.8.2)
 
 PLATFORMS
   x86_64-linux

message-queue/src/main.rs

@@ -6,7 +6,7 @@ pub(crate) use std::{
 pub(crate) use ciphersuite::{group::GroupEncoding, Ciphersuite, Ristretto};
 pub(crate) use schnorr_signatures::SchnorrSignature;
 
-pub(crate) use serai_primitives::NetworkId;
+pub(crate) use serai_primitives::ExternalNetworkId;
 
 pub(crate) use tokio::{
   io::{AsyncReadExt, AsyncWriteExt},
@@ -193,10 +193,7 @@ async fn main() {
     KEYS.write().unwrap().insert(service, key);
     let mut queues = QUEUES.write().unwrap();
     if service == Service::Coordinator {
-      for network in serai_primitives::NETWORKS {
-        if network == NetworkId::Serai {
-          continue;
-        }
+      for network in serai_primitives::EXTERNAL_NETWORKS {
         queues.insert(
           (service, Service::Processor(network)),
           RwLock::new(Queue(db.clone(), service, Service::Processor(network))),
@@ -210,17 +207,13 @@ async fn main() {
     }
   };
 
-  // Make queues for each NetworkId, other than Serai
-  for network in serai_primitives::NETWORKS {
-    if network == NetworkId::Serai {
-      continue;
-    }
+  // Make queues for each ExternalNetworkId
+  for network in serai_primitives::EXTERNAL_NETWORKS {
     // Use a match so we error if the list of NetworkIds changes
     let Some(key) = read_key(match network {
-      NetworkId::Serai => unreachable!(),
-      NetworkId::Bitcoin => "BITCOIN_KEY",
-      NetworkId::Ethereum => "ETHEREUM_KEY",
-      NetworkId::Monero => "MONERO_KEY",
+      ExternalNetworkId::Bitcoin => "BITCOIN_KEY",
+      ExternalNetworkId::Ethereum => "ETHEREUM_KEY",
+      ExternalNetworkId::Monero => "MONERO_KEY",
     }) else {
       continue;
     };

message-queue/src/messages.rs

@@ -3,11 +3,11 @@ use ciphersuite::{group::GroupEncoding, Ciphersuite, Ristretto};
 
 use borsh::{BorshSerialize, BorshDeserialize};
 
-use serai_primitives::NetworkId;
+use serai_primitives::ExternalNetworkId;
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, BorshSerialize, BorshDeserialize)]
 pub enum Service {
-  Processor(NetworkId),
+  Processor(ExternalNetworkId),
   Coordinator,
 }
 

networks/bitcoin/Cargo.toml

@@ -26,7 +26,7 @@ rand_core = { version = "0.6", default-features = false }
 bitcoin = { version = "0.32", default-features = false }
 
 k256 = { version = "^0.13.1", default-features = false, features = ["arithmetic", "bits"] }
-frost = { package = "modular-frost", path = "../../crypto/frost", version = "0.8", default-features = false, features = ["secp256k1"], optional = true }
+frost = { package = "modular-frost", path = "../../crypto/frost", version = "0.9", default-features = false, features = ["secp256k1"], optional = true }
 
 hex = { version = "0.4", default-features = false, optional = true }
 serde = { version = "1", default-features = false, features = ["derive"], optional = true }

networks/bitcoin/src/wallet/send.rs

@@ -44,7 +44,7 @@ pub enum TransactionError {
   #[error("fee was too low to pass the default minimum fee rate")]
   TooLowFee,
   #[error("not enough funds for these payments")]
-  NotEnoughFunds,
+  NotEnoughFunds { inputs: u64, payments: u64, fee: u64 },
   #[error("transaction was too large")]
   TooLargeTransaction,
 }
@@ -213,7 +213,11 @@ impl SignableTransaction {
     }
 
     if input_sat < (payment_sat + needed_fee) {
-      Err(TransactionError::NotEnoughFunds)?;
+      Err(TransactionError::NotEnoughFunds {
+        inputs: input_sat,
+        payments: payment_sat,
+        fee: needed_fee,
+      })?;
     }
 
     // If there's a change address, check if there's change to give it
@@ -258,9 +262,9 @@ impl SignableTransaction {
     res
   }
 
-  /// Returns the outputs this transaction will create.
-  pub fn outputs(&self) -> &[TxOut] {
-    &self.tx.output
+  /// Returns the transaction, sans witness, this will create if signed.
+  pub fn transaction(&self) -> &Transaction {
+    &self.tx
   }
 
   /// Create a multisig machine for this transaction.

networks/bitcoin/tests/wallet.rs

@@ -195,10 +195,10 @@ async_sequential! {
       Err(TransactionError::TooLowFee),
     );
 
-    assert_eq!(
+    assert!(matches!(
       SignableTransaction::new(inputs.clone(), &[(addr(), inputs[0].value() * 2)], None, None, FEE),
-      Err(TransactionError::NotEnoughFunds),
-    );
+      Err(TransactionError::NotEnoughFunds { .. }),
+    ));
 
     assert_eq!(
       SignableTransaction::new(inputs, &vec![(addr(), 1000); 10000], None, None, FEE),

networks/ethereum/Cargo.toml

@@ -29,21 +29,21 @@ frost = { package = "modular-frost", path = "../../crypto/frost", default-featur
 
 alloy-core = { version = "0.8", default-features = false }
 alloy-sol-types = { version = "0.8", default-features = false, features = ["json"] }
-alloy-consensus = { version = "0.3", default-features = false, features = ["k256"] }
-alloy-network = { version = "0.3", default-features = false }
-alloy-rpc-types-eth = { version = "0.3", default-features = false }
-alloy-rpc-client = { version = "0.3", default-features = false }
+alloy-consensus = { version = "0.4", default-features = false, features = ["k256"] }
+alloy-network = { version = "0.4", default-features = false }
+alloy-rpc-types-eth = { version = "0.4", default-features = false }
+alloy-rpc-client = { version = "0.4", default-features = false }
 alloy-simple-request-transport = { path = "./alloy-simple-request-transport", default-features = false }
-alloy-provider = { version = "0.3", default-features = false }
+alloy-provider = { version = "0.4", default-features = false }
 
-alloy-node-bindings = { version = "0.3", default-features = false, optional = true }
+alloy-node-bindings = { version = "0.4", default-features = false, optional = true }
 
 [dev-dependencies]
 frost = { package = "modular-frost", path = "../../crypto/frost", default-features = false, features = ["tests"] }
 
 tokio = { version = "1", features = ["macros"] }
 
-alloy-node-bindings = { version = "0.3", default-features = false }
+alloy-node-bindings = { version = "0.4", default-features = false }
 
 [features]
 tests = ["alloy-node-bindings", "frost/tests"]

networks/ethereum/README.md

@@ -1,13 +1,12 @@
 # Ethereum
 
-This package contains Ethereum-related functionality, specifically deploying and
-interacting with Serai contracts.
+This package contains Ethereum-related functionality, specifically deploying
+and interacting with Serai contracts.
 
-While `monero-serai` and `bitcoin-serai` are general purpose libraries,
-`ethereum-serai` is Serai specific. If any of the utilities are generally
-desired, please fork and maintain your own copy to ensure the desired
-functionality is preserved, or open an issue to request we make this library
-general purpose.
+While `bitcoin-serai` is a general purpose library, `ethereum-serai` is Serai
+specific. If any of the utilities are generally desired, please fork and
+maintain your own copy to ensure the desired functionality is preserved, or
+open an issue to request we make this library general purpose.
 
 ### Dependencies
 

networks/ethereum/alloy-simple-request-transport/Cargo.toml

@@ -16,13 +16,13 @@ rustdoc-args = ["--cfg", "docsrs"]
 workspace = true
 
 [dependencies]
-tower = "0.4"
+tower = "0.5"
 
 serde_json = { version = "1", default-features = false }
 simple-request = { path = "../../../common/request", default-features = false }
 
-alloy-json-rpc = { version = "0.3", default-features = false }
-alloy-transport = { version = "0.3", default-features = false }
+alloy-json-rpc = { version = "0.4", default-features = false }
+alloy-transport = { version = "0.4", default-features = false }
 
 [features]
 default = ["tls"]

networks/ethereum/src/deployer.rs

@@ -39,7 +39,7 @@ impl Deployer {
       nonce: 0,
       gas_price: 100_000_000_000u128,
       // TODO: Use a more accurate gas limit
-      gas_limit: 1_000_000u128,
+      gas_limit: 1_000_000,
       to: TxKind::Create,
       value: U256::ZERO,
       input: bytecode,

networks/ethereum/src/router.rs

@@ -226,7 +226,7 @@ impl Router {
       to: TxKind::Call(self.1),
       input: abi::executeCall::new((outs.to_vec(), sig.into())).abi_encode().into(),
       // TODO
-      gas_limit: 100_000 + ((200_000 + 10_000) * u128::try_from(outs.len()).unwrap()),
+      gas_limit: 100_000 + ((200_000 + 10_000) * u64::try_from(outs.len()).unwrap()),
       ..Default::default()
     }
   }

networks/monero/Cargo.toml

@@ -1,56 +0,0 @@
-[package]
-name = "monero-serai"
-version = "0.1.4-alpha"
-description = "A modern Monero transaction library"
-license = "MIT"
-repository = "https://github.com/serai-dex/serai/tree/develop/networks/monero"
-authors = ["Luke Parker <lukeparker5132@gmail.com>"]
-edition = "2021"
-rust-version = "1.80"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[lints]
-workspace = true
-
-[dependencies]
-std-shims = { path = "../../common/std-shims", version = "^0.1.1", default-features = false }
-
-zeroize = { version = "^1.5", default-features = false, features = ["zeroize_derive"] }
-
-curve25519-dalek = { version = "4", default-features = false, features = ["alloc", "zeroize"] }
-
-monero-io = { path = "io", version = "0.1", default-features = false }
-monero-generators = { path = "generators", version = "0.4", default-features = false }
-monero-primitives = { path = "primitives", version = "0.1", default-features = false }
-monero-mlsag = { path = "ringct/mlsag", version = "0.1", default-features = false }
-monero-clsag = { path = "ringct/clsag", version = "0.1", default-features = false }
-monero-borromean = { path = "ringct/borromean", version = "0.1", default-features = false }
-monero-bulletproofs = { path = "ringct/bulletproofs", version = "0.1", default-features = false }
-
-hex-literal = "0.4"
-
-[dev-dependencies]
-hex = { version = "0.4", default-features = false, features = ["std"] }
-serde = { version = "1", default-features = false, features = ["std", "derive"] }
-serde_json = { version = "1", default-features = false, features = ["std"] }
-
-[features]
-std = [
-  "std-shims/std",
-
-  "zeroize/std",
-
-  "monero-io/std",
-  "monero-generators/std",
-  "monero-primitives/std",
-  "monero-mlsag/std",
-  "monero-clsag/std",
-  "monero-borromean/std",
-  "monero-bulletproofs/std",
-]
-
-compile-time-generators = ["curve25519-dalek/precomputed-tables", "monero-bulletproofs/compile-time-generators"]
-default = ["std", "compile-time-generators"]

networks/monero/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022-2024 Luke Parker
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

networks/monero/README.md

@@ -1,28 +0,0 @@
-# monero-serai
-
-A modern Monero transaction library. It provides a modern, Rust-friendly view of
-the Monero protocol.
-
-This library is usable under no-std when the `std` feature (on by default) is
-disabled.
-
-### Wallet Functionality
-
-monero-serai originally included wallet functionality. That has been moved to
-monero-wallet.
-
-### Purpose and Support
-
-monero-serai was written for Serai, a decentralized exchange aiming to support
-Monero. Despite this, monero-serai is intended to be a widely usable library,
-accurate to Monero. monero-serai guarantees the functionality needed for Serai,
-yet does not include any functionality specific to Serai.
-
-### Cargo Features
-
-- `std` (on by default): Enables `std` (and with it, more efficient internal
-  implementations).
-- `compile-time-generators` (on by default): Derives the generators at
-  compile-time so they don't need to be derived at runtime. This is recommended
-  if program size doesn't need to be kept minimal.
-- `multisig`: Enables the `multisig` feature for all dependencies.

networks/monero/generators/Cargo.toml

@@ -1,46 +0,0 @@
-[package]
-name = "monero-generators"
-version = "0.4.0"
-description = "Monero's hash to point function and generators"
-license = "MIT"
-repository = "https://github.com/serai-dex/serai/tree/develop/networks/monero/generators"
-authors = ["Luke Parker <lukeparker5132@gmail.com>"]
-edition = "2021"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[lints]
-workspace = true
-
-[dependencies]
-std-shims = { path = "../../../common/std-shims", version = "^0.1.1", default-features = false }
-
-subtle = { version = "^2.4", default-features = false }
-
-sha3 = { version = "0.10", default-features = false }
-curve25519-dalek = { version = "4", default-features = false, features = ["alloc", "zeroize"] }
-
-group = { version = "0.13", default-features = false }
-dalek-ff-group = { path = "../../../crypto/dalek-ff-group", version = "0.4", default-features = false }
-
-monero-io = { path = "../io", version = "0.1", default-features = false }
-
-[dev-dependencies]
-hex = "0.4"
-
-[features]
-std = [
-  "std-shims/std",
-
-  "subtle/std",
-
-  "sha3/std",
-
-  "group/alloc",
-  "dalek-ff-group/std",
-
-  "monero-io/std"
-]
-default = ["std"]

networks/monero/generators/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022-2024 Luke Parker
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

networks/monero/generators/README.md

@@ -1,13 +0,0 @@
-# Monero Generators
-
-Generators used by Monero in both its Pedersen commitments and Bulletproofs(+).
-An implementation of Monero's `hash_to_ec` is included, as needed to generate
-the generators.
-
-This library is usable under no-std when the `std` feature (on by default) is
-disabled.
-
-### Cargo Features
-
-- `std` (on by default): Enables `std` (and with it, more efficient internal
-  implementations).

networks/monero/generators/src/hash_to_point.rs

@@ -1,53 +0,0 @@
-use subtle::ConditionallySelectable;
-
-use curve25519_dalek::edwards::EdwardsPoint;
-
-use group::ff::{Field, PrimeField};
-use dalek_ff_group::FieldElement;
-
-use monero_io::decompress_point;
-
-use crate::keccak256;
-
-/// Monero's `hash_to_ec` function.
-pub fn hash_to_point(bytes: [u8; 32]) -> EdwardsPoint {
-  #[allow(non_snake_case)]
-  let A = FieldElement::from(486662u64);
-
-  let v = FieldElement::from_square(keccak256(&bytes)).double();
-  let w = v + FieldElement::ONE;
-  let x = w.square() + (-A.square() * v);
-
-  // This isn't the complete X, yet its initial value
-  // We don't calculate the full X, and instead solely calculate Y, letting dalek reconstruct X
-  // While inefficient, it solves API boundaries and reduces the amount of work done here
-  #[allow(non_snake_case)]
-  let X = {
-    let u = w;
-    let v = x;
-    let v3 = v * v * v;
-    let uv3 = u * v3;
-    let v7 = v3 * v3 * v;
-    let uv7 = u * v7;
-    uv3 * uv7.pow((-FieldElement::from(5u8)) * FieldElement::from(8u8).invert().unwrap())
-  };
-  let x = X.square() * x;
-
-  let y = w - x;
-  let non_zero_0 = !y.is_zero();
-  let y_if_non_zero_0 = w + x;
-  let sign = non_zero_0 & (!y_if_non_zero_0.is_zero());
-
-  let mut z = -A;
-  z *= FieldElement::conditional_select(&v, &FieldElement::from(1u8), sign);
-  #[allow(non_snake_case)]
-  let Z = z + w;
-  #[allow(non_snake_case)]
-  let mut Y = z - w;
-
-  Y *= Z.invert().unwrap();
-  let mut bytes = Y.to_repr();
-  bytes[31] |= sign.unwrap_u8() << 7;
-
-  decompress_point(bytes).unwrap().mul_by_cofactor()
-}

networks/monero/generators/src/lib.rs

@@ -1,91 +0,0 @@
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#![doc = include_str!("../README.md")]
-#![deny(missing_docs)]
-#![cfg_attr(not(feature = "std"), no_std)]
-
-use std_shims::{sync::LazyLock, vec::Vec};
-
-use sha3::{Digest, Keccak256};
-
-use curve25519_dalek::{constants::ED25519_BASEPOINT_POINT, edwards::EdwardsPoint};
-
-use monero_io::{write_varint, decompress_point};
-
-mod hash_to_point;
-pub use hash_to_point::hash_to_point;
-
-#[cfg(test)]
-mod tests;
-
-fn keccak256(data: &[u8]) -> [u8; 32] {
-  Keccak256::digest(data).into()
-}
-
-/// Monero's `H` generator.
-///
-/// Contrary to convention (`G` for values, `H` for randomness), `H` is used by Monero for amounts
-/// within Pedersen commitments.
-#[allow(non_snake_case)]
-pub static H: LazyLock<EdwardsPoint> = LazyLock::new(|| {
-  decompress_point(keccak256(&ED25519_BASEPOINT_POINT.compress().to_bytes()))
-    .unwrap()
-    .mul_by_cofactor()
-});
-
-static H_POW_2_CELL: LazyLock<[EdwardsPoint; 64]> = LazyLock::new(|| {
-  let mut res = [*H; 64];
-  for i in 1 .. 64 {
-    res[i] = res[i - 1] + res[i - 1];
-  }
-  res
-});
-/// Monero's `H` generator, multiplied by 2**i for i in 1 ..= 64.
-///
-/// This table is useful when working with amounts, which are u64s.
-#[allow(non_snake_case)]
-pub fn H_pow_2() -> &'static [EdwardsPoint; 64] {
-  &H_POW_2_CELL
-}
-
-/// The maximum amount of commitments provable for within a single range proof.
-pub const MAX_COMMITMENTS: usize = 16;
-/// The amount of bits a value within a commitment may use.
-pub const COMMITMENT_BITS: usize = 64;
-/// The logarithm (over 2) of the amount of bits a value within a commitment may use.
-pub const LOG_COMMITMENT_BITS: usize = 6; // 2 ** 6 == N
-
-/// Container struct for Bulletproofs(+) generators.
-#[allow(non_snake_case)]
-pub struct Generators {
-  /// The G (bold) vector of generators.
-  pub G: Vec<EdwardsPoint>,
-  /// The H (bold) vector of generators.
-  pub H: Vec<EdwardsPoint>,
-}
-
-/// Generate generators as needed for Bulletproofs(+), as Monero does.
-///
-/// Consumers should not call this function ad-hoc, yet call it within a build script or use a
-/// once-initialized static.
-pub fn bulletproofs_generators(dst: &'static [u8]) -> Generators {
-  // The maximum amount of bits used within a single range proof.
-  const MAX_MN: usize = MAX_COMMITMENTS * COMMITMENT_BITS;
-
-  let mut preimage = H.compress().to_bytes().to_vec();
-  preimage.extend(dst);
-
-  let mut res = Generators { G: Vec::with_capacity(MAX_MN), H: Vec::with_capacity(MAX_MN) };
-  for i in 0 .. MAX_MN {
-    // We generate a pair of generators per iteration
-    let i = 2 * i;
-
-    let mut even = preimage.clone();
-    write_varint(&i, &mut even).unwrap();
-    res.H.push(hash_to_point(keccak256(&even)));
-
-    let mut odd = preimage.clone();
-    write_varint(&(i + 1), &mut odd).unwrap();
-    res.G.push(hash_to_point(keccak256(&odd)));
-  }
-  res
-}

networks/monero/generators/src/tests/mod.rs

@@ -1,36 +0,0 @@
-use crate::{decompress_point, hash_to_point};
-
-#[test]
-fn test_vectors() {
-  // tests.txt file copied from monero repo
-  // https://github.com/monero-project/monero/
-  //   blob/ac02af92867590ca80b2779a7bbeafa99ff94dcb/tests/crypto/tests.txt
-  let reader = include_str!("./tests.txt");
-
-  for line in reader.lines() {
-    let mut words = line.split_whitespace();
-    let command = words.next().unwrap();
-
-    match command {
-      "check_key" => {
-        let key = words.next().unwrap();
-        let expected = match words.next().unwrap() {
-          "true" => true,
-          "false" => false,
-          _ => unreachable!("invalid result"),
-        };
-
-        let actual = decompress_point(hex::decode(key).unwrap().try_into().unwrap());
-        assert_eq!(actual.is_some(), expected);
-      }
-      "hash_to_ec" => {
-        let bytes = words.next().unwrap();
-        let expected = words.next().unwrap();
-
-        let actual = hash_to_point(hex::decode(bytes).unwrap().try_into().unwrap());
-        assert_eq!(hex::encode(actual.compress().to_bytes()), expected);
-      }
-      _ => unreachable!("unknown command"),
-    }
-  }
-}

networks/monero/generators/src/tests/tests.txt

@@ -1,628 +0,0 @@
-check_key c2cb3cf3840aa9893e00ec77093d3d44dba7da840b51c48462072d58d8efd183 false
-check_key bd85a61bae0c101d826cbed54b1290f941d26e70607a07fc6f0ad611eb8f70a6 true
-check_key 328f81cad4eba24ab2bad7c0e56b1e2e7346e625bcb06ae649aef3ffa0b8bef3 false
-check_key 6016a5463b9e5a58c3410d3f892b76278883473c3f0b69459172d3de49e85abe true
-check_key 4c71282b2add07cdc6898a2622553f1ca4eb851e5cb121181628be5f3814c5b1 false
-check_key 69393c25c3b50e177f81f20f852dd604e768eb30052e23108b3cfa1a73f2736e true
-check_key 3d5a89b676cb84c2be3428d20a660dc6a37cae13912e127888a5132e8bac2163 true
-check_key 78cd665deb28cebc6208f307734c56fccdf5fa7e2933fadfcdd2b6246e9ae95c false
-check_key e03b2414e260580f86ee294cd4c636a5b153e617f704e81dad248fbf715b2ee4 true
-check_key 28c3503ce82d7cdc8e0d96c4553bcf0352bbcfc73925495dbe541e7e1df105fc false
-check_key 06855c3c3e0d03fec354059bda319b39916bdc10b6581e3f41b335ee7b014fd5 false
-check_key 556381485df0d7d5a268ab5ecfb2984b060acc63471183fcf538bf273b0c0cb5 true
-check_key c7f76d82ac64b1e7fdc32761ff00d6f0f7ada4cf223aa5a11187e3a02e1d5319 true
-check_key cfa85d8bdb6f633fcf031adee3a299ac42eeb6bd707744049f652f6322f5aa47 true
-check_key 91e9b63ced2b08979fee713365464cc3417c4f238f9bdd3396efbb3c58e195ee true
-check_key 7b56e76fe94bd30b3b2f2c4ba5fe4c504821753a8965eb1cbcf8896e2d6aba19 true
-check_key 7338df494bc416cf5edcc02069e067f39cb269ce67bd9faba956021ce3b3de3a false
-check_key f9a1f27b1618342a558379f4815fa5039a8fe9d98a09f45c1af857ba99231dc1 false
-check_key b2a1f37718180d4448a7fcb5f788048b1a7132dde1cfd25f0b9b01776a21c687 true
-check_key 0d3a0f9443a8b24510ad1e76a8117cca03bce416edfe35e3c2a2c2712454f8dc false
-check_key d8d3d806a76f120c4027dc9c9d741ad32e06861b9cfbc4ce39289c04e251bb3c false
-check_key 1e9e3ba7bc536cd113606842835d1f05b4b9e65875742f3a35bfb2d63164b5d5 true
-check_key 5c52d0087997a2cdf1d01ed0560d94b4bfd328cb741cb9a8d46ff50374b35a57 true
-check_key bb669d4d7ffc4b91a14defedcdbd96b330108b01adc63aa685e2165284c0033b false
-check_key d2709ae751a0a6fd796c98456fa95a7b64b75a3434f1caa3496eeaf5c14109b4 true
-check_key e0c238cba781684e655b10a7d4af04ab7ff2e7022182d7ed2279d6adf36b3e7a false
-check_key 34ebb4bf871572cee5c6935716fab8c8ec28feef4f039763d8f039b84a50bf4c false
-check_key 4730d4f38ec3f3b83e32e6335d2506df4ee39858848842c5a0184417fcc639e4 true
-check_key d42cf7fdf5e17e0a8a7f88505a2b7a3d297113bd93d3c20fa87e11509ec905a2 true
-check_key b757c95059cefabb0080d3a8ebca82e46efecfd29881be3121857f9d915e388c false
-check_key bbe777aaf04d02b96c0632f4b1c6f35f1c7bcbc5f22af192f92c077709a2b50b false
-check_key 73518522aabd28566f858c33fccb34b7a4de0e283f6f783f625604ee647afad9 true
-check_key f230622c4a8f6e516590466bd10f86b64fbef61695f6a054d37604e0b024d5af false
-check_key bc6b9a8379fd6c369f7c3bd9ddce58db6b78f27a41d798bb865c3920824d0943 false
-check_key 45a4f87c25898cd6be105fa1602b85c4d862782adaac8b85c996c4a2bcd8af47 true
-check_key eb4ad3561d21c4311affbd7cc2c7ff5fd509f72f88ba67dc097a75c31fdbd990 false
-check_key 2f34f4630c09a23b7ecc19f02b4190a26df69e07e13de8069ae5ff80d23762fc true
-check_key 2ea4e4fb5085eb5c8adee0d5ab7d35c67d74d343bd816cd13924536cffc2527c true
-check_key 5d35467ee6705a0d35818aa9ae94e4603c3e5500bfc4cf4c4f77a7160a597aa6 true
-check_key 8ff42bc76796e20c99b6e879369bd4b46a256db1366416291de9166e39d5a093 true
-check_key 0262ba718850df6c621e8a24cd9e4831c047e38818a89e15c7a06a489a4558e1 false
-check_key 58b29b2ba238b534b08fb46f05f430e61cb77dc251b0bb50afec1b6061fd9247 false
-check_key 153170e3dc2b0e1b368fc0d0e31053e872f094cdace9a2846367f0d9245a109b false
-check_key 40419d309d07522d493bb047ca9b5fb6c401aae226eefae6fd395f5bb9114200 true
-check_key 713068818d256ef69c78cd6082492013fbd48de3c9e7e076415dd0a692994504 true
-check_key a7218ee08e50781b0c87312d5e0031467e863c10081668e3792d96cbcee4e474 true
-check_key 356ce516b00e674ef1729c75b0a68090e7265cef675bbf32bf809495b67e9342 false
-check_key 52a5c053293675e3efd2c585047002ea6d77931cbf38f541b9070d319dc0d237 false
-check_key 77c0080bf157e069b18c4c604cc9505c5ec6f0f9930e087592d70507ca1b5534 false
-check_key e733bc41f880a4cfb1ca6f397916504130807289cacfca10b15f5b8d058ed1bf false
-check_key c4f1d3c884908a574ecea8be10e02277de35ef84a1d10f105f2be996f285161f true
-check_key aed677f7f69e146aa0863606ac580fc0bbdc22a88c4b4386abaa4bdfff66bcc9 false
-check_key 6ad0edf59769599af8caa986f502afc67aecbebb8107aaf5e7d3ae51d5cf8dd8 false
-check_key 64a0a70e99be1f775c222ee9cd6f1bee6f632cb9417899af398ff9aff70661c6 true
-check_key c63afaa03bb5c4ed7bc77aac175dbfb73f904440b2e3056a65850ac1bd261332 false
-check_key a4e89cd2471c26951513b1cfbdcf053a86575e095af52495276aa56ede8ce344 false
-check_key 2ce935d97f7c3ddb973de685d20f58ee39938fe557216328045ec2b83f3132be true
-check_key 3e3d38b1fca93c1559ac030d586616354c668aa76245a09e3fa6de55ac730973 true
-check_key 8b81b9681f76a4254007fd07ed1ded25fc675973ccb23afd06074805194733a4 false
-check_key 26d1c15dfc371489439e29bcef2afcf7ed01fac24960fdc2e7c20847a8067588 true
-check_key 85c1199b5a4591fc4cc36d23660648c1b9cfbb0e9c47199fa3eea33299a3dcec false
-check_key 60830ba5449c1f04ac54675dfc7cac7510106c4b7549852551f8fe65971123e2 false
-check_key 3e43c28c024597b3b836e4bc16905047cbf6e841b80e0b8cd6a325049070c2a5 false
-check_key 474792c16a0032343a6f28f4cb564747c3b1ea0b6a6b9a42f7c71d7cc3dd3b44 true
-check_key c8ec5e67cb5786673085191881950a3ca20dde88f46851b01dd91c695cfbad16 true
-check_key 861c4b24b24a87b8559e0bb665f84dcc506c147a909f335ae4573b92299f042f false
-check_key 2c9e0fe3e4983d79f86c8c36928528f1bc90d94352ce427032cdef6906d84d0b true
-check_key 9293742822c2dff63fdc1bf6645c864fd527cea2ddba6d4f3048d202fc340c9a true
-check_key 3956422ad380ef19cb9fe360ef09cc7aaec7163eea4114392a7a0b2e2671914e true
-check_key 5ae8e72cadda85e525922fec11bd53a261cf26ee230fe85a1187f831b1b2c258 false
-check_key 973feca43a0baf450c30ace5dc19015e19400f0898316e28d9f3c631da31f99a true
-check_key dd946c91a2077f45c5c16939e53859d9beabaf065e7b1b993d5e5cd385f8716e true
-check_key b3928f2d67e47f6bd6da81f72e64908d8ff391af5689f0202c4c6fec7666ffe8 true
-check_key 313382e82083697d7f9d256c3b3800b099b56c3ef33cacdccbd40a65622e25fc false
-check_key 7d65380c12144802d39ed9306eed79fe165854273700437c0b4b50559800c058 true
-check_key 4db5c20a49422fd27739c9ca80e2271a8a125dfcead22cb8f035d0e1b7b163be true
-check_key dd76a9f565ef0e44d1531349ec4c5f7c3c387c2f5823e693b4952f4b0b70808c true
-check_key 66430bf628eae23918c3ed17b42138db1f98c24819e55fc4a07452d0c85603eb true
-check_key 9f0b677830c3f089c27daf724bb10be848537f8285de83ab0292d35afb617f77 false
-check_key cbf98287391fb00b1e68ad64e9fb10198025864c099b8b9334d840457e673874 true
-check_key a42552e9446e49a83aed9e3370506671216b2d1471392293b8fc2b81c81a73ee false
-check_key fb3de55ac81a923d506a514602d65d004ec9d13e8b47e82d73af06da73006673 false
-check_key e17abb78e58a4b72ff4ad7387b290f2811be880b394b8bcaae7748ac09930169 false
-check_key 9ffbda7ace69753761cdb5eb01f75433efa5cdb6a4f1b664874182c6a95adcba true
-check_key 507123c979179ea0a3f7f67fb485f71c8636ec4ec70aa47b92f3c707e7541a54 false
-check_key f1d0b156571994ef578c61cb6545d34f834eb30e4357539a5633c862d4dffa91 false
-check_key 3de62311ec14f9ee95828c190b2dc3f03059d6119e8dfccb7323efc640e07c75 false
-check_key 5e50bb48bc9f6dd11d52c1f0d10d8ae5674d7a4af89cbbce178dafc8a562e5fe false
-check_key 20b2c16497be101995391ceefb979814b0ea76f1ed5b6987985bcdcd17b36a81 false
-check_key d63bff73b914ce791c840e99bfae0d47afdb99c2375e33c8f149d0df03d97873 false
-check_key 3f24b3d94b5ddd244e4c4e67a6d9f533f0396ca30454aa0ca799f21328b81d47 true
-check_key 6a44c016f09225a6d2e830290719d33eb29b53b553eea7737ed3a6e297b2e7d2 true
-check_key ff0f34df0c76c207b8340be2009db72f730c69c2bbfeea2013105eaccf1d1f8e true
-check_key 4baf559869fe4e915e219c3c8d9a2330fc91e542a5a2a7311d4d59fee996f807 true
-check_key 1632207dfef26e97d13b0d0035ea9468fc5a8a89b0990fce77bb143c9d7f3b67 true
-check_key fcb3dee3993d1a47630f29410903dd03706bd5e81c5802e6f1b9095cbdb404d3 true
-check_key fb527092b9809e3d27d7588c7ef89915a769b99c1e03e7f72bbead9ed837daae false
-check_key 902b118d27d40ab9cbd55edd375801ce302cdb59e09c8659a3ea1401918d8bba false
-check_key 4d6fbf25ca51e263a700f1abf84f758dde3d11b632e908b3093d64fe2e70ea0a true
-check_key f4c3211ec70affc1c9a94a6589460ee8360dad5f8c679152f16994038532e3fc true
-check_key c2b3d73ac14956d7fdf12fa92235af1bb09e1566a6a6ffd0025682c750abdd69 false
-check_key b7e68c12207d2e2104fb2ca224829b6fccc1c0e2154e8a931e3c837a945f4430 false
-check_key 56ca0ca227708f1099bda1463db9559541c8c11ffad7b3d95c717471f25a01bf true
-check_key 3eef3a46833e4d851671182a682e344e36bea7211a001f3b8af1093a9c83f1b2 true
-check_key bd1f4a4f26cab7c1cbc0e17049b90854d6d28d2d55181e1b5f7a8045fcdfa06e true
-check_key 8537b01c87e7c184d9555e8d93363dcd9b60a8acc94cd3e41eb7525fd3e1d35a false
-check_key 68ace49179d549bad391d98ab2cc8afee65f98ce14955c3c1b16e850fabec231 true
-check_key f9922f8a660e7c3e4f3735a817d18b72f59166a0be2d99795f953cf233a27e24 true
-check_key 036b6be3da26e80508d5a5a6a5999a1fe0db1ac4e9ade8f1ea2eaf2ea9b1a70e true
-check_key 5e595e886ce16b5ea31f53bcb619f16c8437276618c595739fece6339731feb0 false
-check_key 4ee2cebae3476ed2eeb7efef9d20958538b3642f938403302682a04115c0f8ed false
-check_key 519eedbd0da8676063ce7d5a605b3fc27afeecded857afa24b894ad248c87b5d false
-check_key ce2b627c0accf4a3105796680c37792b30c6337d2d4fea11678282455ff82ff7 false
-check_key aa26ed99071a8416215e8e7ded784aa7c2b303aab67e66f7539905d7e922eb4d false
-check_key 435ae49c9ca26758aa103bdcca8d51393b1906fe27a61c5245361e554f335ec2 true
-check_key 42568af395bd30024f6ccc95205c0e11a6ad1a7ee100f0ec46fcdf0af88e91fb false
-check_key 0b4a78d1fde56181445f04ca4780f0725daa9c375b496fab6c037d6b2c2275db true
-check_key 2f82d2a3c8ce801e1ad334f9e074a4fbf76ffac4080a7331dc1359c2b4f674a4 false
-check_key 24297d8832d733ed052dd102d4c40e813f702006f325644ccf0cb2c31f77953f false
-check_key 5231a53f6bea7c75b273bde4a9f673044ed87796f20e0909978f29d98fc8d4f0 true
-check_key 94b5affcf78be5cf62765c32a0794bc06b4900e8a47ddba0e166ec20cec05935 true
-check_key c14b4d846ea52ffbbb36aa62f059453af3cfae306280dada185d2d385ef8f317 true
-check_key cceb34fddf01a6182deb79c6000a998742d4800d23d1d8472e3f43cd61f94508 true
-check_key 1faffa33407fba1634d4136cf9447896776c16293b033c6794f06774b514744c true
-check_key faaac98f644a2b77fb09ba0ebf5fcddf3ff55f6604c0e9e77f0278063e25113a true
-check_key 09e8525b00bea395978279ca979247a76f38f86dce4465eb76c140a7f904c109 true
-check_key 2d797fc725e7fb6d3b412694e7386040effe4823cdf01f6ec7edea4bc0e77e20 false
-check_key bbb74dabee651a65f46bca472df6a8a749cc4ba5ca35078df5f6d27a772f922a false
-check_key 77513ca00f3866607c3eff5c2c011beffa775c0022c5a4e7de1120a27e6687fd true
-check_key 10064c14ace2a998fc2843eeeb62884fe3f7ab331ca70613d6a978f44d9868eb false
-check_key 026ae84beb5e54c62629a7b63702e85044e38cadfc9a1fcabee6099ba185005c false
-check_key aef91536292b7ba34a3e787fb019523c2fa7a0d56fca069cc82ccb6b02a45b14 false
-check_key 147bb1a82c623c722540feaad82b7adf4b85c6ec0cbcef3ca52906f3e85617ac true
-check_key fc9fb281a0847d58dc9340ef35ef02f7d20671142f12bdd1bfb324ab61d03911 false
-check_key b739801b9455ac617ca4a7190e2806669f638d4b2f9288171afb55e1542c8d71 false
-check_key 494cc1e2ee997eb1eb051f83c4c89968116714ddf74e460d4fa1c6e7c72e3eb3 true
-check_key ed2fbdf2b727ed9284db90ec900a942224787a880bc41d95c4bc4cf136260fd7 true
-check_key 02843d3e6fc6835ad03983670a592361a26948eb3e31648d572416a944d4909e true
-check_key c14fea556a7e1b6b6c3d4e2e38a4e7e95d834220ff0140d3f7f561a34e460801 true
-check_key 5f8f82a35452d0b0d09ffb40a1154641916c31e161ad1a6ab8cfddc2004efdf6 false
-check_key 7b93d72429fab07b49956007eba335bb8c5629fbf9e7a601eaa030f196934a56 true
-check_key 6a63ed96d2e46c2874beaf82344065d94b1e5c04406997f94caf4ccd97cfbab9 false
-check_key c915f409e1e0f776d1f440aa6969cfec97559ef864b07d8c0d7c1163871b4603 true
-check_key d06bc33630fc94303c2c369481308f805f5ce53c40141160aa4a1f072967617e false
-check_key 1aafb14ca15043c2589bcd32c7c5f29479216a1980e127e9536729faf1c40266 true
-check_key 58c115624a20f4b0c152ccd048c54a28a938556863ab8521b154d3165d3649cd false
-check_key 9001ba086e8aa8a67e128f36d700cc641071556306db7ec9b8ac12a6256b27b7 false
-check_key 898c468541634fb0def11f82c781341fce0def7b15695af4e642e397218c730c true
-check_key 47ea6539e65b7b611b0e1ae9ee170adf7c31581ca9f78796d8ebbcc5cd74b712 false
-check_key 0c60952a64eeac446652f5d3c136fd36966cf66310c15ee6ab2ecbf981461257 false
-check_key 682264c4686dc7736b6e46bdc8ab231239bc5dac3f5cb9681a1e97a527945e8e true
-check_key 276006845ca0ea4238b231434e20ad8b8b2a36876effbe1d1e3ffb1f14973397 true
-check_key eecd3a49e55e32446f86c045dce123ef6fe2e5c57db1d850644b3c56ec689fce true
-check_key a4dced63589118db3d5aebf6b5670e71250f07485ca4bb6dddf9cce3e4c227a1 false
-check_key b8ade608ba43d55db7ab481da88b74a9be513fca651c03e04d30cc79f50e0276 false
-check_key 0d91de88d007a03fe782f904808b036ff63dec6b73ce080c55231afd4ed261c3 true
-check_key 87c59becb52dd16501edadbb0e06b0406d69541c4d46115351e79951a8dd9c28 true
-check_key 9aee723be2265171fe10a86d1d3e9cf5a4e46178e859db83f86d1c6db104a247 false
-check_key 509d34ae5bf56db011845b8cdf0cc7729ed602fce765e9564cb433b4d4421a43 false
-check_key 06e766d9a6640558767c2aab29f73199130bfdc07fd858a73e6ae8e7b7ba23ba false
-check_key 801c4fe5ab3e7cf13f7aa2ca3bc57cc8eba587d21f8bc4cd40b1e98db7aec8d9 false
-check_key d85ad63aeb7d2faa22e5c9b87cd27f45b01e6d0fdc4c3ddf105584ac0a021465 false
-check_key a7ca13051eb2baeb5befa5e236e482e0bb71803ad06a6eae3ae48742393329d2 true
-check_key 5a9ba3ec20f116173d933bf5cf35c320ed3751432f3ab453e4a6c51c1d243257 false
-check_key a4091add8a6710c03285a422d6e67863a48b818f61c62e989b1e9b2ace240a87 false
-check_key bdee0c6442e6808f25bb18e21b19032cf93a55a5f5c6426fba2227a41c748684 true
-check_key d4aeb6cdad9667ec3b65c7fbc5bfd1b82bba1939c6bb448a86e40aec42be5f25 false
-check_key 73525b30a77f1212f7e339ec11f48c453e476f3669e6e70bebabc2fe9e37c160 true
-check_key 45501f2dc4d0a3131f9e0fe37a51c14869ab610abd8bf0158111617924953629 false
-check_key 07d0e4c592aa3676adf81cca31a95d50c8c269d995a78cde27b2a9a7a93083a6 false
-check_key a1797d6178c18add443d22fdbf45ca5e49ead2f78b70bdf1500f570ee90adca5 true
-check_key 0961e82e6e7855d7b7bf96777e14ae729f91c5bbd20f805bd7daac5ccbec4bab false
-check_key 57f5ba0ad36e997a4fb585cd2fc81b9cc5418db702c4d1e366639bb432d37c73 true
-check_key 82b005be61580856841e042ee8be74ae4ca66bb6733478e81ca1e56213de5c05 false
-check_key d7733dcae1874c93e9a2bd46385f720801f913744d60479930dad7d56c767cdc false
-check_key b8b8b698609ac3f1bd8f4965151b43b362e6c5e3d1c1feae312c1d43976d59ab true
-check_key 4bba7815a9a1b86a5b80b17ac0b514e2faa7a24024f269b330e5b7032ae8c04e true
-check_key 0f70da8f8266b58acda259935ef1a947c923f8698622c5503520ff31162e877b false
-check_key 233eaa3db80f314c6c895d1328a658a9175158fa2483ed216670c288a04b27bc false
-check_key a889f124fabfd7a1e2d176f485be0cbd8b3eeaafeee4f40e99e2a56befb665be true
-check_key 2b7b8abc198b11cf7efa21bc63ec436f790fe1f9b8c044440f183ab291af61d6 true
-check_key 2491804714f7938cf501fb2adf07597b4899b919cabbaab49518b8f8767fdc6a true
-check_key 52744a54fcb00dc930a5d7c2bc866cbfc1e75dd38b38021fd792bb0ca9f43164 true
-check_key e42cbf70b81ba318419104dffbb0cdc3b7e7d4698e422206b753a4e2e6fc69bb false
-check_key 2faff73e4fed62965f3dbf2e6446b5fea0364666cc8c9450b6ed63bbb6f5f0e7 true
-check_key 8b963928d75be661c3c18ddd4f4d1f37ebc095ce1edc13fe8b23784c8f416dfd false
-check_key b1162f952808434e4d2562ffda98bd311613d655d8cf85dc86e0a6c59f7158bc true
-check_key 5a69adcd9e4f5b0020467e968d85877cb3aa04fa86088d4499b57ca65a665836 true
-check_key 61ab47da432c829d0bc9d4fdb59520b135428eec665ad509678188b81c7adf49 false
-check_key 154bb547f22f65a87c0c3f56294f5791d04a3c14c8125d256aeed8ec54c4a06e true
-check_key 0a78197861c30fd3547b5f2eabd96d3ac22ac0632f03b7afd9d5d2bfc2db352f true
-check_key 8bdeadcca1f1f8a4a67b01ed2f10ef31aba7b034e8d1df3a69fe9aebf32454e0 false
-check_key f4b17dfca559be7d5cea500ac01e834624fed9befae3af746b39073d5f63190d true
-check_key 622c52821e16ddc63b58f3ec2b959fe8c6ea6b1a596d9a58fd81178963f41c01 true
-check_key 07bedd5d55c937ef5e23a56c6e58f31adb91224d985285d7fef39ede3a9efb17 false
-check_key 5179bf3b7458648e57dc20f003c6bbfd55e8cd7c0a6e90df6ef8e8183b46f99d true
-check_key 683c80c3f304f10fdd53a84813b5c25b1627ebd14eb29b258b41cd14396ef41f true
-check_key c266244ed597c438170875fe7874f81258a830105ca1108131e6b8fea95eb8ba true
-check_key 0c1cdc693df29c2d1e66b2ce3747e34a30287d5eb6c302495634ec856593fe8e true
-check_key 28950f508f6a0d4c20ab5e4d55b80565a6a539092e72b7eb0ed9fa5017ecef88 false
-check_key 8328a2a5fcfc4433b1c283539a8943e6eb8cc16c59f29dedc3af2c77cfd56f25 true
-check_key 5d0f82319676d4d3636ff5dc2a38ea5ec8aeaac4835fdcab983ab35d76b7967b false
-check_key cafcc75e94a014115f25c23aaae86e67352f928f468d4312b92240ff0f3a4481 false
-check_key 3e5fdd8072574218f389d018e959669e8ca4ef20b114ea7dce7bfb32339f9f42 true
-check_key 591763e3390a78ccb529ceea3d3a97165878b179ad2edaa166fd3c78ec69d391 true
-check_key 7a0a196935bf79dc2b1c3050e8f2bf0665f7773fc07511b828ec1c4b1451d317 false
-check_key 9cf0c034162131fbaa94a608f58546d0acbcc2e67b62a0b2be2ce75fc8c25b9a false
-check_key e3840846e3d32644d45654b96def09a5d6968caca9048c13fcaab7ae8851c316 false
-check_key a4e330253739af588d70fbda23543f6df7d76d894a486d169e5fedf7ed32d2e2 false
-check_key cfb41db7091223865f7ecbdda92b9a6fb08887827831451de5bcb3165395d95d true
-check_key 3d10bd023cef8ae30229fdbfa7446a3c218423d00f330857ff6adde080749015 false
-check_key 4403b53b8d4112bb1727bb8b5fd63d1f79f107705ffe17867704e70a61875328 false
-check_key 121ef0813a9f76b7a9c045058557c5072de6a102f06a9b103ead6af079420c29 true
-check_key 386204cf473caf3854351dda55844a41162eb9ce4740e1e31cfef037b41bc56e false
-check_key eb5872300dc658161df469364283e4658f37f6a1349976f8973bd6b5d1d57a39 true
-check_key b8f32188f0fc62eeb38a561ff7b7f3c94440e6d366a05ef7636958bc97834d02 false
-check_key a817f129a8292df79eef8531736fdebb2e985304653e7ef286574d0703b40fb4 false
-check_key 2c06595bc103447b9c20a71cd358c704cb43b0b34c23fb768e6730ac9494f39e true
-check_key dd84bc4c366ced4f65c50c26beb8a9bc26c88b7d4a77effbb0f7af1b28e25734 false
-check_key 76b4d33810eed637f90d49a530ac5415df97cafdac6f17eda1ba7eb9a14e5886 true
-check_key 926ce5161c4c92d90ec4efc58e5f449a2c385766c42d2e60af16b7362097aef5 false
-check_key 20c661f1e95e94a745eb9ec7a4fa719eff2f64052968e448d4734f90952aefee false
-check_key 671b50abbd119c756010416e15fcdcc9a8e92eed0f67cbca240c3a9154db55c0 false
-check_key df7aeee8458433e5c68253b8ef006a1c74ce3aef8951056f1fa918a8eb855213 false
-check_key 70c81a38b92849cf547e3d5a6570d78e5228d4eaf9c8fdd15959edc9eb750daf false
-check_key 55a512100b72d4ae0cfc16c75566fcaa3a7bb9116840db1559c71fd0e961cc36 false
-check_key dbfbec4d0d2433a794ad40dc0aea965b6582875805c9a7351b47377403296acd true
-check_key 0a7fe09eb9342214f98b38964f72ae3c787c19e5d7e256af9216f108f88b00a3 true
-check_key a82e54681475f53ced9730ee9e3a607e341014d9403f5a42f3dbdbe8fc52e842 true
-check_key 4d1f90059f7895a3f89abf16162e8d69b399c417f515ccb43b83144bbe8105f6 true
-check_key 94e5c5b8486b1f2ff4e98ddf3b9295787eb252ba9b408ca4d7724595861da834 false
-check_key d16e3e8dfa6d33d1d2db21c651006ccddbf4ce2e556594de5a22ae433e774ae6 false
-check_key a1b203ec5e36098a3af08d6077068fec57eab3a754cbb5f8192983f37191c2df false
-check_key 5378bb3ec8b4e49849bd7477356ed86f40757dd1ea3cee1e5183c7e7be4c3406 false
-check_key 541a4162edeb57130295441dc1cb604072d7323b6c7dffa02ea5e4fed1d2ee9e true
-check_key d8e86e189edcc4b5c262c26004691edd7bd909090997f886b00ed4b6af64d547 false
-check_key 18a8731d1983d1df2ce2703b4c85e7357b6356634ac1412e6c2ac33ad35f8364 false
-check_key b21212eac1eb11e811022514c5041233c4a07083a5b20acd7d632a938dc627de true
-check_key 50efcfac1a55e9829d89334513d6d921abeb237594174015d154512054e4f9d1 true
-check_key 9c44e8bcba31ddb4e67808422e42062540742ebd73439da0ba7837bf26649ec4 true
-check_key b068a4f90d5bd78fd350daa129de35e5297b0ad6be9c85c7a6f129e3760a1482 false
-check_key e9df93932f0096fcf2055564457c6dc685051673a4a6cd87779924be5c4abead true
-check_key eddab2fc52dac8ed12914d1eb5b0da9978662c4d35b388d64ddf8f065606acaf true
-check_key 54d3e6b3f2143d9083b4c98e4c22d98f99d274228050b2dc11695bf86631e89f true
-check_key 6da1d5ef1827de8bbf886623561b058032e196d17f983cbc52199b31b2acc75b true
-check_key e2a2df18e2235ebd743c9714e334f415d4ca4baf7ad1b335fb45021353d5117f true
-check_key f34cb7d6e861c8bfe6e15ac19de68e74ccc9b345a7b751a10a5c7f85a99dfeb6 false
-check_key f36e2f5967eb56244f9e4981a831f4d19c805e31983662641fe384e68176604a true
-check_key c7e2dc9e8aa6f9c23d379e0f5e3057a69b931b886bbb74ded9f660c06d457463 true
-check_key b97324364941e06f2ab4f5153a368f9b07c524a89e246720099042ad9e8c1c5b false
-check_key eff75c70d425f5bba0eef426e116a4697e54feefac870660d9cf24c685078d75 false
-check_key 161f3cd1a5873788755437e399136bcbf51ff5534700b3a8064f822995a15d24 false
-check_key 63d6d3d2c21e88b06c9ff856809572024d86c85d85d6d62a52105c0672d92e66 false
-check_key 1dc19b610b293de602f43dca6c204ce304702e6dc15d2a9337da55961bd26834 false
-check_key 28a16d02405f509e1cfef5236c0c5f73c3bcadcd23c8eff377253941f82769db true
-check_key 682d9cc3b65d149b8c2e54d6e20101e12b7cf96be90c9458e7a69699ec0c8ed7 false
-check_key 0000000000000000000000000000000000000000000000000000000000000000 true
-check_key 0000000000000000000000000000000000000000000000000000000000000080 true
-check_key 0100000000000000000000000000000000000000000000000000000000000000 true
-check_key 0100000000000000000000000000000000000000000000000000000000000080 false
-check_key 0200000000000000000000000000000000000000000000000000000000000000 false
-check_key 0200000000000000000000000000000000000000000000000000000000000080 false
-check_key 0300000000000000000000000000000000000000000000000000000000000000 true
-check_key 0300000000000000000000000000000000000000000000000000000000000080 true
-check_key 0400000000000000000000000000000000000000000000000000000000000000 true
-check_key 0400000000000000000000000000000000000000000000000000000000000080 true
-check_key 0500000000000000000000000000000000000000000000000000000000000000 true
-check_key 0500000000000000000000000000000000000000000000000000000000000080 true
-check_key 0600000000000000000000000000000000000000000000000000000000000000 true
-check_key 0600000000000000000000000000000000000000000000000000000000000080 true
-check_key 0700000000000000000000000000000000000000000000000000000000000000 false
-check_key 0700000000000000000000000000000000000000000000000000000000000080 false
-check_key 0800000000000000000000000000000000000000000000000000000000000000 false
-check_key 0800000000000000000000000000000000000000000000000000000000000080 false
-check_key 0900000000000000000000000000000000000000000000000000000000000000 true
-check_key 0900000000000000000000000000000000000000000000000000000000000080 true
-check_key 0a00000000000000000000000000000000000000000000000000000000000000 true
-check_key 0a00000000000000000000000000000000000000000000000000000000000080 true
-check_key 0b00000000000000000000000000000000000000000000000000000000000000 false
-check_key 0b00000000000000000000000000000000000000000000000000000000000080 false
-check_key 0c00000000000000000000000000000000000000000000000000000000000000 false
-check_key 0c00000000000000000000000000000000000000000000000000000000000080 false
-check_key 0d00000000000000000000000000000000000000000000000000000000000000 false
-check_key 0d00000000000000000000000000000000000000000000000000000000000080 false
-check_key 0e00000000000000000000000000000000000000000000000000000000000000 true
-check_key 0e00000000000000000000000000000000000000000000000000000000000080 true
-check_key 0f00000000000000000000000000000000000000000000000000000000000000 true
-check_key 0f00000000000000000000000000000000000000000000000000000000000080 true
-check_key 1000000000000000000000000000000000000000000000000000000000000000 true
-check_key 1000000000000000000000000000000000000000000000000000000000000080 true
-check_key 1100000000000000000000000000000000000000000000000000000000000000 false
-check_key 1100000000000000000000000000000000000000000000000000000000000080 false
-check_key 1200000000000000000000000000000000000000000000000000000000000000 true
-check_key 1200000000000000000000000000000000000000000000000000000000000080 true
-check_key 1300000000000000000000000000000000000000000000000000000000000000 true
-check_key 1300000000000000000000000000000000000000000000000000000000000080 true
-check_key daffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key daffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key dbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key dbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key dcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key dcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key ddffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key ddffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key deffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key deffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key dfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key dfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key e0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key e0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key e1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key e1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key e2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key e2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key e3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key e3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key e4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key e4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key e5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key e5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key e6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key e6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key e7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key e7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key e8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key e8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key e9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key e9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key eaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key eaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true
-check_key ebffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key ebffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true
-check_key ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key efffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key efffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key f1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key f1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key f2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key f2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key f4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key f4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key f5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key f5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key f8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key f8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key f9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key f9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key faffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key faffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key fbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key fbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key fcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key fcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key fdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key fdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-check_key ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false
-check_key ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false
-hash_to_ec da66e9ba613919dec28ef367a125bb310d6d83fb9052e71034164b6dc4f392d0 52b3f38753b4e13b74624862e253072cf12f745d43fcfafbe8c217701a6e5875
-hash_to_ec a7fbdeeccb597c2d5fdaf2ea2e10cbfcd26b5740903e7f6d46bcbf9a90384fc6 f055ba2d0d9828ce2e203d9896bfda494d7830e7e3a27fa27d5eaa825a79a19c
-hash_to_ec ed6e6579368caba2cc4851672972e949c0ee586fee4d6d6a9476d4a908f64070 da3ceda9a2ef6316bf9272566e6dffd785ac71f57855c0202f422bbb86af4ec0
-hash_to_ec 9ae78e5620f1c4e6b29d03da006869465b3b16dae87ab0a51f4e1b74bc8aa48b 72d8720da66f797f55fbb7fa538af0b4a4f5930c8289c991472c37dc5ec16853
-hash_to_ec ab49eb4834d24db7f479753217b763f70604ecb79ed37e6c788528720f424e5b 45914ba926a1a22c8146459c7f050a51ef5f560f5b74bae436b93a379866e6b8
-hash_to_ec 5b79158ef2341180b8327b976efddbf364620b7e88d2e0707fa56f3b902c34b3 eac991dcbba39cb3bd166906ab48e2c3c3f4cd289a05e1c188486d348ede7c2e
-hash_to_ec f21daa7896c81d3a7a2e9df721035d3c3902fe546c9d739d0c334ed894fb1d21 a6bedc5ffcc867d0c13a88a03360c8c83a9e4ddf339851bd3768c53a124378ec
-hash_to_ec 3dae79aaca1abe6aecea7b0d38646c6b013d40053c7cdde2bed094497d925d2b 1a442546a35860a4ab697a36b158ded8e001bbfe20aef1c63e2840e87485c613
-hash_to_ec 3d219463a55c24ac6f55706a6e46ade3fcd1edc87bade7b967129372036aca63 b252922ab64e32968735b8ade861445aa8dc02b763bd249bff121d10829f7c52
-hash_to_ec bc5db69aced2b3197398eaf7cf60fd782379874b5ca27cb21bd23692c3c885cc ae072a43f78a0f29dc9822ae5e70865bbd151236a6d7fe4ae3e8f8961e19b0e5
-hash_to_ec 98a6ed760b225976f8ada0579540e35da643089656695b5d0b8c7265a37e2342 6a99dbfa8ead6228910498cc3ff3fb18cb8627c5735e4b8657da846c16d2dcad
-hash_to_ec e9cdc9fd9425a4a2389a5d60f76a2d839f0afbf66330f079a88fe23d73eae930 8aa518d091928668f3ca40e71e14b2698f6cae097b8120d7f6ae9afba8fd3d60
-hash_to_ec a50c026c0af2f9f9884c2e9b8464724ac83bef546fec2c86b7de0880980d24fb b07433f8df39da2453a1e13fd413123a158feae602d822b724d42ef6c8e443bf
-hash_to_ec bf180e20d160fa23ccfa6993febe22b920160efc5a9614245f1a3a360076e87a 9d6454ff69779ce978ea5fb3be88576dc8feaedf151e93b70065f92505f2e800
-hash_to_ec b2b64dfeb1d58c6afbf5a56d8c0c42012175ebb4b7df30f26a67b66be8c34614 0523b22e7f220c939b604a15780abc5816709b91b81d9ee1541d44bd2586bbd8
-hash_to_ec 463fc877f4279740020d10652c950f088ebdebeae34aa7a366c92c9c8773f63a daa5fa72e70c4d3af407b8f2f3364708029b2d4863bbdde54bd67bd08db0fcad
-hash_to_ec 721842f3809982e7b96a806ae1f162d98ae6911d476307ad1e4f24522fd26f55 4397c300a8cfcb42e7cc310bc975dc975ec2d191eaa7e0462998eb2830c34126
-hash_to_ec 384da8d9b83972af8cbefc2da5efc744037c8ef40efa4b3bacc3238a6232963d 3c80f107e6868f73ef600ab9229a3f4bbe24f4adce52e6ab3a66d5d510e0670d
-hash_to_ec e26f8adef5b6fe5bb01466bff0455ca23fda07e200133697b3b6430ca3332bde e262a58bcc1f8baf1980e00d5d40ba00803690174d14fb4c0f608429ce3df773
-hash_to_ec 6e275b4ea4f085a5d3151aa08cf16a8c60b078e70be7ce5dac75b5d7b0eebe7c cb21b5a7744b4fcdc92ead4be0b04bcb9145e7bb4b06eff3bb2f0fe429b85108
-hash_to_ec a0dde4561ad9daa796d9cd8a3c34fd41687cee76d128bf2e2252466e3ef3b068 79a2eb06bb7647f5d0aae5da7cf2e2b2d2ce890f25f2b1f81bfc5fef8c87a7d3
-hash_to_ec dbaf63830e037b4c329969d1d85e58cb6c4f56014fd08eb38219bd20031ae27c 079c93ae27cd98075a487fd3f7457ad2fb57cdf12ec8651fedd944d765d07549
-hash_to_ec 1e87ba8a9acf96948bc199ae55c83ab3277be152c6d0b1d68a07955768d81171 5c6339f834116791f9ea22fcc3970346aaeddacf13fbd0a7d4005fbd469492ca
-hash_to_ec 5a544088e63ddf5b9f444ed75a75bc9315c4c50439522f06b4823ecaf5e8a08d e95ca0730d57c6469be3a0f3c94382f8490257e2e546de86c650bdbc6482eaee
-hash_to_ec e4e06d92ebb036a5e4bb547dbaa43fd70db3929eef2702649455c86d7e59aa46 e26210ff8ee28e24ef2613df40aa8a874b5e3c1d07ae14acc59220615aa334dc
-hash_to_ec 5793b8b32dcc0f204501647f2976493c4f8f1fa5132315226f99f29a5a6fdfce 656e390086906d99852c9696e831f62cb56fc8f85f9a5c936c327f23c7faf4fe
-hash_to_ec 84f56fa4d7f12e0efd48b1f7c81c15d6e3843ebb419f4a27ec97028d4f9da19e 0cbd4f0cd288e1e071cce800877de6aef97b63fff867424a4f2b2bab25602608
-hash_to_ec 242683ddf0a9fc55f6585de3aa64ea17c9c544896ff7677cd82c98f833bdf2ca 38c36d52314549213df7c7201ab7749a4724cbea92812f583bb48cabc20816ad
-hash_to_ec a93ee320dc030aa382168c2eb6d75fce6e5a63a81f15632d514c6de8a7cfa5ee bd0a2facaa95bc95215a94be21996e46f789ee8beb38e75a1173b75fc686c505
-hash_to_ec e36136601d84475d25c3f14efe030363d646658937a8a8a19a812d5e6deb5944 2fb93d78fae299c9f6b22346acfb829796ee7a47ec71db5456d8201bec6c35a3
-hash_to_ec ba4b67d3d387c66baa4a32ec8b1db7681087e85076e71bab10036388c3aeb011 cc01329ce56f963bf444a124751c45b2c779ccb6dea16ca05251baca246b5401
-hash_to_ec 3fbc91896a2585154d6f7094c5ab9c487e29a27951c226eec1235f618e44946b 7d983acbb901bf5497d0708392e5e742ec8c8036cbb0d03403e9929da8cc85a7
-hash_to_ec a2da289fed650e9901f69a5f33535eb47c6bd07798633cbf6c00ce3172df76ac dca8a4d30ec2d657fefd0dba9c1c5fd45a79f665048b3cf72ac2c3b7363da1ac
-hash_to_ec 99025d2d493f768e273ed66cacd3a5b392761e6bd158ca09c8fba84631ea1534 7ef5af79ab155ab7e1770a47fcd7f194aca43d79ec6e303c7ce18c6a20279b04
-hash_to_ec 3cf1d01d0b70fb31f2a2f979c1bae812381430f474247d0b018167f2a2cd9a9f 7c53d799ec938a21bb305a6b5ca0a7a355fa9a68b01d289c4f22b36ce3738f95
-hash_to_ec 639c421b49636b2a1f8416c5d6e64425fe51e3b52584c265502379189895668e 0b47216ae5e6e03667143a6cf8894d9d73e3152c64fb455631d81a424410e871
-hash_to_ec 4ccf2c973348b7cc4b14f846f9bfcdcb959b7429accf6dede96248946841d990 7fd41f5b97ba42ed03947dd953f8e69770c92cc34b16236edad7ab3c78cbbb2e
-hash_to_ec f76ae09fff537f8919fd1a43ff9b8922b6a77e9e30791c82cf2c4b8acb51363e 8e2c6bf86461ad2c230c496ee3896da33c11cc020fd4c70faa3645b329049234
-hash_to_ec 98932da7450f15db6c1eef78359904915c31c2aa7572366ec8855180edb81e3a 86180adddfac0b4d1fb41d58e98445dde1da605b380d392e9386bd445f1d821c
-hash_to_ec ab26a1660988ec7aba91fc01f7aa9a157bbc12927f5b197062b922a5c0c7f8dd 2c44a43eda0d0aad055f18333e761f2f2ec11c585ec7339081c19266af918e4f
-hash_to_ec 4465d0c1b4930cc718252efd87d11d04162d2a321b9b850c4a19a6acdfca24f4 b03806287d804188a4d679a0ecee66f399d7bdc3bd1494f9b2b0772bbb5a034f
-hash_to_ec 0f2a7867864ed00e5c40082df0a0b031c89fa5f978d9beb2fde75153f51cfb75 5c471e1b118ef9d76c93aec70e0578f46e8db1d55affd447c1f64c0ad9a5caa5
-hash_to_ec 5c2808c07d8175f332cae050ce13bec4254870d76abff68faf34b0b8d3ad5000 eeff1d9a5aa428b7aecc575e63dde17294072eb246568493e1ed88ce5c95b779
-hash_to_ec 36300a21601fad00d00da45e27b36c11923b857f97e50303bd01f21998eaef95 b33b077871e6f5dad8ff6bc621c1b6dedcf700777d996c8c02d73f7297108b7e
-hash_to_ec 9e1afb76d6c480816d2cedd7f2ab08a36c309efaa3764dcdb51bad6049683805 4cd96ba7b543b1a224b8670bf20b3733e3910711d32456d3e58e920215788adf
-hash_to_ec 685f152704664495459b76c81567a4b571e8b307dd0e3c9b08ee95651a006047 80dd6b637580cb3be76025867f1525852b65a7a66066993fda3af7eb187dc1a5
-hash_to_ec 0b216444391a1163c14f7b27f9135e9747978c0e426dce1fa65c657f3e9146be 021259695a6854a4a03e8c74d09ab9630a401bfca06172a733fe122f01af90b4
-hash_to_ec cfcb35e98f71226c3558eaa9cf620db5ae207ece081ab13ddea4b1f122850a5a 46763d2742e2cdffe80bb3d056f4d3a1565aa83f19aab0a1f89e54ad81ae0814
-hash_to_ec 07e7292da8cdcdb58ee30c3fa16f1d609e9b3b1110dd6fa9b2cc18f4103a1c12 fe949ca251ac66f13a8925ae624a09cdbf6696d3c110442338d37700536e8ec7
-hash_to_ec 813bc7e3749e658190cf2a4e358bc07a6671f262e2c4eef9f44c66066a72e6a7 6b92fbda984bd0e6f4af7a5e04c2b66b6f0f9d197a9694362a8556e5b7439f8a
-hash_to_ec 89c50a1e5497156e0fae20d99f5e33e330362b962c9ca00eaf084fe91aaec71d ef36cb75eb95fb761a8fa8c376e9c4447bcd61421250f7a711bd289e6ed78a9b
-hash_to_ec d9bd9ff2dd807eb25de7c5de865dbc43cce2466389cedbc92b90aab0eb014f81 30104771ff961cd1861cd053689feab888c57b8a4a2e3989646ea7dea40f3c04
-hash_to_ec b8c837501b6ca3e118db9848717c847c062bf0ebeca5a7c211726c1426878af5 19a1e204b4a32ce9cccf5d96a541eb76a78789dceaf4fe69964e58ff96c29b63
-hash_to_ec 84376c5350a42c07ac9f96e8d5c35a8c7f62c639a1834b09e4331b5962ecace8 ba1e4437d5048bd1294eadc502092eafc470b99fde82649e84a52225e68e88f2
-hash_to_ec a3345e4a4cfc369bf0e7d11f49aed0d2a6ded00e3ff8c7605db9a919cf730640 0d318705c16e943c0fdcde134aaf6e4ccce9f3d9161d001861656fc7ea77a0b1
-hash_to_ec 3c994dfb9c71e4f401e65fd552dc9f49885f88b8b3588e24e1d2e9b8870ffab1 984157de5d7c2c4b43b2bffea171809165d7bb442baea88e83b27f839ebdb939
-hash_to_ec 153674c1c1b18a646f564af77c5bd7de452dc3f3e1e2326bfe9c57745b69ec5c e9a4a1e225ae472d1b3168c99f8ba1943ad2ed84ef29598f3f96314f22db9ef2
-hash_to_ec 2d46a705d4fe5d8b5a1f4e9ef46d9e06467450eb357b6d39faa000995314e871 b9d1aec540bf6a9c0e1b325ab87d4fbe66b1df48986dde3cb62e66e136eba107
-hash_to_ec 6764c3767f16ec8faecc62f9f76735f76b11d7556aeb61066aeaeaad4fc9042f 3a5c68fb94b023488fb5940e07d1005e7c18328e7a84f673ccd536c07560a57b
-hash_to_ec c99c6ee5804d4b13a445bc03eaa07a6ef5bcb2fff0f71678dd3bd66b822f8be8 a9e1ce91deed4136e6e53e143d1c0af106abde9d77c066c78ebbf5d227f9dde0
-hash_to_ec 3009182e1efac085c7eba24a7d9ef28ace98ebafa72211e73a41c935c37e6768 e55431a4c89d38bd95f8092cdf6e44d164ad5855677aba17ec262abc8c217c86
-hash_to_ec e7153acd114a7636a207be0b67fa86fee56dd318f2808a81e35dd13d4251b2d0 ff2b98d257e4d4ff7379e8871441ca7d26e73f78f3f5afcf421d78c9799ba677
-hash_to_ec 6378586744b721c5003976e3e18351c49cd28154c821bc45338892e5efedd197 3d765fb7bb4e165a3fa6ea00b5b5e22250f3861f0db0099626d9a9020443dda2
-hash_to_ec 5be49aba389b7e3ad6def3ba3c7dbec0a11a3c36fc9d441130ef370b8a8d29c2 2d61faf38062dc98ae1aaafec05e90a925c9769df5b8b8f7090d9e91b2a11151
-hash_to_ec f7bc382178d38e1b9a1a995bd8347c1283d8a2e8d150379faa53fd125e903d2b 544c815da65c3c5994b0ac7d6455578d03a2bc7cf558b788bcdb3430e231635a
-hash_to_ec c28b5c4b6662eebb3ec358600644849ebeb59d827ed589c161d900ca18715fa8 a2d64db3c0e0353c257aadf9abc12ac779654d364f348b9f8e429aa7571203db
-hash_to_ec 3a4792e5df9b2416a785739b9cf4e0d68aef600fa756a399cc949dd1fff5033a 4b54591bd79c30640b700dfb7f20158f692f467b6af70bd8a4e739c14a66c86a
-hash_to_ec 002e70f25e1ceaf35cc14b2c6975a4c777b284a695550541e6f5424b962c19f5 73987e9342e338eb57a7a9e03bd33144db37c1091e952a10bd243c5bb295c18a
-hash_to_ec 7eb671319f212c9cae0975571b6af109124724ba182937a9066546c92bdeff0c 49b46da3be0df1d141d2a323d5af82202afa2947a95b9f3df47722337f0d5798
-hash_to_ec ca093712559c8edd5c51689e2ddcb8641c2960e5d9c8b03a44926bb798a0c8dc b9ef9cf0f8e4a3d123db565afafb1102338bfb75498444ac0a25c5ed70d615da
-hash_to_ec cfea0a08a72777ff3aa7be0d8934587fa4127cd49a1a938232815dc3fd8b23ac b4de604b3d712f1ef578195fb0e53c865d41e2dfe425202c6cfe6f10e4404eb5
-hash_to_ec aa0122ae258d6db21a26a31c0c92d8a0e3fdb46594aed41d561e069687dedcd6 5247eaec346de1c6cddf0ab04c12cd1d85cdb6d3a2fba2a5f9a5fe461abef5eb
-hash_to_ec b3941734f4d3ba34ccaf03c4c737ac5a1e036eb74309300ce44d73aca24fef08 535938985c936e3780c61fe29a4121d6cb89a05080b6c2147031ea0c2b5b9829
-hash_to_ec 8c2ee1041a2743b30dcbf413cc9232099b9268f82a5a21a09b63e7aff750882f 6ad0d4b3a65b522dfad0e9ac814b1fb939bc4910bd780943c72f57f362754cca
-hash_to_ec 4b6829a2a2d46c8f0d0c23db0f735fcf976524bf39ccb623b919dd3b28ad5193 2e0097d7f92993bc45ba06baf4ca63d64899d86760adc4eb5eeefb4a78561050
-hash_to_ec 9c1407cb6bba11e7b4c1d274d772f074f410d6fe9a1ee7a22cddf379257877d9 692261c7d6a9a7031c67d033f6d82a68ef3c27bd51a5666e55972238769821cd
-hash_to_ec 638c42e4997abf8a4a9bffd040e31bd695d590cde8afbd7efd16ffdbae63bf66 793024c8ce196a2419f761dde8734734af6bd9eb772b30cc78f2cb89598dce97
-hash_to_ec 1fb60d79600de151a1cf8a2334deb5828632cbd91cb5b3d45ae06e08187ae23d ff2542cde5bc2562e69471a31cfc3d0c26e2f6ccc1891a633b07a3968e42521c
-hash_to_ec d2fdbbae4e38a1b734151c3df52540feb2d3ff74edfef2f740e49a5c363406ee 344c83ba6ff4e38b257077623d298d2f2b52002645021241bc9389f81b29ad12
-hash_to_ec 836c27a6ddfe1a24aba3d6022dff6dfe970f142d8b4ac6afb8efcba5a051942f b8af481d33726b3f875268282d621e4c63f891a09f920b8f2f49080f3a507387
-hash_to_ec 46281153ddcdf2e79d459693b6fe318c1969538dd59a750b790bfff6e9481abf 8eaf534919ab6573ba4e0fbde0e370ae01eae0763335177aa429f61c4295e9d4
-hash_to_ec d57b789e050bf3db462b79a997dac76aa048d4be05f133c66edee56afd3dbe66 0c5a294cb2cbb6d9d1c0a1d57d938278f674867f612ed89dcbe4533449f1a131
-hash_to_ec 548d524d03ac22da18ff4201ce8dbee83ad9af54ee4e26791d26ed2ab8f9bfc7 c6609d9e7d9fd982dec8a166ff4fb6f7d195b413aad2df85f73d555349134f3b
-hash_to_ec cc920690422e307357f573b87a6e0e65f432c6ec12a604eb718b66ba18897a56 6f11c466d1c72fccd81e51d9bda03b6e8d6a395e1d931b2a84e392dc9a3efa18
-hash_to_ec c7fb8a51f5fcd8824fc0875d4eb57ab4917cb97090a6e2288f852f2bb449edd9 45543fea6eed461016e48598b521f18ff70178afea18032b188deea3e56052fc
-hash_to_ec c681bb1b829e24b1c52cb890036b89f0029d261c6a15e5b2c684ee7dfe91e746 263006fe2c6b08f1ab29cdf442472c298e2faf225bbf5c32399d3745cd3904bd
-hash_to_ec e06411c542312fdd305e17e46be14c63bab5836dc8751da06164b1ae22d4e20f 901871be7a7ff5aecade2acff869846f3c50de69307ac155f2aa3a74d5472ef2
-hash_to_ec 9c725a2acb80fa712f9781da510e5163b1b30f4e1c064c26b5185e537f0614ea 02420d49257846eb39fddd196d3171679f6be21d9adac667786b65a6e90f57b1
-hash_to_ec 22792772820feafa85c5cb3fa8f876105251bef08617d389619697f47dff54f2 a3ad444e7811693687f3925e7c315ae55d08d9f4b0a29876bc2a891ab941c1c3
-hash_to_ec 0587b790121395d0f4f39093d10b4817f58a1e80621a24eea22b3c127d6ac5a2 86c417c695c64c7becaad0d59ddbb2bca4cb2b409a21253d680aac1a08617095
-hash_to_ec fa0b5f28399bef0cd87bfe6b8a2b69e9c5506fb4bacd22deba8049615a5db526 ede0ea240036ff75d075258a053f3ce5d6f77925d358dbe33c06509fc9b12111
-hash_to_ec 62a3274fc0bed109d5057b865c2ba6b6a5a417cb90a3425674102fcd457ede2d ff7e46751bb4dcd1e800a8feab7cf6771f42dc0cfed7084c23b8a5d255a6f34e
-hash_to_ec a6fcd4aecaaaf281563b9b7cd6fbc7b1829654f644f4165942669a2ef632b2bf 28f136be0eb957a5b36f8ec294399c9f73ad3a3c9bb953ad191758ced554a233
-hash_to_ec 01baa4c06d6676c9b286cda76ed949fd80a408b3309500ba84a5bb7e3dce58e2 a943d1afa2efce284740e7db21ea02db70b124808be2ff80cbf9b9cb96c7b73e
-hash_to_ec dd9aff9c006ba514cef8fae665657bc9813fe2715467cf479643ea4c4e365d6d 68de2f7d49de4004286ce0989a06a686b15d0f463a02ffd448a18914e1ddf713
-hash_to_ec 3df3513d5e539161761ce7992ab9935f649bc934bed0da3c5e1095344b733bb9 e9c2dd747d7b2482474325943cd850102b8093164678362c7621993a790e2a8a
-hash_to_ec 7680cfb244dc8ef37c671fff176be1a3dad00e5d283f93145d0cbee74cca2df4 a0fd8c3cca16a130eaa5864cbe8152b7adfbf09e8cf72244b2fc8364c3b20bf4
-hash_to_ec 8a547c38bd6b219ea0d612d4a155eba9c56034a1405dcf4b608de787f37e0fd8 76bf0dc40fd0a5508c5e091d8bb7eccfa28b331e72c6a0d4ac0e05a3d651850b
-hash_to_ec dd93901621f58465e9791012afa76908f1e80ad80e52b809dc7fc32bb004f0a8 09a0b7ecfe8058b1e9ee01c9b523826867ca97a32efad29ac8ceebca67a4ea00
-hash_to_ec b643010220f1f4ee6c7565f6e1b3dc84c18274ede363ac36b6af3707e69a1542 233c9ff8de59e5f96c2f91892a71d9d93fa7316319f30d1615f10ac1e01f9285
-hash_to_ec c2637b2299dfc1fd7e953e39a582bafd19e6e7fff3642978eb092b900dbfea80 339587ba1c05e2cba44196a4be1fd218b772199e2c61c3c0ff21dcd54b570c43
-hash_to_ec 1f36d3a7e7c468eb000937de138809e381ad2e23414cbbaac49b7f33533ed486 7e5b0a96051c77237a027a79764c2763487af88121c7774645e97827fb744888
-hash_to_ec 8c142a55f60b2edbe03335b7f90aa2bd63e567048a65d61c70cb28779c5200af d3d6d5563b3d81c8c91cf9806bb13b2850fb7c162c610fd2f5b83c464add8182
-hash_to_ec 99e7b98293c9de1f81aff1376485a990014b8b176521b2a68cdbde6300190398 119cbc01a1d9b9fb4759031d3a70685aebea0f01bc5ee082ce824265fd21b3b4
-hash_to_ec 9753bd38be072b51490290be6207ca4545e3541bdf194e0850ae0a9f9e64b8ba 1ad3aa759863153606fa6570f0e1290baded4c8c1f2ba0f67c1911bfc8ccd7a0
-hash_to_ec 322703864ceee19b7f17cec2a822f310f0c4da3ff98b0be61a6fd30ac4db649c 89d9e7a5947e1cde874e4030de278070aae363063cd3592ce5411821474f0816
-hash_to_ec c1acd01e1e535fad273a8b757d981470f43dd7d95af732901fbba16b6e245761 57e80445248111150da5e63c706b4abbf3eef2cc508bd0347ff6b81e8c59f5bc
-hash_to_ec 492473559f181bbe78f60215bc6d3a5168435ea2fc0a508372d6f5ca126e9767 df3965f137cf6f60c56ebd7c8f246281fd6dc92ce23a37e9f846f8452c884e01
-hash_to_ec afa9d6e0e2fb972ee806beb450c2c0165e58234b0676a4ec0ca19b6e710d7c35 669a57e69dd2845a5e50ed8e5d8423ac9ae792a43c7738554d6c5e765a7b088a
-hash_to_ec 094de050bdadef3b7dbaeeca29381c667e63e71220970149d97b95db8f4db61b 0cf5d03530c5e97850d0964c6a394de9cde1e8e498f8c0e173c518242c07f99a
-hash_to_ec 2ce583724bc699ad800b33176a1d983512fe3cb3afa65d99224b23dae223efb7 e1548fd563c75ae5b5366dbab4cb73c54e7d5e087c9e5453125ff8fbe6c83a5c
-hash_to_ec 8064974b976ff5ef6adaade6196ab69cda6970cd74f7f5899181805f691ad970 98ae63c47331a4ac433cb2f17230c525982d89d21e2838515a36ec5744ec2d15
-hash_to_ec 384911047de609c6ae8438c745897357989363885cef2381a8a00a090cf04a58 4692ec3a0a03263620841c108538d584322fdd24d221a74bf1e1f407f83828af
-hash_to_ec 0e1b1ced5ae997ef9c10b72cfc6d8c36d7433c01fc04f4083447f87243282528 6ee443ab0637702b7340bd4a908b9e2e63df0cc423c409fb320eb3f383118b80
-hash_to_ec 5a7aea70c85c040af6ff3384bcaa63ec45c015b55b44fffa37ab982a00dc57c5 2df2e20137cefd166c767646ecd2e386d28f405aebe43d739aa55beba04ed407
-hash_to_ec 3e878a3567487f20f7c98ea0488a40b87f1ba99e50bbfe9f00a423f927cbd898 697c7e60e4bf8c429ba7ac22b11a4b248d7465fc6abe597ec6d1e1c973330688
-hash_to_ec c0bb08350d8a4bb6bf8745f6440e9bd254653102a81c79d6528da2810da758e4 396a872ac9147a69b27223bf4ec4198345b26576b3690f233b832395f2598235
-hash_to_ec 6c3026a9284053a4ddb754818f9ae306ffa96eb7003bd03826eeccc9a0cf656e bef73da51d3ba9972a33d1afb7d263094b66ab6dbe3988161b08c17f8c69c2d5
-hash_to_ec f80b7d8f5a80d321af3a42130db199d9edcb8f5a82507d8bfca6d002d65458b6 aa59c167ea60ee024421bfbd00adbb3cbfc20e16bd3c9b172a6bef4d47ca7f57
-hash_to_ec bc0ffc24615aa02fafef447f17e7b776489cd2cc909f71e8344e01cad9f1610d 5c4195cc8dc3518143f06a9c228ae59ec9a6425a8fab89bfc638ad997cf35220
-hash_to_ec b15fad558737229f8816fcba8fbef805bd420c03e392d118c69bdf01890c4924 f5810477e37554728837f097e1b170d1d8c95351c7fff8abbbfc624e1a50c1b9
-hash_to_ec ec8c1f10d8e9da9cf0d57c4a1f2c402771bed7970109f3cf21ad32111f1f198f a697e0a3f09827b0cf3a4ffb6386388feda80d30ffffcbd54443dafcba162b28
-hash_to_ec a989647bf0d70fdb7533b8c303a2a07f5e42e26a45ffc4e48cff5ba88643a201 450fd73e636f94d0d232600dd39031386b0e2ecde4105124fc451341da9803db
-hash_to_ec 7159971b03c365480d91d625a0fadc8e3a632c518acf0dbec87dd659da70e168 377bc43c038ac46cf6565aa0a6d6bf39968c0c1142755dba3141eeebf0acdf5d
-hash_to_ec e39089a64fedac4b2c25e36312b33f79d02bf75a883f450f910915b8560a3b06 77efa7db1be020e77596f550de45626824a8268095d56a0991696b211cb329cc
-hash_to_ec 2056b3c6347611bb0929dad00ec932a4d9bec0f06b2d57f17e01ffa1528a719e b6072c2be2ce928e8cbbb87e8eb7e06975c0f93b309dd3b6a29edaad2b56f99b
-hash_to_ec 2c026793146e81b889fc741d62e06c341ce263560d57cd46d0376f5b29174489 8f1f64b67762aa784969e954c196a2c6610addc3604aa3291eb0b80304dfe9ef
-hash_to_ec be6026d6704379c489fa7749832b58bdb1a9685a5ffb68c438537f2f76e0011f 0072569a4090a9ad383a205bb092196c9de871c22506e3bb63d6b9d1b2357c96
-hash_to_ec f4db802d5c6b7d7b53663b03d988b4cd0c7cad6c26612c5307754a93ebdc9710 f21bc9be4cb28761f6fe1d0a555ad5e9748375a2e9faea25a1df75cc8d273e18
-hash_to_ec c27d79a564c56b00956a55090481e85fbc837fd5fb5e8311ecb436e300c07e3a 1b1891e6abec74621501450cd68bb1eeaa5b2fffff4ec441a55d1235ff3a0842
-hash_to_ec a1e2f93c717cad32af386efa624198973df5a710963dd19d4c3ac40032a3a286 69c60571e3f9f63d2bfb359386ae3b8cd9e49a2e9127753002866e85c0443573
-hash_to_ec 76920d7b1763474bc94a16433c3c28241a9acdee3ff2b2cb0e6757ba415310aa c1b409169f102b696fc7fa1aa9c48631e58e08b5132b6aadf43407627bb1b499
-hash_to_ec 57ac654b29fa227c181fff2121491fcb283af6cbe932c8199c946862c0e90cb2 a204e8d327ea93b0b1bd74a78ffc370b20cea6455e209f2bc258114baa16d728
-hash_to_ec 88e66cfaef6432b759c50efce885097d1752252b479dac5ed822fa6c85d56427 6fb84790d3749a5c1088209ee3823848d9c19bf1524215c44031143dd8080d70
-hash_to_ec c1e55da929c4f8f793696fc77ff4e1c317c34852d98403bfd15dd388ee7df0df 2f41e76f15c5b480665bd84067e3b543b85ce6de02be9da7a550b5e1ead94d34
-hash_to_ec 29e9ace5aa3c5a572b13f4b62b738a764d90c8c293ccb062ad798acbab7c5ef4 bce791aba1edc2a66079628fd838799489ab16b0a475ce7fe62e24cc56fe131c
-hash_to_ec f25b2340689dadacaa9a0ef08aee8447d80b982e8a1ea42cf0500a1b9d85b37d f7f53aa117e6772a9abc452b3931b0a99405ac45147e7c550ac9fcf7ffe377b5
-hash_to_ec 0cb6c47fc8478063b33f5aed615a05bcc84d782c497b6cc8e76ec1fa11edbfdb 7a0b58b03147e7c9be1d98de49ead2ce738d0071b0af8ca03cc92ceb26fc2246
-hash_to_ec 7bd7287d7c4b596fe46fe57a6982c959653487bea843a77dd47d40986200d576 343084618c58284c64a5ff076f891be64885dc2ac73fa1567f7b39fde6b91542
-hash_to_ec e4984bf330708152254fb18ecef12d546afd24898a3cf00fba866957b6ee1b82 c70e88b061656181fbd6ff12aca578fb66de5553c756ea4698a248b177185bc6
-hash_to_ec cefd6c3cb9754ea632d6aea140af017de5ea12e5184f868936b74d9aa349d603 4b476502a8a483aadd50667f262f95351901628dd3a2aac1a5a41c4ea03f1647
-hash_to_ec da5d0f33344ee7f3345204badf183491b9452b84bccc907602c7bad43e5cf43e 9561b9e61241625e028361494d4fa5cd78df4c7219fa64c8fede6d8421b8904a
-hash_to_ec d6f0a4f8c770a1274a76fd7ae4e5faf7779249263e1aaecc6f815cf376f5c302 cd5c55820be10f0d38feb81363ede3716a9168601a0dd1ce3109aab81367d698
-hash_to_ec b6bf32491d12a41c275d8518fc534d9a0d17aade509e7e8b8409a95c86167307 4aae534abbd67a9a8f2974154606c0e9be8932e920c7a5e931b46a92859acf82
-hash_to_ec 0f930beaad041f9cefd867bc194027dd651fb3c9bda5944ececdba8a7136b6d3 521708f8149891b418d0920369569a9d578029c78f8e41c68a0bb68d3ad5df60
-hash_to_ec 49b1fe0f97be74b81e0b047027b3e9f726fa5e90a67dafa877309397291c06c5 0852e59dfae5ec32cce606c119376597bce5cd4d04879d329f74e3ec66414cd3
-hash_to_ec 4d57647d03f2cfbd4782fcc933e0683b52d35fc8d37283e6c7de522ddfa7e698 cbeb9ebfbbc49ec81fac3b7b063fecac1bb40ea686d3ffb08f82b291715cd87f
-hash_to_ec 4ea3238c06fc9346c7421ff85bc0244b893860b94bc437378472814d09b2e99f a1fbae941adc344031bbdf53385dfdc012311490a4eb5e9a2749a21b27ce917a
-hash_to_ec 0cd3609f5c78b318cb853d189b73b1ee2d00edd4e5fce2812027daa3fcb1fed1 0c7a7241b16e3c47d41f5abbf205797bd4b63fc425a7120cb2a4bf324e08ae74
-hash_to_ec d74ab71428e36943c9868f70d3243469babd27988a1666a06f499a5741a52e3e 65b7c259f3b4547c082b2a7669b2b363668c4d87ac14e80471317b03b34e5216
-hash_to_ec f6b151998365e7d69bcbce383dd2e8b5bf93b8b72f029ff942588208c1619591 6ce840ce5dfbca238665c1e6eddb8b045aa85c69b5976fc55ab57e66d3d0a791
-hash_to_ec 207751de234b2bd7ec20bdd8326210c23aa68f04875c94ad7e256a96520f25d6 fc8f79ab3af317c38bfb88f40fb84422995a0479cfa6b03fa6df7f4e5f2813fb
-hash_to_ec 62291e2873f38c0a234b77d1964205f3f91905c261d3c06f81051a9b0cb787cb 076d1d767457518e6777cb3bd4df22c8a19eb617e4bbccd1b0bd37522d6597a5
-hash_to_ec 4b060df2d2854036751d00190ee821cb0066d256d4172539fdfa6fbd1cdfe1f9 59866e927c69e7de5df00dc46c0d2a1ddf799d901128ff040cebb8fd61b95da4
-hash_to_ec ac8daf73f9c609bb36bce4fdeec1e50be5f22de38c3904fabcf758f0fc180bc7 7d8dc4e956363b652468a5fecafd7c08d48a2297e93b8edcb38e595fdd5a1fde
-hash_to_ec fef7b6563fd27f3aab1d659806b26b8f2ec38bc8feefad50288383c001d1c20f e6e42547f12df431439d45103d2c5a583248f44554a98a3a433cf8c38b11805d
-hash_to_ec 40a3d6871c76ecc6bb7b28324478733e196cc11d062dd4c9265cf31be5cf5a97 8c55a3811c241a020b1be202a58d5defbc4c8945d73b132570b47dd7c019ccf0
-hash_to_ec 0cd71e7e562b2b47f4bc8640caf20e69d3a62f10231b4c7a372c9691cff9ac3c fb8e4e3de479b3bf1f4f13b4ed5507df1e80bd9250567b9d021b03339d6e7197
-hash_to_ec 40a4e62800a99b7a26e0b507ffb29592e5bdba25284dc473048f24b27d25b40a 90ae131d29ee4a71cd764ab26f1ca4e6d09a40db98f8692b345c3a0e130dc860
-hash_to_ec 1ddf35193cf52860bfe3e41060a7f44281241c6ae49cd541d24c1aca679b7501 3b4f50013895c522776ced456329c4e727de03575f6b99ae7d238a9f70862121
-hash_to_ec 014e0fa8ce9d5df262b9a1765725fde354a855de8aef3fc23684e05dd1ba8d34 3857f57776a3cb68721bcb7f1533a5f9fb416a1dc8824d719399b63a142d24de
-hash_to_ec 09987979b0e98d1d5355df8a8698b8f54d3a037d12745c0a4317fe519c3df9cc 32a181e2b754aeced214c73ac459c97d99e63317be3eb923344c64a396173bca
-hash_to_ec 51e9e8ec4413e92dbaaba067824c32b018487a8d16412ed310507b4741e18eed 0356b209156b4993fd5d5630308298429a1b0021c19bedecb7719ac607cfa644
-hash_to_ec 14d91313dfe46e353310e6a4a23ee15d7a4e1f431700a444be8520e6043d08d9 6f345f4018b5d178d9f61894d9f46ac09ff639483727b0d113943507cee88cfd
-hash_to_ec 0d5af9ace87382acfffb9ab1a34b6e921881aa015d4f6d9c73171b2b0a97600d a8dbf36c85bebe6a7b3733e70cd3cd9ed0eb282ca470f344e5fcf9fe959f2e6e
-hash_to_ec 996690caac7328b19d20ed28eb0003d675b1a9ff79055ab530e3bf170eb22a94 14340d7d935cffce74b8b2f325c9d92ce0238b51807ef2c1512935bb843194ce
-hash_to_ec ad839c4b4c278c8ebe16ff137a558255a1f74646aa87c6cd99e994c7bb97ce8a d4f2da327ffded913b50577be0e583db2b237b5ca74da648e9b985c247073b76
-hash_to_ec 26fc2eeeee983e1300d72362fdff42edf08038e4eee277a6e2dbd1bd8c9d6560 3468b8269728c2c0bfc2e53b1575415124798bc0f59b60ea2f14967fc0ca19ce
-hash_to_ec db33cecaf4ee6f0ceba338cc5fabfb7462cd952a9c9007357ff3f0ca8336f8bc 0bab38f58686d0ff770f770a297971510bc83e2ff2dfead34823d1c4d67f11af
-hash_to_ec a0ee84b3c646526fb8787d26dcd9b7fe9dc713c8a6c1a4ea640465a9f36a64df 4d7a638f6759d3ec45339cd1300e1239cca5f0f658ca3cd29bc9bdb32f44faf0
-hash_to_ec 6a702e7899fcf3988e2b6b55654c22e54f43d3fa29de19177bdff5b2295fe27f 145d5748d6054fb586568e276f6925aef593a5b9c8249ad3dbef510af99b4307
-hash_to_ec 30ce0fd4f1fac8b62d613b8ee4a66deef6eb7094bd8466531050b837460f6971 f3aa850d593ba7cef01389f7e1916e57617f1d75cd42f64ce8f5f272384b148c
-hash_to_ec 3aa31d4ad7046ad13d83eb11c9a6e90eb8483a374a77a9a7b2a7cc0978fefa76 2fe0827dc080d9c1e7ec475a78aa7ae3c86d1a35f4c3f25f4a1f7299cacf018a
-hash_to_ec 8562a5a91e763b98014523ebb6e49120979098f89c31df1fde9eb3a49a15b20f ae223bf85e2009a9daf5fd8a14685e2e1e625fc88818b2fd437dd7e109a48f59
-hash_to_ec ccf9c313a47b8dbf7ce42c94b785818bc24134d95b6d22acc53c1ec2be29cf27 3e79fce6fe5aa14251b6560df4b76e811d7739eec097f27052c4403a283be71d
-hash_to_ec d1e33cd6f8918618d5fb6d67ad8de939db8beaec4f115551eac64479b739b773 613fffcbe1bf48bb2d7bfd64fd97790a06025f8f2429edddb9ac145707847ecf
-hash_to_ec 81eaeced34dd44e448d5dafa5715225e4956c90911c964a96ff7aa5b86b969bc 8f81177495d120a1357380164d677509b167f2958eb8b962b616c3951d426d8c
-hash_to_ec 2bc001a29f8eab1c7377de69957ba365fb5bdaf9c2c220889709af920dfe27d3 9bcb3010038f366fa4c280eed6e914a23bfc402594d0b83d0e66730a465a565b
-hash_to_ec 6feeb703c05e86c58d9fc5623f1af8657ecd1e75a14d18c4eedb642a8a393d16 6544628ba67ed0e14854961739c4d467fcf49d6361e39d32ea73dabeae51e6c3
-hash_to_ec e8ff145a7c26897f2c1639edd333a5412f87752f110079f581ccdc87fcce208c d4b5a6e06069c7e012e32119f8eda08ff04a8dfa784e1cf1bced455a4d41d905
-hash_to_ec 80488131dcb2018527908dbf8cdf4b823ef0806dc1d360f4da671004ef7ff74d 9984a79d9fd4f317768b442161116eef84e2ca49e938642b268fd64312d59a27
-hash_to_ec d8c4ca60446849a784d1462aa26a3b93073ff6841cb2da3ef52ab9785b00b1fd da5ec1562e7de2382d35728312f4eea3608d4dba775c1c108de510e1ce97d059
-hash_to_ec 68645728dfc6b9358dfb426493238ba38f24a2f46a3e89edb47d212549939cb7 d3253aa7235113dcc1b577d3bb80be34f528398815a653dbdbacbcbdfd5887a1
-hash_to_ec 4e8eb97ba2d1046e1b42e67530a61441e31c84e5e5e448d8e8dbe75d104eaccb de94f73e83222aa0e39b559d4fef70387b0815b9b2f6beff5da67262d8f0eb3e
-hash_to_ec 104ff03122ffdf59b22b8c0fe3d8f2ef67d02328e4d5181916d3d2a92f9a0bb7 1517ccf69c0328327e1cf581f16944ff66bc91c37e1cd68a99525415e00b7c9f
-hash_to_ec 80f23aae7356ae9a2f9f7504495a731214d26f870fb7df68fdc00b233494156f 7aef046b0a70f84e8d239aa95e192b5a3fffa0fae5090c91273e8996beca9e38
-hash_to_ec 2424b33235955a737ebddbf1c6c59cd8778af74da3bd3e658447666a2ab2f557 d19e2be8d482950fbdae429618da7a9daedb8c5944dea19cd1b6b274e792231b
-hash_to_ec 0adc839d2b8f099e4341a4763b074c06318d6bcbd1ec558d20a9820c4a426463 cea5da12a84e5c20011726d9224a9930bec30f9571762dd7ca857b86bd37d056
-hash_to_ec 46c84d53951f1ba23c46a23d5d96bf019c559aa5d2d79e4535cfcdb36f38ce25 2a913a01a6f7dd78a43cdd5354d1160d9a5f0d824c489a892c80eba798a77567
-hash_to_ec 99bdaaf68555ccdc93d97c3a0fb4c126a1aa8b1202194a1a753401a6cae21055 1f645efe173577a092f2d847cc966e28ba3b36397fe84c96dfa4724ed4fcfdf9
-hash_to_ec c540ff78f1e063ad26ffa69febb8818c9f2a325072c566091ad816e40fe39af4 de7a762262c91ab4beccc0713233cb91163aec43e34de0dbcfad0c431e8a9722
-hash_to_ec de8b1ff8978cd5e02681521542b7b6c3c2f8f4602065059f83594809d04e3dda 290601e75207085bff3e016746e55a80310a76dea9ef566c24181079c76da11c
-hash_to_ec d555994c8a022e52602d2a8bdd01fc1bfa6b9ab6734ff72a1bd5f937de4627f8 5f6794e874f48c4b362d0a24207374c2d274e28de86351afc6ddb95d8cc2fd62
-hash_to_ec 19db72f703fe6f1b73f21b6ba133ae6b111ae8cc496d3aa32e02411e34c0d8d7 42f159f43d2d62b8cf8a47d5f1340c5cf070e9860fc60de647c55d50fe9f5607
-hash_to_ec 23a87a258c2a5d1353aa2d5946f9e5749b92f85e3c58e1d177c3b6c3dcac809c e5685016f79d5e87d1fecb3e2a0fe64e4875f7accd2f6649d7f6b16317549cb1
-hash_to_ec 43e1738d7d1b5b565f5fc78e81480f7edf9a4dc18f104fc4be95135b98931b17 650f5b682e45f2d0c5d5e8bcfd9e0cda7d9071b55ecbfaf5e3b59941cd7479f2
-hash_to_ec a9d644de0804edf62dee613efa2547e510990a9b7a987ebe55ec74c23873a878 52ad329f88499a4f110e6a6cba1f820012d8db6ccb8f6495ab1e3eb5a24786e1
-hash_to_ec 11f2b5d89a0350d7c8727becf0f4dd19bd90f8c94ff207132ab13282dd9b94e6 b798a47bb98dc2a8f99deaf64d27638e33a0d504c5d2fbee477a2bc9b89e2838
-hash_to_ec 5e206e3190b3b715d125f1a11fff424fb33e36e534c99ddde2a3517068b7dcc4 2738e9571c96b2ddf93cb5f4a72b1ea78d3731d9555b830494513c0683c950ca
-hash_to_ec efc3d65a43d4f10795c7265a76671348f80173e0f507c812f7ae76793b99c529 cf4434d18ce8167b51f117fe930860143c46e1739a8db1fba73b6b0de830d707
-hash_to_ec 81f00469788aad6631cf75b585ae06d43ec81c20479925a2009afac9687dff60 c335b5889b36ba4b4175bb0d986807e8eedb6f6b7329b70b922e2ab729c4202a
-hash_to_ec 9ef5ff329b525ee8f5c3ac38e1dba7cb19985617341d356707c67ff273aed02d bef9f9e051ba0e24d1fdf72099cf43ecdd250d047fb329855b5372d5c422db9e
-hash_to_ec 3fa1401bd63132cf8b385c0fa65f0715ba1fe6161e41d59f8033ae2b22f63fa1 8289a1cb3c2dae48879bb8913fafe2d196cc2fdab5f2a77607910efd33eae6df
-hash_to_ec 6559836fd0081fa38a3f8d8408b564e5698b9797cf5e15f7f12a7d2c84511989 28d405a6687d2ecc90c1c66bf0454d58f3fa38835743075e1db58c658e15a104
-hash_to_ec 8e0882d45f0e4c2fb2839d3be86ff699d4b2242f5b25ac5a3c2f65297c7d2032 2771fdcf9135a62007adb5f0004d8222f0e42f819c81710aa4dc3ab2042bebf3
-hash_to_ec 1d91dc4dd9bd82646029d13aca1af96830c1d8a0400ddebeb14b00c93501c039 7792c62e897f32cbc9c4229f0d28f7882ceeae120329a1cd35f76a75ac704e93
-hash_to_ec 09527f9052acbbdd7676cbbd9534780865f04a27aaadad2b7d4f1dac68883cf0 b934220cde1327f2dc6af67bcb4124bf424d5084ef4da945e4daad1717cd0bb8
-hash_to_ec 2362e1abe73e64cdd2ca7f6c5ea9f467213747dd3f2b7c6e5df9cb21e03307d7 676b7122b96564358bbaaf77e3a5a4db1767e4f9a50f6ddd1c69df4566755af9
-hash_to_ec 26c2dd2356e9b6c68a415b25f91d18614dc8500c66f346d28489da543ee75a94 0f4fd7086acd68eb7c9fa2410e2ecf18e34654eb44e979bc03ce436e992d5feb
-hash_to_ec 422dc0a09d6a45a8e0b563eeb6a5ee84b08abd3a8cb34ff93f77ba3b163f4042 631f1b412ff5a0fccbe53a02b4a3deaa93a0418ed9874df401eb698ef75d7441
-hash_to_ec ceecdf46f57ef3f36ff30a1a3579b609340282d1b26ab5ddef2f53514e91bab1 9bc6f981fe98d14a2fc5b01a8134b6d35e123ec9ab8a3f303e0a5abb28150e2e
-hash_to_ec 024a9e6e0d73f28aa6207fb1e02ce86d444d2d46f8211e8aaab54f459db91a5a 5fb0c1d2c3b30f399102104ea1874099fa83110b3d9c1fcfffb2981c98bf8cdf
-hash_to_ec 5b8e45e269c9ccac4c68e532a72b29346d218f4606f37a14064826a62050e3a8 c7be46a871b77fc05ce891d24bd6bd54d9775b7ef573c6bc2d92b67f3604c1d1
-hash_to_ec 9a6593a385c266389eef14237874b97bdcd1823c3199311667d4853c2d12aa81 9f55ee9d94102d2b9c5670f30586cf9823bf205b4d4fe088c323e87c4e10f26f
-hash_to_ec 27377e2811598c3569b92990865d39b72c7a5533e1be30f77330863187c11875 abd82bc726f2710a8b87e4c1cf5a069f0ae800de614468d3ff35639983020197
-hash_to_ec 7cacfaa135fb7d568b8dce8ea9136498b1b28c6d1020af45d376288d78d411f0 229fccd49744c0692508af329224553d21561ee6062b2b8a21f080f73da5bd97
-hash_to_ec 52abd90a5542d6496b8dec9567b020f30058e29458d64f2d4f3ad6f3bfc1a5a0 874e82ced7cf77577b3374087fb08a2300b7f403de628310c26bdb3be869d309
-hash_to_ec 5c8eebe9d12309187afa8d0d5191de3fdb84e5a05485d7cd62e8804ce7fdc0bc 12b7537643488aa8b9dcc4bae040cd491f8b466163b7988157b0502fb6c9177f
-hash_to_ec 6ca3dd5c7a21a6bf65d6eefbe20a66e9b1d6b64196344be0c075f47aea48e3aa 5e1d0705ee24675238293b73ab1d98359119d4b328275be2460cc6ee4d19cc88
-hash_to_ec d7e6cd0d39b4308c2a5ee547c4569c8bb3887e49cedece62d218d7c3c5277797 793dc4397112dfd9a8f4e061f457eb6d6fbb1d7a58c40bad5f16002c64914186
-hash_to_ec 9cb6de8ba967cca0f0f861c6e20546f8958446595c01c28dae7ba6cfa09d6b14 ba1a2f7502b58fee3499c20e35fa01bb932e7a7c4a925dc04fbf5d90f33cfb5e
-hash_to_ec 8ef9c7366733a1edcd116238cdbd177d61222d5c3e05b30ef6b85014cbcb6b79 8fc89664722947164ac9b77086aed319897612068f56ecd57f47029f14671603
-hash_to_ec 7f317a34e4fb7de9f69cb107ffc0e57fd9f5c85b85ccb5319d05cebfc169924a 4b71c42339c73db7d710cd63f374d478a6c13bdc352cff40e967282268965ba7
-hash_to_ec 15beef8d9687b92918a903b01d594859db4e7128263c8db0cae9d423ff962c1e cd75e6323952f6ac88f138f391b69f38c46d70b7eda61f9e431725b6f1d514a5
-hash_to_ec 7a1c04c9af8fc6649833fe81e96f0199fcfe94959256cbe1490075fc5be0904e 0368270cd979439ae0a9552a5d6c9f959e4247fcf920d9e071464582e79c04b1
-hash_to_ec c854c583d338615f85f69061e0fa9c9d7c5bbbfe562e8774fef3be556fe8bb63 061620171d7320f64bee98414ff7200a1f481521d202fb281cab06be73b80402
-hash_to_ec 0fb8af5aba05ad2503edf1cfad5a451da088e7e974772057cd991a4e0601a3eb d3cbc20384a4420143fcce2cb763b0c15bec4f3267d1bdad3c34c1ee6b790f5e
-hash_to_ec 9a251cf59e84a9da5630642f9671c732440caa8fcf4c92446a7e5f5ef99da46c 9b9679086a433f2077f40bcd4c7545fb5cc87e7dbb8bba468d53cb04a74361a0
-hash_to_ec 8c632e357cef00e0911eb566f8cc809136b3f5ac1e82d183e4d645cef89fa155 5e06b0f4f278fa1ccb5431866e0b35171cdb814e2e82b9189ce01d8d8a1b2408
-hash_to_ec 4aa4c31463475086a5d96b3ff550340567ab3b4a86fa3f01cfe9be18bc4dcb54 76a2916cfc093f27992e1f07b50f431d61d58e255507e208cd29ea4d3bc56623
-hash_to_ec 1d33d9aadb949346e3c78d065a0f5262374524f4cb97a7390c8cdaede7ca6578 9ad2f757f499359903031adea6126c577469c4e834a2959e3ac08ee74b13783c
-hash_to_ec d9217b9a070df20c4d2f0db42ff0bb36bfba9f51b0b6df8fdfe150405dce4934 65a843c522b4b8ec081a696a0d2dd8dfdfea45db201de7a5889a1446c6dff8c7
-hash_to_ec b665b2ca8a285e44ba84e785533b56496a5319730dbb95bc14d3bdfece7544dc 8a804cd13457497b0a29eeca2cecfaa858766ec1d270a0e0c6785b43fd49b824
-hash_to_ec 43b5cbcc21b3404bca97fa9a661940fe64d40f3ca569310e50b1bb0173c4d5ee 6c12fffb540d536060bb8b96cf635c1b2cbaa4d875a8d2fb0bf79a690363df19
-hash_to_ec 11c58f20562c00dec5bb4456be07cd98186837e9af38d50d45f5e7b6f0f9000d cee76b567586f66dadd38c01213bfc1a17d38e96a495efb4c26063dc498ba209
-hash_to_ec b069a980b51d8e030262db0b30069e660f4a3f6f8075d1790c153ba12b879f8b 262391b00bdee71d1d827b2cfe50b46c29e265934dc91959bd369aca0cc6444e
-hash_to_ec 75274bfd79bf33eb2f9ab046d34528af9a71811e7e3d55c20eb049c81ac692d8 cb93c850e36896fe6626e97c53652af6736ec3ba0641c7765d0cca2bad2352de
-hash_to_ec 5cdb6a24d9736a00f197d9707949fedc5405f367744fe8c83b7cff650302b589 8b4ac03123fab9275dcf340345a1b11fba48ef106d410ba2e0e6f6457037a419
-hash_to_ec 07fdc85f809f95a07b59b084402bf91c512ebbe05c7657d6ba27a9e7e121e3e2 61182b3def063630e11de648a278032bcb75949f3a24ef5a133da87830ae5c4e
-hash_to_ec a4188ca634cbb796f9927822e343d7b267e0a609c1a0ffa4dcf3726b9ffcc8a2 a911e4899fda28fd6337d708d34553ac5e810ee4938f6f7d9d6e521cab069edb
-hash_to_ec 3c128ec5c955ea189a5789df2c892e94193a534a9d5801b8f75df870bc492a69 59eef5ee9df0f681df5b5c67ead1f06b059a8a843837b67f20cce15779608170
-hash_to_ec 51a4cc7ec4a14a98c0731e9de7f3ce0779123222d95455e940f2014a23729ec8 105863ccda076af7290d1bf9ec828651dc5811159839044d23f1c3e31a11c5e2
-hash_to_ec 1b901a31acbb7807c3309facdc7d04bc3b5a4aa714e6e346bd1c6ad4634e6534 01b3c0000b6c6b471c67c6ab3f9c7a500beaea5edb5c8f2b34df91b69ff67f21
-hash_to_ec d2f2c8d79cfa2e7cb2db80568ba62ca0576741acfbe5e2baa0d9b3c424a7c84d 7df9d9088022bd1ce6814d6f8051eef27a650ee38e789b184da2691efd27139d
-hash_to_ec 04dcb7644fdfc12d8e34d6e57d7769db939b4a149ed2b81aa51a74ee90babe19 6cff0ab2dd3b32ba1bd1a78e3661722f3f10003a01ce83e430970557decedb2c
-hash_to_ec 222798c6841eeaa07e7b7e29686942d7c7f9afc38d09360c8e1f52f2b7debd12 133e3a04ec82aa9b8dbbec18cadbafff446d1270bf7c6f3f97ddd3906dae2468
-hash_to_ec 4f7277c3ef247a0689b486ad965f969c433fc63e95d7310e789c4708418ccabc 7e0f2c984dd3cffb35458938c95fe92acf2e697aed060b0e3377c7a07e53c494
-hash_to_ec 359b4d6709413243ae2c5409ea02714a9f8961bbbb64a91e81daf01e18c981bf eab69af2cb7f113ad6a27035c0399853d10bd0b99291fad37794d100f7530431
-hash_to_ec 6cea3c6a9eb38f60329537170aa4db8dbb869af2040061e53b10c267daf6568c da9a97f4fa96bd05dade5e2704a6a633ba4dbe5080a1e831cda888e9d4f86615
-hash_to_ec 3dddecb954ef0209bcf61fd5b46b6c94f2384ef281c48a20ffee74f90788172d af9899c31f944617af54712f93d1a2b4944e48867f480d0d1aec61f3b713e32d
-hash_to_ec 9605247462f50bdf7ff57fe966abbefe8b6efa0b65b5116252f0ec723717013f fc8f10904d42a74e09310ccf63db31a90f1dab88b278f15e3364a2356810f7e9
-hash_to_ec a005143c4d299933f866db41d0a0b8c67264f5d4ea840dd243cb10c3526bc077 928df1fe9404ffa9c1f4a1c8b2d43ab9b81c5615c8330d2dc2074ac66d4d5200
-hash_to_ec f45ce88065c34a163f8e77b6fb583502ed0eb1f490f63f76065a9d97e214e3a9 41bd6784270af4154f2f24f118617e2d7f5b7771a409f08b0f2b7bbcb5e3d666
-hash_to_ec 7b40ac30ed02b12ff592a5479c80cf5a7673abfdd4dd38810e40e63275bc2eed 6c6bf5961d83851c9728801093d9af04e5a693bc6cbad237b9ac4b0ed580a771
-hash_to_ec 9f985005794d3052a63361413a9820d2ce903198d6d5195b3f20a68f146c6d5c 88bcac53ba5b1c5b44730a24b4cc2cd782298fc70dc9d777b577a2b33b256449
-hash_to_ec 31b8e37d01fd5669de4ebf78889d749bc44ffe997186ace56f1fb3e60b8742d2 776366b44170efb130a5045597db5675c6c0b56f3def84863c6b6358aa8dcf40

networks/monero/io/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "monero-io"
-version = "0.1.0"
-description = "Serialization functions, as within the Monero protocol"
-license = "MIT"
-repository = "https://github.com/serai-dex/serai/tree/develop/networks/monero/io"
-authors = ["Luke Parker <lukeparker5132@gmail.com>"]
-edition = "2021"
-rust-version = "1.80"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[lints]
-workspace = true
-
-[dependencies]
-std-shims = { path = "../../../common/std-shims", version = "^0.1.1", default-features = false }
-
-curve25519-dalek = { version = "4", default-features = false, features = ["alloc"] }
-
-[features]
-std = ["std-shims/std"]
-default = ["std"]

networks/monero/io/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022-2024 Luke Parker
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

networks/monero/io/README.md

@@ -1,11 +0,0 @@
-# Monero IO
-
-Serialization functions, as within the Monero protocol.
-
-This library is usable under no-std when the `std` feature (on by default) is
-disabled.
-
-### Cargo Features
-
-- `std` (on by default): Enables `std` (and with it, more efficient internal
-  implementations).

networks/monero/io/src/lib.rs

@@ -1,219 +0,0 @@
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#![doc = include_str!("../README.md")]
-#![deny(missing_docs)]
-#![cfg_attr(not(feature = "std"), no_std)]
-
-use core::fmt::Debug;
-use std_shims::{
-  vec,
-  vec::Vec,
-  io::{self, Read, Write},
-};
-
-use curve25519_dalek::{
-  scalar::Scalar,
-  edwards::{EdwardsPoint, CompressedEdwardsY},
-};
-
-const VARINT_CONTINUATION_MASK: u8 = 0b1000_0000;
-
-mod sealed {
-  /// A trait for a number readable/writable as a VarInt.
-  ///
-  /// This is sealed to prevent unintended implementations.
-  pub trait VarInt: TryInto<u64> + TryFrom<u64> + Copy {
-    const BITS: usize;
-  }
-
-  impl VarInt for u8 {
-    const BITS: usize = 8;
-  }
-  impl VarInt for u32 {
-    const BITS: usize = 32;
-  }
-  impl VarInt for u64 {
-    const BITS: usize = 64;
-  }
-  impl VarInt for usize {
-    const BITS: usize = core::mem::size_of::<usize>() * 8;
-  }
-}
-
-/// The amount of bytes this number will take when serialized as a VarInt.
-///
-/// This function will panic if the VarInt exceeds u64::MAX.
-pub fn varint_len<V: sealed::VarInt>(varint: V) -> usize {
-  let varint_u64: u64 = varint.try_into().map_err(|_| "varint exceeded u64").unwrap();
-  ((usize::try_from(u64::BITS - varint_u64.leading_zeros()).unwrap().saturating_sub(1)) / 7) + 1
-}
-
-/// Write a byte.
-///
-/// This is used as a building block within generic functions.
-pub fn write_byte<W: Write>(byte: &u8, w: &mut W) -> io::Result<()> {
-  w.write_all(&[*byte])
-}
-
-/// Write a number, VarInt-encoded.
-///
-/// This will panic if the VarInt exceeds u64::MAX.
-pub fn write_varint<W: Write, U: sealed::VarInt>(varint: &U, w: &mut W) -> io::Result<()> {
-  let mut varint: u64 = (*varint).try_into().map_err(|_| "varint exceeded u64").unwrap();
-  while {
-    let mut b = u8::try_from(varint & u64::from(!VARINT_CONTINUATION_MASK)).unwrap();
-    varint >>= 7;
-    if varint != 0 {
-      b |= VARINT_CONTINUATION_MASK;
-    }
-    write_byte(&b, w)?;
-    varint != 0
-  } {}
-  Ok(())
-}
-
-/// Write a scalar.
-pub fn write_scalar<W: Write>(scalar: &Scalar, w: &mut W) -> io::Result<()> {
-  w.write_all(&scalar.to_bytes())
-}
-
-/// Write a point.
-pub fn write_point<W: Write>(point: &EdwardsPoint, w: &mut W) -> io::Result<()> {
-  w.write_all(&point.compress().to_bytes())
-}
-
-/// Write a list of elements, without length-prefixing.
-pub fn write_raw_vec<T, W: Write, F: Fn(&T, &mut W) -> io::Result<()>>(
-  f: F,
-  values: &[T],
-  w: &mut W,
-) -> io::Result<()> {
-  for value in values {
-    f(value, w)?;
-  }
-  Ok(())
-}
-
-/// Write a list of elements, with length-prefixing.
-pub fn write_vec<T, W: Write, F: Fn(&T, &mut W) -> io::Result<()>>(
-  f: F,
-  values: &[T],
-  w: &mut W,
-) -> io::Result<()> {
-  write_varint(&values.len(), w)?;
-  write_raw_vec(f, values, w)
-}
-
-/// Read a constant amount of bytes.
-pub fn read_bytes<R: Read, const N: usize>(r: &mut R) -> io::Result<[u8; N]> {
-  let mut res = [0; N];
-  r.read_exact(&mut res)?;
-  Ok(res)
-}
-
-/// Read a single byte.
-pub fn read_byte<R: Read>(r: &mut R) -> io::Result<u8> {
-  Ok(read_bytes::<_, 1>(r)?[0])
-}
-
-/// Read a u16, little-endian encoded.
-pub fn read_u16<R: Read>(r: &mut R) -> io::Result<u16> {
-  read_bytes(r).map(u16::from_le_bytes)
-}
-
-/// Read a u32, little-endian encoded.
-pub fn read_u32<R: Read>(r: &mut R) -> io::Result<u32> {
-  read_bytes(r).map(u32::from_le_bytes)
-}
-
-/// Read a u64, little-endian encoded.
-pub fn read_u64<R: Read>(r: &mut R) -> io::Result<u64> {
-  read_bytes(r).map(u64::from_le_bytes)
-}
-
-/// Read a canonically-encoded VarInt.
-pub fn read_varint<R: Read, U: sealed::VarInt>(r: &mut R) -> io::Result<U> {
-  let mut bits = 0;
-  let mut res = 0;
-  while {
-    let b = read_byte(r)?;
-    if (bits != 0) && (b == 0) {
-      Err(io::Error::other("non-canonical varint"))?;
-    }
-    if ((bits + 7) >= U::BITS) && (b >= (1 << (U::BITS - bits))) {
-      Err(io::Error::other("varint overflow"))?;
-    }
-
-    res += u64::from(b & (!VARINT_CONTINUATION_MASK)) << bits;
-    bits += 7;
-    b & VARINT_CONTINUATION_MASK == VARINT_CONTINUATION_MASK
-  } {}
-  res.try_into().map_err(|_| io::Error::other("VarInt does not fit into integer type"))
-}
-
-/// Read a canonically-encoded scalar.
-///
-/// Some scalars within the Monero protocol are not enforced to be canonically encoded. For such
-/// scalars, they should be represented as `[u8; 32]` and later converted to scalars as relevant.
-pub fn read_scalar<R: Read>(r: &mut R) -> io::Result<Scalar> {
-  Option::from(Scalar::from_canonical_bytes(read_bytes(r)?))
-    .ok_or_else(|| io::Error::other("unreduced scalar"))
-}
-
-/// Decompress a canonically-encoded Ed25519 point.
-///
-/// Ed25519 is of order `8 * l`. This function ensures each of those `8 * l` points have a singular
-/// encoding by checking points aren't encoded with an unreduced field element, and aren't negative
-/// when the negative is equivalent (0 == -0).
-///
-/// Since this decodes an Ed25519 point, it does not check the point is in the prime-order
-/// subgroup. Torsioned points do have a canonical encoding, and only aren't canonical when
-/// considered in relation to the prime-order subgroup.
-pub fn decompress_point(bytes: [u8; 32]) -> Option<EdwardsPoint> {
-  CompressedEdwardsY(bytes)
-    .decompress()
-    // Ban points which are either unreduced or -0
-    .filter(|point| point.compress().to_bytes() == bytes)
-}
-
-/// Read a canonically-encoded Ed25519 point.
-///
-/// This internally calls `decompress_point` and has the same definition of canonicity. This
-/// function does not check the resulting point is within the prime-order subgroup.
-pub fn read_point<R: Read>(r: &mut R) -> io::Result<EdwardsPoint> {
-  let bytes = read_bytes(r)?;
-  decompress_point(bytes).ok_or_else(|| io::Error::other("invalid point"))
-}
-
-/// Read a canonically-encoded Ed25519 point, within the prime-order subgroup.
-pub fn read_torsion_free_point<R: Read>(r: &mut R) -> io::Result<EdwardsPoint> {
-  read_point(r)
-    .ok()
-    .filter(EdwardsPoint::is_torsion_free)
-    .ok_or_else(|| io::Error::other("invalid point"))
-}
-
-/// Read a variable-length list of elements, without length-prefixing.
-pub fn read_raw_vec<R: Read, T, F: Fn(&mut R) -> io::Result<T>>(
-  f: F,
-  len: usize,
-  r: &mut R,
-) -> io::Result<Vec<T>> {
-  let mut res = vec![];
-  for _ in 0 .. len {
-    res.push(f(r)?);
-  }
-  Ok(res)
-}
-
-/// Read a constant-length list of elements.
-pub fn read_array<R: Read, T: Debug, F: Fn(&mut R) -> io::Result<T>, const N: usize>(
-  f: F,
-  r: &mut R,
-) -> io::Result<[T; N]> {
-  read_raw_vec(f, N, r).map(|vec| vec.try_into().unwrap())
-}
-
-/// Read a length-prefixed variable-length list of elements.
-pub fn read_vec<R: Read, T, F: Fn(&mut R) -> io::Result<T>>(f: F, r: &mut R) -> io::Result<Vec<T>> {
-  read_raw_vec(f, read_varint(r)?, r)
-}

networks/monero/primitives/Cargo.toml

@@ -1,44 +0,0 @@
-[package]
-name = "monero-primitives"
-version = "0.1.0"
-description = "Primitives for the Monero protocol"
-license = "MIT"
-repository = "https://github.com/serai-dex/serai/tree/develop/networks/monero/primitives"
-authors = ["Luke Parker <lukeparker5132@gmail.com>"]
-edition = "2021"
-rust-version = "1.80"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[lints]
-workspace = true
-
-[dependencies]
-std-shims = { path = "../../../common/std-shims", version = "^0.1.1", default-features = false }
-
-zeroize = { version = "^1.5", default-features = false, features = ["zeroize_derive"] }
-
-# Cryptographic dependencies
-sha3 = { version = "0.10", default-features = false }
-curve25519-dalek = { version = "4", default-features = false, features = ["alloc", "zeroize"] }
-
-# Other Monero dependencies
-monero-io = { path = "../io", version = "0.1", default-features = false }
-monero-generators = { path = "../generators", version = "0.4", default-features = false }
-
-[dev-dependencies]
-hex = { version = "0.4", default-features = false, features = ["alloc"] }
-
-[features]
-std = [
-  "std-shims/std",
-
-  "zeroize/std",
-
-  "sha3/std",
-
-  "monero-generators/std",
-]
-default = ["std"]

networks/monero/primitives/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022-2024 Luke Parker
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

networks/monero/primitives/README.md

@@ -1,11 +0,0 @@
-# Monero Primitives
-
-Primitive structures and functions for the Monero protocol.
-
-This library is usable under no-std when the `std` feature (on by default) is
-disabled.
-
-### Cargo Features
-
-- `std` (on by default): Enables `std` (and with it, more efficient internal
-  implementations).

networks/monero/primitives/src/lib.rs

@@ -1,249 +0,0 @@
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#![doc = include_str!("../README.md")]
-#![deny(missing_docs)]
-#![cfg_attr(not(feature = "std"), no_std)]
-
-use std_shims::{io, vec::Vec};
-#[cfg(feature = "std")]
-use std_shims::sync::LazyLock;
-
-use zeroize::{Zeroize, ZeroizeOnDrop};
-
-use sha3::{Digest, Keccak256};
-use curve25519_dalek::{
-  constants::ED25519_BASEPOINT_POINT,
-  traits::VartimePrecomputedMultiscalarMul,
-  scalar::Scalar,
-  edwards::{EdwardsPoint, VartimeEdwardsPrecomputation},
-};
-
-use monero_io::*;
-use monero_generators::H;
-
-mod unreduced_scalar;
-pub use unreduced_scalar::UnreducedScalar;
-
-#[cfg(test)]
-mod tests;
-
-// On std, we cache some variables in statics.
-#[cfg(feature = "std")]
-static INV_EIGHT_CELL: LazyLock<Scalar> = LazyLock::new(|| Scalar::from(8u8).invert());
-/// The inverse of 8 over l, the prime factor of the order of Ed25519.
-#[cfg(feature = "std")]
-#[allow(non_snake_case)]
-pub fn INV_EIGHT() -> Scalar {
-  *INV_EIGHT_CELL
-}
-// In no-std environments, we prefer the reduced memory use and calculate it ad-hoc.
-/// The inverse of 8 over l, the prime factor of the order of Ed25519.
-#[cfg(not(feature = "std"))]
-#[allow(non_snake_case)]
-pub fn INV_EIGHT() -> Scalar {
-  Scalar::from(8u8).invert()
-}
-
-#[cfg(feature = "std")]
-static G_PRECOMP_CELL: LazyLock<VartimeEdwardsPrecomputation> =
-  LazyLock::new(|| VartimeEdwardsPrecomputation::new([ED25519_BASEPOINT_POINT]));
-/// A cached (if std) pre-computation of the Ed25519 generator, G.
-#[cfg(feature = "std")]
-#[allow(non_snake_case)]
-pub fn G_PRECOMP() -> &'static VartimeEdwardsPrecomputation {
-  &G_PRECOMP_CELL
-}
-/// A cached (if std) pre-computation of the Ed25519 generator, G.
-#[cfg(not(feature = "std"))]
-#[allow(non_snake_case)]
-pub fn G_PRECOMP() -> VartimeEdwardsPrecomputation {
-  VartimeEdwardsPrecomputation::new([ED25519_BASEPOINT_POINT])
-}
-
-/// The Keccak-256 hash function.
-pub fn keccak256(data: impl AsRef<[u8]>) -> [u8; 32] {
-  Keccak256::digest(data.as_ref()).into()
-}
-
-/// Hash the provided data to a scalar via keccak256(data) % l.
-///
-/// This function panics if it finds the Keccak-256 preimage for [0; 32].
-pub fn keccak256_to_scalar(data: impl AsRef<[u8]>) -> Scalar {
-  let scalar = Scalar::from_bytes_mod_order(keccak256(data.as_ref()));
-  // Monero will explicitly error in this case
-  // This library acknowledges its practical impossibility of it occurring, and doesn't bother to
-  // code in logic to handle it. That said, if it ever occurs, something must happen in order to
-  // not generate/verify a proof we believe to be valid when it isn't
-  assert!(scalar != Scalar::ZERO, "ZERO HASH: {:?}", data.as_ref());
-  scalar
-}
-
-/// Transparent structure representing a Pedersen commitment's contents.
-#[allow(non_snake_case)]
-#[derive(Clone, PartialEq, Eq, Zeroize, ZeroizeOnDrop)]
-pub struct Commitment {
-  /// The mask for this commitment.
-  pub mask: Scalar,
-  /// The amount committed to by this commitment.
-  pub amount: u64,
-}
-
-impl core::fmt::Debug for Commitment {
-  fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-    fmt.debug_struct("Commitment").field("amount", &self.amount).finish_non_exhaustive()
-  }
-}
-
-impl Commitment {
-  /// A commitment to zero, defined with a mask of 1 (as to not be the identity).
-  pub fn zero() -> Commitment {
-    Commitment { mask: Scalar::ONE, amount: 0 }
-  }
-
-  /// Create a new Commitment.
-  pub fn new(mask: Scalar, amount: u64) -> Commitment {
-    Commitment { mask, amount }
-  }
-
-  /// Calculate the Pedersen commitment, as a point, from this transparent structure.
-  pub fn calculate(&self) -> EdwardsPoint {
-    EdwardsPoint::vartime_double_scalar_mul_basepoint(&Scalar::from(self.amount), &H, &self.mask)
-  }
-
-  /// Write the Commitment.
-  ///
-  /// This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol
-  /// defined serialization.
-  pub fn write<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
-    w.write_all(&self.mask.to_bytes())?;
-    w.write_all(&self.amount.to_le_bytes())
-  }
-
-  /// Serialize the Commitment to a `Vec<u8>`.
-  ///
-  /// This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol
-  /// defined serialization.
-  pub fn serialize(&self) -> Vec<u8> {
-    let mut res = Vec::with_capacity(32 + 8);
-    self.write(&mut res).unwrap();
-    res
-  }
-
-  /// Read a Commitment.
-  ///
-  /// This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol
-  /// defined serialization.
-  pub fn read<R: io::Read>(r: &mut R) -> io::Result<Commitment> {
-    Ok(Commitment::new(read_scalar(r)?, read_u64(r)?))
-  }
-}
-
-/// Decoy data, as used for producing Monero's ring signatures.
-#[derive(Clone, PartialEq, Eq, Zeroize, ZeroizeOnDrop)]
-pub struct Decoys {
-  offsets: Vec<u64>,
-  signer_index: u8,
-  ring: Vec<[EdwardsPoint; 2]>,
-}
-
-impl core::fmt::Debug for Decoys {
-  fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-    fmt
-      .debug_struct("Decoys")
-      .field("offsets", &self.offsets)
-      .field("ring", &self.ring)
-      .finish_non_exhaustive()
-  }
-}
-
-#[allow(clippy::len_without_is_empty)]
-impl Decoys {
-  /// Create a new instance of decoy data.
-  ///
-  /// `offsets` are the positions of each ring member within the Monero blockchain, offset from the
-  /// prior member's position (with the initial ring member offset from 0).
-  pub fn new(offsets: Vec<u64>, signer_index: u8, ring: Vec<[EdwardsPoint; 2]>) -> Option<Self> {
-    if (offsets.len() != ring.len()) || (usize::from(signer_index) >= ring.len()) {
-      None?;
-    }
-    Some(Decoys { offsets, signer_index, ring })
-  }
-
-  /// The length of the ring.
-  pub fn len(&self) -> usize {
-    self.offsets.len()
-  }
-
-  /// The positions of the ring members within the Monero blockchain, as their offsets.
-  ///
-  /// The list is formatted as the position of the first ring member, then the offset from each
-  /// ring member to its prior.
-  pub fn offsets(&self) -> &[u64] {
-    &self.offsets
-  }
-
-  /// The positions of the ring members within the Monero blockchain.
-  pub fn positions(&self) -> Vec<u64> {
-    let mut res = Vec::with_capacity(self.len());
-    res.push(self.offsets[0]);
-    for m in 1 .. self.len() {
-      res.push(res[m - 1] + self.offsets[m]);
-    }
-    res
-  }
-
-  /// The index of the signer within the ring.
-  pub fn signer_index(&self) -> u8 {
-    self.signer_index
-  }
-
-  /// The ring.
-  pub fn ring(&self) -> &[[EdwardsPoint; 2]] {
-    &self.ring
-  }
-
-  /// The [key, commitment] pair of the signer.
-  pub fn signer_ring_members(&self) -> [EdwardsPoint; 2] {
-    self.ring[usize::from(self.signer_index)]
-  }
-
-  /// Write the Decoys.
-  ///
-  /// This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol
-  /// defined serialization.
-  pub fn write(&self, w: &mut impl io::Write) -> io::Result<()> {
-    write_vec(write_varint, &self.offsets, w)?;
-    w.write_all(&[self.signer_index])?;
-    write_vec(
-      |pair, w| {
-        write_point(&pair[0], w)?;
-        write_point(&pair[1], w)
-      },
-      &self.ring,
-      w,
-    )
-  }
-
-  /// Serialize the Decoys to a `Vec<u8>`.
-  ///
-  /// This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol
-  /// defined serialization.
-  pub fn serialize(&self) -> Vec<u8> {
-    let mut res =
-      Vec::with_capacity((1 + (2 * self.offsets.len())) + 1 + 1 + (self.ring.len() * 64));
-    self.write(&mut res).unwrap();
-    res
-  }
-
-  /// Read a set of Decoys.
-  ///
-  /// This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol
-  /// defined serialization.
-  pub fn read(r: &mut impl io::Read) -> io::Result<Decoys> {
-    Decoys::new(
-      read_vec(read_varint, r)?,
-      read_byte(r)?,
-      read_vec(|r| Ok([read_point(r)?, read_point(r)?]), r)?,
-    )
-    .ok_or_else(|| io::Error::other("invalid Decoys"))
-  }
-}

networks/monero/primitives/src/tests.rs

@@ -1,32 +0,0 @@
-use curve25519_dalek::scalar::Scalar;
-
-use crate::UnreducedScalar;
-
-#[test]
-fn recover_scalars() {
-  let test_recover = |stored: &str, recovered: &str| {
-    let stored = UnreducedScalar(hex::decode(stored).unwrap().try_into().unwrap());
-    let recovered =
-      Scalar::from_canonical_bytes(hex::decode(recovered).unwrap().try_into().unwrap()).unwrap();
-    assert_eq!(stored.recover_monero_slide_scalar(), recovered);
-  };
-
-  // https://www.moneroinflation.com/static/data_py/report_scalars_df.pdf
-  // Table 4.
-  test_recover(
-    "cb2be144948166d0a9edb831ea586da0c376efa217871505ad77f6ff80f203f8",
-    "b8ffd6a1aee47828808ab0d4c8524cb5c376efa217871505ad77f6ff80f20308",
-  );
-  test_recover(
-    "343d3df8a1051c15a400649c423dc4ed58bef49c50caef6ca4a618b80dee22f4",
-    "21113355bc682e6d7a9d5b3f2137a30259bef49c50caef6ca4a618b80dee2204",
-  );
-  test_recover(
-    "c14f75d612800ca2c1dcfa387a42c9cc086c005bc94b18d204dd61342418eba7",
-    "4f473804b1d27ab2c789c80ab21d034a096c005bc94b18d204dd61342418eb07",
-  );
-  test_recover(
-    "000102030405060708090a0b0c0d0e0f826c4f6e2329a31bc5bc320af0b2bcbb",
-    "a124cfd387f461bf3719e03965ee6877826c4f6e2329a31bc5bc320af0b2bc0b",
-  );
-}

networks/monero/primitives/src/unreduced_scalar.rs

@@ -1,137 +0,0 @@
-use core::cmp::Ordering;
-use std_shims::{
-  sync::LazyLock,
-  io::{self, *},
-};
-
-use zeroize::Zeroize;
-
-use curve25519_dalek::scalar::Scalar;
-
-use monero_io::*;
-
-// Precomputed scalars used to recover an incorrectly reduced scalar.
-static PRECOMPUTED_SCALARS: LazyLock<[Scalar; 8]> = LazyLock::new(|| {
-  let mut precomputed_scalars = [Scalar::ONE; 8];
-  for (i, scalar) in precomputed_scalars.iter_mut().enumerate().skip(1) {
-    *scalar = Scalar::from(u8::try_from((i * 2) + 1).unwrap());
-  }
-  precomputed_scalars
-});
-
-/// An unreduced scalar.
-///
-/// While most of modern Monero enforces scalars be reduced, certain legacy parts of the code did
-/// not. These section can generally simply be read as a scalar/reduced into a scalar when the time
-/// comes, yet a couple have non-standard reductions performed.
-///
-/// This struct delays scalar conversions and offers the non-standard reduction.
-#[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
-pub struct UnreducedScalar(pub [u8; 32]);
-
-impl UnreducedScalar {
-  /// Write an UnreducedScalar.
-  pub fn write<W: Write>(&self, w: &mut W) -> io::Result<()> {
-    w.write_all(&self.0)
-  }
-
-  /// Read an UnreducedScalar.
-  pub fn read<R: Read>(r: &mut R) -> io::Result<UnreducedScalar> {
-    Ok(UnreducedScalar(read_bytes(r)?))
-  }
-
-  fn as_bits(&self) -> [u8; 256] {
-    let mut bits = [0; 256];
-    for (i, bit) in bits.iter_mut().enumerate() {
-      *bit = core::hint::black_box(1 & (self.0[i / 8] >> (i % 8)))
-    }
-
-    bits
-  }
-
-  // Computes the non-adjacent form of this scalar with width 5.
-  //
-  // This matches Monero's `slide` function and intentionally gives incorrect outputs under
-  // certain conditions in order to match Monero.
-  //
-  // This function does not execute in constant time.
-  fn non_adjacent_form(&self) -> [i8; 256] {
-    let bits = self.as_bits();
-    let mut naf = [0i8; 256];
-    for (b, bit) in bits.into_iter().enumerate() {
-      naf[b] = i8::try_from(bit).unwrap();
-    }
-
-    for i in 0 .. 256 {
-      if naf[i] != 0 {
-        // if the bit is a one, work our way up through the window
-        // combining the bits with this bit.
-        for b in 1 .. 6 {
-          if (i + b) >= 256 {
-            // if we are at the length of the array then break out
-            // the loop.
-            break;
-          }
-          // potential_carry - the value of the bit at i+b compared to the bit at i
-          let potential_carry = naf[i + b] << b;
-
-          if potential_carry != 0 {
-            if (naf[i] + potential_carry) <= 15 {
-              // if our current "bit" plus the potential carry is less than 16
-              // add it to our current "bit" and set the potential carry bit to 0.
-              naf[i] += potential_carry;
-              naf[i + b] = 0;
-            } else if (naf[i] - potential_carry) >= -15 {
-              // else if our current "bit" minus the potential carry is more than -16
-              // take it away from our current "bit".
-              // we then work our way up through the bits setting ones to zero, when
-              // we hit the first zero we change it to one then stop, this is to factor
-              // in the minus.
-              naf[i] -= potential_carry;
-              #[allow(clippy::needless_range_loop)]
-              for k in (i + b) .. 256 {
-                if naf[k] == 0 {
-                  naf[k] = 1;
-                  break;
-                }
-                naf[k] = 0;
-              }
-            } else {
-              break;
-            }
-          }
-        }
-      }
-    }
-
-    naf
-  }
-
-  /// Recover the scalar that an array of bytes was incorrectly interpreted as by Monero's `slide`
-  /// function.
-  ///
-  /// In Borromean range proofs, Monero was not checking that the scalars used were
-  /// reduced. This lead to the scalar stored being interpreted as a different scalar.
-  /// This function recovers that scalar.
-  ///
-  /// See <https://github.com/monero-project/monero/issues/8438> for more info.
-  pub fn recover_monero_slide_scalar(&self) -> Scalar {
-    if self.0[31] & 128 == 0 {
-      // Computing the w-NAF of a number can only give an output with 1 more bit than
-      // the number, so even if the number isn't reduced, the `slide` function will be
-      // correct when the last bit isn't set.
-      return Scalar::from_bytes_mod_order(self.0);
-    }
-
-    let mut recovered = Scalar::ZERO;
-    for &numb in self.non_adjacent_form().iter().rev() {
-      recovered += recovered;
-      match numb.cmp(&0) {
-        Ordering::Greater => recovered += PRECOMPUTED_SCALARS[usize::try_from(numb).unwrap() / 2],
-        Ordering::Less => recovered -= PRECOMPUTED_SCALARS[usize::try_from(-numb).unwrap() / 2],
-        Ordering::Equal => (),
-      }
-    }
-    recovered
-  }
-}

networks/monero/ringct/borromean/Cargo.toml

@@ -1,41 +0,0 @@
-[package]
-name = "monero-borromean"
-version = "0.1.0"
-description = "Borromean ring signatures arranged into a range proof, as done by the Monero protocol"
-license = "MIT"
-repository = "https://github.com/serai-dex/serai/tree/develop/networks/monero/ringct/borromean"
-authors = ["Luke Parker <lukeparker5132@gmail.com>"]
-edition = "2021"
-rust-version = "1.80"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[lints]
-workspace = true
-
-[dependencies]
-std-shims = { path = "../../../../common/std-shims", version = "^0.1.1", default-features = false }
-
-zeroize = { version = "^1.5", default-features = false, features = ["zeroize_derive"] }
-
-# Cryptographic dependencies
-curve25519-dalek = { version = "4", default-features = false, features = ["alloc", "zeroize"] }
-
-# Other Monero dependencies
-monero-io = { path = "../../io", version = "0.1", default-features = false }
-monero-generators = { path = "../../generators", version = "0.4", default-features = false }
-monero-primitives = { path = "../../primitives", version = "0.1", default-features = false }
-
-[features]
-std = [
-  "std-shims/std",
-
-  "zeroize/std",
-
-  "monero-io/std",
-  "monero-generators/std",
-  "monero-primitives/std",
-]
-default = ["std"]

networks/monero/ringct/borromean/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022-2024 Luke Parker
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

networks/monero/ringct/borromean/README.md

@@ -1,12 +0,0 @@
-# Monero Borromean
-
-Borromean ring signatures arranged into a range proof, as done by the Monero
-protocol.
-
-This library is usable under no-std when the `std` feature (on by default) is
-disabled.
-
-### Cargo Features
-
-- `std` (on by default): Enables `std` (and with it, more efficient internal
-  implementations).

networks/monero/ringct/borromean/src/lib.rs

@@ -1,112 +0,0 @@
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#![doc = include_str!("../README.md")]
-#![deny(missing_docs)]
-#![cfg_attr(not(feature = "std"), no_std)]
-#![allow(non_snake_case)]
-
-use core::fmt::Debug;
-use std_shims::io::{self, Read, Write};
-
-use zeroize::Zeroize;
-
-use curve25519_dalek::{traits::Identity, Scalar, EdwardsPoint};
-
-use monero_io::*;
-use monero_generators::H_pow_2;
-use monero_primitives::{keccak256_to_scalar, UnreducedScalar};
-
-// 64 Borromean ring signatures, as needed for a 64-bit range proof.
-//
-// s0 and s1 are stored as `UnreducedScalar`s due to Monero not requiring they were reduced.
-// `UnreducedScalar` preserves their original byte encoding and implements a custom reduction
-// algorithm which was in use.
-#[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
-struct BorromeanSignatures {
-  s0: [UnreducedScalar; 64],
-  s1: [UnreducedScalar; 64],
-  ee: Scalar,
-}
-
-impl BorromeanSignatures {
-  // Read a set of BorromeanSignatures.
-  fn read<R: Read>(r: &mut R) -> io::Result<BorromeanSignatures> {
-    Ok(BorromeanSignatures {
-      s0: read_array(UnreducedScalar::read, r)?,
-      s1: read_array(UnreducedScalar::read, r)?,
-      ee: read_scalar(r)?,
-    })
-  }
-
-  // Write the set of BorromeanSignatures.
-  fn write<W: Write>(&self, w: &mut W) -> io::Result<()> {
-    for s0 in &self.s0 {
-      s0.write(w)?;
-    }
-    for s1 in &self.s1 {
-      s1.write(w)?;
-    }
-    write_scalar(&self.ee, w)
-  }
-
-  fn verify(&self, keys_a: &[EdwardsPoint], keys_b: &[EdwardsPoint]) -> bool {
-    let mut transcript = [0; 2048];
-
-    for i in 0 .. 64 {
-      #[allow(non_snake_case)]
-      let LL = EdwardsPoint::vartime_double_scalar_mul_basepoint(
-        &self.ee,
-        &keys_a[i],
-        &self.s0[i].recover_monero_slide_scalar(),
-      );
-      #[allow(non_snake_case)]
-      let LV = EdwardsPoint::vartime_double_scalar_mul_basepoint(
-        &keccak256_to_scalar(LL.compress().as_bytes()),
-        &keys_b[i],
-        &self.s1[i].recover_monero_slide_scalar(),
-      );
-      transcript[(i * 32) .. ((i + 1) * 32)].copy_from_slice(LV.compress().as_bytes());
-    }
-
-    keccak256_to_scalar(transcript) == self.ee
-  }
-}
-
-/// A range proof premised on Borromean ring signatures.
-#[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
-pub struct BorromeanRange {
-  sigs: BorromeanSignatures,
-  bit_commitments: [EdwardsPoint; 64],
-}
-
-impl BorromeanRange {
-  /// Read a BorromeanRange proof.
-  pub fn read<R: Read>(r: &mut R) -> io::Result<BorromeanRange> {
-    Ok(BorromeanRange {
-      sigs: BorromeanSignatures::read(r)?,
-      bit_commitments: read_array(read_point, r)?,
-    })
-  }
-
-  /// Write the BorromeanRange proof.
-  pub fn write<W: Write>(&self, w: &mut W) -> io::Result<()> {
-    self.sigs.write(w)?;
-    write_raw_vec(write_point, &self.bit_commitments, w)
-  }
-
-  /// Verify the commitment contains a 64-bit value.
-  #[must_use]
-  pub fn verify(&self, commitment: &EdwardsPoint) -> bool {
-    if &self.bit_commitments.iter().sum::<EdwardsPoint>() != commitment {
-      return false;
-    }
-
-    #[allow(non_snake_case)]
-    let H_pow_2 = H_pow_2();
-    let mut commitments_sub_one = [EdwardsPoint::identity(); 64];
-    for i in 0 .. 64 {
-      commitments_sub_one[i] = self.bit_commitments[i] - H_pow_2[i];
-    }
-
-    self.sigs.verify(&self.bit_commitments, &commitments_sub_one)
-  }
-}

networks/monero/ringct/bulletproofs/Cargo.toml

@@ -1,55 +0,0 @@
-[package]
-name = "monero-bulletproofs"
-version = "0.1.0"
-description = "Bulletproofs(+) range proofs, as defined by the Monero protocol"
-license = "MIT"
-repository = "https://github.com/serai-dex/serai/tree/develop/networks/monero/ringct/bulletproofs"
-authors = ["Luke Parker <lukeparker5132@gmail.com>"]
-edition = "2021"
-rust-version = "1.80"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[lints]
-workspace = true
-
-[dependencies]
-std-shims = { path = "../../../../common/std-shims", version = "^0.1.1", default-features = false }
-
-thiserror = { version = "1", default-features = false, optional = true }
-
-rand_core = { version = "0.6", default-features = false }
-zeroize = { version = "^1.5", default-features = false, features = ["zeroize_derive"] }
-
-# Cryptographic dependencies
-curve25519-dalek = { version = "4", default-features = false, features = ["alloc", "zeroize"] }
-
-# Other Monero dependencies
-monero-io = { path = "../../io", version = "0.1", default-features = false }
-monero-generators = { path = "../../generators", version = "0.4", default-features = false }
-monero-primitives = { path = "../../primitives", version = "0.1", default-features = false }
-
-[build-dependencies]
-curve25519-dalek = { version = "4", default-features = false, features = ["alloc", "zeroize"] }
-monero-generators = { path = "../../generators", version = "0.4", default-features = false }
-
-[dev-dependencies]
-hex-literal = "0.4"
-
-[features]
-std = [
-  "std-shims/std",
-
-  "thiserror",
-
-  "rand_core/std",
-  "zeroize/std",
-
-  "monero-io/std",
-  "monero-generators/std",
-  "monero-primitives/std",
-]
-compile-time-generators = ["curve25519-dalek/precomputed-tables"]
-default = ["std", "compile-time-generators"]

networks/monero/ringct/bulletproofs/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022-2024 Luke Parker
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

networks/monero/ringct/bulletproofs/README.md

@@ -1,14 +0,0 @@
-# Monero Bulletproofs(+)
-
-Bulletproofs(+) range proofs, as defined by the Monero protocol.
-
-This library is usable under no-std when the `std` feature (on by default) is
-disabled.
-
-### Cargo Features
-
-- `std` (on by default): Enables `std` (and with it, more efficient internal
-  implementations).
-- `compile-time-generators` (on by default): Derives the generators at
-  compile-time so they don't need to be derived at runtime. This is recommended
-  if program size doesn't need to be kept minimal.

networks/monero/ringct/bulletproofs/build.rs

@@ -1,82 +0,0 @@
-use std::{
-  io::Write,
-  env,
-  path::Path,
-  fs::{File, remove_file},
-};
-
-#[cfg(feature = "compile-time-generators")]
-fn generators(prefix: &'static str, path: &str) {
-  use curve25519_dalek::EdwardsPoint;
-
-  use monero_generators::bulletproofs_generators;
-
-  fn serialize(generators_string: &mut String, points: &[EdwardsPoint]) {
-    for generator in points {
-      generators_string.extend(
-        format!(
-          "
-          curve25519_dalek::edwards::CompressedEdwardsY({:?}).decompress().unwrap(),
-        ",
-          generator.compress().to_bytes()
-        )
-        .chars(),
-      );
-    }
-  }
-
-  let generators = bulletproofs_generators(prefix.as_bytes());
-  #[allow(non_snake_case)]
-  let mut G_str = String::new();
-  serialize(&mut G_str, &generators.G);
-  #[allow(non_snake_case)]
-  let mut H_str = String::new();
-  serialize(&mut H_str, &generators.H);
-
-  let path = Path::new(&env::var("OUT_DIR").unwrap()).join(path);
-  let _ = remove_file(&path);
-  File::create(&path)
-    .unwrap()
-    .write_all(
-      format!(
-        "
-          pub(crate) static GENERATORS: LazyLock<Generators> = LazyLock::new(|| Generators {{
-            G: std_shims::vec![
-              {G_str}
-            ],
-            H: std_shims::vec![
-              {H_str}
-            ],
-          }});
-        ",
-      )
-      .as_bytes(),
-    )
-    .unwrap();
-}
-
-#[cfg(not(feature = "compile-time-generators"))]
-fn generators(prefix: &'static str, path: &str) {
-  let path = Path::new(&env::var("OUT_DIR").unwrap()).join(path);
-  let _ = remove_file(&path);
-  File::create(&path)
-    .unwrap()
-    .write_all(
-      format!(
-        r#"
-        pub(crate) static GENERATORS: LazyLock<Generators> = LazyLock::new(|| {{
-          monero_generators::bulletproofs_generators(b"{prefix}")
-        }});
-      "#,
-      )
-      .as_bytes(),
-    )
-    .unwrap();
-}
-
-fn main() {
-  println!("cargo:rerun-if-changed=build.rs");
-
-  generators("bulletproof", "generators.rs");
-  generators("bulletproof_plus", "generators_plus.rs");
-}

networks/monero/ringct/bulletproofs/src/batch_verifier.rs

@@ -1,101 +0,0 @@
-use std_shims::vec::Vec;
-
-use curve25519_dalek::{
-  constants::ED25519_BASEPOINT_POINT,
-  traits::{IsIdentity, VartimeMultiscalarMul},
-  scalar::Scalar,
-  edwards::EdwardsPoint,
-};
-
-use monero_generators::{H as MONERO_H, Generators};
-
-use crate::{original, plus};
-
-#[derive(Default)]
-pub(crate) struct InternalBatchVerifier {
-  pub(crate) g: Scalar,
-  pub(crate) h: Scalar,
-  pub(crate) g_bold: Vec<Scalar>,
-  pub(crate) h_bold: Vec<Scalar>,
-  pub(crate) other: Vec<(Scalar, EdwardsPoint)>,
-}
-
-impl InternalBatchVerifier {
-  #[must_use]
-  fn verify(self, G: EdwardsPoint, H: EdwardsPoint, generators: &Generators) -> bool {
-    let capacity = 2 + self.g_bold.len() + self.h_bold.len() + self.other.len();
-    let mut scalars = Vec::with_capacity(capacity);
-    let mut points = Vec::with_capacity(capacity);
-
-    scalars.push(self.g);
-    points.push(G);
-
-    scalars.push(self.h);
-    points.push(H);
-
-    for (i, g_bold) in self.g_bold.into_iter().enumerate() {
-      scalars.push(g_bold);
-      points.push(generators.G[i]);
-    }
-
-    for (i, h_bold) in self.h_bold.into_iter().enumerate() {
-      scalars.push(h_bold);
-      points.push(generators.H[i]);
-    }
-
-    for (scalar, point) in self.other {
-      scalars.push(scalar);
-      points.push(point);
-    }
-
-    EdwardsPoint::vartime_multiscalar_mul(scalars, points).is_identity()
-  }
-}
-
-#[derive(Default)]
-pub(crate) struct BulletproofsBatchVerifier(pub(crate) InternalBatchVerifier);
-impl BulletproofsBatchVerifier {
-  #[must_use]
-  pub(crate) fn verify(self) -> bool {
-    self.0.verify(ED25519_BASEPOINT_POINT, *MONERO_H, &original::GENERATORS)
-  }
-}
-
-#[derive(Default)]
-pub(crate) struct BulletproofsPlusBatchVerifier(pub(crate) InternalBatchVerifier);
-impl BulletproofsPlusBatchVerifier {
-  #[must_use]
-  pub(crate) fn verify(self) -> bool {
-    // Bulletproofs+ is written as per the paper, with G for the value and H for the mask
-    // Monero uses H for the value and G for the mask
-    self.0.verify(*MONERO_H, ED25519_BASEPOINT_POINT, &plus::GENERATORS)
-  }
-}
-
-/// A batch verifier for Bulletproofs(+).
-///
-/// This uses a fixed layout such that all fixed points only incur a single point scaling,
-/// regardless of the amounts of proofs verified. For all variable points (commitments), they're
-/// accumulated with the fixed points into a single multiscalar multiplication.
-#[derive(Default)]
-pub struct BatchVerifier {
-  pub(crate) original: BulletproofsBatchVerifier,
-  pub(crate) plus: BulletproofsPlusBatchVerifier,
-}
-impl BatchVerifier {
-  /// Create a new batch verifier.
-  pub fn new() -> Self {
-    Self {
-      original: BulletproofsBatchVerifier(InternalBatchVerifier::default()),
-      plus: BulletproofsPlusBatchVerifier(InternalBatchVerifier::default()),
-    }
-  }
-
-  /// Verify all of the proofs queued within this batch verifier.
-  ///
-  /// This uses a variable-time multiscalar multiplication internally.
-  #[must_use]
-  pub fn verify(self) -> bool {
-    self.original.verify() && self.plus.verify()
-  }
-}

networks/monero/ringct/bulletproofs/src/core.rs

@@ -1,74 +0,0 @@
-use std_shims::{vec, vec::Vec};
-
-use curve25519_dalek::{
-  traits::{MultiscalarMul, VartimeMultiscalarMul},
-  scalar::Scalar,
-  edwards::EdwardsPoint,
-};
-
-pub(crate) use monero_generators::{MAX_COMMITMENTS, COMMITMENT_BITS, LOG_COMMITMENT_BITS};
-
-pub(crate) fn multiexp(pairs: &[(Scalar, EdwardsPoint)]) -> EdwardsPoint {
-  let mut buf_scalars = Vec::with_capacity(pairs.len());
-  let mut buf_points = Vec::with_capacity(pairs.len());
-  for (scalar, point) in pairs {
-    buf_scalars.push(scalar);
-    buf_points.push(point);
-  }
-  EdwardsPoint::multiscalar_mul(buf_scalars, buf_points)
-}
-
-pub(crate) fn multiexp_vartime(pairs: &[(Scalar, EdwardsPoint)]) -> EdwardsPoint {
-  let mut buf_scalars = Vec::with_capacity(pairs.len());
-  let mut buf_points = Vec::with_capacity(pairs.len());
-  for (scalar, point) in pairs {
-    buf_scalars.push(scalar);
-    buf_points.push(point);
-  }
-  EdwardsPoint::vartime_multiscalar_mul(buf_scalars, buf_points)
-}
-
-/*
-This has room for optimization worth investigating further. It currently takes
-an iterative approach. It can be optimized further via divide and conquer.
-
-Assume there are 4 challenges.
-
-Iterative approach (current):
-  1. Do the optimal multiplications across challenge column 0 and 1.
-  2. Do the optimal multiplications across that result and column 2.
-  3. Do the optimal multiplications across that result and column 3.
-
-Divide and conquer (worth investigating further):
-  1. Do the optimal multiplications across challenge column 0 and 1.
-  2. Do the optimal multiplications across challenge column 2 and 3.
-  3. Multiply both results together.
-
-When there are 4 challenges (n=16), the iterative approach does 28 multiplications
-versus divide and conquer's 24.
-*/
-pub(crate) fn challenge_products(challenges: &[(Scalar, Scalar)]) -> Vec<Scalar> {
-  let mut products = vec![Scalar::ONE; 1 << challenges.len()];
-
-  if !challenges.is_empty() {
-    products[0] = challenges[0].1;
-    products[1] = challenges[0].0;
-
-    for (j, challenge) in challenges.iter().enumerate().skip(1) {
-      let mut slots = (1 << (j + 1)) - 1;
-      while slots > 0 {
-        products[slots] = products[slots / 2] * challenge.0;
-        products[slots - 1] = products[slots / 2] * challenge.1;
-
-        slots = slots.saturating_sub(2);
-      }
-    }
-
-    // Sanity check since if the above failed to populate, it'd be critical
-    for product in &products {
-      debug_assert!(*product != Scalar::ZERO);
-    }
-  }
-
-  products
-}

networks/monero/ringct/bulletproofs/src/lib.rs

@@ -1,292 +0,0 @@
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#![doc = include_str!("../README.md")]
-#![deny(missing_docs)]
-#![cfg_attr(not(feature = "std"), no_std)]
-#![allow(non_snake_case)]
-
-use std_shims::{
-  vec,
-  vec::Vec,
-  io::{self, Read, Write},
-};
-
-use rand_core::{RngCore, CryptoRng};
-use zeroize::Zeroizing;
-
-use curve25519_dalek::edwards::EdwardsPoint;
-
-use monero_io::*;
-pub use monero_generators::MAX_COMMITMENTS;
-use monero_primitives::Commitment;
-
-pub(crate) mod scalar_vector;
-pub(crate) mod point_vector;
-
-pub(crate) mod core;
-use crate::core::LOG_COMMITMENT_BITS;
-
-pub(crate) mod batch_verifier;
-use batch_verifier::{BulletproofsBatchVerifier, BulletproofsPlusBatchVerifier};
-pub use batch_verifier::BatchVerifier;
-
-pub(crate) mod original;
-use crate::original::{
-  IpProof, AggregateRangeStatement as OriginalStatement, AggregateRangeWitness as OriginalWitness,
-  AggregateRangeProof as OriginalProof,
-};
-
-pub(crate) mod plus;
-use crate::plus::{
-  WipProof, AggregateRangeStatement as PlusStatement, AggregateRangeWitness as PlusWitness,
-  AggregateRangeProof as PlusProof,
-};
-
-#[cfg(test)]
-mod tests;
-
-/// An error from proving/verifying Bulletproofs(+).
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-#[cfg_attr(feature = "std", derive(thiserror::Error))]
-pub enum BulletproofError {
-  /// Proving/verifying a Bulletproof(+) range proof with no commitments.
-  #[cfg_attr(feature = "std", error("no commitments to prove the range for"))]
-  NoCommitments,
-  /// Proving/verifying a Bulletproof(+) range proof with more commitments than supported.
-  #[cfg_attr(feature = "std", error("too many commitments to prove the range for"))]
-  TooManyCommitments,
-}
-
-/// A Bulletproof(+).
-///
-/// This encapsulates either a Bulletproof or a Bulletproof+.
-#[allow(clippy::large_enum_variant)]
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum Bulletproof {
-  /// A Bulletproof.
-  Original(OriginalProof),
-  /// A Bulletproof+.
-  Plus(PlusProof),
-}
-
-impl Bulletproof {
-  fn bp_fields(plus: bool) -> usize {
-    if plus {
-      6
-    } else {
-      9
-    }
-  }
-
-  /// Calculate the weight penalty for the Bulletproof(+).
-  ///
-  /// Bulletproofs(+) are logarithmically sized yet linearly timed. Evaluating by their size alone
-  /// accordingly doesn't properly represent the burden of the proof. Monero 'claws back' some of
-  /// the weight lost by using a proof smaller than it is fast to compensate for this.
-  // https://github.com/monero-project/monero/blob/94e67bf96bbc010241f29ada6abc89f49a81759c/
-  //   src/cryptonote_basic/cryptonote_format_utils.cpp#L106-L124
-  pub fn calculate_bp_clawback(plus: bool, n_outputs: usize) -> (usize, usize) {
-    #[allow(non_snake_case)]
-    let mut LR_len = 0;
-    let mut n_padded_outputs = 1;
-    while n_padded_outputs < n_outputs {
-      LR_len += 1;
-      n_padded_outputs = 1 << LR_len;
-    }
-    LR_len += LOG_COMMITMENT_BITS;
-
-    let mut bp_clawback = 0;
-    if n_padded_outputs > 2 {
-      let fields = Bulletproof::bp_fields(plus);
-      let base = ((fields + (2 * (LOG_COMMITMENT_BITS + 1))) * 32) / 2;
-      let size = (fields + (2 * LR_len)) * 32;
-      bp_clawback = ((base * n_padded_outputs) - size) * 4 / 5;
-    }
-
-    (bp_clawback, LR_len)
-  }
-
-  /// Prove the list of commitments are within [0 .. 2^64) with an aggregate Bulletproof.
-  pub fn prove<R: RngCore + CryptoRng>(
-    rng: &mut R,
-    outputs: Vec<Commitment>,
-  ) -> Result<Bulletproof, BulletproofError> {
-    if outputs.is_empty() {
-      Err(BulletproofError::NoCommitments)?;
-    }
-    if outputs.len() > MAX_COMMITMENTS {
-      Err(BulletproofError::TooManyCommitments)?;
-    }
-    let commitments = outputs.iter().map(Commitment::calculate).collect::<Vec<_>>();
-    Ok(Bulletproof::Original(
-      OriginalStatement::new(&commitments)
-        .unwrap()
-        .prove(rng, OriginalWitness::new(outputs).unwrap())
-        .unwrap(),
-    ))
-  }
-
-  /// Prove the list of commitments are within [0 .. 2^64) with an aggregate Bulletproof+.
-  pub fn prove_plus<R: RngCore + CryptoRng>(
-    rng: &mut R,
-    outputs: Vec<Commitment>,
-  ) -> Result<Bulletproof, BulletproofError> {
-    if outputs.is_empty() {
-      Err(BulletproofError::NoCommitments)?;
-    }
-    if outputs.len() > MAX_COMMITMENTS {
-      Err(BulletproofError::TooManyCommitments)?;
-    }
-    let commitments = outputs.iter().map(Commitment::calculate).collect::<Vec<_>>();
-    Ok(Bulletproof::Plus(
-      PlusStatement::new(&commitments)
-        .unwrap()
-        .prove(rng, &Zeroizing::new(PlusWitness::new(outputs).unwrap()))
-        .unwrap(),
-    ))
-  }
-
-  /// Verify the given Bulletproof(+).
-  #[must_use]
-  pub fn verify<R: RngCore + CryptoRng>(&self, rng: &mut R, commitments: &[EdwardsPoint]) -> bool {
-    match self {
-      Bulletproof::Original(bp) => {
-        let mut verifier = BulletproofsBatchVerifier::default();
-        let Some(statement) = OriginalStatement::new(commitments) else {
-          return false;
-        };
-        if !statement.verify(rng, &mut verifier, bp.clone()) {
-          return false;
-        }
-        verifier.verify()
-      }
-      Bulletproof::Plus(bp) => {
-        let mut verifier = BulletproofsPlusBatchVerifier::default();
-        let Some(statement) = PlusStatement::new(commitments) else {
-          return false;
-        };
-        if !statement.verify(rng, &mut verifier, bp.clone()) {
-          return false;
-        }
-        verifier.verify()
-      }
-    }
-  }
-
-  /// Accumulate the verification for the given Bulletproof(+) into the specified BatchVerifier.
-  ///
-  /// Returns false if the Bulletproof(+) isn't sane, leaving the BatchVerifier in an undefined
-  /// state.
-  ///
-  /// Returns true if the Bulletproof(+) is sane, regardless of its validity.
-  ///
-  /// The BatchVerifier must have its verification function executed to actually verify this proof.
-  #[must_use]
-  pub fn batch_verify<R: RngCore + CryptoRng>(
-    &self,
-    rng: &mut R,
-    verifier: &mut BatchVerifier,
-    commitments: &[EdwardsPoint],
-  ) -> bool {
-    match self {
-      Bulletproof::Original(bp) => {
-        let Some(statement) = OriginalStatement::new(commitments) else {
-          return false;
-        };
-        statement.verify(rng, &mut verifier.original, bp.clone())
-      }
-      Bulletproof::Plus(bp) => {
-        let Some(statement) = PlusStatement::new(commitments) else {
-          return false;
-        };
-        statement.verify(rng, &mut verifier.plus, bp.clone())
-      }
-    }
-  }
-
-  fn write_core<W: Write, F: Fn(&[EdwardsPoint], &mut W) -> io::Result<()>>(
-    &self,
-    w: &mut W,
-    specific_write_vec: F,
-  ) -> io::Result<()> {
-    match self {
-      Bulletproof::Original(bp) => {
-        write_point(&bp.A, w)?;
-        write_point(&bp.S, w)?;
-        write_point(&bp.T1, w)?;
-        write_point(&bp.T2, w)?;
-        write_scalar(&bp.tau_x, w)?;
-        write_scalar(&bp.mu, w)?;
-        specific_write_vec(&bp.ip.L, w)?;
-        specific_write_vec(&bp.ip.R, w)?;
-        write_scalar(&bp.ip.a, w)?;
-        write_scalar(&bp.ip.b, w)?;
-        write_scalar(&bp.t_hat, w)
-      }
-
-      Bulletproof::Plus(bp) => {
-        write_point(&bp.A, w)?;
-        write_point(&bp.wip.A, w)?;
-        write_point(&bp.wip.B, w)?;
-        write_scalar(&bp.wip.r_answer, w)?;
-        write_scalar(&bp.wip.s_answer, w)?;
-        write_scalar(&bp.wip.delta_answer, w)?;
-        specific_write_vec(&bp.wip.L, w)?;
-        specific_write_vec(&bp.wip.R, w)
-      }
-    }
-  }
-
-  /// Write a Bulletproof(+) for the message signed by a transaction's signature.
-  ///
-  /// This has a distinct encoding from the standard encoding.
-  pub fn signature_write<W: Write>(&self, w: &mut W) -> io::Result<()> {
-    self.write_core(w, |points, w| write_raw_vec(write_point, points, w))
-  }
-
-  /// Write a Bulletproof(+).
-  pub fn write<W: Write>(&self, w: &mut W) -> io::Result<()> {
-    self.write_core(w, |points, w| write_vec(write_point, points, w))
-  }
-
-  /// Serialize a Bulletproof(+) to a `Vec<u8>`.
-  pub fn serialize(&self) -> Vec<u8> {
-    let mut serialized = vec![];
-    self.write(&mut serialized).unwrap();
-    serialized
-  }
-
-  /// Read a Bulletproof.
-  pub fn read<R: Read>(r: &mut R) -> io::Result<Bulletproof> {
-    Ok(Bulletproof::Original(OriginalProof {
-      A: read_point(r)?,
-      S: read_point(r)?,
-      T1: read_point(r)?,
-      T2: read_point(r)?,
-      tau_x: read_scalar(r)?,
-      mu: read_scalar(r)?,
-      ip: IpProof {
-        L: read_vec(read_point, r)?,
-        R: read_vec(read_point, r)?,
-        a: read_scalar(r)?,
-        b: read_scalar(r)?,
-      },
-      t_hat: read_scalar(r)?,
-    }))
-  }
-
-  /// Read a Bulletproof+.
-  pub fn read_plus<R: Read>(r: &mut R) -> io::Result<Bulletproof> {
-    Ok(Bulletproof::Plus(PlusProof {
-      A: read_point(r)?,
-      wip: WipProof {
-        A: read_point(r)?,
-        B: read_point(r)?,
-        r_answer: read_scalar(r)?,
-        s_answer: read_scalar(r)?,
-        delta_answer: read_scalar(r)?,
-        L: read_vec(read_point, r)?.into_iter().collect(),
-        R: read_vec(read_point, r)?.into_iter().collect(),
-      },
-    }))
-  }
-}

networks/monero/ringct/bulletproofs/src/original/inner_product.rs

@@ -1,303 +0,0 @@
-use std_shims::{vec, vec::Vec};
-
-use zeroize::Zeroize;
-
-use curve25519_dalek::{Scalar, EdwardsPoint};
-
-use monero_generators::H;
-use monero_primitives::{INV_EIGHT, keccak256_to_scalar};
-use crate::{
-  core::{multiexp_vartime, challenge_products},
-  scalar_vector::ScalarVector,
-  point_vector::PointVector,
-  BulletproofsBatchVerifier,
-};
-
-/// An error from proving/verifying Inner-Product statements.
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub(crate) enum IpError {
-  IncorrectAmountOfGenerators,
-  DifferingLrLengths,
-}
-
-/// The Bulletproofs Inner-Product statement.
-///
-/// This is for usage with Protocol 2 from the Bulletproofs paper.
-#[derive(Clone, Debug)]
-pub(crate) struct IpStatement {
-  // Weights for h_bold
-  h_bold_weights: ScalarVector,
-  // u as the discrete logarithm of G
-  u: Scalar,
-}
-
-/// The witness for the Bulletproofs Inner-Product statement.
-#[derive(Clone, Debug)]
-pub(crate) struct IpWitness {
-  // a
-  a: ScalarVector,
-  // b
-  b: ScalarVector,
-}
-
-impl IpWitness {
-  /// Construct a new witness for an Inner-Product statement.
-  ///
-  /// This functions return None if the lengths of a, b are mismatched, not a power of two, or are
-  /// empty.
-  pub(crate) fn new(a: ScalarVector, b: ScalarVector) -> Option<Self> {
-    if a.0.is_empty() || (a.len() != b.len()) {
-      None?;
-    }
-
-    let mut power_of_2 = 1;
-    while power_of_2 < a.len() {
-      power_of_2 <<= 1;
-    }
-    if power_of_2 != a.len() {
-      None?;
-    }
-
-    Some(Self { a, b })
-  }
-}
-
-/// A proof for the Bulletproofs Inner-Product statement.
-#[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
-pub(crate) struct IpProof {
-  pub(crate) L: Vec<EdwardsPoint>,
-  pub(crate) R: Vec<EdwardsPoint>,
-  pub(crate) a: Scalar,
-  pub(crate) b: Scalar,
-}
-
-impl IpStatement {
-  /// Create a new Inner-Product statement which won't transcript P.
-  ///
-  /// This MUST only be called when P is deterministic to already transcripted elements.
-  pub(crate) fn new_without_P_transcript(h_bold_weights: ScalarVector, u: Scalar) -> Self {
-    Self { h_bold_weights, u }
-  }
-
-  // Transcript a round of the protocol
-  fn transcript_L_R(transcript: Scalar, L: EdwardsPoint, R: EdwardsPoint) -> Scalar {
-    let mut transcript = transcript.to_bytes().to_vec();
-    transcript.extend(L.compress().to_bytes());
-    transcript.extend(R.compress().to_bytes());
-    keccak256_to_scalar(transcript)
-  }
-
-  /// Prove for this Inner-Product statement.
-  ///
-  /// Returns an error if this statement couldn't be proven for (such as if the witness isn't
-  /// consistent).
-  pub(crate) fn prove(
-    self,
-    mut transcript: Scalar,
-    witness: IpWitness,
-  ) -> Result<IpProof, IpError> {
-    let generators = &crate::original::GENERATORS;
-    let g_bold_slice = &generators.G[.. witness.a.len()];
-    let h_bold_slice = &generators.H[.. witness.a.len()];
-
-    let (mut g_bold, mut h_bold, u, mut a, mut b) = {
-      let IpStatement { h_bold_weights, u } = self;
-      let u = *H * u;
-
-      // Ensure we have the exact amount of weights
-      if h_bold_weights.len() != g_bold_slice.len() {
-        Err(IpError::IncorrectAmountOfGenerators)?;
-      }
-      // Acquire a local copy of the generators
-      let g_bold = PointVector(g_bold_slice.to_vec());
-      let h_bold = PointVector(h_bold_slice.to_vec()).mul_vec(&h_bold_weights);
-
-      let IpWitness { a, b } = witness;
-
-      (g_bold, h_bold, u, a, b)
-    };
-
-    let mut L_vec = vec![];
-    let mut R_vec = vec![];
-
-    // `else: (n > 1)` case, lines 18-35 of the Bulletproofs paper
-    // This interprets `g_bold.len()` as `n`
-    while g_bold.len() > 1 {
-      // Split a, b, g_bold, h_bold as needed for lines 20-24
-      let (a1, a2) = a.clone().split();
-      let (b1, b2) = b.clone().split();
-
-      let (g_bold1, g_bold2) = g_bold.split();
-      let (h_bold1, h_bold2) = h_bold.split();
-
-      let n_hat = g_bold1.len();
-
-      // Sanity
-      debug_assert_eq!(a1.len(), n_hat);
-      debug_assert_eq!(a2.len(), n_hat);
-      debug_assert_eq!(b1.len(), n_hat);
-      debug_assert_eq!(b2.len(), n_hat);
-      debug_assert_eq!(g_bold1.len(), n_hat);
-      debug_assert_eq!(g_bold2.len(), n_hat);
-      debug_assert_eq!(h_bold1.len(), n_hat);
-      debug_assert_eq!(h_bold2.len(), n_hat);
-
-      // cl, cr, lines 21-22
-      let cl = a1.clone().inner_product(&b2);
-      let cr = a2.clone().inner_product(&b1);
-
-      let L = {
-        let mut L_terms = Vec::with_capacity(1 + (2 * g_bold1.len()));
-        for (a, g) in a1.0.iter().zip(g_bold2.0.iter()) {
-          L_terms.push((*a, *g));
-        }
-        for (b, h) in b2.0.iter().zip(h_bold1.0.iter()) {
-          L_terms.push((*b, *h));
-        }
-        L_terms.push((cl, u));
-        // Uses vartime since this isn't a ZK proof
-        multiexp_vartime(&L_terms)
-      };
-      L_vec.push(L * INV_EIGHT());
-
-      let R = {
-        let mut R_terms = Vec::with_capacity(1 + (2 * g_bold1.len()));
-        for (a, g) in a2.0.iter().zip(g_bold1.0.iter()) {
-          R_terms.push((*a, *g));
-        }
-        for (b, h) in b1.0.iter().zip(h_bold2.0.iter()) {
-          R_terms.push((*b, *h));
-        }
-        R_terms.push((cr, u));
-        multiexp_vartime(&R_terms)
-      };
-      R_vec.push(R * INV_EIGHT());
-
-      // Now that we've calculate L, R, transcript them to receive x (26-27)
-      transcript = Self::transcript_L_R(transcript, *L_vec.last().unwrap(), *R_vec.last().unwrap());
-      let x = transcript;
-      let x_inv = x.invert();
-
-      // The prover and verifier now calculate the following (28-31)
-      g_bold = PointVector(Vec::with_capacity(g_bold1.len()));
-      for (a, b) in g_bold1.0.into_iter().zip(g_bold2.0.into_iter()) {
-        g_bold.0.push(multiexp_vartime(&[(x_inv, a), (x, b)]));
-      }
-      h_bold = PointVector(Vec::with_capacity(h_bold1.len()));
-      for (a, b) in h_bold1.0.into_iter().zip(h_bold2.0.into_iter()) {
-        h_bold.0.push(multiexp_vartime(&[(x, a), (x_inv, b)]));
-      }
-
-      // 32-34
-      a = (a1 * x) + &(a2 * x_inv);
-      b = (b1 * x_inv) + &(b2 * x);
-    }
-
-    // `if n = 1` case from line 14-17
-
-    // Sanity
-    debug_assert_eq!(g_bold.len(), 1);
-    debug_assert_eq!(h_bold.len(), 1);
-    debug_assert_eq!(a.len(), 1);
-    debug_assert_eq!(b.len(), 1);
-
-    // We simply send a/b
-    Ok(IpProof { L: L_vec, R: R_vec, a: a[0], b: b[0] })
-  }
-
-  /// Queue an Inner-Product proof for batch verification.
-  ///
-  /// This will return Err if there is an error. This will return Ok if the proof was successfully
-  /// queued for batch verification. The caller is required to verify the batch in order to ensure
-  /// the proof is actually correct.
-  pub(crate) fn verify(
-    self,
-    verifier: &mut BulletproofsBatchVerifier,
-    ip_rows: usize,
-    mut transcript: Scalar,
-    verifier_weight: Scalar,
-    proof: IpProof,
-  ) -> Result<(), IpError> {
-    let generators = &crate::original::GENERATORS;
-    let g_bold_slice = &generators.G[.. ip_rows];
-    let h_bold_slice = &generators.H[.. ip_rows];
-
-    let IpStatement { h_bold_weights, u } = self;
-
-    // Verify the L/R lengths
-    {
-      // Calculate the discrete log w.r.t. 2 for the amount of generators present
-      let mut lr_len = 0;
-      while (1 << lr_len) < g_bold_slice.len() {
-        lr_len += 1;
-      }
-
-      // This proof has less/more terms than the passed in generators are for
-      if proof.L.len() != lr_len {
-        Err(IpError::IncorrectAmountOfGenerators)?;
-      }
-      if proof.L.len() != proof.R.len() {
-        Err(IpError::DifferingLrLengths)?;
-      }
-    }
-
-    // Again, we start with the `else: (n > 1)` case
-
-    // We need x, x_inv per lines 25-27 for lines 28-31
-    let mut xs = Vec::with_capacity(proof.L.len());
-    for (L, R) in proof.L.iter().zip(proof.R.iter()) {
-      transcript = Self::transcript_L_R(transcript, *L, *R);
-      xs.push(transcript);
-    }
-
-    // We calculate their inverse in batch
-    let mut x_invs = xs.clone();
-    Scalar::batch_invert(&mut x_invs);
-
-    // Now, with x and x_inv, we need to calculate g_bold', h_bold', P'
-    //
-    // For the sake of performance, we solely want to calculate all of these in terms of scalings
-    // for g_bold, h_bold, P, and don't want to actually perform intermediary scalings of the
-    // points
-    //
-    // L and R are easy, as it's simply x**2, x**-2
-    //
-    // For the series of g_bold, h_bold, we use the `challenge_products` function
-    // For how that works, please see its own documentation
-    let product_cache = {
-      let mut challenges = Vec::with_capacity(proof.L.len());
-
-      let x_iter = xs.into_iter().zip(x_invs);
-      let lr_iter = proof.L.into_iter().zip(proof.R);
-      for ((x, x_inv), (L, R)) in x_iter.zip(lr_iter) {
-        challenges.push((x, x_inv));
-        verifier.0.other.push((verifier_weight * (x * x), L.mul_by_cofactor()));
-        verifier.0.other.push((verifier_weight * (x_inv * x_inv), R.mul_by_cofactor()));
-      }
-
-      challenge_products(&challenges)
-    };
-
-    // And now for the `if n = 1` case
-    let c = proof.a * proof.b;
-
-    // The multiexp of these terms equate to the final permutation of P
-    // We now add terms for a * g_bold' + b * h_bold' b + c * u, with the scalars negative such
-    // that the terms sum to 0 for an honest prover
-
-    // The g_bold * a term case from line 16
-    #[allow(clippy::needless_range_loop)]
-    for i in 0 .. g_bold_slice.len() {
-      verifier.0.g_bold[i] -= verifier_weight * product_cache[i] * proof.a;
-    }
-    // The h_bold * b term case from line 16
-    for i in 0 .. h_bold_slice.len() {
-      verifier.0.h_bold[i] -=
-        verifier_weight * product_cache[product_cache.len() - 1 - i] * proof.b * h_bold_weights[i];
-    }
-    // The c * u term case from line 16
-    verifier.0.h -= verifier_weight * c * u;
-
-    Ok(())
-  }
-}

networks/monero/ringct/bulletproofs/src/original/mod.rs

@@ -1,339 +0,0 @@
-use std_shims::{sync::LazyLock, vec::Vec};
-
-use rand_core::{RngCore, CryptoRng};
-
-use zeroize::Zeroize;
-
-use curve25519_dalek::{constants::ED25519_BASEPOINT_POINT, Scalar, EdwardsPoint};
-
-use monero_generators::{H as MONERO_H, Generators, MAX_COMMITMENTS, COMMITMENT_BITS};
-use monero_primitives::{Commitment, INV_EIGHT, keccak256_to_scalar};
-use crate::{core::multiexp, scalar_vector::ScalarVector, BulletproofsBatchVerifier};
-
-pub(crate) mod inner_product;
-use inner_product::*;
-pub(crate) use inner_product::IpProof;
-
-include!(concat!(env!("OUT_DIR"), "/generators.rs"));
-
-#[derive(Clone, Debug)]
-pub(crate) struct AggregateRangeStatement<'a> {
-  commitments: &'a [EdwardsPoint],
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct AggregateRangeWitness {
-  commitments: Vec<Commitment>,
-}
-
-#[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
-pub struct AggregateRangeProof {
-  pub(crate) A: EdwardsPoint,
-  pub(crate) S: EdwardsPoint,
-  pub(crate) T1: EdwardsPoint,
-  pub(crate) T2: EdwardsPoint,
-  pub(crate) tau_x: Scalar,
-  pub(crate) mu: Scalar,
-  pub(crate) t_hat: Scalar,
-  pub(crate) ip: IpProof,
-}
-
-impl<'a> AggregateRangeStatement<'a> {
-  pub(crate) fn new(commitments: &'a [EdwardsPoint]) -> Option<Self> {
-    if commitments.is_empty() || (commitments.len() > MAX_COMMITMENTS) {
-      None?;
-    }
-    Some(Self { commitments })
-  }
-}
-
-impl AggregateRangeWitness {
-  pub(crate) fn new(commitments: Vec<Commitment>) -> Option<Self> {
-    if commitments.is_empty() || (commitments.len() > MAX_COMMITMENTS) {
-      None?;
-    }
-    Some(Self { commitments })
-  }
-}
-
-impl<'a> AggregateRangeStatement<'a> {
-  fn initial_transcript(&self) -> (Scalar, Vec<EdwardsPoint>) {
-    let V = self.commitments.iter().map(|c| c * INV_EIGHT()).collect::<Vec<_>>();
-    (keccak256_to_scalar(V.iter().flat_map(|V| V.compress().to_bytes()).collect::<Vec<_>>()), V)
-  }
-
-  fn transcript_A_S(transcript: Scalar, A: EdwardsPoint, S: EdwardsPoint) -> (Scalar, Scalar) {
-    let mut buf = Vec::with_capacity(96);
-    buf.extend(transcript.to_bytes());
-    buf.extend(A.compress().to_bytes());
-    buf.extend(S.compress().to_bytes());
-    let y = keccak256_to_scalar(buf);
-    let z = keccak256_to_scalar(y.to_bytes());
-    (y, z)
-  }
-
-  fn transcript_T12(transcript: Scalar, T1: EdwardsPoint, T2: EdwardsPoint) -> Scalar {
-    let mut buf = Vec::with_capacity(128);
-    buf.extend(transcript.to_bytes());
-    buf.extend(transcript.to_bytes());
-    buf.extend(T1.compress().to_bytes());
-    buf.extend(T2.compress().to_bytes());
-    keccak256_to_scalar(buf)
-  }
-
-  fn transcript_tau_x_mu_t_hat(
-    transcript: Scalar,
-    tau_x: Scalar,
-    mu: Scalar,
-    t_hat: Scalar,
-  ) -> Scalar {
-    let mut buf = Vec::with_capacity(128);
-    buf.extend(transcript.to_bytes());
-    buf.extend(transcript.to_bytes());
-    buf.extend(tau_x.to_bytes());
-    buf.extend(mu.to_bytes());
-    buf.extend(t_hat.to_bytes());
-    keccak256_to_scalar(buf)
-  }
-
-  #[allow(clippy::needless_pass_by_value)]
-  pub(crate) fn prove(
-    self,
-    rng: &mut (impl RngCore + CryptoRng),
-    witness: AggregateRangeWitness,
-  ) -> Option<AggregateRangeProof> {
-    if self.commitments != witness.commitments.iter().map(Commitment::calculate).collect::<Vec<_>>()
-    {
-      None?
-    };
-
-    let generators = &GENERATORS;
-
-    let (mut transcript, _) = self.initial_transcript();
-
-    // Find out the padded amount of commitments
-    let mut padded_pow_of_2 = 1;
-    while padded_pow_of_2 < witness.commitments.len() {
-      padded_pow_of_2 <<= 1;
-    }
-
-    let mut aL = ScalarVector::new(padded_pow_of_2 * COMMITMENT_BITS);
-    for (i, commitment) in witness.commitments.iter().enumerate() {
-      let mut amount = commitment.amount;
-      for j in 0 .. COMMITMENT_BITS {
-        aL[(i * COMMITMENT_BITS) + j] = Scalar::from(amount & 1);
-        amount >>= 1;
-      }
-    }
-    let aR = aL.clone() - Scalar::ONE;
-
-    let alpha = Scalar::random(&mut *rng);
-
-    let A = {
-      let mut terms = Vec::with_capacity(1 + (2 * aL.len()));
-      terms.push((alpha, ED25519_BASEPOINT_POINT));
-      for (aL, G) in aL.0.iter().zip(&generators.G) {
-        terms.push((*aL, *G));
-      }
-      for (aR, H) in aR.0.iter().zip(&generators.H) {
-        terms.push((*aR, *H));
-      }
-      let res = multiexp(&terms) * INV_EIGHT();
-      terms.zeroize();
-      res
-    };
-
-    let mut sL = ScalarVector::new(padded_pow_of_2 * COMMITMENT_BITS);
-    let mut sR = ScalarVector::new(padded_pow_of_2 * COMMITMENT_BITS);
-    for i in 0 .. (padded_pow_of_2 * COMMITMENT_BITS) {
-      sL[i] = Scalar::random(&mut *rng);
-      sR[i] = Scalar::random(&mut *rng);
-    }
-    let rho = Scalar::random(&mut *rng);
-
-    let S = {
-      let mut terms = Vec::with_capacity(1 + (2 * sL.len()));
-      terms.push((rho, ED25519_BASEPOINT_POINT));
-      for (sL, G) in sL.0.iter().zip(&generators.G) {
-        terms.push((*sL, *G));
-      }
-      for (sR, H) in sR.0.iter().zip(&generators.H) {
-        terms.push((*sR, *H));
-      }
-      let res = multiexp(&terms) * INV_EIGHT();
-      terms.zeroize();
-      res
-    };
-
-    let (y, z) = Self::transcript_A_S(transcript, A, S);
-    transcript = z;
-    let z = ScalarVector::powers(z, 3 + padded_pow_of_2);
-
-    let twos = ScalarVector::powers(Scalar::from(2u8), COMMITMENT_BITS);
-
-    let l = [aL - z[1], sL];
-    let y_pow_n = ScalarVector::powers(y, aR.len());
-    let mut r = [((aR + z[1]) * &y_pow_n), sR * &y_pow_n];
-    {
-      for j in 0 .. padded_pow_of_2 {
-        for i in 0 .. COMMITMENT_BITS {
-          r[0].0[(j * COMMITMENT_BITS) + i] += z[2 + j] * twos[i];
-        }
-      }
-    }
-    let t1 = (l[0].clone().inner_product(&r[1])) + (r[0].clone().inner_product(&l[1]));
-    let t2 = l[1].clone().inner_product(&r[1]);
-
-    let tau_1 = Scalar::random(&mut *rng);
-    let T1 = {
-      let mut T1_terms = [(t1, *MONERO_H), (tau_1, ED25519_BASEPOINT_POINT)];
-      for term in &mut T1_terms {
-        term.0 *= INV_EIGHT();
-      }
-      let T1 = multiexp(&T1_terms);
-      T1_terms.zeroize();
-      T1
-    };
-    let tau_2 = Scalar::random(&mut *rng);
-    let T2 = {
-      let mut T2_terms = [(t2, *MONERO_H), (tau_2, ED25519_BASEPOINT_POINT)];
-      for term in &mut T2_terms {
-        term.0 *= INV_EIGHT();
-      }
-      let T2 = multiexp(&T2_terms);
-      T2_terms.zeroize();
-      T2
-    };
-
-    transcript = Self::transcript_T12(transcript, T1, T2);
-    let x = transcript;
-
-    let [l0, l1] = l;
-    let l = l0 + &(l1 * x);
-    let [r0, r1] = r;
-    let r = r0 + &(r1 * x);
-    let t_hat = l.clone().inner_product(&r);
-    let mut tau_x = ((tau_2 * x) + tau_1) * x;
-    {
-      for (i, commitment) in witness.commitments.iter().enumerate() {
-        tau_x += z[2 + i] * commitment.mask;
-      }
-    }
-    let mu = alpha + (rho * x);
-
-    let y_inv_pow_n = ScalarVector::powers(y.invert(), l.len());
-
-    transcript = Self::transcript_tau_x_mu_t_hat(transcript, tau_x, mu, t_hat);
-    let x_ip = transcript;
-
-    let ip = IpStatement::new_without_P_transcript(y_inv_pow_n, x_ip)
-      .prove(transcript, IpWitness::new(l, r).unwrap())
-      .unwrap();
-
-    let res = AggregateRangeProof { A, S, T1, T2, tau_x, mu, t_hat, ip };
-    #[cfg(debug_assertions)]
-    {
-      let mut verifier = BulletproofsBatchVerifier::default();
-      debug_assert!(self.verify(rng, &mut verifier, res.clone()));
-      debug_assert!(verifier.verify());
-    }
-    Some(res)
-  }
-
-  #[must_use]
-  pub(crate) fn verify(
-    self,
-    rng: &mut (impl RngCore + CryptoRng),
-    verifier: &mut BulletproofsBatchVerifier,
-    mut proof: AggregateRangeProof,
-  ) -> bool {
-    let mut padded_pow_of_2 = 1;
-    while padded_pow_of_2 < self.commitments.len() {
-      padded_pow_of_2 <<= 1;
-    }
-    let ip_rows = padded_pow_of_2 * COMMITMENT_BITS;
-
-    while verifier.0.g_bold.len() < ip_rows {
-      verifier.0.g_bold.push(Scalar::ZERO);
-      verifier.0.h_bold.push(Scalar::ZERO);
-    }
-
-    let (mut transcript, mut commitments) = self.initial_transcript();
-    for commitment in &mut commitments {
-      *commitment = commitment.mul_by_cofactor();
-    }
-
-    let (y, z) = Self::transcript_A_S(transcript, proof.A, proof.S);
-    transcript = z;
-    let z = ScalarVector::powers(z, 3 + padded_pow_of_2);
-    transcript = Self::transcript_T12(transcript, proof.T1, proof.T2);
-    let x = transcript;
-    transcript = Self::transcript_tau_x_mu_t_hat(transcript, proof.tau_x, proof.mu, proof.t_hat);
-    let x_ip = transcript;
-
-    proof.A = proof.A.mul_by_cofactor();
-    proof.S = proof.S.mul_by_cofactor();
-    proof.T1 = proof.T1.mul_by_cofactor();
-    proof.T2 = proof.T2.mul_by_cofactor();
-
-    let y_pow_n = ScalarVector::powers(y, ip_rows);
-    let y_inv_pow_n = ScalarVector::powers(y.invert(), ip_rows);
-
-    let twos = ScalarVector::powers(Scalar::from(2u8), COMMITMENT_BITS);
-
-    // 65
-    {
-      let weight = Scalar::random(&mut *rng);
-      verifier.0.h += weight * proof.t_hat;
-      verifier.0.g += weight * proof.tau_x;
-
-      // Now that we've accumulated the lhs, negate the weight and accumulate the rhs
-      // These will now sum to 0 if equal
-      let weight = -weight;
-
-      verifier.0.h += weight * (z[1] - (z[2])) * y_pow_n.sum();
-
-      for (i, commitment) in commitments.iter().enumerate() {
-        verifier.0.other.push((weight * z[2 + i], *commitment));
-      }
-
-      for i in 0 .. padded_pow_of_2 {
-        verifier.0.h -= weight * z[3 + i] * twos.clone().sum();
-      }
-      verifier.0.other.push((weight * x, proof.T1));
-      verifier.0.other.push((weight * (x * x), proof.T2));
-    }
-
-    let ip_weight = Scalar::random(&mut *rng);
-
-    // 66
-    verifier.0.other.push((ip_weight, proof.A));
-    verifier.0.other.push((ip_weight * x, proof.S));
-    // We can replace these with a g_sum, h_sum scalar in the batch verifier
-    // It'd trade `2 * ip_rows` scalar additions (per proof) for one scalar addition and an
-    // additional term in the MSM
-    let ip_z = ip_weight * z[1];
-    for i in 0 .. ip_rows {
-      verifier.0.h_bold[i] += ip_z;
-    }
-    let neg_ip_z = -ip_z;
-    for i in 0 .. ip_rows {
-      verifier.0.g_bold[i] += neg_ip_z;
-    }
-    {
-      for j in 0 .. padded_pow_of_2 {
-        for i in 0 .. COMMITMENT_BITS {
-          let full_i = (j * COMMITMENT_BITS) + i;
-          verifier.0.h_bold[full_i] += ip_weight * y_inv_pow_n[full_i] * z[2 + j] * twos[i];
-        }
-      }
-    }
-    verifier.0.h += ip_weight * x_ip * proof.t_hat;
-
-    // 67, 68
-    verifier.0.g += ip_weight * -proof.mu;
-    let res = IpStatement::new_without_P_transcript(y_inv_pow_n, x_ip)
-      .verify(verifier, ip_rows, transcript, ip_weight, proof.ip);
-    res.is_ok()
-  }
-}

networks/monero/ringct/bulletproofs/src/plus/aggregate_range_proof.rs

@@ -1,255 +0,0 @@
-use std_shims::{vec, vec::Vec};
-
-use rand_core::{RngCore, CryptoRng};
-use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};
-
-use curve25519_dalek::{traits::Identity, scalar::Scalar, edwards::EdwardsPoint};
-
-use monero_primitives::{INV_EIGHT, Commitment, keccak256_to_scalar};
-
-use crate::{
-  batch_verifier::BulletproofsPlusBatchVerifier,
-  core::{MAX_COMMITMENTS, COMMITMENT_BITS, multiexp, multiexp_vartime},
-  plus::{
-    ScalarVector, PointVector, GeneratorsList, BpPlusGenerators,
-    transcript::*,
-    weighted_inner_product::{WipStatement, WipWitness, WipProof},
-    padded_pow_of_2, u64_decompose,
-  },
-};
-
-// Figure 3 of the Bulletproofs+ Paper
-#[derive(Clone, Debug)]
-pub(crate) struct AggregateRangeStatement<'a> {
-  generators: BpPlusGenerators,
-  V: &'a [EdwardsPoint],
-}
-
-#[derive(Clone, Debug, Zeroize, ZeroizeOnDrop)]
-pub(crate) struct AggregateRangeWitness(Vec<Commitment>);
-
-impl AggregateRangeWitness {
-  pub(crate) fn new(commitments: Vec<Commitment>) -> Option<Self> {
-    if commitments.is_empty() || (commitments.len() > MAX_COMMITMENTS) {
-      return None;
-    }
-
-    Some(AggregateRangeWitness(commitments))
-  }
-}
-
-/// Internal structure representing a Bulletproof+, as defined by Monero..
-#[doc(hidden)]
-#[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
-pub struct AggregateRangeProof {
-  pub(crate) A: EdwardsPoint,
-  pub(crate) wip: WipProof,
-}
-
-struct AHatComputation {
-  y: Scalar,
-  d_descending_y_plus_z: ScalarVector,
-  y_mn_plus_one: Scalar,
-  z: Scalar,
-  z_pow: ScalarVector,
-  A_hat: EdwardsPoint,
-}
-
-impl<'a> AggregateRangeStatement<'a> {
-  pub(crate) fn new(V: &'a [EdwardsPoint]) -> Option<Self> {
-    if V.is_empty() || (V.len() > MAX_COMMITMENTS) {
-      return None;
-    }
-
-    Some(Self { generators: BpPlusGenerators::new(), V })
-  }
-
-  fn transcript_A(transcript: &mut Scalar, A: EdwardsPoint) -> (Scalar, Scalar) {
-    let y = keccak256_to_scalar(
-      [transcript.to_bytes().as_ref(), A.compress().to_bytes().as_ref()].concat(),
-    );
-    let z = keccak256_to_scalar(y.to_bytes().as_ref());
-    *transcript = z;
-    (y, z)
-  }
-
-  fn d_j(j: usize, m: usize) -> ScalarVector {
-    let mut d_j = Vec::with_capacity(m * COMMITMENT_BITS);
-    for _ in 0 .. (j - 1) * COMMITMENT_BITS {
-      d_j.push(Scalar::ZERO);
-    }
-    d_j.append(&mut ScalarVector::powers(Scalar::from(2u8), COMMITMENT_BITS).0);
-    for _ in 0 .. (m - j) * COMMITMENT_BITS {
-      d_j.push(Scalar::ZERO);
-    }
-    ScalarVector(d_j)
-  }
-
-  fn compute_A_hat(
-    mut V: PointVector,
-    generators: &BpPlusGenerators,
-    transcript: &mut Scalar,
-    mut A: EdwardsPoint,
-  ) -> AHatComputation {
-    let (y, z) = Self::transcript_A(transcript, A);
-    A = A.mul_by_cofactor();
-
-    while V.len() < padded_pow_of_2(V.len()) {
-      V.0.push(EdwardsPoint::identity());
-    }
-    let mn = V.len() * COMMITMENT_BITS;
-
-    // 2, 4, 6, 8... powers of z, of length equivalent to the amount of commitments
-    let mut z_pow = Vec::with_capacity(V.len());
-    // z**2
-    z_pow.push(z * z);
-
-    let mut d = ScalarVector::new(mn);
-    for j in 1 ..= V.len() {
-      z_pow.push(*z_pow.last().unwrap() * z_pow[0]);
-      d = d + &(Self::d_j(j, V.len()) * (z_pow[j - 1]));
-    }
-
-    let mut ascending_y = ScalarVector(vec![y]);
-    for i in 1 .. d.len() {
-      ascending_y.0.push(ascending_y[i - 1] * y);
-    }
-    let y_pows = ascending_y.clone().sum();
-
-    let mut descending_y = ascending_y.clone();
-    descending_y.0.reverse();
-
-    let d_descending_y = d.clone() * &descending_y;
-    let d_descending_y_plus_z = d_descending_y + z;
-
-    let y_mn_plus_one = descending_y[0] * y;
-
-    let mut commitment_accum = EdwardsPoint::identity();
-    for (j, commitment) in V.0.iter().enumerate() {
-      commitment_accum += *commitment * z_pow[j];
-    }
-
-    let neg_z = -z;
-    let mut A_terms = Vec::with_capacity((generators.len() * 2) + 2);
-    for (i, d_y_z) in d_descending_y_plus_z.0.iter().enumerate() {
-      A_terms.push((neg_z, generators.generator(GeneratorsList::GBold, i)));
-      A_terms.push((*d_y_z, generators.generator(GeneratorsList::HBold, i)));
-    }
-    A_terms.push((y_mn_plus_one, commitment_accum));
-    A_terms.push((
-      ((y_pows * z) - (d.sum() * y_mn_plus_one * z) - (y_pows * (z * z))),
-      BpPlusGenerators::g(),
-    ));
-
-    AHatComputation {
-      y,
-      d_descending_y_plus_z,
-      y_mn_plus_one,
-      z,
-      z_pow: ScalarVector(z_pow),
-      A_hat: A + multiexp_vartime(&A_terms),
-    }
-  }
-
-  pub(crate) fn prove<R: RngCore + CryptoRng>(
-    self,
-    rng: &mut R,
-    witness: &AggregateRangeWitness,
-  ) -> Option<AggregateRangeProof> {
-    // Check for consistency with the witness
-    if self.V.len() != witness.0.len() {
-      return None;
-    }
-    for (commitment, witness) in self.V.iter().zip(witness.0.iter()) {
-      if witness.calculate() != *commitment {
-        return None;
-      }
-    }
-
-    let Self { generators, V } = self;
-    // Monero expects all of these points to be torsion-free
-    // Generally, for Bulletproofs, it sends points * INV_EIGHT and then performs a torsion clear
-    // by multiplying by 8
-    // This also restores the original value due to the preprocessing
-    // Commitments aren't transmitted INV_EIGHT though, so this multiplies by INV_EIGHT to enable
-    // clearing its cofactor without mutating the value
-    // For some reason, these values are transcripted * INV_EIGHT, not as transmitted
-    let V = V.iter().map(|V| V * INV_EIGHT()).collect::<Vec<_>>();
-    let mut transcript = initial_transcript(V.iter());
-    let mut V = V.iter().map(EdwardsPoint::mul_by_cofactor).collect::<Vec<_>>();
-
-    // Pad V
-    while V.len() < padded_pow_of_2(V.len()) {
-      V.push(EdwardsPoint::identity());
-    }
-
-    let generators = generators.reduce(V.len() * COMMITMENT_BITS);
-
-    let mut d_js = Vec::with_capacity(V.len());
-    let mut a_l = ScalarVector(Vec::with_capacity(V.len() * COMMITMENT_BITS));
-    for j in 1 ..= V.len() {
-      d_js.push(Self::d_j(j, V.len()));
-      #[allow(clippy::map_unwrap_or)]
-      a_l.0.append(
-        &mut u64_decompose(
-          *witness.0.get(j - 1).map(|commitment| &commitment.amount).unwrap_or(&0),
-        )
-        .0,
-      );
-    }
-
-    let a_r = a_l.clone() - Scalar::ONE;
-
-    let alpha = Scalar::random(&mut *rng);
-
-    let mut A_terms = Vec::with_capacity((generators.len() * 2) + 1);
-    for (i, a_l) in a_l.0.iter().enumerate() {
-      A_terms.push((*a_l, generators.generator(GeneratorsList::GBold, i)));
-    }
-    for (i, a_r) in a_r.0.iter().enumerate() {
-      A_terms.push((*a_r, generators.generator(GeneratorsList::HBold, i)));
-    }
-    A_terms.push((alpha, BpPlusGenerators::h()));
-    let mut A = multiexp(&A_terms);
-    A_terms.zeroize();
-
-    // Multiply by INV_EIGHT per earlier commentary
-    A *= INV_EIGHT();
-
-    let AHatComputation { y, d_descending_y_plus_z, y_mn_plus_one, z, z_pow, A_hat } =
-      Self::compute_A_hat(PointVector(V), &generators, &mut transcript, A);
-
-    let a_l = a_l - z;
-    let a_r = a_r + &d_descending_y_plus_z;
-    let mut alpha = alpha;
-    for j in 1 ..= witness.0.len() {
-      alpha += z_pow[j - 1] * witness.0[j - 1].mask * y_mn_plus_one;
-    }
-
-    Some(AggregateRangeProof {
-      A,
-      wip: WipStatement::new(generators, A_hat, y)
-        .prove(rng, transcript, &Zeroizing::new(WipWitness::new(a_l, a_r, alpha).unwrap()))
-        .unwrap(),
-    })
-  }
-
-  pub(crate) fn verify<R: RngCore + CryptoRng>(
-    self,
-    rng: &mut R,
-    verifier: &mut BulletproofsPlusBatchVerifier,
-    proof: AggregateRangeProof,
-  ) -> bool {
-    let Self { generators, V } = self;
-
-    let V = V.iter().map(|V| V * INV_EIGHT()).collect::<Vec<_>>();
-    let mut transcript = initial_transcript(V.iter());
-    let V = V.iter().map(EdwardsPoint::mul_by_cofactor).collect::<Vec<_>>();
-
-    let generators = generators.reduce(V.len() * COMMITMENT_BITS);
-
-    let AHatComputation { y, A_hat, .. } =
-      Self::compute_A_hat(PointVector(V), &generators, &mut transcript, proof.A);
-    WipStatement::new(generators, A_hat, y).verify(rng, verifier, transcript, proof.wip)
-  }
-}

networks/monero/ringct/bulletproofs/src/plus/mod.rs

@@ -1,81 +0,0 @@
-#![allow(non_snake_case)]
-
-use std_shims::sync::LazyLock;
-
-use curve25519_dalek::{constants::ED25519_BASEPOINT_POINT, scalar::Scalar, edwards::EdwardsPoint};
-
-use monero_generators::{H, Generators};
-
-pub(crate) use crate::{scalar_vector::ScalarVector, point_vector::PointVector};
-
-pub(crate) mod transcript;
-pub(crate) mod weighted_inner_product;
-pub(crate) use weighted_inner_product::*;
-pub(crate) mod aggregate_range_proof;
-pub(crate) use aggregate_range_proof::*;
-
-pub(crate) fn padded_pow_of_2(i: usize) -> usize {
-  let mut next_pow_of_2 = 1;
-  while next_pow_of_2 < i {
-    next_pow_of_2 <<= 1;
-  }
-  next_pow_of_2
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub(crate) enum GeneratorsList {
-  GBold,
-  HBold,
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct BpPlusGenerators {
-  g_bold: &'static [EdwardsPoint],
-  h_bold: &'static [EdwardsPoint],
-}
-
-include!(concat!(env!("OUT_DIR"), "/generators_plus.rs"));
-
-impl BpPlusGenerators {
-  #[allow(clippy::new_without_default)]
-  pub(crate) fn new() -> Self {
-    let gens = &GENERATORS;
-    BpPlusGenerators { g_bold: &gens.G, h_bold: &gens.H }
-  }
-
-  pub(crate) fn len(&self) -> usize {
-    self.g_bold.len()
-  }
-
-  pub(crate) fn g() -> EdwardsPoint {
-    *H
-  }
-
-  pub(crate) fn h() -> EdwardsPoint {
-    ED25519_BASEPOINT_POINT
-  }
-
-  pub(crate) fn generator(&self, list: GeneratorsList, i: usize) -> EdwardsPoint {
-    match list {
-      GeneratorsList::GBold => self.g_bold[i],
-      GeneratorsList::HBold => self.h_bold[i],
-    }
-  }
-
-  pub(crate) fn reduce(&self, generators: usize) -> Self {
-    // Round to the nearest power of 2
-    let generators = padded_pow_of_2(generators);
-    assert!(generators <= self.g_bold.len());
-
-    BpPlusGenerators { g_bold: &self.g_bold[.. generators], h_bold: &self.h_bold[.. generators] }
-  }
-}
-
-// Returns the little-endian decomposition.
-fn u64_decompose(value: u64) -> ScalarVector {
-  let mut bits = ScalarVector::new(64);
-  for bit in 0 .. 64 {
-    bits[bit] = Scalar::from((value >> bit) & 1);
-  }
-  bits
-}

networks/monero/ringct/bulletproofs/src/plus/transcript.rs

@@ -1,17 +0,0 @@
-use std_shims::{sync::LazyLock, vec::Vec};
-
-use curve25519_dalek::{scalar::Scalar, edwards::EdwardsPoint};
-
-use monero_generators::hash_to_point;
-use monero_primitives::{keccak256, keccak256_to_scalar};
-
-// Monero starts BP+ transcripts with the following constant.
-// Why this uses a hash_to_point is completely unknown.
-pub(crate) static TRANSCRIPT: LazyLock<[u8; 32]> =
-  LazyLock::new(|| hash_to_point(keccak256(b"bulletproof_plus_transcript")).compress().to_bytes());
-
-pub(crate) fn initial_transcript(commitments: core::slice::Iter<'_, EdwardsPoint>) -> Scalar {
-  let commitments_hash =
-    keccak256_to_scalar(commitments.flat_map(|V| V.compress().to_bytes()).collect::<Vec<_>>());
-  keccak256_to_scalar([TRANSCRIPT.as_ref(), &commitments_hash.to_bytes()].concat())
-}

networks/monero/ringct/bulletproofs/src/plus/weighted_inner_product.rs

@@ -1,405 +0,0 @@
-use std_shims::{vec, vec::Vec};
-
-use rand_core::{RngCore, CryptoRng};
-use zeroize::{Zeroize, ZeroizeOnDrop};
-
-use curve25519_dalek::{scalar::Scalar, edwards::EdwardsPoint};
-
-use monero_primitives::{INV_EIGHT, keccak256_to_scalar};
-use crate::{
-  core::{multiexp, multiexp_vartime, challenge_products},
-  batch_verifier::BulletproofsPlusBatchVerifier,
-  plus::{ScalarVector, PointVector, GeneratorsList, BpPlusGenerators, padded_pow_of_2},
-};
-
-// Figure 1 of the Bulletproofs+ paper
-#[derive(Clone, Debug)]
-pub(crate) struct WipStatement {
-  generators: BpPlusGenerators,
-  P: EdwardsPoint,
-  y: ScalarVector,
-}
-
-impl Zeroize for WipStatement {
-  fn zeroize(&mut self) {
-    self.P.zeroize();
-    self.y.zeroize();
-  }
-}
-
-#[derive(Clone, Debug, Zeroize, ZeroizeOnDrop)]
-pub(crate) struct WipWitness {
-  a: ScalarVector,
-  b: ScalarVector,
-  alpha: Scalar,
-}
-
-impl WipWitness {
-  pub(crate) fn new(mut a: ScalarVector, mut b: ScalarVector, alpha: Scalar) -> Option<Self> {
-    if a.0.is_empty() || (a.len() != b.len()) {
-      return None;
-    }
-
-    // Pad to the nearest power of 2
-    let missing = padded_pow_of_2(a.len()) - a.len();
-    a.0.reserve(missing);
-    b.0.reserve(missing);
-    for _ in 0 .. missing {
-      a.0.push(Scalar::ZERO);
-      b.0.push(Scalar::ZERO);
-    }
-
-    Some(Self { a, b, alpha })
-  }
-}
-
-#[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
-pub(crate) struct WipProof {
-  pub(crate) L: Vec<EdwardsPoint>,
-  pub(crate) R: Vec<EdwardsPoint>,
-  pub(crate) A: EdwardsPoint,
-  pub(crate) B: EdwardsPoint,
-  pub(crate) r_answer: Scalar,
-  pub(crate) s_answer: Scalar,
-  pub(crate) delta_answer: Scalar,
-}
-
-impl WipStatement {
-  pub(crate) fn new(generators: BpPlusGenerators, P: EdwardsPoint, y: Scalar) -> Self {
-    debug_assert_eq!(generators.len(), padded_pow_of_2(generators.len()));
-
-    // y ** n
-    let mut y_vec = ScalarVector::new(generators.len());
-    y_vec[0] = y;
-    for i in 1 .. y_vec.len() {
-      y_vec[i] = y_vec[i - 1] * y;
-    }
-
-    Self { generators, P, y: y_vec }
-  }
-
-  fn transcript_L_R(transcript: &mut Scalar, L: EdwardsPoint, R: EdwardsPoint) -> Scalar {
-    let e = keccak256_to_scalar(
-      [
-        transcript.to_bytes().as_ref(),
-        L.compress().to_bytes().as_ref(),
-        R.compress().to_bytes().as_ref(),
-      ]
-      .concat(),
-    );
-    *transcript = e;
-    e
-  }
-
-  fn transcript_A_B(transcript: &mut Scalar, A: EdwardsPoint, B: EdwardsPoint) -> Scalar {
-    let e = keccak256_to_scalar(
-      [
-        transcript.to_bytes().as_ref(),
-        A.compress().to_bytes().as_ref(),
-        B.compress().to_bytes().as_ref(),
-      ]
-      .concat(),
-    );
-    *transcript = e;
-    e
-  }
-
-  // Prover's variant of the shared code block to calculate G/H/P when n > 1
-  // Returns each permutation of G/H since the prover needs to do operation on each permutation
-  // P is dropped as it's unused in the prover's path
-  #[allow(clippy::too_many_arguments)]
-  fn next_G_H(
-    transcript: &mut Scalar,
-    mut g_bold1: PointVector,
-    mut g_bold2: PointVector,
-    mut h_bold1: PointVector,
-    mut h_bold2: PointVector,
-    L: EdwardsPoint,
-    R: EdwardsPoint,
-    y_inv_n_hat: Scalar,
-  ) -> (Scalar, Scalar, Scalar, Scalar, PointVector, PointVector) {
-    debug_assert_eq!(g_bold1.len(), g_bold2.len());
-    debug_assert_eq!(h_bold1.len(), h_bold2.len());
-    debug_assert_eq!(g_bold1.len(), h_bold1.len());
-
-    let e = Self::transcript_L_R(transcript, L, R);
-    let inv_e = e.invert();
-
-    // This vartime is safe as all of these arguments are public
-    let mut new_g_bold = Vec::with_capacity(g_bold1.len());
-    let e_y_inv = e * y_inv_n_hat;
-    for g_bold in g_bold1.0.drain(..).zip(g_bold2.0.drain(..)) {
-      new_g_bold.push(multiexp_vartime(&[(inv_e, g_bold.0), (e_y_inv, g_bold.1)]));
-    }
-
-    let mut new_h_bold = Vec::with_capacity(h_bold1.len());
-    for h_bold in h_bold1.0.drain(..).zip(h_bold2.0.drain(..)) {
-      new_h_bold.push(multiexp_vartime(&[(e, h_bold.0), (inv_e, h_bold.1)]));
-    }
-
-    let e_square = e * e;
-    let inv_e_square = inv_e * inv_e;
-
-    (e, inv_e, e_square, inv_e_square, PointVector(new_g_bold), PointVector(new_h_bold))
-  }
-
-  pub(crate) fn prove<R: RngCore + CryptoRng>(
-    self,
-    rng: &mut R,
-    mut transcript: Scalar,
-    witness: &WipWitness,
-  ) -> Option<WipProof> {
-    let WipStatement { generators, P, mut y } = self;
-    #[cfg(not(debug_assertions))]
-    let _ = P;
-
-    if generators.len() != witness.a.len() {
-      return None;
-    }
-    let (g, h) = (BpPlusGenerators::g(), BpPlusGenerators::h());
-    let mut g_bold = vec![];
-    let mut h_bold = vec![];
-    for i in 0 .. generators.len() {
-      g_bold.push(generators.generator(GeneratorsList::GBold, i));
-      h_bold.push(generators.generator(GeneratorsList::HBold, i));
-    }
-    let mut g_bold = PointVector(g_bold);
-    let mut h_bold = PointVector(h_bold);
-
-    let mut y_inv = {
-      let mut i = 1;
-      let mut to_invert = vec![];
-      while i < g_bold.len() {
-        to_invert.push(y[i - 1]);
-        i *= 2;
-      }
-      Scalar::batch_invert(&mut to_invert);
-      to_invert
-    };
-
-    // Check P has the expected relationship
-    #[cfg(debug_assertions)]
-    {
-      let mut P_terms = witness
-        .a
-        .0
-        .iter()
-        .copied()
-        .zip(g_bold.0.iter().copied())
-        .chain(witness.b.0.iter().copied().zip(h_bold.0.iter().copied()))
-        .collect::<Vec<_>>();
-      P_terms.push((witness.a.clone().weighted_inner_product(&witness.b, &y), g));
-      P_terms.push((witness.alpha, h));
-      debug_assert_eq!(multiexp(&P_terms), P);
-      P_terms.zeroize();
-    }
-
-    let mut a = witness.a.clone();
-    let mut b = witness.b.clone();
-    let mut alpha = witness.alpha;
-
-    // From here on, g_bold.len() is used as n
-    debug_assert_eq!(g_bold.len(), a.len());
-
-    let mut L_vec = vec![];
-    let mut R_vec = vec![];
-
-    // else n > 1 case from figure 1
-    while g_bold.len() > 1 {
-      let (a1, a2) = a.clone().split();
-      let (b1, b2) = b.clone().split();
-      let (g_bold1, g_bold2) = g_bold.split();
-      let (h_bold1, h_bold2) = h_bold.split();
-
-      let n_hat = g_bold1.len();
-      debug_assert_eq!(a1.len(), n_hat);
-      debug_assert_eq!(a2.len(), n_hat);
-      debug_assert_eq!(b1.len(), n_hat);
-      debug_assert_eq!(b2.len(), n_hat);
-      debug_assert_eq!(g_bold1.len(), n_hat);
-      debug_assert_eq!(g_bold2.len(), n_hat);
-      debug_assert_eq!(h_bold1.len(), n_hat);
-      debug_assert_eq!(h_bold2.len(), n_hat);
-
-      let y_n_hat = y[n_hat - 1];
-      y.0.truncate(n_hat);
-
-      let d_l = Scalar::random(&mut *rng);
-      let d_r = Scalar::random(&mut *rng);
-
-      let c_l = a1.clone().weighted_inner_product(&b2, &y);
-      let c_r = (a2.clone() * y_n_hat).weighted_inner_product(&b1, &y);
-
-      let y_inv_n_hat = y_inv.pop().unwrap();
-
-      let mut L_terms = (a1.clone() * y_inv_n_hat)
-        .0
-        .drain(..)
-        .zip(g_bold2.0.iter().copied())
-        .chain(b2.0.iter().copied().zip(h_bold1.0.iter().copied()))
-        .collect::<Vec<_>>();
-      L_terms.push((c_l, g));
-      L_terms.push((d_l, h));
-      let L = multiexp(&L_terms) * INV_EIGHT();
-      L_vec.push(L);
-      L_terms.zeroize();
-
-      let mut R_terms = (a2.clone() * y_n_hat)
-        .0
-        .drain(..)
-        .zip(g_bold1.0.iter().copied())
-        .chain(b1.0.iter().copied().zip(h_bold2.0.iter().copied()))
-        .collect::<Vec<_>>();
-      R_terms.push((c_r, g));
-      R_terms.push((d_r, h));
-      let R = multiexp(&R_terms) * INV_EIGHT();
-      R_vec.push(R);
-      R_terms.zeroize();
-
-      let (e, inv_e, e_square, inv_e_square);
-      (e, inv_e, e_square, inv_e_square, g_bold, h_bold) =
-        Self::next_G_H(&mut transcript, g_bold1, g_bold2, h_bold1, h_bold2, L, R, y_inv_n_hat);
-
-      a = (a1 * e) + &(a2 * (y_n_hat * inv_e));
-      b = (b1 * inv_e) + &(b2 * e);
-      alpha += (d_l * e_square) + (d_r * inv_e_square);
-
-      debug_assert_eq!(g_bold.len(), a.len());
-      debug_assert_eq!(g_bold.len(), h_bold.len());
-      debug_assert_eq!(g_bold.len(), b.len());
-    }
-
-    // n == 1 case from figure 1
-    debug_assert_eq!(g_bold.len(), 1);
-    debug_assert_eq!(h_bold.len(), 1);
-
-    debug_assert_eq!(a.len(), 1);
-    debug_assert_eq!(b.len(), 1);
-
-    let r = Scalar::random(&mut *rng);
-    let s = Scalar::random(&mut *rng);
-    let delta = Scalar::random(&mut *rng);
-    let eta = Scalar::random(&mut *rng);
-
-    let ry = r * y[0];
-
-    let mut A_terms =
-      vec![(r, g_bold[0]), (s, h_bold[0]), ((ry * b[0]) + (s * y[0] * a[0]), g), (delta, h)];
-    let A = multiexp(&A_terms) * INV_EIGHT();
-    A_terms.zeroize();
-
-    let mut B_terms = vec![(ry * s, g), (eta, h)];
-    let B = multiexp(&B_terms) * INV_EIGHT();
-    B_terms.zeroize();
-
-    let e = Self::transcript_A_B(&mut transcript, A, B);
-
-    let r_answer = r + (a[0] * e);
-    let s_answer = s + (b[0] * e);
-    let delta_answer = eta + (delta * e) + (alpha * (e * e));
-
-    Some(WipProof { L: L_vec, R: R_vec, A, B, r_answer, s_answer, delta_answer })
-  }
-
-  pub(crate) fn verify<R: RngCore + CryptoRng>(
-    self,
-    rng: &mut R,
-    verifier: &mut BulletproofsPlusBatchVerifier,
-    mut transcript: Scalar,
-    mut proof: WipProof,
-  ) -> bool {
-    let verifier_weight = Scalar::random(rng);
-
-    let WipStatement { generators, P, y } = self;
-
-    // Verify the L/R lengths
-    {
-      let mut lr_len = 0;
-      while (1 << lr_len) < generators.len() {
-        lr_len += 1;
-      }
-      if (proof.L.len() != lr_len) ||
-        (proof.R.len() != lr_len) ||
-        (generators.len() != (1 << lr_len))
-      {
-        return false;
-      }
-    }
-
-    let inv_y = {
-      let inv_y = y[0].invert();
-      let mut res = Vec::with_capacity(y.len());
-      res.push(inv_y);
-      while res.len() < y.len() {
-        res.push(inv_y * res.last().unwrap());
-      }
-      res
-    };
-
-    let mut e_is = Vec::with_capacity(proof.L.len());
-    for (L, R) in proof.L.iter_mut().zip(proof.R.iter_mut()) {
-      e_is.push(Self::transcript_L_R(&mut transcript, *L, *R));
-      *L = L.mul_by_cofactor();
-      *R = R.mul_by_cofactor();
-    }
-
-    let e = Self::transcript_A_B(&mut transcript, proof.A, proof.B);
-    proof.A = proof.A.mul_by_cofactor();
-    proof.B = proof.B.mul_by_cofactor();
-    let neg_e_square = verifier_weight * -(e * e);
-
-    verifier.0.other.push((neg_e_square, P));
-
-    let mut challenges = Vec::with_capacity(proof.L.len());
-    let product_cache = {
-      let mut inv_e_is = e_is.clone();
-      Scalar::batch_invert(&mut inv_e_is);
-
-      debug_assert_eq!(e_is.len(), inv_e_is.len());
-      debug_assert_eq!(e_is.len(), proof.L.len());
-      debug_assert_eq!(e_is.len(), proof.R.len());
-      for ((e_i, inv_e_i), (L, R)) in
-        e_is.drain(..).zip(inv_e_is.drain(..)).zip(proof.L.iter().zip(proof.R.iter()))
-      {
-        debug_assert_eq!(e_i.invert(), inv_e_i);
-
-        challenges.push((e_i, inv_e_i));
-
-        let e_i_square = e_i * e_i;
-        let inv_e_i_square = inv_e_i * inv_e_i;
-        verifier.0.other.push((neg_e_square * e_i_square, *L));
-        verifier.0.other.push((neg_e_square * inv_e_i_square, *R));
-      }
-
-      challenge_products(&challenges)
-    };
-
-    while verifier.0.g_bold.len() < generators.len() {
-      verifier.0.g_bold.push(Scalar::ZERO);
-    }
-    while verifier.0.h_bold.len() < generators.len() {
-      verifier.0.h_bold.push(Scalar::ZERO);
-    }
-
-    let re = proof.r_answer * e;
-    for i in 0 .. generators.len() {
-      let mut scalar = product_cache[i] * re;
-      if i > 0 {
-        scalar *= inv_y[i - 1];
-      }
-      verifier.0.g_bold[i] += verifier_weight * scalar;
-    }
-
-    let se = proof.s_answer * e;
-    for i in 0 .. generators.len() {
-      verifier.0.h_bold[i] += verifier_weight * (se * product_cache[product_cache.len() - 1 - i]);
-    }
-
-    verifier.0.other.push((verifier_weight * -e, proof.A));
-    verifier.0.g += verifier_weight * (proof.r_answer * y[0] * proof.s_answer);
-    verifier.0.h += verifier_weight * proof.delta_answer;
-    verifier.0.other.push((-verifier_weight, proof.B));
-
-    true
-  }
-}

networks/monero/ringct/bulletproofs/src/point_vector.rs

@@ -1,59 +0,0 @@
-use core::ops::{Index, IndexMut};
-use std_shims::vec::Vec;
-
-use zeroize::Zeroize;
-
-use curve25519_dalek::edwards::EdwardsPoint;
-
-use crate::scalar_vector::ScalarVector;
-
-#[cfg(test)]
-use crate::core::multiexp;
-
-#[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
-pub(crate) struct PointVector(pub(crate) Vec<EdwardsPoint>);
-
-impl Index<usize> for PointVector {
-  type Output = EdwardsPoint;
-  fn index(&self, index: usize) -> &EdwardsPoint {
-    &self.0[index]
-  }
-}
-
-impl IndexMut<usize> for PointVector {
-  fn index_mut(&mut self, index: usize) -> &mut EdwardsPoint {
-    &mut self.0[index]
-  }
-}
-
-impl PointVector {
-  pub(crate) fn mul_vec(&self, vector: &ScalarVector) -> Self {
-    assert_eq!(self.len(), vector.len());
-    let mut res = self.clone();
-    for (i, val) in res.0.iter_mut().enumerate() {
-      *val *= vector.0[i];
-    }
-    res
-  }
-
-  #[cfg(test)]
-  pub(crate) fn multiexp(&self, vector: &ScalarVector) -> EdwardsPoint {
-    debug_assert_eq!(self.len(), vector.len());
-    let mut res = Vec::with_capacity(self.len());
-    for (point, scalar) in self.0.iter().copied().zip(vector.0.iter().copied()) {
-      res.push((scalar, point));
-    }
-    multiexp(&res)
-  }
-
-  pub(crate) fn len(&self) -> usize {
-    self.0.len()
-  }
-
-  pub(crate) fn split(mut self) -> (Self, Self) {
-    debug_assert!(self.len() > 1);
-    let r = self.0.split_off(self.0.len() / 2);
-    debug_assert_eq!(self.len(), r.len());
-    (self, PointVector(r))
-  }
-}

networks/monero/ringct/bulletproofs/src/scalar_vector.rs

@@ -1,138 +0,0 @@
-use core::{
-  borrow::Borrow,
-  ops::{Index, IndexMut, Add, Sub, Mul},
-};
-use std_shims::{vec, vec::Vec};
-
-use zeroize::{Zeroize, ZeroizeOnDrop};
-
-use curve25519_dalek::{scalar::Scalar, edwards::EdwardsPoint};
-
-use crate::core::multiexp;
-
-#[derive(Clone, PartialEq, Eq, Debug, Zeroize, ZeroizeOnDrop)]
-pub(crate) struct ScalarVector(pub(crate) Vec<Scalar>);
-
-impl Index<usize> for ScalarVector {
-  type Output = Scalar;
-  fn index(&self, index: usize) -> &Scalar {
-    &self.0[index]
-  }
-}
-impl IndexMut<usize> for ScalarVector {
-  fn index_mut(&mut self, index: usize) -> &mut Scalar {
-    &mut self.0[index]
-  }
-}
-
-impl<S: Borrow<Scalar>> Add<S> for ScalarVector {
-  type Output = ScalarVector;
-  fn add(mut self, scalar: S) -> ScalarVector {
-    for s in &mut self.0 {
-      *s += scalar.borrow();
-    }
-    self
-  }
-}
-impl<S: Borrow<Scalar>> Sub<S> for ScalarVector {
-  type Output = ScalarVector;
-  fn sub(mut self, scalar: S) -> ScalarVector {
-    for s in &mut self.0 {
-      *s -= scalar.borrow();
-    }
-    self
-  }
-}
-impl<S: Borrow<Scalar>> Mul<S> for ScalarVector {
-  type Output = ScalarVector;
-  fn mul(mut self, scalar: S) -> ScalarVector {
-    for s in &mut self.0 {
-      *s *= scalar.borrow();
-    }
-    self
-  }
-}
-
-impl Add<&ScalarVector> for ScalarVector {
-  type Output = ScalarVector;
-  fn add(mut self, other: &ScalarVector) -> ScalarVector {
-    debug_assert_eq!(self.len(), other.len());
-    for (s, o) in self.0.iter_mut().zip(other.0.iter()) {
-      *s += o;
-    }
-    self
-  }
-}
-impl Sub<&ScalarVector> for ScalarVector {
-  type Output = ScalarVector;
-  fn sub(mut self, other: &ScalarVector) -> ScalarVector {
-    debug_assert_eq!(self.len(), other.len());
-    for (s, o) in self.0.iter_mut().zip(other.0.iter()) {
-      *s -= o;
-    }
-    self
-  }
-}
-impl Mul<&ScalarVector> for ScalarVector {
-  type Output = ScalarVector;
-  fn mul(mut self, other: &ScalarVector) -> ScalarVector {
-    debug_assert_eq!(self.len(), other.len());
-    for (s, o) in self.0.iter_mut().zip(other.0.iter()) {
-      *s *= o;
-    }
-    self
-  }
-}
-
-impl Mul<&[EdwardsPoint]> for &ScalarVector {
-  type Output = EdwardsPoint;
-  fn mul(self, b: &[EdwardsPoint]) -> EdwardsPoint {
-    debug_assert_eq!(self.len(), b.len());
-    let mut multiexp_args = self.0.iter().copied().zip(b.iter().copied()).collect::<Vec<_>>();
-    let res = multiexp(&multiexp_args);
-    multiexp_args.zeroize();
-    res
-  }
-}
-
-impl ScalarVector {
-  pub(crate) fn new(len: usize) -> Self {
-    ScalarVector(vec![Scalar::ZERO; len])
-  }
-
-  pub(crate) fn powers(x: Scalar, len: usize) -> Self {
-    debug_assert!(len != 0);
-
-    let mut res = Vec::with_capacity(len);
-    res.push(Scalar::ONE);
-    res.push(x);
-    for i in 2 .. len {
-      res.push(res[i - 1] * x);
-    }
-    res.truncate(len);
-    ScalarVector(res)
-  }
-
-  pub(crate) fn len(&self) -> usize {
-    self.0.len()
-  }
-
-  pub(crate) fn sum(mut self) -> Scalar {
-    self.0.drain(..).sum()
-  }
-
-  pub(crate) fn inner_product(self, vector: &Self) -> Scalar {
-    (self * vector).sum()
-  }
-
-  pub(crate) fn weighted_inner_product(self, vector: &Self, y: &Self) -> Scalar {
-    (self * vector * y).sum()
-  }
-
-  pub(crate) fn split(mut self) -> (Self, Self) {
-    debug_assert!(self.len() > 1);
-    let r = self.0.split_off(self.0.len() / 2);
-    debug_assert_eq!(self.len(), r.len());
-    (self, ScalarVector(r))
-  }
-}

networks/monero/ringct/bulletproofs/src/tests/mod.rs

@@ -1,56 +0,0 @@
-use rand_core::{RngCore, OsRng};
-
-use curve25519_dalek::scalar::Scalar;
-
-use monero_primitives::Commitment;
-use crate::{batch_verifier::BatchVerifier, Bulletproof, BulletproofError};
-
-mod original;
-mod plus;
-
-macro_rules! bulletproofs_tests {
-  ($name: ident, $max: ident, $plus: literal) => {
-    #[test]
-    fn $name() {
-      // Create Bulletproofs for all possible output quantities
-      let mut verifier = BatchVerifier::new();
-      for i in 1 ..= 16 {
-        let commitments = (1 ..= i)
-          .map(|_| Commitment::new(Scalar::random(&mut OsRng), OsRng.next_u64()))
-          .collect::<Vec<_>>();
-
-        let bp = if $plus {
-          Bulletproof::prove_plus(&mut OsRng, commitments.clone()).unwrap()
-        } else {
-          Bulletproof::prove(&mut OsRng, commitments.clone()).unwrap()
-        };
-
-        let commitments = commitments.iter().map(Commitment::calculate).collect::<Vec<_>>();
-        assert!(bp.verify(&mut OsRng, &commitments));
-        assert!(bp.batch_verify(&mut OsRng, &mut verifier, &commitments));
-      }
-      assert!(verifier.verify());
-    }
-
-    #[test]
-    fn $max() {
-      // Check Bulletproofs errors if we try to prove for too many outputs
-      let mut commitments = vec![];
-      for _ in 0 .. 17 {
-        commitments.push(Commitment::new(Scalar::ZERO, 0));
-      }
-      assert_eq!(
-        (if $plus {
-          Bulletproof::prove_plus(&mut OsRng, commitments)
-        } else {
-          Bulletproof::prove(&mut OsRng, commitments)
-        })
-        .unwrap_err(),
-        BulletproofError::TooManyCommitments,
-      );
-    }
-  };
-}
-
-bulletproofs_tests!(bulletproofs, bulletproofs_max, false);
-bulletproofs_tests!(bulletproofs_plus, bulletproofs_plus_max, true);

networks/monero/ringct/bulletproofs/src/tests/original/inner_product.rs

@@ -1,75 +0,0 @@
-// The inner product relation is P = sum(g_bold * a, h_bold * b, g * (a * b))
-
-use rand_core::OsRng;
-
-use curve25519_dalek::Scalar;
-
-use monero_generators::H;
-
-use crate::{
-  scalar_vector::ScalarVector,
-  point_vector::PointVector,
-  original::{
-    GENERATORS,
-    inner_product::{IpStatement, IpWitness},
-  },
-  BulletproofsBatchVerifier,
-};
-
-#[test]
-fn test_zero_inner_product() {
-  let statement =
-    IpStatement::new_without_P_transcript(ScalarVector(vec![Scalar::ONE; 1]), Scalar::ONE);
-  let witness = IpWitness::new(ScalarVector::new(1), ScalarVector::new(1)).unwrap();
-
-  let transcript = Scalar::random(&mut OsRng);
-  let proof = statement.clone().prove(transcript, witness).unwrap();
-
-  let mut verifier = BulletproofsBatchVerifier::default();
-  verifier.0.g_bold = vec![Scalar::ZERO; 1];
-  verifier.0.h_bold = vec![Scalar::ZERO; 1];
-  statement.verify(&mut verifier, 1, transcript, Scalar::random(&mut OsRng), proof).unwrap();
-  assert!(verifier.verify());
-}
-
-#[test]
-fn test_inner_product() {
-  // P = sum(g_bold * a, h_bold * b, g * u * <a, b>)
-  let generators = &GENERATORS;
-  let mut verifier = BulletproofsBatchVerifier::default();
-  verifier.0.g_bold = vec![Scalar::ZERO; 32];
-  verifier.0.h_bold = vec![Scalar::ZERO; 32];
-  for i in [1, 2, 4, 8, 16, 32] {
-    let g = *H;
-    let mut g_bold = vec![];
-    let mut h_bold = vec![];
-    for i in 0 .. i {
-      g_bold.push(generators.G[i]);
-      h_bold.push(generators.H[i]);
-    }
-    let g_bold = PointVector(g_bold);
-    let h_bold = PointVector(h_bold);
-
-    let mut a = ScalarVector::new(i);
-    let mut b = ScalarVector::new(i);
-
-    for i in 0 .. i {
-      a[i] = Scalar::random(&mut OsRng);
-      b[i] = Scalar::random(&mut OsRng);
-    }
-
-    let P = g_bold.multiexp(&a) + h_bold.multiexp(&b) + (g * a.clone().inner_product(&b));
-
-    let statement =
-      IpStatement::new_without_P_transcript(ScalarVector(vec![Scalar::ONE; i]), Scalar::ONE);
-    let witness = IpWitness::new(a, b).unwrap();
-
-    let transcript = Scalar::random(&mut OsRng);
-    let proof = statement.clone().prove(transcript, witness).unwrap();
-
-    let weight = Scalar::random(&mut OsRng);
-    verifier.0.other.push((weight, P));
-    statement.verify(&mut verifier, i, transcript, weight, proof).unwrap();
-  }
-  assert!(verifier.verify());
-}

networks/monero/ringct/bulletproofs/src/tests/original/mod.rs

@@ -1,62 +0,0 @@
-use hex_literal::hex;
-use rand_core::OsRng;
-
-use curve25519_dalek::scalar::Scalar;
-
-use monero_io::decompress_point;
-
-use crate::{
-  original::{IpProof, AggregateRangeProof as OriginalProof},
-  Bulletproof,
-};
-
-mod inner_product;
-
-#[test]
-fn bulletproofs_vector() {
-  let scalar = |scalar| Scalar::from_canonical_bytes(scalar).unwrap();
-  let point = |point| decompress_point(point).unwrap();
-
-  // Generated from Monero
-  assert!(Bulletproof::Original(OriginalProof {
-    A: point(hex!("ef32c0b9551b804decdcb107eb22aa715b7ce259bf3c5cac20e24dfa6b28ac71")),
-    S: point(hex!("e1285960861783574ee2b689ae53622834eb0b035d6943103f960cd23e063fa0")),
-    T1: point(hex!("4ea07735f184ba159d0e0eb662bac8cde3eb7d39f31e567b0fbda3aa23fe5620")),
-    T2: point(hex!("b8390aa4b60b255630d40e592f55ec6b7ab5e3a96bfcdcd6f1cd1d2fc95f441e")),
-    tau_x: scalar(hex!("5957dba8ea9afb23d6e81cc048a92f2d502c10c749dc1b2bd148ae8d41ec7107")),
-    mu: scalar(hex!("923023b234c2e64774b820b4961f7181f6c1dc152c438643e5a25b0bf271bc02")),
-    ip: IpProof {
-      L: vec![
-        point(hex!("c45f656316b9ebf9d357fb6a9f85b5f09e0b991dd50a6e0ae9b02de3946c9d99")),
-        point(hex!("9304d2bf0f27183a2acc58cc755a0348da11bd345485fda41b872fee89e72aac")),
-        point(hex!("1bb8b71925d155dd9569f64129ea049d6149fdc4e7a42a86d9478801d922129b")),
-        point(hex!("5756a7bf887aa72b9a952f92f47182122e7b19d89e5dd434c747492b00e1c6b7")),
-        point(hex!("6e497c910d102592830555356af5ff8340e8d141e3fb60ea24cfa587e964f07d")),
-        point(hex!("f4fa3898e7b08e039183d444f3d55040f3c790ed806cb314de49f3068bdbb218")),
-        point(hex!("0bbc37597c3ead517a3841e159c8b7b79a5ceaee24b2a9a20350127aab428713")),
-      ],
-      R: vec![
-        point(hex!("609420ba1702781692e84accfd225adb3d077aedc3cf8125563400466b52dbd9")),
-        point(hex!("fb4e1d079e7a2b0ec14f7e2a3943bf50b6d60bc346a54fcf562fb234b342abf8")),
-        point(hex!("6ae3ac97289c48ce95b9c557289e82a34932055f7f5e32720139824fe81b12e5")),
-        point(hex!("d071cc2ffbdab2d840326ad15f68c01da6482271cae3cf644670d1632f29a15c")),
-        point(hex!("e52a1754b95e1060589ba7ce0c43d0060820ebfc0d49dc52884bc3c65ad18af5")),
-        point(hex!("41573b06140108539957df71aceb4b1816d2409ce896659aa5c86f037ca5e851")),
-        point(hex!("a65970b2cc3c7b08b2b5b739dbc8e71e646783c41c625e2a5b1535e3d2e0f742")),
-      ],
-      a: scalar(hex!("0077c5383dea44d3cd1bc74849376bd60679612dc4b945255822457fa0c0a209")),
-      b: scalar(hex!("fe80cf5756473482581e1d38644007793ddc66fdeb9404ec1689a907e4863302")),
-    },
-    t_hat: scalar(hex!("40dfb08e09249040df997851db311bd6827c26e87d6f0f332c55be8eef10e603"))
-  })
-  .verify(
-    &mut OsRng,
-    &[
-      // For some reason, these vectors are * INV_EIGHT
-      point(hex!("8e8f23f315edae4f6c2f948d9a861e0ae32d356b933cd11d2f0e031ac744c41f"))
-        .mul_by_cofactor(),
-      point(hex!("2829cbd025aa54cd6e1b59a032564f22f0b2e5627f7f2c4297f90da438b5510f"))
-        .mul_by_cofactor(),
-    ]
-  ));
-}

networks/monero/ringct/bulletproofs/src/tests/plus/aggregate_range_proof.rs

@@ -1,28 +0,0 @@
-use rand_core::{RngCore, OsRng};
-
-use curve25519_dalek::Scalar;
-
-use monero_primitives::Commitment;
-
-use crate::{
-  batch_verifier::BulletproofsPlusBatchVerifier,
-  plus::aggregate_range_proof::{AggregateRangeStatement, AggregateRangeWitness},
-};
-
-#[test]
-fn test_aggregate_range_proof() {
-  let mut verifier = BulletproofsPlusBatchVerifier::default();
-  for m in 1 ..= 16 {
-    let mut commitments = vec![];
-    for _ in 0 .. m {
-      commitments.push(Commitment::new(Scalar::random(&mut OsRng), OsRng.next_u64()));
-    }
-    let commitment_points = commitments.iter().map(Commitment::calculate).collect::<Vec<_>>();
-    let statement = AggregateRangeStatement::new(&commitment_points).unwrap();
-    let witness = AggregateRangeWitness::new(commitments).unwrap();
-
-    let proof = statement.clone().prove(&mut OsRng, &witness).unwrap();
-    statement.verify(&mut OsRng, &mut verifier, proof);
-  }
-  assert!(verifier.verify());
-}

networks/monero/ringct/bulletproofs/src/tests/plus/mod.rs

@@ -1,4 +0,0 @@
-#[cfg(test)]
-mod weighted_inner_product;
-#[cfg(test)]
-mod aggregate_range_proof;

networks/monero/ringct/bulletproofs/src/tests/plus/weighted_inner_product.rs

@@ -1,82 +0,0 @@
-// The inner product relation is P = sum(g_bold * a, h_bold * b, g * (a * y * b), h * alpha)
-
-use rand_core::OsRng;
-
-use curve25519_dalek::{traits::Identity, scalar::Scalar, edwards::EdwardsPoint};
-
-use crate::{
-  batch_verifier::BulletproofsPlusBatchVerifier,
-  plus::{
-    ScalarVector, PointVector, GeneratorsList, BpPlusGenerators,
-    weighted_inner_product::{WipStatement, WipWitness},
-  },
-};
-
-#[test]
-fn test_zero_weighted_inner_product() {
-  #[allow(non_snake_case)]
-  let P = EdwardsPoint::identity();
-  let y = Scalar::random(&mut OsRng);
-
-  let generators = BpPlusGenerators::new().reduce(1);
-  let statement = WipStatement::new(generators, P, y);
-  let witness = WipWitness::new(ScalarVector::new(1), ScalarVector::new(1), Scalar::ZERO).unwrap();
-
-  let transcript = Scalar::random(&mut OsRng);
-  let proof = statement.clone().prove(&mut OsRng, transcript, &witness).unwrap();
-
-  let mut verifier = BulletproofsPlusBatchVerifier::default();
-  statement.verify(&mut OsRng, &mut verifier, transcript, proof);
-  assert!(verifier.verify());
-}
-
-#[test]
-fn test_weighted_inner_product() {
-  // P = sum(g_bold * a, h_bold * b, g * (a * y * b), h * alpha)
-  let mut verifier = BulletproofsPlusBatchVerifier::default();
-  let generators = BpPlusGenerators::new();
-  for i in [1, 2, 4, 8, 16, 32] {
-    let generators = generators.reduce(i);
-    let g = BpPlusGenerators::g();
-    let h = BpPlusGenerators::h();
-    assert_eq!(generators.len(), i);
-    let mut g_bold = vec![];
-    let mut h_bold = vec![];
-    for i in 0 .. i {
-      g_bold.push(generators.generator(GeneratorsList::GBold, i));
-      h_bold.push(generators.generator(GeneratorsList::HBold, i));
-    }
-    let g_bold = PointVector(g_bold);
-    let h_bold = PointVector(h_bold);
-
-    let mut a = ScalarVector::new(i);
-    let mut b = ScalarVector::new(i);
-    let alpha = Scalar::random(&mut OsRng);
-
-    let y = Scalar::random(&mut OsRng);
-    let mut y_vec = ScalarVector::new(g_bold.len());
-    y_vec[0] = y;
-    for i in 1 .. y_vec.len() {
-      y_vec[i] = y_vec[i - 1] * y;
-    }
-
-    for i in 0 .. i {
-      a[i] = Scalar::random(&mut OsRng);
-      b[i] = Scalar::random(&mut OsRng);
-    }
-
-    #[allow(non_snake_case)]
-    let P = g_bold.multiexp(&a) +
-      h_bold.multiexp(&b) +
-      (g * a.clone().weighted_inner_product(&b, &y_vec)) +
-      (h * alpha);
-
-    let statement = WipStatement::new(generators, P, y);
-    let witness = WipWitness::new(a, b, alpha).unwrap();
-
-    let transcript = Scalar::random(&mut OsRng);
-    let proof = statement.clone().prove(&mut OsRng, transcript, &witness).unwrap();
-    statement.verify(&mut OsRng, &mut verifier, transcript, proof);
-  }
-  assert!(verifier.verify());
-}

networks/monero/ringct/clsag/Cargo.toml

@@ -1,65 +0,0 @@
-[package]
-name = "monero-clsag"
-version = "0.1.0"
-description = "The CLSAG linkable ring signature, as defined by the Monero protocol"
-license = "MIT"
-repository = "https://github.com/serai-dex/serai/tree/develop/networks/monero/ringct/clsag"
-authors = ["Luke Parker <lukeparker5132@gmail.com>"]
-edition = "2021"
-rust-version = "1.80"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[lints]
-workspace = true
-
-[dependencies]
-std-shims = { path = "../../../../common/std-shims", version = "^0.1.1", default-features = false }
-
-thiserror = { version = "1", default-features = false, optional = true }
-
-rand_core = { version = "0.6", default-features = false }
-zeroize = { version = "^1.5", default-features = false, features = ["zeroize_derive"] }
-subtle = { version = "^2.4", default-features = false }
-
-# Cryptographic dependencies
-curve25519-dalek = { version = "4", default-features = false, features = ["alloc", "zeroize"] }
-
-# Multisig dependencies
-rand_chacha = { version = "0.3", default-features = false, optional = true }
-transcript = { package = "flexible-transcript", path = "../../../../crypto/transcript", version = "0.3", default-features = false, features = ["recommended"], optional = true }
-group = { version = "0.13", default-features = false, optional = true }
-dalek-ff-group = { path = "../../../../crypto/dalek-ff-group", version = "0.4", default-features = false, optional = true }
-frost = { package = "modular-frost", path = "../../../../crypto/frost", default-features = false, features = ["ed25519"], optional = true }
-
-# Other Monero dependencies
-monero-io = { path = "../../io", version = "0.1", default-features = false }
-monero-generators = { path = "../../generators", version = "0.4", default-features = false }
-monero-primitives = { path = "../../primitives", version = "0.1", default-features = false }
-
-[dev-dependencies]
-frost = { package = "modular-frost", path = "../../../../crypto/frost", default-features = false, features = ["ed25519", "tests"] }
-
-[features]
-std = [
-  "std-shims/std",
-
-  "thiserror",
-
-  "rand_core/std",
-  "zeroize/std",
-  "subtle/std",
-
-  "rand_chacha?/std",
-  "transcript?/std",
-  "group?/alloc",
-  "dalek-ff-group?/std",
-
-  "monero-io/std",
-  "monero-generators/std",
-  "monero-primitives/std",
-]
-multisig = ["rand_chacha", "transcript", "group", "dalek-ff-group", "frost", "std"]
-default = ["std"]