@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/contracts/utils/src/ttl.rs

@@ -1,123 +0,0 @@
-use crate::errors::TtlError;
-use soroban_sdk::{assert_with_error, contractclient, contractevent, contracttype, Env};
-
-/// Number of ledgers per day (~5 second ledger close time).
-pub const LEDGERS_PER_DAY: u32 = (24 * 3600) / 5;
-
-/// Maximum TTL (1 year) allowed by the protocol.
-/// Note: Stellar's current maximum TTL is 6 months, but this constraint may change
-/// in the future. In order to preserve LayerZero's censorship-resistance and protect
-/// users from abusive parameter changes, a constant upper bound is enforced on the
-/// extend_to value.
-pub const MAX_TTL: u32 = 365 * LEDGERS_PER_DAY;
-
-/// Default TTL for instance storage (30 days, extends at 29 days remaining).
-pub const DEFAULT_INSTANCE_TTL: TtlConfig = TtlConfig::new(29 * LEDGERS_PER_DAY, 30 * LEDGERS_PER_DAY);
-/// Default TTL for persistent storage (30 days, extends at 29 days remaining).
-pub const DEFAULT_PERSISTENT_TTL: TtlConfig = TtlConfig::new(29 * LEDGERS_PER_DAY, 30 * LEDGERS_PER_DAY);
-
-/// A pair of TTL values: threshold (when to trigger extension) and extend_to (target TTL).
-#[contracttype]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct TtlConfig {
-    /// TTL threshold that triggers extension (in ledgers).
-    pub threshold: u32,
-    /// Target TTL after extension (in ledgers).
-    pub extend_to: u32,
-}
-
-impl TtlConfig {
-    /// Creates a new TTL config.
-    pub const fn new(threshold: u32, extend_to: u32) -> Self {
-        Self { threshold, extend_to }
-    }
-
-    /// Validates that threshold <= extend_to <= max_ttl.
-    pub fn is_valid(&self, max_ttl: u32) -> bool {
-        self.threshold <= self.extend_to && self.extend_to <= max_ttl
-    }
-}
-
-/// Storage keys for TTL configuration.
-///
-/// Note: These instance storage entries do NOT have automatic TTL extension enabled to avoid
-/// infinite recursion--extending TTL config storage would require reading the TTL config,
-/// which would trigger another extension, creating a deep loop.
-#[common_macros::storage]
-pub enum TtlConfigStorage {
-    #[instance(bool)]
-    #[default(false)]
-    Frozen,
-
-    #[instance(TtlConfig)]
-    Instance,
-
-    #[instance(TtlConfig)]
-    Persistent,
-}
-
-/// Trait for contracts that allow TTL configuration management.
-#[contractclient(name = "TtlConfigurableClient")]
-pub trait TtlConfigurable {
-    /// Sets TTL configs. None values remove the config.
-    fn set_ttl_configs(env: &Env, instance: &Option<TtlConfig>, persistent: &Option<TtlConfig>);
-
-    /// Returns current TTL configs (instance, persistent).
-    fn ttl_configs(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>);
-
-    /// Permanently freezes TTL configs, preventing further changes.
-    fn freeze_ttl_configs(env: &Env);
-
-    /// Returns whether TTL configs are frozen.
-    fn is_ttl_configs_frozen(env: &Env) -> bool;
-}
-
-/// Default implementation of TtlConfigurable.
-pub struct DefaultTtlConfigurable;
-
-impl TtlConfigurable for DefaultTtlConfigurable {
-    fn set_ttl_configs(env: &Env, instance: &Option<TtlConfig>, persistent: &Option<TtlConfig>) {
-        assert_with_error!(env, !Self::is_ttl_configs_frozen(env), TtlError::TtlConfigFrozen);
-
-        let max_ttl = u32::min(MAX_TTL, env.storage().max_ttl());
-        let all_valid = [instance, persistent].iter().all(|c| c.is_none_or(|cfg| cfg.is_valid(max_ttl)));
-        assert_with_error!(env, all_valid, TtlError::InvalidTtlConfig);
-
-        TtlConfigStorage::set_or_remove_instance(env, instance);
-        TtlConfigStorage::set_or_remove_persistent(env, persistent);
-
-        TtlConfigsSet { instance: *instance, persistent: *persistent }.publish(env);
-    }
-
-    fn ttl_configs(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>) {
-        (TtlConfigStorage::instance(env), TtlConfigStorage::persistent(env))
-    }
-
-    fn freeze_ttl_configs(env: &Env) {
-        assert_with_error!(env, !Self::is_ttl_configs_frozen(env), TtlError::TtlConfigAlreadyFrozen);
-        TtlConfigStorage::set_frozen(env, &true);
-
-        TtlConfigsFrozen {}.publish(env);
-    }
-
-    fn is_ttl_configs_frozen(env: &Env) -> bool {
-        TtlConfigStorage::frozen(env)
-    }
-}
-
-// ============================================
-// Events
-// ============================================
-
-/// Event emitted when TTL configs are set.
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct TtlConfigsSet {
-    pub instance: Option<TtlConfig>,
-    pub persistent: Option<TtlConfig>,
-}
-
-/// Event emitted when TTL configs are frozen.
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct TtlConfigsFrozen {}

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

@@ -1,56 +0,0 @@
-use soroban_sdk::{contractclient, BytesN, Env, Vec};
-
-/// Length of an ECDSA signature (64 bytes) plus recovery ID (1 byte).
-pub const SIGNATURE_LENGTH: usize = 65;
-
-/// Multisig interface for threshold-based signature verification.
-///
-/// Provides functionality to manage signers and verify that a sufficient
-/// number of valid signatures (meeting the threshold) have signed a message.
-#[contractclient(name = "MultiSigClient")]
-pub trait IMultisig {
-    /// Adds or removes a signer from the multisig.
-    ///
-    /// # Arguments
-    /// * `signer` - The 20-byte signer address (derived from secp256k1 public key)
-    /// * `active` - `true` to add, `false` to remove
-    fn set_signer(env: &Env, signer: &BytesN<20>, active: bool);
-
-    /// Returns all registered signers.
-    fn get_signers(env: &Env) -> Vec<BytesN<20>>;
-
-    /// Returns the total number of registered signers.
-    fn total_signers(env: &Env) -> u32;
-
-    /// Checks if an address is a registered signer.
-    fn is_signer(env: &Env, signer: &BytesN<20>) -> bool;
-
-    /// Returns the current signature threshold (quorum).
-    fn threshold(env: &Env) -> u32;
-
-    /// Sets the signature threshold (quorum).
-    ///
-    /// The threshold must be greater than 0 and not exceed total signers.
-    fn set_threshold(env: &Env, threshold: u32);
-
-    /// Verifies signatures against the configured threshold.
-    ///
-    /// # Arguments
-    /// * `hash` - The 32-byte message hash that was signed
-    /// * `signatures` - List of signatures to verify
-    ///
-    /// # Panics
-    /// If fewer than `threshold` valid signatures from registered signers are provided.
-    fn verify_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<SIGNATURE_LENGTH>>);
-
-    /// Verifies signatures against a custom threshold.
-    ///
-    /// # Arguments
-    /// * `hash` - The 32-byte message hash that was signed
-    /// * `signatures` - List of signatures to verify
-    /// * `threshold` - Custom threshold to use instead of the configured one
-    ///
-    /// # Panics
-    /// If fewer than `threshold` valid signatures from registered signers are provided.
-    fn verify_n_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<SIGNATURE_LENGTH>>, threshold: u32);
-}

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

@@ -1,153 +0,0 @@
-//! Multisig functionality for the DVN contract.
-//!
-//! Provides secp256k1-based multisig signature verification using Ethereum-style
-//! 20-byte addresses derived from recovered public keys.
-
-use super::*;
-
-use crate::{
-    errors::DvnError,
-    events::{SignerSet, ThresholdSet},
-    storage::DvnStorage,
-};
-use soroban_sdk::assert_with_error;
-
-// ============================================================================
-// IMultisig Implementation
-// ============================================================================
-
-#[contract_impl]
-impl IMultisig for LzDVN {
-    /// Adds or removes a signer. Requires contract self-authorization (quorum).
-    fn set_signer(env: &Env, signer: &BytesN<20>, active: bool) {
-        env.current_contract_address().require_auth();
-        if active {
-            Self::add_signer(env, signer);
-        } else {
-            Self::remove_signer(env, signer);
-        }
-    }
-
-    /// Updates the signature threshold. Requires contract self-authorization (quorum).
-    fn set_threshold(env: &Env, threshold: u32) {
-        env.current_contract_address().require_auth();
-
-        assert_with_error!(env, threshold > 0, DvnError::ZeroThreshold);
-        assert_with_error!(env, Self::total_signers(env) >= threshold, DvnError::TotalSignersLessThanThreshold);
-
-        DvnStorage::set_threshold(env, &threshold);
-
-        ThresholdSet { threshold }.publish(env);
-    }
-
-    /// Returns the list of all registered signers.
-    fn get_signers(env: &Env) -> Vec<BytesN<20>> {
-        DvnStorage::signers(env)
-    }
-
-    /// Returns the total number of registered signers.
-    fn total_signers(env: &Env) -> u32 {
-        DvnStorage::signers(env).len()
-    }
-
-    /// Checks if an address is a registered signer.
-    fn is_signer(env: &Env, signer: &BytesN<20>) -> bool {
-        DvnStorage::signers(env).iter().any(|s| &s == signer)
-    }
-
-    /// Returns the current signature threshold.
-    fn threshold(env: &Env) -> u32 {
-        DvnStorage::threshold(env)
-    }
-
-    /// Verifies signatures against the current threshold.
-    fn verify_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<65>>) {
-        Self::verify_n_signatures(env, hash, signatures, Self::threshold(env));
-    }
-
-    /// Verifies that at least `threshold` valid signatures exist for the given hash.
-    ///
-    /// Signatures must be:
-    /// - From registered signers
-    /// - Sorted by signer address (ascending, no duplicates)
-    fn verify_n_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<65>>, threshold: u32) {
-        assert_with_error!(env, threshold > 0, DvnError::ZeroThreshold);
-        assert_with_error!(env, signatures.len() >= threshold, DvnError::SignatureError);
-
-        let mut last_signer: Option<BytesN<20>> = None;
-        signatures.iter().for_each(|signature| {
-            let signer = Self::recover_signer(env, hash, &signature);
-
-            // Signers must be strictly increasing (ensures no duplicates)
-            assert_with_error!(env, last_signer.as_ref().is_none_or(|last| &signer > last), DvnError::UnsortedSigners);
-            assert_with_error!(env, Self::is_signer(env, &signer), DvnError::SignerNotFound);
-
-            last_signer = Some(signer);
-        });
-    }
-}
-
-// ============================================================================
-// Internal Functions
-// ============================================================================
-
-impl LzDVN {
-    /// Initializes the multisig with a set of signers and threshold.
-    /// Called during contract construction.
-    pub fn init_multisig(env: &Env, signers: &Vec<BytesN<20>>, threshold: u32) {
-        signers.iter().for_each(|signer| Self::add_signer(env, &signer));
-        Self::set_threshold(env, threshold);
-    }
-
-    /// Adds a new signer to the multisig.
-    ///
-    /// # Errors
-    /// - `InvalidSigner` if the signer is the zero address
-    /// - `SignerAlreadyExists` if the signer is already registered
-    fn add_signer(env: &Env, signer: &BytesN<20>) {
-        let zero_signer = BytesN::from_array(env, &[0u8; 20]);
-        assert_with_error!(env, signer != &zero_signer, DvnError::InvalidSigner);
-
-        let mut signers = Self::get_signers(env);
-        assert_with_error!(env, !signers.iter().any(|s| &s == signer), DvnError::SignerAlreadyExists);
-        signers.push_back(signer.clone());
-        DvnStorage::set_signers(env, &signers);
-
-        SignerSet { signer: signer.clone(), active: true }.publish(env);
-    }
-
-    /// Removes a signer from the multisig.
-    ///
-    /// # Errors
-    /// - `SignerNotFound` if the signer is not registered
-    /// - `TotalSignersLessThanThreshold` if removal would violate threshold constraint
-    fn remove_signer(env: &Env, signer: &BytesN<20>) {
-        let mut signers = Self::get_signers(env);
-        let index = signers.first_index_of(signer);
-        assert_with_error!(env, index.is_some(), DvnError::SignerNotFound);
-
-        signers.remove(index.unwrap());
-
-        // Ensure removal doesn't violate threshold constraint
-        assert_with_error!(env, signers.len() >= Self::threshold(env), DvnError::TotalSignersLessThanThreshold);
-        DvnStorage::set_signers(env, &signers);
-
-        SignerSet { signer: signer.clone(), active: false }.publish(env);
-    }
-
-    /// Recovers the Ethereum-style signer address from a secp256k1 signature.
-    ///
-    /// The signature format is 65 bytes: r (32) + s (32) + v (1).
-    /// Returns the last 20 bytes of keccak256(uncompressed_pubkey[1..65]).
-    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);
-
-        // Derive Ethereum address: keccak256(pubkey[1..65])[12..32]
-        Bytes::from(env.crypto().keccak256(&Bytes::from(public_key).slice(1..65))).slice(12..32).try_into().unwrap()
-    }
-}