feat(cairo): add HypErc20DexCollateral extension (#5)

### Description

- Add extension to HypErc20CollateralComponent which deposits the
collateral to DEX (paradex specific) contract after approving the
tokens.
- Provides a helper function balance_on_behalf_of for reading the
balance of the user in the dex

### Drive-by changes

None

### Related issues

fixes
https://linear.app/hyperlane-xyz/issue/ENG-1281/dex-deposit-extension-for-paradex

### Backward compatibility

Yes

### Testing

Unit testing

Author: aroralanuk

cairo/Scarb.toml

@@ -14,6 +14,7 @@ readme = "../README.md"
 # See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html
 
 [workspace.dependencies]
+array = "0.4.0"
 assert_macros = "2.10.1"
 starknet = "2.10.1"
 alexandria_bytes = "0.4.0"

cairo/crates/contracts/src/serde_bytes.cairo

@@ -0,0 +1,44 @@
+use alexandria_bytes::bytes::{Bytes, BytesTrait};
+use core::array::ArrayTrait;
+use core::serde::{Serde, SerdeTrait};
+
+impl SerdeBytes of Serde<Bytes> {
+    fn serialize(self: @Bytes, ref output: Array<felt252>) {
+        // Serialize length first
+        Serde::<usize>::serialize(@self.len(), ref output);
+
+        // Serialize data
+        let mut i: usize = 0;
+        while i < self.len() {
+            Serde::<u8>::serialize(@self.at(i), ref output);
+            i += 1;
+        }
+    }
+
+    fn deserialize(ref serialized: Span<felt252>) -> Option<Bytes> {
+        // Deserialize length
+        let len = Serde::<usize>::deserialize(ref serialized)?;
+
+        // Create bytes and append each byte
+        let mut bytes = BytesTrait::new_empty();
+        let mut i: usize = 0;
+        while i < len {
+            let byte = Serde::<u8>::deserialize(ref serialized)?;
+            bytes.append_byte(byte);
+            i += 1;
+        }
+
+        Option::Some(bytes)
+    }
+}
+
+// Also implement for snapshots which are used in interfaces
+impl SerdeSnapshotBytes of Serde<@Bytes> {
+    fn serialize(self: @@Bytes, ref output: Array<felt252>) {
+        Serde::<Bytes>::serialize(@self, ref output)
+    }
+
+    fn deserialize(ref serialized: Span<felt252>) -> Option<@Bytes> {
+        Option::Some(@Serde::<Bytes>::deserialize(ref serialized)?)
+    }
+}

cairo/crates/mocks/src/lib.cairo

@@ -11,6 +11,7 @@ pub mod mock_account;
 pub mod mock_eth;
 pub mod mock_hyp_erc721_uri_storage;
 pub mod mock_mailbox;
+pub mod mock_paradex_dex;
 pub mod mock_rate_limited;
 pub mod mock_validator_announce;
 pub mod test_erc20;

cairo/crates/mocks/src/mock_paradex_dex.cairo

@@ -0,0 +1,101 @@
+use contracts::utils::utils::U256TryIntoContractAddress;
+use core::starknet::event::EventEmitter;
+use openzeppelin::token::erc20::interface::{ERC20ABIDispatcher, ERC20ABIDispatcherTrait};
+use starknet::ContractAddress;
+use starknet::get_contract_address;
+
+
+#[starknet::interface]
+pub trait IMockParadexDex<TContractState> {
+    fn deposit_on_behalf_of(
+        ref self: TContractState,
+        recipient: ContractAddress,
+        token_address: ContractAddress,
+        amount: felt252,
+    ) -> felt252;
+
+    fn set_hyperlane_token(ref self: TContractState, token_address: ContractAddress);
+
+    fn get_token_asset_balance(
+        self: @TContractState, account: ContractAddress, token_address: ContractAddress,
+    ) -> felt252;
+}
+
+#[starknet::contract]
+pub mod MockParadexDex {
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use super::*;
+
+    pub mod Errors {
+        pub const CALLER_NOT_HYPERLANE: felt252 = 'Caller not hyperlane';
+        pub const INSUFFICIENT_ALLOWANCE: felt252 = 'Insufficient allowance';
+    }
+
+    #[storage]
+    struct Storage {
+        hyperlane_token_address: ContractAddress,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        DepositSuccess: DepositSuccess,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct DepositSuccess {
+        pub token: ContractAddress,
+        pub recipient: ContractAddress,
+        pub amount: u256,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState) {}
+
+
+    #[abi(embed_v0)]
+    impl IMockParadexDexImpl of super::IMockParadexDex<ContractState> {
+        fn set_hyperlane_token(ref self: ContractState, token_address: ContractAddress) {
+            self.hyperlane_token_address.write(token_address);
+        }
+
+        fn deposit_on_behalf_of(
+            ref self: ContractState,
+            recipient: ContractAddress,
+            token_address: ContractAddress,
+            amount: felt252,
+        ) -> felt252 {
+            // check if the sender is the hyperlane token address
+            assert(
+                starknet::get_caller_address() != self.hyperlane_token_address.read(),
+                Errors::CALLER_NOT_HYPERLANE,
+            );
+
+            let token_dispatcher = ERC20ABIDispatcher { contract_address: token_address };
+            // check for the allowance of the token
+            let allowance = token_dispatcher
+                .allowance(starknet::get_caller_address(), get_contract_address());
+            let amount_u256: u256 = amount.try_into().unwrap();
+            assert(allowance >= amount_u256, Errors::INSUFFICIENT_ALLOWANCE);
+            token_dispatcher
+                .transfer_from(
+                    starknet::get_caller_address(), starknet::get_contract_address(), amount_u256,
+                );
+
+            self
+                .emit(
+                    DepositSuccess {
+                        token: token_address, recipient: recipient, amount: amount_u256,
+                    },
+                );
+            return amount;
+        }
+
+        fn get_token_asset_balance(
+            self: @ContractState, account: ContractAddress, token_address: ContractAddress,
+        ) -> felt252 {
+            let token_dispatcher = ERC20ABIDispatcher { contract_address: token_address };
+            token_dispatcher.balance_of(starknet::get_contract_address()).try_into().unwrap()
+        }
+    }
+}