diff --git a/packages/account/src/tests/test_account.cairo b/packages/account/src/tests/test_account.cairo index 7af00ef4a..d71acc1f0 100644 --- a/packages/account/src/tests/test_account.cairo +++ b/packages/account/src/tests/test_account.cairo @@ -294,7 +294,7 @@ fn test_multicall() { let address = utils::declare_and_deploy("SimpleMock", calldata); let simple_mock = ISimpleMockDispatcher { contract_address: address }; - // Craft call1 + // Craft 1st call let amount1 = 300; let calldata1 = array![amount1]; let call1 = Call { @@ -303,7 +303,7 @@ fn test_multicall() { calldata: calldata1.span() }; - // Craft call2 + // Craft 2nd call let amount2 = 500; let calldata2 = array![amount2]; let call2 = Call { diff --git a/packages/account/src/tests/test_dual_eth_account.cairo b/packages/account/src/tests/test_dual_eth_account.cairo index dcb6c714d..165442cef 100644 --- a/packages/account/src/tests/test_dual_eth_account.cairo +++ b/packages/account/src/tests/test_dual_eth_account.cairo @@ -1,13 +1,13 @@ -use openzeppelin_account::dual_eth_account::{DualCaseEthAccountABI, DualCaseEthAccount}; +use openzeppelin_account::dual_eth_account::{DualCaseEthAccount, DualCaseEthAccountABI}; use openzeppelin_account::interface::{EthAccountABIDispatcherTrait, EthAccountABIDispatcher}; use openzeppelin_account::utils::secp256k1::{DebugSecp256k1Point, Secp256k1PointPartialEq}; use openzeppelin_introspection::interface::ISRC5_ID; use openzeppelin_test_common::eth_account::get_accept_ownership_signature; use openzeppelin_testing as utils; -use openzeppelin_testing::constants::secp256k1::KEY_PAIR; -use openzeppelin_testing::constants::{ETH_PUBKEY, NEW_ETH_PUBKEY, TRANSACTION_HASH}; -use openzeppelin_testing::signing::Secp256k1SerializedSigning; +use openzeppelin_testing::constants::TRANSACTION_HASH; +use openzeppelin_testing::constants::secp256k1::{KEY_PAIR, KEY_PAIR_2}; +use openzeppelin_testing::signing::{Secp256k1KeyPair, Secp256k1SerializedSigning}; use openzeppelin_utils::serde::SerializedAppend; use snforge_std::start_cheat_caller_address; @@ -15,32 +15,26 @@ use snforge_std::start_cheat_caller_address; // Setup // -fn setup_snake() -> (DualCaseEthAccount, EthAccountABIDispatcher) { +fn setup_snake(key_pair: Secp256k1KeyPair) -> (DualCaseEthAccount, EthAccountABIDispatcher) { let mut calldata = array![]; - calldata.append_serde(ETH_PUBKEY()); + calldata.append_serde(key_pair.public_key); - let target = utils::declare_and_deploy("SnakeEthAccountMock", calldata); - ( - DualCaseEthAccount { contract_address: target }, - EthAccountABIDispatcher { contract_address: target } - ) + let contract_address = utils::declare_and_deploy("SnakeEthAccountMock", calldata); + (DualCaseEthAccount { contract_address }, EthAccountABIDispatcher { contract_address }) } -fn setup_camel() -> (DualCaseEthAccount, EthAccountABIDispatcher) { +fn setup_camel(key_pair: Secp256k1KeyPair) -> (DualCaseEthAccount, EthAccountABIDispatcher) { let mut calldata = array![]; - calldata.append_serde(ETH_PUBKEY()); + calldata.append_serde(key_pair.public_key); - let target = utils::declare_and_deploy("CamelEthAccountMock", calldata); - ( - DualCaseEthAccount { contract_address: target }, - EthAccountABIDispatcher { contract_address: target } - ) + let contract_address = utils::declare_and_deploy("CamelEthAccountMock", calldata); + (DualCaseEthAccount { contract_address }, EthAccountABIDispatcher { contract_address }) } fn setup_non_account() -> DualCaseEthAccount { let calldata = array![]; - let target = utils::declare_and_deploy("NonImplementingMock", calldata); - DualCaseEthAccount { contract_address: target } + let contract_address = utils::declare_and_deploy("NonImplementingMock", calldata); + DualCaseEthAccount { contract_address } } fn setup_account_panic() -> (DualCaseEthAccount, DualCaseEthAccount) { @@ -58,16 +52,18 @@ fn setup_account_panic() -> (DualCaseEthAccount, DualCaseEthAccount) { #[test] fn test_dual_set_public_key() { - let (snake_dispatcher, target) = setup_snake(); + let key_pair = KEY_PAIR(); + let (snake_dispatcher, target) = setup_snake(key_pair); let contract_address = snake_dispatcher.contract_address; + let new_key_pair = KEY_PAIR_2(); start_cheat_caller_address(contract_address, contract_address); + let signature = get_accept_ownership_signature( + contract_address, key_pair.public_key, new_key_pair + ); + snake_dispatcher.set_public_key(new_key_pair.public_key, signature); - let key_pair = KEY_PAIR(); - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); - - snake_dispatcher.set_public_key(key_pair.public_key, signature); - assert_eq!(target.get_public_key(), key_pair.public_key); + assert_eq!(target.get_public_key(), new_key_pair.public_key); } #[test] @@ -75,20 +71,21 @@ fn test_dual_set_public_key() { #[should_panic(expected: ('ENTRYPOINT_NOT_FOUND',))] fn test_dual_no_set_public_key() { let dispatcher = setup_non_account(); - dispatcher.set_public_key(NEW_ETH_PUBKEY(), array![].span()); + dispatcher.set_public_key(KEY_PAIR().public_key, array![].span()); } #[test] #[should_panic(expected: ("Some error",))] fn test_dual_set_public_key_exists_and_panics() { let (dispatcher, _) = setup_account_panic(); - dispatcher.set_public_key(NEW_ETH_PUBKEY(), array![].span()); + dispatcher.set_public_key(KEY_PAIR().public_key, array![].span()); } #[test] fn test_dual_get_public_key() { - let (snake_dispatcher, _) = setup_snake(); - assert_eq!(snake_dispatcher.get_public_key(), ETH_PUBKEY()); + let key_pair = KEY_PAIR(); + let (snake_dispatcher, _) = setup_snake(key_pair); + assert_eq!(snake_dispatcher.get_public_key(), key_pair.public_key); } #[test] @@ -108,16 +105,10 @@ fn test_dual_get_public_key_exists_and_panics() { #[test] fn test_dual_is_valid_signature() { - let (snake_dispatcher, target) = setup_snake(); - let contract_address = snake_dispatcher.contract_address; - - start_cheat_caller_address(contract_address, contract_address); let key_pair = KEY_PAIR(); - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); + let (snake_dispatcher, _) = setup_snake(key_pair); - target.set_public_key(key_pair.public_key, signature); let serialized_signature = key_pair.serialized_sign(TRANSACTION_HASH.into()); - let is_valid = snake_dispatcher.is_valid_signature(TRANSACTION_HASH, serialized_signature); assert_eq!(is_valid, starknet::VALIDATED); } @@ -126,26 +117,24 @@ fn test_dual_is_valid_signature() { #[ignore] // REASON: should_panic attribute not fit for complex panic messages. #[should_panic(expected: ('ENTRYPOINT_NOT_FOUND',))] fn test_dual_no_is_valid_signature() { - let hash = 0x0; let signature = array![]; let dispatcher = setup_non_account(); - dispatcher.is_valid_signature(hash, signature); + dispatcher.is_valid_signature(TRANSACTION_HASH, signature); } #[test] #[should_panic(expected: ("Some error",))] fn test_dual_is_valid_signature_exists_and_panics() { - let hash = 0x0; let signature = array![]; let (dispatcher, _) = setup_account_panic(); - dispatcher.is_valid_signature(hash, signature); + dispatcher.is_valid_signature(TRANSACTION_HASH, signature); } #[test] fn test_dual_supports_interface() { - let (snake_dispatcher, _) = setup_snake(); + let (snake_dispatcher, _) = setup_snake(KEY_PAIR()); assert!(snake_dispatcher.supports_interface(ISRC5_ID), "Should implement ISRC5"); } @@ -171,16 +160,18 @@ fn test_dual_supports_interface_exists_and_panics() { #[test] #[ignore] // REASON: foundry entrypoint_not_found error message inconsistent with mainnet. fn test_dual_setPublicKey() { - let (camel_dispatcher, target) = setup_camel(); + let key_pair = KEY_PAIR(); + let (camel_dispatcher, target) = setup_camel(key_pair); let contract_address = camel_dispatcher.contract_address; start_cheat_caller_address(contract_address, contract_address); + let new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + contract_address, key_pair.public_key, new_key_pair + ); - let key_pair = KEY_PAIR(); - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); - - camel_dispatcher.set_public_key(key_pair.public_key, signature); - assert_eq!(target.getPublicKey(), key_pair.public_key); + camel_dispatcher.set_public_key(new_key_pair.public_key, signature); + assert_eq!(target.getPublicKey(), new_key_pair.public_key); } #[test] @@ -188,14 +179,15 @@ fn test_dual_setPublicKey() { #[should_panic(expected: ("Some error",))] fn test_dual_setPublicKey_exists_and_panics() { let (_, dispatcher) = setup_account_panic(); - dispatcher.set_public_key(NEW_ETH_PUBKEY(), array![].span()); + dispatcher.set_public_key(KEY_PAIR_2().public_key, array![].span()); } #[test] #[ignore] // REASON: foundry entrypoint_not_found error message inconsistent with mainnet. fn test_dual_getPublicKey() { - let (camel_dispatcher, _) = setup_camel(); - assert_eq!(camel_dispatcher.get_public_key(), ETH_PUBKEY()); + let key_pair = KEY_PAIR(); + let (camel_dispatcher, _) = setup_camel(key_pair); + assert_eq!(camel_dispatcher.get_public_key(), key_pair.public_key); } #[test] @@ -209,17 +201,10 @@ fn test_dual_getPublicKey_exists_and_panics() { #[test] #[ignore] // REASON: foundry entrypoint_not_found error message inconsistent with mainnet. fn test_dual_isValidSignature() { - let (camel_dispatcher, target) = setup_camel(); - let contract_address = camel_dispatcher.contract_address; - - start_cheat_caller_address(contract_address, contract_address); - let key_pair = KEY_PAIR(); - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); + let (camel_dispatcher, _) = setup_camel(key_pair); - target.setPublicKey(key_pair.public_key, signature); let serialized_signature = key_pair.serialized_sign(TRANSACTION_HASH.into()); - let is_valid = camel_dispatcher.is_valid_signature(TRANSACTION_HASH, serialized_signature); assert_eq!(is_valid, starknet::VALIDATED); } @@ -228,9 +213,8 @@ fn test_dual_isValidSignature() { #[ignore] // REASON: foundry entrypoint_not_found error message inconsistent with mainnet. #[should_panic(expected: ("Some error",))] fn test_dual_isValidSignature_exists_and_panics() { - let hash = 0x0; let signature = array![]; let (_, dispatcher) = setup_account_panic(); - dispatcher.is_valid_signature(hash, signature); + dispatcher.is_valid_signature(TRANSACTION_HASH, signature); } diff --git a/packages/account/src/tests/test_eth_account.cairo b/packages/account/src/tests/test_eth_account.cairo index 9bf2b8671..093c1b49a 100644 --- a/packages/account/src/tests/test_eth_account.cairo +++ b/packages/account/src/tests/test_eth_account.cairo @@ -16,11 +16,11 @@ use openzeppelin_test_common::eth_account::{ SIGNED_TX_DATA, SignedTransactionData, get_accept_ownership_signature }; use openzeppelin_testing as utils; -use openzeppelin_testing::constants::secp256k1::KEY_PAIR; +use openzeppelin_testing::constants::secp256k1::{KEY_PAIR, KEY_PAIR_2}; use openzeppelin_testing::constants::{ - ETH_PUBKEY, NEW_ETH_PUBKEY, SALT, ZERO, OTHER, RECIPIENT, CALLER, QUERY_VERSION, - MIN_TRANSACTION_VERSION + SALT, ZERO, OTHER, RECIPIENT, CALLER, QUERY_VERSION, MIN_TRANSACTION_VERSION }; +use openzeppelin_testing::signing::Secp256k1KeyPair; use openzeppelin_utils::selectors; use openzeppelin_utils::serde::SerializedAppend; use snforge_std::{ @@ -44,32 +44,27 @@ fn COMPONENT_STATE() -> ComponentState { EthAccountComponent::component_state_for_testing() } -fn setup() -> ComponentState { +fn setup(key_pair: Secp256k1KeyPair) -> ComponentState { let mut state = COMPONENT_STATE(); - state.initializer(ETH_PUBKEY()); + state.initializer(key_pair.public_key); state } -fn setup_dispatcher(data: Option<@SignedTransactionData>) -> (EthAccountABIDispatcher, felt252) { +fn setup_dispatcher( + key_pair: Secp256k1KeyPair, data: SignedTransactionData +) -> (EthAccountABIDispatcher, felt252) { let mut calldata = array![]; - if let Option::Some(data) = data { - let mut serialized_signature = array![]; - data.signature.serialize(ref serialized_signature); - - cheat_signature_global(serialized_signature.span()); - cheat_transaction_hash_global(*data.tx_hash); - - calldata.append_serde(*data.public_key); - } else { - calldata.append_serde(ETH_PUBKEY()); - }; - + calldata.append_serde(key_pair.public_key); let contract_class = utils::declare_class("DualCaseEthAccountMock"); - let address = utils::deploy(contract_class, calldata); - let dispatcher = EthAccountABIDispatcher { contract_address: address }; + let contract_address = utils::deploy(contract_class, calldata); + let dispatcher = EthAccountABIDispatcher { contract_address }; + let mut serialized_signature = array![]; + data.signature.serialize(ref serialized_signature); + cheat_signature_global(serialized_signature.span()); + cheat_transaction_hash_global(data.tx_hash); cheat_transaction_version_global(MIN_TRANSACTION_VERSION); - start_cheat_caller_address(address, ZERO()); + start_cheat_caller_address(contract_address, ZERO()); (dispatcher, contract_class.class_hash.into()) } @@ -81,8 +76,8 @@ fn setup_dispatcher(data: Option<@SignedTransactionData>) -> (EthAccountABIDispa #[test] fn test_is_valid_signature() { let mut state = COMPONENT_STATE(); - let data = SIGNED_TX_DATA(KEY_PAIR()); - let hash = data.tx_hash; + let key_pair = KEY_PAIR(); + let data = SIGNED_TX_DATA(key_pair); let mut bad_signature = data.signature; bad_signature.r += 1; @@ -93,20 +88,20 @@ fn test_is_valid_signature() { data.signature.serialize(ref serialized_good_signature); bad_signature.serialize(ref serialized_bad_signature); - state.initializer(data.public_key); + state.initializer(key_pair.public_key); - let is_valid = state.is_valid_signature(hash, serialized_good_signature); + let is_valid = state.is_valid_signature(data.tx_hash, serialized_good_signature); assert_eq!(is_valid, starknet::VALIDATED); - let is_valid = state.is_valid_signature(hash, serialized_bad_signature); + let is_valid = state.is_valid_signature(data.tx_hash, serialized_bad_signature); assert_eq!(is_valid, 0, "Should reject invalid signature"); } #[test] fn test_isValidSignature() { let mut state = COMPONENT_STATE(); - let data = SIGNED_TX_DATA(KEY_PAIR()); - let hash = data.tx_hash; + let key_pair = KEY_PAIR(); + let data = SIGNED_TX_DATA(key_pair); let mut bad_signature = data.signature; @@ -118,12 +113,12 @@ fn test_isValidSignature() { data.signature.serialize(ref serialized_good_signature); bad_signature.serialize(ref serialized_bad_signature); - state.initializer(data.public_key); + state.initializer(key_pair.public_key); - let is_valid = state.isValidSignature(hash, serialized_good_signature); + let is_valid = state.isValidSignature(data.tx_hash, serialized_good_signature); assert_eq!(is_valid, starknet::VALIDATED); - let is_valid = state.isValidSignature(hash, serialized_bad_signature); + let is_valid = state.isValidSignature(data.tx_hash, serialized_bad_signature); assert_eq!(is_valid, 0, "Should reject invalid signature"); } @@ -133,49 +128,54 @@ fn test_isValidSignature() { #[test] fn test_validate_deploy() { - let (account, class_hash) = setup_dispatcher(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); // `__validate_deploy__` does not directly use the passed arguments. Their // values are already integrated in the tx hash. The passed arguments in this // testing context are decoupled from the signature and have no effect on the test. - let is_valid = account.__validate_deploy__(class_hash, SALT, ETH_PUBKEY()); + let is_valid = account.__validate_deploy__(class_hash, SALT, key_pair.public_key); assert_eq!(is_valid, starknet::VALIDATED); } #[test] #[should_panic(expected: ('EthAccount: invalid signature',))] fn test_validate_deploy_invalid_signature_data() { - let mut data = SIGNED_TX_DATA(KEY_PAIR()); + let key_pair = KEY_PAIR(); + let mut data = SIGNED_TX_DATA(key_pair); data.tx_hash += 1; - let (account, class_hash) = setup_dispatcher(Option::Some(@data)); + let (account, class_hash) = setup_dispatcher(key_pair, data); - account.__validate_deploy__(class_hash, SALT, ETH_PUBKEY()); + account.__validate_deploy__(class_hash, SALT, key_pair.public_key); } #[test] #[should_panic(expected: ('Signature: Invalid format.',))] fn test_validate_deploy_invalid_signature_length() { - let (account, class_hash) = setup_dispatcher(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); - let signature = array![0x1]; + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); - cheat_signature_global(signature.span()); + let invalid_len_sig = array!['INVALID_LEN']; + cheat_signature_global(invalid_len_sig.span()); - account.__validate_deploy__(class_hash, SALT, ETH_PUBKEY()); + account.__validate_deploy__(class_hash, SALT, key_pair.public_key); } #[test] #[should_panic(expected: ('Signature: Invalid format.',))] fn test_validate_deploy_empty_signature() { - let (account, class_hash) = setup_dispatcher(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); let empty_sig = array![]; cheat_signature_global(empty_sig.span()); - account.__validate_deploy__(class_hash, SALT, ETH_PUBKEY()); + account.__validate_deploy__(class_hash, SALT, key_pair.public_key); } #[test] fn test_validate_declare() { - let (account, class_hash) = setup_dispatcher(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); // `__validate_declare__` does not directly use the class_hash argument. Its // value is already integrated in the tx hash. The class_hash argument in this @@ -187,9 +187,10 @@ fn test_validate_declare() { #[test] #[should_panic(expected: ('EthAccount: invalid signature',))] fn test_validate_declare_invalid_signature_data() { - let mut data = SIGNED_TX_DATA(KEY_PAIR()); + let key_pair = KEY_PAIR(); + let mut data = SIGNED_TX_DATA(key_pair); data.tx_hash += 1; - let (account, class_hash) = setup_dispatcher(Option::Some(@data)); + let (account, class_hash) = setup_dispatcher(key_pair, data); account.__validate_declare__(class_hash); } @@ -197,11 +198,11 @@ fn test_validate_declare_invalid_signature_data() { #[test] #[should_panic(expected: ('Signature: Invalid format.',))] fn test_validate_declare_invalid_signature_length() { - let (account, class_hash) = setup_dispatcher(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); - let mut signature = array![]; + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); - signature.append(0x1); - cheat_signature_global(signature.span()); + let invalid_len_sig = array!['INVALID_LEN']; + cheat_signature_global(invalid_len_sig.span()); account.__validate_declare__(class_hash); } @@ -209,7 +210,8 @@ fn test_validate_declare_invalid_signature_length() { #[test] #[should_panic(expected: ('Signature: Invalid format.',))] fn test_validate_declare_empty_signature() { - let (account, class_hash) = setup_dispatcher(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); let empty_sig = array![]; cheat_signature_global(empty_sig.span()); @@ -218,8 +220,9 @@ fn test_validate_declare_empty_signature() { } fn test_execute_with_version(version: Option) { - let data = SIGNED_TX_DATA(KEY_PAIR()); - let (account, _) = setup_dispatcher(Option::Some(@data)); + let key_pair = KEY_PAIR(); + let data = SIGNED_TX_DATA(key_pair); + let (account, _) = setup_dispatcher(key_pair, data); // Deploy target contract let calldata = array![]; @@ -255,7 +258,7 @@ fn test_execute_with_version(version: Option) { #[test] fn test_execute() { - test_execute_with_version(Option::None(())); + test_execute_with_version(Option::None); } #[test] @@ -271,8 +274,9 @@ fn test_execute_invalid_version() { #[test] fn test_validate() { + let key_pair = KEY_PAIR(); let calls = array![]; - let (account, _) = setup_dispatcher(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); + let (account, _) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); let is_valid = account.__validate__(calls); assert_eq!(is_valid, starknet::VALIDATED); @@ -281,24 +285,26 @@ fn test_validate() { #[test] #[should_panic(expected: ('EthAccount: invalid signature',))] fn test_validate_invalid() { - let calls = array![]; - let mut data = SIGNED_TX_DATA(KEY_PAIR()); + let key_pair = KEY_PAIR(); + let mut data = SIGNED_TX_DATA(key_pair); data.tx_hash += 1; - let (account, _) = setup_dispatcher(Option::Some(@data)); + let (account, _) = setup_dispatcher(key_pair, data); + let calls = array![]; account.__validate__(calls); } #[test] fn test_multicall() { - let (account, _) = setup_dispatcher(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); + let key_pair = KEY_PAIR(); + let (account, _) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); // Deploy target contract let calldata = array![]; let address = utils::declare_and_deploy("SimpleMock", calldata); let simple_mock = ISimpleMockDispatcher { contract_address: address }; - // Craft call1 + // Craft 1st call let amount1 = 300; let calldata1 = array![amount1]; let call1 = Call { @@ -307,7 +313,7 @@ fn test_multicall() { calldata: calldata1.span() }; - // Craft call2 + // Craft 2nd call let amount2 = 500; let calldata2 = array![amount2]; let call2 = Call { @@ -326,17 +332,19 @@ fn test_multicall() { // Test return value let mut call1_serialized_retval = *ret.at(0); - let mut call2_serialized_retval = *ret.at(1); let call1_retval = Serde::::deserialize(ref call1_serialized_retval); - let call2_retval = Serde::::deserialize(ref call2_serialized_retval); assert!(call1_retval.unwrap()); + + let mut call2_serialized_retval = *ret.at(1); + let call2_retval = Serde::::deserialize(ref call2_serialized_retval); assert!(call2_retval.unwrap()); } #[test] fn test_multicall_zero_calls() { - let (account, _) = setup_dispatcher(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); - let mut calls = array![]; + let key_pair = KEY_PAIR(); + let (account, _) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); + let calls = array![]; let ret = account.__execute__(calls); @@ -347,9 +355,10 @@ fn test_multicall_zero_calls() { #[test] #[should_panic(expected: ('EthAccount: invalid caller',))] fn test_account_called_from_contract() { - let state = setup(); - let calls = array![]; + let key_pair = KEY_PAIR(); + let state = setup(key_pair); + let calls = array![]; start_cheat_caller_address(test_address(), CALLER()); state.__execute__(calls); } @@ -361,44 +370,44 @@ fn test_account_called_from_contract() { #[test] #[should_panic(expected: ('Secp256k1Point: Invalid point.',))] fn test_cannot_get_without_initialize() { - let mut state = COMPONENT_STATE(); + let state = COMPONENT_STATE(); state.get_public_key(); } #[test] #[should_panic(expected: ('Secp256k1Point: Invalid point.',))] fn test_cannot_set_without_initialize() { + let key_pair = KEY_PAIR(); let mut state = COMPONENT_STATE(); start_cheat_caller_address(test_address(), test_address()); - state.set_public_key(NEW_ETH_PUBKEY(), array![].span()); + state.set_public_key(key_pair.public_key, array![].span()); } #[test] fn test_public_key_setter_and_getter() { let mut state = COMPONENT_STATE(); - let public_key = ETH_PUBKEY(); let key_pair = KEY_PAIR(); let contract_address = test_address(); start_cheat_caller_address(contract_address, contract_address); - state.initializer(public_key); + state.initializer(key_pair.public_key); // Check default - let current = state.get_public_key(); - assert_eq!(current, public_key); - - let mut spy = spy_events(); + assert_eq!(state.get_public_key(), key_pair.public_key); // Set key - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); - state.set_public_key(key_pair.public_key, signature); + let mut spy = spy_events(); + let new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + contract_address, key_pair.public_key, new_key_pair + ); + state.set_public_key(new_key_pair.public_key, signature); - spy.assert_event_owner_removed(contract_address, current); - spy.assert_only_event_owner_added(contract_address, key_pair.public_key); + spy.assert_event_owner_removed(contract_address, key_pair.public_key); + spy.assert_only_event_owner_added(contract_address, new_key_pair.public_key); - let public_key = state.get_public_key(); - assert_eq!(public_key, key_pair.public_key); + assert_eq!(state.get_public_key(), new_key_pair.public_key); } #[test] @@ -410,8 +419,11 @@ fn test_public_key_setter_different_account() { start_cheat_caller_address(contract_address, CALLER()); - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); - state.set_public_key(key_pair.public_key, signature); + let new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + contract_address, key_pair.public_key, new_key_pair + ); + state.set_public_key(new_key_pair.public_key, signature); } // @@ -421,26 +433,25 @@ fn test_public_key_setter_different_account() { #[test] fn test_public_key_setter_and_getter_camel() { let mut state = COMPONENT_STATE(); - let public_key = ETH_PUBKEY(); let key_pair = KEY_PAIR(); let contract_address = test_address(); start_cheat_caller_address(contract_address, contract_address); - state.initializer(public_key); + state.initializer(key_pair.public_key); - let current = state.getPublicKey(); - assert_eq!(current, public_key); + assert_eq!(state.getPublicKey(), key_pair.public_key); let mut spy = spy_events(); + let new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + contract_address, key_pair.public_key, new_key_pair + ); + state.setPublicKey(new_key_pair.public_key, signature); - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); - state.setPublicKey(key_pair.public_key, signature); - - spy.assert_event_owner_removed(contract_address, public_key); - spy.assert_only_event_owner_added(contract_address, key_pair.public_key); + spy.assert_event_owner_removed(contract_address, key_pair.public_key); + spy.assert_only_event_owner_added(contract_address, new_key_pair.public_key); - let public_key = state.getPublicKey(); - assert_eq!(public_key, key_pair.public_key); + assert_eq!(state.getPublicKey(), new_key_pair.public_key); } #[test] @@ -452,8 +463,11 @@ fn test_public_key_setter_different_account_camel() { start_cheat_caller_address(contract_address, CALLER()); - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); - state.setPublicKey(key_pair.public_key, signature); + let new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + contract_address, key_pair.public_key, new_key_pair + ); + state.setPublicKey(new_key_pair.public_key, signature); } // @@ -464,14 +478,14 @@ fn test_public_key_setter_different_account_camel() { fn test_initializer() { let mut state = COMPONENT_STATE(); let mock_state = CONTRACT_STATE(); - let public_key = ETH_PUBKEY(); + let key_pair = KEY_PAIR(); let mut spy = spy_events(); - state.initializer(public_key); + state.initializer(key_pair.public_key); - spy.assert_only_event_owner_added(test_address(), public_key); + spy.assert_only_event_owner_added(test_address(), key_pair.public_key); - assert_eq!(state.get_public_key(), public_key); + assert_eq!(state.get_public_key(), key_pair.public_key); let supports_default_interface = mock_state.supports_interface(ISRC5_ID); assert!(supports_default_interface, "Should support ISRC5"); @@ -482,7 +496,7 @@ fn test_initializer() { #[test] fn test_assert_only_self_true() { - let mut state = COMPONENT_STATE(); + let state = COMPONENT_STATE(); start_cheat_caller_address(test_address(), test_address()); state.assert_only_self(); @@ -491,7 +505,7 @@ fn test_assert_only_self_true() { #[test] #[should_panic(expected: ('EthAccount: unauthorized',))] fn test_assert_only_self_false() { - let mut state = COMPONENT_STATE(); + let state = COMPONENT_STATE(); start_cheat_caller_address(test_address(), OTHER()); state.assert_only_self(); @@ -499,35 +513,38 @@ fn test_assert_only_self_false() { #[test] fn test_assert_valid_new_owner() { - let mut state = setup(); + let key_pair = KEY_PAIR(); + let state = setup(key_pair); let contract_address = test_address(); - let key_pair = KEY_PAIR(); - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); + let new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + contract_address, key_pair.public_key, new_key_pair + ); - state.assert_valid_new_owner(ETH_PUBKEY(), key_pair.public_key, signature); + state.assert_valid_new_owner(key_pair.public_key, new_key_pair.public_key, signature); } #[test] #[should_panic(expected: ('EthAccount: invalid signature',))] fn test_assert_valid_new_owner_invalid_signature() { - let mut state = setup(); + let key_pair = KEY_PAIR(); + let state = setup(key_pair); start_cheat_caller_address(test_address(), test_address()); let mut bad_signature = array![]; - EthSignature { - r: 0xe2c02fbaa03809019ce6501cb5e57fc4a1e96e09dd8becfde8508ceddb53330b, - s: 0x6811f854c0f5793a0086f53e4a23c3773fd8afee401b1c4ef148a1554eede5e1, - } - .serialize(ref bad_signature); - state.assert_valid_new_owner(ETH_PUBKEY(), NEW_ETH_PUBKEY(), bad_signature.span()); + EthSignature { r: 'BAD'.into(), s: 'SIG'.into() }.serialize(ref bad_signature); + let new_key_pair = KEY_PAIR_2(); + + state + .assert_valid_new_owner(key_pair.public_key, new_key_pair.public_key, bad_signature.span()); } #[test] fn test__is_valid_signature() { + let key_pair = KEY_PAIR(); let mut state = COMPONENT_STATE(); - let data = SIGNED_TX_DATA(KEY_PAIR()); - let hash = data.tx_hash; + let data = SIGNED_TX_DATA(key_pair); let mut bad_signature = data.signature; @@ -539,25 +556,24 @@ fn test__is_valid_signature() { data.signature.serialize(ref serialized_good_signature); bad_signature.serialize(ref serialized_bad_signature); - state.initializer(data.public_key); + state.initializer(key_pair.public_key); - let is_valid = state._is_valid_signature(hash, serialized_good_signature.span()); + let is_valid = state._is_valid_signature(data.tx_hash, serialized_good_signature.span()); assert!(is_valid); - let is_not_valid = !state._is_valid_signature(hash, serialized_bad_signature.span()); + let is_not_valid = !state._is_valid_signature(data.tx_hash, serialized_bad_signature.span()); assert!(is_not_valid); } #[test] fn test__set_public_key() { + let key_pair = KEY_PAIR(); let mut state = COMPONENT_STATE(); - let public_key = ETH_PUBKEY(); let mut spy = spy_events(); - state._set_public_key(public_key); + state._set_public_key(key_pair.public_key); - spy.assert_only_event_owner_added(test_address(), public_key); + spy.assert_only_event_owner_added(test_address(), key_pair.public_key); - let public_key = state.get_public_key(); - assert_eq!(public_key, ETH_PUBKEY()); + assert_eq!(state.get_public_key(), key_pair.public_key); } diff --git a/packages/account/src/tests/test_signature.cairo b/packages/account/src/tests/test_signature.cairo index 36da6e644..98cc7e025 100644 --- a/packages/account/src/tests/test_signature.cairo +++ b/packages/account/src/tests/test_signature.cairo @@ -45,20 +45,22 @@ fn test_is_valid_stark_signature_invalid_len_sig() { #[test] fn test_is_valid_eth_signature_good_sig() { - let data = eth_signature_data(secp256k1::KEY_PAIR()); + let key_pair = secp256k1::KEY_PAIR(); + let data = eth_signature_data(key_pair); let mut serialized_good_signature = array![]; data.signature.serialize(ref serialized_good_signature); let is_valid = is_valid_eth_signature( - data.tx_hash, data.public_key, serialized_good_signature.span() + data.tx_hash, key_pair.public_key, serialized_good_signature.span() ); assert!(is_valid); } #[test] fn test_is_valid_eth_signature_bad_sig() { - let data = eth_signature_data(secp256k1::KEY_PAIR()); + let key_pair = secp256k1::KEY_PAIR(); + let data = eth_signature_data(key_pair); let mut bad_signature = data.signature; bad_signature.r += 1; @@ -68,7 +70,7 @@ fn test_is_valid_eth_signature_bad_sig() { bad_signature.serialize(ref serialized_bad_signature); let is_invalid = !is_valid_eth_signature( - data.tx_hash, data.public_key, serialized_bad_signature.span() + data.tx_hash, key_pair.public_key, serialized_bad_signature.span() ); assert!(is_invalid); } @@ -76,15 +78,17 @@ fn test_is_valid_eth_signature_bad_sig() { #[test] #[should_panic(expected: ('Signature: Invalid format.',))] fn test_is_valid_eth_signature_invalid_format_sig() { - let data = eth_signature_data(secp256k1::KEY_PAIR()); + let key_pair = secp256k1::KEY_PAIR(); + let data = eth_signature_data(key_pair); let mut serialized_bad_signature = array![0x1]; - is_valid_eth_signature(data.tx_hash, data.public_key, serialized_bad_signature.span()); + is_valid_eth_signature(data.tx_hash, key_pair.public_key, serialized_bad_signature.span()); } #[test] fn test_signature_r_out_of_range() { - let data = eth_signature_data(secp256k1::KEY_PAIR()); + let key_pair = secp256k1::KEY_PAIR(); + let data = eth_signature_data(key_pair); let mut bad_signature = data.signature; let curve_size = Secp256Trait::::get_curve_size(); @@ -96,14 +100,15 @@ fn test_signature_r_out_of_range() { bad_signature.serialize(ref serialized_bad_signature); let is_invalid = !is_valid_eth_signature( - data.tx_hash, data.public_key, serialized_bad_signature.span() + data.tx_hash, key_pair.public_key, serialized_bad_signature.span() ); assert!(is_invalid); } #[test] fn test_signature_s_out_of_range() { - let data = eth_signature_data(secp256k1::KEY_PAIR()); + let key_pair = secp256k1::KEY_PAIR(); + let data = eth_signature_data(key_pair); let mut bad_signature = data.signature; let curve_size = Secp256Trait::::get_curve_size(); @@ -115,7 +120,7 @@ fn test_signature_s_out_of_range() { bad_signature.serialize(ref serialized_bad_signature); let is_invalid = !is_valid_eth_signature( - data.tx_hash, data.public_key, serialized_bad_signature.span() + data.tx_hash, key_pair.public_key, serialized_bad_signature.span() ); assert!(is_invalid); } diff --git a/packages/presets/src/tests/test_account.cairo b/packages/presets/src/tests/test_account.cairo index 75fa966be..2682ed3ed 100644 --- a/packages/presets/src/tests/test_account.cairo +++ b/packages/presets/src/tests/test_account.cairo @@ -436,7 +436,7 @@ fn test_multicall() { let recipient2 = OTHER(); let mut calls = array![]; - // Craft call1 + // Craft 1st call let mut calldata1 = array![]; let amount1: u256 = 300; calldata1.append_serde(recipient1); @@ -445,7 +445,7 @@ fn test_multicall() { to: erc20.contract_address, selector: selectors::transfer, calldata: calldata1.span() }; - // Craft call2 + // Craft 2nd call let mut calldata2 = array![]; let amount2: u256 = 500; calldata2.append_serde(recipient2); diff --git a/packages/presets/src/tests/test_eth_account.cairo b/packages/presets/src/tests/test_eth_account.cairo index 77e568bef..9a07d87fd 100644 --- a/packages/presets/src/tests/test_eth_account.cairo +++ b/packages/presets/src/tests/test_eth_account.cairo @@ -16,11 +16,10 @@ use openzeppelin_test_common::eth_account::{ }; use openzeppelin_test_common::upgrades::UpgradeableSpyHelpers; use openzeppelin_testing as utils; -use openzeppelin_testing::constants::secp256k1::KEY_PAIR; -use openzeppelin_testing::constants::{ - CLASS_HASH_ZERO, ETH_PUBKEY, NEW_ETH_PUBKEY, SALT, ZERO, RECIPIENT, QUERY_VERSION, - MIN_TRANSACTION_VERSION -}; +use openzeppelin_testing::constants::secp256k1::{KEY_PAIR, KEY_PAIR_2}; +use openzeppelin_testing::constants::{CLASS_HASH_ZERO, ZERO, RECIPIENT, CALLER, OTHER}; +use openzeppelin_testing::constants::{SALT, QUERY_VERSION, MIN_TRANSACTION_VERSION}; +use openzeppelin_testing::signing::Secp256k1KeyPair; use openzeppelin_token::erc20::interface::IERC20DispatcherTrait; use openzeppelin_utils::selectors; use openzeppelin_utils::serde::SerializedAppend; @@ -36,7 +35,7 @@ use starknet::contract_address_const; use starknet::secp256_trait::Secp256Trait; use starknet::secp256k1::Secp256k1Point; -fn declare_v2_class_hash() -> ClassHash { +fn declare_v2_class() -> ClassHash { utils::declare_class("SnakeEthAccountMock").class_hash } @@ -44,35 +43,29 @@ fn declare_v2_class_hash() -> ClassHash { // Setup // -fn setup_dispatcher() -> EthAccountUpgradeableABIDispatcher { +fn setup_dispatcher(key_pair: Secp256k1KeyPair) -> EthAccountUpgradeableABIDispatcher { let mut calldata = array![]; - calldata.append_serde(ETH_PUBKEY()); + calldata.append_serde(key_pair.public_key); - let target = utils::declare_and_deploy("EthAccountUpgradeable", calldata); - EthAccountUpgradeableABIDispatcher { contract_address: target } + let contract_address = utils::declare_and_deploy("EthAccountUpgradeable", calldata); + EthAccountUpgradeableABIDispatcher { contract_address } } fn setup_dispatcher_with_data( - data: Option<@SignedTransactionData> + key_pair: Secp256k1KeyPair, data: SignedTransactionData ) -> (EthAccountUpgradeableABIDispatcher, felt252) { let mut calldata = array![]; - if let Option::Some(data) = data { - let mut serialized_signature = array![]; - data.signature.serialize(ref serialized_signature); - - cheat_signature_global(serialized_signature.span()); - cheat_transaction_hash_global(*data.tx_hash); - - calldata.append_serde(*data.public_key); - } else { - calldata.append_serde(ETH_PUBKEY()); - } + calldata.append_serde(key_pair.public_key); let contract_class = utils::declare_class("EthAccountUpgradeable"); - let address = utils::deploy(contract_class, calldata); - let dispatcher = EthAccountUpgradeableABIDispatcher { contract_address: address }; + let contract_address = utils::deploy(contract_class, calldata); + let dispatcher = EthAccountUpgradeableABIDispatcher { contract_address }; + let mut serialized_signature = array![]; + data.signature.serialize(ref serialized_signature); + cheat_signature_global(serialized_signature.span()); + cheat_transaction_hash_global(data.tx_hash); cheat_transaction_version_global(MIN_TRANSACTION_VERSION); - start_cheat_caller_address(address, ZERO()); + start_cheat_caller_address(contract_address, ZERO()); (dispatcher, contract_class.class_hash.into()) } @@ -85,13 +78,15 @@ fn setup_dispatcher_with_data( fn test_constructor() { let mut state = EthAccountUpgradeable::contract_state_for_testing(); let mut spy = spy_events(); + let key_pair = KEY_PAIR(); - EthAccountUpgradeable::constructor(ref state, ETH_PUBKEY()); + EthAccountUpgradeable::constructor(ref state, key_pair.public_key); - spy.assert_only_event_owner_added(test_address(), ETH_PUBKEY()); + spy.assert_only_event_owner_added(test_address(), key_pair.public_key); let public_key = EthAccountUpgradeable::EthAccountMixinImpl::get_public_key(@state); - assert_eq!(public_key, ETH_PUBKEY()); + assert_eq!(public_key, key_pair.public_key); + let supports_isrc5 = EthAccountUpgradeable::EthAccountMixinImpl::supports_interface( @state, ISRC5_ID ); @@ -108,50 +103,57 @@ fn test_constructor() { #[test] fn test_public_key_setter_and_getter() { - let dispatcher = setup_dispatcher(); let key_pair = KEY_PAIR(); + let dispatcher = setup_dispatcher(key_pair); let contract_address = dispatcher.contract_address; let mut spy = spy_events(); + let new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + contract_address, key_pair.public_key, new_key_pair + ); start_cheat_caller_address(contract_address, contract_address); + dispatcher.set_public_key(new_key_pair.public_key, signature); - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); - dispatcher.set_public_key(key_pair.public_key, signature); - assert_eq!(dispatcher.get_public_key(), key_pair.public_key); + assert_eq!(dispatcher.get_public_key(), new_key_pair.public_key); - spy.assert_event_owner_removed(contract_address, ETH_PUBKEY()); - spy.assert_only_event_owner_added(contract_address, key_pair.public_key); + spy.assert_event_owner_removed(contract_address, key_pair.public_key); + spy.assert_only_event_owner_added(contract_address, new_key_pair.public_key); } #[test] fn test_public_key_setter_and_getter_camel() { - let dispatcher = setup_dispatcher(); let key_pair = KEY_PAIR(); + let dispatcher = setup_dispatcher(key_pair); let contract_address = dispatcher.contract_address; let mut spy = spy_events(); + let new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + contract_address, key_pair.public_key, new_key_pair + ); start_cheat_caller_address(contract_address, contract_address); + dispatcher.setPublicKey(new_key_pair.public_key, signature); + assert_eq!(dispatcher.getPublicKey(), new_key_pair.public_key); - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); - dispatcher.setPublicKey(key_pair.public_key, signature); - assert_eq!(dispatcher.getPublicKey(), key_pair.public_key); - - spy.assert_event_owner_removed(contract_address, ETH_PUBKEY()); - spy.assert_only_event_owner_added(contract_address, key_pair.public_key); + spy.assert_event_owner_removed(contract_address, key_pair.public_key); + spy.assert_only_event_owner_added(contract_address, new_key_pair.public_key); } #[test] #[should_panic(expected: ('EthAccount: unauthorized',))] fn test_set_public_key_different_account() { - let dispatcher = setup_dispatcher(); - dispatcher.set_public_key(NEW_ETH_PUBKEY(), array![].span()); + let dispatcher = setup_dispatcher(KEY_PAIR()); + + dispatcher.set_public_key(KEY_PAIR_2().public_key, array![].span()); } #[test] #[should_panic(expected: ('EthAccount: unauthorized',))] fn test_setPublicKey_different_account() { - let dispatcher = setup_dispatcher(); - dispatcher.setPublicKey(NEW_ETH_PUBKEY(), array![].span()); + let dispatcher = setup_dispatcher(KEY_PAIR()); + + dispatcher.setPublicKey(KEY_PAIR_2().public_key, array![].span()); } // @@ -159,21 +161,14 @@ fn test_setPublicKey_different_account() { // fn is_valid_sig_dispatcher() -> (EthAccountUpgradeableABIDispatcher, felt252, Array) { - let dispatcher = setup_dispatcher(); let key_pair = KEY_PAIR(); - let contract_address = dispatcher.contract_address; + let dispatcher = setup_dispatcher(key_pair); let data = SIGNED_TX_DATA(key_pair); - let hash = data.tx_hash; let mut serialized_signature = array![]; data.signature.serialize(ref serialized_signature); - start_cheat_caller_address(contract_address, contract_address); - - let signature = get_accept_ownership_signature(contract_address, ETH_PUBKEY(), key_pair); - dispatcher.set_public_key(data.public_key, signature); - - (dispatcher, hash, serialized_signature) + (dispatcher, data.tx_hash, serialized_signature) } #[test] @@ -214,14 +209,17 @@ fn test_isValidSignature_bad_sig() { #[test] fn test_supports_interface() { - let dispatcher = setup_dispatcher(); + let key_pair = KEY_PAIR(); + let dispatcher = setup_dispatcher(key_pair); let supports_isrc5 = dispatcher.supports_interface(ISRC5_ID); assert!(supports_isrc5); + let supports_isrc6 = dispatcher.supports_interface(ISRC6_ID); assert!(supports_isrc6); - let doesnt_support_0x123 = !dispatcher.supports_interface(0x123); - assert!(doesnt_support_0x123); + + let doesnt_support_dummy_id = !dispatcher.supports_interface('DUMMY_INTERFACE_ID'); + assert!(doesnt_support_dummy_id); } // @@ -230,57 +228,53 @@ fn test_supports_interface() { #[test] fn test_validate_deploy() { - let (account, class_hash) = setup_dispatcher_with_data( - Option::Some(@SIGNED_TX_DATA(KEY_PAIR())) - ); + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher_with_data(key_pair, SIGNED_TX_DATA(key_pair)); // `__validate_deploy__` does not directly use the passed arguments. Their // values are already integrated in the tx hash. The passed arguments in this // testing context are decoupled from the signature and have no effect on the test. - let is_valid = account.__validate_deploy__(class_hash, SALT, ETH_PUBKEY()); + let is_valid = account.__validate_deploy__(class_hash, SALT, key_pair.public_key); assert_eq!(is_valid, starknet::VALIDATED); } #[test] #[should_panic(expected: ('EthAccount: invalid signature',))] fn test_validate_deploy_invalid_signature_data() { - let mut data = SIGNED_TX_DATA(KEY_PAIR()); + let key_pair = KEY_PAIR(); + let mut data = SIGNED_TX_DATA(key_pair); data.tx_hash += 1; - let (account, class_hash) = setup_dispatcher_with_data(Option::Some(@data)); + let (account, class_hash) = setup_dispatcher_with_data(key_pair, data); - account.__validate_deploy__(class_hash, SALT, ETH_PUBKEY()); + account.__validate_deploy__(class_hash, SALT, key_pair.public_key); } #[test] #[should_panic(expected: ('Signature: Invalid format.',))] fn test_validate_deploy_invalid_signature_length() { - let (account, class_hash) = setup_dispatcher_with_data( - Option::Some(@SIGNED_TX_DATA(KEY_PAIR())) - ); - let mut signature = array![0x1]; - - cheat_signature_global(signature.span()); + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher_with_data(key_pair, SIGNED_TX_DATA(key_pair)); - account.__validate_deploy__(class_hash, SALT, ETH_PUBKEY()); + let invalid_len_sig = array!['INVALID_LEN']; + cheat_signature_global(invalid_len_sig.span()); + account.__validate_deploy__(class_hash, SALT, key_pair.public_key); } #[test] #[should_panic(expected: ('Signature: Invalid format.',))] fn test_validate_deploy_empty_signature() { - let (account, class_hash) = setup_dispatcher_with_data( - Option::Some(@SIGNED_TX_DATA(KEY_PAIR())) - ); - let empty_sig = array![]; + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher_with_data(key_pair, SIGNED_TX_DATA(key_pair)); + let empty_sig = array![]; cheat_signature_global(empty_sig.span()); - account.__validate_deploy__(class_hash, SALT, ETH_PUBKEY()); + account.__validate_deploy__(class_hash, SALT, key_pair.public_key); } #[test] fn test_validate_declare() { - let (account, class_hash) = setup_dispatcher_with_data( - Option::Some(@SIGNED_TX_DATA(KEY_PAIR())) - ); + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher_with_data(key_pair, SIGNED_TX_DATA(key_pair)); // `__validate_declare__` does not directly use the class_hash argument. Its // value is already integrated in the tx hash. The class_hash argument in this @@ -292,9 +286,10 @@ fn test_validate_declare() { #[test] #[should_panic(expected: ('EthAccount: invalid signature',))] fn test_validate_declare_invalid_signature_data() { - let mut data = SIGNED_TX_DATA(KEY_PAIR()); + let key_pair = KEY_PAIR(); + let mut data = SIGNED_TX_DATA(key_pair); data.tx_hash += 1; - let (account, class_hash) = setup_dispatcher_with_data(Option::Some(@data)); + let (account, class_hash) = setup_dispatcher_with_data(key_pair, data); account.__validate_declare__(class_hash); } @@ -302,32 +297,29 @@ fn test_validate_declare_invalid_signature_data() { #[test] #[should_panic(expected: ('Signature: Invalid format.',))] fn test_validate_declare_invalid_signature_length() { - let (account, class_hash) = setup_dispatcher_with_data( - Option::Some(@SIGNED_TX_DATA(KEY_PAIR())) - ); - let mut signature = array![0x1]; - - cheat_signature_global(signature.span()); + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher_with_data(key_pair, SIGNED_TX_DATA(key_pair)); + let invalid_len_sig = array!['INVALID_LEN']; + cheat_signature_global(invalid_len_sig.span()); account.__validate_declare__(class_hash); } #[test] #[should_panic(expected: ('Signature: Invalid format.',))] fn test_validate_declare_empty_signature() { - let (account, class_hash) = setup_dispatcher_with_data( - Option::Some(@SIGNED_TX_DATA(KEY_PAIR())) - ); + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher_with_data(key_pair, SIGNED_TX_DATA(key_pair)); let empty_sig = array![]; cheat_signature_global(empty_sig.span()); - account.__validate_declare__(class_hash); } fn test_execute_with_version(version: Option) { - let data = SIGNED_TX_DATA(KEY_PAIR()); - let (account, _) = setup_dispatcher_with_data(Option::Some(@data)); + let key_pair = KEY_PAIR(); + let data = SIGNED_TX_DATA(key_pair); + let (account, _) = setup_dispatcher_with_data(key_pair, data); let erc20 = deploy_erc20(account.contract_address, 1000); let amount: u256 = 200; @@ -339,8 +331,7 @@ fn test_execute_with_version(version: Option) { let call = Call { to: erc20.contract_address, selector: selectors::transfer, calldata: calldata.span() }; - let mut calls = array![]; - calls.append(call); + let calls = array![call]; if let Option::Some(version) = version { cheat_transaction_version_global(version); @@ -358,7 +349,7 @@ fn test_execute_with_version(version: Option) { #[test] fn test_execute() { - test_execute_with_version(Option::None(())); + test_execute_with_version(Option::None); } #[test] @@ -374,9 +365,10 @@ fn test_execute_invalid_version() { #[test] fn test_validate() { - let calls = array![]; - let (account, _) = setup_dispatcher_with_data(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); + let key_pair = KEY_PAIR(); + let (account, _) = setup_dispatcher_with_data(key_pair, SIGNED_TX_DATA(key_pair)); + let calls = array![]; let is_valid = account.__validate__(calls); assert_eq!(is_valid, starknet::VALIDATED); } @@ -384,22 +376,24 @@ fn test_validate() { #[test] #[should_panic(expected: ('EthAccount: invalid signature',))] fn test_validate_invalid() { - let calls = array![]; - let mut data = SIGNED_TX_DATA(KEY_PAIR()); + let key_pair = KEY_PAIR(); + let mut data = SIGNED_TX_DATA(key_pair); data.tx_hash += 1; - let (account, _) = setup_dispatcher_with_data(Option::Some(@data)); + let (account, _) = setup_dispatcher_with_data(key_pair, data); + let calls = array![]; account.__validate__(calls); } #[test] fn test_multicall() { - let (account, _) = setup_dispatcher_with_data(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); + let key_pair = KEY_PAIR(); + let (account, _) = setup_dispatcher_with_data(key_pair, SIGNED_TX_DATA(key_pair)); let erc20 = deploy_erc20(account.contract_address, 1000); - let recipient1 = contract_address_const::<0x123>(); - let recipient2 = contract_address_const::<0x456>(); - let mut calls = array![]; + let recipient1 = RECIPIENT(); + let recipient2 = OTHER(); + // Craft 1st call let mut calldata1 = array![]; let amount1: u256 = 300; calldata1.append_serde(recipient1); @@ -408,6 +402,7 @@ fn test_multicall() { to: erc20.contract_address, selector: selectors::transfer, calldata: calldata1.span() }; + // Craft 2nd call let mut calldata2 = array![]; let amount2: u256 = 500; calldata2.append_serde(recipient2); @@ -416,8 +411,7 @@ fn test_multicall() { to: erc20.contract_address, selector: selectors::transfer, calldata: calldata2.span() }; - calls.append(call1); - calls.append(call2); + let calls = array![call1, call2]; let ret = account.__execute__(calls); assert_eq!(erc20.balance_of(account.contract_address), 200, "Should have remainder"); @@ -434,9 +428,10 @@ fn test_multicall() { #[test] fn test_multicall_zero_calls() { - let (account, _) = setup_dispatcher_with_data(Option::Some(@SIGNED_TX_DATA(KEY_PAIR()))); - let mut calls = array![]; + let key_pair = KEY_PAIR(); + let (account, _) = setup_dispatcher_with_data(key_pair, SIGNED_TX_DATA(key_pair)); + let calls = array![]; let ret = account.__execute__(calls); assert!(ret.len().is_zero(), "Should have an empty response"); @@ -445,11 +440,10 @@ fn test_multicall_zero_calls() { #[test] #[should_panic(expected: ('EthAccount: invalid caller',))] fn test_account_called_from_contract() { - let account = setup_dispatcher(); + let account = setup_dispatcher(KEY_PAIR()); let calls = array![]; - let caller = contract_address_const::<0x123>(); - start_cheat_caller_address(account.contract_address, caller); + start_cheat_caller_address(account.contract_address, CALLER()); account.__execute__(calls); } @@ -461,14 +455,14 @@ fn test_account_called_from_contract() { #[test] #[should_panic(expected: ('EthAccount: unauthorized',))] fn test_upgrade_access_control() { - let v1 = setup_dispatcher(); + let v1 = setup_dispatcher(KEY_PAIR()); v1.upgrade(CLASS_HASH_ZERO()); } #[test] #[should_panic(expected: ('Class hash cannot be zero',))] fn test_upgrade_with_class_hash_zero() { - let v1 = setup_dispatcher(); + let v1 = setup_dispatcher(KEY_PAIR()); start_cheat_caller_address(v1.contract_address, v1.contract_address); v1.upgrade(CLASS_HASH_ZERO()); @@ -476,52 +470,56 @@ fn test_upgrade_with_class_hash_zero() { #[test] fn test_upgraded_event() { - let v1 = setup_dispatcher(); - let v2_class_hash = declare_v2_class_hash(); + let v1 = setup_dispatcher(KEY_PAIR()); + let contract_address = v1.contract_address; let mut spy = spy_events(); - start_cheat_caller_address(v1.contract_address, v1.contract_address); + start_cheat_caller_address(contract_address, contract_address); + let v2_class_hash = declare_v2_class(); v1.upgrade(v2_class_hash); - spy.assert_only_event_upgraded(v1.contract_address, v2_class_hash); + spy.assert_only_event_upgraded(contract_address, v2_class_hash); } #[test] #[feature("safe_dispatcher")] fn test_v2_missing_camel_selector() { - let v1 = setup_dispatcher(); - let v2_class_hash = declare_v2_class_hash(); + let v1 = setup_dispatcher(KEY_PAIR()); + let contract_address = v1.contract_address; + let v2_class_hash = declare_v2_class(); - start_cheat_caller_address(v1.contract_address, v1.contract_address); + start_cheat_caller_address(contract_address, contract_address); v1.upgrade(v2_class_hash); - let safe_dispatcher = EthAccountUpgradeableABISafeDispatcher { - contract_address: v1.contract_address - }; + let safe_dispatcher = EthAccountUpgradeableABISafeDispatcher { contract_address }; let result = safe_dispatcher.getPublicKey(); - utils::assert_entrypoint_not_found_error(result, selector!("getPublicKey"), v1.contract_address) + utils::assert_entrypoint_not_found_error(result, selector!("getPublicKey"), contract_address) } #[test] fn test_state_persists_after_upgrade() { - let v1 = setup_dispatcher(); let key_pair = KEY_PAIR(); - let v2_class_hash = declare_v2_class_hash(); + let v1 = setup_dispatcher(key_pair); + let contract_address = v1.contract_address; - start_cheat_caller_address(v1.contract_address, v1.contract_address); - let dispatcher = EthAccountUpgradeableABIDispatcher { contract_address: v1.contract_address }; + start_cheat_caller_address(contract_address, contract_address); + let dispatcher = EthAccountUpgradeableABIDispatcher { contract_address }; - let signature = get_accept_ownership_signature(v1.contract_address, ETH_PUBKEY(), KEY_PAIR()); - dispatcher.set_public_key(key_pair.public_key, signature); + let new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + contract_address, key_pair.public_key, new_key_pair + ); + dispatcher.set_public_key(new_key_pair.public_key, signature); let camel_public_key = dispatcher.getPublicKey(); - assert_eq!(camel_public_key, key_pair.public_key); + assert_eq!(camel_public_key, new_key_pair.public_key); + let v2_class_hash = declare_v2_class(); v1.upgrade(v2_class_hash); - let snake_public_key = dispatcher.get_public_key(); - assert_eq!(snake_public_key, camel_public_key); + let snake_public_key = dispatcher.get_public_key(); + assert_eq!(snake_public_key, new_key_pair.public_key); } // diff --git a/packages/testing/src/constants.cairo b/packages/testing/src/constants.cairo index e6447b9d5..a26449dc8 100644 --- a/packages/testing/src/constants.cairo +++ b/packages/testing/src/constants.cairo @@ -44,14 +44,6 @@ pub fn BASE_URI_2() -> ByteArray { "https://api.example.com/v2/" } -pub fn ETH_PUBKEY() -> EthPublicKey { - Secp256Trait::secp256_ec_get_point_from_x_syscall(3, false).unwrap_syscall().unwrap() -} - -pub fn NEW_ETH_PUBKEY() -> EthPublicKey { - Secp256Trait::secp256_ec_get_point_from_x_syscall(4, false).unwrap_syscall().unwrap() -} - pub fn ADMIN() -> ContractAddress { contract_address_const::<'ADMIN'>() }