feat: fixed transfer untis to L1 (#19)

Author: noa-starkware

packages/usdc_migration/src/errors.cairo

@@ -1 +1,3 @@
-
+pub mod Errors {
+    pub const THRESHOLD_TOO_SMALL: felt252 = 'Threshold is too small';
+}

packages/usdc_migration/src/tests/test_usdc_migration.cairo

@@ -16,6 +16,7 @@ use starkware_utils_testing::test_utils::{
     assert_expected_event_emitted, assert_panic_with_error, assert_panic_with_felt_error,
     cheat_caller_address_once,
 };
+use usdc_migration::errors::Errors;
 use usdc_migration::events::USDCMigrationEvents::USDCMigrated;
 use usdc_migration::interface::{
     IUSDCMigrationAdminDispatcher, IUSDCMigrationAdminDispatcherTrait,
@@ -30,6 +31,8 @@ use usdc_migration::tests::test_utils::{
     deploy_usdc_migration, generic_test_fixture, load_contract_address, load_u256, new_user,
     supply_contract,
 };
+use usdc_migration::usdc_migration::USDCMigration::{LARGE_BATCH_SIZE, SMALL_BATCH_SIZE};
+
 #[test]
 fn test_constructor() {
     let cfg = deploy_usdc_migration();
@@ -56,6 +59,7 @@ fn test_constructor() {
         load_contract_address(usdc_migration_contract, selector!("starkgate_address")),
     );
     assert_eq!(LEGACY_THRESHOLD, load_u256(usdc_migration_contract, selector!("legacy_threshold")));
+    assert_eq!(LARGE_BATCH_SIZE, load_u256(usdc_migration_contract, selector!("batch_size")));
     // Assert owner is set correctly.
     let ownable_dispatcher = IOwnableDispatcher { contract_address: usdc_migration_contract };
     assert_eq!(ownable_dispatcher.owner(), cfg.owner);
@@ -73,6 +77,19 @@ fn test_set_legacy_threshold() {
     cheat_caller_address_once(contract_address: usdc_migration_contract, caller_address: cfg.owner);
     usdc_migration_admin_dispatcher.set_legacy_threshold(threshold: new_threshold);
     assert_eq!(new_threshold, load_u256(usdc_migration_contract, selector!("legacy_threshold")));
+    assert_eq!(LARGE_BATCH_SIZE, load_u256(usdc_migration_contract, selector!("batch_size")));
+    // Set the threshold to a new value that is less than the current transfer unit.
+    let new_threshold = LARGE_BATCH_SIZE - 1;
+    cheat_caller_address_once(contract_address: usdc_migration_contract, caller_address: cfg.owner);
+    usdc_migration_admin_dispatcher.set_legacy_threshold(threshold: new_threshold);
+    assert_eq!(new_threshold, load_u256(usdc_migration_contract, selector!("legacy_threshold")));
+    assert_eq!(SMALL_BATCH_SIZE, load_u256(usdc_migration_contract, selector!("batch_size")));
+    // Set the threshold to a new value that is greater than the current transfer unit.
+    let new_threshold = LEGACY_THRESHOLD;
+    cheat_caller_address_once(contract_address: usdc_migration_contract, caller_address: cfg.owner);
+    usdc_migration_admin_dispatcher.set_legacy_threshold(threshold: new_threshold);
+    assert_eq!(new_threshold, load_u256(usdc_migration_contract, selector!("legacy_threshold")));
+    assert_eq!(LARGE_BATCH_SIZE, load_u256(usdc_migration_contract, selector!("batch_size")));
 }
 
 #[test]
@@ -87,6 +104,12 @@ fn test_set_legacy_threshold_assertions() {
     let result = usdc_migration_admin_safe_dispatcher
         .set_legacy_threshold(threshold: LEGACY_THRESHOLD);
     assert_panic_with_felt_error(:result, expected_error: OwnableErrors::NOT_OWNER);
+    // Catch the invalid threshold error.
+    let invalid_threshold = 1000;
+    cheat_caller_address_once(contract_address: usdc_migration_contract, caller_address: cfg.owner);
+    let result = usdc_migration_admin_safe_dispatcher
+        .set_legacy_threshold(threshold: invalid_threshold);
+    assert_panic_with_felt_error(:result, expected_error: Errors::THRESHOLD_TOO_SMALL);
 }
 
 #[test]

packages/usdc_migration/src/tests/test_utils.cairo

@@ -22,13 +22,14 @@ pub(crate) struct USDCMigrationCfg {
 pub(crate) mod constants {
     use core::num::traits::Pow;
     use starknet::{ContractAddress, EthAddress};
+    use crate::usdc_migration::USDCMigration::LARGE_BATCH_SIZE;
 
     // Total legacy USDC supply is ~140 million.
     pub const INITIAL_SUPPLY: u256 = 140
         * 10_u256.pow(6)
         * 10_u256.pow(6); // 140 * million * decimals
     // TODO: Change to the real value.
-    pub const LEGACY_THRESHOLD: u256 = 100_000;
+    pub const LEGACY_THRESHOLD: u256 = LARGE_BATCH_SIZE;
     pub const INITIAL_CONTRACT_SUPPLY: u256 = INITIAL_SUPPLY / 20;
     pub fn OWNER_ADDRESS() -> ContractAddress {
         'OWNER_ADDRESS'.try_into().unwrap()

packages/usdc_migration/src/usdc_migration.cairo

@@ -10,9 +10,15 @@ pub mod USDCMigration {
     };
     use starkware_utils::constants::MAX_U256;
     use starkware_utils::erc20::erc20_utils::CheckedIERC20DispatcherTrait;
+    use usdc_migration::errors::Errors;
     use usdc_migration::events::USDCMigrationEvents::USDCMigrated;
     use usdc_migration::interface::{IUSDCMigration, IUSDCMigrationAdmin};
 
+    pub(crate) const SMALL_BATCH_SIZE: u256 = 10_000_000_000_u256;
+    pub(crate) const LARGE_BATCH_SIZE: u256 = 100_000_000_000_u256;
+    /// Fixed set of batch sizes used when bridging the legacy token to L1.
+    pub(crate) const FIXED_BATCH_SIZES: [u256; 2] = [SMALL_BATCH_SIZE, LARGE_BATCH_SIZE];
+
     component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
     component!(path: UpgradeableComponent, storage: upgradeable, event: UpgradeableEvent);
 
@@ -34,6 +40,9 @@ pub mod USDCMigration {
         starkgate_address: ContractAddress,
         /// The threshold amount of legacy token balance, that triggers sending to L1.
         legacy_threshold: u256,
+        /// The exact amount of legacy token sent to L1 in a single withdraw action.
+        /// Must be a value from FIXED_BATCH_SIZES.
+        batch_size: u256,
     }
 
     #[event]
@@ -60,7 +69,9 @@ pub mod USDCMigration {
         self.new_token_dispatcher.write(new_dispatcher);
         self.l1_recipient.write(l1_recipient);
         self.starkgate_address.write(starkgate_address);
+        assert(LARGE_BATCH_SIZE <= legacy_threshold, Errors::THRESHOLD_TOO_SMALL);
         self.legacy_threshold.write(legacy_threshold);
+        self.batch_size.write(LARGE_BATCH_SIZE);
         self.ownable.initializer(:owner);
     }
 
@@ -94,11 +105,20 @@ pub mod USDCMigration {
     pub impl AdminFunctions of IUSDCMigrationAdmin<ContractState> { //impl logic
         fn set_legacy_threshold(ref self: ContractState, threshold: u256) {
             self.ownable.assert_only_owner();
-            // TODO: Assert the given threshold is valid according to the fixed transfer units.
-            // TODO: Allow threshold zero?
+            let batch_sizes = FIXED_BATCH_SIZES.span();
+            assert(threshold >= *batch_sizes[0], Errors::THRESHOLD_TOO_SMALL);
             self.legacy_threshold.write(threshold);
-            // TODO: Update transfer unit accordingly.
-        // TODO: Emit event?
+            // Infer the batch size from the threshold.
+            let mut i = batch_sizes.len() - 1;
+            while i >= 0 {
+                let batch_size = *batch_sizes[i];
+                if batch_size <= threshold {
+                    self.batch_size.write(batch_size);
+                    break;
+                }
+                i -= 1;
+            }
+            // TODO: Emit event?
         // TODO: Send to L1 here according the new threshold?
         }