diff --git a/sui_programmability/examples/utils/sources/epoch_time_lock.move b/sui_programmability/examples/utils/sources/epoch_time_lock.move index 532fc12c124d9..b6820e8b74210 100644 --- a/sui_programmability/examples/utils/sources/epoch_time_lock.move +++ b/sui_programmability/examples/utils/sources/epoch_time_lock.move @@ -17,14 +17,14 @@ module utils::epoch_time_lock { /// Create a new epoch time lock with `epoch`. Aborts if the current epoch is less than the input epoch. public fun new(epoch: u64, ctx: &TxContext) : EpochTimeLock { - assert!(tx_context::epoch(ctx) < epoch, EEpochAlreadyPassed); + assert!(ctx.epoch() < epoch, EEpochAlreadyPassed); EpochTimeLock { epoch } } /// Destroys an epoch time lock. Aborts if the current epoch is less than the locked epoch. public fun destroy(lock: EpochTimeLock, ctx: &TxContext) { let EpochTimeLock { epoch } = lock; - assert!(tx_context::epoch(ctx) >= epoch, EEpochNotYetEnded); + assert!(ctx.epoch() >= epoch, EEpochNotYetEnded); } /// Getter for the epoch number. diff --git a/sui_programmability/examples/utils/sources/immutable_external_resource.move b/sui_programmability/examples/utils/sources/immutable_external_resource.move index c9db4b37218d3..6853765d993d1 100644 --- a/sui_programmability/examples/utils/sources/immutable_external_resource.move +++ b/sui_programmability/examples/utils/sources/immutable_external_resource.move @@ -42,6 +42,6 @@ module utils::immutable_external_resource { /// Update the URL, but the digest of the resource must never change. public fun update(self: &mut ImmutableExternalResource, url: Url) { - sui::url::update(&mut self.url, inner_url(&url)) + self.url.update(url.inner_url()) } } diff --git a/sui_programmability/examples/utils/sources/locked_coin.move b/sui_programmability/examples/utils/sources/locked_coin.move index 852667a378206..4e72dc03543a5 100644 --- a/sui_programmability/examples/utils/sources/locked_coin.move +++ b/sui_programmability/examples/utils/sources/locked_coin.move @@ -2,7 +2,7 @@ // SPDX-License-Identifier: Apache-2.0 module utils::locked_coin { - use sui::balance::{Self, Balance}; + use sui::balance::Balance; use sui::coin::{Self, Coin}; use utils::epoch_time_lock::{Self, EpochTimeLock}; @@ -25,7 +25,7 @@ module utils::locked_coin { /// Public getter for the locked coin's value public fun value(self: &LockedCoin): u64 { - balance::value(&self.balance) + self.balance.value() } /// Lock a coin up until `locked_until_epoch`. The input Coin is deleted and a LockedCoin @@ -34,7 +34,7 @@ module utils::locked_coin { public entry fun lock_coin( coin: Coin, recipient: address, locked_until_epoch: u64, ctx: &mut TxContext ) { - let balance = coin::into_balance(coin); + let balance = coin.into_balance(); new_from_balance(balance, epoch_time_lock::new(locked_until_epoch, ctx), recipient, ctx); } @@ -43,9 +43,9 @@ module utils::locked_coin { /// to the sender. public entry fun unlock_coin(locked_coin: LockedCoin, ctx: &mut TxContext) { let LockedCoin { id, balance, locked_until_epoch } = locked_coin; - object::delete(id); - epoch_time_lock::destroy(locked_until_epoch, ctx); + id.delete(); + locked_until_epoch.destroy(ctx); let coin = coin::from_balance(balance, ctx); - transfer::public_transfer(coin, tx_context::sender(ctx)); + transfer::public_transfer(coin, ctx.sender()); } } diff --git a/sui_programmability/examples/utils/sources/safe.move b/sui_programmability/examples/utils/sources/safe.move index 3e18a281ccf24..12eed36871463 100644 --- a/sui_programmability/examples/utils/sources/safe.move +++ b/sui_programmability/examples/utils/sources/safe.move @@ -52,7 +52,7 @@ module utils::safe { // Check that the ids match assert!(object::id(safe) == capability.safe_id, EInvalidTransferCapability); // Check that it has not been cancelled - assert!(vec_set::contains(&safe.allowed_safes, &object::id(capability)), ETransferCapabilityRevoked); + assert!(safe.allowed_safes.contains(&object::id(capability)), ETransferCapabilityRevoked); } fun check_owner_capability_validity(safe: &Safe, capability: &OwnerCapability) { @@ -62,11 +62,11 @@ module utils::safe { /// Helper function to create a capability. fun create_capability_(safe: &mut Safe, withdraw_amount: u64, ctx: &mut TxContext): TransferCapability { let cap_id = object::new(ctx); - vec_set::insert(&mut safe.allowed_safes, object::uid_to_inner(&cap_id)); + safe.allowed_safes.insert(cap_id.uid_to_inner()); let capability = TransferCapability { id: cap_id, - safe_id: object::uid_to_inner(&safe.id), + safe_id: safe.id.uid_to_inner(), amount: withdraw_amount, }; @@ -98,7 +98,7 @@ module utils::safe { } public entry fun create(coin: Coin, ctx: &mut TxContext) { - let balance = coin::into_balance(coin); + let balance = coin.into_balance(); let cap = create_(balance, ctx); transfer::public_transfer(cap, ctx.sender()); } @@ -111,12 +111,12 @@ module utils::safe { /// Deposit funds to the safe public fun deposit_(safe: &mut Safe, balance: Balance) { - balance::join(&mut safe.balance, balance); + safe.balance.join(balance); } /// Deposit funds to the safe public entry fun deposit(safe: &mut Safe, coin: Coin) { - let balance = coin::into_balance(coin); + let balance = coin.into_balance(); deposit_(safe, balance); } @@ -124,7 +124,7 @@ module utils::safe { public fun withdraw_(safe: &mut Safe, capability: &OwnerCapability, withdraw_amount: u64): Balance { // Ensures that only the owner can withdraw from the safe. check_owner_capability_validity(safe, capability); - balance::split(&mut safe.balance, withdraw_amount) + safe.balance.split(withdraw_amount) } /// Withdraw coins from the safe as a `OwnerCapability` holder @@ -142,20 +142,20 @@ module utils::safe { // Withdraw funds assert!(capability.amount >= withdraw_amount, EOverdrawn); capability.amount = capability.amount - withdraw_amount; - balance::split(&mut safe.balance, withdraw_amount) + safe.balance.split(withdraw_amount) } /// Revoke a `TransferCapability` as an `OwnerCapability` holder public entry fun revoke_transfer_capability(safe: &mut Safe, capability: &OwnerCapability, capability_id: ID) { // Ensures that only the owner can withdraw from the safe. check_owner_capability_validity(safe, capability); - vec_set::remove(&mut safe.allowed_safes, &capability_id); + safe.allowed_safes.remove(&capability_id); } /// Revoke a `TransferCapability` as its owner public entry fun self_revoke_transfer_capability(safe: &mut Safe, capability: &TransferCapability) { check_capability_validity(safe, capability); - vec_set::remove(&mut safe.allowed_safes, &object::id(capability)); + safe.allowed_safes.remove(&object::id(capability)); } /// Create `TransferCapability` as an `OwnerCapability` holder diff --git a/sui_programmability/examples/utils/tests/immutable_external_resource_tests.move b/sui_programmability/examples/utils/tests/immutable_external_resource_tests.move index d7c543336368c..14c8246ac4a4d 100644 --- a/sui_programmability/examples/utils/tests/immutable_external_resource_tests.move +++ b/sui_programmability/examples/utils/tests/immutable_external_resource_tests.move @@ -22,13 +22,13 @@ module utils::immutable_external_resource_tests { let digest = sha3_256(hash); let mut resource = immutable_external_resource::new(url, digest); - assert!(immutable_external_resource::url(&resource) == url, EUrlStringMisMatch); - assert!(immutable_external_resource::digest(&resource) == digest, EHashStringMisMatch); + assert!(resource.url() == url, EUrlStringMisMatch); + assert!(resource.digest() == digest, EHashStringMisMatch); let new_url_str = ascii::string(x"37414243454647"); let new_url = url::new_unsafe(new_url_str); - immutable_external_resource::update(&mut resource, new_url); - assert!(immutable_external_resource::url(&resource) == new_url, EUrlStringMisMatch); + resource.update(new_url); + assert!(resource.url() == new_url, EUrlStringMisMatch); } } diff --git a/sui_programmability/examples/utils/tests/safe_tests.move b/sui_programmability/examples/utils/tests/safe_tests.move index b91cbc6cb41cb..399b24e294687 100644 --- a/sui_programmability/examples/utils/tests/safe_tests.move +++ b/sui_programmability/examples/utils/tests/safe_tests.move @@ -14,7 +14,7 @@ module utils::safe_tests { const TEST_DELEGATEE_ADDR: address = @0x1ce1ce1ce; fun create_safe(scenario: &mut Scenario, owner: address, stored_amount: u64) { - ts::next_tx(scenario, owner); + scenario.next_tx(owner); { let coin = coin::mint_for_testing(stored_amount, ctx(scenario)); safe::create(coin, ctx(scenario)); @@ -24,35 +24,35 @@ module utils::safe_tests { // Delegates the safe to delegatee and return the capability ID. fun delegate_safe(scenario: &mut Scenario, owner: address, delegate_to: address, delegate_amount: u64): ID { let id; - ts::next_tx(scenario, owner); - let mut safe = ts::take_shared>(scenario); - let cap = ts::take_from_sender>(scenario); - let capability = safe::create_transfer_capability(&mut safe, &cap, delegate_amount, ctx(scenario)); + scenario.next_tx(owner); + let mut safe = scenario.take_shared>(); + let cap = scenario.take_from_sender>(); + let capability = safe.create_transfer_capability(&cap, delegate_amount, ctx(scenario)); id = object::id(&capability); transfer::public_transfer(capability, delegate_to); - ts::return_to_sender(scenario, cap); + scenario.return_to_sender(cap); ts::return_shared(safe); id } fun withdraw_as_delegatee(scenario: &mut Scenario, delegatee: address, withdraw_amount: u64) { - ts::next_tx(scenario, delegatee); - let mut safe = ts::take_shared>(scenario); - let mut capability = ts::take_from_sender>(scenario); - let balance = safe::debit(&mut safe, &mut capability, withdraw_amount); + scenario.next_tx(delegatee); + let mut safe = scenario.take_shared>(); + let mut capability = scenario.take_from_sender>(); + let balance = safe.debit(&mut capability, withdraw_amount); test_utils::destroy(balance); - ts::return_to_sender(scenario, capability); + scenario.return_to_sender(capability); ts::return_shared(safe); } fun revoke_capability(scenario: &mut Scenario, owner: address, capability_id: ID) { - ts::next_tx(scenario, owner); - let mut safe = ts::take_shared>(scenario); - let cap = ts::take_from_sender>(scenario); - safe::revoke_transfer_capability(&mut safe, &cap, capability_id); + scenario.next_tx(owner); + let mut safe = scenario.take_shared>(); + let cap = scenario.take_from_sender>(); + safe.revoke_transfer_capability(&cap, capability_id); - ts::return_to_sender(scenario, cap); + scenario.return_to_sender(cap); ts::return_shared(safe); } @@ -60,27 +60,25 @@ module utils::safe_tests { /// Ensure that all funds can be withdrawn by the owners fun test_safe_create_and_withdraw_funds_as_owner() { let owner = TEST_OWNER_ADDR; - let mut scenario_val = ts::begin(TEST_SENDER_ADDR); - let scenario = &mut scenario_val; + let mut scenario = ts::begin(TEST_SENDER_ADDR); let initial_funds = 1000u64; create_safe(scenario, owner, initial_funds); - ts::next_tx(scenario, owner); - let mut safe = ts::take_shared>(scenario); - let cap = ts::take_from_sender>(scenario); + scenario.next_tx(owner); + let mut safe = scenario.take_shared>(); + let cap = scenario.take_from_sender>(); - safe::withdraw(&mut safe, &cap, initial_funds, ts::ctx(scenario)); - ts::next_tx(scenario, owner); - let withdrawn_coin = ts::take_from_sender>(scenario); - assert!(coin::value(&withdrawn_coin) == initial_funds, 0); + safe.withdraw(&cap, initial_funds, ts::ctx(scenario)); + scenario.next_tx(owner); + let withdrawn_coin = scenario.take_from_sender>(); + assert!(withdrawn_coin.value() == initial_funds, 0); test_utils::destroy(withdrawn_coin); - ts::return_to_sender(scenario, cap); + scenario.return_to_sender(cap); ts::return_shared(safe); - - ts::end(scenario_val); + scenario.end(); } #[test] @@ -88,8 +86,7 @@ module utils::safe_tests { fun test_safe_create_and_withdraw_funds_as_delegatee() { let owner = TEST_OWNER_ADDR; let delegatee = TEST_DELEGATEE_ADDR; - let mut scenario_val = ts::begin(TEST_SENDER_ADDR); - let scenario = &mut scenario_val; + let mut scenario = ts::begin(TEST_SENDER_ADDR); let initial_funds = 1000u64; let delegated_funds = 1000u64; @@ -97,7 +94,8 @@ module utils::safe_tests { create_safe(scenario, owner, initial_funds); delegate_safe(scenario, owner, delegatee, delegated_funds); withdraw_as_delegatee(scenario, delegatee, delegated_funds); - ts::end(scenario_val); + + scenario.end(); } #[test] @@ -106,8 +104,7 @@ module utils::safe_tests { fun test_safe_attempt_to_over_withdraw() { let owner = TEST_OWNER_ADDR; let delegatee = TEST_DELEGATEE_ADDR; - let mut scenario_val = ts::begin(TEST_SENDER_ADDR); - let scenario = &mut scenario_val; + let mut scenario = ts::begin(TEST_SENDER_ADDR); let initial_funds = 1000u64; let delegated_funds = 1000u64; @@ -120,7 +117,7 @@ module utils::safe_tests { // Attempt to withdraw by 1 coin. withdraw_as_delegatee(scenario, delegatee, 1); - ts::end(scenario_val); + scenario.end(); } #[test] @@ -129,8 +126,7 @@ module utils::safe_tests { fun test_safe_withdraw_revoked() { let owner = TEST_OWNER_ADDR; let delegatee = TEST_DELEGATEE_ADDR; - let mut scenario_val = ts::begin(TEST_SENDER_ADDR); - let scenario = &mut scenario_val; + let mut scenario = ts::begin(TEST_SENDER_ADDR); let initial_funds = 1000u64; let delegated_funds = 1000u64; @@ -143,7 +139,7 @@ module utils::safe_tests { // Withdraw funds withdraw_as_delegatee(scenario, delegatee, delegated_funds); - ts::end(scenario_val); + scenario.end(); } #[test] @@ -151,29 +147,28 @@ module utils::safe_tests { /// Ensure owner cannot withdraw funds after revoking itself. fun test_safe_withdraw_self_revoked() { let owner = TEST_OWNER_ADDR; - let mut scenario_val = ts::begin(owner); - let scenario = &mut scenario_val; + let mut scenario = ts::begin(owner); let initial_funds = 1000u64; create_safe(scenario, owner, initial_funds); - ts::next_tx(scenario, owner); - let cap = ts::take_from_sender>(scenario); - let mut safe = ts::take_shared>(scenario); - let mut transfer_capability = safe::create_transfer_capability(&mut safe, &cap, initial_funds, ctx(scenario)); + scenario.next_tx(owner); + let cap = scenario.take_from_sender>(); + let mut safe = scenario.take_shared>(); + let mut transfer_capability = safe.create_transfer_capability(&cap, initial_funds, ctx(scenario)); // Function under test - safe::self_revoke_transfer_capability(&mut safe, &transfer_capability); + safe.self_revoke_transfer_capability(&transfer_capability); ts::return_shared(safe); // Try withdraw funds with transfer capability. - ts::next_tx(scenario, owner); - let mut safe = ts::take_shared>(scenario); - let balance = safe::debit(&mut safe, &mut transfer_capability, 1000u64); + scenario.next_tx(owner); + let mut safe = scenario.take_shared>(); + let balance = safe.debit(&mut transfer_capability, 1000u64); test_utils::destroy(balance); ts::return_shared(safe); - ts::return_to_sender(scenario, cap); - ts::return_to_sender(scenario, transfer_capability); - ts::end(scenario_val); + scenario.return_to_sender(cap); + scenario.return_to_sender(transfer_capability); + scenario.end(); } }