Merge branch 'develop' into remove-coin-metadata

Author: FelixFan1992

bindings/generated/ccip/ccip_token_pools/token_pool/token_pool.go

@@ -55,6 +55,6 @@ dependencies = [
 ]
 
 [move.toolchain-version]
-compiler-version = "1.57.2"
+compiler-version = "1.58.1"
 edition = "2024"
 flavor = "sui"

contracts/ccip/ccip/Move.lock

@@ -90,7 +90,7 @@ public struct Any2SuiMessage {
 
 public struct Any2SuiTokenAmount has copy, drop, store {
     token: address,
-    amount: u64,
+    amount: u256,
 }
 
 public(package) fun new_any2sui_message(
@@ -128,7 +128,7 @@ public(package) fun consume_any2sui_message(
 
 public fun new_dest_token_amounts(
     token_addresses: vector<address>,
-    token_amounts: vector<u64>,
+    token_amounts: vector<u256>,
 ): vector<Any2SuiTokenAmount> {
     token_addresses.zip_map_ref!(&token_amounts, |token_address, token_amount| {
         Any2SuiTokenAmount { token: *token_address, amount: *token_amount }
@@ -139,10 +139,10 @@ public fun get_token(input: &Any2SuiTokenAmount): address {
     input.token
 }
 
-public fun get_amount(input: &Any2SuiTokenAmount): u64 {
+public fun get_amount(input: &Any2SuiTokenAmount): u256 {
     input.amount
 }
 
-public fun get_token_and_amount(input: &Any2SuiTokenAmount): (address, u64) {
+public fun get_token_and_amount(input: &Any2SuiTokenAmount): (address, u256) {
     (input.token, input.amount)
 }

contracts/ccip/ccip/sources/client.move

@@ -43,7 +43,7 @@ public struct DestTokenTransfer has copy, drop {
     token_receiver: address,
     remote_chain_selector: u64,
     // the amount of token to transfer, denoted from the source chain
-    source_amount: u64,
+    source_amount: u256,
     // the token's coin metadata object id on SUI
     dest_token_address: address,
     // the destination token pool package id on SUI
@@ -82,7 +82,7 @@ public fun add_dest_token_transfer(
     receiver_params: &mut ReceiverParams,
     token_receiver: address,
     remote_chain_selector: u64,
-    source_amount: u64,
+    source_amount: u256,
     dest_token_address: address,
     dest_token_pool_package_id: address,
     source_pool_address: vector<u8>,
@@ -117,31 +117,9 @@ public fun populate_message(
     receiver_params.message.fill(any2sui_message);
 }
 
-public fun create_dest_token_transfer(
-    token_receiver: address,
-    remote_chain_selector: u64,
-    source_amount: u64,
-    dest_token_address: address,
-    dest_token_pool_package_id: address,
-    source_pool_address: vector<u8>,
-    source_pool_data: vector<u8>,
-    offchain_token_data: vector<u8>,
-): DestTokenTransfer {
-    DestTokenTransfer {
-        token_receiver,
-        remote_chain_selector,
-        source_amount,
-        dest_token_address,
-        dest_token_pool_package_id,
-        source_pool_address,
-        source_pool_data,
-        offchain_token_data,
-    }
-}
-
 public fun get_dest_token_transfer_data(
     receiver_params: &ReceiverParams,
-): (address, u64, u64, address, address, vector<u8>, vector<u8>, vector<u8>) {
+): (address, u64, u256, address, address, vector<u8>, vector<u8>, vector<u8>) {
     assert!(receiver_params.token_transfer.is_some(), ETokenTransferDoesNotExist);
 
     let token_transfer = receiver_params.token_transfer.borrow();
@@ -159,7 +137,7 @@ public fun get_dest_token_transfer_data(
 
 public fun get_token_param_data(
     receiver_params: &ReceiverParams,
-): (address, u64, address, vector<u8>, vector<u8>, vector<u8>) {
+): (address, u256, address, vector<u8>, vector<u8>, vector<u8>) {
     assert!(receiver_params.token_transfer.is_some(), ETokenTransferDoesNotExist);
     let token_param = receiver_params.token_transfer.borrow();
 

contracts/ccip/ccip/sources/offramp_state_helper.move

@@ -7,6 +7,7 @@ use std::type_name;
 const ETypeProofMismatch: u64 = 1;
 const ETokenTransferAlreadyExists: u64 = 2;
 const ETokenTransferDoesNotExist: u64 = 3;
+const EInvalidTokenReceiver: u64 = 4;
 
 public struct ONRAMP_STATE_HELPER has drop {}
 
@@ -17,10 +18,10 @@ public struct SourceTransferCap has key, store {
 
 public struct TokenTransferParams {
     token_transfer: Option<TokenTransferMetadata>,
-    token_receiver: address,
+    token_receiver: vector<u8>,
 }
 
-public fun get_token_receiver(params: &TokenTransferParams): address {
+public fun get_token_receiver(params: &TokenTransferParams): vector<u8> {
     params.token_receiver
 }
 
@@ -41,7 +42,8 @@ fun init(_witness: ONRAMP_STATE_HELPER, ctx: &mut TxContext) {
     transfer::transfer(source_cap, ctx.sender());
 }
 
-public fun create_token_transfer_params(token_receiver: address): TokenTransferParams {
+public fun create_token_transfer_params(token_receiver: vector<u8>): TokenTransferParams {
+    assert!(token_receiver.length() == 32, EInvalidTokenReceiver);
     TokenTransferParams {
         token_transfer: option::none(),
         token_receiver,

contracts/ccip/ccip/sources/onramp_state_helper.move

@@ -321,7 +321,7 @@ fun test_new_any2sui_message() {
 #[test]
 fun test_new_dest_token_amounts() {
     let token_addresses = vector[@0x1, @0x2, @0x3];
-    let token_amounts = vector[100u64, 200u64, 300u64];
+    let token_amounts = vector[100u256, 200u256, 300u256];
 
     let dest_token_amounts = client::new_dest_token_amounts(token_addresses, token_amounts);
 
@@ -331,17 +331,17 @@ fun test_new_dest_token_amounts() {
     // Verify the first token amount
     let first_amount = &dest_token_amounts[0];
     assert!(client::get_token(first_amount) == @0x1, 1);
-    assert!(client::get_amount(first_amount) == 100u64, 2);
+    assert!(client::get_amount(first_amount) == 100u256, 2);
 
     // Verify the second token amount
     let second_amount = &dest_token_amounts[1];
     assert!(client::get_token(second_amount) == @0x2, 3);
-    assert!(client::get_amount(second_amount) == 200u64, 4);
+    assert!(client::get_amount(second_amount) == 200u256, 4);
 
     // Verify the third token amount
     let third_amount = &dest_token_amounts[2];
     assert!(client::get_token(third_amount) == @0x3, 5);
-    assert!(client::get_amount(third_amount) == 300u64, 6);
+    assert!(client::get_amount(third_amount) == 300u256, 6);
 }
 
 #[test]
@@ -391,7 +391,7 @@ fun test_message_with_token_amounts() {
     // Create some token amounts
     let token_receiver = @0x12345;
     let token_addresses = vector[@0xa, @0xb];
-    let token_amounts = vector[1000u64, 2000u64];
+    let token_amounts = vector[1000u256, 2000u256];
     let dest_token_amounts = client::new_dest_token_amounts(token_addresses, token_amounts);
 
     let message = client::new_any2sui_message(
@@ -420,7 +420,7 @@ fun test_message_with_token_amounts() {
     assert!(returned_token_receiver == token_receiver, 4);
     assert!(returned_dest_token_amounts.length() == 2, 5);
     assert!(client::get_token(&returned_dest_token_amounts[0]) == @0xa, 6);
-    assert!(client::get_amount(&returned_dest_token_amounts[0]) == 1000u64, 7);
+    assert!(client::get_amount(&returned_dest_token_amounts[0]) == 1000u256, 7);
     assert!(client::get_token(&returned_dest_token_amounts[1]) == @0xb, 8);
-    assert!(client::get_amount(&returned_dest_token_amounts[1]) == 2000u64, 9);
+    assert!(client::get_amount(&returned_dest_token_amounts[1]) == 2000u256, 9);
 }

contracts/ccip/ccip/tests/client_tests.move

@@ -7,6 +7,7 @@ use ccip::state_object::{Self, CCIPObjectRef};
 use ccip::token_admin_registry as registry;
 use ccip::upgrade_registry;
 use std::ascii;
+use std::bcs;
 use std::string;
 use std::type_name;
 use sui::test_scenario::{Self as ts, Scenario};
@@ -83,7 +84,9 @@ public fun test_create_token_transfer_params() {
     );
 
     // Test creating token transfer params with valid data
-    let mut token_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
         &ref,
         &mut token_params,
@@ -139,7 +142,9 @@ public fun test_create_token_transfer_params_basic() {
 
     // Try to create token transfer params - this test now just creates empty params
     // since type proof validation was removed from the helper
-    let mut token_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
         &ref,
         &mut token_params,
@@ -175,7 +180,9 @@ public fun test_get_remote_chain_selector() {
     );
 
     // Test creating token transfer params with different chain selectors
-    let mut token_params1 = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params1 = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
         &ref,
         &mut token_params1,
@@ -188,7 +195,9 @@ public fun test_get_remote_chain_selector() {
     );
 
     let different_chain = 2000;
-    let mut token_params2 = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params2 = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
         &ref,
         &mut token_params2,
@@ -238,7 +247,9 @@ public fun test_create_and_verify_token_transfer() {
     );
 
     // Create source token transfer
-    let mut token_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
         &ref,
         &mut token_params,
@@ -278,7 +289,7 @@ public fun test_deconstruct_empty_params_vector() {
     let (scenario, owner_cap, ref, source_cap) = setup_test();
 
     // Create empty params and test deconstruct
-    let empty_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let empty_params = onramp_state_helper::create_token_transfer_params(bcs::to_bytes(&@0x456));
 
     // Deconstruct should work with empty params
     onramp_state_helper::deconstruct_token_params(&source_cap, empty_params);
@@ -307,7 +318,9 @@ public fun test_add_multiple_token_transfers_should_fail() {
     );
 
     // Create token transfer params
-    let mut token_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
 
     // Add first token transfer
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
@@ -344,7 +357,7 @@ public fun test_get_token_transfer_data_when_empty() {
     let (scenario, owner_cap, ref, source_cap) = setup_test();
 
     // Create empty token transfer params (no token transfer added)
-    let token_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let token_params = onramp_state_helper::create_token_transfer_params(bcs::to_bytes(&@0x456));
 
     // This should fail with ETokenTransferDoesNotExist because no token transfer was added
     let (
@@ -381,7 +394,9 @@ public fun test_get_source_token_transfer_data() {
     );
 
     // Create token transfer with specific data
-    let mut token_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
         &ref,
         &mut token_params,
@@ -437,7 +452,9 @@ public fun test_edge_case_large_amounts() {
 
     // Test with maximum u64 value
     let max_amount = 18446744073709551615; // u64::MAX
-    let mut token_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
         &ref,
         &mut token_params,
@@ -481,7 +498,9 @@ public fun test_edge_case_empty_data() {
     );
 
     // Test with empty destination address and extra data
-    let mut token_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
         &ref,
         &mut token_params,
@@ -531,7 +550,9 @@ public fun test_zero_amount_transfer() {
     );
 
     // Test with zero amount - should be allowed
-    let mut token_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
         &ref,
         &mut token_params,
@@ -575,7 +596,9 @@ public fun test_source_transfer_cap_permission() {
     );
 
     // Create a source token transfer
-    let mut token_params = onramp_state_helper::create_token_transfer_params(@0x456);
+    let mut token_params = onramp_state_helper::create_token_transfer_params(
+        bcs::to_bytes(&@0x456),
+    );
     onramp_state_helper::add_token_transfer_param<TestTypeProof>(
         &ref,
         &mut token_params,

contracts/ccip/ccip/tests/onramp_state_helper_tests.move

@@ -21,7 +21,6 @@ use mcms::mcms_registry::{Self, Registry, ExecutingCallbackParams};
 use std::ascii;
 use std::string::{Self, String};
 use std::type_name;
-use std::u256;
 use sui::address;
 use sui::clock;
 use sui::derived_object;
@@ -220,18 +219,18 @@ const ECursedByRmn: u64 = 16;
 const ESignatureVerificationRequiredInCommitPlugin: u64 = 17;
 const ESignatureVerificationNotAllowedInExecutionPlugin: u64 = 18;
 const EFeeQuoterCapExists: u64 = 19;
-const ETokenAmountOverflow: u64 = 20;
-const EDestTransferCapExists: u64 = 21;
-const ERmnBlessingMismatch: u64 = 22;
-const EUnsupportedToken: u64 = 23;
-const EInvalidOnRampUpdate: u64 = 24;
-const EDestTransferCapNotSet: u64 = 25;
-const ECalculateMessageHashInvalidArguments: u64 = 26;
-const EInvalidFunction: u64 = 27;
-const EInvalidTokenReceiver: u64 = 28;
-const ETokenTransferLimitExceeded: u64 = 29;
-const EPackageIdNotFound: u64 = 30;
-const EInvalidOwnerCap: u64 = 31;
+const EDestTransferCapExists: u64 = 20;
+const ERmnBlessingMismatch: u64 = 21;
+const EUnsupportedToken: u64 = 22;
+const EInvalidOnRampUpdate: u64 = 23;
+const EDestTransferCapNotSet: u64 = 24;
+const ECalculateMessageHashInvalidArguments: u64 = 25;
+const EInvalidFunction: u64 = 26;
+const EInvalidTokenReceiver: u64 = 27;
+const ETokenTransferLimitExceeded: u64 = 28;
+const EPackageIdNotFound: u64 = 29;
+const EInvalidOwnerCap: u64 = 30;
+const EUnknownSequenceNumber: u64 = 31;
 
 const VERSION: u8 = 1;
 
@@ -491,6 +490,7 @@ public fun get_execution_state(
 ): u8 {
     assert!(state.execution_states.contains(source_chain_selector), EUnknownSourceChainSelector);
     let source_chain_execution_states = state.execution_states.borrow(source_chain_selector);
+    assert!(source_chain_execution_states.contains(sequence_number), EUnknownSequenceNumber);
     let execution_state = source_chain_execution_states.borrow(sequence_number);
     *execution_state
 }
@@ -652,24 +652,21 @@ fun pre_execute_single_report(
             message.token_amounts[0].dest_token_address,
         );
         assert!(token_pool_address != @0x0, EUnsupportedToken);
-        let mut amount_op = u256::try_as_u64(message.token_amounts[0].amount);
-        assert!(amount_op.is_some(), ETokenAmountOverflow);
-        let amount = amount_op.extract();
 
         osh::add_dest_token_transfer(
             state.dest_transfer_cap.borrow(),
             &mut receiver_params,
             message.token_receiver, // when sending tokens, token receiver will be included in the execution report
             source_chain_selector,
-            amount,
+            message.token_amounts[0].amount,
             message.token_amounts[0].dest_token_address,
             token_pool_address,
             message.token_amounts[0].source_pool_address,
             message.token_amounts[0].extra_data,
             execution_report.offchain_token_data[0],
         );
         token_addresses.push_back(message.token_amounts[0].dest_token_address);
-        token_amounts.push_back(amount);
+        token_amounts.push_back(message.token_amounts[0].amount);
     };
 
     let has_valid_message_receiver =