feat(multisig-prover): encode bcs proof

contracts/multisig-prover/Cargo.toml

@@ -30,6 +30,7 @@ optimize = """docker run --rm -v "$(pwd)":/code \
 [dependencies]
 axelar-wasm-std = { workspace = true }
 axelar-wasm-std-derive = { workspace = true }
+bcs = "0.1.5"
 connection-router = { workspace = true, features = ["library"] }
 cosmwasm-schema = "1.1.3"
 cosmwasm-std = "1.1.3"

contracts/multisig-prover/src/encoding/bcs.rs

@@ -0,0 +1,135 @@
+use bcs::to_bytes;
+use cosmwasm_std::{HexBinary, Uint256};
+use itertools::Itertools;
+use multisig::{key::Signature, msg::Signer};
+
+use crate::{error::ContractError, types::Operator};
+
+fn u256_to_u128(val: Uint256) -> u128 {
+    val.to_string().parse().expect("value is larger than u128")
+}
+
+#[allow(dead_code)]
+fn encode_proof(
+    quorum: Uint256,
+    signers: Vec<(Signer, Option<Signature>)>,
+) -> Result<HexBinary, ContractError> {
+    let mut operators = make_operators_with_sigs(signers);
+    operators.sort(); // gateway requires operators to be sorted
+
+    let (addresses, weights, signatures): (Vec<_>, Vec<_>, Vec<_>) = operators
+        .iter()
+        .map(|op| {
+            (
+                op.address.to_vec(),
+                u256_to_u128(op.weight),
+                op.signature.as_ref().map(|sig| sig.as_ref().to_vec()),
+            )
+        })
+        .multiunzip();
+
+    let signatures: Vec<Vec<u8>> = signatures.into_iter().flatten().collect();
+    let quorum = u256_to_u128(quorum);
+    Ok(to_bytes(&(addresses, weights, quorum, signatures))?.into())
+}
+
+fn make_operators_with_sigs(signers_with_sigs: Vec<(Signer, Option<Signature>)>) -> Vec<Operator> {
+    signers_with_sigs
+        .into_iter()
+        .map(|(signer, sig)| Operator {
+            address: signer.pub_key.into(),
+            weight: signer.weight,
+            signature: sig,
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod test {
+
+    use std::vec;
+
+    use bcs::from_bytes;
+    use cosmwasm_std::{Addr, HexBinary, Uint256};
+    use multisig::{
+        key::{PublicKey, Signature},
+        msg::Signer,
+    };
+
+    use crate::encoding::bcs::u256_to_u128;
+
+    use super::encode_proof;
+
+    #[test]
+    fn test_u256_to_u128() {
+        let val = u128::MAX;
+        assert_eq!(val, u256_to_u128(Uint256::from(val)));
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_u256_to_u128_fails() {
+        let _ = u256_to_u128(Uint256::MAX);
+    }
+
+    #[test]
+    fn test_encode_proof() {
+        let signers = vec![
+        (Signer {
+            address: Addr::unchecked("axelarvaloper1ff675m593vve8yh82lzhdnqfpu7m23cxstr6h4"),
+            weight: Uint256::from(10u128),
+            pub_key: PublicKey::Ecdsa(
+                HexBinary::from_hex(
+                    "03c6ddb0fcee7b528da1ef3c9eed8d51eeacd7cc28a8baa25c33037c5562faa6e4",
+                )
+                .unwrap(),
+            ),
+        },
+        Some(Signature::Ecdsa(
+        HexBinary::from_hex("283786d844a7c4d1d424837074d0c8ec71becdcba4dd42b5307cb543a0e2c8b81c10ad541defd5ce84d2a608fc454827d0b65b4865c8192a2ea1736a5c4b72021b").unwrap()))),
+            (Signer {
+            address: Addr::unchecked("axelarvaloper1x86a8prx97ekkqej2x636utrdu23y8wupp9gk5"),
+            weight: Uint256::from(10u128),
+            pub_key: PublicKey::Ecdsa(
+                HexBinary::from_hex(
+                    "03d123ce370b163acd576be0e32e436bb7e63262769881d35fa3573943bf6c6f81",
+                )
+                .unwrap(),
+            ),
+        },
+        Some(Signature::Ecdsa(
+        HexBinary::from_hex("283786d844a7c4d1d424837074d0c8ec71becdcba4dd42b5307cb543a0e2c8b81c10ad541defd5ce84d2a608fc454827d0b65b4865c8192a2ea1736a5c4b72021b").unwrap())))];
+
+        let quorum = Uint256::from(10u128);
+        let proof = encode_proof(quorum, signers.clone());
+
+        assert!(proof.is_ok());
+        let proof = proof.unwrap();
+        let decoded_proof: Result<(Vec<Vec<u8>>, Vec<u128>, u128, Vec<Vec<u8>>), _> =
+            from_bytes(&proof);
+        assert!(decoded_proof.is_ok());
+        let (operators, weights, quorum_decoded, signatures): (
+            Vec<Vec<u8>>,
+            Vec<u128>,
+            u128,
+            Vec<Vec<u8>>,
+        ) = decoded_proof.unwrap();
+
+        assert_eq!(operators.len(), signers.len());
+        assert_eq!(weights.len(), signers.len());
+        assert_eq!(signatures.len(), signers.len());
+        assert_eq!(quorum_decoded, 10u128);
+
+        for i in 0..signers.len() {
+            assert_eq!(
+                operators[i],
+                HexBinary::from(signers[i].0.pub_key.clone()).to_vec()
+            );
+            assert_eq!(weights[i], 10u128);
+            assert_eq!(
+                signatures[i],
+                HexBinary::from(signers[i].1.clone().unwrap()).to_vec()
+            );
+        }
+    }
+}

contracts/multisig-prover/src/encoding/mod.rs

@@ -1,4 +1,5 @@
 mod abi;
+mod bcs;
 
 use axelar_wasm_std::operators::Operators;
 use cosmwasm_schema::cw_serde;

contracts/multisig-prover/src/error.rs

@@ -35,6 +35,9 @@ pub enum ContractError {
     #[error(transparent)]
     NonEmptyError(#[from] nonempty::Error),
 
+    #[error(transparent)]
+    BcsError(#[from] bcs::Error),
+
     #[error("worker set has not changed sufficiently since last update")]
     WorkerSetUnchanged,