@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.9

package/contracts/workers/dvn/src/dvn.rs

@@ -0,0 +1,143 @@
+use crate::{
+    errors::{DvnError, MultisigError},
+    events::SetDstConfig,
+    storage::DvnStorage,
+    types::{DstConfig, DstConfigParam},
+    IDVN,
+};
+use common_macros::ttl_configurable;
+use endpoint_v2::FeeRecipient;
+use message_lib_common::interfaces::ILayerZeroDVN;
+use soroban_sdk::{
+    assert_with_error, contract, contractimpl, crypto::Hash, xdr::ToXdr, Address, Bytes, BytesN, Env, Vec,
+};
+use utils::{buffer_writer::BufferWriter, option_ext::OptionExt};
+use worker::{
+    assert_acl, assert_not_paused, assert_supported_message_lib, init_worker, require_admin_auth, set_admin_by_admin,
+    set_admin_by_owner, storage::WorkerStorage, DvnFeeLibClient, DvnFeeParams, Worker,
+};
+#[contract]
+#[ttl_configurable]
+pub struct Dvn;
+
+#[contractimpl]
+impl Dvn {
+    pub fn __constructor(
+        env: &Env,
+        vid: u32,
+        signers: &Vec<BytesN<20>>,
+        threshold: u32,
+        admins: &Vec<Address>,
+        supported_msglibs: &Vec<Address>,
+        price_feed: &Address,
+        worker_fee_lib: &Address,
+        default_multiplier_bps: u32,
+        deposit_address: &Address,
+    ) {
+        init_multisig(env, signers, threshold);
+        Self::init_owner(env, &env.current_contract_address());
+        init_worker::<Self>(env, admins, supported_msglibs, price_feed, default_multiplier_bps);
+        WorkerStorage::set_worker_fee_lib(env, worker_fee_lib);
+        WorkerStorage::set_deposit_address(env, deposit_address);
+        DvnStorage::set_vid(env, &vid);
+    }
+
+    /// Sets admin status for an address. Can be called by an existing admin.
+    ///
+    /// This allows existing admins to add or remove other admins without going through
+    /// the owner/multisig path.
+    ///
+    /// # Arguments
+    /// * `caller` - The admin calling this function (must provide authorization)
+    /// * `admin` - The address to set admin status for
+    /// * `active` - `true` to add admin, `false` to remove
+    pub fn set_admin(env: &Env, caller: &Address, admin: &Address, active: bool) {
+        set_admin_by_admin::<Self>(env, caller, admin, active);
+    }
+
+    /// Function for quorum to change the admin without going through the execute function
+    ///
+    /// # Arguments
+    ///
+    /// * `admin` - The address to set admin status for
+    /// * `active` - `true` to add admin, `false` to remove
+    pub fn quorum_change_admin(env: &Env, admin: &Address, active: bool) {
+        set_admin_by_owner::<Self>(env, admin, active);
+    }
+}
+
+#[contractimpl]
+impl IDVN for Dvn {
+    fn set_dst_config(env: &Env, admin: &Address, params: &Vec<DstConfigParam>) {
+        require_admin_auth::<Self>(env, admin);
+        for param in params {
+            DvnStorage::set_dst_config(env, param.dst_eid, &param.config);
+        }
+
+        SetDstConfig { params: params.clone() }.publish(env);
+    }
+
+    fn dst_config(env: &Env, dst_eid: u32) -> DstConfig {
+        DvnStorage::dst_config(env, dst_eid).unwrap_or_panic(env, DvnError::EidNotSupported)
+    }
+
+    fn vid(env: &Env) -> u32 {
+        DvnStorage::vid(env).unwrap()
+    }
+}
+
+#[contractimpl]
+impl ILayerZeroDVN for Dvn {
+    fn get_fee(
+        env: &Env,
+        _send_lib: &Address,
+        sender: &Address,
+        dst_eid: u32,
+        _packet_header: &Bytes,
+        _payload_hash: &BytesN<32>,
+        confirmations: u64,
+        options: &Bytes,
+    ) -> i128 {
+        assert_not_paused::<Self>(env);
+        assert_acl::<Self>(env, sender);
+
+        let dst_config = Self::dst_config(env, dst_eid);
+        let params = DvnFeeParams {
+            sender: sender.clone(),
+            dst_eid,
+            confirmations,
+            options: options.clone(),
+            price_feed: Self::price_feed(env),
+            default_multiplier_bps: Self::default_multiplier_bps(env),
+            quorum: Self::threshold(env),
+            gas: dst_config.gas,
+            multiplier_bps: dst_config.multiplier_bps,
+            floor_margin_usd: dst_config.floor_margin_usd,
+        };
+
+        DvnFeeLibClient::new(env, &Self::worker_fee_lib(env)).get_fee(&params)
+    }
+
+    fn assign_job(
+        env: &Env,
+        send_lib: &Address,
+        sender: &Address,
+        dst_eid: u32,
+        packet_header: &Bytes,
+        payload_hash: &BytesN<32>,
+        confirmations: u64,
+        options: &Bytes,
+    ) -> FeeRecipient {
+        send_lib.require_auth();
+        assert_supported_message_lib::<Self>(env, send_lib);
+
+        let fee = Self::get_fee(env, send_lib, sender, dst_eid, packet_header, payload_hash, confirmations, options);
+        FeeRecipient { amount: fee, to: Self::deposit_address(env) }
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl Worker for Dvn {}
+
+include!("multisig.rs");
+include!("auth.rs");

package/contracts/workers/dvn/src/errors.rs

@@ -0,0 +1,21 @@
+use common_macros::contract_error;
+
+#[contract_error]
+pub enum MultisigError {
+    ZeroThreshold,
+    TotalSignersLessThanThreshold,
+    InvalidSigner,
+    SignerAlreadyExists,
+    SignerNotFound,
+    UnsortedSigners,
+    SignatureError,
+}
+
+#[contract_error]
+pub enum DvnError {
+    InvalidVid,
+    AuthDataExpired,
+    HashAlreadyUsed,
+    OnlyAdmin,
+    EidNotSupported,
+}

package/contracts/workers/dvn/src/events.rs

@@ -0,0 +1,19 @@
+use crate::DstConfigParam;
+use common_macros::event;
+use soroban_sdk::{BytesN, Vec};
+
+#[event]
+pub struct SignerSet {
+    pub signer: BytesN<20>,
+    pub active: bool,
+}
+
+#[event]
+pub struct ThresholdSet {
+    pub threshold: u32,
+}
+
+#[event]
+pub struct SetDstConfig {
+    pub params: Vec<DstConfigParam>,
+}

package/contracts/workers/dvn/src/interfaces/dvn.rs

@@ -0,0 +1,12 @@
+use crate::types::{DstConfig, DstConfigParam};
+use crate::IMultisig;
+use message_lib_common::interfaces::ILayerZeroDVN;
+use soroban_sdk::{contractclient, Address, Env, Vec};
+use worker::Worker;
+
+#[contractclient(name = "DVNClient")]
+pub trait IDVN: ILayerZeroDVN + Worker + IMultisig {
+    fn set_dst_config(env: &Env, admin: &Address, params: &Vec<DstConfigParam>);
+    fn dst_config(env: &Env, dst_eid: u32) -> DstConfig;
+    fn vid(env: &Env) -> u32;
+}

package/contracts/workers/dvn/src/interfaces/mod.rs

@@ -0,0 +1,5 @@
+mod dvn;
+mod multisig;
+
+pub use dvn::*;
+pub use multisig::*;

package/contracts/workers/dvn/src/interfaces/multisig.rs

@@ -0,0 +1,15 @@
+use soroban_sdk::{contractclient, BytesN, Env, Vec};
+
+pub const SIGNATURE_LENGTH: usize = 65;
+
+#[contractclient(name = "MultiSigClient")]
+pub trait IMultisig {
+    fn set_signer(env: &Env, signer: &BytesN<20>, active: bool);
+    fn get_signers(env: &Env) -> Vec<BytesN<20>>;
+    fn total_signers(env: &Env) -> u32;
+    fn is_signer(env: &Env, signer: &BytesN<20>) -> bool;
+    fn threshold(env: &Env) -> u32;
+    fn set_threshold(env: &Env, threshold: u32);
+    fn verify_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<SIGNATURE_LENGTH>>);
+    fn verify_n_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<SIGNATURE_LENGTH>>, threshold: u32);
+}

package/contracts/workers/dvn/src/lib.rs

@@ -0,0 +1,24 @@
+#![no_std]
+#[cfg(test)]
+extern crate std;
+
+mod errors;
+pub mod events;
+mod interfaces;
+mod types;
+
+pub use errors::*;
+pub use interfaces::*;
+pub use types::*;
+
+cfg_if::cfg_if! {
+    if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
+        mod storage;
+        mod dvn;
+
+        pub use dvn::Dvn;
+    }
+}
+
+#[cfg(test)]
+mod tests;

package/contracts/workers/dvn/src/multisig.rs

@@ -0,0 +1,127 @@
+use crate::{
+    events::{SignerSet, ThresholdSet},
+    storage::MultisigStorage,
+    IMultisig,
+};
+
+#[contractimpl]
+impl IMultisig for Dvn {
+    fn set_signer(env: &Env, signer: &BytesN<20>, active: bool) {
+        env.current_contract_address().require_auth();
+
+        if active {
+            add_signer(env, signer);
+        } else {
+            remove_signer(env, signer);
+        }
+    }
+
+    fn set_threshold(env: &Env, threshold: u32) {
+        env.current_contract_address().require_auth();
+
+        set_threshold(env, threshold);
+    }
+
+    fn get_signers(env: &Env) -> Vec<BytesN<20>> {
+        MultisigStorage::signers(env)
+    }
+
+    fn total_signers(env: &Env) -> u32 {
+        MultisigStorage::signers(env).len()
+    }
+
+    fn is_signer(env: &Env, signer: &BytesN<20>) -> bool {
+        MultisigStorage::signers(env).iter().any(|s| &s == signer)
+    }
+
+    fn threshold(env: &Env) -> u32 {
+        MultisigStorage::threshold(env)
+    }
+
+    fn verify_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<65>>) {
+        Self::verify_n_signatures(env, hash, signatures, Self::threshold(env));
+    }
+
+    fn verify_n_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<65>>, threshold: u32) {
+        assert_with_error!(env, threshold > 0, MultisigError::ZeroThreshold);
+        assert_with_error!(env, signatures.len() >= threshold, MultisigError::SignatureError);
+
+        let mut last_signer: Option<BytesN<20>> = None;
+        signatures.iter().for_each(|signature| {
+            let signer = recover_signer(env, hash, &signature);
+
+            // Signers must be strictly increasing
+            assert_with_error!(
+                env,
+                last_signer.as_ref().is_none_or(|last| &signer > last),
+                MultisigError::UnsortedSigners
+            );
+            assert_with_error!(env, Self::is_signer(env, &signer), MultisigError::SignerNotFound);
+
+            last_signer = Some(signer);
+        });
+    }
+}
+
+// ============================================================================
+// Internal Helper Functions
+// ============================================================================
+
+fn add_signer(env: &Env, signer: &BytesN<20>) {
+    let zero_signer = BytesN::from_array(env, &[0u8; 20]);
+    assert_with_error!(env, signer != &zero_signer, MultisigError::InvalidSigner);
+
+    let mut signers = MultisigStorage::signers(env);
+    assert_with_error!(env, !signers.iter().any(|s| &s == signer), MultisigError::SignerAlreadyExists);
+    signers.push_back(signer.clone());
+    MultisigStorage::set_signers(env, &signers);
+
+    SignerSet { signer: signer.clone(), active: true }.publish(env);
+}
+
+fn remove_signer(env: &Env, signer: &BytesN<20>) {
+    let mut signers = MultisigStorage::signers(env);
+    let index = signers.first_index_of(signer);
+    assert_with_error!(env, index.is_some(), MultisigError::SignerNotFound);
+
+    signers.remove(index.unwrap());
+    // Check that removing didn't violate threshold constraint
+    assert_with_error!(
+        env,
+        signers.len() >= MultisigStorage::threshold(env),
+        MultisigError::TotalSignersLessThanThreshold
+    );
+    MultisigStorage::set_signers(env, &signers);
+
+    SignerSet { signer: signer.clone(), active: false }.publish(env);
+}
+
+fn set_threshold(env: &Env, threshold: u32) {
+    assert_with_error!(env, threshold > 0, MultisigError::ZeroThreshold);
+    assert_with_error!(
+        env,
+        MultisigStorage::signers(env).len() >= threshold,
+        MultisigError::TotalSignersLessThanThreshold
+    );
+
+    MultisigStorage::set_threshold(env, &threshold);
+
+    ThresholdSet { threshold }.publish(env);
+}
+
+fn init_multisig(env: &Env, signers: &Vec<BytesN<20>>, threshold: u32) {
+    signers.iter().for_each(|signer| add_signer(env, &signer));
+
+    set_threshold(env, threshold);
+}
+
+fn recover_signer(env: &Env, digest: &BytesN<32>, signature: &BytesN<65>) -> BytesN<20> {
+    let sig_bytes: Bytes = signature.into();
+    let v = sig_bytes.get(64).unwrap();
+    let recovery_id = if (27..=30).contains(&v) { v - 27 } else { v };
+    let sig_rs: BytesN<64> = sig_bytes.slice(0..64).try_into().unwrap();
+
+    let public_key = env.crypto_hazmat().secp256k1_recover(digest, &sig_rs, recovery_id as u32);
+
+    Bytes::from(env.crypto().keccak256(&Bytes::from(public_key).slice(1..65))).slice(12..32).try_into().unwrap()
+}

package/contracts/workers/dvn/src/storage.rs

@@ -0,0 +1,35 @@
+use crate::DstConfig;
+use common_macros::storage;
+use soroban_sdk::{BytesN, Vec};
+
+// ============================================================================
+// Multisig Storage
+// ============================================================================
+
+#[storage]
+pub enum MultisigStorage {
+    #[persistent(Vec<BytesN<20>>)]
+    #[default(Vec::new(env))]
+    Signers,
+
+    #[instance(u32)]
+    #[default(0)]
+    Threshold,
+}
+
+// ============================================================================
+// DVN Storage
+// ============================================================================
+
+#[storage]
+pub enum DvnStorage {
+    #[instance(u32)]
+    Vid,
+
+    #[persistent(DstConfig)]
+    DstConfig { dst_eid: u32 },
+
+    #[persistent(bool)]
+    #[default(false)]
+    UsedHash { hash: BytesN<32> },
+}

package/contracts/workers/dvn/src/tests/auth.rs

@@ -0,0 +1,237 @@
+use crate::tests::setup::{TestSetup, VID};
+use crate::{errors::DvnError, errors::MultisigError, TransactionAuthData};
+use ed25519_dalek::{Signer, SigningKey};
+use rand::thread_rng;
+use soroban_sdk::{auth::Context, vec, Bytes, BytesN, Env, IntoVal, Vec};
+
+struct Ed25519KeyPair {
+    signing_key: SigningKey,
+}
+
+impl Ed25519KeyPair {
+    fn generate() -> Self {
+        Self { signing_key: SigningKey::generate(&mut thread_rng()) }
+    }
+
+    fn public_key_bytes(&self) -> [u8; 32] {
+        self.signing_key.verifying_key().to_bytes()
+    }
+
+    fn public_key(&self, env: &Env) -> BytesN<32> {
+        self.public_key_bytes().into_val(env)
+    }
+
+    fn sign(&self, env: &Env, message: &[u8; 32]) -> BytesN<64> {
+        let sig = self.signing_key.sign(message);
+        BytesN::from_array(env, &sig.to_bytes())
+    }
+}
+
+fn hash_auth_data(env: &Env, vid: u32, expiration: u64, auth_contexts: &Vec<Context>) -> BytesN<32> {
+    use soroban_sdk::xdr::ToXdr;
+    let mut data = Bytes::new(env);
+    data.extend_from_array(&vid.to_be_bytes());
+    data.extend_from_array(&expiration.to_be_bytes());
+    data.append(&auth_contexts.to_xdr(env));
+    let hash = env.crypto().keccak256(&data);
+    BytesN::from_array(env, &hash.to_array())
+}
+
+#[test]
+fn test_check_auth_success() {
+    extern crate std;
+    let admin_kp = Ed25519KeyPair::generate();
+    let admin_bytes = admin_kp.public_key_bytes();
+
+    let setup = TestSetup::with_admin_bytes(1, std::vec![admin_bytes]);
+    let env = setup.env.clone();
+    let expiration = env.ledger().timestamp() + 1000;
+    let auth_contexts: Vec<Context> = Vec::new(&env);
+
+    let payload = BytesN::from_array(&env, &[0u8; 32]);
+    let admin = admin_kp.public_key(&env);
+    let admin_signature = admin_kp.sign(&env, &payload.to_array());
+
+    let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
+    let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
+
+    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], admin, admin_signature };
+
+    let res = env.try_invoke_contract_check_auth::<DvnError>(
+        &setup.contract_id,
+        &payload,
+        tx_auth.into_val(&env),
+        &auth_contexts,
+    );
+
+    assert!(res.is_ok(), "Expected success, got {:?}", res);
+}
+
+#[test]
+fn test_check_auth_not_admin() {
+    extern crate std;
+    let non_admin_kp = Ed25519KeyPair::generate();
+
+    let setup = TestSetup::new(1);
+    let env = setup.env.clone();
+    let expiration = env.ledger().timestamp() + 1000;
+    let auth_contexts: Vec<Context> = Vec::new(&env);
+
+    let payload = BytesN::from_array(&env, &[0u8; 32]);
+    let admin = non_admin_kp.public_key(&env);
+    let admin_signature = non_admin_kp.sign(&env, &payload.to_array());
+
+    let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
+    let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
+
+    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], admin, admin_signature };
+
+    let res = env.try_invoke_contract_check_auth::<DvnError>(
+        &setup.contract_id,
+        &payload,
+        tx_auth.into_val(&env),
+        &auth_contexts,
+    );
+
+    assert_eq!(res, Err(Ok(DvnError::OnlyAdmin)));
+}
+
+#[test]
+fn test_check_auth_wrong_signer_fails() {
+    extern crate std;
+    let admin_kp = Ed25519KeyPair::generate();
+    let admin_bytes = admin_kp.public_key_bytes();
+
+    let setup = TestSetup::with_admin_bytes(1, std::vec![admin_bytes]);
+    let env = setup.env.clone();
+    let expiration = env.ledger().timestamp() + 1000;
+    let auth_contexts: Vec<Context> = Vec::new(&env);
+
+    let payload = BytesN::from_array(&env, &[0u8; 32]);
+    let admin = admin_kp.public_key(&env);
+    let admin_signature = admin_kp.sign(&env, &payload.to_array());
+
+    let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
+    let wrong_sig = crate::tests::key_pair::KeyPair::generate().sign_bytes(&env, &hash);
+
+    let tx_auth =
+        TransactionAuthData { vid: VID, expiration, signatures: vec![&env, wrong_sig], admin, admin_signature };
+
+    // verify_signatures panics with MultisigError::SignerNotFound when signer is not found
+    let res = env.try_invoke_contract_check_auth::<MultisigError>(
+        &setup.contract_id,
+        &payload,
+        tx_auth.into_val(&env),
+        &auth_contexts,
+    );
+
+    assert_eq!(res, Err(Ok(MultisigError::SignerNotFound)));
+}
+
+#[test]
+fn test_check_auth_invalid_vid_fails() {
+    extern crate std;
+    let admin_kp = Ed25519KeyPair::generate();
+    let admin_bytes = admin_kp.public_key_bytes();
+
+    let setup = TestSetup::with_admin_bytes(1, std::vec![admin_bytes]);
+    let env = setup.env.clone();
+    let expiration = env.ledger().timestamp() + 1000;
+    let wrong_vid = VID + 1;
+    let auth_contexts: Vec<Context> = Vec::new(&env);
+
+    let payload = BytesN::from_array(&env, &[0u8; 32]);
+    let admin = admin_kp.public_key(&env);
+    let admin_signature = admin_kp.sign(&env, &payload.to_array());
+
+    let hash = hash_auth_data(&env, wrong_vid, expiration, &auth_contexts);
+    let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
+
+    let tx_auth =
+        TransactionAuthData { vid: wrong_vid, expiration, signatures: vec![&env, sig], admin, admin_signature };
+
+    let res = env.try_invoke_contract_check_auth::<DvnError>(
+        &setup.contract_id,
+        &payload,
+        tx_auth.into_val(&env),
+        &auth_contexts,
+    );
+
+    assert_eq!(res, Err(Ok(DvnError::InvalidVid)));
+}
+
+#[test]
+fn test_check_auth_expired_fails() {
+    extern crate std;
+    let admin_kp = Ed25519KeyPair::generate();
+    let admin_bytes = admin_kp.public_key_bytes();
+
+    let setup = TestSetup::with_admin_bytes(1, std::vec![admin_bytes]);
+    let env = setup.env.clone();
+    let expiration = env.ledger().timestamp();
+    let auth_contexts: Vec<Context> = Vec::new(&env);
+
+    let payload = BytesN::from_array(&env, &[0u8; 32]);
+    let admin = admin_kp.public_key(&env);
+    let admin_signature = admin_kp.sign(&env, &payload.to_array());
+
+    let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
+    let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
+
+    let tx_auth = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], admin, admin_signature };
+
+    let res = env.try_invoke_contract_check_auth::<DvnError>(
+        &setup.contract_id,
+        &payload,
+        tx_auth.into_val(&env),
+        &auth_contexts,
+    );
+
+    assert_eq!(res, Err(Ok(DvnError::AuthDataExpired)));
+}
+
+#[test]
+fn test_check_auth_hash_already_used_fails() {
+    extern crate std;
+    let admin_kp = Ed25519KeyPair::generate();
+    let admin_bytes = admin_kp.public_key_bytes();
+
+    let setup = TestSetup::with_admin_bytes(1, std::vec![admin_bytes]);
+    let env = setup.env.clone();
+    let expiration = env.ledger().timestamp() + 1000;
+    let auth_contexts: Vec<Context> = Vec::new(&env);
+
+    let payload = BytesN::from_array(&env, &[0u8; 32]);
+    let admin = admin_kp.public_key(&env);
+    let admin_signature = admin_kp.sign(&env, &payload.to_array());
+
+    let hash = hash_auth_data(&env, VID, expiration, &auth_contexts);
+    let sig = setup.key_pairs[0].sign_bytes(&env, &hash);
+
+    let tx_auth = TransactionAuthData {
+        vid: VID,
+        expiration,
+        signatures: vec![&env, sig.clone()],
+        admin: admin.clone(),
+        admin_signature: admin_signature.clone(),
+    };
+
+    let res = env.try_invoke_contract_check_auth::<DvnError>(
+        &setup.contract_id,
+        &payload,
+        tx_auth.into_val(&env),
+        &auth_contexts,
+    );
+    assert!(res.is_ok());
+
+    let tx_auth2 = TransactionAuthData { vid: VID, expiration, signatures: vec![&env, sig], admin, admin_signature };
+
+    let res2 = env.try_invoke_contract_check_auth::<DvnError>(
+        &setup.contract_id,
+        &payload,
+        tx_auth2.into_val(&env),
+        &auth_contexts,
+    );
+
+    assert_eq!(res2, Err(Ok(DvnError::HashAlreadyUsed)));
+}