diff --git a/.changeset/dull-humans-fold.md b/.changeset/dull-humans-fold.md new file mode 100644 index 00000000..348049d8 --- /dev/null +++ b/.changeset/dull-humans-fold.md @@ -0,0 +1,5 @@ +--- +'@axelar-network/axelar-cgp-sui': minor +--- + +added randomness to all axelar gateway tests diff --git a/move/axelar_gateway/sources/auth.move b/move/axelar_gateway/sources/auth.move index 73e09e34..295c338f 100644 --- a/move/axelar_gateway/sources/auth.move +++ b/move/axelar_gateway/sources/auth.move @@ -165,10 +165,11 @@ use axelar_gateway::proof; #[test_only] public fun dummy(ctx: &mut TxContext): AxelarSigners { + let mut rng = sui::random::new_generator_for_testing(); AxelarSigners { epoch: 0, epoch_by_signers_hash: table::new(ctx), - domain_separator: bytes32::new(@0x1), + domain_separator: bytes32::from_bytes(rng.generate_bytes(32)), minimum_rotation_delay: 1, last_rotation_timestamp: 0, previous_signers_retention: 3, @@ -262,13 +263,14 @@ fun test_update_rotation_timestamp_insufficient_rotation_delay() { #[test] #[expected_failure(abort_code = EInvalidEpoch)] fun test_validate_proof_invalid_epoch() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); let mut self = new(ctx); let proof = axelar_gateway::proof::create_for_testing( axelar_gateway::weighted_signers::create_for_testing( vector[], 0, - bytes32::new(@0x0), + bytes32::from_bytes(rng.generate_bytes(32)), ), vector[], ); @@ -281,7 +283,7 @@ fun test_validate_proof_invalid_epoch() { self.epoch = 3; self.validate_proof( - bytes32::new(@0x0), + bytes32::from_bytes(rng.generate_bytes(32)), proof, ); diff --git a/move/axelar_gateway/sources/channel.move b/move/axelar_gateway/sources/channel.move index 16d9813c..133a576d 100644 --- a/move/axelar_gateway/sources/channel.move +++ b/move/axelar_gateway/sources/channel.move @@ -217,11 +217,12 @@ fun test_to_address() { #[test] fun test_create_approved_message() { + let mut rng = sui::random::new_generator_for_testing(); let input_source_chain = std::ascii::string(b"Source Chain"); let input_message_id = std::ascii::string(b"message id"); let input_source_address = std::ascii::string(b"Source Address"); - let input_destination_id = @0x5678; - let input_payload = b"payload"; + let input_destination_id = sui::address::from_bytes(rng.generate_bytes(32)); + let input_payload = rng.generate_bytes(32); let approved_message: ApprovedMessage = create_approved_message( input_source_chain, input_message_id, @@ -246,6 +247,7 @@ fun test_create_approved_message() { #[test] fun test_consume_approved_message() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); let channel: Channel = new(ctx); @@ -253,7 +255,7 @@ fun test_consume_approved_message() { let input_message_id = std::ascii::string(b"message id"); let input_source_address = std::ascii::string(b"Source Address"); let input_destination_id = channel.to_address(); - let input_payload = b"payload"; + let input_payload = rng.generate_bytes(32); let approved_message: ApprovedMessage = create_approved_message( input_source_chain, input_message_id, @@ -280,14 +282,15 @@ fun test_consume_approved_message() { #[test] #[expected_failure(abort_code = EInvalidDestination)] fun test_consume_approved_message_wrong_destination() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); let channel: Channel = new(ctx); let source_chain = std::ascii::string(b"Source Chain"); let message_id = std::ascii::string(b"message id"); let source_address = std::ascii::string(b"Source Address"); - let destination_id = @0x5678; - let payload = b"payload"; + let destination_id = sui::address::from_bytes(rng.generate_bytes(32)); + let payload = rng.generate_bytes(32); let approved_message = create_approved_message( source_chain, diff --git a/move/axelar_gateway/sources/gateway.move b/move/axelar_gateway/sources/gateway.move index f4aa8e4b..2a123aba 100644 --- a/move/axelar_gateway/sources/gateway.move +++ b/move/axelar_gateway/sources/gateway.move @@ -5,41 +5,49 @@ /// - When call approvals is sent to Sui, it targets an object and not a module; /// - To support cross-chain messaging, a Channel object has to be created; /// - Channel can be either owned or shared but not frozen; -/// - Module developer on the Sui side will have to implement a system to support messaging; -/// - Checks for uniqueness of approvals should be done through `Channel`s to avoid big value storage; +/// - Module developer on the Sui side will have to implement a system to +/// support messaging; +/// - Checks for uniqueness of approvals should be done through `Channel`s to +/// avoid big value storage; /// /// I. Sending call approvals /// -/// A approval is sent through the `send` function, a Channel is supplied to determine the source -> ID. +/// A approval is sent through the `send` function, a Channel is supplied to +/// determine the source -> ID. /// Event is then emitted and Axelar network can operate /// /// II. Receiving call approvals /// -/// Approval bytes and signatures are passed into `create` function to generate a CallApproval object. +/// Approval bytes and signatures are passed into `create` function to generate +/// a CallApproval object. /// - Signatures are checked against the known set of signers. -/// - CallApproval bytes are parsed to determine: source, destination_chain, payload and destination_id +/// - CallApproval bytes are parsed to determine: source, destination_chain, +/// payload and destination_id /// - `destination_id` points to a `Channel` object /// -/// Once created, `CallApproval` needs to be consumed. And the only way to do it is by calling -/// `consume_call_approval` function and pass a correct `Channel` instance alongside the `CallApproval`. +/// Once created, `CallApproval` needs to be consumed. And the only way to do it +/// is by calling +/// `consume_call_approval` function and pass a correct `Channel` instance +/// alongside the `CallApproval`. /// - CallApproval is checked for uniqueness (for this channel) /// - CallApproval is checked to match the `Channel`.id /// -/// The Gateway object uses a versioned field to support upgradability. The current implementation uses Gateway_v0. +/// The Gateway object uses a versioned field to support upgradability. The +/// current implementation uses Gateway_v0. module axelar_gateway::gateway; use axelar_gateway::auth::{Self, validate_proof}; use axelar_gateway::bytes32::{Self, Bytes32}; use axelar_gateway::channel::{Channel, ApprovedMessage}; -use axelar_gateway::weighted_signers; -use axelar_gateway::message_ticket::{Self, MessageTicket}; use axelar_gateway::gateway_v0::{Self, Gateway_v0}; +use axelar_gateway::message_ticket::{Self, MessageTicket}; +use axelar_gateway::weighted_signers; use std::ascii::{Self, String}; use sui::clock::Clock; -use sui::table::{Self}; +use sui::table; use sui::versioned::{Self, Versioned}; -use version_control::version_control::{Self, VersionControl}; use utils::utils; +use version_control::version_control::{Self, VersionControl}; // ------- // Version @@ -65,7 +73,8 @@ public struct CreatorCap has key, store { // Setup // ----- -/// Init the module by giving a CreatorCap to the sender to allow a full `setup`. +/// Init the module by giving a CreatorCap to the sender to allow a full +/// `setup`. fun init(ctx: &mut TxContext) { let cap = CreatorCap { id: object::new(ctx), @@ -128,7 +137,10 @@ macro fun value($self: &Gateway, $function_name: vector): &Gateway_v0 { } /// This macro also uses version control to sinplify things a bit. -macro fun value_mut($self: &mut Gateway, $function_name: vector): &mut Gateway_v0 { +macro fun value_mut( + $self: &mut Gateway, + $function_name: vector, +): &mut Gateway_v0 { let gateway = $self; let value = gateway.inner.load_value_mut(); value.version_control().check(VERSION, ascii::string($function_name)); @@ -140,8 +152,10 @@ macro fun value_mut($self: &mut Gateway, $function_name: vector): &mut Gatew // ----------- /// The main entrypoint for approving Axelar signed messages. -/// If proof is valid, message approvals are stored in the Gateway object, if not already approved before. -/// This method is only intended to be called via a Transaction Block, keeping more flexibility for upgrades. +/// If proof is valid, message approvals are stored in the Gateway object, if +/// not already approved before. +/// This method is only intended to be called via a Transaction Block, keeping +/// more flexibility for upgrades. entry fun approve_messages( self: &mut Gateway, message_data: vector, @@ -153,7 +167,8 @@ entry fun approve_messages( /// The main entrypoint for rotating Axelar signers. /// If proof is valid, signers stored on the Gateway object are rotated. -/// This method is only intended to be called via a Transaction Block, keeping more flexibility for upgrades. +/// This method is only intended to be called via a Transaction Block, keeping +/// more flexibility for upgrades. entry fun rotate_signers( self: &mut Gateway, clock: &Clock, @@ -190,12 +205,10 @@ public fun prepare_message( ) } -/// Submit the MessageTicket which causes a contract call by sending an event from an +/// Submit the MessageTicket which causes a contract call by sending an event +/// from an /// authorized Channel. -public fun send_message( - self: &Gateway, - message: MessageTicket, -) { +public fun send_message(self: &Gateway, message: MessageTicket) { let value = self.value!(b"send_message"); value.send_message(message, VERSION); } @@ -228,7 +241,8 @@ public fun is_message_executed( } /// To execute a message, the relayer will call `take_approved_message` -/// to get the hot potato `ApprovedMessage` object, and then trigger the app's package via discovery. +/// to get the hot potato `ApprovedMessage` object, and then trigger the app's +/// package via discovery. public fun take_approved_message( self: &mut Gateway, source_chain: String, @@ -252,19 +266,16 @@ public fun take_approved_message( // ----------------- fun version_control(): VersionControl { - version_control::new( - vector [ - // Version 0 - vector [ - b"approve_messages", - b"rotate_signers", - b"is_message_approved", - b"is_message_executed", - b"take_approved_message", - b"send_message", - ].map!(|function_name| function_name.to_ascii_string()) - ] - ) + version_control::new(vector[ + vector[ + b"approve_messages", + b"rotate_signers", + b"is_message_approved", + b"is_message_executed", + b"take_approved_message", + b"send_message", + ].map!(|function_name| function_name.to_ascii_string()), + ]) } // --------- @@ -310,26 +321,24 @@ public fun create_for_testing( #[test_only] fun dummy(ctx: &mut TxContext): Gateway { + let mut rng = sui::random::new_generator_for_testing(); let inner = versioned::create( VERSION, gateway_v0::new( - @0x0, + sui::address::from_bytes(rng.generate_bytes(32)), table::new(ctx), auth::dummy(ctx), - version_control::new( - vector [ - // Version 0 - vector [ - b"approve_messages", - b"rotate_signers", - b"is_message_approved", - b"is_message_executed", - b"take_approved_message", - b"send_message", - b"", - ].map!(|function_name| function_name.to_ascii_string()) - ] - ) + version_control::new(vector[ + vector[ + b"approve_messages", + b"rotate_signers", + b"is_message_approved", + b"is_message_executed", + b"take_approved_message", + b"send_message", + b"", + ].map!(|function_name| function_name.to_ascii_string()), + ]), ), ctx, ); @@ -348,12 +357,7 @@ public fun destroy_for_testing(self: Gateway) { id.delete(); let value = inner.destroy(); - let ( - _, - messages, - signers, - _, - ) = value.destroy_for_testing(); + let (_, messages, signers, _) = value.destroy_for_testing(); let (_, table, _, _, _, _) = signers.destroy_for_testing(); table.destroy_empty(); @@ -377,14 +381,15 @@ fun test_init() { #[test] fun test_setup() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); - let operator = @123456; - let domain_separator = @789012; - let minimum_rotation_delay = 765; - let previous_signers_retention = 650; + let operator = sui::address::from_bytes(rng.generate_bytes(32)); + let domain_separator = sui::address::from_bytes(rng.generate_bytes(32)); + let minimum_rotation_delay = rng.generate_u64(); + let previous_signers_retention = rng.generate_u64(); let initial_signers = axelar_gateway::weighted_signers::dummy(); let mut clock = sui::clock::create_for_testing(ctx); - let timestamp = 1234; + let timestamp = rng.generate_u64(); clock.increment_for_testing(timestamp); let creator_cap = CreatorCap { @@ -417,12 +422,9 @@ fun test_setup() { } = gateway; id.delete(); - let ( - operator_result, - messages, - signers, - _, - ) = inner.destroy().destroy_for_testing(); + let (operator_result, messages, signers, _) = inner + .destroy() + .destroy_for_testing(); assert!(operator == operator_result); messages.destroy_empty(); @@ -453,14 +455,15 @@ fun test_setup() { #[test] #[expected_failure] fun test_setup_remaining_bytes() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); - let operator = @123456; - let domain_separator = @789012; - let minimum_rotation_delay = 765; - let previous_signers_retention = 650; + let operator = sui::address::from_bytes(rng.generate_bytes(32)); + let domain_separator = sui::address::from_bytes(rng.generate_bytes(32)); + let minimum_rotation_delay = rng.generate_u64(); + let previous_signers_retention = rng.generate_u64(); let initial_signers = axelar_gateway::weighted_signers::dummy(); let mut clock = sui::clock::create_for_testing(ctx); - let timestamp = 1234; + let timestamp = rng.generate_u64(); clock.increment_for_testing(timestamp); let creator_cap = CreatorCap { @@ -494,12 +497,9 @@ fun test_setup_remaining_bytes() { } = gateway; id.delete(); - let ( - operator_result, - messages, - signers, - _, - ) = inner.destroy().destroy_for_testing(); + let (operator_result, messages, signers, _) = inner + .destroy() + .destroy_for_testing(); assert!(operator == operator_result); messages.destroy_empty(); @@ -567,14 +567,15 @@ fun test_peel_proof_no_remaining_data() { #[test] fun test_take_approved_message() { + let mut rng = sui::random::new_generator_for_testing(); let mut gateway = dummy(&mut sui::tx_context::dummy()); let source_chain = std::ascii::string(b"Source Chain"); let message_id = std::ascii::string(b"Message Id"); let source_address = std::ascii::string(b"Source Address"); - let destination_id = @0x1; - let payload = b"payload"; + let destination_id = sui::address::from_bytes(rng.generate_bytes(32)); + let payload = rng.generate_bytes(32); let payload_hash = axelar_gateway::bytes32::new( - sui::address::from_bytes(sui::hash::keccak256(&payload)) + sui::address::from_bytes(sui::hash::keccak256(&payload)), ); let message = axelar_gateway::message::new( source_chain, @@ -584,14 +585,14 @@ fun test_take_approved_message() { payload_hash, ); - gateway.value_mut!(b"") + gateway + .value_mut!(b"") .messages_mut() .add( message.command_id(), axelar_gateway::message_status::approved(message.hash()), ); - let approved_message = gateway.take_approved_message( source_chain, message_id, @@ -608,7 +609,6 @@ fun test_take_approved_message() { ); assert!(&approved_message == &expected_approved_message); - gateway.value_mut!(b"").messages_mut().remove(message.command_id()); approved_message.destroy_for_testing(); @@ -618,22 +618,25 @@ fun test_take_approved_message() { #[test] fun test_approve_messages() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); - let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed(&@0x1234.to_bytes()); + let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed( + &rng.generate_bytes(32), + ); let weighted_signers = weighted_signers::create_for_testing( vector[ axelar_gateway::weighted_signer::new( *keypair.public_key(), 1, - ) + ), ], 1, - bytes32::new(@0x0), + bytes32::from_bytes(rng.generate_bytes(32)), ); - let operator = @0x1; - let domain_separator = bytes32::new(@0x2); - let minimum_rotation_delay = 1; - let previous_signers_retention = 10; + let operator = sui::address::from_bytes(rng.generate_bytes(32)); + let domain_separator = bytes32::from_bytes(rng.generate_bytes(32)); + let minimum_rotation_delay = rng.generate_u64(); + let previous_signers_retention = rng.generate_u64(); let initial_signers = weighted_signers; let clock = sui::clock::create_for_testing(ctx); let mut self = create_for_testing( @@ -646,10 +649,15 @@ fun test_approve_messages() { ctx, ); let messages = vector[ - axelar_gateway::message::dummy() + axelar_gateway::message::dummy(), ]; let data_hash = gateway_v0::approve_messages_data_hash(messages); - let proof = generate_proof(data_hash, domain_separator, weighted_signers, &vector[keypair]); + let proof = generate_proof( + data_hash, + domain_separator, + weighted_signers, + &vector[keypair], + ); self.approve_messages(bcs::to_bytes(&messages), bcs::to_bytes(&proof)); @@ -660,22 +668,25 @@ fun test_approve_messages() { #[test] #[expected_failure] fun test_approve_messages_remaining_data() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); - let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed(&@0x1234.to_bytes()); + let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed( + &rng.generate_bytes(32), + ); let weighted_signers = weighted_signers::create_for_testing( vector[ axelar_gateway::weighted_signer::new( *keypair.public_key(), 1, - ) + ), ], 1, - bytes32::new(@0x0), + bytes32::from_bytes(rng.generate_bytes(32)), ); - let operator = @0x1; - let domain_separator = bytes32::new(@0x2); - let minimum_rotation_delay = 1; - let previous_signers_retention = 10; + let operator = sui::address::from_bytes(rng.generate_bytes(32)); + let domain_separator = bytes32::from_bytes(rng.generate_bytes(32)); + let minimum_rotation_delay = rng.generate_u64(); + let previous_signers_retention = rng.generate_u64(); let initial_signers = weighted_signers; let clock = sui::clock::create_for_testing(ctx); let mut self = create_for_testing( @@ -687,11 +698,14 @@ fun test_approve_messages_remaining_data() { &clock, ctx, ); - let messages = vector[ - axelar_gateway::message::dummy() - ]; + let messages = vector[axelar_gateway::message::dummy()]; let data_hash = gateway_v0::approve_messages_data_hash(messages); - let proof = generate_proof(data_hash, domain_separator, weighted_signers, &vector[keypair]); + let proof = generate_proof( + data_hash, + domain_separator, + weighted_signers, + &vector[keypair], + ); let mut proof_data = bcs::to_bytes(&proof); proof_data.push_back(0); @@ -703,33 +717,38 @@ fun test_approve_messages_remaining_data() { #[test] fun test_rotate_signers() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); - let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed(&@0x1234.to_bytes()); + let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed( + &rng.generate_bytes(32), + ); let weighted_signers = weighted_signers::create_for_testing( vector[ axelar_gateway::weighted_signer::new( *keypair.public_key(), 1, - ) + ), ], 1, - bytes32::new(@0x0), + bytes32::from_bytes(rng.generate_bytes(32)), ); let next_weighted_signers = weighted_signers::create_for_testing( vector[ axelar_gateway::weighted_signer::new( - *sui::ecdsa_k1::secp256k1_keypair_from_seed(&@0x5678.to_bytes()).public_key(), + *sui::ecdsa_k1::secp256k1_keypair_from_seed( + &rng.generate_bytes(32), + ).public_key(), 1, - ) + ), ], 1, - bytes32::new(@0x1), + bytes32::from_bytes(rng.generate_bytes(32)), ); - let operator = @0x1; - let domain_separator = bytes32::new(@0x2); - let minimum_rotation_delay = 1; - let previous_signers_retention = 10; + let operator = sui::address::from_bytes(rng.generate_bytes(32)); + let domain_separator = bytes32::from_bytes(rng.generate_bytes(32)); + let minimum_rotation_delay = rng.generate_u64(); + let previous_signers_retention = rng.generate_u64(); let initial_signers = weighted_signers; let mut clock = sui::clock::create_for_testing(ctx); let mut self = create_for_testing( @@ -743,10 +762,20 @@ fun test_rotate_signers() { ); let data_hash = gateway_v0::rotate_signers_data_hash(next_weighted_signers); - let proof = generate_proof(data_hash, domain_separator, weighted_signers, &vector[keypair]); + let proof = generate_proof( + data_hash, + domain_separator, + weighted_signers, + &vector[keypair], + ); clock.increment_for_testing(minimum_rotation_delay); - self.rotate_signers(&clock, bcs::to_bytes(&next_weighted_signers), bcs::to_bytes(&proof), ctx); + self.rotate_signers( + &clock, + bcs::to_bytes(&next_weighted_signers), + bcs::to_bytes(&proof), + ctx, + ); clock.destroy_for_testing(); sui::test_utils::destroy(self); @@ -755,33 +784,38 @@ fun test_rotate_signers() { #[test] #[expected_failure] fun test_rotate_signers_remaining_data_message_data() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); - let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed(&@0x1234.to_bytes()); + let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed( + &rng.generate_bytes(32), + ); let weighted_signers = weighted_signers::create_for_testing( vector[ axelar_gateway::weighted_signer::new( *keypair.public_key(), 1, - ) + ), ], 1, - bytes32::new(@0x0), + bytes32::from_bytes(rng.generate_bytes(32)), ); let next_weighted_signers = weighted_signers::create_for_testing( vector[ axelar_gateway::weighted_signer::new( - *sui::ecdsa_k1::secp256k1_keypair_from_seed(&@0x5678.to_bytes()).public_key(), + *sui::ecdsa_k1::secp256k1_keypair_from_seed( + &rng.generate_bytes(32), + ).public_key(), 1, - ) + ), ], 1, - bytes32::new(@0x1), + bytes32::from_bytes(rng.generate_bytes(32)), ); - let operator = @0x1; - let domain_separator = bytes32::new(@0x2); - let minimum_rotation_delay = 1; - let previous_signers_retention = 10; + let operator = sui::address::from_bytes(rng.generate_bytes(32)); + let domain_separator = bytes32::from_bytes(rng.generate_bytes(32)); + let minimum_rotation_delay = rng.generate_u64(); + let previous_signers_retention = rng.generate_u64(); let initial_signers = weighted_signers; let mut clock = sui::clock::create_for_testing(ctx); let mut self = create_for_testing( @@ -798,7 +832,12 @@ fun test_rotate_signers_remaining_data_message_data() { message_data.push_back(0); let data_hash = gateway_v0::rotate_signers_data_hash(next_weighted_signers); - let proof = generate_proof(data_hash, domain_separator, weighted_signers, &vector[keypair]); + let proof = generate_proof( + data_hash, + domain_separator, + weighted_signers, + &vector[keypair], + ); clock.increment_for_testing(minimum_rotation_delay); self.rotate_signers(&clock, message_data, bcs::to_bytes(&proof), ctx); @@ -810,33 +849,38 @@ fun test_rotate_signers_remaining_data_message_data() { #[test] #[expected_failure] fun test_rotate_signers_remaining_data_proof_data() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); - let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed(&@0x1234.to_bytes()); + let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed( + &rng.generate_bytes(32), + ); let weighted_signers = weighted_signers::create_for_testing( vector[ axelar_gateway::weighted_signer::new( *keypair.public_key(), 1, - ) + ), ], 1, - bytes32::new(@0x0), + bytes32::from_bytes(rng.generate_bytes(32)), ); let next_weighted_signers = weighted_signers::create_for_testing( vector[ axelar_gateway::weighted_signer::new( - *sui::ecdsa_k1::secp256k1_keypair_from_seed(&@0x5678.to_bytes()).public_key(), + *sui::ecdsa_k1::secp256k1_keypair_from_seed( + &rng.generate_bytes(32), + ).public_key(), 1, - ) + ), ], 1, - bytes32::new(@0x1), + bytes32::from_bytes(rng.generate_bytes(32)), ); - let operator = @0x1; - let domain_separator = bytes32::new(@0x2); - let minimum_rotation_delay = 1; - let previous_signers_retention = 10; + let operator = sui::address::from_bytes(rng.generate_bytes(32)); + let domain_separator = bytes32::from_bytes(rng.generate_bytes(32)); + let minimum_rotation_delay = rng.generate_u64(); + let previous_signers_retention = rng.generate_u64(); let initial_signers = weighted_signers; let mut clock = sui::clock::create_for_testing(ctx); let mut self = create_for_testing( @@ -850,12 +894,22 @@ fun test_rotate_signers_remaining_data_proof_data() { ); let data_hash = gateway_v0::rotate_signers_data_hash(next_weighted_signers); - let proof = generate_proof(data_hash, domain_separator, weighted_signers, &vector[keypair]); + let proof = generate_proof( + data_hash, + domain_separator, + weighted_signers, + &vector[keypair], + ); let mut proof_data = bcs::to_bytes(&proof); proof_data.push_back(0); clock.increment_for_testing(minimum_rotation_delay); - self.rotate_signers(&clock, bcs::to_bytes(&next_weighted_signers), proof_data, ctx); + self.rotate_signers( + &clock, + bcs::to_bytes(&next_weighted_signers), + proof_data, + ctx, + ); clock.destroy_for_testing(); sui::test_utils::destroy(self); @@ -864,33 +918,38 @@ fun test_rotate_signers_remaining_data_proof_data() { #[test] #[expected_failure(abort_code = axelar_gateway::gateway_v0::ENotLatestSigners)] fun test_rotate_signers_not_latest_signers() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); - let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed(&@0x1234.to_bytes()); + let keypair = sui::ecdsa_k1::secp256k1_keypair_from_seed( + &rng.generate_bytes(32), + ); let weighted_signers = weighted_signers::create_for_testing( vector[ axelar_gateway::weighted_signer::new( *keypair.public_key(), 1, - ) + ), ], 1, - bytes32::new(@0x0), + bytes32::from_bytes(rng.generate_bytes(32)), ); let next_weighted_signers = weighted_signers::create_for_testing( vector[ axelar_gateway::weighted_signer::new( - *sui::ecdsa_k1::secp256k1_keypair_from_seed(&@0x5678.to_bytes()).public_key(), + *sui::ecdsa_k1::secp256k1_keypair_from_seed( + &rng.generate_bytes(32), + ).public_key(), 1, - ) + ), ], 1, - bytes32::new(@0x2), + bytes32::from_bytes(rng.generate_bytes(32)), ); - let operator = @0x1; - let domain_separator = bytes32::new(@0x2); - let minimum_rotation_delay = 1; - let previous_signers_retention = 10; + let operator = sui::address::from_bytes(rng.generate_bytes(32)); + let domain_separator = bytes32::from_bytes(rng.generate_bytes(32)); + let minimum_rotation_delay = rng.generate_u64(); + let previous_signers_retention = rng.generate_u64(); let initial_signers = weighted_signers; let mut clock = sui::clock::create_for_testing(ctx); let mut self = create_for_testing( @@ -907,10 +966,20 @@ fun test_rotate_signers_not_latest_signers() { *epoch = *epoch + 1; let data_hash = gateway_v0::rotate_signers_data_hash(next_weighted_signers); - let proof = generate_proof(data_hash, domain_separator, weighted_signers, &vector[keypair]); + let proof = generate_proof( + data_hash, + domain_separator, + weighted_signers, + &vector[keypair], + ); clock.increment_for_testing(minimum_rotation_delay); - self.rotate_signers(&clock, bcs::to_bytes(&next_weighted_signers), bcs::to_bytes(&proof), ctx); + self.rotate_signers( + &clock, + bcs::to_bytes(&next_weighted_signers), + bcs::to_bytes(&proof), + ctx, + ); clock.destroy_for_testing(); sui::test_utils::destroy(self); @@ -918,13 +987,14 @@ fun test_rotate_signers_not_latest_signers() { #[test] fun test_is_message_approved() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); let source_chain = ascii::string(b"Source Chain"); let source_address = ascii::string(b"Source Address"); let message_id = ascii::string(b"Message Id"); - let destination_id = @0x4; - let payload_hash = bytes32::new(@0x5); + let destination_id = sui::address::from_bytes(rng.generate_bytes(32)); + let payload_hash = bytes32::from_bytes(rng.generate_bytes(32)); let message = axelar_gateway::message::new( source_chain, message_id, @@ -935,28 +1005,33 @@ fun test_is_message_approved() { let mut gateway = dummy(ctx); gateway.value_mut!(b"").approve_message_for_testing(message); - assert!(gateway.is_message_approved( - source_chain, - message_id, - source_address, - destination_id, - payload_hash, - )); - assert!(!gateway.is_message_executed( - source_chain, - message_id, - )); + assert!( + gateway.is_message_approved( + source_chain, + message_id, + source_address, + destination_id, + payload_hash, + ), + ); + assert!( + !gateway.is_message_executed( + source_chain, + message_id, + ), + ); sui::test_utils::destroy(gateway); } #[test] fun test_send_message() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); let channel = axelar_gateway::channel::new(ctx); let destination_chain = ascii::string(b"Destination Chain"); let destination_address = ascii::string(b"Destination Address"); - let payload = b"payload"; + let payload = rng.generate_bytes(32); let message_ticket = prepare_message( &channel, destination_chain, diff --git a/move/axelar_gateway/sources/types/bytes32.move b/move/axelar_gateway/sources/types/bytes32.move index 0c900a06..704175f0 100644 --- a/move/axelar_gateway/sources/types/bytes32.move +++ b/move/axelar_gateway/sources/types/bytes32.move @@ -56,9 +56,10 @@ public(package) fun peel(bcs: &mut BCS): Bytes32 { #[test] public fun test_new() { - let actual = new(@0x1); + let addr = address::from_u256(sui::random::new_generator_for_testing().generate_u256()); + let actual = new(addr); - assert!(actual.to_bytes() == @0x1.to_bytes()); + assert!(actual.to_bytes() == addr.to_bytes()); assert!(actual.length() == LENGTH); } @@ -72,7 +73,7 @@ public fun test_default() { #[test] public fun test_from_address() { - let addr = @0x1234; + let addr = address::from_u256(sui::random::new_generator_for_testing().generate_u256()); let bytes32 = from_address(addr); assert!(bytes32.bytes == addr); assert!(bytes32.length() == LENGTH); diff --git a/move/axelar_gateway/sources/types/message_ticket.move b/move/axelar_gateway/sources/types/message_ticket.move index 32820487..176bf43f 100644 --- a/move/axelar_gateway/sources/types/message_ticket.move +++ b/move/axelar_gateway/sources/types/message_ticket.move @@ -96,12 +96,13 @@ public fun new_for_testing( #[test] fun test_all() { - let source_id: address = @0x123; - let destination_chain: String = std::ascii::string(b"Destination Chain"); - let destination_address: String = std::ascii::string( + let mut rng = sui::random::new_generator_for_testing(); + let source_id = sui::address::from_u256(rng.generate_u256()); + let destination_chain = std::ascii::string(b"Destination Chain"); + let destination_address = std::ascii::string( b"Destination Address", ); - let payload: vector = b"payload"; + let payload: vector = rng.generate_bytes(256); let version: u64 = 2; let message_ticket = new( diff --git a/move/axelar_gateway/sources/types/proof.move b/move/axelar_gateway/sources/types/proof.move index f0e8ea26..ac4625de 100644 --- a/move/axelar_gateway/sources/types/proof.move +++ b/move/axelar_gateway/sources/types/proof.move @@ -168,9 +168,8 @@ public(package) fun create_for_testing( #[test_only] public(package) fun dummy(): Proof { - let mut signature = sui::address::to_bytes(@0x01); - signature.append(sui::address::to_bytes(@0x23)); - signature.push_back(2); + let mut rng = sui::random::new_generator_for_testing(); + let signature = rng.generate_bytes(SIGNATURE_LENGTH as u16); Proof { signers: axelar_gateway::weighted_signers::dummy(), signatures: vector[Signature { bytes: signature }], @@ -203,12 +202,8 @@ public(package) fun generate( fun test_getters() { let proof = dummy(); - assert!(proof.signers() == axelar_gateway::weighted_signers::dummy()); - - let mut signature = sui::address::to_bytes(@0x01); - signature.append(sui::address::to_bytes(@0x23)); - signature.push_back(2); - assert!(proof.signatures() == vector[Signature { bytes: signature }]); + assert!(proof.signers() == proof.signers); + assert!(proof.signatures() == proof.signatures); } #[test] @@ -219,8 +214,9 @@ fun test_new_signature_invalid_signature_length() { #[test] fun test_recover_pub_key() { - let keypair = ecdsa::secp256k1_keypair_from_seed(&@0x1234.to_bytes()); - let message = @0x5678.to_bytes(); + let mut rng = sui::random::new_generator_for_testing(); + let keypair = ecdsa::secp256k1_keypair_from_seed(&rng.generate_bytes(32)); + let message = rng.generate_bytes(32); let signature = new_signature( ecdsa::secp256k1_sign(keypair.private_key(), &message, 0, true), ); @@ -229,13 +225,14 @@ fun test_recover_pub_key() { #[test] fun test_validate() { - let mut keypairs = vector[@0x1234, @0x5678, @0x9abc].map!( - |seed| ecdsa::secp256k1_keypair_from_seed(&seed.to_bytes()), + let mut rng = sui::random::new_generator_for_testing(); + let mut keypairs = vector[0, 1, 2].map!( + |_| ecdsa::secp256k1_keypair_from_seed(&rng.generate_bytes(32)), ); let pub_keys = keypairs.map_ref!(|keypair| *keypair.public_key()); - let weights = vector[123, 234, 456]; - let message = @0x5678.to_bytes(); - let nonce = axelar_gateway::bytes32::new(@0x0123); + let weights = vector[0, 1, 2].map!(|_| rng.generate_u64() as u128); + let message = rng.generate_bytes(32); + let nonce = axelar_gateway::bytes32::from_bytes(rng.generate_bytes(32)); let weighted_signers = axelar_gateway::weighted_signers::create_for_testing( vector[0, 1, 2].map!( @@ -255,13 +252,14 @@ fun test_validate() { #[test] #[expected_failure(abort_code = ERedundantSignaturesProvided)] fun test_validate_redundant_signatures() { - let keypairs = vector[@0x1234, @0x5678, @0x9abc].map!( - |seed| ecdsa::secp256k1_keypair_from_seed(&seed.to_bytes()), + let mut rng = sui::random::new_generator_for_testing(); + let keypairs = vector[0, 1, 2].map!( + |_| ecdsa::secp256k1_keypair_from_seed(&rng.generate_bytes(32)), ); let pub_keys = keypairs.map_ref!(|keypair| *keypair.public_key()); - let weights = vector[123, 234, 456]; - let message = @0x5678.to_bytes(); - let nonce = axelar_gateway::bytes32::new(@0x0123); + let weights = vector[0, 1, 2].map!(|_| rng.generate_u64() as u128); + let message = rng.generate_bytes(32); + let nonce = axelar_gateway::bytes32::from_bytes(rng.generate_bytes(32)); let weighted_signers = axelar_gateway::weighted_signers::create_for_testing( vector[0, 1, 2].map!( @@ -280,8 +278,9 @@ fun test_validate_redundant_signatures() { #[test] #[expected_failure(abort_code = ELowSignaturesWeight)] fun test_validate_empty_signers() { - let message = @0x5678.to_bytes(); - let nonce = axelar_gateway::bytes32::new(@0x0123); + let mut rng = sui::random::new_generator_for_testing(); + let message = rng.generate_bytes(32); + let nonce = axelar_gateway::bytes32::from_bytes(rng.generate_bytes(32)); let weighted_signers = axelar_gateway::weighted_signers::create_for_testing( vector[], 1, @@ -294,13 +293,14 @@ fun test_validate_empty_signers() { #[test] #[expected_failure(abort_code = ELowSignaturesWeight)] fun test_validate_low_signature_weight() { - let keypairs = vector[@0x1234, @0x5678, @0x9abc].map!( - |seed| ecdsa::secp256k1_keypair_from_seed(&seed.to_bytes()), + let mut rng = sui::random::new_generator_for_testing(); + let keypairs = vector[0, 1, 2].map!( + |_| ecdsa::secp256k1_keypair_from_seed(&rng.generate_bytes(32)), ); let pub_keys = keypairs.map_ref!(|keypair| *keypair.public_key()); - let weights = vector[123, 234, 456]; - let message = @0x5678.to_bytes(); - let nonce = axelar_gateway::bytes32::new(@0x0123); + let weights = vector[0, 1, 2].map!(|_| rng.generate_u64() as u128); + let message = rng.generate_bytes(32); + let nonce = axelar_gateway::bytes32::from_bytes(rng.generate_bytes(32)); let weighted_signers = axelar_gateway::weighted_signers::create_for_testing( vector[0, 1, 2].map!( @@ -327,13 +327,14 @@ fun test_validate_low_signature_weight() { #[test] #[expected_failure(abort_code = ESignerNotFound)] fun test_validate_signer_not_found() { - let keypairs = vector[@0x1234, @0x5678, @0x9abc].map!( - |seed| ecdsa::secp256k1_keypair_from_seed(&seed.to_bytes()), + let mut rng = sui::random::new_generator_for_testing(); + let keypairs = vector[0, 1, 2].map!( + |_| ecdsa::secp256k1_keypair_from_seed(&rng.generate_bytes(32)), ); let pub_keys = keypairs.map_ref!(|keypair| *keypair.public_key()); - let weights = vector[123, 234, 456]; - let message = @0x5678.to_bytes(); - let nonce = axelar_gateway::bytes32::new(@0x0123); + let weights = vector[0, 1, 2].map!(|_| rng.generate_u64() as u128); + let message = rng.generate_bytes(32); + let nonce = axelar_gateway::bytes32::from_bytes(rng.generate_bytes(32)); let weighted_signers = axelar_gateway::weighted_signers::create_for_testing( vector[0, 2].map!( diff --git a/move/axelar_gateway/sources/types/weighted_signer.move b/move/axelar_gateway/sources/types/weighted_signer.move index c7255efe..90d4479e 100644 --- a/move/axelar_gateway/sources/types/weighted_signer.move +++ b/move/axelar_gateway/sources/types/weighted_signer.move @@ -93,7 +93,8 @@ public(package) fun lt(self: &WeightedSigner, other: &WeightedSigner): bool { #[test] #[expected_failure(abort_code = EInvalidPubKeyLength)] fun test_new_incorrect_pubkey() { - new(vector[], 123u128); + let mut rng = sui::random::new_generator_for_testing(); + new(vector[], rng.generate_u128()); } #[test] @@ -109,7 +110,8 @@ fun test_validate_invalid_weight() { #[test] fun test_pub_key() { - let pub_key = vector[1u8, 2u8, 3u8]; + let mut rng = sui::random::new_generator_for_testing(); + let pub_key = rng.generate_bytes(3); assert!( &WeightedSigner { pub_key, diff --git a/move/axelar_gateway/sources/types/weighted_signers.move b/move/axelar_gateway/sources/types/weighted_signers.move index cf7671f8..51f6153a 100644 --- a/move/axelar_gateway/sources/types/weighted_signers.move +++ b/move/axelar_gateway/sources/types/weighted_signers.move @@ -15,13 +15,16 @@ public struct WeightedSigners has copy, drop, store { /// Errors /// ------ #[error] -const EInvalidSignersLength: vector = b"invalid signers length: expected at least 1 signer"; +const EInvalidSignersLength: vector = + b"invalid signers length: expected at least 1 signer"; #[error] -const EInvalidThreshold: vector = b"invalid threshold: expected non-zero value and less than or equal to the total weight of the signers"; +const EInvalidThreshold: vector = + b"invalid threshold: expected non-zero value and less than or equal to the total weight of the signers"; #[error] -const EInvalidSignerOrder: vector = b"invalid signer order: signers must be in ascending order by their public key"; +const EInvalidSignerOrder: vector = + b"invalid signer order: signers must be in ascending order by their public key"; /// ----------------- /// Package Functions @@ -74,28 +77,29 @@ public(package) fun nonce(self: &WeightedSigners): Bytes32 { fun validate_signers(self: &WeightedSigners) { assert!(!self.signers.is_empty(), EInvalidSignersLength); let mut previous = &weighted_signer::default(); - self.signers.do_ref!( - |signer| { - signer.validate(); - assert!(previous.lt(signer), EInvalidSignerOrder); - previous = signer; - }, - ); + self.signers.do_ref!(|signer| { + signer.validate(); + assert!(previous.lt(signer), EInvalidSignerOrder); + previous = signer; + }); } /// Calculates the total weight of the signers. fun total_weight(self: &WeightedSigners): u128 { - self.signers.fold!( - 0, - |acc, signer| acc + signer.weight(), - ) + self + .signers + .fold!(0, |acc, signer| acc + signer.weight()) } /// Validates the threshold. -/// The threshold must be greater than zero and less than or equal to the total weight of the signers. +/// The threshold must be greater than zero and less than or equal to the total +/// weight of the signers. /// Otherwise, the error `EInvalidThreshold` is raised. fun validate_threshold(self: &WeightedSigners) { - assert!(self.threshold != 0 && self.total_weight() >= self.threshold, EInvalidThreshold); + assert!( + self.threshold != 0 && self.total_weight() >= self.threshold, + EInvalidThreshold, + ); } #[test_only] @@ -113,44 +117,14 @@ public fun create_for_testing( #[test_only] public fun dummy(): WeightedSigners { - let pub_key = vector[ - 0, - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 11, - 12, - 13, - 14, - 15, - 16, - 17, - 18, - 19, - 20, - 21, - 22, - 23, - 24, - 25, - 26, - 27, - 28, - 29, - 30, - 31, - 32, - ]; - let signer = axelar_gateway::weighted_signer::new(pub_key, 123); - let nonce = bytes32::new(@3456); - let threshold = 100; + let mut rng = sui::random::new_generator_for_testing(); + let pub_key = rng.generate_bytes(33); + let signer = axelar_gateway::weighted_signer::new( + pub_key, + rng.generate_u128(), + ); + let nonce = bytes32::from_bytes(rng.generate_bytes(32)); + let threshold = signer.weight(); WeightedSigners { signers: vector[signer], threshold, @@ -158,24 +132,24 @@ public fun dummy(): WeightedSigners { } } - #[test] fun tent_nonce() { let weighted_signers = dummy(); - assert!(weighted_signers.nonce() == bytes32::new(@3456)); + assert!(weighted_signers.nonce() == weighted_signers.nonce); } #[test] #[expected_failure(abort_code = EInvalidSignersLength)] fun test_peel_invalid_signers_length() { + let mut rng = sui::random::new_generator_for_testing(); let mut bcs = bcs::new( bcs::to_bytes( &WeightedSigners { signers: vector[], - threshold: 0, - nonce: bytes32::new(@0x0), - } - ) + threshold: rng.generate_u128(), + nonce: bytes32::from_bytes(rng.generate_bytes(32)), + }, + ), ); peel(&mut bcs); } @@ -183,16 +157,18 @@ fun test_peel_invalid_signers_length() { #[test] #[expected_failure(abort_code = EInvalidSignersLength)] fun test_validate_signers_invalid_signers_length() { + let mut rng = sui::random::new_generator_for_testing(); WeightedSigners { signers: vector[], - threshold: 0, - nonce: bytes32::new(@0x0), + threshold: rng.generate_u128(), + nonce: bytes32::from_bytes(rng.generate_bytes(32)), }.validate_signers(); } #[test] #[expected_failure(abort_code = EInvalidSignerOrder)] fun test_validate_signers_invalid_signer_order() { + let mut rng = sui::random::new_generator_for_testing(); let mut pub_key = @0x0.to_bytes(); pub_key.push_back(2); let signer1 = axelar_gateway::weighted_signer::new(pub_key, 1); @@ -201,30 +177,31 @@ fun test_validate_signers_invalid_signer_order() { let signer2 = axelar_gateway::weighted_signer::new(pub_key, 1); WeightedSigners { signers: vector[signer1, signer2], - threshold: 1, - nonce: bytes32::new(@0x0), + threshold: rng.generate_u128(), + nonce: bytes32::from_bytes(rng.generate_bytes(32)), }.validate_signers(); } #[test] #[expected_failure(abort_code = EInvalidThreshold)] fun test_validate_zero_threshold() { + let mut rng = sui::random::new_generator_for_testing(); WeightedSigners { signers: vector[], threshold: 0, - nonce: bytes32::new(@0x0), + nonce: bytes32::from_bytes(rng.generate_bytes(32)), }.validate_threshold(); } #[test] #[expected_failure(abort_code = EInvalidThreshold)] fun test_validate_threshold_above_weight_sum() { - let mut pub_key = @0x0.to_bytes(); - pub_key.push_back(2); - let signer = axelar_gateway::weighted_signer::new(pub_key, 0); + let mut rng = sui::random::new_generator_for_testing(); + let pub_key = rng.generate_bytes(33); + let signer = axelar_gateway::weighted_signer::new(pub_key, 1); WeightedSigners { signers: vector[signer], threshold: 2, - nonce: bytes32::new(@0x0), + nonce: bytes32::from_bytes(rng.generate_bytes(32)), }.validate_threshold(); } diff --git a/move/axelar_gateway/sources/versioned/gateway_v0.move b/move/axelar_gateway/sources/versioned/gateway_v0.move index d0fb16bc..15193647 100644 --- a/move/axelar_gateway/sources/versioned/gateway_v0.move +++ b/move/axelar_gateway/sources/versioned/gateway_v0.move @@ -356,13 +356,14 @@ fun test_peel_messages_no_zero_messages() { #[test] fun test_approve_message() { + let mut rng = sui::random::new_generator_for_testing(); let ctx = &mut sui::tx_context::dummy(); let message_id = std::ascii::string(b"Message Id"); let channel = axelar_gateway::channel::new(ctx); let source_chain = std::ascii::string(b"Source Chain"); let source_address = std::ascii::string(b"Destination Address"); - let payload = vector[0, 1, 2, 3]; + let payload = rng.generate_bytes(32); let payload_hash = axelar_gateway::bytes32::new( sui::address::from_bytes(hash::keccak256(&payload)), ); @@ -483,7 +484,8 @@ fun test_command_type_as_u8() { #[test] fun test_data_hash() { - let data = vector[0, 1, 2, 3]; + let mut rng = sui::random::new_generator_for_testing(); + let data = rng.generate_bytes(32); let mut typed_data = vector::singleton(CommandType::ApproveMessages.as_u8()); typed_data.append(data); @@ -497,10 +499,11 @@ fun test_data_hash() { #[test] #[expected_failure(abort_code = ENewerMessage)] fun test_send_message_newer_message() { - let source_id = @0x1; + let mut rng = sui::random::new_generator_for_testing(); + let source_id = address::from_u256(rng.generate_u256()); let destination_chain = std::ascii::string(b"Destination Chain"); let destination_address = std::ascii::string(b"Destination Address"); - let payload = b"payload"; + let payload = rng.generate_bytes(32); let version = 1; let message = axelar_gateway::message_ticket::new( source_id, @@ -518,11 +521,12 @@ fun test_send_message_newer_message() { #[test] #[expected_failure(abort_code = EMessageNotApproved)] fun test_take_approved_message_message_not_approved() { - let destination_id = @0x1; + let mut rng = sui::random::new_generator_for_testing(); + let destination_id = address::from_u256(rng.generate_u256()); let source_chain = std::ascii::string(b"Source Chain"); let source_address = std::ascii::string(b"Source Address"); let message_id = std::ascii::string(b"Message Id"); - let payload = b"payload"; + let payload = rng.generate_bytes(32); let command_id = message::message_to_command_id(source_chain, message_id); let ctx = &mut sui::tx_context::dummy();