feat: recycle implementation

Author: arad-starkware

packages/usdc_migration/src/interface.cairo

@@ -3,6 +3,7 @@ pub trait IUSDCMigration<T> {
     /// Exchange `amount` of legacy token for new token.
     /// Precondition: Caller has approved the contract to spend `amount` of legacy token.
     fn exchange_legacy_for_new(ref self: T, amount: u256);
+    fn recycle(ref self: T);
 }
 
 #[starknet::interface]

packages/usdc_migration/src/lib.cairo

@@ -1,6 +1,7 @@
 pub mod errors;
 pub mod events;
 pub mod interface;
+pub(crate) mod starkgate_interface;
 
 #[cfg(test)]
 pub mod tests;

packages/usdc_migration/src/starkgate_interface.cairo

@@ -0,0 +1,9 @@
+use starknet::{ContractAddress, EthAddress};
+
+#[starknet::interface]
+pub(crate) trait ITokenBridge<TContractState> {
+    fn get_l1_token(self: @TContractState, l2_token: ContractAddress) -> EthAddress;
+    fn initiate_token_withdraw(
+        ref self: TContractState, l1_token: EthAddress, l1_recipient: EthAddress, amount: u256,
+    );
+}

packages/usdc_migration/src/token_bridge_mock.cairo

@@ -0,0 +1,32 @@
+#[starknet::contract]
+pub mod TokenBridgeMock {
+    use starknet::{ContractAddress, EthAddress};
+
+    #[storage]
+    struct Storage {
+        l1_token_address: EthAddress,
+        l2_token_address: ContractAddress,
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState, l1_token_address: EthAddress, l2_token_address: ContractAddress,
+    ) {
+        self.l1_token_address.write(l1_token_address);
+        self.l2_token_address.write(l2_token_address);
+    }
+
+    #[abi(embed_v0)]
+    pub impl TokenBridgeMockImpl of ITokenBridge<ContractState> {
+        fn get_l1_token(self: @ContractState, l2_token: ContractAddress) -> EthAddress {
+            assert_eq!(l2_token, self.l2_token_address.read(), "Invalid L2 token address");
+            self.l1_token_address.read()
+        }
+
+        fn initiate_token_withdraw(
+            ref self: ContractState, l1_token: EthAddress, l1_recipient: EthAddress, amount: u256,
+        ) {
+            assert_eq!(l1_token, self.l1_token_address.read(), "Invalid L1 token address");
+        }
+    }
+}

packages/usdc_migration/src/usdc_migration.cairo

@@ -7,6 +7,7 @@ pub mod USDCMigration {
     use usdc_migration::errors::USDCMigrationError;
     use usdc_migration::events::USDCMigrationEvents;
     use usdc_migration::interface::{IUSDCMigration, IUSDCMigrationConfig};
+    use usdc_migration::starkgate_interface::{ITokenBridgeDispatcher, ITokenBridgeDispatcherTrait};
 
     #[storage]
     struct Storage {
@@ -18,10 +19,14 @@ pub mod USDCMigration {
         l1_recipient: EthAddress,
         /// Address in L2 that gets the remaining USDC.
         owner_l2_address: ContractAddress,
-        /// Token bridge address.
-        starkgate_address: ContractAddress,
+        /// Token bridge dispatcher.
+        starkgate_dispatcher: ITokenBridgeDispatcher,
         /// The threshold amount of legacy token balance, that triggers sending to L1.
         legacy_threshold: u256,
+        /// Amount to send to L1 per recycle.
+        l1_transfer_unit: u256,
+        /// L1 USDC token address.
+        l1_usdc_token_address: EthAddress,
     }
 
     #[event]
@@ -42,11 +47,12 @@ pub mod USDCMigration {
     ) {
         let legacy_dispatcher = IERC20Dispatcher { contract_address: legacy_token };
         let new_dispatcher = IERC20Dispatcher { contract_address: new_token };
+        let starkgate_dispatcher = ITokenBridgeDispatcher { contract_address: starkgate_address };
         self.legacy_token_dispatcher.write(legacy_dispatcher);
         self.new_token_dispatcher.write(new_dispatcher);
         self.l1_recipient.write(l1_recipient);
         self.owner_l2_address.write(owner_l2_address);
-        self.starkgate_address.write(starkgate_address);
+        self.starkgate_dispatcher.write(starkgate_dispatcher);
         self.legacy_threshold.write(legacy_threshold);
         // Infinite approval to l2 address for both legacy and new tokens.
         legacy_dispatcher.approve(spender: owner_l2_address, amount: MAX_U256);
@@ -74,7 +80,41 @@ pub mod USDCMigration {
             new_token_dispatcher.transfer(recipient: caller_address, :amount);
 
             self.emit(USDCMigrationEvents::USDCMigratedEvent { user: caller_address, amount });
-            // TODO: send to l1 if threshold is reached.
+            self._recycle(:contract_address);
+        }
+
+        fn recycle(ref self: ContractState) {
+            let contract_address = get_contract_address();
+            self._recycle(:contract_address);
+        }
+    }
+
+    #[generate_trait]
+    impl InternalUSDCMigration of InternalUSDCMigrationTrait {
+        fn _recycle(self: @ContractState, contract_address: ContractAddress) {
+            let legacy_balance = self
+                .legacy_token_dispatcher
+                .read()
+                .balance_of(account: contract_address);
+            if (legacy_balance >= self.threshold.read()) {
+                self.send_units_to_l1(amount: legacy_balance);
+            }
+        }
+
+        fn send_units_to_l1(self: @ContractState, mut amount: u256) {
+            let starkgate_dispatcher = self.starkgate_dispatcher.read();
+            let l1_recipient = self.l1_recipient.read();
+            let l1_usdc_token_address = self.l1_usdc_token_address.read();
+            let l1_transfer_unit = self.l1_transfer_unit.read();
+            let threshold = self.threshold.read();
+
+            while (amount >= threshold) {
+                starkgate_dispatcher
+                    .initiate_token_withdraw(
+                        l1_token: l1_usdc_token_address, :l1_recipient, :amount,
+                    );
+                amount -= l1_transfer_unit;
+            }
         }
     }