Connector cleanup

engine-precompiles/Cargo.toml

@@ -32,7 +32,6 @@ wee_alloc = { version = "0.4.5", default-features = false }
 logos = { version = "0.12", default-features = false, features = ["export_derive"] }
 ethabi = { git = "https://github.com/darwinia-network/ethabi", branch = "xavier-no-std", default-features = false }
 hex = { version = "0.4", default-features = false, features = ["alloc"] }
-byte-slice-cast = { version = "1.0", default-features = false }
 rjson = { git = "https://github.com/aurora-is-near/rjson", rev = "cc3da949", default-features = false, features = ["integer"] }
 
 [dev-dependencies]

engine-standalone-storage/src/relayer_db/mod.rs

@@ -218,7 +218,7 @@ mod test {
                 .unwrap();
             let mut io = storage.access_engine_storage_at_position(block_height, 0, &[]);
             engine::set_state(&mut io, engine_state.clone());
-            connector::EthConnectorContract::init_contract(
+            connector::EthConnectorContract::create_contract(
                 io,
                 engine_state.owner_id.clone(),
                 parameters::InitCallArgs {

engine-standalone-storage/src/sync/mod.rs

@@ -107,7 +107,7 @@ pub fn consume_message(storage: &mut crate::Storage, message: Message) -> Result
                         engine::Engine::new(relayer_address, env.current_account_id(), io, &env)?;
 
                     if env.predecessor_account_id == env.current_account_id {
-                        connector::EthConnectorContract::get_instance(io)
+                        connector::EthConnectorContract::init_instance(io)
                             .ft_on_transfer(&engine, &args)?;
                     } else {
                         engine.receive_erc20_tokens(
@@ -123,7 +123,7 @@ pub fn consume_message(storage: &mut crate::Storage, message: Message) -> Result
                 }
 
                 TransactionKind::Deposit(raw_proof) => {
-                    let mut connector_contract = connector::EthConnectorContract::get_instance(io);
+                    let mut connector_contract = connector::EthConnectorContract::init_instance(io);
                     let promise_args = connector_contract.deposit(
                         raw_proof,
                         env.current_account_id(),

engine-tests/Cargo.toml

@@ -20,7 +20,6 @@ aurora-engine-precompiles = { path = "../engine-precompiles", default-features =
 engine-standalone-storage = { path = "../engine-standalone-storage", default-features = false }
 engine-standalone-tracing = { path = "../engine-standalone-tracing", default-features = false }
 borsh = { version = "0.8.2", default-features = false }
-byte-slice-cast = { version = "1.0", default-features = false }
 sha3 = { version = "0.9.1", default-features = false }
 evm = { git = "https://github.com/aurora-is-near/sputnikvm.git", default-features = false, features = ["std", "tracing"] }
 evm-runtime = { git = "https://github.com/aurora-is-near/sputnikvm.git", default-features = false, features = ["std", "tracing"] }
@@ -30,6 +29,7 @@ rlp = { version = "0.5.0", default-features = false }
 [dev-dependencies]
 base64 = "0.13.0"
 bstr = "0.2"
+byte-slice-cast = { version = "1.0", default-features = false }
 ethabi = { git = "https://github.com/darwinia-network/ethabi", branch = "xavier-no-std" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

engine-tests/src/test_utils/standalone/mocks/mod.rs

@@ -64,7 +64,7 @@ pub fn init_evm<I: IO + Copy, E: Env>(mut io: I, env: &E) {
         metadata: FungibleTokenMetadata::default(),
     };
 
-    aurora_engine::connector::EthConnectorContract::init_contract(
+    aurora_engine::connector::EthConnectorContract::create_contract(
         io,
         env.current_account_id(),
         connector_args,
@@ -102,7 +102,7 @@ pub fn mint_evm_account<I: IO + Copy, E: Env>(
         amount: balance.raw().low_u128(),
         proof_key: String::new(),
         relayer_id: aurora_account_id.clone(),
-        fee: 0,
+        fee: 0.into(),
         msg: None,
     };
 
@@ -113,7 +113,7 @@ pub fn mint_evm_account<I: IO + Copy, E: Env>(
     );
     io.remove_storage(&proof_key);
 
-    aurora_engine::connector::EthConnectorContract::get_instance(io)
+    aurora_engine::connector::EthConnectorContract::init_instance(io)
         .finish_deposit(
             aurora_account_id.clone(),
             aurora_account_id.clone(),

engine-tests/src/tests/eth_connector.rs

@@ -1,6 +1,5 @@
 use crate::prelude::EthAddress;
 use crate::prelude::WithdrawCallArgs;
-use crate::prelude::U256;
 use crate::test_utils::str_to_account_id;
 use aurora_engine::admin_controlled::{PausedMask, ERR_PAUSED};
 use aurora_engine::connector::{
@@ -10,8 +9,10 @@ use aurora_engine::fungible_token::FungibleTokenMetadata;
 use aurora_engine::parameters::{
     InitCallArgs, NewCallArgs, RegisterRelayerCallArgs, WithdrawResult,
 };
+use aurora_engine_types::types::Fee;
 use borsh::{BorshDeserialize, BorshSerialize};
 use byte_slice_cast::AsByteSlice;
+use ethabi::ethereum_types::U256;
 use near_sdk::test_utils::accounts;
 use near_sdk_sim::transaction::ExecutionStatus;
 use near_sdk_sim::{to_yocto, ExecutionResult, UserAccount, DEFAULT_GAS, STORAGE_AMOUNT};
@@ -409,9 +410,10 @@ fn test_ft_transfer_call_eth() {
     res.assert_success();
 
     let transfer_amount = 50;
-    let fee = 30;
+    let fee: u128 = 30;
     let mut msg = U256::from(fee).as_byte_slice().to_vec();
     msg.append(&mut validate_eth_address(RECIPIENT_ETH_ADDRESS).to_vec());
+
     let message = [CONTRACT_ACC, hex::encode(msg).as_str()].join(":");
     let res = contract.call(
         CONTRACT_ACC.parse().unwrap(),
@@ -592,6 +594,7 @@ fn test_ft_transfer_call_without_message() {
 
 #[test]
 fn test_deposit_with_0x_prefix() {
+    use aurora_engine::deposit_event::TokenMessageData;
     let (master_account, contract) = init(CUSTODIAN_ADDRESS);
 
     let eth_custodian_address: [u8; 20] = {
@@ -601,20 +604,22 @@ fn test_deposit_with_0x_prefix() {
         buf
     };
     let recipient_address = [10u8; 20];
-    let deposit_amount = U256::from(17);
+    let deposit_amount = 17;
+    let recipient_address_encoded = hex::encode(&recipient_address);
+
+    // Note the 0x prefix before the deposit address.
+    let message = [CONTRACT_ACC, ":", "0x", &recipient_address_encoded].concat();
+    let fee: Fee = 0.into();
+    let token_message_data =
+        TokenMessageData::parse_event_message_and_prepare_token_message_data(&message, fee)
+            .unwrap();
+
     let deposit_event = aurora_engine::deposit_event::DepositedEvent {
         eth_custodian_address,
         sender: [0u8; 20],
-        // Note the 0x prefix before the deposit address.
-        recipient: [
-            CONTRACT_ACC,
-            ":",
-            "0x",
-            hex::encode(&recipient_address).as_str(),
-        ]
-        .concat(),
+        token_message_data,
         amount: deposit_amount,
-        fee: U256::zero(),
+        fee,
     };
 
     let event_schema = ethabi::Event {
@@ -630,9 +635,9 @@ fn test_deposit_with_0x_prefix() {
             crate::prelude::H256::zero(),
         ],
         data: ethabi::encode(&[
-            ethabi::Token::String(deposit_event.recipient),
-            ethabi::Token::Uint(deposit_event.amount),
-            ethabi::Token::Uint(deposit_event.fee),
+            ethabi::Token::String(message),
+            ethabi::Token::Uint(U256::from(deposit_event.amount)),
+            ethabi::Token::Uint(U256::from(deposit_event.fee.into_u128())),
         ]),
     };
     let proof = Proof {
@@ -655,9 +660,9 @@ fn test_deposit_with_0x_prefix() {
     res.assert_success();
 
     let aurora_balance = get_eth_on_near_balance(&master_account, CONTRACT_ACC, CONTRACT_ACC);
-    assert_eq!(aurora_balance, deposit_amount.low_u128());
+    assert_eq!(aurora_balance, deposit_amount);
     let address_balance = get_eth_balance(&master_account, recipient_address, CONTRACT_ACC);
-    assert_eq!(address_balance, deposit_amount.low_u128());
+    assert_eq!(address_balance, deposit_amount);
 }
 
 #[test]
@@ -711,7 +716,7 @@ fn test_ft_transfer_call_without_relayer() {
     assert_eq!(balance, DEPOSITED_FEE);
 
     let transfer_amount = 50;
-    let fee = 30;
+    let fee: u128 = 30;
     let mut msg = U256::from(fee).as_byte_slice().to_vec();
     msg.append(&mut validate_eth_address(RECIPIENT_ETH_ADDRESS).to_vec());
     let relayer_id = "relayer.root";
@@ -767,8 +772,8 @@ fn test_ft_transfer_call_fee_greater_than_amount() {
     call_deposit_eth_to_near(&contract, CONTRACT_ACC);
 
     let transfer_amount = 10;
-    let fee = transfer_amount + 10;
-    let mut msg = U256::from(fee).as_byte_slice().to_vec();
+    let fee: u128 = transfer_amount + 10;
+    let mut msg = fee.to_be_bytes().to_vec();
     msg.append(&mut validate_eth_address(RECIPIENT_ETH_ADDRESS).to_vec());
     let relayer_id = "relayer.root";
     let message = [relayer_id, hex::encode(msg).as_str()].join(":");

engine-tests/src/tests/standalone/sync.rs

@@ -1,4 +1,6 @@
+use aurora_engine::deposit_event::TokenMessageData;
 use aurora_engine_sdk::env::{Env, Timestamp};
+use aurora_engine_types::types::Fee;
 use aurora_engine_types::{account_id::AccountId, types::Wei, Address, H256, U256};
 use borsh::BorshSerialize;
 use engine_standalone_storage::sync;
@@ -331,12 +333,19 @@ fn test_consume_submit_message() {
 
 fn mock_proof(recipient_address: Address, deposit_amount: Wei) -> aurora_engine::proof::Proof {
     let eth_custodian_address = test_utils::standalone::mocks::ETH_CUSTODIAN_ADDRESS;
+
+    let fee = Fee::new(0);
+    let message = ["aurora", ":", hex::encode(&recipient_address).as_str()].concat();
+    let token_message_data: TokenMessageData =
+        TokenMessageData::parse_event_message_and_prepare_token_message_data(&message, fee)
+            .unwrap();
+
     let deposit_event = aurora_engine::deposit_event::DepositedEvent {
         eth_custodian_address: eth_custodian_address.0,
         sender: [0u8; 20],
-        recipient: ["aurora", ":", hex::encode(&recipient_address).as_str()].concat(),
-        amount: deposit_amount.raw(),
-        fee: U256::zero(),
+        token_message_data,
+        amount: deposit_amount.raw().as_u128(),
+        fee,
     };
 
     let event_schema = ethabi::Event {
@@ -352,9 +361,9 @@ fn mock_proof(recipient_address: Address, deposit_amount: Wei) -> aurora_engine:
             crate::prelude::H256::zero(),
         ],
         data: ethabi::encode(&[
-            ethabi::Token::String(deposit_event.recipient),
-            ethabi::Token::Uint(deposit_event.amount),
-            ethabi::Token::Uint(deposit_event.fee),
+            ethabi::Token::String(message),
+            ethabi::Token::Uint(U256::from(deposit_event.amount)),
+            ethabi::Token::Uint(U256::from(deposit_event.fee.into_u128())),
         ]),
     };
     aurora_engine::proof::Proof {

engine-types/src/types.rs

@@ -3,10 +3,14 @@ use borsh::{BorshDeserialize, BorshSerialize};
 
 use crate::fmt::Formatter;
 
+// TODO: introduce new Balance type for more strict typing
 pub type Balance = u128;
 pub type RawAddress = [u8; 20];
-pub type RawU256 = [u8; 32]; // Big-endian large integer type.
+pub type RawU256 = [u8; 32];
+// Big-endian large integer type.
 pub type RawH256 = [u8; 32]; // Unformatted binary data of fixed length.
+
+// TODO: introduce new type. Add encode/decode/validation methods
 pub type EthAddress = [u8; 20];
 pub type StorageUsage = u64;
 /// Wei compatible Borsh-encoded raw value to attach an ETH balance to the transaction
@@ -104,6 +108,44 @@ impl Mul<EthGas> for u64 {
     }
 }
 
+#[derive(
+    Default, Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, BorshSerialize, BorshDeserialize,
+)]
+/// Engine `fee` type which wraps an underlying u128.
+pub struct Fee(u128);
+
+impl Display for Fee {
+    fn fmt(&self, f: &mut Formatter<'_>) -> crate::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl Fee {
+    /// Constructs a new `Fee` with a given u128 value.
+    pub const fn new(fee: u128) -> Fee {
+        Self(fee)
+    }
+
+    /// Consumes `Fee` and returns the underlying type.
+    pub fn into_u128(self) -> u128 {
+        self.0
+    }
+}
+
+impl Add<Fee> for Fee {
+    type Output = Fee;
+
+    fn add(self, rhs: Fee) -> Self::Output {
+        Fee(self.0 + rhs.0)
+    }
+}
+
+impl From<u128> for Fee {
+    fn from(fee: u128) -> Self {
+        Self(fee)
+    }
+}
+
 /// Selector to call mint function in ERC 20 contract
 ///
 /// keccak("mint(address,uint256)".as_bytes())[..4];
@@ -125,7 +167,7 @@ impl AsRef<[u8]> for AddressValidationError {
     }
 }
 
-/// Validate Etherium address from string and return EthAddress
+/// Validate Ethereum address from string and return Result data EthAddress or Error data
 pub fn validate_eth_address(address: String) -> Result<EthAddress, AddressValidationError> {
     let data = hex::decode(address).map_err(|_| AddressValidationError::FailedDecodeHex)?;
     if data.len() != 20 {
@@ -183,6 +225,13 @@ impl Wei {
     pub fn checked_add(self, rhs: Self) -> Option<Self> {
         self.0.checked_add(rhs.0).map(Self)
     }
+
+    /// Try convert U256 to u128 with checking overflow.
+    /// NOTICE: Error can contain only overflow
+    pub fn try_into_u128(self) -> Result<u128, error::BalanceOverflowError> {
+        use crate::TryInto;
+        self.0.try_into().map_err(|_| error::BalanceOverflowError)
+    }
 }
 
 impl Display for Wei {
@@ -214,10 +263,8 @@ impl From<WeiU256> for Wei {
     }
 }
 
-#[derive(BorshSerialize, BorshDeserialize)]
-pub struct U128(pub u128);
-
-pub const STORAGE_PRICE_PER_BYTE: u128 = 10_000_000_000_000_000_000; // 1e19yN, 0.00001N
+pub const STORAGE_PRICE_PER_BYTE: u128 = 10_000_000_000_000_000_000;
+// 1e19yN, 0.00001N
 pub const ERR_FAILED_PARSE: &str = "ERR_FAILED_PARSE";
 pub const ERR_INVALID_ETH_ADDRESS: &str = "ERR_INVALID_ETH_ADDRESS";
 
@@ -314,10 +361,31 @@ impl<T> Stack<T> {
         self.stack
     }
 }
+
 pub fn str_from_slice(inp: &[u8]) -> &str {
     str::from_utf8(inp).unwrap()
 }
 
+pub mod error {
+    use crate::{fmt, String};
+
+    #[derive(Eq, Hash, Clone, Debug, PartialEq)]
+    pub struct BalanceOverflowError;
+
+    impl AsRef<[u8]> for BalanceOverflowError {
+        fn as_ref(&self) -> &[u8] {
+            b"ERR_BALANCE_OVERFLOW"
+        }
+    }
+
+    impl fmt::Display for BalanceOverflowError {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            let msg = String::from_utf8(self.as_ref().to_vec()).unwrap();
+            write!(f, "{}", msg)
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -420,4 +488,20 @@ mod tests {
         let wei_amount = U256::from(eth_amount) * U256::from(10).pow(18.into());
         assert_eq!(Wei::from_eth(eth_amount.into()), Some(Wei::new(wei_amount)));
     }
+
+    #[test]
+    fn test_fee_add() {
+        let fee = Fee::new(100);
+        assert_eq!(fee + fee, Fee::new(200));
+        assert_eq!(fee.add(200.into()), Fee::new(300));
+    }
+
+    #[test]
+    fn test_fee_from() {
+        let fee = Fee::new(100);
+        let fee2 = Fee::from(100u128);
+        assert_eq!(fee, fee2);
+        let res: u128 = fee.into_u128();
+        assert_eq!(res, 100);
+    }
 }