Eth Address cleanup

engine-precompiles/src/blake2.rs

@@ -1,7 +1,7 @@
 use evm::{Context, ExitError};
 
 use crate::prelude::types::EthGas;
-use crate::prelude::{mem, Address, Borrowed, TryInto};
+use crate::prelude::{mem, types::Address, Borrowed, TryInto};
 use crate::{EvmPrecompileResult, Precompile, PrecompileOutput};
 
 /// Blake2 costs.

engine-precompiles/src/bn128.rs

@@ -1,5 +1,5 @@
-use crate::prelude::types::EthGas;
-use crate::prelude::{Address, Borrowed, PhantomData, Vec};
+use crate::prelude::types::{Address, EthGas};
+use crate::prelude::{Borrowed, PhantomData, Vec};
 use crate::{Byzantium, EvmPrecompileResult, HardFork, Istanbul, Precompile, PrecompileOutput};
 use evm::{Context, ExitError};
 

engine-precompiles/src/hash.rs

@@ -1,7 +1,7 @@
 #[cfg(feature = "contract")]
 use crate::prelude::sdk;
-use crate::prelude::types::EthGas;
-use crate::prelude::{vec, Address};
+use crate::prelude::types::{Address, EthGas};
+use crate::prelude::vec;
 use crate::{EvmPrecompileResult, Precompile, PrecompileOutput};
 use evm::{Context, ExitError};
 

engine-precompiles/src/identity.rs

@@ -1,5 +1,4 @@
-use crate::prelude::types::EthGas;
-use crate::prelude::Address;
+use crate::prelude::types::{Address, EthGas};
 use crate::{EvmPrecompileResult, Precompile, PrecompileOutput};
 use evm::{Context, ExitError};
 

engine-precompiles/src/lib.rs

@@ -23,10 +23,10 @@ use crate::identity::Identity;
 use crate::modexp::ModExp;
 use crate::native::{ExitToEthereum, ExitToNear};
 use crate::prelude::types::EthGas;
-use crate::prelude::{Vec, H256};
+use crate::prelude::{Vec, H160, H256};
 use crate::random::RandomSeed;
 use crate::secp256k1::ECRecover;
-use aurora_engine_types::{account_id::AccountId, vec, Address, BTreeMap, Box};
+use aurora_engine_types::{account_id::AccountId, types::Address, vec, BTreeMap, Box};
 use evm::backend::Log;
 use evm::executor;
 use evm::{Context, ExitError, ExitSucceed};
@@ -106,20 +106,20 @@ pub struct Precompiles(pub prelude::BTreeMap<Address, Box<dyn Precompile>>);
 impl executor::PrecompileSet for Precompiles {
  fn execute(
  &self,
- address: prelude::Address,
+ address: prelude::H160,
  input: &[u8],
  gas_limit: Option<u64>,
  context: &Context,
  is_static: bool,
  ) -> Option<Result<executor::PrecompileOutput, executor::PrecompileFailure>> {
- self.0.get(&address).map(|p| {
+ self.0.get(&Address::new(address)).map(|p| {
  p.run(input, gas_limit.map(EthGas::new), context, is_static)
  .map_err(|exit_status| executor::PrecompileFailure::Error { exit_status })
  })
  }
 
- fn is_precompile(&self, address: prelude::Address) -> bool {
- self.0.contains_key(&address)
+ fn is_precompile(&self, address: prelude::H160) -> bool {
+ self.0.contains_key(&Address::new(address))
  }
 }
 
@@ -259,13 +259,13 @@ impl Precompiles {
  }
 }
 
-/// const fn for making an address by concatenating the bytes from two given numbers,
+/// fn for making an address by concatenating the bytes from two given numbers,
 /// Note that 32 + 128 = 160 = 20 bytes (the length of an address). This function is used
 /// as a convenience for specifying the addresses of the various precompiles.
-pub const fn make_address(x: u32, y: u128) -> prelude::Address {
+pub const fn make_address(x: u32, y: u128) -> prelude::types::Address {
  let x_bytes = x.to_be_bytes();
  let y_bytes = y.to_be_bytes();
- prelude::Address([
+ prelude::types::ADDRESS(H160([
  x_bytes[0],
  x_bytes[1],
  x_bytes[2],
@@ -286,7 +286,7 @@ pub const fn make_address(x: u32, y: u128) -> prelude::Address {
  y_bytes[13],
  y_bytes[14],
  y_bytes[15],
- ])
+ ]))
 }
 
 const fn make_h256(x: u128, y: u128) -> prelude::H256 {
@@ -330,7 +330,9 @@ const fn make_h256(x: u128, y: u128) -> prelude::H256 {
 
 #[cfg(test)]
 mod tests {
+ use crate::prelude::H160;
  use crate::{prelude, Byzantium, Istanbul};
+ use prelude::types::{Address, ADDRESS};
  use rand::Rng;
 
  #[test]
@@ -354,25 +356,25 @@ mod tests {
 
  let mut rng = rand::thread_rng();
  for _ in 0..u8::MAX {
- let address: prelude::Address = prelude::Address(rng.gen());
+ let address = ADDRESS(H160(rng.gen()));
  let (x, y) = split_address(address);
  assert_eq!(address, super::make_address(x, y))
  }
  }
 
- fn u8_to_address(x: u8) -> prelude::Address {
+ fn u8_to_address(x: u8) -> Address {
  let mut bytes = [0u8; 20];
  bytes[19] = x;
- prelude::Address(bytes)
+ ADDRESS(H160(bytes))
  }
 
  // Inverse function of `super::make_address`.
- fn split_address(a: prelude::Address) -> (u32, u128) {
+ fn split_address(a: Address) -> (u32, u128) {
  let mut x_bytes = [0u8; 4];
  let mut y_bytes = [0u8; 16];
 
- x_bytes.copy_from_slice(&a[0..4]);
- y_bytes.copy_from_slice(&a[4..20]);
+ x_bytes.copy_from_slice(&a.raw()[0..4]);
+ y_bytes.copy_from_slice(&a.raw()[4..20]);
 
  (u32::from_be_bytes(x_bytes), u128::from_be_bytes(y_bytes))
  }

engine-precompiles/src/modexp.rs

@@ -1,7 +1,7 @@
-use crate::prelude::{Address, PhantomData, Vec, U256};
+use crate::prelude::{PhantomData, Vec, U256};
 use crate::{Berlin, Byzantium, EvmPrecompileResult, HardFork, Precompile, PrecompileOutput};
 
-use crate::prelude::types::EthGas;
+use crate::prelude::types::{Address, EthGas};
 use evm::{Context, ExitError};
 use num::{BigUint, Integer};
 

engine-precompiles/src/native.rs

@@ -6,16 +6,15 @@ use crate::prelude::{
  sdk,
  storage::{bytes_to_key, KeyPrefix},
  types::Yocto,
- vec, BorshSerialize, Cow, String, ToString, TryFrom, TryInto, Vec, H160, U256,
+ vec, BorshSerialize, Cow, String, ToString, TryFrom, TryInto, Vec, U256,
 };
 #[cfg(all(feature = "error_refund", feature = "contract"))]
 use crate::prelude::{
  parameters::{PromiseWithCallbackArgs, RefundCallArgs},
  types,
 };
 
-use crate::prelude::types::EthGas;
-use crate::prelude::Address;
+use crate::prelude::types::{Address, EthGas};
 use crate::PrecompileOutput;
 use aurora_engine_types::account_id::AccountId;
 #[cfg(feature = "contract")]
@@ -45,7 +44,10 @@ mod costs {
 }
 
 pub mod events {
- use crate::prelude::{vec, Address, String, ToString, H256, U256};
+ use crate::prelude::{
+ types::{Address, ADDRESS},
+ vec, String, ToString, H160, H256, U256,
+ };
 
  /// Derived from event signature (see tests::test_exit_signatures)
  pub const EXIT_TO_NEAR_SIGNATURE: H256 = crate::make_h256(
@@ -62,7 +64,7 @@ pub mod events {
  /// which ERC-20 token is being withdrawn. However, ETH is not an ERC-20 token
  /// So we need to have some other address to fill this field. This constant is
  /// used for this purpose.
- pub const ETH_ADDRESS: Address = Address([0; 20]);
+ pub const ETH_ADDRESS: Address = ADDRESS(H160([0; 20]));
 
  /// ExitToNear(
  /// Address indexed sender,
@@ -128,7 +130,7 @@ pub mod events {
 
  fn encode_address(a: Address) -> H256 {
  let mut result = [0u8; 32];
- result[12..].copy_from_slice(a.as_ref());
+ result[12..].copy_from_slice(a.as_bytes());
  H256(result)
  }
 
@@ -302,7 +304,7 @@ impl Precompile for ExitToNear {
  context.apparent_value.as_u128()
  ),
  events::ExitToNear {
- sender: context.caller,
+ sender: Address::new(context.caller),
  erc20_address: events::ETH_ADDRESS,
  dest: dest_account.to_string(),
  amount: context.apparent_value,
@@ -346,8 +348,8 @@ impl Precompile for ExitToNear {
  amount.as_u128()
  ),
  events::ExitToNear {
- sender: erc20_address,
- erc20_address,
+ sender: Address::new(erc20_address),
+ erc20_address: Address::new(erc20_address),
  dest: receiver_account_id.to_string(),
  amount,
  },
@@ -365,11 +367,11 @@ impl Precompile for ExitToNear {
  let erc20_address = if flag == 0 {
  None
  } else {
- Some(exit_event.erc20_address.0)
+ Some(exit_event.erc20_address)
  };
  #[cfg(feature = "error_refund")]
  let refund_args = RefundCallArgs {
- recipient_address: refund_address.0,
+ recipient_address: refund_address,
  erc20_address,
  amount: types::u256_to_arr(&exit_event.amount),
  };
@@ -398,13 +400,13 @@ impl Precompile for ExitToNear {
  let promise = PromiseArgs::Create(transfer_promise);
 
  let promise_log = Log {
- address: Self::ADDRESS,
+ address: Self::ADDRESS.raw(),
  topics: Vec::new(),
  data: promise.try_to_vec().unwrap(),
  };
  let exit_event_log = exit_event.encode();
  let exit_event_log = Log {
- address: Self::ADDRESS,
+ address: Self::ADDRESS.raw(),
  topics: exit_event_log.topics,
  data: exit_event_log.data,
  };
@@ -489,7 +491,7 @@ impl Precompile for ExitToEthereum {
  //
  // Input slice format:
  // eth_recipient (20 bytes) - the address of recipient which will receive ETH on Ethereum
- let recipient_address = input
+ let recipient_address: Address = input
  .try_into()
  .map_err(|_| ExitError::Other(Cow::from("ERR_INVALID_RECIPIENT_ADDRESS")))?;
  (
@@ -503,9 +505,9 @@ impl Precompile for ExitToEthereum {
  .try_to_vec()
  .map_err(|_| ExitError::Other(Cow::from("ERR_INVALID_AMOUNT")))?,
  events::ExitToEth {
- sender: context.caller,
+ sender: Address::new(context.caller),
  erc20_address: events::ETH_ADDRESS,
- dest: H160(recipient_address),
+ dest: recipient_address,
  amount: context.apparent_value,
  },
  )
@@ -536,7 +538,7 @@ impl Precompile for ExitToEthereum {
  // Parse ethereum address in hex
  let eth_recipient: String = hex::encode(input.to_vec());
  // unwrap cannot fail since we checked the length already
- let recipient_address = input.try_into().unwrap();
+ let recipient_address = Address::from_slice(input);
 
  (
  nep141_address,
@@ -550,9 +552,9 @@ impl Precompile for ExitToEthereum {
  .as_bytes()
  .to_vec(),
  events::ExitToEth {
- sender: erc20_address,
- erc20_address,
- dest: H160(recipient_address),
+ sender: Address::new(erc20_address),
+ erc20_address: Address::new(erc20_address),
+ dest: recipient_address,
  amount,
  },
  )
@@ -577,13 +579,13 @@ impl Precompile for ExitToEthereum {
 
  let promise = PromiseArgs::Create(withdraw_promise).try_to_vec().unwrap();
  let promise_log = Log {
- address: Self::ADDRESS,
+ address: Self::ADDRESS.raw(),
  topics: Vec::new(),
  data: promise,
  };
  let exit_event_log = exit_event.encode();
  let exit_event_log = Log {
- address: Self::ADDRESS,
+ address: Self::ADDRESS.raw(),
  topics: exit_event_log.topics,
  data: exit_event_log.data,
  };

engine-precompiles/src/random.rs

@@ -1,6 +1,6 @@
 use super::{EvmPrecompileResult, Precompile};
-use crate::prelude::types::EthGas;
-use crate::prelude::{Address, H256};
+use crate::prelude::types::{Address, EthGas};
+use crate::prelude::H256;
 use crate::PrecompileOutput;
 use evm::{Context, ExitError};
 

engine-precompiles/src/secp256k1.rs

@@ -1,7 +1,6 @@
-use crate::prelude::types::EthGas;
+use crate::prelude::types::{Address, EthGas};
 use crate::prelude::{sdk, vec, Borrowed, H256};
 use crate::{EvmPrecompileResult, Precompile, PrecompileOutput};
-use ethabi::Address;
 use evm::{Context, ExitError};
 
 mod costs {

engine-sdk/src/prelude.rs

@@ -1,3 +1,3 @@
-pub use aurora_engine_types::types::{NearGas, PromiseResult, STORAGE_PRICE_PER_BYTE};
-pub use aurora_engine_types::{vec, Address, Vec, H256};
+pub use aurora_engine_types::types::{Address, NearGas, PromiseResult, STORAGE_PRICE_PER_BYTE};
+pub use aurora_engine_types::{vec, Vec, H256};
 pub use borsh::{BorshDeserialize, BorshSerialize};

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

@@ -2,7 +2,8 @@ use aurora_engine::transaction::{
  legacy::{LegacyEthSignedTransaction, TransactionLegacy},
  EthTransactionKind,
 };
-use aurora_engine_types::{types::Wei, Address, H256, U256};
+use aurora_engine_types::types::{Address, Wei};
+use aurora_engine_types::{H256, U256};
 use std::convert::TryFrom;
 use std::io::{Cursor, Read};
 use std::time::SystemTime;

engine-tests/src/benches/eth_deploy_code.rs

@@ -1,7 +1,7 @@
 use criterion::{BatchSize, BenchmarkId, Criterion, Throughput};
 use secp256k1::SecretKey;
 
-use crate::prelude::types::Wei;
+use crate::prelude::Wei;
 use crate::test_utils::{
  address_from_secret_key, create_deploy_transaction, deploy_evm, sign_transaction, SUBMIT,
 };

engine-tests/src/benches/eth_erc20.rs

@@ -15,7 +15,7 @@ pub(crate) fn eth_erc20_benchmark(c: &mut Criterion) {
  let source_account = SecretKey::random(&mut rng);
  runner.create_address(
  address_from_secret_key(&source_account),
- crate::prelude::types::Wei::new_u64(INITIAL_BALANCE),
+ crate::prelude::Wei::new_u64(INITIAL_BALANCE),
  INITIAL_NONCE.into(),
  );
  let calling_account_id = "some-account.near";

engine-tests/src/benches/eth_standard_precompiles.rs

@@ -2,7 +2,7 @@ use crate::prelude::U256;
 use criterion::{BatchSize, BenchmarkId, Criterion};
 use secp256k1::SecretKey;
 
-use crate::prelude::types::Wei;
+use crate::prelude::Wei;
 use crate::test_utils::standard_precompiles::{PrecompilesConstructor, PrecompilesContract};
 use crate::test_utils::{address_from_secret_key, deploy_evm, sign_transaction, SUBMIT};
 

engine-tests/src/benches/eth_transfer.rs

@@ -1,7 +1,7 @@
 use criterion::{BatchSize, Criterion};
 use secp256k1::SecretKey;
 
-use crate::prelude::types::Wei;
+use crate::prelude::Wei;
 use crate::test_utils::{address_from_secret_key, create_eth_transaction, deploy_evm, SUBMIT};
 
 const INITIAL_BALANCE: Wei = Wei::new_u64(1000);

engine-tests/src/benches/nft_pagination.rs

@@ -1,5 +1,4 @@
-use crate::prelude::types::Wei;
-use crate::prelude::{Address, U256};
+use crate::prelude::{Address, Wei, U256};
 use crate::test_utils::{self, solidity};
 use aurora_engine::transaction::legacy::TransactionLegacy;
 use secp256k1::SecretKey;
@@ -134,7 +133,7 @@ impl MarketPlace {
  self.0.call_method_with_args(
  "minar",
  &[
- ethabi::Token::Address(recipient),
+ ethabi::Token::Address(recipient.raw()),
  ethabi::Token::String(data),
  ethabi::Token::Uint(price.raw()),
  ],