@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.9

package/contracts/utils/src/tests/ttl.rs

@@ -0,0 +1,421 @@
+extern crate std;
+
+use crate::errors::TtlError;
+use crate::ttl::{
+    DefaultTtlConfigurable, TtlConfig, TtlConfigStorage, TtlConfigurable, DEFAULT_INSTANCE_TTL, DEFAULT_PERSISTENT_TTL,
+    MAX_TTL,
+};
+use soroban_sdk::{contract, contractimpl, Address, Env};
+
+// ============================================
+// Test Contract for TTL functionality
+// ============================================
+
+#[contract]
+pub struct TtlTestContract;
+
+#[contractimpl]
+impl TtlTestContract {
+    // TtlConfigStorage storage tests
+    pub fn frozen(env: &Env) -> bool {
+        TtlConfigStorage::frozen(env)
+    }
+
+    pub fn set_frozen(env: &Env, value: bool) {
+        TtlConfigStorage::set_frozen(env, &value);
+    }
+
+    pub fn instance_ttl(env: &Env) -> TtlConfig {
+        TtlConfigStorage::instance(env).unwrap_or(DEFAULT_INSTANCE_TTL)
+    }
+
+    pub fn set_instance_ttl(env: &Env, config: TtlConfig) {
+        TtlConfigStorage::set_instance(env, &config);
+    }
+
+    pub fn has_instance_ttl(env: &Env) -> bool {
+        TtlConfigStorage::has_instance(env)
+    }
+
+    pub fn remove_instance_ttl(env: &Env) {
+        TtlConfigStorage::remove_instance(env);
+    }
+
+    pub fn remove_persistent_ttl(env: &Env) {
+        TtlConfigStorage::remove_persistent(env);
+    }
+
+    pub fn persistent_ttl(env: &Env) -> TtlConfig {
+        TtlConfigStorage::persistent(env).unwrap_or(DEFAULT_PERSISTENT_TTL)
+    }
+
+    pub fn set_persistent_ttl(env: &Env, config: TtlConfig) {
+        TtlConfigStorage::set_persistent(env, &config);
+    }
+
+    pub fn has_persistent_ttl(env: &Env) -> bool {
+        TtlConfigStorage::has_persistent(env)
+    }
+
+    // DefaultTtlConfigurable tests
+    pub fn configurable_set_ttl_configs(env: &Env, instance: Option<TtlConfig>, persistent: Option<TtlConfig>) {
+        DefaultTtlConfigurable::set_ttl_configs(env, &instance, &persistent);
+    }
+
+    pub fn configurable_ttl_configs(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>) {
+        DefaultTtlConfigurable::ttl_configs(env)
+    }
+
+    pub fn configurable_freeze_ttl_configs(env: &Env) {
+        DefaultTtlConfigurable::freeze_ttl_configs(env);
+    }
+
+    pub fn is_ttl_configs_frozen(env: &Env) -> bool {
+        DefaultTtlConfigurable::is_ttl_configs_frozen(env)
+    }
+}
+
+fn setup_contract() -> (Env, Address, TtlTestContractClient<'static>) {
+    let env = Env::default();
+    let contract_id = env.register(TtlTestContract, ());
+    let client = TtlTestContractClient::new(&env, &contract_id);
+    (env, contract_id, client)
+}
+
+// ============================================
+// TtlConfig Struct Tests
+// ============================================
+
+#[test]
+fn test_ttl_config_new() {
+    let config = TtlConfig::new(100, 200);
+    assert_eq!(config.threshold, 100);
+    assert_eq!(config.extend_to, 200);
+}
+
+#[test]
+fn test_ttl_config_is_valid() {
+    // Valid configs
+    assert!(TtlConfig::new(100, 200).is_valid(300)); // threshold < extend_to < max
+    assert!(TtlConfig::new(100, 100).is_valid(200)); // threshold == extend_to
+    assert!(TtlConfig::new(100, 200).is_valid(200)); // extend_to == max
+    assert!(TtlConfig::new(100, 100).is_valid(100)); // all equal
+    assert!(TtlConfig::new(0, 0).is_valid(0)); // all zeros
+    assert!(TtlConfig::new(0, 0).is_valid(100)); // zero config with non-zero max
+    assert!(TtlConfig::new(0, 100).is_valid(100)); // threshold at minimum
+    assert!(TtlConfig::new(99, 100).is_valid(100)); // threshold just below extend_to
+    assert!(TtlConfig::new(MAX_TTL - 1, MAX_TTL).is_valid(MAX_TTL)); // large values
+    assert!(TtlConfig::new(MAX_TTL, MAX_TTL).is_valid(MAX_TTL)); // max values
+
+    // Invalid configs
+    assert!(!TtlConfig::new(200, 100).is_valid(300)); // threshold > extend_to
+    assert!(!TtlConfig::new(100, 400).is_valid(300)); // extend_to > max
+    assert!(!TtlConfig::new(100, 100).is_valid(99)); // extend_to > max
+}
+
+#[test]
+fn test_default_ttl_configs_are_valid() {
+    assert!(DEFAULT_INSTANCE_TTL.is_valid(MAX_TTL));
+    assert!(DEFAULT_PERSISTENT_TTL.is_valid(MAX_TTL));
+}
+
+// ============================================
+// TtlConfigStorage Storage Tests
+// ============================================
+
+#[test]
+fn test_ttl_config_data_defaults() {
+    let (_, _, client) = setup_contract();
+
+    // Default frozen state should be false
+    assert!(!client.frozen());
+
+    // Default TTLs should be returned when not set
+    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
+    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
+
+    // has_* should return false initially
+    assert!(!client.has_instance_ttl());
+    assert!(!client.has_persistent_ttl());
+}
+
+#[test]
+fn test_ttl_config_data_set_get_remove() {
+    let (_, _, client) = setup_contract();
+
+    let instance_cfg = TtlConfig::new(1000, 2000);
+    let persistent_cfg = TtlConfig::new(3000, 4000);
+
+    // Set and verify instance
+    client.set_instance_ttl(&instance_cfg);
+    assert!(client.has_instance_ttl());
+    assert_eq!(client.instance_ttl(), instance_cfg);
+
+    // Set and verify persistent
+    client.set_persistent_ttl(&persistent_cfg);
+    assert!(client.has_persistent_ttl());
+    assert_eq!(client.persistent_ttl(), persistent_cfg);
+
+    // Remove and verify defaults return
+    client.remove_instance_ttl();
+    assert!(!client.has_instance_ttl());
+    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
+
+    // Remove persistent
+    client.remove_persistent_ttl();
+    assert!(!client.has_persistent_ttl());
+    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
+}
+
+#[test]
+fn test_ttl_config_data_frozen() {
+    let (_, _, client) = setup_contract();
+
+    assert!(!client.frozen());
+
+    client.set_frozen(&true);
+    assert!(client.frozen());
+
+    client.set_frozen(&false);
+    assert!(!client.frozen());
+}
+
+#[test]
+fn test_ttl_config_data_independent_storage() {
+    let (_, _, client) = setup_contract();
+
+    let instance_cfg = TtlConfig::new(100, 200);
+    let persistent_cfg = TtlConfig::new(300, 400);
+
+    // Set each independently and verify others unchanged
+    client.set_instance_ttl(&instance_cfg);
+    assert_eq!(client.instance_ttl(), instance_cfg);
+    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
+
+    client.set_persistent_ttl(&persistent_cfg);
+    assert_eq!(client.instance_ttl(), instance_cfg);
+    assert_eq!(client.persistent_ttl(), persistent_cfg);
+}
+
+#[test]
+fn test_ttl_config_data_remove_all() {
+    let (_, _, client) = setup_contract();
+
+    let instance_cfg = TtlConfig::new(1000, 2000);
+    let persistent_cfg = TtlConfig::new(3000, 4000);
+
+    // Set all configs
+    client.set_instance_ttl(&instance_cfg);
+    client.set_persistent_ttl(&persistent_cfg);
+
+    // Verify all are set
+    assert!(client.has_instance_ttl());
+    assert!(client.has_persistent_ttl());
+
+    // Remove all
+    client.remove_instance_ttl();
+    client.remove_persistent_ttl();
+
+    // Verify all return to defaults
+    assert!(!client.has_instance_ttl());
+    assert!(!client.has_persistent_ttl());
+    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
+    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
+}
+
+#[test]
+fn test_ttl_config_data_remove_when_not_set() {
+    let (_, _, client) = setup_contract();
+
+    // Removing when not set should not panic
+    client.remove_instance_ttl();
+    client.remove_persistent_ttl();
+
+    // Should still return defaults
+    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
+    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
+}
+
+// ============================================
+// DefaultTtlConfigurable Tests - Basic Operations
+// ============================================
+
+#[test]
+fn test_default_ttl_configurable_initial_state() {
+    let (_, _, client) = setup_contract();
+
+    let (instance, persistent) = client.configurable_ttl_configs();
+    assert!(instance.is_none());
+    assert!(persistent.is_none());
+
+    assert!(!client.is_ttl_configs_frozen());
+}
+
+#[test]
+fn test_default_ttl_configurable_set_all() {
+    let (_, _, client) = setup_contract();
+
+    let instance_cfg = TtlConfig::new(1000, 2000);
+    let persistent_cfg = TtlConfig::new(3000, 4000);
+
+    client.configurable_set_ttl_configs(&Some(instance_cfg), &Some(persistent_cfg));
+
+    let (instance, persistent) = client.configurable_ttl_configs();
+    assert_eq!(instance, Some(instance_cfg));
+    assert_eq!(persistent, Some(persistent_cfg));
+}
+
+#[test]
+fn test_default_ttl_configurable_set_partial() {
+    let (_, _, client) = setup_contract();
+
+    let instance_cfg = TtlConfig::new(1000, 2000);
+
+    // Only set instance config
+    client.configurable_set_ttl_configs(&Some(instance_cfg), &None);
+
+    let (instance, persistent) = client.configurable_ttl_configs();
+    assert_eq!(instance, Some(instance_cfg));
+    assert!(persistent.is_none());
+}
+
+#[test]
+fn test_default_ttl_configurable_set_and_remove() {
+    let (_, _, client) = setup_contract();
+
+    let instance_cfg = TtlConfig::new(1000, 2000);
+
+    // Set config
+    client.configurable_set_ttl_configs(&Some(instance_cfg), &None);
+    assert_eq!(client.configurable_ttl_configs().0, Some(instance_cfg));
+
+    // Remove by passing None
+    client.configurable_set_ttl_configs(&None, &None);
+    assert!(client.configurable_ttl_configs().0.is_none());
+}
+
+// ============================================
+// DefaultTtlConfigurable Tests - Freeze Operations
+// ============================================
+
+#[test]
+fn test_default_ttl_configurable_freeze() {
+    let (_, _, client) = setup_contract();
+
+    assert!(!client.is_ttl_configs_frozen());
+    client.configurable_freeze_ttl_configs();
+    assert!(client.is_ttl_configs_frozen());
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1201)")]
+fn test_default_ttl_configurable_set_when_frozen() {
+    let (_, _, client) = setup_contract();
+
+    client.configurable_freeze_ttl_configs();
+
+    let instance_cfg = TtlConfig::new(1000, 2000);
+    client.configurable_set_ttl_configs(&Some(instance_cfg), &None);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1202)")]
+fn test_default_ttl_configurable_freeze_when_already_frozen() {
+    let (_, _, client) = setup_contract();
+
+    client.configurable_freeze_ttl_configs();
+    client.configurable_freeze_ttl_configs();
+}
+
+// ============================================
+// DefaultTtlConfigurable Tests - Validation
+// ============================================
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1200)")]
+fn test_default_ttl_configurable_invalid_instance_config() {
+    let (_, _, client) = setup_contract();
+    // threshold > extend_to is invalid
+    let invalid_cfg = TtlConfig::new(3000, 2000);
+    client.configurable_set_ttl_configs(&Some(invalid_cfg), &None);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1200)")]
+fn test_default_ttl_configurable_invalid_persistent_config() {
+    let (_, _, client) = setup_contract();
+    let invalid_cfg = TtlConfig::new(5000, 4000);
+    client.configurable_set_ttl_configs(&None, &Some(invalid_cfg));
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1200)")]
+fn test_default_ttl_configurable_exceeds_max_ttl() {
+    let (_, _, client) = setup_contract();
+    let invalid_cfg = TtlConfig::new(1000, MAX_TTL + 1);
+    client.configurable_set_ttl_configs(&Some(invalid_cfg), &None);
+}
+
+#[test]
+fn test_default_ttl_configurable_invalid_does_not_partially_update() {
+    let (_, _, client) = setup_contract();
+
+    // Seed with an initial valid state.
+    let before_instance = TtlConfig::new(1000, 2000);
+    let before_persistent = TtlConfig::new(3000, 4000);
+    client.configurable_set_ttl_configs(&Some(before_instance), &Some(before_persistent));
+    assert_eq!(client.configurable_ttl_configs(), (Some(before_instance), Some(before_persistent)));
+
+    // Attempt to update with one invalid config and one different valid config.
+    // This must fail and must not partially apply any changes.
+    let invalid_instance = TtlConfig::new(3000, 2000); // threshold > extend_to
+    let next_persistent = TtlConfig::new(3100, 4100);
+    assert_eq!(
+        client.try_configurable_set_ttl_configs(&Some(invalid_instance), &Some(next_persistent)).unwrap_err().unwrap(),
+        TtlError::InvalidTtlConfig.into()
+    );
+
+    // Ensure nothing changed.
+    assert_eq!(client.configurable_ttl_configs(), (Some(before_instance), Some(before_persistent)));
+}
+
+// ============================================
+// DefaultTtlConfigurable Tests - Boundary Values
+// ============================================
+
+#[test]
+fn test_default_ttl_configurable_at_max_ttl() {
+    let (env, _, client) = setup_contract();
+
+    // Get the effective max TTL
+    let effective_max = u32::min(MAX_TTL, env.storage().max_ttl());
+
+    // extend_to == effective_max should be valid
+    let valid_cfg = TtlConfig::new(1000, effective_max);
+    client.configurable_set_ttl_configs(&Some(valid_cfg), &None);
+
+    let (instance, _) = client.configurable_ttl_configs();
+    assert_eq!(instance, Some(valid_cfg));
+}
+
+#[test]
+fn test_default_ttl_configurable_boundary_values() {
+    let (env, _, client) = setup_contract();
+
+    let effective_max = u32::min(MAX_TTL, env.storage().max_ttl());
+
+    // Zero threshold and extend_to
+    let cfg = TtlConfig::new(0, 0);
+    client.configurable_set_ttl_configs(&Some(cfg), &None);
+    assert_eq!(client.configurable_ttl_configs().0, Some(cfg));
+
+    // Zero threshold, max extend_to
+    let cfg = TtlConfig::new(0, effective_max);
+    client.configurable_set_ttl_configs(&Some(cfg), &None);
+    assert_eq!(client.configurable_ttl_configs().0, Some(cfg));
+
+    // Equal threshold and extend_to
+    let cfg = TtlConfig::new(1000, 1000);
+    client.configurable_set_ttl_configs(&Some(cfg), &None);
+    assert_eq!(client.configurable_ttl_configs().0, Some(cfg));
+}

package/contracts/utils/src/ttl.rs

@@ -1,6 +1,5 @@
-use crate as utils;
 use crate::errors::TtlError;
-use soroban_sdk::{assert_with_error, contracttype, Env};
+use soroban_sdk::{assert_with_error, contractclient, contracttype, Env};
 
 /// Number of ledgers per day (~5 second ledger close time).
 pub const LEDGERS_PER_DAY: u32 = (24 * 3600) / 5;
@@ -16,8 +15,6 @@ pub const MAX_TTL: u32 = 365 * LEDGERS_PER_DAY;
 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);
-/// Default TTL for temporary storage (7 days, extends at 6 days remaining).
-pub const DEFAULT_TEMPORARY_TTL: TtlConfig = TtlConfig::new(6 * LEDGERS_PER_DAY, 7 * LEDGERS_PER_DAY);
 
 /// A pair of TTL values: threshold (when to trigger extension) and extend_to (target TTL).
 #[contracttype]
@@ -42,8 +39,12 @@ impl TtlConfig {
 }
 
 /// 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 TtlConfigData {
+pub enum TtlConfigStorage {
     #[instance(bool)]
     #[default(false)]
     Frozen,
@@ -53,111 +54,50 @@ pub enum TtlConfigData {
 
     #[instance(TtlConfig)]
     Persistent,
-
-    #[instance(TtlConfig)]
-    Temporary,
-}
-
-/// Trait for providing TTL configurations.
-pub trait TtlConfigProvider {
-    fn persistent(env: &Env) -> TtlConfig;
-    fn instance(env: &Env) -> TtlConfig;
-    fn temporary(env: &Env) -> TtlConfig;
-}
-
-/// Helper functions used by the `#[storage]` macro to enforce that a user-provided
-/// TTL config provider implements the [`TtlConfigProvider`] trait.
-///
-/// The macro generates code that calls these functions with the provider type as
-/// the generic parameter `T`. If the provider does not implement `TtlConfigProvider`,
-/// the compiler will emit an error at the macro expansion site, ensuring type safety
-/// at compile time.
-pub mod ttl_config {
-    use super::{TtlConfig, TtlConfigProvider};
-    use soroban_sdk::Env;
-
-    pub fn instance<T: TtlConfigProvider>(env: &Env) -> TtlConfig {
-        T::instance(env)
-    }
-
-    pub fn persistent<T: TtlConfigProvider>(env: &Env) -> TtlConfig {
-        T::persistent(env)
-    }
-
-    pub fn temporary<T: TtlConfigProvider>(env: &Env) -> TtlConfig {
-        T::temporary(env)
-    }
 }
 
-/// Default implementation using TtlConfigData storage.
-pub struct DefaultTtlConfigProvider;
+/// 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>);
 
-impl TtlConfigProvider for DefaultTtlConfigProvider {
-    fn instance(env: &Env) -> TtlConfig {
-        TtlConfigData::instance(env).unwrap_or(DEFAULT_INSTANCE_TTL)
-    }
+    /// Returns current TTL configs (instance, persistent).
+    fn ttl_configs(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>);
 
-    fn persistent(env: &Env) -> TtlConfig {
-        TtlConfigData::persistent(env).unwrap_or(DEFAULT_PERSISTENT_TTL)
-    }
+    /// Permanently freezes TTL configs, preventing further changes.
+    fn freeze_ttl_configs(env: &Env);
 
-    fn temporary(env: &Env) -> TtlConfig {
-        TtlConfigData::temporary(env).unwrap_or(DEFAULT_TEMPORARY_TTL)
-    }
-}
-
-/// Trait for contracts that allow TTL configuration management.
-pub trait TtlConfigurable {
-    /// Sets TTL configs. None values remove the config (use defaults).
-    fn set_ttl_config(
-        env: &Env,
-        instance: &Option<TtlConfig>,
-        persistent: &Option<TtlConfig>,
-        temporary: &Option<TtlConfig>,
-    );
-
-    /// Returns current TTL configs (instance, persistent, temporary).
-    fn ttl_config(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>, Option<TtlConfig>);
-
-    /// Permanently freezes TTL config, preventing further changes.
-    fn freeze_ttl_config(env: &Env);
-
-    /// Returns whether TTL config is frozen.
-    fn is_ttl_config_frozen(env: &Env) -> bool;
+    /// 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_config(
-        env: &Env,
-        instance: &Option<TtlConfig>,
-        persistent: &Option<TtlConfig>,
-        temporary: &Option<TtlConfig>,
-    ) {
-        assert_with_error!(env, !Self::is_ttl_config_frozen(env), TtlError::TtlConfigFrozen);
+    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, temporary].iter().all(|c| c.is_none_or(|cfg| cfg.is_valid(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);
 
-        TtlConfigData::set_or_remove_instance(env, instance);
-        TtlConfigData::set_or_remove_persistent(env, persistent);
-        TtlConfigData::set_or_remove_temporary(env, temporary);
+        TtlConfigStorage::set_or_remove_instance(env, instance);
+        TtlConfigStorage::set_or_remove_persistent(env, persistent);
     }
 
-    fn ttl_config(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>, Option<TtlConfig>) {
-        (TtlConfigData::instance(env), TtlConfigData::persistent(env), TtlConfigData::temporary(env))
+    fn ttl_configs(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>) {
+        (TtlConfigStorage::instance(env), TtlConfigStorage::persistent(env))
     }
 
-    fn freeze_ttl_config(env: &Env) {
-        assert_with_error!(env, !Self::is_ttl_config_frozen(env), TtlError::TtlConfigAlreadyFrozen);
-        TtlConfigData::set_frozen(env, &true);
+    fn freeze_ttl_configs(env: &Env) {
+        assert_with_error!(env, !Self::is_ttl_configs_frozen(env), TtlError::TtlConfigAlreadyFrozen);
+        TtlConfigStorage::set_frozen(env, &true);
     }
 
-    fn is_ttl_config_frozen(env: &Env) -> bool {
-        TtlConfigData::frozen(env)
+    fn is_ttl_configs_frozen(env: &Env) -> bool {
+        TtlConfigStorage::frozen(env)
     }
 }
 

package/contracts/workers/dvn/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "dvn"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[features]
+library = []
+testutils = []
+
+[lib]
+crate-type = ["cdylib"]
+doctest = false
+
+[dependencies]
+cfg-if = "1.0"
+soroban-sdk = { workspace = true, features = ["hazmat-crypto"] }
+worker = { workspace = true }
+message-lib-common = { workspace = true }
+utils = { workspace = true }
+common-macros = { workspace = true }
+endpoint-v2 = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+insta = { workspace = true }
+k256 = "0.13"
+sha3 = "0.10"
+rand = "0.8"
+ed25519-dalek = "2"

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

@@ -0,0 +1,66 @@
+use crate::TransactionAuthData;
+use soroban_sdk::{
+    address_payload::AddressPayload,
+    auth::{Context, CustomAccountInterface},
+};
+
+#[contractimpl]
+impl CustomAccountInterface for Dvn {
+    type Signature = TransactionAuthData;
+    type Error = DvnError;
+
+    #[allow(non_snake_case)]
+    fn __check_auth(
+        env: Env,
+        signature_payload: Hash<32>,
+        auth_data: Self::Signature,
+        auth_contexts: Vec<Context>,
+    ) -> Result<(), Self::Error> {
+        let TransactionAuthData { vid, expiration, signatures, admin, admin_signature } = auth_data;
+
+        verify_admin(&env, &admin, &admin_signature, &signature_payload)?;
+
+        let stored_vid = DvnStorage::vid(&env).unwrap();
+        if vid != stored_vid {
+            return Err(DvnError::InvalidVid);
+        }
+
+        if expiration <= env.ledger().timestamp() {
+            return Err(DvnError::AuthDataExpired);
+        }
+
+        let hash = hash_auth_data(&env, vid, expiration, &auth_contexts);
+
+        if DvnStorage::used_hash(&env, &hash) {
+            return Err(DvnError::HashAlreadyUsed);
+        }
+
+        Dvn::verify_signatures(&env, &hash, &signatures);
+
+        DvnStorage::set_used_hash(&env, &hash, &true);
+
+        Ok(())
+    }
+}
+
+fn verify_admin(
+    env: &Env,
+    admin: &BytesN<32>,
+    admin_signature: &BytesN<64>,
+    signature_payload: &Hash<32>,
+) -> Result<(), DvnError> {
+    let admin_address = Address::from_payload(env, AddressPayload::AccountIdPublicKeyEd25519(admin.clone()));
+    if !Dvn::is_admin(env, &admin_address) {
+        return Err(DvnError::OnlyAdmin);
+    }
+
+    env.crypto().ed25519_verify(admin, &signature_payload.clone().into(), admin_signature);
+
+    Ok(())
+}
+
+fn hash_auth_data(env: &Env, vid: u32, expiration: u64, auth_contexts: &Vec<Context>) -> BytesN<32> {
+    let mut writer = BufferWriter::new(env);
+    let data = writer.write_u32(vid).write_u64(expiration).write_bytes(&auth_contexts.to_xdr(env)).to_bytes();
+    env.crypto().keccak256(&data).into()
+}