diff --git a/src/tests/account/ethereum.cairo b/src/tests/account/ethereum.cairo index 2d87a5992..d6fcf488b 100644 --- a/src/tests/account/ethereum.cairo +++ b/src/tests/account/ethereum.cairo @@ -2,4 +2,3 @@ pub(crate) mod common; mod test_dual_eth_account; mod test_eth_account; - diff --git a/src/tests/account/starknet.cairo b/src/tests/account/starknet.cairo index f426692e3..8c3e80c69 100644 --- a/src/tests/account/starknet.cairo +++ b/src/tests/account/starknet.cairo @@ -1,5 +1,3 @@ pub(crate) mod common; -// mod test_account; -// mod test_dual_account; - - +mod test_account; +mod test_dual_account; diff --git a/src/tests/account/starknet/common.cairo b/src/tests/account/starknet/common.cairo index f029dff0a..26554ba33 100644 --- a/src/tests/account/starknet/common.cairo +++ b/src/tests/account/starknet/common.cairo @@ -1,35 +1,32 @@ +use core::hash::{HashStateTrait, HashStateExTrait}; +use core::poseidon::PoseidonTrait; use openzeppelin::account::AccountComponent::{OwnerAdded, OwnerRemoved}; use openzeppelin::account::AccountComponent; -use openzeppelin::tests::utils::constants::{NAME, SYMBOL, NEW_PUBKEY}; +use openzeppelin::tests::utils::constants::{NAME, SYMBOL, TRANSACTION_HASH}; use openzeppelin::tests::utils::events::EventSpyExt; +use openzeppelin::tests::utils::signing::StarkKeyPair; use openzeppelin::tests::utils; -use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait}; +use openzeppelin::token::erc20::interface::IERC20Dispatcher; use openzeppelin::utils::serde::SerializedAppend; use snforge_std::EventSpy; +use snforge_std::signature::stark_curve::StarkCurveSignerImpl; use starknet::ContractAddress; #[derive(Drop)] pub(crate) struct SignedTransactionData { - pub(crate) private_key: felt252, - pub(crate) public_key: felt252, pub(crate) tx_hash: felt252, pub(crate) r: felt252, pub(crate) s: felt252 } -pub(crate) fn SIGNED_TX_DATA() -> SignedTransactionData { - SignedTransactionData { - private_key: 1234, - public_key: NEW_PUBKEY, - tx_hash: 0x601d3d2e265c10ff645e1554c435e72ce6721f0ba5fc96f0c650bfc6231191a, - r: 0x6bc22689efcaeacb9459577138aff9f0af5b77ee7894cdc8efabaf760f6cf6e, - s: 0x295989881583b9325436851934334faa9d639a2094cd1e2f8691c8a71cd4cdf - } +pub(crate) fn SIGNED_TX_DATA(key_pair: StarkKeyPair) -> SignedTransactionData { + let tx_hash = TRANSACTION_HASH; + let (r, s) = key_pair.sign(tx_hash).unwrap(); + SignedTransactionData { tx_hash, r, s } } pub(crate) fn deploy_erc20(recipient: ContractAddress, initial_supply: u256) -> IERC20Dispatcher { let mut calldata = array![]; - calldata.append_serde(NAME()); calldata.append_serde(SYMBOL()); calldata.append_serde(initial_supply); @@ -39,6 +36,18 @@ pub(crate) fn deploy_erc20(recipient: ContractAddress, initial_supply: u256) -> IERC20Dispatcher { contract_address: address } } +pub(crate) fn get_accept_ownership_signature( + account_address: ContractAddress, current_public_key: felt252, new_key_pair: StarkKeyPair +) -> Span { + let msg_hash = PoseidonTrait::new() + .update_with('StarkNet Message') + .update_with('accept_ownership') + .update_with(account_address) + .update_with(current_public_key) + .finalize(); + let (sig_r, sig_s) = new_key_pair.sign(msg_hash).unwrap(); + array![sig_r, sig_s].span() +} #[generate_trait] pub(crate) impl AccountSpyHelpersImpl of AccountSpyHelpers { diff --git a/src/tests/account/starknet/test_account.cairo b/src/tests/account/starknet/test_account.cairo index ed4dc81ed..13dd7f36e 100644 --- a/src/tests/account/starknet/test_account.cairo +++ b/src/tests/account/starknet/test_account.cairo @@ -1,4 +1,5 @@ use core::num::traits::Zero; +use core::starknet::SyscallResultTrait; use openzeppelin::account::AccountComponent::{InternalTrait, SRC6CamelOnlyImpl}; use openzeppelin::account::AccountComponent::{PublicKeyCamelImpl, PublicKeyImpl}; use openzeppelin::account::AccountComponent; @@ -6,32 +7,24 @@ use openzeppelin::account::interface::{AccountABIDispatcherTrait, AccountABIDisp use openzeppelin::account::interface::{ISRC6, ISRC6_ID}; use openzeppelin::introspection::interface::{ISRC5, ISRC5_ID}; use openzeppelin::tests::mocks::account_mocks::DualCaseAccountMock; +use openzeppelin::tests::utils::constants::stark::{KEY_PAIR, KEY_PAIR_2}; use openzeppelin::tests::utils::constants::{ - PUBKEY, NEW_PUBKEY, SALT, ZERO, QUERY_OFFSET, QUERY_VERSION, MIN_TRANSACTION_VERSION + SALT, ZERO, OTHER, CALLER, RECIPIENT, QUERY_OFFSET, QUERY_VERSION, MIN_TRANSACTION_VERSION }; +use openzeppelin::tests::utils::signing::StarkKeyPair; use openzeppelin::tests::utils; -use openzeppelin::token::erc20::interface::{IERC20DispatcherTrait, IERC20Dispatcher}; +use openzeppelin::token::erc20::interface::IERC20DispatcherTrait; use openzeppelin::utils::selectors; use openzeppelin::utils::serde::SerializedAppend; -use starknet::ContractAddress; +use snforge_std::{ + cheat_signature_global, cheat_transaction_version_global, cheat_transaction_hash_global +}; +use snforge_std::{spy_events, declare, test_address, start_cheat_caller_address}; use starknet::account::Call; -use starknet::contract_address_const; -use starknet::testing; +use starknet::{contract_address_const, ContractAddress, ClassHash}; -use super::common::{assert_only_event_owner_added, assert_event_owner_removed}; -use super::common::{deploy_erc20, SIGNED_TX_DATA, SignedTransactionData}; - -// -// Constants -// - -fn CLASS_HASH() -> felt252 { - DualCaseAccountMock::TEST_CLASS_HASH -} - -fn ACCOUNT_ADDRESS() -> ContractAddress { - contract_address_const::<0x111111>() -} +use super::common::{AccountSpyHelpers, SignedTransactionData}; +use super::common::{deploy_erc20, SIGNED_TX_DATA, get_accept_ownership_signature}; // // Setup @@ -47,28 +40,26 @@ fn COMPONENT_STATE() -> ComponentState { AccountComponent::component_state_for_testing() } -fn setup() -> ComponentState { +fn setup(key_pair: StarkKeyPair) -> ComponentState { let mut state = COMPONENT_STATE(); - state.initializer(PUBKEY); - utils::drop_event(ZERO()); + state.initializer(key_pair.public_key); state } -fn setup_dispatcher(data: Option<@SignedTransactionData>) -> AccountABIDispatcher { - testing::set_version(MIN_TRANSACTION_VERSION); +fn setup_dispatcher( + key_pair: StarkKeyPair, data: SignedTransactionData +) -> (AccountABIDispatcher, felt252) { + let contract_class = declare("DualCaseAccountMock").unwrap_syscall(); + let calldata = array![key_pair.public_key]; + let address = utils::deploy(contract_class, calldata); + let dispatcher = AccountABIDispatcher { contract_address: address }; - let mut calldata = array![]; - if data.is_some() { - let data = data.unwrap(); - testing::set_signature(array![*data.r, *data.s].span()); - testing::set_transaction_hash(*data.transaction_hash); - - calldata.append(*data.public_key); - } else { - calldata.append(PUBKEY); - } - let address = utils::deploy(CLASS_HASH(), calldata); - AccountABIDispatcher { contract_address: address } + cheat_signature_global(array![data.r, data.s].span()); + cheat_transaction_hash_global(data.tx_hash); + cheat_transaction_version_global(MIN_TRANSACTION_VERSION); + start_cheat_caller_address(address, ZERO()); + + (dispatcher, contract_class.class_hash.into()) } // @@ -78,36 +69,34 @@ fn setup_dispatcher(data: Option<@SignedTransactionData>) -> AccountABIDispatche #[test] fn test_is_valid_signature() { let mut state = COMPONENT_STATE(); - let data = SIGNED_TX_DATA(); - let hash = data.transaction_hash; + let key_pair = KEY_PAIR(); + let data = SIGNED_TX_DATA(key_pair); - let mut good_signature = array![data.r, data.s]; - let mut bad_signature = array![0x987, 0x564]; + state._set_public_key(key_pair.public_key); - state._set_public_key(data.public_key); - - let is_valid = state.is_valid_signature(hash, good_signature); + let good_signature = array![data.r, data.s]; + let is_valid = state.is_valid_signature(data.tx_hash, good_signature); assert_eq!(is_valid, starknet::VALIDATED); - let is_valid = state.is_valid_signature(hash, bad_signature); + let bad_signature = array!['BAD', 'SIGNATURE']; + let is_valid = state.is_valid_signature(data.tx_hash, bad_signature); assert!(is_valid.is_zero(), "Should reject invalid signature"); } #[test] fn test_isValidSignature() { let mut state = COMPONENT_STATE(); - let data = SIGNED_TX_DATA(); - let hash = data.transaction_hash; - - let mut good_signature = array![data.r, data.s]; - let mut bad_signature = array![0x987, 0x564]; + let key_pair = KEY_PAIR(); + let data = SIGNED_TX_DATA(key_pair); - state._set_public_key(data.public_key); + state._set_public_key(key_pair.public_key); - let is_valid = state.isValidSignature(hash, good_signature); + let good_signature = array![data.r, data.s]; + let is_valid = state.isValidSignature(data.tx_hash, good_signature); assert_eq!(is_valid, starknet::VALIDATED); - let is_valid = state.isValidSignature(hash, bad_signature); + let bad_signature = array!['BAD', 'SIGNATURE']; + let is_valid = state.isValidSignature(data.tx_hash, bad_signature); assert!(is_valid.is_zero(), "Should reject invalid signature"); } @@ -117,96 +106,99 @@ fn test_isValidSignature() { #[test] fn test_validate_deploy() { - let account = setup_dispatcher(Option::Some(@SIGNED_TX_DATA())); + 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, PUBKEY); + let is_valid = account.__validate_deploy__(class_hash, SALT, key_pair.public_key); assert_eq!(is_valid, starknet::VALIDATED); } #[test] -#[should_panic(expected: ('Account: invalid signature', 'ENTRYPOINT_FAILED'))] +#[should_panic(expected: ('Account: invalid signature',))] fn test_validate_deploy_invalid_signature_data() { - let mut data = SIGNED_TX_DATA(); - data.transaction_hash += 1; - let account = setup_dispatcher(Option::Some(@data)); + let key_pair = KEY_PAIR(); + let mut data = SIGNED_TX_DATA(key_pair); + data.tx_hash += 1; + let (account, class_hash) = setup_dispatcher(key_pair, data); - account.__validate_deploy__(CLASS_HASH(), SALT, PUBKEY); + account.__validate_deploy__(class_hash, SALT, key_pair.public_key); } #[test] -#[should_panic(expected: ('Account: invalid signature', 'ENTRYPOINT_FAILED'))] +#[should_panic(expected: ('Account: invalid signature',))] fn test_validate_deploy_invalid_signature_length() { - let account = setup_dispatcher(Option::Some(@SIGNED_TX_DATA())); - let mut signature = array![]; + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); + let invalid_len_sig = array!['INVALID_LEN_SIG']; + cheat_signature_global(invalid_len_sig.span()); - signature.append(0x1); - testing::set_signature(signature.span()); - - account.__validate_deploy__(CLASS_HASH(), SALT, PUBKEY); + account.__validate_deploy__(class_hash, SALT, key_pair.public_key); } #[test] -#[should_panic(expected: ('Account: invalid signature', 'ENTRYPOINT_FAILED'))] +#[should_panic(expected: ('Account: invalid signature',))] fn test_validate_deploy_empty_signature() { - let account = setup_dispatcher(Option::Some(@SIGNED_TX_DATA())); + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); let empty_sig = array![]; - testing::set_signature(empty_sig.span()); - account.__validate_deploy__(CLASS_HASH(), SALT, PUBKEY); + cheat_signature_global(empty_sig.span()); + account.__validate_deploy__(class_hash, SALT, key_pair.public_key); } #[test] fn test_validate_declare() { - let account = setup_dispatcher(Option::Some(@SIGNED_TX_DATA())); + 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 // testing context is decoupled from the signature and has no effect on the test. - let is_valid = account.__validate_declare__(CLASS_HASH()); + let is_valid = account.__validate_declare__(class_hash); assert_eq!(is_valid, starknet::VALIDATED); } #[test] -#[should_panic(expected: ('Account: invalid signature', 'ENTRYPOINT_FAILED'))] +#[should_panic(expected: ('Account: invalid signature',))] fn test_validate_declare_invalid_signature_data() { - let mut data = SIGNED_TX_DATA(); - data.transaction_hash += 1; - let account = setup_dispatcher(Option::Some(@data)); + let key_pair = KEY_PAIR(); + let mut data = SIGNED_TX_DATA(key_pair); + data.tx_hash += 1; + let (account, class_hash) = setup_dispatcher(key_pair, data); - account.__validate_declare__(CLASS_HASH()); + account.__validate_declare__(class_hash); } #[test] -#[should_panic(expected: ('Account: invalid signature', 'ENTRYPOINT_FAILED'))] +#[should_panic(expected: ('Account: invalid signature',))] fn test_validate_declare_invalid_signature_length() { - let account = setup_dispatcher(Option::Some(@SIGNED_TX_DATA())); - let mut signature = array![]; + let key_pair = KEY_PAIR(); + let (account, class_hash) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); + let invalid_len_sig = array!['INVALID_LEN_SIG']; + cheat_signature_global(invalid_len_sig.span()); - signature.append(0x1); - testing::set_signature(signature.span()); - - account.__validate_declare__(CLASS_HASH()); + account.__validate_declare__(class_hash); } #[test] -#[should_panic(expected: ('Account: invalid signature', 'ENTRYPOINT_FAILED'))] +#[should_panic(expected: ('Account: invalid signature',))] fn test_validate_declare_empty_signature() { - let account = setup_dispatcher(Option::Some(@SIGNED_TX_DATA())); + 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()); - testing::set_signature(empty_sig.span()); - - account.__validate_declare__(CLASS_HASH()); + account.__validate_declare__(class_hash); } fn test_execute_with_version(version: Option) { - let data = SIGNED_TX_DATA(); - let account = setup_dispatcher(Option::Some(@data)); + let key_pair = KEY_PAIR(); + let (account, _) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); let erc20 = deploy_erc20(account.contract_address, 1000); - let recipient = contract_address_const::<0x123>(); + let recipient = RECIPIENT(); // Craft call and add to calls array let mut calldata = array![]; @@ -216,12 +208,11 @@ 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]; // Handle version for test - if version.is_some() { - testing::set_version(version.unwrap()); + if let Option::Some(version) = version { + cheat_transaction_version_global(version); } // Execute @@ -239,7 +230,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] @@ -253,7 +244,7 @@ fn test_execute_query_version() { } #[test] -#[should_panic(expected: ('Account: invalid tx version', 'ENTRYPOINT_FAILED'))] +#[should_panic(expected: ('Account: invalid tx version',))] fn test_execute_invalid_query_version() { test_execute_with_version(Option::Some(QUERY_OFFSET)); } @@ -264,38 +255,40 @@ fn test_execute_future_query_version() { } #[test] -#[should_panic(expected: ('Account: invalid tx version', 'ENTRYPOINT_FAILED'))] +#[should_panic(expected: ('Account: invalid tx version',))] fn test_execute_invalid_version() { test_execute_with_version(Option::Some(MIN_TRANSACTION_VERSION - 1)); } #[test] fn test_validate() { + let key_pair = KEY_PAIR(); + let (account, _) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); let calls = array![]; - let account = setup_dispatcher(Option::Some(@SIGNED_TX_DATA())); let is_valid = account.__validate__(calls); assert_eq!(is_valid, starknet::VALIDATED); } #[test] -#[should_panic(expected: ('Account: invalid signature', 'ENTRYPOINT_FAILED'))] +#[should_panic(expected: ('Account: invalid signature',))] fn test_validate_invalid() { + let key_pair = KEY_PAIR(); + let mut data = SIGNED_TX_DATA(key_pair); + data.tx_hash += 1; + let (account, _) = setup_dispatcher(key_pair, data); let calls = array![]; - let mut data = SIGNED_TX_DATA(); - data.transaction_hash += 1; - let account = setup_dispatcher(Option::Some(@data)); account.__validate__(calls); } #[test] fn test_multicall() { - let account = setup_dispatcher(Option::Some(@SIGNED_TX_DATA())); + let key_pair = KEY_PAIR(); + let (account, _) = setup_dispatcher(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 call1 let mut calldata1 = array![]; @@ -316,8 +309,7 @@ fn test_multicall() { }; // Bundle calls and exeute - calls.append(call1); - calls.append(call2); + let calls = array![call1, call2]; let ret = account.__execute__(calls); // Assert that the transfers were successful @@ -338,8 +330,9 @@ fn test_multicall() { #[test] fn test_multicall_zero_calls() { - let account = setup_dispatcher(Option::Some(@SIGNED_TX_DATA())); - let mut calls = array![]; + let key_pair = KEY_PAIR(); + let (account, _) = setup_dispatcher(key_pair, SIGNED_TX_DATA(key_pair)); + let calls = array![]; let response = account.__execute__(calls); assert!(response.is_empty()); @@ -348,12 +341,11 @@ fn test_multicall_zero_calls() { #[test] #[should_panic(expected: ('Account: invalid caller',))] fn test_account_called_from_contract() { - let state = setup(); + let state = setup(KEY_PAIR()); + let account_address = test_address(); let calls = array![]; - let caller = contract_address_const::<0x123>(); - testing::set_contract_address(ACCOUNT_ADDRESS()); - testing::set_caller_address(caller); + start_cheat_caller_address(account_address, CALLER()); state.__execute__(calls); } @@ -365,33 +357,36 @@ fn test_account_called_from_contract() { #[test] fn test_public_key_setter_and_getter() { let mut state = COMPONENT_STATE(); - testing::set_contract_address(ACCOUNT_ADDRESS()); - testing::set_caller_address(ACCOUNT_ADDRESS()); + let account_address = test_address(); + let key_pair = KEY_PAIR(); + let new_key_pair = KEY_PAIR_2(); + start_cheat_caller_address(account_address, account_address); - state._set_public_key(PUBKEY); - utils::drop_event(ACCOUNT_ADDRESS()); - let public_key = state.get_public_key(); - assert_eq!(public_key, PUBKEY); + state._set_public_key(key_pair.public_key); + assert_eq!(state.get_public_key(), key_pair.public_key); // Set key - state.set_public_key(NEW_PUBKEY, get_accept_ownership_signature()); + let mut spy = spy_events(); + let signature = get_accept_ownership_signature( + account_address, key_pair.public_key, new_key_pair + ); + state.set_public_key(new_key_pair.public_key, signature); - assert_event_owner_removed(ACCOUNT_ADDRESS(), PUBKEY); - assert_only_event_owner_added(ACCOUNT_ADDRESS(), NEW_PUBKEY); + spy.assert_event_owner_removed(account_address, key_pair.public_key); + spy.assert_only_event_owner_added(account_address, new_key_pair.public_key); - let public_key = state.get_public_key(); - assert_eq!(public_key, NEW_PUBKEY); + assert_eq!(state.get_public_key(), new_key_pair.public_key); } #[test] #[should_panic(expected: ('Account: unauthorized',))] fn test_public_key_setter_different_account() { let mut state = COMPONENT_STATE(); - let caller = contract_address_const::<0x123>(); - testing::set_contract_address(ACCOUNT_ADDRESS()); - testing::set_caller_address(caller); + let account_address = test_address(); + let new_public_key = KEY_PAIR_2().public_key; + start_cheat_caller_address(account_address, CALLER()); - state.set_public_key(NEW_PUBKEY, array![].span()); + state.set_public_key(new_public_key, array![].span()); } // @@ -401,33 +396,36 @@ fn test_public_key_setter_different_account() { #[test] fn test_public_key_setter_and_getter_camel() { let mut state = COMPONENT_STATE(); - testing::set_contract_address(ACCOUNT_ADDRESS()); - testing::set_caller_address(ACCOUNT_ADDRESS()); + let account_address = test_address(); + let key_pair = KEY_PAIR(); + let new_key_pair = KEY_PAIR_2(); + start_cheat_caller_address(account_address, account_address); - state._set_public_key(PUBKEY); - utils::drop_event(ACCOUNT_ADDRESS()); - let public_key = state.getPublicKey(); - assert_eq!(public_key, PUBKEY); + state._set_public_key(key_pair.public_key); + assert_eq!(state.getPublicKey(), key_pair.public_key); // Set key - state.setPublicKey(NEW_PUBKEY, get_accept_ownership_signature()); + let mut spy = spy_events(); + let signature = get_accept_ownership_signature( + account_address, key_pair.public_key, new_key_pair + ); + state.setPublicKey(new_key_pair.public_key, signature); - assert_event_owner_removed(ACCOUNT_ADDRESS(), PUBKEY); - assert_only_event_owner_added(ACCOUNT_ADDRESS(), NEW_PUBKEY); + spy.assert_event_owner_removed(account_address, key_pair.public_key); + spy.assert_only_event_owner_added(account_address, new_key_pair.public_key); - let public_key = state.getPublicKey(); - assert_eq!(public_key, NEW_PUBKEY); + assert_eq!(state.getPublicKey(), new_key_pair.public_key); } #[test] #[should_panic(expected: ('Account: unauthorized',))] fn test_public_key_setter_different_account_camel() { let mut state = COMPONENT_STATE(); - let caller = contract_address_const::<0x123>(); - testing::set_contract_address(ACCOUNT_ADDRESS()); - testing::set_caller_address(caller); + let account_address = test_address(); + let new_public_key = KEY_PAIR_2().public_key; + start_cheat_caller_address(account_address, CALLER()); - state.setPublicKey(NEW_PUBKEY, array![].span()); + state.setPublicKey(new_public_key, array![].span()); } // @@ -438,12 +436,14 @@ fn test_public_key_setter_different_account_camel() { fn test_initializer() { let mut state = COMPONENT_STATE(); let mock_state = CONTRACT_STATE(); + let account_address = test_address(); + let public_key = KEY_PAIR().public_key; + let mut spy = spy_events(); - state.initializer(PUBKEY); - assert_only_event_owner_added(ZERO(), PUBKEY); + state.initializer(public_key); + spy.assert_only_event_owner_added(account_address, public_key); - let public_key = state.get_public_key(); - assert_eq!(public_key, PUBKEY); + assert_eq!(state.get_public_key(), public_key); let supports_isrc5 = mock_state.supports_interface(ISRC5_ID); assert!(supports_isrc5); @@ -455,9 +455,9 @@ fn test_initializer() { #[test] fn test_assert_only_self_true() { let mut state = COMPONENT_STATE(); + let account_address = test_address(); + start_cheat_caller_address(account_address, account_address); - testing::set_contract_address(ACCOUNT_ADDRESS()); - testing::set_caller_address(ACCOUNT_ADDRESS()); state.assert_only_self(); } @@ -465,88 +465,67 @@ fn test_assert_only_self_true() { #[should_panic(expected: ('Account: unauthorized',))] fn test_assert_only_self_false() { let mut state = COMPONENT_STATE(); + let account_address = test_address(); + start_cheat_caller_address(account_address, OTHER()); - testing::set_contract_address(ACCOUNT_ADDRESS()); - let other = contract_address_const::<0x4567>(); - testing::set_caller_address(other); state.assert_only_self(); } #[test] fn test_assert_valid_new_owner() { - let state = setup(); + let key_pair = KEY_PAIR(); + let state = setup(key_pair); + let account_address = test_address(); + + let new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + account_address, key_pair.public_key, new_key_pair + ); - testing::set_contract_address(ACCOUNT_ADDRESS()); - state.assert_valid_new_owner(PUBKEY, NEW_PUBKEY, get_accept_ownership_signature()); + state.assert_valid_new_owner(key_pair.public_key, new_key_pair.public_key, signature); } #[test] #[should_panic(expected: ('Account: invalid signature',))] fn test_assert_valid_new_owner_invalid_signature() { - let state = setup(); + let key_pair = KEY_PAIR(); + let state = setup(key_pair); - testing::set_contract_address(ACCOUNT_ADDRESS()); - let bad_signature = array![ - 0x2ce8fbcf8a793ee5b2a57254dc96863b696698943e3bc7845285f3851336318, - 0x6009f5720649ff1ceb0aba44f85bec3572c81aecb9d2dada7c0cc70b791debe - ]; - state.assert_valid_new_owner(PUBKEY, NEW_PUBKEY, bad_signature.span()); + let new_key_pair = KEY_PAIR_2(); + let bad_signature = array!['BAD', 'SIGNATURE']; + + state + .assert_valid_new_owner(key_pair.public_key, new_key_pair.public_key, bad_signature.span()); } #[test] fn test__is_valid_signature() { let mut state = COMPONENT_STATE(); - let data = SIGNED_TX_DATA(); - let hash = data.transaction_hash; + let key_pair = KEY_PAIR(); + let data = SIGNED_TX_DATA(key_pair); - let mut good_signature = array![data.r, data.s]; - let mut bad_signature = array![0x987, 0x564]; - let mut invalid_length_signature = array![0x987]; + state._set_public_key(key_pair.public_key); - state._set_public_key(data.public_key); + let good_signature = array![data.r, data.s]; + assert!(state._is_valid_signature(data.tx_hash, good_signature.span())); - let is_valid = state._is_valid_signature(hash, good_signature.span()); - assert!(is_valid); + let bad_signature = array!['BAD', 'SIGNATURE']; + assert!(!state._is_valid_signature(data.tx_hash, bad_signature.span())); - let is_not_valid = !state._is_valid_signature(hash, bad_signature.span()); - assert!(is_not_valid); - - let is_not_valid = !state._is_valid_signature(hash, invalid_length_signature.span()); - assert!(is_not_valid); + let invalid_length_signature = array!['SINGLE_ELEMENT']; + assert!(!state._is_valid_signature(data.tx_hash, invalid_length_signature.span())); } #[test] fn test__set_public_key() { let mut state = COMPONENT_STATE(); - state._set_public_key(PUBKEY); - - assert_only_event_owner_added(ZERO(), PUBKEY); + let mut spy = spy_events(); + let public_key = KEY_PAIR().public_key; + let account_address = test_address(); - let public_key = state.get_public_key(); - assert_eq!(public_key, PUBKEY); -} - -// -// Helpers -// + state._set_public_key(public_key); -fn get_accept_ownership_signature() -> Span { - // 0x7b3d2ce38c132a36e692f6e809b518276d091513af3baf0e94ce2abceee3632 = - // PoseidonTrait::new() - // .update_with('StarkNet Message') - // .update_with('accept_ownership') - // .update_with(ACCOUNT_ADDRESS()) - // .update_with(PUBKEY) - // .finalize(); - - // This signature was computed using starknet js sdk from the following values: - // - private_key: '1234' - // - public_key: 0x26da8d11938b76025862be14fdb8b28438827f73e75e86f7bfa38b196951fa7 - // - msg_hash: 0x7b3d2ce38c132a36e692f6e809b518276d091513af3baf0e94ce2abceee3632 - array![ - 0x1ce8fbcf8a793ee5b2a57254dc96863b696698943e3bc7845285f3851336318, - 0x6009f5720649ff1ceb0aba44f85bec3572c81aecb9d2dada7c0cc70b791debe - ] - .span() + spy.assert_only_event_owner_added(account_address, public_key); + assert_eq!(state.get_public_key(), public_key); } diff --git a/src/tests/account/starknet/test_dual_account.cairo b/src/tests/account/starknet/test_dual_account.cairo index 003075b1f..ab0887896 100644 --- a/src/tests/account/starknet/test_dual_account.cairo +++ b/src/tests/account/starknet/test_dual_account.cairo @@ -2,45 +2,39 @@ use openzeppelin::account::dual_account::{DualCaseAccountABI, DualCaseAccount}; use openzeppelin::account::interface::{AccountABIDispatcherTrait, AccountABIDispatcher}; use openzeppelin::introspection::interface::ISRC5_ID; use openzeppelin::tests::account::starknet::common::SIGNED_TX_DATA; -use openzeppelin::tests::mocks::account_mocks::{ - CamelAccountPanicMock, CamelAccountMock, SnakeAccountMock, SnakeAccountPanicMock -}; -use openzeppelin::tests::mocks::non_implementing_mock::NonImplementingMock; -use openzeppelin::tests::utils::constants::{PUBKEY, NEW_PUBKEY}; +use openzeppelin::tests::utils::constants::TRANSACTION_HASH; +use openzeppelin::tests::utils::constants::stark::{KEY_PAIR, KEY_PAIR_2}; +use openzeppelin::tests::utils::signing::{StarkKeyPair, StarkKeyPairExt}; use openzeppelin::tests::utils; -use starknet::testing; +use snforge_std::{declare, start_cheat_caller_address}; + +use super::common::get_accept_ownership_signature; // // Setup // -fn setup_snake() -> (DualCaseAccount, AccountABIDispatcher) { - let mut calldata = array![PUBKEY]; - let target = utils::deploy(SnakeAccountMock::TEST_CLASS_HASH, calldata); - ( - DualCaseAccount { contract_address: target }, - AccountABIDispatcher { contract_address: target } - ) +fn setup_snake(key_pair: StarkKeyPair) -> (DualCaseAccount, AccountABIDispatcher) { + let calldata = array![key_pair.public_key]; + let contract_address = utils::declare_and_deploy("SnakeAccountMock", calldata); + (DualCaseAccount { contract_address }, AccountABIDispatcher { contract_address }) } -fn setup_camel() -> (DualCaseAccount, AccountABIDispatcher) { - let mut calldata = array![PUBKEY]; - let target = utils::deploy(CamelAccountMock::TEST_CLASS_HASH, calldata); - ( - DualCaseAccount { contract_address: target }, - AccountABIDispatcher { contract_address: target } - ) +fn setup_camel(key_pair: StarkKeyPair) -> (DualCaseAccount, AccountABIDispatcher) { + let calldata = array![key_pair.public_key]; + let contract_address = utils::declare_and_deploy("CamelAccountMock", calldata); + (DualCaseAccount { contract_address }, AccountABIDispatcher { contract_address }) } fn setup_non_account() -> DualCaseAccount { let calldata = array![]; - let target = utils::deploy(NonImplementingMock::TEST_CLASS_HASH, calldata); - DualCaseAccount { contract_address: target } + let contract_address = utils::declare_and_deploy("NonImplementingMock", calldata); + DualCaseAccount { contract_address } } fn setup_account_panic() -> (DualCaseAccount, DualCaseAccount) { - let snake_target = utils::deploy(SnakeAccountPanicMock::TEST_CLASS_HASH, array![]); - let camel_target = utils::deploy(CamelAccountPanicMock::TEST_CLASS_HASH, array![]); + let snake_target = utils::declare_and_deploy("SnakeAccountPanicMock", array![]); + let camel_target = utils::declare_and_deploy("CamelAccountPanicMock", array![]); ( DualCaseAccount { contract_address: snake_target }, DualCaseAccount { contract_address: camel_target } @@ -53,38 +47,46 @@ fn setup_account_panic() -> (DualCaseAccount, DualCaseAccount) { #[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 new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + snake_dispatcher.contract_address, key_pair.public_key, new_key_pair + ); + start_cheat_caller_address(target.contract_address, target.contract_address); - testing::set_contract_address(snake_dispatcher.contract_address); + snake_dispatcher.set_public_key(new_key_pair.public_key, signature); - snake_dispatcher.set_public_key(NEW_PUBKEY, get_accept_ownership_signature_snake()); - - let public_key = target.get_public_key(); - assert_eq!(public_key, NEW_PUBKEY); + assert_eq!(target.get_public_key(), new_key_pair.public_key); } #[test] +#[ignore] // REASON: should_panic attribute not fit for complex panic messages. #[should_panic(expected: ('ENTRYPOINT_NOT_FOUND',))] fn test_dual_no_set_public_key() { let dispatcher = setup_non_account(); - dispatcher.set_public_key(NEW_PUBKEY, array![].span()); + let new_public_key = KEY_PAIR_2().public_key; + dispatcher.set_public_key(new_public_key, array![].span()); } #[test] -#[should_panic(expected: ("Some error", 'ENTRYPOINT_FAILED',))] +#[should_panic(expected: ("Some error",))] fn test_dual_set_public_key_exists_and_panics() { - let (dispatcher, _) = setup_account_panic(); - dispatcher.set_public_key(NEW_PUBKEY, array![].span()); + let (snake_dispatcher, _) = setup_account_panic(); + let new_public_key = KEY_PAIR_2().public_key; + snake_dispatcher.set_public_key(new_public_key, array![].span()); } #[test] fn test_dual_get_public_key() { - let (snake_dispatcher, _) = setup_snake(); - let public_key = snake_dispatcher.get_public_key(); - assert_eq!(public_key, PUBKEY); + let key_pair = KEY_PAIR(); + let (snake_dispatcher, _) = setup_snake(key_pair); + let expected_public_key = key_pair.public_key; + assert_eq!(snake_dispatcher.get_public_key(), expected_public_key); } #[test] +#[ignore] // REASON: should_panic attribute not fit for complex panic messages. #[should_panic(expected: ('ENTRYPOINT_NOT_FOUND',))] fn test_dual_no_get_public_key() { let dispatcher = setup_non_account(); @@ -92,55 +94,51 @@ fn test_dual_no_get_public_key() { } #[test] -#[should_panic(expected: ("Some error", 'ENTRYPOINT_FAILED',))] +#[should_panic(expected: ("Some error",))] fn test_dual_get_public_key_exists_and_panics() { - let (dispatcher, _) = setup_account_panic(); - dispatcher.get_public_key(); + let (snake_dispatcher, _) = setup_account_panic(); + snake_dispatcher.get_public_key(); } #[test] fn test_dual_is_valid_signature() { - let (snake_dispatcher, target) = setup_snake(); - - let data = SIGNED_TX_DATA(); - let hash = data.transaction_hash; - let mut signature = array![data.r, data.s]; + let key_pair = KEY_PAIR(); + let (snake_dispatcher, _) = setup_snake(key_pair); + let tx_hash = TRANSACTION_HASH; + let serialized_signature = key_pair.serialized_sign(tx_hash); - testing::set_contract_address(snake_dispatcher.contract_address); - target.set_public_key(data.public_key, get_accept_ownership_signature_snake()); - - let is_valid = snake_dispatcher.is_valid_signature(hash, signature); + let is_valid = snake_dispatcher.is_valid_signature(tx_hash, serialized_signature); assert_eq!(is_valid, starknet::VALIDATED); } #[test] +#[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", 'ENTRYPOINT_FAILED',))] +#[should_panic(expected: ("Some error",))] fn test_dual_is_valid_signature_exists_and_panics() { - let hash = 0x0; let signature = array![]; + let (snake_dispatcher, _) = setup_account_panic(); - let (dispatcher, _) = setup_account_panic(); - dispatcher.is_valid_signature(hash, signature); + snake_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()); let supports_isrc5 = snake_dispatcher.supports_interface(ISRC5_ID); assert!(supports_isrc5); } #[test] +#[ignore] // REASON: should_panic attribute not fit for complex panic messages. #[should_panic(expected: ('ENTRYPOINT_NOT_FOUND',))] fn test_dual_no_supports_interface() { let dispatcher = setup_non_account(); @@ -148,10 +146,10 @@ fn test_dual_no_supports_interface() { } #[test] -#[should_panic(expected: ("Some error", 'ENTRYPOINT_FAILED',))] +#[should_panic(expected: ("Some error",))] fn test_dual_supports_interface_exists_and_panics() { - let (dispatcher, _) = setup_account_panic(); - dispatcher.supports_interface(ISRC5_ID); + let (snake_dispatcher, _) = setup_account_panic(); + snake_dispatcher.supports_interface(ISRC5_ID); } // @@ -159,102 +157,65 @@ 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 new_key_pair = KEY_PAIR_2(); + let signature = get_accept_ownership_signature( + camel_dispatcher.contract_address, key_pair.public_key, new_key_pair + ); + start_cheat_caller_address(target.contract_address, target.contract_address); - testing::set_contract_address(camel_dispatcher.contract_address); - camel_dispatcher.set_public_key(NEW_PUBKEY, get_accept_ownership_signature_camel()); + camel_dispatcher.set_public_key(new_key_pair.public_key, signature); - let public_key = target.getPublicKey(); - assert_eq!(public_key, NEW_PUBKEY); + assert_eq!(target.getPublicKey(), new_key_pair.public_key); } #[test] -#[should_panic(expected: ("Some error", 'ENTRYPOINT_FAILED',))] +#[ignore] // REASON: foundry entrypoint_not_found error message inconsistent with mainnet. +#[should_panic(expected: ("Some error",))] fn test_dual_setPublicKey_exists_and_panics() { - let (_, dispatcher) = setup_account_panic(); - dispatcher.set_public_key(NEW_PUBKEY, array![].span()); + let (_, camel_dispatcher) = setup_account_panic(); + let new_public_key = KEY_PAIR_2().public_key; + camel_dispatcher.set_public_key(new_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(); - let public_key = camel_dispatcher.get_public_key(); - assert_eq!(public_key, PUBKEY); + let key_pair = KEY_PAIR(); + let (camel_dispatcher, _) = setup_camel(key_pair); + let expected_public_key = key_pair.public_key; + assert_eq!(camel_dispatcher.get_public_key(), expected_public_key); } #[test] -#[should_panic(expected: ("Some error", 'ENTRYPOINT_FAILED',))] +#[ignore] // REASON: foundry entrypoint_not_found error message inconsistent with mainnet. +#[should_panic(expected: ("Some error",))] fn test_dual_getPublicKey_exists_and_panics() { - let (_, dispatcher) = setup_account_panic(); - dispatcher.get_public_key(); + let (_, camel_dispatcher) = setup_account_panic(); + camel_dispatcher.get_public_key(); } #[test] +#[ignore] // REASON: foundry entrypoint_not_found error message inconsistent with mainnet. fn test_dual_isValidSignature() { - let (camel_dispatcher, target) = setup_camel(); - - let data = SIGNED_TX_DATA(); - let hash = data.transaction_hash; - let signature = array![data.r, data.s]; - - testing::set_contract_address(camel_dispatcher.contract_address); - target.setPublicKey(data.public_key, get_accept_ownership_signature_camel()); + let key_pair = KEY_PAIR(); + let (camel_dispatcher, _) = setup_camel(key_pair); + let tx_hash = TRANSACTION_HASH; + let serialized_signature = key_pair.serialized_sign(tx_hash); - let is_valid = camel_dispatcher.is_valid_signature(hash, signature); + let is_valid = camel_dispatcher.is_valid_signature(tx_hash, serialized_signature); assert_eq!(is_valid, starknet::VALIDATED); } #[test] -#[should_panic(expected: ("Some error", 'ENTRYPOINT_FAILED',))] +#[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); -} - -// -// Helpers -// - -fn get_accept_ownership_signature_snake() -> Span { - // 0x26a14ae81fad8adcb81337e49fd68ac44d508cfca09c4a6167c71e85759e98d = - // PoseidonTrait::new() - // .update_with('StarkNet Message') - // .update_with('accept_ownership') - // .update_with(snake_dispatcher.contract_address) - // .update_with(PUBKEY) - // .finalize(); - - // This signature was computed using starknet js sdk from the following values: - // - private_key: '1234' - // - public_key: 0x26da8d11938b76025862be14fdb8b28438827f73e75e86f7bfa38b196951fa7 - // - msg_hash: 0x26a14ae81fad8adcb81337e49fd68ac44d508cfca09c4a6167c71e85759e98d - array![ - 0x14de5d99a3a43bc7e8e0ddf8ff72fab172798ac3dd7bd858d4f6f489a2a4bcb, - 0x88dd5cb7f27a8932a5c6d226b486830e952e3d9e78996e7ca2315afa9c0be2 - ] - .span() -} - -fn get_accept_ownership_signature_camel() -> Span { - // 0x1e2acd787c2778bebfbf4d8770fdc0834db1576b5fd190f35afae5a6f7f469f = - // PoseidonTrait::new() - // .update_with('StarkNet Message') - // .update_with('accept_ownership') - // .update_with(camel_dispatcher.contract_address) - // .update_with(PUBKEY) - // .finalize(); - - // This signature was computed using starknet js sdk from the following values: - // - private_key: '1234' - // - public_key: 0x26da8d11938b76025862be14fdb8b28438827f73e75e86f7bfa38b196951fa7 - // - msg_hash: 0x1e2acd787c2778bebfbf4d8770fdc0834db1576b5fd190f35afae5a6f7f469f - array![ - 0xd0eab69db72a46ee0fb39c833cfaec035ca809eb884285d0e603262f15e0dd, - 0x768e984a96d5f731c3cf1660c5a00f508f3d99d8240bf3ba4c3e69561a545d1 - ] - .span() + let (_, camel_dispatcher) = setup_account_panic(); + camel_dispatcher.is_valid_signature(TRANSACTION_HASH, signature); } diff --git a/src/tests/account/test_signature.cairo b/src/tests/account/test_signature.cairo index 7da6fe741..548afb817 100644 --- a/src/tests/account/test_signature.cairo +++ b/src/tests/account/test_signature.cairo @@ -1,5 +1,5 @@ use openzeppelin::account::utils::signature::{is_valid_stark_signature, is_valid_eth_signature}; -use openzeppelin::tests::utils::constants::secp256k1::KEY_PAIR; +use openzeppelin::tests::utils::constants::{stark, secp256k1}; use starknet::secp256_trait::Secp256Trait; use starknet::secp256k1::Secp256k1Point; @@ -12,34 +12,31 @@ use super::starknet::common::SIGNED_TX_DATA as stark_signature_data; #[test] fn test_is_valid_stark_signature_good_sig() { - let data = stark_signature_data(); - let hash = data.tx_hash; + let key_pair = stark::KEY_PAIR(); + let data = stark_signature_data(key_pair); + let good_signature = array![data.r, data.s].span(); - let mut good_signature = array![data.r, data.s].span(); - - let is_valid = is_valid_stark_signature(hash, data.public_key, good_signature); + let is_valid = is_valid_stark_signature(data.tx_hash, key_pair.public_key, good_signature); assert!(is_valid); } #[test] fn test_is_valid_stark_signature_bad_sig() { - let data = stark_signature_data(); - let hash = data.tx_hash; - - let mut bad_signature = array![0x987, 0x564].span(); + let key_pair = stark::KEY_PAIR(); + let data = stark_signature_data(key_pair); + let bad_signature = array!['BAD', 'SIGNATURE'].span(); - let is_invalid = !is_valid_stark_signature(hash, data.public_key, bad_signature); + let is_invalid = !is_valid_stark_signature(data.tx_hash, key_pair.public_key, bad_signature); assert!(is_invalid); } #[test] fn test_is_valid_stark_signature_invalid_len_sig() { - let data = stark_signature_data(); - let hash = data.tx_hash; - - let mut bad_signature = array![0x987].span(); + let key_pair = stark::KEY_PAIR(); + let data = stark_signature_data(key_pair); + let bad_signature = array!['BAD_SIGNATURE'].span(); - let is_invalid = !is_valid_stark_signature(hash, data.public_key, bad_signature); + let is_invalid = !is_valid_stark_signature(data.tx_hash, key_pair.public_key, bad_signature); assert!(is_invalid); } @@ -49,21 +46,20 @@ fn test_is_valid_stark_signature_invalid_len_sig() { #[test] fn test_is_valid_eth_signature_good_sig() { - let data = eth_signature_data(KEY_PAIR()); - let hash = data.tx_hash; + let data = eth_signature_data(secp256k1::KEY_PAIR()); let mut serialized_good_signature = array![]; - data.signature.serialize(ref serialized_good_signature); - let is_valid = is_valid_eth_signature(hash, data.public_key, serialized_good_signature.span()); + let is_valid = is_valid_eth_signature( + data.tx_hash, data.public_key, serialized_good_signature.span() + ); assert!(is_valid); } #[test] fn test_is_valid_eth_signature_bad_sig() { - let data = eth_signature_data(KEY_PAIR()); - let hash = data.tx_hash; + let data = eth_signature_data(secp256k1::KEY_PAIR()); let mut bad_signature = data.signature; bad_signature.r += 1; @@ -73,7 +69,7 @@ fn test_is_valid_eth_signature_bad_sig() { bad_signature.serialize(ref serialized_bad_signature); let is_invalid = !is_valid_eth_signature( - hash, data.public_key, serialized_bad_signature.span() + data.tx_hash, data.public_key, serialized_bad_signature.span() ); assert!(is_invalid); } @@ -81,18 +77,15 @@ 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(KEY_PAIR()); - let hash = data.tx_hash; - + let data = eth_signature_data(secp256k1::KEY_PAIR()); let mut serialized_bad_signature = array![0x1]; - is_valid_eth_signature(hash, data.public_key, serialized_bad_signature.span()); + is_valid_eth_signature(data.tx_hash, data.public_key, serialized_bad_signature.span()); } #[test] fn test_signature_r_out_of_range() { - let data = eth_signature_data(KEY_PAIR()); - let hash = data.tx_hash; + let data = eth_signature_data(secp256k1::KEY_PAIR()); let mut bad_signature = data.signature; let curve_size = Secp256Trait::::get_curve_size(); @@ -104,15 +97,14 @@ fn test_signature_r_out_of_range() { bad_signature.serialize(ref serialized_bad_signature); let is_invalid = !is_valid_eth_signature( - hash, data.public_key, serialized_bad_signature.span() + data.tx_hash, data.public_key, serialized_bad_signature.span() ); assert!(is_invalid); } #[test] fn test_signature_s_out_of_range() { - let data = eth_signature_data(KEY_PAIR()); - let hash = data.tx_hash; + let data = eth_signature_data(secp256k1::KEY_PAIR()); let mut bad_signature = data.signature; let curve_size = Secp256Trait::::get_curve_size(); @@ -124,7 +116,7 @@ fn test_signature_s_out_of_range() { bad_signature.serialize(ref serialized_bad_signature); let is_invalid = !is_valid_eth_signature( - hash, data.public_key, serialized_bad_signature.span() + data.tx_hash, data.public_key, serialized_bad_signature.span() ); assert!(is_invalid); } diff --git a/src/tests/utils/constants.cairo b/src/tests/utils/constants.cairo index 2259ef968..4d8df0911 100644 --- a/src/tests/utils/constants.cairo +++ b/src/tests/utils/constants.cairo @@ -124,13 +124,25 @@ pub(crate) fn EMPTY_DATA() -> Span { pub(crate) mod secp256k1 { use openzeppelin::tests::utils::signing::{Secp256k1KeyPair, get_secp256k1_keys_from}; - pub(crate) const PRIVATE_KEY: u256 = u256 { low: 'PRIVATE_LOW', high: 'PRIVATE_HIGH' }; pub(crate) fn KEY_PAIR() -> Secp256k1KeyPair { - get_secp256k1_keys_from(PRIVATE_KEY) + let private_key = u256 { low: 'PRIVATE_LOW', high: 'PRIVATE_HIGH' }; + get_secp256k1_keys_from(private_key) } - pub(crate) const PRIVATE_KEY_2: u256 = u256 { low: 'PRIVATE_LOW_2', high: 'PRIVATE_HIGH_2' }; pub(crate) fn KEY_PAIR_2() -> Secp256k1KeyPair { - get_secp256k1_keys_from(PRIVATE_KEY_2) + let private_key = u256 { low: 'PRIVATE_LOW_2', high: 'PRIVATE_HIGH_2' }; + get_secp256k1_keys_from(private_key) + } +} + +pub(crate) mod stark { + use openzeppelin::tests::utils::signing::{StarkKeyPair, get_stark_keys_from}; + + pub(crate) fn KEY_PAIR() -> StarkKeyPair { + get_stark_keys_from('PRIVATE_KEY') + } + + pub(crate) fn KEY_PAIR_2() -> StarkKeyPair { + get_stark_keys_from('PRIVATE_KEY_2') } } diff --git a/src/tests/utils/signing.cairo b/src/tests/utils/signing.cairo index ee596c8d0..8b1e7ca44 100644 --- a/src/tests/utils/signing.cairo +++ b/src/tests/utils/signing.cairo @@ -14,6 +14,14 @@ pub fn get_secp256k1_keys_from(private_key: u256) -> Secp256k1KeyPair { Secp256k1CurveKeyPairImpl::from_secret_key(private_key) } +#[generate_trait] +pub impl StarkKeyPairExt of StarkKeyPairExtTrait { + fn serialized_sign(self: StarkKeyPair, msg: felt252) -> Array { + let (r, s) = self.sign(msg).unwrap(); + array![r, s] + } +} + #[generate_trait] pub impl Secp256k1KeyPairExt of Secp256k1KeyPairExtTrait { fn serialized_sign(self: Secp256k1KeyPair, msg: u256) -> Array {