Eth Address cleanup (#387)

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::new(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;
  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::new(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::new(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,7 @@ mod costs {
 }
 
 pub mod events {
- use crate::prelude::{vec, Address, String, ToString, H256, U256};
+ use crate::prelude::{types::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 +61,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::new(H160([0; 20]));
 
  /// ExitToNear(
  /// Address indexed sender,
@@ -128,7 +127,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)
  }
 
@@ -253,7 +252,7 @@ impl Precompile for ExitToNear {
  ) -> EvmPrecompileResult {
  #[cfg(feature = "error_refund")]
  fn parse_input(input: &[u8]) -> (Address, &[u8]) {
- let refund_address = Address::from_slice(&input[1..21]);
+ let refund_address = Address::from_array(&input[1..21]);
  (refund_address, &input[21..])
  }
  #[cfg(not(feature = "error_refund"))]
@@ -302,7 +301,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 +345,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 +364,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 +397,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 +488,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 +502,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 +535,9 @@ 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::try_from_slice(input).map_err(|_| {
+ ExitError::Other(crate::prelude::Cow::from("ERR_WRONG_ADDRESS"))
+ })?;
 
  (
  nep141_address,
@@ -550,9 +551,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 +578,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 {
@@ -45,7 +44,8 @@ fn internal_impl(hash: H256, signature: &[u8]) -> Result<Address, ExitError> {
  if let Ok(public_key) = secp256k1::recover(&hash, &signature, &recovery_id) {
  // recover returns a 65-byte key, but addresses come from the raw 64-byte key
  let r = sha3::Keccak256::digest(&public_key.serialize()[1..]);
- return Ok(Address::from_slice(&r[12..]));
+ return Address::try_from_slice(&r[12..])
+ .map_err(|_| ExitError::Other(Borrowed("ERR_INCORRECT_ADDRESS")));
  }
  }
 
@@ -132,8 +132,10 @@ mod tests {
  let signature =
  &hex::decode("b9f0bb08640d3c1c00761cdd0121209268f6fd3816bc98b9e6f3cc77bf82b69812ac7a61788a0fdc0e19180f14c945a8e1088a27d92a74dce81c0981fb6447441b")
  .unwrap();
- let signer =
- Address::from_slice(&hex::decode("1563915e194D8CfBA1943570603F7606A3115508").unwrap());
+ let signer = Address::try_from_slice(
+ &hex::decode("1563915e194D8CfBA1943570603F7606A3115508").unwrap(),
+ )
+ .unwrap();
  assert!(ecverify(hash, &signature, signer));
  }
 

engine-sdk/src/lib.rs

@@ -97,7 +97,7 @@ pub fn ecrecover(hash: H256, signature: &[u8]) -> Result<Address, ECRecoverErr>
  exports::keccak256(u64::MAX, RECOVER_REGISTER_ID, KECCACK_REGISTER_ID);
  let keccak_hash_bytes = [0u8; 32];
  exports::read_register(KECCACK_REGISTER_ID, keccak_hash_bytes.as_ptr() as u64);
- Ok(Address::from_slice(&keccak_hash_bytes[12..]))
+ Ok(Address::try_from_slice(&keccak_hash_bytes[12..]).map_err(|_| ECRecoverErr)?)
  } else {
  Err(ECRecoverErr)
  }

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-sdk/src/types.rs

@@ -23,7 +23,7 @@ pub fn keccak(data: &[u8]) -> H256 {
 }
 
 pub fn near_account_to_evm_address(addr: &[u8]) -> Address {
- Address::from_slice(&keccak(addr)[12..])
+ Address::try_from_slice(&keccak(addr)[12..]).unwrap()
 }
 
 #[cfg(feature = "contract")]