feat: impl constructor

Author: noa-starkware

packages/usdc_migration/Scarb.toml

@@ -22,6 +22,7 @@ starkware_utils_testing.workspace = true
 
 [[test]]
 name = "usdc_migration_unittest"
+build-external-contracts = ["starkware_utils::erc20::erc20_mocks::DualCaseERC20Mock"]
 
 [scripts]
 test = "SNFORGE_BACKTRACE=1 snforge test"

packages/usdc_migration/src/tests.cairo

@@ -1 +1,4 @@
-pub mod test_usdc_migration;
+#[cfg(test)]
+pub(crate) mod test_usdc_migration;
+#[cfg(test)]
+pub(crate) mod test_utils;

packages/usdc_migration/src/tests/test_usdc_migration.cairo

@@ -1 +1,34 @@
-
+use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+use starkware_utils::constants::MAX_U256;
+use usdc_migration::tests::test_utils::{deploy_usdc_migration, load_contract_address};
+#[test]
+fn test_constructor() {
+    let cfg = deploy_usdc_migration();
+    let usdc_migration_contract = cfg.usdc_migration_contract;
+    // Assert contract storage is initialized correctly.
+    assert_eq!(
+        cfg.usdc_e_token, load_contract_address(usdc_migration_contract, selector!("usdc_e_token")),
+    );
+    assert_eq!(
+        cfg.usdc_token, load_contract_address(usdc_migration_contract, selector!("usdc_token")),
+    );
+    assert_eq!(
+        cfg.owner_l1_address,
+        load_contract_address(usdc_migration_contract, selector!("owner_l1_address")),
+    );
+    assert_eq!(
+        cfg.owner_l2_address,
+        load_contract_address(usdc_migration_contract, selector!("owner_l2_address")),
+    );
+    // Assert infinite approval to owner_l2_address for both USDC.e and USDC.
+    let usdc_e_dispacther = IERC20Dispatcher { contract_address: cfg.usdc_e_token };
+    let usdc_dispacther = IERC20Dispatcher { contract_address: cfg.usdc_token };
+    assert_eq!(
+        usdc_e_dispacther.allowance(owner: usdc_migration_contract, spender: cfg.owner_l2_address),
+        MAX_U256,
+    );
+    assert_eq!(
+        usdc_dispacther.allowance(owner: usdc_migration_contract, spender: cfg.owner_l2_address),
+        MAX_U256,
+    );
+}

packages/usdc_migration/src/tests/test_utils.cairo

@@ -0,0 +1,60 @@
+use constants::{INITIAL_SUPPLY, OWNER_ADDRESS};
+use snforge_std::{ContractClassTrait, DeclareResultTrait};
+use starknet::ContractAddress;
+use starkware_utils_testing::test_utils::{Deployable, TokenConfig};
+
+#[derive(Debug, Drop, Copy)]
+pub(crate) struct USDCMigrationCfg {
+    pub usdc_migration_contract: ContractAddress,
+    pub usdc_e_token: ContractAddress,
+    pub usdc_token: ContractAddress,
+    pub owner_l1_address: ContractAddress,
+    pub owner_l2_address: ContractAddress,
+}
+
+pub(crate) mod constants {
+    use starknet::ContractAddress;
+
+    pub const INITIAL_SUPPLY: u256 = 1000000000000000000000000000;
+    pub fn OWNER_ADDRESS() -> ContractAddress {
+        'OWNER_ADDRESS'.try_into().unwrap()
+    }
+}
+
+pub(crate) fn deploy_usdc_migration() -> USDCMigrationCfg {
+    // Deploy USDC-E and USDC tokens.
+    let usdc_e_config = TokenConfig {
+        name: "USDC-E", symbol: "USDC-E", initial_supply: INITIAL_SUPPLY, owner: OWNER_ADDRESS(),
+    };
+    let usdc_config = TokenConfig {
+        name: "USDC", symbol: "USDC", initial_supply: INITIAL_SUPPLY, owner: OWNER_ADDRESS(),
+    };
+    let usdc_e_state = usdc_e_config.deploy();
+    let usdc_state = usdc_config.deploy();
+    let usdc_e_token = usdc_e_state.address;
+    let usdc_token = usdc_state.address;
+    // Deploy USDCMigration contract.
+    let mut calldata = ArrayTrait::new();
+    usdc_e_token.serialize(ref calldata);
+    usdc_token.serialize(ref calldata);
+    OWNER_ADDRESS().serialize(ref calldata);
+    OWNER_ADDRESS().serialize(ref calldata);
+    let usdc_migration_contract = snforge_std::declare("USDCMigration").unwrap().contract_class();
+    let (usdc_migration_contract_address, _) = usdc_migration_contract.deploy(@calldata).unwrap();
+    // Return the configuration with the deployed contract address.
+    USDCMigrationCfg {
+        usdc_migration_contract: usdc_migration_contract_address,
+        usdc_e_token,
+        usdc_token,
+        owner_l2_address: OWNER_ADDRESS(),
+        owner_l1_address: OWNER_ADDRESS(),
+    }
+}
+
+// TODO: Move to starkware_utils_testing.
+pub(crate) fn load_contract_address(
+    target: ContractAddress, storage_address: felt252,
+) -> ContractAddress {
+    let value = snforge_std::load(:target, :storage_address, size: 1);
+    (*value[0]).try_into().unwrap()
+}

packages/usdc_migration/src/usdc_migration.cairo

@@ -1,10 +1,21 @@
 #[starknet::contract]
 pub mod USDCMigration {
-    //use statements
+    use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+    use starknet::ContractAddress;
+    use starknet::storage::StoragePointerWriteAccess;
+    use starkware_utils::constants::MAX_U256;
     use usdc_migration::interface::IUSDCMigration;
 
     #[storage]
-    struct Storage { //storage variables
+    struct Storage {
+        /// Deprecated USDC.e token address.
+        usdc_e_token: ContractAddress,
+        /// New USDC token address.
+        usdc_token: ContractAddress,
+        /// Address in L1 that gets the USDC.e.
+        owner_l1_address: ContractAddress,
+        /// Address in L2 that gets the remaining USDC.
+        owner_l2_address: ContractAddress,
     }
 
     #[event]
@@ -13,7 +24,22 @@ pub mod USDCMigration {
     }
 
     #[constructor]
-    fn constructor(ref self: ContractState) { //constructor logic
+    fn constructor(
+        ref self: ContractState,
+        usdc_e_token: ContractAddress,
+        usdc_token: ContractAddress,
+        owner_l1_address: ContractAddress,
+        owner_l2_address: ContractAddress,
+    ) {
+        self.usdc_e_token.write(usdc_e_token);
+        self.usdc_token.write(usdc_token);
+        self.owner_l1_address.write(owner_l1_address);
+        self.owner_l2_address.write(owner_l2_address);
+        // Infinite approval to l2 address for both USDC.e and USDC.
+        let usdc_e_dispacther = IERC20Dispatcher { contract_address: usdc_e_token };
+        let usdc_dispacther = IERC20Dispatcher { contract_address: usdc_token };
+        usdc_e_dispacther.approve(spender: owner_l2_address, amount: MAX_U256);
+        usdc_dispacther.approve(spender: owner_l2_address, amount: MAX_U256);
     }
 
     #[abi(embed_v0)]