feat: add initial integration (POC) of the axelar-encoding crate

Cargo.toml

@@ -37,6 +37,7 @@ serde_json = "1.0.89"
 schemars = "0.8.10"
 sha3 = { version = "0.10.8", default-features = false, features = [] }
 signature-verifier-api = { version = "^0.1.0", path = "packages/signature-verifier-api" }
+axelar-encoding = { git = "ssh://[email protected]/eigerco/solana-axelar-internal.git", branch = "main"}
 
 [workspace.lints.clippy]
 arithmetic_side_effects = "deny"

contracts/multisig-prover/Cargo.toml

@@ -59,6 +59,7 @@ service-registry = { workspace = true }
 sha3 = { workspace = true }
 thiserror = { workspace = true }
 voting-verifier = { workspace = true, features = ["library"] }
+axelar-encoding = { workspace = true }
 
 [dev-dependencies]
 anyhow = "1.0"

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

@@ -1,4 +1,5 @@
 pub mod abi;
+pub mod sol;
 
 use cosmwasm_schema::cw_serde;
 
@@ -7,4 +8,5 @@ use cosmwasm_schema::cw_serde;
 pub enum Encoder {
     Abi,
     Bcs,
+    Solana
 }

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

@@ -0,0 +1,136 @@
+use std::{array::TryFromSliceError, collections::BTreeMap};
+
+use axelar_encoding::types::{
+    CrossChainId, Message, Payload, PublicKey, Signature, Signer, WeightedSignature, WorkerSet,
+    U256,
+};
+
+use itertools::Itertools;
+use multisig::{msg::SignerWithSig, verifier_set::VerifierSet};
+
+use crate::error::ContractError;
+
+const ECDSA_COMPRESSED_PUBKEY_LEN: usize = 33; // this should be probably a public constant in axelar_encoding.
+const ED25519_PUBKEY_LEN: usize = 32; // this should be probably a public constant in axelar_encoding.
+
+type Result<T> = core::result::Result<T, ContractError>;
+
+pub fn to_worker_set(vs: &VerifierSet) -> Result<WorkerSet> {
+    let mut signers: BTreeMap<String, Signer> = BTreeMap::new();
+
+    vs.signers
+        .iter()
+        .try_for_each(|(address, signer)| -> Result<()> {
+            let enc_signer = signer.address.to_string();
+            let enc_pubkey = to_pub_key(&signer.pub_key)?;
+
+            let enc_weight = U256::from_be(to_u256_be(signer.weight.u128()));
+
+            signers.insert(
+                address.clone(),
+                Signer::new(enc_signer, enc_pubkey, enc_weight),
+            );
+            Ok(())
+        })?;
+
+    Ok(WorkerSet::new(
+        vs.created_at,
+        signers,
+        U256::from_be(to_u256_be(vs.threshold.u128())),
+    ))
+}
+
+fn to_pub_key(pk: &multisig::key::PublicKey) -> Result<PublicKey> {
+    Ok(match pk {
+        multisig::key::PublicKey::Ecdsa(hb) => {
+            PublicKey::new_ecdsa(hb.to_array::<ECDSA_COMPRESSED_PUBKEY_LEN>()?)
+        }
+        multisig::key::PublicKey::Ed25519(hb) => {
+            PublicKey::new_ed25519(hb.to_array::<ED25519_PUBKEY_LEN>()?)
+        }
+    })
+}
+
+// Fits a u128 into a u256 in big endian representation.
+fn to_u256_be(u: u128) -> [u8; 32] {
+    let mut uin256 = [0u8; 32];
+    uin256[16..32].copy_from_slice(&u.to_be_bytes());
+    uin256
+}
+
+impl TryFrom<&crate::payload::Payload> for Payload {
+    type Error = ContractError;
+    fn try_from(value: &crate::payload::Payload) -> std::result::Result<Self, Self::Error> {
+        Ok(match value {
+            crate::payload::Payload::Messages(msgs) => {
+                Payload::new_messages(msgs.iter().map(to_msg).collect_vec())
+            }
+            crate::payload::Payload::VerifierSet(vs) => {
+                Payload::new_worker_set(to_worker_set(&vs)?)
+            }
+        })
+    }
+}
+
+fn to_msg(msg: &router_api::Message) -> Message {
+    let enc_cc_id = CrossChainId::new(msg.cc_id.chain.to_string(), msg.cc_id.id.to_string());
+
+    Message::new(
+        enc_cc_id,
+        msg.source_address.to_string(),
+        msg.destination_chain.to_string(),
+        msg.destination_address.to_string(),
+        msg.payload_hash,
+    )
+}
+
+pub fn to_weighted_signature(sig: &SignerWithSig) -> Result<WeightedSignature> {
+    let enc_pub_key = to_pub_key(&sig.signer.pub_key)?;
+    let enc_signature = to_signature(&sig.signature)?;
+    let enc_weight = U256::from_be(to_u256_be(sig.signer.weight.u128()));
+
+    Ok(WeightedSignature::new(
+        enc_pub_key,
+        enc_signature,
+        enc_weight,
+    ))
+}
+
+fn to_signature(sig: &multisig::key::Signature) -> Result<Signature> {
+    match sig {
+        multisig::key::Signature::Ecdsa(_) => unimplemented!(), // Todo: should we implement this in axelar_encoding ?
+
+        // Following 2: We are just moving the bytes around, hoping this conversions match. Not sure if `HexBinary`
+        // representation will match here with the decoding part.
+        multisig::key::Signature::EcdsaRecoverable(r) => {
+            let data = r
+                .as_ref()
+                .try_into()
+                .map_err(|e: TryFromSliceError| ContractError::SolEncodingError(e.to_string()))?;
+            Ok(Signature::EcdsaRecoverable(data))
+        }
+        multisig::key::Signature::Ed25519(ed) => {
+            let data = ed
+                .as_ref()
+                .try_into()
+                .map_err(|e: TryFromSliceError| ContractError::SolEncodingError(e.to_string()))?;
+
+            Ok(Signature::new_ed25519(data))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn conversion_to_u256_be_works() {
+        let integer = to_u256_be(u128::MAX);
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255,
+            255, 255, 255, 255, 255, 255, 255, 255,
+        ];
+        assert_eq!(expected, integer);
+    }
+}

contracts/multisig-prover/src/error.rs

@@ -41,6 +41,11 @@ pub enum ContractError {
     #[error(transparent)]
     BcsError(#[from] bcs::Error),
 
+    /// Todo, Below error throws: binary operation `==` cannot be applied to type `EncodingError<1024>`
+    /// this is a workaround.
+    #[error("encoding/decoding failure: [0]")]
+    SolEncodingError(String),
+
     #[error("verifier set has not changed sufficiently since last update")]
     VerifierSetUnchanged,
 

contracts/multisig-prover/src/payload.rs

@@ -1,6 +1,7 @@
 use cosmwasm_schema::cw_serde;
 use cosmwasm_std::{from_json, HexBinary, StdResult};
 use cw_storage_plus::{Key, KeyDeserialize, PrimaryKey};
+use itertools::Itertools;
 use sha3::{Digest, Keccak256};
 
 use axelar_wasm_std::hash::Hash;
@@ -9,7 +10,11 @@ use multisig::verifier_set::VerifierSet;
 use router_api::{CrossChainId, Message};
 
 use crate::{
-    encoding::{abi, Encoder},
+    encoding::{
+        abi,
+        sol::{to_weighted_signature, to_worker_set},
+        Encoder,
+    },
     error::ContractError,
 };
 
@@ -46,6 +51,11 @@ impl Payload {
         match encoder {
             Encoder::Abi => abi::payload_hash_to_sign(domain_separator, cur_verifier_set, self),
             Encoder::Bcs => todo!(),
+            Encoder::Solana => Ok(axelar_encoding::hash_payload(
+                &domain_separator,
+                &to_worker_set(cur_verifier_set)?,
+                &axelar_encoding::types::Payload::try_from(self)?,
+            )),
         }
     }
 
@@ -70,6 +80,23 @@ impl Payload {
                 abi::execute_data::encode(verifier_set, signers_with_sigs, &payload_hash, payload)
             }
             Encoder::Bcs => todo!(),
+            Encoder::Solana => {
+                let mut enc_signatures = Vec::new();
+
+                for s in signers_with_sigs {
+                    enc_signatures.push(to_weighted_signature(&s)?)
+                }
+
+                let bytes = axelar_encoding::encode::<1024>(
+                    // Todo reason about this "1024" magic number.
+                    &to_worker_set(&verifier_set)?,
+                    enc_signatures,
+                    axelar_encoding::types::Payload::try_from(payload)?,
+                )
+                .map_err(|e| ContractError::SolEncodingError(e.to_string()))?;
+
+                Ok(HexBinary::from(bytes)) // Todo, what kind of conversion if any comes from here. Can we expect hex repr directly ?
+            }
         }
     }
 }