refactor(move): 2024 syntax update (#47)

* refactor(SUI): 2024 syntax update * refactor(SUI): 2024 borrow syntax update --------- Co-authored-by: Milap Sheth <[email protected]>
axelarnetwork · Jun 4, 2024 · c5cc91d · c5cc91d
1 parent 0f44465
commit c5cc91d
Show file tree

Hide file tree

Showing 12 changed files with 41 additions and 41 deletions.
diff --git a/move/abi/sources/abi.move b/move/abi/sources/abi.move
@@ -153,7 +153,7 @@ module abi::abi {
         while (i < 32) {
             let exp = ((31 - i) * 8 as u8);
             let byte = (var >> exp & 255 as u8);
-            *self.bytes.borrow_mut(i + pos) = byte;
+            *&mut self.bytes[i + pos] = byte;
             i = i + 1;
         };
 

diff --git a/move/axelar_gateway/sources/discovery.move b/move/axelar_gateway/sources/discovery.move
@@ -96,7 +96,7 @@ module axelar_gateway::discovery {
         channel_id: ID,
     ): Transaction {
         assert!(self.configurations.contains(channel_id), EChannelNotFound);
-        *self.configurations.borrow(channel_id)
+        self.configurations[channel_id]
     }
 
     // === Tx Building ===

diff --git a/move/its/sources/address_tracker.move b/move/its/sources/address_tracker.move
@@ -18,7 +18,7 @@ module its::address_tracker {
         self: &InterchainAddressTracker, chain_name: String
     ): &String {
         assert!(self.trusted_addresses.contains(chain_name), ENoAddress);
-        self.trusted_addresses.borrow(chain_name)
+        &self.trusted_addresses[chain_name]
     }
 
     /// Check if the given address is trusted for the given chain.
@@ -46,7 +46,7 @@ module its::address_tracker {
             if (trusted_address.length() == 0) {
                 self.trusted_addresses.remove(chain_name);
             } else {
-                *self.trusted_addresses.borrow_mut(chain_name) = trusted_address;
+                *&mut self.trusted_addresses[chain_name] = trusted_address;
             }
         } else {
             if (trusted_address.length() > 0) {

diff --git a/move/its/sources/discovery.move b/move/its/sources/discovery.move
@@ -42,7 +42,7 @@ module its::discovery {
     public fun register_transaction(self: &mut ITS, discovery: &mut RelayerDiscovery) {
         self.set_relayer_discovery_id(discovery);
         let mut arg = vector[0];
-        vector::append(&mut arg, bcs::to_bytes(&object::id(self)));
+        arg.append(bcs::to_bytes(&object::id(self)));
 
         let arguments = vector[
             arg,
@@ -88,7 +88,7 @@ module its::discovery {
 
         if (data.is_empty()) {
             let mut arg = vector[0];
-            vector::append(&mut arg, address::to_bytes(object::id_address(self)));
+            arg.append(address::to_bytes(object::id_address(self)));
 
             let type_name = self.get_registered_coin_type(token_id);
 
@@ -112,10 +112,10 @@ module its::discovery {
             )
         } else {
             let mut discovery_arg = vector[0];
-            vector::append(&mut discovery_arg, self.relayer_discovery_id().id_to_address().to_bytes());
+            discovery_arg.append(self.relayer_discovery_id().id_to_address().to_bytes());
 
             let mut channel_id_arg = vector[1];
-            vector::append(&mut channel_id_arg, destination_address.to_bytes());
+            channel_id_arg.append(destination_address.to_bytes());
 
             discovery::new_transaction(
                 false,
@@ -137,7 +137,7 @@ module its::discovery {
 
     fun get_deploy_interchain_token_tx(self: &ITS, reader: &mut AbiReader): Transaction {
         let mut arg = vector[0];
-        vector::append(&mut arg, address::to_bytes(object::id_address(self)));
+        arg.append(address::to_bytes(object::id_address(self)));
 
         let arguments = vector[
             arg,
@@ -171,7 +171,7 @@ module its::discovery {
     #[test_only]
     fun get_initial_tx(self: &ITS): Transaction {
         let mut arg = vector[0];
-        vector::append(&mut arg, bcs::to_bytes(&object::id(self)));
+        arg.append(bcs::to_bytes(&object::id(self)));
 
         let arguments = vector[
             arg,
@@ -244,13 +244,13 @@ module its::discovery {
         assert!(tx_block == get_interchain_transfer_tx(&its, &mut reader), 1);
         assert!(tx_block.is_final() && tx_block.move_calls().length() == 1, 2);
 
-        let call_info = vector::pop_back(&mut tx_block.move_calls());
+        let call_info = tx_block.move_calls().pop_back();
 
         assert!(call_info.function().package_id_from_function() == package_id<ITS>(), 3);
         assert!(call_info.function().module_name() == ascii::string(b"service"), 4);
         assert!(call_info.function().name() == ascii::string(b"receive_interchain_transfer"), 5);
         let mut arg = vector[0];
-        vector::append(&mut arg, address::to_bytes(object::id_address(&its)));
+        arg.append(address::to_bytes(object::id_address(&its)));
 
         let arguments = vector[
             arg,
@@ -340,12 +340,12 @@ module its::discovery {
         assert!(tx_block.is_final(), 2);
         let mut move_calls = tx_block.move_calls();
         assert!(move_calls.length() == 1, 3);
-        let call_info = vector::pop_back(&mut move_calls);
+        let call_info = move_calls.pop_back();
         assert!(call_info.function().package_id_from_function() == package_id<ITS>(), 4);
         assert!(call_info.function().module_name() == ascii::string(b"service"), 5);
         assert!(call_info.function().name() == ascii::string(b"receive_deploy_interchain_token"), 6);
         let mut arg = vector[0];
-        vector::append(&mut arg, address::to_bytes(object::id_address(&its)));
+        arg.append(address::to_bytes(object::id_address(&its)));
 
         let arguments = vector[
             arg,

diff --git a/move/its/sources/its.move b/move/its/sources/its.move
@@ -74,7 +74,7 @@ module its::its {
     }
 
     public(package) fun set_trusted_address(self: &mut ITS, chain_name: String, trusted_address: String) {
-        address_tracker::set_trusted_address(&mut self.address_tracker, chain_name, trusted_address);
+        self.address_tracker.set_trusted_address(chain_name, trusted_address);
     }
 
     public fun get_unregistered_coin_type(
@@ -83,17 +83,17 @@ module its::its {
         let key = token_id::unregistered_token_id(symbol, decimals);
 
         assert!(self.unregistered_coin_types.contains(key), ENotFound);
-        self.unregistered_coin_types.borrow(key)
+        &self.unregistered_coin_types[key]
     }
 
     public fun get_registered_coin_type(self: &ITS, token_id: TokenId): &TypeName {
         assert!(self.registered_coin_types.contains(token_id), EUnregisteredCoin);
-        self.registered_coin_types.borrow(token_id)
+        &self.registered_coin_types[token_id]
     }
 
     public fun get_coin_data<T>(self: &ITS, token_id: TokenId): &CoinData<T> {
         assert!(self.registered_coins.contains(token_id), EUnregisteredCoin);
-        self.registered_coins.borrow(token_id)
+        &self.registered_coins[token_id]
     }
 
     public fun get_coin_info<T>(self: &ITS, token_id: TokenId): &CoinInfo<T> {
@@ -138,7 +138,7 @@ module its::its {
     }
 
     public(package) fun coin_data_mut<T>(self: &mut ITS, token_id: TokenId): &mut CoinData<T> {
-        self.registered_coins.borrow_mut(token_id)
+        &mut self.registered_coins[token_id]
     }
 
     public(package) fun add_unregistered_coin<T>(

diff --git a/move/its/sources/service.move b/move/its/sources/service.move
@@ -256,8 +256,8 @@ module its::service {
         let mut i = 0;
         while(i < length) {
             its.set_trusted_address(
-                ascii::string(vector::pop_back(&mut chain_names)),
-                ascii::string(vector::pop_back(&mut trusted_addresses)),
+                ascii::string(chain_names.pop_back()),
+                ascii::string(trusted_addresses.pop_back()),
             );
             i = i + 1;
         }

diff --git a/move/its/sources/token_id.move b/move/its/sources/token_id.move
@@ -42,12 +42,12 @@ module its::token_id {
         has_treasury: &bool
     ): TokenId {
         let mut vec = address::to_bytes(address::from_u256(PREFIX_SUI_TOKEN_ID));
-        vector::append(&mut vec, bcs::to_bytes(&type_name::get<T>()));
-        vector::append(&mut vec, bcs::to_bytes(name));
-        vector::append(&mut vec, bcs::to_bytes(symbol));
-        vector::append(&mut vec, bcs::to_bytes(decimals));
-        vector::append(&mut vec, bcs::to_bytes(has_metadata));
-        vector::append(&mut vec, bcs::to_bytes(has_treasury));
+        vec.append(bcs::to_bytes(&type_name::get<T>()));
+        vec.append(bcs::to_bytes(name));
+        vec.append(bcs::to_bytes(symbol));
+        vec.append(bcs::to_bytes(decimals));
+        vec.append(bcs::to_bytes(has_metadata));
+        vec.append(bcs::to_bytes(has_treasury));
         TokenId { id: address::from_bytes(keccak256(&vec)) }
     }
 
@@ -67,7 +67,7 @@ module its::token_id {
         symbol: &ascii::String, decimals: u8
     ): UnregisteredTokenId {
         let mut v = vector[decimals];
-        vector::append(&mut v, *ascii::as_bytes(symbol));
+        v.append(*ascii::as_bytes(symbol));
         let id = address::from_bytes(keccak256(&v));
         UnregisteredTokenId { id }
     }
@@ -90,7 +90,7 @@ module its::token_id {
         let coin_info = coin_info::from_info<String>(name, symbol, decimals);
         let mut vec = address::to_bytes(address::from_u256(PREFIX_SUI_TOKEN_ID));
 
-        vector::append<u8>(&mut vec, bcs::to_bytes<CoinInfo<String>>(&coin_info));
-        coin_info::drop(coin_info);
+        vec.append<u8>(bcs::to_bytes<CoinInfo<String>>(&coin_info));
+        coin_info.drop();
     }
 }
diff --git a/move/its/sources/utils.move b/move/its/sources/utils.move
@@ -50,7 +50,7 @@ module its::utils {
 
     public fun hash_coin_info(symbol: &ascii::String, decimals: &u8): address {
         let mut v = vector[*decimals];
-        vector::append(&mut v, *symbol.as_bytes());
+        v.append(*symbol.as_bytes());
         address::from_bytes(keccak256(&v))
     }
 
@@ -61,7 +61,7 @@ module its::utils {
             let mut i = 0;
             let mut version: u32 = 0;
             while (i < 4) {
-                version = (version << (8 as u8) as u32) + (vector::remove<u8>(&mut metadata, 0) as u32);
+                version = (version << (8 as u8) as u32) + (metadata.remove<u8>(0) as u32);
                 i = i + 1;
             };
 

diff --git a/move/squid/sources/squid/coin_bag.move b/move/squid/sources/squid/coin_bag.move
@@ -95,13 +95,13 @@ module squid::coin_bag {
 
     fun get_balance_key<T>(): address {
         let mut data = vector[0];
-        vector::append(&mut data, type_name::get<T>().into_string().into_bytes());
+        data.append(type_name::get<T>().into_string().into_bytes());
         address::from_bytes(keccak256(&data))
     }
 
     fun get_estimate_key<T>(): address {
         let mut data = vector[1];
-        vector::append(&mut data, type_name::get<T>().into_string().into_bytes());
+        data.append(type_name::get<T>().into_string().into_bytes());
         address::from_bytes(keccak256(&data))
     }
 }
diff --git a/move/squid/sources/squid/deepbook_v2.move b/move/squid/sources/squid/deepbook_v2.move
@@ -321,7 +321,7 @@ module squid::deepbook_v2 {
 
     public(package) fun get_estimate_move_call(package_id: address, mut bcs: BCS, swap_info_arg: vector<u8>): MoveCall {
         let mut pool_arg = vector[0];
-        vector::append(&mut pool_arg, bcs.peel_address().to_bytes());
+        pool_arg.append(bcs.peel_address().to_bytes());
 
         let _has_base = bcs.peel_bool();
         let _min_output = bcs.peel_u64();
@@ -346,7 +346,7 @@ module squid::deepbook_v2 {
 
     public(package) fun get_swap_move_call(package_id: address, mut bcs: BCS, swap_info_arg: vector<u8>, squid_arg: vector<u8>): MoveCall {
         let mut pool_arg = vector[0];
-        vector::append(&mut pool_arg, bcs.peel_address().to_bytes());
+        pool_arg.append(bcs.peel_address().to_bytes());
 
         let _has_base = bcs.peel_bool();
         let _min_output = bcs.peel_u64();

diff --git a/move/squid/sources/squid/discovery.move b/move/squid/sources/squid/discovery.move
@@ -20,10 +20,10 @@ module squid::discovery {
 
     public fun register_transaction(squid: &Squid, its: &ITS, relayer_discovery: &mut RelayerDiscovery) {
         let mut squid_arg = vector[0];
-        vector::append(&mut squid_arg, object::id(squid).id_to_bytes());
+        squid_arg.append(object::id(squid).id_to_bytes());
 
         let mut its_arg = vector[0];
-        vector::append(&mut its_arg, object::id(its).id_to_bytes());
+        its_arg.append(object::id(its).id_to_bytes());
 
         let transaction = discovery::new_transaction(
             false,
@@ -56,10 +56,10 @@ module squid::discovery {
 
 
         let mut squid_arg = vector[0];
-        vector::append(&mut squid_arg, object::id(squid).id_to_bytes());
+        squid_arg.append(object::id(squid).id_to_bytes());
 
         let mut its_arg = vector[0];
-        vector::append(&mut its_arg, object::id(its).id_to_bytes());
+        its_arg.append(object::id(its).id_to_bytes());
         let swap_info_arg = vector[4, 0, 0];
 
         let mut move_calls = vector [

diff --git a/move/test/sources/test/test.move b/move/test/sources/test/test.move
@@ -35,7 +35,7 @@ module test::test {
         let mut arg = vector::singleton<u8>(2);
         arguments.push_back(arg);
         arg = vector::singleton<u8>(0);
-        vector::append(&mut arg, address::to_bytes(object::id_address(singleton)));
+        arg.append(address::to_bytes(object::id_address(singleton)));
         arguments.push_back(arg);
         let transaction = discovery::new_transaction(
             true,