erc20 dual dispatcher

src/openzeppelin/access/ownable/dual_ownable.cairo

@@ -6,12 +6,12 @@ use starknet::ContractAddress;
 use starknet::Felt252TryIntoContractAddress;
 use starknet::SyscallResultTrait;
 use starknet::call_contract_syscall;
-use traits::Into;
 use traits::TryInto;
 
 use openzeppelin::utils::try_selector_with_fallback;
 use openzeppelin::utils::Felt252TryIntoBool;
 use openzeppelin::utils::selectors;
+use openzeppelin::utils::serde::SerializedAppend;
 
 #[derive(Copy, Drop)]
 struct DualCaseOwnable {
@@ -26,7 +26,9 @@ trait DualCaseOwnableTrait {
 
 impl DualCaseOwnableImpl of DualCaseOwnableTrait {
     fn owner(self: @DualCaseOwnable) -> ContractAddress {
-        (*call_contract_syscall(*self.contract_address, selectors::owner, ArrayTrait::new().span())
+        let args = ArrayTrait::new();
+
+        (*call_contract_syscall(*self.contract_address, selectors::owner, args.span())
             .unwrap_syscall()
             .at(0))
             .try_into()
@@ -35,7 +37,7 @@ impl DualCaseOwnableImpl of DualCaseOwnableTrait {
 
     fn transfer_ownership(self: @DualCaseOwnable, new_owner: ContractAddress) {
         let mut args = ArrayTrait::new();
-        args.append(new_owner.into());
+        args.append_serde(new_owner);
 
         try_selector_with_fallback(
             *self.contract_address,

src/openzeppelin/tests.cairo

@@ -2,9 +2,7 @@ mod access;
 mod test_reentrancyguard;
 mod test_src5;
 mod test_account;
-mod test_erc20;
-mod test_erc721;
-mod test_dual721;
+mod token;
 mod test_initializable;
 mod test_pausable;
 mod mocks;

src/openzeppelin/tests/mocks.cairo

@@ -3,6 +3,10 @@ mod reentrancy_mock;
 mod erc721_receiver;
 mod erc721_panic_mock;
 mod mock_pausable;
+mod camel20_mock;
+mod snake20_mock;
+mod erc20_panic;
+mod non721_mock;
 mod accesscontrol_panic_mock;
 mod camel_accesscontrol_mock;
 mod snake_accesscontrol_mock;

src/openzeppelin/tests/mocks/camel20_mock.cairo

@@ -0,0 +1,58 @@
+#[contract]
+mod CamelERC20Mock {
+    use starknet::ContractAddress;
+    use openzeppelin::token::erc20::ERC20;
+
+    #[constructor]
+    fn constructor(
+        name: felt252, symbol: felt252, initial_supply: u256, recipient: ContractAddress
+    ) {
+        ERC20::initializer(name, symbol);
+        ERC20::_mint(recipient, initial_supply);
+    }
+
+    #[view]
+    fn name() -> felt252 {
+        ERC20::name()
+    }
+
+    #[view]
+    fn symbol() -> felt252 {
+        ERC20::symbol()
+    }
+
+    #[view]
+    fn decimals() -> u8 {
+        ERC20::decimals()
+    }
+
+    #[view]
+    fn totalSupply() -> u256 {
+        ERC20::totalSupply()
+    }
+
+    #[view]
+    fn balanceOf(account: ContractAddress) -> u256 {
+        ERC20::balanceOf(account)
+    }
+
+    #[view]
+    fn allowance(owner: ContractAddress, spender: ContractAddress) -> u256 {
+        ERC20::allowance(owner, spender)
+    }
+
+    #[external]
+    fn transfer(recipient: ContractAddress, amount: u256) -> bool {
+        ERC20::transfer(recipient, amount)
+    }
+
+    #[external]
+    fn transferFrom(sender: ContractAddress, recipient: ContractAddress, amount: u256) -> bool {
+        ERC20::transferFrom(sender, recipient, amount)
+    }
+
+    #[external]
+    fn approve(spender: ContractAddress, amount: u256) -> bool {
+        ERC20::approve(spender, amount)
+    }
+}

src/openzeppelin/tests/mocks/erc20_panic.cairo

@@ -0,0 +1,96 @@
+// Although these modules are designed to panic, functions
+// still need a valid return value. We chose:
+//
+// 3 for felt252 and u8
+// zero for ContractAddress
+// false for bool
+// u256 { 3, 3 } for u256
+
+#[contract]
+mod SnakeERC20Panic {
+    use starknet::ContractAddress;
+
+    ///
+    /// Agnostic
+    ///
+
+    #[view]
+    fn name() -> felt252 {
+        panic_with_felt252('Some error');
+        3
+    }
+
+    #[view]
+    fn symbol() -> felt252 {
+        panic_with_felt252('Some error');
+        3
+    }
+
+    #[view]
+    fn decimals() -> u8 {
+        panic_with_felt252('Some error');
+        3_u8
+    }
+
+    #[view]
+    fn allowance(owner: ContractAddress, spender: ContractAddress) -> u256 {
+        panic_with_felt252('Some error');
+        u256 { low: 3, high: 3 }
+    }
+
+    #[external]
+    fn transfer(recipient: ContractAddress, amount: u256) -> bool {
+        panic_with_felt252('Some error');
+        false
+    }
+
+    #[external]
+    fn approve(to: ContractAddress, token_id: u256) -> bool {
+        panic_with_felt252('Some error');
+        false
+    }
+
+    ///
+    /// Snake
+    ///
+
+    #[view]
+    fn total_supply() -> u256 {
+        panic_with_felt252('Some error');
+        u256 { low: 3, high: 3 }
+    }
+
+    #[view]
+    fn balance_of(account: ContractAddress) -> u256 {
+        panic_with_felt252('Some error');
+        u256 { low: 3, high: 3 }
+    }
+
+    #[external]
+    fn transfer_from(from: ContractAddress, to: ContractAddress, amount: u256) -> bool {
+        panic_with_felt252('Some error');
+        false
+    }
+}
+
+#[contract]
+mod CamelERC20Panic {
+    use starknet::ContractAddress;
+
+    #[view]
+    fn totalSupply() -> u256 {
+        panic_with_felt252('Some error');
+        u256 { low: 3, high: 3 }
+    }
+
+    #[view]
+    fn balanceOf(account: ContractAddress) -> u256 {
+        panic_with_felt252('Some error');
+        u256 { low: 3, high: 3 }
+    }
+
+    #[external]
+    fn transferFrom(sender: ContractAddress, recipient: ContractAddress, amount: u256) {
+        panic_with_felt252('Some error');
+    }
+}

src/openzeppelin/tests/mocks/non721_mock.cairo

@@ -0,0 +1,7 @@
+#[contract]
+mod NonERC721 {
+    #[view]
+    fn nope() -> bool {
+        false
+    }
+}

src/openzeppelin/tests/mocks/snake20_mock.cairo

@@ -0,0 +1,58 @@
+#[contract]
+mod SnakeERC20Mock {
+    use starknet::ContractAddress;
+    use openzeppelin::token::erc20::ERC20;
+
+    #[constructor]
+    fn constructor(
+        name: felt252, symbol: felt252, initial_supply: u256, recipient: ContractAddress
+    ) {
+        ERC20::initializer(name, symbol);
+        ERC20::_mint(recipient, initial_supply);
+    }
+
+    #[view]
+    fn name() -> felt252 {
+        ERC20::name()
+    }
+
+    #[view]
+    fn symbol() -> felt252 {
+        ERC20::symbol()
+    }
+
+    #[view]
+    fn decimals() -> u8 {
+        ERC20::decimals()
+    }
+
+    #[view]
+    fn total_supply() -> u256 {
+        ERC20::total_supply()
+    }
+
+    #[view]
+    fn balance_of(account: ContractAddress) -> u256 {
+        ERC20::balance_of(account)
+    }
+
+    #[view]
+    fn allowance(owner: ContractAddress, spender: ContractAddress) -> u256 {
+        ERC20::allowance(owner, spender)
+    }
+
+    #[external]
+    fn transfer(recipient: ContractAddress, amount: u256) -> bool {
+        ERC20::transfer(recipient, amount)
+    }
+
+    #[external]
+    fn transfer_from(sender: ContractAddress, recipient: ContractAddress, amount: u256) -> bool {
+        ERC20::transfer_from(sender, recipient, amount)
+    }
+
+    #[external]
+    fn approve(spender: ContractAddress, amount: u256) -> bool {
+        ERC20::approve(spender, amount)
+    }
+}

src/openzeppelin/tests/test_account.cairo

@@ -17,12 +17,13 @@ use openzeppelin::account::TRANSACTION_VERSION;
 use openzeppelin::introspection::src5::ISRC5_ID;
 use openzeppelin::tests::utils;
 use openzeppelin::token::erc20::ERC20;
-use openzeppelin::token::erc20::IERC20Dispatcher;
-use openzeppelin::token::erc20::IERC20DispatcherTrait;
+use openzeppelin::token::erc20::interface::IERC20Dispatcher;
+use openzeppelin::token::erc20::interface::IERC20DispatcherTrait;
+use openzeppelin::utils::selectors;
+use openzeppelin::utils::serde::SerializedAppend;
 
 const PUBLIC_KEY: felt252 = 0x333333;
 const NEW_PUBKEY: felt252 = 0x789789;
-const TRANSFER_SELECTOR: felt252 = 0x83afd3f4caedc6eebf44246fe54e38c95e3179a5ec9ea81740eca5b482d12e;
 const SALT: felt252 = 123;
 
 #[derive(Drop)]
@@ -81,11 +82,10 @@ fn deploy_erc20(recipient: ContractAddress, initial_supply: u256) -> IERC20Dispa
     let symbol = 0;
     let mut calldata = ArrayTrait::new();
 
-    calldata.append(name);
-    calldata.append(symbol);
-    calldata.append(initial_supply.low.into());
-    calldata.append(initial_supply.high.into());
-    calldata.append(recipient.into());
+    calldata.append_serde(name);
+    calldata.append_serde(symbol);
+    calldata.append_serde(initial_supply);
+    calldata.append_serde(recipient);
 
     let address = utils::deploy(ERC20::TEST_CLASS_HASH, calldata);
     IERC20Dispatcher { contract_address: address }
@@ -241,10 +241,11 @@ fn test_execute_with_version(version: Option<felt252>) {
     // Craft call and add to calls array
     let mut calldata = ArrayTrait::new();
     let amount: u256 = 200;
-    calldata.append(recipient.into());
-    calldata.append(amount.low.into());
-    calldata.append(amount.high.into());
-    let call = Call { to: erc20.contract_address, selector: TRANSFER_SELECTOR, calldata: calldata };
+    calldata.append_serde(recipient);
+    calldata.append_serde(amount);
+    let call = Call {
+        to: erc20.contract_address, selector: selectors::transfer, calldata: calldata
+    };
     let mut calls = ArrayTrait::new();
     calls.append(call);
 
@@ -318,21 +319,19 @@ fn test_multicall() {
     // Craft call1
     let mut calldata1 = ArrayTrait::new();
     let amount1: u256 = 300;
-    calldata1.append(recipient1.into());
-    calldata1.append(amount1.low.into());
-    calldata1.append(amount1.high.into());
+    calldata1.append_serde(recipient1);
+    calldata1.append_serde(amount1);
     let call1 = Call {
-        to: erc20.contract_address, selector: TRANSFER_SELECTOR, calldata: calldata1
+        to: erc20.contract_address, selector: selectors::transfer, calldata: calldata1
     };
 
     // Craft call2
     let mut calldata2 = ArrayTrait::new();
     let amount2: u256 = 500;
-    calldata2.append(recipient2.into());
-    calldata2.append(amount2.low.into());
-    calldata2.append(amount2.high.into());
+    calldata2.append_serde(recipient2);
+    calldata2.append_serde(amount2);
     let call2 = Call {
-        to: erc20.contract_address, selector: TRANSFER_SELECTOR, calldata: calldata2
+        to: erc20.contract_address, selector: selectors::transfer, calldata: calldata2
     };
 
     // Bundle calls and exeute