@layerzerolabs/protocol-stellar-v2 0.2.18 → 0.2.19

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

@@ -2,7 +2,10 @@ use crate::{
     auth::Auth,
     errors::OwnableError,
     option_ext::OptionExt,
-    ownable::{self, Ownable, OwnableInitializer, OwnableStorage, OwnershipRenounced, OwnershipTransferred},
+    ownable::{
+        self, Ownable, OwnableInitializer, OwnableStorage, OwnershipRenounced, OwnershipTransferred,
+        OwnershipTransferring,
+    },
     testing_utils::assert_event,
 };
 use soroban_sdk::{
@@ -87,7 +90,7 @@ fn auth_non_owner_cannot_call() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn auth_require_owner_when_no_owner_set() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -109,7 +112,7 @@ fn auth_require_owner_when_no_owner_set() {
 }
 
 // ============================================
-// transfer: Transfer ownership tests
+// transfer: Single-step transfer ownership tests
 // ============================================
 
 #[test]
@@ -165,7 +168,7 @@ fn transfer_ownership_to_same_owner() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn transfer_after_renounce_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -199,6 +202,343 @@ fn transfer_after_renounce_fails() {
     client.transfer_ownership(&new_owner);
 }
 
+#[test]
+#[should_panic(expected = "Error(Contract, #1035)")] // TransferInProgress
+fn transfer_ownership_blocked_during_2step() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    let another_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate 2-step transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    // Try single-step transfer - should fail
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&another_owner,).into_val(&env),
+            fn_name: "transfer_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.transfer_ownership(&another_owner);
+}
+
+// ============================================
+// transfer_2step: Two-step transfer ownership tests
+// ============================================
+
+#[test]
+fn propose_ownership_transfer_initiate_and_accept() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    assert_eq!(client.owner(), Some(owner.clone()));
+    assert_eq!(client.pending_owner(), None);
+
+    // Step 1: Initiate transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    assert_event(
+        &env,
+        &contract,
+        OwnershipTransferring { old_owner: owner.clone(), new_owner: new_owner.clone(), ttl },
+    );
+    assert_eq!(client.owner(), Some(owner.clone())); // Still old owner
+    assert_eq!(client.pending_owner(), Some(new_owner.clone()));
+
+    // Step 2: Accept transfer
+    env.mock_auths(&[MockAuth {
+        address: &new_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+
+    assert_event(&env, &contract, OwnershipTransferred { old_owner: owner, new_owner: new_owner.clone() });
+    assert_eq!(client.owner(), Some(new_owner)); // Now new owner
+    assert_eq!(client.pending_owner(), None);
+}
+
+#[test]
+fn propose_ownership_transfer_cancel() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    assert_eq!(client.pending_owner(), Some(new_owner.clone()));
+
+    // Cancel transfer (ttl = 0)
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, 0u32).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &0u32);
+
+    // No event emitted on cancel (matching OpenZeppelin behavior)
+    assert_eq!(client.owner(), Some(owner)); // Still old owner
+    assert_eq!(client.pending_owner(), None);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1032)")] // NoPendingTransfer
+fn propose_ownership_transfer_cancel_no_pending_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    // Try to cancel when no transfer is pending
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, 0u32).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &0u32);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1030)")] // InvalidPendingOwner
+fn propose_ownership_transfer_cancel_wrong_address_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    let wrong_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    // Try to cancel with wrong address
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&wrong_owner, 0u32).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&wrong_owner, &0u32);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1031)")] // InvalidTtl
+fn propose_ownership_transfer_invalid_ttl_exceeds_max_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    // TTL that would exceed max_live_until_ledger
+    let ttl = u32::MAX;
+
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1032)")] // NoPendingTransfer
+fn accept_ownership_no_pending_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    // Try to accept when no transfer is pending
+    env.mock_auths(&[MockAuth {
+        address: &new_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn accept_ownership_wrong_address_fails() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    let wrong_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    // Try to accept with wrong address
+    env.mock_auths(&[MockAuth {
+        address: &wrong_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+}
+
+#[test]
+fn propose_ownership_transfer_override_pending() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner1 = Address::generate(&env);
+    let new_owner2 = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate first transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner1, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner1, &ttl);
+
+    assert_eq!(client.pending_owner(), Some(new_owner1.clone()));
+
+    // Override with second transfer (allowed - replaces pending)
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner2, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner2, &ttl);
+
+    assert_eq!(client.pending_owner(), Some(new_owner2.clone()));
+
+    // new_owner2 can accept
+    env.mock_auths(&[MockAuth {
+        address: &new_owner2,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+
+    assert_eq!(client.owner(), Some(new_owner2));
+}
+
 // ============================================
 // renounce: Renounce ownership tests
 // ============================================
@@ -229,7 +569,7 @@ fn renounce_ownership_with_event() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn renounce_after_renounce_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -262,6 +602,43 @@ fn renounce_after_renounce_fails() {
     client.renounce_ownership();
 }
 
+#[test]
+#[should_panic(expected = "Error(Contract, #1035)")] // TransferInProgress
+fn renounce_blocked_during_2step_transfer() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // Initiate 2-step transfer
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    // Try to renounce - should fail
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "renounce_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.renounce_ownership();
+}
+
 // ============================================
 // chain: Ownership chain tests
 // ============================================
@@ -303,12 +680,73 @@ fn chain_new_owner_can_transfer() {
     assert_eq!(client.owner(), Some(third_owner));
 }
 
+#[test]
+fn chain_new_owner_can_transfer_2step() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    let third_owner = Address::generate(&env);
+
+    let contract = env.register(Contract, (&owner,));
+    let client = ContractClient::new(&env, &contract);
+
+    let ttl = 1000u32;
+
+    // 2-step transfer to new_owner
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&new_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&new_owner, &ttl);
+
+    env.mock_auths(&[MockAuth {
+        address: &new_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+
+    // new_owner can now do another 2-step transfer
+    env.mock_auths(&[MockAuth {
+        address: &new_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: (&third_owner, ttl).into_val(&env),
+            fn_name: "propose_ownership_transfer",
+            sub_invokes: &[],
+        },
+    }]);
+    client.propose_ownership_transfer(&third_owner, &ttl);
+
+    env.mock_auths(&[MockAuth {
+        address: &third_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract,
+            args: ().into_val(&env),
+            fn_name: "accept_ownership",
+            sub_invokes: &[],
+        },
+    }]);
+    client.accept_ownership();
+
+    assert_eq!(client.owner(), Some(third_owner));
+}
+
 // ============================================
 // init: DefaultOwnable::init_owner tests
 // ============================================
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1030)")] // OwnerAlreadySet
+#[should_panic(expected = "Error(Contract, #1033)")] // OwnerAlreadySet
 fn reinit_owner_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -345,7 +783,7 @@ fn enforce_owner_auth_returns_owner() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn enforce_owner_auth_no_owner_set_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);

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

@@ -423,7 +423,7 @@ fn test_default_ttl_configurable_freeze_wrong_signer_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn test_default_ttl_configurable_freeze_when_owner_not_set() {
     let env = Env::default();
     let contract_id = env.register(TtlTestContract, ());
@@ -529,7 +529,7 @@ fn test_default_ttl_configurable_set_wrong_signer_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
+#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn test_default_ttl_configurable_set_when_owner_not_set() {
     let env = Env::default();
     let contract_id = env.register(TtlTestContract, ());

package/package.json

@@ -1,24 +1,23 @@
 {
   "name": "@layerzerolabs/protocol-stellar-v2",
-  "version": "0.2.18",
+  "version": "0.2.19",
   "private": false,
   "devDependencies": {
     "@types/node": "^22.18.6",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",
-    "@layerzerolabs/common-node-utils": "0.2.18",
-    "@layerzerolabs/vm-tooling-stellar": "0.2.18"
+    "@layerzerolabs/common-node-utils": "0.2.19",
+    "@layerzerolabs/vm-tooling-stellar": "0.2.19"
   },
   "publishConfig": {
     "access": "restricted",
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "pnpm build:contracts:sandbox && pnpm generate:sdk && pnpm build:wasm",
+    "build": "pnpm build:contracts:sandbox && pnpm generate:sdk",
     "build:contracts:mainnet": "pnpm exec lz-tool stellar contract build --features mainnet",
     "build:contracts:sandbox": "pnpm exec lz-tool stellar contract build --features sandbox",
     "build:contracts:testnet": "pnpm exec lz-tool stellar contract build --features testnet",
-    "build:wasm": "lz-tool extra stellar build-typescript-sdk target sdk/src",
     "format": "pnpm exec lz-tool --script \"cargo fmt\" stellar",
     "generate:sdk": "pnpm exec lz-tool --script \"cargo run -p ts-bindings-gen\" stellar",
     "lint": "pnpm exec lz-tool --script \"cargo clippy -- -D warnings\" stellar",