XRPL Multisig Prover

Cargo.toml

@@ -14,6 +14,8 @@ axelar-wasm-std = { version = "^0.1.0", path = "packages/axelar-wasm-std" }
 axelar-wasm-std-derive = { version = "^0.1.0", path = "packages/axelar-wasm-std-derive" }
 itertools = "0.11.0"
 voting-verifier = { version = "^0.1.0", path = "contracts/voting-verifier" }
+xrpl-voting-verifier = { version = "^0.1.0", path = "contracts/xrpl-voting-verifier" }
+xrpl-multisig-prover = { version = "^0.1.0", path = "contracts/xrpl-multisig-prover" }
 multisig = { version = "^0.1.0", path = "contracts/multisig" }
 multisig-prover = { version = "^0.1.0", path = "contracts/multisig-prover" }
 service-registry = { version = "^0.1.0", path = "contracts/service-registry" }

contracts/xrpl-multisig-prover/Cargo.toml

@@ -0,0 +1,57 @@
+[package]
+name = "xrpl-multisig-prover"
+version = "0.1.0"
+edition = "2021"
+description = "XRPL multisig prover contract"
+
+exclude = [
+  # Those files are rust-optimizer artifacts. You might want to commit them for convenience but they should not be part of the source code publication.
+  "contract.wasm",
+  "hash.txt",
+]
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+# for more explicit tests, cargo test --features=backtraces
+backtraces = ["cosmwasm-std/backtraces"]
+# use library feature to disable all instantiate/execute/query exports
+library = []
+
+[package.metadata.scripts]
+optimize = """docker run --rm -v "$(pwd)":/code \
+  --mount type=volume,source="$(basename "$(pwd)")_cache",target=/code/target \
+  --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
+  cosmwasm/rust-optimizer:0.12.6
+"""
+
+[dependencies]
+cosmwasm-std = { workspace = true }
+cosmwasm-schema = { workspace = true }
+axelar-wasm-std = { workspace = true }
+axelar-wasm-std-derive = { workspace = true }
+cw-storage-plus = { workspace = true }
+connection-router = { workspace = true, features = ["library"] }
+service-registry = { workspace = true }
+multisig = { workspace = true, features = ["library"] }
+gateway = { workspace = true }
+thiserror = { workspace = true }
+error-stack = { workspace = true }
+report = { workspace = true }
+serde_json = "1.0.89"
+sha2 = { version = "0.10.7" }
+sha3 = { workspace = true }
+cw-utils = "1.0.1"
+bs58 = "0.5.0"
+ripemd = "0.1.3"
+hex = { version = "0.4.3", default-features = false, features = [] }
+xrpl-voting-verifier = { workspace = true, features = ["library"] }
+k256 = { version = "0.13.1", features = ["ecdsa"] }
+
+[dev-dependencies]
+anyhow = "1.0"
+cw-multi-test = "0.15.1"
+elliptic-curve = "0.13.5"
+generic-array = "0.14.7"

contracts/xrpl-multisig-prover/src/axelar_workers.rs

@@ -0,0 +1,203 @@
+use std::collections::hash_map::RandomState;
+use std::collections::{BTreeSet, HashMap};
+
+use axelar_wasm_std::{Threshold, nonempty};
+use axelar_wasm_std::Participant;
+use cosmwasm_schema::cw_serde;
+use cosmwasm_std::{HexBinary, Uint256, Addr, Fraction};
+use multisig::key::KeyType;
+use service_registry::state::Worker;
+use multisig::key::PublicKey;
+
+use crate::querier::Querier;
+use crate::error::ContractError;
+
+#[cw_serde]
+#[derive(Eq, Ord, PartialOrd)]
+pub struct AxelarSigner {
+    pub address: Addr,
+    pub weight: u16,
+    pub pub_key: PublicKey,
+}
+
+impl Into<Participant> for AxelarSigner {
+    fn into(self) -> Participant {
+        let weight = nonempty::Uint256::try_from(Uint256::from(self.weight as u128)).unwrap();
+        Participant {
+            address: self.address,
+            weight,
+        }
+    }
+}
+
+#[cw_serde]
+pub struct WorkerSet {
+    pub signers: BTreeSet<AxelarSigner>,
+    pub quorum: u32,
+    // for hash uniqueness. The same exact worker set could be in use at two different times,
+    // and we need to be able to distinguish between the two
+    pub created_at: u64,
+}
+
+impl Into<multisig::worker_set::WorkerSet> for WorkerSet {
+    fn into(self) -> multisig::worker_set::WorkerSet {
+        let participants = self.signers.into_iter()
+            .map(|s| (s.clone().into(), s.pub_key))
+            .collect();
+        multisig::worker_set::WorkerSet::new(
+            participants,
+            Uint256::from(self.quorum as u128),
+            self.created_at
+        )
+    }
+}
+
+impl WorkerSet {
+    pub fn pub_keys_by_address(&self) -> HashMap<String, (KeyType, HexBinary), RandomState> {
+        self
+            .signers
+            .clone()
+            .into_iter()
+            .map(|signer| {
+                (
+                    signer.address.to_string(),
+                    (KeyType::Ecdsa, signer.pub_key.as_ref().into()),
+                )
+            })
+            .collect()
+    }
+}
+
+fn convert_uint256_to_u16_unsafely(value: Uint256) -> u16 {
+    let bytes = value.to_le_bytes();
+    (bytes[0] as u16) | (bytes[1] as u16) << 8
+}
+
+// Converts a Vec<Uint256> to Vec<u16>, scaling down with precision loss, if necessary.
+// We make sure that XRPL multisig and Axelar multisig both use the same scaled down numbers and have the same precision loss
+fn convert_or_scale_weights(weights: Vec<Uint256>) -> Vec<u16> {
+    let max_weight: Option<&Uint256> = weights.iter().max();
+    match max_weight {
+        Some(max_weight) => {
+            let max_u16_as_uint256 = Uint256::from(u16::MAX);
+            // Scaling down
+            weights
+                .clone()
+                .into_iter()
+                .map(|weight| {
+                    // multiply_ratio returns a rounded down value
+                    let scaled = weight.multiply_ratio(max_u16_as_uint256, *max_weight);
+                    convert_uint256_to_u16_unsafely(scaled)
+                })
+                .collect()
+        },
+        None => vec![],
+    }
+}
+
+pub fn get_active_worker_set(
+    querier: Querier,
+    signing_threshold: Threshold,
+    block_height: u64,
+) -> Result<WorkerSet, ContractError> {
+    let workers: Vec<Worker> = querier.get_active_workers()?;
+
+    let participants: Vec<Participant> = workers
+        .into_iter()
+        .map(|worker| Participant::try_from(worker))
+        .filter(|result| result.is_ok())
+        .map(|result| result.unwrap())
+        .collect();
+
+    let weights = convert_or_scale_weights(participants
+        .clone()
+        .into_iter()
+        .map(|participant| Uint256::from(participant.weight))
+        .collect());
+
+    let mut signers: Vec<AxelarSigner> = vec![];
+    for (i, participant) in participants.iter().enumerate() {
+        let pub_key: PublicKey = querier.get_public_key(participant.address.clone().to_string())?;
+        signers.push(AxelarSigner {
+            address: participant.address.clone(),
+            weight: weights[i],
+            pub_key,
+        });
+    }
+
+    let sum_of_weights: u32 = weights.iter().map(|w| u32::from(*w)).sum();
+
+    let quorum = (sum_of_weights as u64)
+        .checked_mul(signing_threshold.numerator().into())
+        .unwrap()
+        .checked_div(signing_threshold.denominator().into())
+        .unwrap() as u32;
+
+    let worker_set = WorkerSet {
+        signers: signers.into_iter().collect(),
+        quorum,
+        created_at: block_height,
+    };
+
+    Ok(worker_set)
+}
+
+pub fn should_update_worker_set(
+    new_workers: &WorkerSet,
+    cur_workers: &WorkerSet,
+    max_diff: usize,
+) -> bool {
+    new_workers.signers.difference(&cur_workers.signers).count()
+        + cur_workers.signers.difference(&new_workers.signers).count()
+        > max_diff
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_convert_or_scale_weights() {
+        let weights = vec![Uint256::from(1u128), Uint256::from(1u128)];
+        let scaled_weights = convert_or_scale_weights(weights);
+        assert_eq!(scaled_weights, vec![65535, 65535]);
+
+        let weights = vec![Uint256::from(1u128), Uint256::from(2u128), Uint256::from(3u128)];
+        let scaled_weights = convert_or_scale_weights(weights);
+        assert_eq!(scaled_weights, vec![21845, 43690, 65535]);
+
+        let weights = vec![Uint256::from(1u128), Uint256::from(2u128), Uint256::from(3u128), Uint256::from(4u128)];
+        let scaled_weights = convert_or_scale_weights(weights);
+        assert_eq!(scaled_weights, vec![16383, 32767, 49151, 65535]);
+
+        let weights = vec![
+            Uint256::MAX - Uint256::from(3u128),
+            Uint256::MAX - Uint256::from(2u128),
+            Uint256::MAX - Uint256::from(1u128),
+            Uint256::MAX
+        ];
+        let scaled_weights = convert_or_scale_weights(weights);
+        assert_eq!(scaled_weights, vec![65534, 65534, 65534, 65535]);
+
+        let weights = vec![
+            Uint256::from(0u128),
+            Uint256::from(1u128),
+            Uint256::MAX - Uint256::from(1u128),
+            Uint256::MAX
+        ];
+        let scaled_weights = convert_or_scale_weights(weights);
+        assert_eq!(scaled_weights, vec![0, 0, 65534, 65535]);
+
+        let weights = vec![
+            Uint256::from(100000u128),
+            Uint256::from(2000000u128),
+            Uint256::from(30000000u128),
+            Uint256::from(400000000u128),
+            Uint256::from(50000000000u128),
+        ];
+        let scaled_weights = convert_or_scale_weights(weights);
+        assert_eq!(scaled_weights, vec![0, 2, 39, 524, 65535]);
+
+        assert_eq!(convert_or_scale_weights(vec![] as Vec<Uint256>), vec![] as Vec<u16>);
+    }
+}