From b2cb3286cc4ea31847a6b3ef020f0137ecd2df01 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Tue, 14 Dec 2021 18:26:25 +0200 Subject: [PATCH 01/26] Added address file --- engine-types/src/address.rs | 80 +++++++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100755 engine-types/src/address.rs diff --git a/engine-types/src/address.rs b/engine-types/src/address.rs new file mode 100755 index 000000000..4bd93a8c2 --- /dev/null +++ b/engine-types/src/address.rs @@ -0,0 +1,80 @@ +use crate::{String, H160}; +use borsh::maybestd::io; +use borsh::{BorshDeserialize, BorshSerialize}; + +/// Base Eth Address type +pub struct Address(H160); + +impl Address { + /// Construct Address from H160 + pub fn new(val: H160) -> Self { + Self(val) + } + + /// Get raw H160 data + pub fn raw(&self) -> H160 { + self.0 + } + + /// Encode address to string + pub fn encode(&self) -> String { + hex::encode(self.0.as_bytes()) + } +} + +impl BorshSerialize for Address { + fn serialize(&self, writer: &mut W) -> io::Result<()> { + writer.write_all(self.0.as_bytes()) + } +} + +impl BorshDeserialize for Address { + fn deserialize(buf: &mut &[u8]) -> io::Result { + Ok(Self(H160::from_slice(buf))) + } + + fn try_from_slice(v: &[u8]) -> io::Result { + let mut v_mut = v; + Self::deserialize(&mut v_mut) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_address_serializer() { + let eth_address = "096DE9C2B8A5B8c22cEe3289B101f6960d68E51E"; + // borsh serialize + let serialized_addr = + Address::new(H160::from_slice(&hex::decode(eth_address).unwrap()[..])) + .try_to_vec() + .unwrap(); + assert_eq!(serialized_addr.len(), 20); + + let addr = Address::try_from_slice(&serialized_addr).unwrap(); + assert_eq!( + addr.encode(), + "096DE9C2B8A5B8c22cEe3289B101f6960d68E51E".to_lowercase() + ); + } + + #[test] + #[should_panic] + fn test_wrong_address_19() { + let serialized_addr = [0u8; 19]; + let addr = Address::try_from_slice(&serialized_addr); + assert!(addr.is_err()); + + let serialized_addr = [0u8; 21]; + let _ = Address::try_from_slice(&serialized_addr); + } + + #[test] + #[should_panic] + fn test_wrong_address_21() { + let serialized_addr = [0u8; 21]; + let _ = Address::try_from_slice(&serialized_addr); + } +} From 94d7c7f24859dccbc5a5c590874ac46786f604ed Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Tue, 14 Dec 2021 19:03:24 +0200 Subject: [PATCH 02/26] Changed basic Address dependency --- engine-types/src/lib.rs | 4 +++- engine-types/src/{ => types_new}/address.rs | 0 engine-types/src/types_new/mod.rs | 3 +++ 3 files changed, 6 insertions(+), 1 deletion(-) rename engine-types/src/{ => types_new}/address.rs (100%) create mode 100644 engine-types/src/types_new/mod.rs diff --git a/engine-types/src/lib.rs b/engine-types/src/lib.rs index ae35c46f9..4f4ade1a3 100644 --- a/engine-types/src/lib.rs +++ b/engine-types/src/lib.rs @@ -7,6 +7,7 @@ pub mod account_id; pub mod parameters; pub mod storage; pub mod types; +pub mod types_new; mod v0 { #[cfg(not(feature = "std"))] @@ -43,7 +44,7 @@ mod v0 { } pub use v0::*; - +/* /// See: https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485 pub type Address = H160; @@ -52,3 +53,4 @@ pub type Address = H160; pub const fn Address(input: [u8; 20]) -> Address { H160(input) } +*/ diff --git a/engine-types/src/address.rs b/engine-types/src/types_new/address.rs similarity index 100% rename from engine-types/src/address.rs rename to engine-types/src/types_new/address.rs diff --git a/engine-types/src/types_new/mod.rs b/engine-types/src/types_new/mod.rs new file mode 100644 index 000000000..5d8143497 --- /dev/null +++ b/engine-types/src/types_new/mod.rs @@ -0,0 +1,3 @@ +pub mod address; + +pub use address::*; From f49340441db675198ae016217bea0557a20b9287 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Tue, 14 Dec 2021 22:21:27 +0200 Subject: [PATCH 03/26] Changed Addess dependecies --- engine-precompiles/src/blake2.rs | 2 +- engine-precompiles/src/bn128.rs | 2 +- engine-precompiles/src/hash.rs | 3 ++- engine-precompiles/src/identity.rs | 2 +- engine-precompiles/src/lib.rs | 14 +++++------ engine-precompiles/src/modexp.rs | 2 +- engine-precompiles/src/native.rs | 36 +++++++++++++-------------- engine-precompiles/src/random.rs | 3 ++- engine-precompiles/src/secp256k1.rs | 2 +- engine-sdk/src/prelude.rs | 2 +- engine-types/src/parameters.rs | 3 ++- engine-types/src/storage.rs | 7 +++--- engine-types/src/types.rs | 2 +- engine-types/src/types_new/address.rs | 25 +++++++++++++++++-- 14 files changed, 65 insertions(+), 40 deletions(-) diff --git a/engine-precompiles/src/blake2.rs b/engine-precompiles/src/blake2.rs index a6a300e03..db62d86ab 100644 --- a/engine-precompiles/src/blake2.rs +++ b/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_new::Address, Borrowed, TryInto}; use crate::{EvmPrecompileResult, Precompile, PrecompileOutput}; /// Blake2 costs. diff --git a/engine-precompiles/src/bn128.rs b/engine-precompiles/src/bn128.rs index 5422ed2cd..84c51f56c 100644 --- a/engine-precompiles/src/bn128.rs +++ b/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_new::Address, Borrowed, PhantomData, Vec}; use crate::{Byzantium, EvmPrecompileResult, HardFork, Istanbul, Precompile, PrecompileOutput}; use evm::{Context, ExitError}; diff --git a/engine-precompiles/src/hash.rs b/engine-precompiles/src/hash.rs index d096c3cb8..b66b43d63 100644 --- a/engine-precompiles/src/hash.rs +++ b/engine-precompiles/src/hash.rs @@ -1,7 +1,8 @@ #[cfg(feature = "contract")] use crate::prelude::sdk; use crate::prelude::types::EthGas; -use crate::prelude::{vec, Address}; +use crate::prelude::types_new::Address; +use crate::prelude::vec; use crate::{EvmPrecompileResult, Precompile, PrecompileOutput}; use evm::{Context, ExitError}; diff --git a/engine-precompiles/src/identity.rs b/engine-precompiles/src/identity.rs index 371d7747b..0ae0eb5e8 100644 --- a/engine-precompiles/src/identity.rs +++ b/engine-precompiles/src/identity.rs @@ -1,5 +1,5 @@ use crate::prelude::types::EthGas; -use crate::prelude::Address; +use crate::prelude::types_new::Address; use crate::{EvmPrecompileResult, Precompile, PrecompileOutput}; use evm::{Context, ExitError}; diff --git a/engine-precompiles/src/lib.rs b/engine-precompiles/src/lib.rs index 22acf4d5b..3999d8478 100644 --- a/engine-precompiles/src/lib.rs +++ b/engine-precompiles/src/lib.rs @@ -26,7 +26,7 @@ use crate::prelude::types::EthGas; use crate::prelude::{Vec, 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_new::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>); impl executor::PrecompileSet for Precompiles { fn execute( &self, - address: prelude::Address, + address: prelude::H160, input: &[u8], gas_limit: Option, context: &Context, is_static: bool, ) -> Option> { - 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)) } } @@ -262,10 +262,10 @@ impl Precompiles { /// const 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_new::Address { let x_bytes = x.to_be_bytes(); let y_bytes = y.to_be_bytes(); - prelude::Address([ + prelude::types_new::Address::from_slice(&[ x_bytes[0], x_bytes[1], x_bytes[2], diff --git a/engine-precompiles/src/modexp.rs b/engine-precompiles/src/modexp.rs index eac9735df..0e8ba429d 100644 --- a/engine-precompiles/src/modexp.rs +++ b/engine-precompiles/src/modexp.rs @@ -1,4 +1,4 @@ -use crate::prelude::{Address, PhantomData, Vec, U256}; +use crate::prelude::{types_new::Address, PhantomData, Vec, U256}; use crate::{Berlin, Byzantium, EvmPrecompileResult, HardFork, Precompile, PrecompileOutput}; use crate::prelude::types::EthGas; diff --git a/engine-precompiles/src/native.rs b/engine-precompiles/src/native.rs index 8cf4bf58e..fcee06140 100644 --- a/engine-precompiles/src/native.rs +++ b/engine-precompiles/src/native.rs @@ -5,7 +5,7 @@ use crate::prelude::{ parameters::{PromiseArgs, PromiseCreateArgs, WithdrawCallArgs}, sdk, storage::{bytes_to_key, KeyPrefix}, - 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::{ @@ -14,7 +14,7 @@ use crate::prelude::{ }; use crate::prelude::types::EthGas; -use crate::prelude::Address; +use crate::prelude::types_new::Address; use crate::PrecompileOutput; use aurora_engine_types::account_id::AccountId; #[cfg(feature = "contract")] @@ -44,7 +44,7 @@ mod costs { } pub mod events { - use crate::prelude::{vec, Address, String, ToString, H256, U256}; + use crate::prelude::{types_new::Address, vec, String, ToString, H256, U256}; /// Derived from event signature (see tests::test_exit_signatures) pub const EXIT_TO_NEAR_SIGNATURE: H256 = crate::make_h256( @@ -61,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::from_slice(&[0; 20]); /// ExitToNear( /// Address indexed sender, @@ -127,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) } @@ -301,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, @@ -345,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, }, @@ -397,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, }; @@ -501,9 +501,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, }, ) @@ -534,7 +534,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, @@ -548,9 +548,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, }, ) @@ -575,13 +575,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, }; diff --git a/engine-precompiles/src/random.rs b/engine-precompiles/src/random.rs index 014b7ee8a..00aa4ab29 100644 --- a/engine-precompiles/src/random.rs +++ b/engine-precompiles/src/random.rs @@ -1,6 +1,7 @@ use super::{EvmPrecompileResult, Precompile}; use crate::prelude::types::EthGas; -use crate::prelude::{Address, H256}; +use crate::prelude::types_new::Address; +use crate::prelude::H256; use crate::PrecompileOutput; use evm::{Context, ExitError}; diff --git a/engine-precompiles/src/secp256k1.rs b/engine-precompiles/src/secp256k1.rs index 14f11d87c..c9ea7e9e4 100644 --- a/engine-precompiles/src/secp256k1.rs +++ b/engine-precompiles/src/secp256k1.rs @@ -1,7 +1,7 @@ use crate::prelude::types::EthGas; +use crate::prelude::types_new::Address; use crate::prelude::{sdk, vec, Borrowed, H256}; use crate::{EvmPrecompileResult, Precompile, PrecompileOutput}; -use ethabi::Address; use evm::{Context, ExitError}; mod costs { diff --git a/engine-sdk/src/prelude.rs b/engine-sdk/src/prelude.rs index 359551455..493c3188d 100644 --- a/engine-sdk/src/prelude.rs +++ b/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_new::Address, vec, Vec, H256}; pub use borsh::{BorshDeserialize, BorshSerialize}; diff --git a/engine-types/src/parameters.rs b/engine-types/src/parameters.rs index 417326874..23d7348c5 100644 --- a/engine-types/src/parameters.rs +++ b/engine-types/src/parameters.rs @@ -1,5 +1,6 @@ use crate::account_id::*; use crate::types::*; +use crate::types_new::Address; use crate::*; use borsh::{BorshDeserialize, BorshSerialize}; @@ -53,7 +54,7 @@ pub struct PromiseBatchAction { /// withdraw NEAR eth-connector call args #[derive(Debug, BorshSerialize, BorshDeserialize)] pub struct WithdrawCallArgs { - pub recipient_address: EthAddress, + pub recipient_address: Address, pub amount: Balance, } diff --git a/engine-types/src/storage.rs b/engine-types/src/storage.rs index 9a6827a96..31af0ef68 100644 --- a/engine-types/src/storage.rs +++ b/engine-types/src/storage.rs @@ -1,3 +1,4 @@ +use crate::types_new::Address; use crate::*; use borsh::{BorshDeserialize, BorshSerialize}; @@ -65,7 +66,7 @@ pub fn address_to_key(prefix: KeyPrefix, address: &Address) -> [u8; 22] { let mut result = [0u8; 22]; result[0] = VersionPrefix::V1 as u8; result[1] = prefix as u8; - result[2..22].copy_from_slice(&address.0); + result[2..22].copy_from_slice(address.as_bytes()); result } @@ -97,7 +98,7 @@ fn normal_storage_key(address: &Address, key: &H256) -> [u8; 54] { let mut result = [0u8; 54]; result[0] = VersionPrefix::V1 as u8; result[1] = KeyPrefix::Storage as u8; - result[2..22].copy_from_slice(&address.0); + result[2..22].copy_from_slice(address.as_bytes()); result[22..54].copy_from_slice(&key.0); result } @@ -107,7 +108,7 @@ fn generation_storage_key(address: &Address, key: &H256, generation: u32) -> [u8 let mut result = [0u8; 58]; result[0] = VersionPrefix::V1 as u8; result[1] = KeyPrefix::Storage as u8; - result[2..22].copy_from_slice(&address.0); + result[2..22].copy_from_slice(address.as_bytes()); result[22..26].copy_from_slice(&generation.to_le_bytes()); result[26..58].copy_from_slice(&key.0); result diff --git a/engine-types/src/types.rs b/engine-types/src/types.rs index e37f04b8d..c46233f71 100644 --- a/engine-types/src/types.rs +++ b/engine-types/src/types.rs @@ -1,4 +1,4 @@ -use crate::{str, vec, Add, Address, Display, Div, Mul, String, Sub, Vec, U256}; +use crate::{str, types_new::Address, vec, Add, Display, Div, Mul, String, Sub, Vec, U256}; use borsh::{BorshDeserialize, BorshSerialize}; use crate::fmt::Formatter; diff --git a/engine-types/src/types_new/address.rs b/engine-types/src/types_new/address.rs index 4bd93a8c2..717059a4e 100755 --- a/engine-types/src/types_new/address.rs +++ b/engine-types/src/types_new/address.rs @@ -1,8 +1,9 @@ -use crate::{String, H160}; +use crate::{String, TryFrom, TryInto, H160}; use borsh::maybestd::io; use borsh::{BorshDeserialize, BorshSerialize}; /// Base Eth Address type +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)] pub struct Address(H160); impl Address { @@ -20,6 +21,22 @@ impl Address { pub fn encode(&self) -> String { hex::encode(self.0.as_bytes()) } + + pub fn as_bytes(&self) -> &[u8] { + self.0.as_bytes() + } + + pub fn from_slice(raw_addr: &[u8]) -> Self { + Self::new(H160::from_slice(raw_addr)) + } +} + +impl TryFrom<&[u8]> for Address { + type Error = (); + + fn try_from(raw_addr: &[u8]) -> Result { + Ok(Self::try_from_slice(raw_addr)) + } } impl BorshSerialize for Address { @@ -30,7 +47,7 @@ impl BorshSerialize for Address { impl BorshDeserialize for Address { fn deserialize(buf: &mut &[u8]) -> io::Result { - Ok(Self(H160::from_slice(buf))) + Ok(Self(H160::try_from(buf))) } fn try_from_slice(v: &[u8]) -> io::Result { @@ -78,3 +95,7 @@ mod tests { let _ = Address::try_from_slice(&serialized_addr); } } + +pub mod error { + pub struct Err; +} From c1204c842a208de9e763876e6577436ada62a774 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Wed, 15 Dec 2021 00:18:53 +0200 Subject: [PATCH 04/26] Added AddressConst --- engine-precompiles/src/lib.rs | 12 +++++---- engine-types/src/types_new/address.rs | 39 ++++++++++++++++++++++----- 2 files changed, 40 insertions(+), 11 deletions(-) diff --git a/engine-precompiles/src/lib.rs b/engine-precompiles/src/lib.rs index 3999d8478..206eb7252 100644 --- a/engine-precompiles/src/lib.rs +++ b/engine-precompiles/src/lib.rs @@ -23,7 +23,7 @@ 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, types_new::Address, vec, BTreeMap, Box}; @@ -259,11 +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::types_new::Address { - let x_bytes = x.to_be_bytes(); +pub const fn make_address(_x: u32, _y: u128) -> prelude::types_new::Address { + let addr = H160([0u8; 20]); + prelude::types_new::Address::new(addr) + /*let x_bytes = x.to_be_bytes(); let y_bytes = y.to_be_bytes(); prelude::types_new::Address::from_slice(&[ x_bytes[0], @@ -286,7 +288,7 @@ pub const fn make_address(x: u32, y: u128) -> prelude::types_new::Address { y_bytes[13], y_bytes[14], y_bytes[15], - ]) + ])*/ } const fn make_h256(x: u128, y: u128) -> prelude::H256 { diff --git a/engine-types/src/types_new/address.rs b/engine-types/src/types_new/address.rs index 717059a4e..c7021d414 100755 --- a/engine-types/src/types_new/address.rs +++ b/engine-types/src/types_new/address.rs @@ -1,11 +1,15 @@ -use crate::{String, TryFrom, TryInto, H160}; +use crate::{String, TryFrom, H160}; use borsh::maybestd::io; use borsh::{BorshDeserialize, BorshSerialize}; /// Base Eth Address type -#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)] +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)] pub struct Address(H160); +pub const fn AddressConst(addr: H160) -> Address { + Address(addr) +} + impl Address { /// Construct Address from H160 pub fn new(val: H160) -> Self { @@ -32,10 +36,10 @@ impl Address { } impl TryFrom<&[u8]> for Address { - type Error = (); + type Error = error::AddressLengthError; fn try_from(raw_addr: &[u8]) -> Result { - Ok(Self::try_from_slice(raw_addr)) + Self::try_from_slice(raw_addr).map_err(|_| error::AddressLengthError) } } @@ -47,7 +51,14 @@ impl BorshSerialize for Address { impl BorshDeserialize for Address { fn deserialize(buf: &mut &[u8]) -> io::Result { - Ok(Self(H160::try_from(buf))) + if buf.len() != 20 { + return Err(io::Error::new( + io::ErrorKind::Other, + format!("{}", error::AddressLengthError), + )); + } + // Guaranty no panics. The length checked early + Ok(Self(H160::from_slice(buf))) } fn try_from_slice(v: &[u8]) -> io::Result { @@ -97,5 +108,21 @@ mod tests { } pub mod error { - pub struct Err; + use crate::{fmt, String}; + + #[derive(Eq, Hash, Clone, Debug, PartialEq)] + pub struct AddressLengthError; + + impl AsRef<[u8]> for AddressLengthError { + fn as_ref(&self) -> &[u8] { + b"ERR_WRONG_ADDRESS_LENGTH" + } + } + + impl fmt::Display for AddressLengthError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let msg = String::from_utf8(self.as_ref().to_vec()).unwrap(); + write!(f, "{}", msg) + } + } } From edc99adff5fe6d4709b98a3c3c03df690983d290 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Wed, 15 Dec 2021 00:35:32 +0200 Subject: [PATCH 05/26] Fix address types for engine --- engine-precompiles/src/lib.rs | 10 +++---- engine-precompiles/src/native.rs | 9 ++++--- engine-types/src/lib.rs | 10 ------- engine-types/src/types_new/address.rs | 1 + engine/src/connector.rs | 7 ++--- engine/src/engine.rs | 39 ++++++++++++++------------- engine/src/fungible_token.rs | 10 +++---- engine/src/lib.rs | 4 +-- engine/src/transaction/eip_2930.rs | 3 ++- engine/src/transaction/legacy.rs | 3 ++- engine/src/transaction/mod.rs | 5 ++-- 11 files changed, 49 insertions(+), 52 deletions(-) diff --git a/engine-precompiles/src/lib.rs b/engine-precompiles/src/lib.rs index 206eb7252..e0814c78d 100644 --- a/engine-precompiles/src/lib.rs +++ b/engine-precompiles/src/lib.rs @@ -262,12 +262,10 @@ impl Precompiles { /// 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::types_new::Address { - let addr = H160([0u8; 20]); - prelude::types_new::Address::new(addr) - /*let x_bytes = x.to_be_bytes(); +pub const fn make_address(x: u32, y: u128) -> prelude::types_new::Address { + let x_bytes = x.to_be_bytes(); let y_bytes = y.to_be_bytes(); - prelude::types_new::Address::from_slice(&[ + prelude::types_new::AddressConst(H160([ x_bytes[0], x_bytes[1], x_bytes[2], @@ -288,7 +286,7 @@ pub const fn make_address(_x: u32, _y: u128) -> prelude::types_new::Address { y_bytes[13], y_bytes[14], y_bytes[15], - ])*/ + ])) } const fn make_h256(x: u128, y: u128) -> prelude::H256 { diff --git a/engine-precompiles/src/native.rs b/engine-precompiles/src/native.rs index fcee06140..5791f1fdb 100644 --- a/engine-precompiles/src/native.rs +++ b/engine-precompiles/src/native.rs @@ -44,7 +44,8 @@ mod costs { } pub mod events { - use crate::prelude::{types_new::Address, vec, String, ToString, H256, U256}; + use crate::prelude::{types_new::Address, vec, String, ToString, H160, H256, U256}; + use aurora_engine_types::types_new::AddressConst; /// Derived from event signature (see tests::test_exit_signatures) pub const EXIT_TO_NEAR_SIGNATURE: H256 = crate::make_h256( @@ -61,7 +62,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::from_slice(&[0; 20]); + pub const ETH_ADDRESS: Address = AddressConst(H160([0; 20])); /// ExitToNear( /// Address indexed sender, @@ -487,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")))?; ( @@ -495,7 +496,7 @@ impl Precompile for ExitToEthereum { // There is no way to inject json, given the encoding of both arguments // as decimal and hexadecimal respectively. WithdrawCallArgs { - recipient_address, + recipient_address: recipient_address.clone(), amount: context.apparent_value.as_u128(), } .try_to_vec() diff --git a/engine-types/src/lib.rs b/engine-types/src/lib.rs index 4f4ade1a3..79bac0bc5 100644 --- a/engine-types/src/lib.rs +++ b/engine-types/src/lib.rs @@ -44,13 +44,3 @@ mod v0 { } pub use v0::*; -/* -/// See: https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485 -pub type Address = H160; - -#[allow(non_snake_case, dead_code)] -// Gets around the fact that you can't contract pub fields with types. -pub const fn Address(input: [u8; 20]) -> Address { - H160(input) -} -*/ diff --git a/engine-types/src/types_new/address.rs b/engine-types/src/types_new/address.rs index c7021d414..7aa9bcd09 100755 --- a/engine-types/src/types_new/address.rs +++ b/engine-types/src/types_new/address.rs @@ -6,6 +6,7 @@ use borsh::{BorshDeserialize, BorshSerialize}; #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)] pub struct Address(H160); +#[allow(non_snake_case, dead_code)] pub const fn AddressConst(addr: H160) -> Address { Address(addr) } diff --git a/engine/src/connector.rs b/engine/src/connector.rs index 959dd8e7d..ab5d6a390 100644 --- a/engine/src/connector.rs +++ b/engine/src/connector.rs @@ -8,10 +8,11 @@ use crate::parameters::{ SetContractDataCallArgs, StorageBalanceOfCallArgs, StorageDepositCallArgs, StorageWithdrawCallArgs, TransferCallArgs, TransferCallCallArgs, WithdrawResult, }; +use crate::prelude::types_new::Address; use crate::prelude::{ - format, sdk, str, validate_eth_address, AccountId, Address, Balance, BorshDeserialize, - BorshSerialize, EthAddress, EthConnectorStorageId, KeyPrefix, NearGas, PromiseResult, ToString, - Vec, WithdrawCallArgs, ERR_FAILED_PARSE, H160, + format, sdk, str, validate_eth_address, AccountId, Balance, BorshDeserialize, BorshSerialize, + EthAddress, EthConnectorStorageId, KeyPrefix, NearGas, PromiseResult, ToString, Vec, + WithdrawCallArgs, ERR_FAILED_PARSE, H160, }; use crate::prelude::{ AddressValidationError, PromiseBatchAction, PromiseCreateArgs, PromiseWithCallbackArgs, diff --git a/engine/src/engine.rs b/engine/src/engine.rs index 1f1937410..634439420 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -13,10 +13,11 @@ use aurora_engine_sdk::promise::{PromiseHandler, PromiseId}; use crate::parameters::{DeployErc20TokenArgs, NewCallArgs, TransactionStatus}; use crate::prelude::precompiles::native::{ExitToEthereum, ExitToNear}; use crate::prelude::precompiles::Precompiles; +use crate::prelude::H160; use crate::prelude::{ - address_to_key, bytes_to_key, sdk, storage_to_key, u256_to_arr, vec, AccountId, Address, - BorshDeserialize, BorshSerialize, KeyPrefix, PromiseArgs, PromiseCreateArgs, ToString, TryFrom, - TryInto, Vec, Wei, ERC20_MINT_SELECTOR, H256, U256, + address_to_key, bytes_to_key, sdk, storage_to_key, types_new::Address, u256_to_arr, vec, + AccountId, BorshDeserialize, BorshSerialize, KeyPrefix, PromiseArgs, PromiseCreateArgs, + ToString, TryFrom, TryInto, Vec, Wei, ERC20_MINT_SELECTOR, H256, U256, }; use crate::transaction::{EthTransactionKind, NormalizedEthTransaction}; use aurora_engine_precompiles::PrecompileConstructorContext; @@ -526,7 +527,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let origin = self.origin(); match args { CallArgs::V2(call_args) => { - let contract = Address(call_args.contract); + let contract = Address::from_slice(call_args.contract); let value = call_args.value.into(); let input = call_args.input; self.call( @@ -540,7 +541,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { ) } CallArgs::V1(call_args) => { - let contract = Address(call_args.contract); + let contract = Address::from_slice(call_args.contract); let value = Wei::zero(); let input = call_args.input; self.call( @@ -709,7 +710,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let mut message = args.msg.as_bytes(); assert_or_finish!(message.len() >= 40, output_on_fail, self.io); - let recipient = Address(unwrap_res_or_finish!( + let recipient = Address::from_slice(unwrap_res_or_finish!( hex::decode(&message[..40]).unwrap().as_slice().try_into(), output_on_fail, self.io @@ -728,7 +729,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { (recipient, fee) }; - let erc20_token = Address(unwrap_res_or_finish!( + let erc20_token = Address::from_slice(unwrap_res_or_finish!( unwrap_res_or_finish!( get_erc20_from_nep141(&self.io, token), output_on_fail, @@ -1037,7 +1038,9 @@ pub fn deploy_erc20_token( handler, ) { Ok(result) => match result.status { - TransactionStatus::Succeed(ret) => Address(ret.as_slice().try_into().unwrap()), + TransactionStatus::Succeed(ret) => { + Address::from_slice(ret.as_slice().try_into().unwrap()) + } other => return Err(DeployErc20Error::Failed(other)), }, Err(e) => return Err(DeployErc20Error::Engine(e)), @@ -1297,7 +1300,7 @@ impl<'env, I: IO + Copy, E: Env> evm::backend::Backend for Engine<'env, I, E> { } /// Returns the origin address that created the contract. - fn origin(&self) -> Address { + fn origin(&self) -> H160 { self.origin } @@ -1341,8 +1344,8 @@ impl<'env, I: IO + Copy, E: Env> evm::backend::Backend for Engine<'env, I, E> { /// account, being 0x4444588443C3a91288c5002483449Aba1054192b. /// /// See: https://doc.aurora.dev/develop/compat/evm#coinbase - fn block_coinbase(&self) -> Address { - Address([ + fn block_coinbase(&self) -> H160 { + H160([ 0x44, 0x44, 0x58, 0x84, 0x43, 0xC3, 0xa9, 0x12, 0x88, 0xc5, 0x00, 0x24, 0x83, 0x44, 0x9A, 0xba, 0x10, 0x54, 0x19, 0x2b, ]) @@ -1387,12 +1390,12 @@ impl<'env, I: IO + Copy, E: Env> evm::backend::Backend for Engine<'env, I, E> { } /// Checks if an address exists. - fn exists(&self, address: Address) -> bool { + fn exists(&self, address: H160) -> bool { !is_account_empty(&self.io, &address) } /// Returns basic account information. - fn basic(&self, address: Address) -> Basic { + fn basic(&self, address: H160) -> Basic { Basic { nonce: get_nonce(&self.io, &address), balance: get_balance(&self.io, &address).raw(), @@ -1400,14 +1403,14 @@ impl<'env, I: IO + Copy, E: Env> evm::backend::Backend for Engine<'env, I, E> { } /// Returns the code of the contract from an address. - fn code(&self, address: Address) -> Vec { - get_code(&self.io, &address) + fn code(&self, address: H160) -> Vec { + get_code(&self.io, &Address::new(address)) } /// Get storage value of address at index. - fn storage(&self, address: Address, index: H256) -> H256 { + fn storage(&self, address: H160, index: H256) -> H256 { let generation = get_generation(&self.io, &address); - get_storage(&self.io, &address, &index, generation) + get_storage(&self.io, &Address::new(address), &index, generation) } /// Get original storage value of address at index, if available. @@ -1415,7 +1418,7 @@ impl<'env, I: IO + Copy, E: Env> evm::backend::Backend for Engine<'env, I, E> { /// Since SputnikVM collects storage changes in memory until the transaction is over, /// the "original storage" will always be the same as the storage because no values /// are written to storage until after the transaction is complete. - fn original_storage(&self, address: Address, index: H256) -> Option { + fn original_storage(&self, address: H160, index: H256) -> Option { Some(self.storage(address, index)) } } diff --git a/engine/src/fungible_token.rs b/engine/src/fungible_token.rs index 74f220ce2..8319bbbaa 100644 --- a/engine/src/fungible_token.rs +++ b/engine/src/fungible_token.rs @@ -4,8 +4,8 @@ use crate::json::{parse_json, JsonValue}; use crate::parameters::{NEP141FtOnTransferArgs, ResolveTransferCallArgs, StorageBalance}; use crate::prelude::account_id::AccountId; use crate::prelude::{ - sdk, storage, vec, Address, BTreeMap, Balance, BorshDeserialize, BorshSerialize, EthAddress, - NearGas, PromiseAction, PromiseBatchAction, PromiseCreateArgs, PromiseResult, + sdk, storage, types_new::Address, vec, BTreeMap, Balance, BorshDeserialize, BorshSerialize, + EthAddress, NearGas, PromiseAction, PromiseBatchAction, PromiseCreateArgs, PromiseResult, PromiseWithCallbackArgs, StorageBalanceBounds, StorageUsage, String, ToString, TryInto, Vec, Wei, U256, }; @@ -149,7 +149,7 @@ impl FungibleTokenOps { &self, address: EthAddress, ) -> Result { - engine::get_balance(&self.io, &Address(address)).try_into_u128() + engine::get_balance(&self.io, &Address::from_slice(address)).try_into_u128() } /// Internal ETH deposit to NEAR - nETH (NEP-141) @@ -184,7 +184,7 @@ impl FungibleTokenOps { .ok_or(error::DepositError::BalanceOverflow)?; engine::set_balance( &mut self.io, - &Address(address), + &Address::from_slice(address), &Wei::new(U256::from(new_balance)), ); self.total_eth_supply_on_aurora = self @@ -226,7 +226,7 @@ impl FungibleTokenOps { .ok_or(error::WithdrawError::InsufficientFunds)?; engine::set_balance( &mut self.io, - &Address(address), + &Address::from_slice(address), &Wei::new(U256::from(new_balance)), ); self.total_eth_supply_on_aurora = self diff --git a/engine/src/lib.rs b/engine/src/lib.rs index 04dc19285..99efaf88d 100644 --- a/engine/src/lib.rs +++ b/engine/src/lib.rs @@ -91,8 +91,8 @@ mod contract { use crate::prelude::storage::{bytes_to_key, KeyPrefix}; use crate::prelude::types::{u256_to_arr, ERR_FAILED_PARSE}; use crate::prelude::{ - sdk, vec, Address, PromiseResult, ToString, TryFrom, TryInto, Vec, Wei, - ERC20_MINT_SELECTOR, H256, U256, + sdk, vec, PromiseResult, ToString, TryFrom, TryInto, Vec, Wei, ERC20_MINT_SELECTOR, H256, + U256, }; #[cfg(feature = "integration-test")] diff --git a/engine/src/transaction/eip_2930.rs b/engine/src/transaction/eip_2930.rs index 72aa564ae..d6f6c649a 100644 --- a/engine/src/transaction/eip_2930.rs +++ b/engine/src/transaction/eip_2930.rs @@ -1,5 +1,6 @@ use crate::prelude::precompiles::secp256k1::ecrecover; -use crate::prelude::{sdk, Address, Vec, Wei, H256, U256}; +use crate::prelude::{sdk, Vec, Wei, H256, U256}; +use aurora_engine_types::types_new::Address; use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream}; /// Type indicator (per EIP-2718) for access list transactions diff --git a/engine/src/transaction/legacy.rs b/engine/src/transaction/legacy.rs index 124830383..09afc1c5f 100644 --- a/engine/src/transaction/legacy.rs +++ b/engine/src/transaction/legacy.rs @@ -1,5 +1,6 @@ use crate::prelude::precompiles::secp256k1::ecrecover; -use crate::prelude::{sdk, Address, Vec, Wei, U256}; +use crate::prelude::types_new::Address; +use crate::prelude::{sdk, Vec, Wei, U256}; use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream}; #[derive(Debug, Eq, PartialEq, Clone)] diff --git a/engine/src/transaction/mod.rs b/engine/src/transaction/mod.rs index 7a16af021..a74f0bdf6 100644 --- a/engine/src/transaction/mod.rs +++ b/engine/src/transaction/mod.rs @@ -1,11 +1,12 @@ -use crate::prelude::{vec, Address, TryFrom, Vec, U256}; +use crate::prelude::{vec, TryFrom, Vec, U256}; use rlp::{Decodable, DecoderError, Rlp}; pub mod eip_1559; pub mod eip_2930; pub mod legacy; -use aurora_engine_types::types::Wei; +use crate::prelude::types::Wei; +use crate::prelude::types_new::Address; use eip_2930::AccessTuple; /// Typed Transaction Envelope (see https://eips.ethereum.org/EIPS/eip-2718) From bdbcb45c44020ecb6890c28336d333e0b914939b Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Wed, 15 Dec 2021 13:28:21 +0200 Subject: [PATCH 06/26] Removed EthAddress type --- engine-tests/src/tests/eth_connector.rs | 8 ++++---- engine-types/src/parameters.rs | 4 ++-- engine-types/src/types.rs | 5 +---- engine/src/connector.rs | 12 ++++++------ engine/src/deposit_event.rs | 14 +++++++------- engine/src/engine.rs | 15 ++++++++------- engine/src/fungible_token.rs | 20 ++++++-------------- engine/src/parameters.rs | 14 +++++++------- 8 files changed, 41 insertions(+), 51 deletions(-) diff --git a/engine-tests/src/tests/eth_connector.rs b/engine-tests/src/tests/eth_connector.rs index 7f1de673c..ae28465e9 100644 --- a/engine-tests/src/tests/eth_connector.rs +++ b/engine-tests/src/tests/eth_connector.rs @@ -1,4 +1,4 @@ -use crate::prelude::EthAddress; +use crate::prelude::types_new::Address; use crate::prelude::WithdrawCallArgs; use crate::test_utils::str_to_account_id; use aurora_engine::admin_controlled::{PausedMask, ERR_PAUSED}; @@ -98,7 +98,7 @@ fn init_contract( contract_account } -fn validate_eth_address(address: &str) -> EthAddress { +fn validate_eth_address(address: &str) -> Address { let data = hex::decode(address).unwrap(); assert_eq!(data.len(), 20); let mut result = [0u8; 20]; @@ -192,10 +192,10 @@ fn get_eth_on_near_balance(master_account: &UserAccount, acc: &str, contract: &s val.parse().unwrap() } -fn get_eth_balance(master_account: &UserAccount, address: EthAddress, contract: &str) -> u128 { +fn get_eth_balance(master_account: &UserAccount, address: Address, contract: &str) -> u128 { #[derive(BorshSerialize, BorshDeserialize)] pub struct BalanceOfEthCallArgs { - pub address: EthAddress, + pub address: Address, } let balance = master_account.view( diff --git a/engine-types/src/parameters.rs b/engine-types/src/parameters.rs index 23d7348c5..5174ac85c 100644 --- a/engine-types/src/parameters.rs +++ b/engine-types/src/parameters.rs @@ -61,7 +61,7 @@ pub struct WithdrawCallArgs { /// withdraw NEAR eth-connector call args #[derive(BorshSerialize, BorshDeserialize)] pub struct RefundCallArgs { - pub recipient_address: EthAddress, - pub erc20_address: Option, + pub recipient_address: Address, + pub erc20_address: Option
, pub amount: RawU256, } diff --git a/engine-types/src/types.rs b/engine-types/src/types.rs index c46233f71..f1b5784e2 100644 --- a/engine-types/src/types.rs +++ b/engine-types/src/types.rs @@ -9,9 +9,6 @@ pub type RawAddress = [u8; 20]; 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 pub type WeiU256 = [u8; 32]; @@ -176,7 +173,7 @@ impl AsRef<[u8]> for AddressValidationError { } /// Validate Ethereum address from string and return Result data EthAddress or Error data -pub fn validate_eth_address(address: String) -> Result { +pub fn validate_eth_address(address: String) -> Result { let data = hex::decode(address).map_err(|_| AddressValidationError::FailedDecodeHex)?; if data.len() != 20 { return Err(AddressValidationError::IncorrectLength); diff --git a/engine/src/connector.rs b/engine/src/connector.rs index ab5d6a390..e645943b9 100644 --- a/engine/src/connector.rs +++ b/engine/src/connector.rs @@ -10,9 +10,9 @@ use crate::parameters::{ }; use crate::prelude::types_new::Address; use crate::prelude::{ - format, sdk, str, validate_eth_address, AccountId, Balance, BorshDeserialize, BorshSerialize, - EthAddress, EthConnectorStorageId, KeyPrefix, NearGas, PromiseResult, ToString, Vec, - WithdrawCallArgs, ERR_FAILED_PARSE, H160, + format, sdk, str, types_new::Address, validate_eth_address, AccountId, Balance, + BorshDeserialize, BorshSerialize, EthConnectorStorageId, KeyPrefix, NearGas, PromiseResult, + ToString, Vec, WithdrawCallArgs, ERR_FAILED_PARSE, H160, }; use crate::prelude::{ AddressValidationError, PromiseBatchAction, PromiseCreateArgs, PromiseWithCallbackArgs, @@ -56,7 +56,7 @@ pub struct EthConnector { /// It used in the Deposit flow, to verify log entry form incoming proof. pub prover_account: AccountId, /// It is Eth address, used in the Deposit and Withdraw logic. - pub eth_custodian_address: EthAddress, + pub eth_custodian_address: Address, } impl EthConnectorContract { @@ -326,7 +326,7 @@ impl EthConnectorContract { /// Mint ETH tokens fn mint_eth_on_aurora( &mut self, - owner_id: EthAddress, + owner_id: Address, amount: Balance, ) -> Result<(), fungible_token::error::DepositError> { sdk::log!(&format!( @@ -340,7 +340,7 @@ impl EthConnectorContract { /// Burn ETH tokens fn burn_eth_on_aurora( &mut self, - address: EthAddress, + address: Address, amount: Balance, ) -> Result<(), fungible_token::error::WithdrawError> { sdk::log!(&format!( diff --git a/engine/src/deposit_event.rs b/engine/src/deposit_event.rs index da1a9625f..4f497f474 100644 --- a/engine/src/deposit_event.rs +++ b/engine/src/deposit_event.rs @@ -2,8 +2,8 @@ use crate::deposit_event::error::ParseEventMessageError; use crate::log_entry::LogEntry; use crate::prelude::account_id::AccountId; use crate::prelude::{ - validate_eth_address, vec, AddressValidationError, Balance, BorshDeserialize, BorshSerialize, - EthAddress, Fee, String, ToString, TryFrom, TryInto, Vec, U256, + types_new::Address, validate_eth_address, vec, AddressValidationError, Balance, + BorshDeserialize, BorshSerialize, Fee, String, ToString, TryFrom, TryInto, Vec, U256, }; use byte_slice_cast::AsByteSlice; use ethabi::{Event, EventParam, Hash, Log, ParamType, RawLog}; @@ -18,7 +18,7 @@ pub type EventParams = Vec; #[cfg_attr(not(target_arch = "wasm32"), derive(Debug))] pub struct FtTransferMessageData { pub relayer: AccountId, - pub recipient: EthAddress, + pub recipient: Address, pub fee: Fee, } @@ -58,7 +58,7 @@ impl FtTransferMessageData { let fee: Fee = fee_u128.into(); // Get recipient Eth address from message slice - let mut recipient: EthAddress = Default::default(); + let mut recipient: Address = Default::default(); recipient.copy_from_slice(&msg[32..52]); Ok(FtTransferMessageData { @@ -182,7 +182,7 @@ impl TokenMessageData { /// Ethereum event pub struct EthEvent { - pub eth_custodian_address: EthAddress, + pub eth_custodian_address: Address, pub log: Log, } @@ -220,8 +220,8 @@ impl EthEvent { /// Data that was emitted by Deposited event. pub struct DepositedEvent { - pub eth_custodian_address: EthAddress, - pub sender: EthAddress, + pub eth_custodian_address: Address, + pub sender: Address, pub token_message_data: TokenMessageData, pub amount: Balance, pub fee: Fee, diff --git a/engine/src/engine.rs b/engine/src/engine.rs index 634439420..2b293f3f6 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -21,6 +21,7 @@ use crate::prelude::{ }; use crate::transaction::{EthTransactionKind, NormalizedEthTransaction}; use aurora_engine_precompiles::PrecompileConstructorContext; +use aurora_engine_types::types_new::AddressConst; /// Used as the first byte in the concatenation of data used to compute the blockhash. /// Could be useful in the future as a version byte, or to distinguish different types of blocks. @@ -527,7 +528,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let origin = self.origin(); match args { CallArgs::V2(call_args) => { - let contract = Address::from_slice(call_args.contract); + let contract = AddressConst(H160(call_args.contract)); let value = call_args.value.into(); let input = call_args.input; self.call( @@ -541,7 +542,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { ) } CallArgs::V1(call_args) => { - let contract = Address::from_slice(call_args.contract); + let contract = AddressConst(H160(call_args.contract)); let value = Wei::zero(); let input = call_args.input; self.call( @@ -710,11 +711,11 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let mut message = args.msg.as_bytes(); assert_or_finish!(message.len() >= 40, output_on_fail, self.io); - let recipient = Address::from_slice(unwrap_res_or_finish!( + let recipient = AddressConst(H160(unwrap_res_or_finish!( hex::decode(&message[..40]).unwrap().as_slice().try_into(), output_on_fail, self.io - )); + ))); message = &message[40..]; let fee = if message.is_empty() { @@ -729,7 +730,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { (recipient, fee) }; - let erc20_token = Address::from_slice(unwrap_res_or_finish!( + let erc20_token = Address(H160(unwrap_res_or_finish!( unwrap_res_or_finish!( get_erc20_from_nep141(&self.io, token), output_on_fail, @@ -739,7 +740,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { .try_into(), output_on_fail, self.io - )); + ))); if fee != U256::from(0) { let relayer_address = unwrap_res_or_finish!( @@ -1039,7 +1040,7 @@ pub fn deploy_erc20_token( ) { Ok(result) => match result.status { TransactionStatus::Succeed(ret) => { - Address::from_slice(ret.as_slice().try_into().unwrap()) + AddressConst(H160(ret.as_slice().try_into().unwrap())) } other => return Err(DeployErc20Error::Failed(other)), }, diff --git a/engine/src/fungible_token.rs b/engine/src/fungible_token.rs index 8319bbbaa..516051a25 100644 --- a/engine/src/fungible_token.rs +++ b/engine/src/fungible_token.rs @@ -5,7 +5,7 @@ use crate::parameters::{NEP141FtOnTransferArgs, ResolveTransferCallArgs, Storage use crate::prelude::account_id::AccountId; use crate::prelude::{ sdk, storage, types_new::Address, vec, BTreeMap, Balance, BorshDeserialize, BorshSerialize, - EthAddress, NearGas, PromiseAction, PromiseBatchAction, PromiseCreateArgs, PromiseResult, + NearGas, PromiseAction, PromiseBatchAction, PromiseCreateArgs, PromiseResult, PromiseWithCallbackArgs, StorageBalanceBounds, StorageUsage, String, ToString, TryInto, Vec, Wei, U256, }; @@ -147,7 +147,7 @@ impl FungibleTokenOps { /// Balance of ETH (ETH on Aurora) pub fn internal_unwrap_balance_of_eth_on_aurora( &self, - address: EthAddress, + address: Address, ) -> Result { engine::get_balance(&self.io, &Address::from_slice(address)).try_into_u128() } @@ -173,7 +173,7 @@ impl FungibleTokenOps { /// Internal ETH deposit to Aurora pub fn internal_deposit_eth_to_aurora( &mut self, - address: EthAddress, + address: Address, amount: Balance, ) -> Result<(), error::DepositError> { let balance = self @@ -182,11 +182,7 @@ impl FungibleTokenOps { let new_balance = balance .checked_add(amount) .ok_or(error::DepositError::BalanceOverflow)?; - engine::set_balance( - &mut self.io, - &Address::from_slice(address), - &Wei::new(U256::from(new_balance)), - ); + engine::set_balance(&mut self.io, &address, &Wei::new(U256::from(new_balance))); self.total_eth_supply_on_aurora = self .total_eth_supply_on_aurora .checked_add(amount) @@ -215,7 +211,7 @@ impl FungibleTokenOps { /// Withdraw ETH tokens pub fn internal_withdraw_eth_from_aurora( &mut self, - address: EthAddress, + address: Address, amount: Balance, ) -> Result<(), error::WithdrawError> { let balance = self @@ -224,11 +220,7 @@ impl FungibleTokenOps { let new_balance = balance .checked_sub(amount) .ok_or(error::WithdrawError::InsufficientFunds)?; - engine::set_balance( - &mut self.io, - &Address::from_slice(address), - &Wei::new(U256::from(new_balance)), - ); + engine::set_balance(&mut self.io, &address, &Wei::new(U256::from(new_balance))); self.total_eth_supply_on_aurora = self .total_eth_supply_on_aurora .checked_sub(amount) diff --git a/engine/src/parameters.rs b/engine/src/parameters.rs index d27ce394b..b67534863 100644 --- a/engine/src/parameters.rs +++ b/engine/src/parameters.rs @@ -3,8 +3,8 @@ use crate::fungible_token::FungibleTokenMetadata; use crate::json::{JsonError, JsonValue}; use crate::prelude::account_id::AccountId; use crate::prelude::{ - format, Balance, BorshDeserialize, BorshSerialize, EthAddress, RawAddress, RawH256, RawU256, - String, ToString, TryFrom, Vec, WeiU256, + format, types_new::Address, Balance, BorshDeserialize, BorshSerialize, RawAddress, RawH256, + RawU256, String, ToString, TryFrom, Vec, WeiU256, }; use crate::proof::Proof; use aurora_engine_types::types::Fee; @@ -272,7 +272,7 @@ pub struct DepositCallArgs { /// Proof data pub proof: Proof, /// Optional relayer address - pub relayer_eth_account: Option, + pub relayer_eth_account: Option
, } /// Eth-connector isUsedProof arguments @@ -333,13 +333,13 @@ pub struct FinishDepositCallArgs { #[derive(Default, BorshDeserialize, BorshSerialize, Clone)] pub struct DepositEthCallArgs { pub proof: Proof, - pub relayer_eth_account: EthAddress, + pub relayer_eth_account: Address, } /// Finish deposit NEAR eth-connector call args #[derive(BorshSerialize, BorshDeserialize)] pub struct FinishDepositEthCallArgs { - pub new_owner_id: EthAddress, + pub new_owner_id: Address, pub amount: Balance, pub fee: Balance, pub relayer_eth_account: AccountId, @@ -458,7 +458,7 @@ pub struct BalanceOfCallArgs { #[derive(BorshSerialize, BorshDeserialize)] pub struct BalanceOfEthCallArgs { - pub address: EthAddress, + pub address: Address, } impl TryFrom for BalanceOfCallArgs { @@ -473,7 +473,7 @@ impl TryFrom for BalanceOfCallArgs { #[derive(BorshSerialize, BorshDeserialize)] pub struct RegisterRelayerCallArgs { - pub address: EthAddress, + pub address: Address, } #[derive(BorshSerialize, BorshDeserialize)] From 99194ec0df37d4bab7e4cf49b4b39d471f53d3d5 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Wed, 15 Dec 2021 17:06:51 +0200 Subject: [PATCH 07/26] Changed Address const methods --- engine-precompiles/src/lib.rs | 2 +- engine-precompiles/src/native.rs | 4 +-- engine-types/src/types.rs | 26 ----------------- engine-types/src/types_new/address.rs | 42 ++++++++++++++++++++++----- engine/src/connector.rs | 23 +++++++-------- engine/src/deposit_event.rs | 13 +++++---- engine/src/engine.rs | 14 ++++----- engine/src/transaction/eip_1559.rs | 5 ++-- engine/src/transaction/eip_2930.rs | 1 - engine/src/transaction/mod.rs | 3 +- 10 files changed, 65 insertions(+), 68 deletions(-) diff --git a/engine-precompiles/src/lib.rs b/engine-precompiles/src/lib.rs index e0814c78d..b967bbd35 100644 --- a/engine-precompiles/src/lib.rs +++ b/engine-precompiles/src/lib.rs @@ -265,7 +265,7 @@ impl Precompiles { pub const fn make_address(x: u32, y: u128) -> prelude::types_new::Address { let x_bytes = x.to_be_bytes(); let y_bytes = y.to_be_bytes(); - prelude::types_new::AddressConst(H160([ + prelude::types_new::ADDRESS(H160([ x_bytes[0], x_bytes[1], x_bytes[2], diff --git a/engine-precompiles/src/native.rs b/engine-precompiles/src/native.rs index 5791f1fdb..80f14db29 100644 --- a/engine-precompiles/src/native.rs +++ b/engine-precompiles/src/native.rs @@ -45,7 +45,7 @@ mod costs { pub mod events { use crate::prelude::{types_new::Address, vec, String, ToString, H160, H256, U256}; - use aurora_engine_types::types_new::AddressConst; + use aurora_engine_types::types_new::ADDRESS; /// Derived from event signature (see tests::test_exit_signatures) pub const EXIT_TO_NEAR_SIGNATURE: H256 = crate::make_h256( @@ -62,7 +62,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 = AddressConst(H160([0; 20])); + pub const ETH_ADDRESS: Address = ADDRESS(H160([0; 20])); /// ExitToNear( /// Address indexed sender, diff --git a/engine-types/src/types.rs b/engine-types/src/types.rs index f1b5784e2..3a6013bbf 100644 --- a/engine-types/src/types.rs +++ b/engine-types/src/types.rs @@ -157,32 +157,6 @@ impl From for Fee { #[allow(dead_code)] pub const ERC20_MINT_SELECTOR: &[u8] = &[64, 193, 15, 25]; -#[derive(Debug)] -pub enum AddressValidationError { - FailedDecodeHex, - IncorrectLength, -} - -impl AsRef<[u8]> for AddressValidationError { - fn as_ref(&self) -> &[u8] { - match self { - Self::FailedDecodeHex => b"FAILED_DECODE_ETH_ADDRESS", - Self::IncorrectLength => b"ETH_WRONG_ADDRESS_LENGTH", - } - } -} - -/// Validate Ethereum address from string and return Result data EthAddress or Error data -pub fn validate_eth_address(address: String) -> Result { - let data = hex::decode(address).map_err(|_| AddressValidationError::FailedDecodeHex)?; - if data.len() != 20 { - return Err(AddressValidationError::IncorrectLength); - } - let mut result = [0u8; 20]; - result.copy_from_slice(&data); - Ok(result) -} - /// Newtype to distinguish balances (denominated in Wei) from other U256 types. #[derive(Default, Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)] pub struct Wei(U256); diff --git a/engine-types/src/types_new/address.rs b/engine-types/src/types_new/address.rs index 7aa9bcd09..b8d2060a0 100755 --- a/engine-types/src/types_new/address.rs +++ b/engine-types/src/types_new/address.rs @@ -7,7 +7,7 @@ use borsh::{BorshDeserialize, BorshSerialize}; pub struct Address(H160); #[allow(non_snake_case, dead_code)] -pub const fn AddressConst(addr: H160) -> Address { +pub const fn ADDRESS(addr: H160) -> Address { Address(addr) } @@ -27,6 +27,16 @@ impl Address { hex::encode(self.0.as_bytes()) } + pub fn decode(address: String) -> Result { + let data = hex::decode(address).map_err(|_| error::AddressError::FailedDecodeHex)?; + if data.len() != 20 { + return Err(error::AddressError::IncorrectLength); + } + let mut result = [0u8; 20]; + result.copy_from_slice(&data); + Ok(Address::new(H160(result))) + } + pub fn as_bytes(&self) -> &[u8] { self.0.as_bytes() } @@ -34,13 +44,17 @@ impl Address { pub fn from_slice(raw_addr: &[u8]) -> Self { Self::new(H160::from_slice(raw_addr)) } + + pub const fn zero() -> Self { + ADDRESS(H160([0u8; 20])) + } } impl TryFrom<&[u8]> for Address { - type Error = error::AddressLengthError; + type Error = error::AddressError; fn try_from(raw_addr: &[u8]) -> Result { - Self::try_from_slice(raw_addr).map_err(|_| error::AddressLengthError) + Self::try_from_slice(raw_addr).map_err(|_| error::AddressError::IncorrectLength) } } @@ -55,7 +69,7 @@ impl BorshDeserialize for Address { if buf.len() != 20 { return Err(io::Error::new( io::ErrorKind::Other, - format!("{}", error::AddressLengthError), + format!("{}", error::AddressError::IncorrectLength), )); } // Guaranty no panics. The length checked early @@ -68,6 +82,12 @@ impl BorshDeserialize for Address { } } +impl Default for Address { + fn default() -> Self { + Address::zero() + } +} + #[cfg(test)] mod tests { use super::*; @@ -112,15 +132,21 @@ pub mod error { use crate::{fmt, String}; #[derive(Eq, Hash, Clone, Debug, PartialEq)] - pub struct AddressLengthError; + pub enum AddressError { + FailedDecodeHex, + IncorrectLength, + } - impl AsRef<[u8]> for AddressLengthError { + impl AsRef<[u8]> for AddressError { fn as_ref(&self) -> &[u8] { - b"ERR_WRONG_ADDRESS_LENGTH" + match self { + Self::FailedDecodeHex => b"FAILED_DECODE_ETH_ADDRESS", + Self::IncorrectLength => b"ETH_WRONG_ADDRESS_LENGTH", + } } } - impl fmt::Display for AddressLengthError { + impl fmt::Display for AddressError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let msg = String::from_utf8(self.as_ref().to_vec()).unwrap(); write!(f, "{}", msg) diff --git a/engine/src/connector.rs b/engine/src/connector.rs index e645943b9..f4dfacbd4 100644 --- a/engine/src/connector.rs +++ b/engine/src/connector.rs @@ -8,18 +8,16 @@ use crate::parameters::{ SetContractDataCallArgs, StorageBalanceOfCallArgs, StorageDepositCallArgs, StorageWithdrawCallArgs, TransferCallArgs, TransferCallCallArgs, WithdrawResult, }; -use crate::prelude::types_new::Address; use crate::prelude::{ - format, sdk, str, types_new::Address, validate_eth_address, AccountId, Balance, - BorshDeserialize, BorshSerialize, EthConnectorStorageId, KeyPrefix, NearGas, PromiseResult, - ToString, Vec, WithdrawCallArgs, ERR_FAILED_PARSE, H160, -}; -use crate::prelude::{ - AddressValidationError, PromiseBatchAction, PromiseCreateArgs, PromiseWithCallbackArgs, + format, sdk, str, types_new::Address, AccountId, Balance, BorshDeserialize, BorshSerialize, + EthConnectorStorageId, KeyPrefix, NearGas, PromiseResult, ToString, Vec, WithdrawCallArgs, + ERR_FAILED_PARSE, H160, }; +use crate::prelude::{PromiseBatchAction, PromiseCreateArgs, PromiseWithCallbackArgs}; use crate::proof::Proof; use aurora_engine_sdk::env::Env; use aurora_engine_sdk::io::{StorageIntermediate, IO}; +use aurora_engine_types::types_new::address::error::AddressError; pub const ERR_NOT_ENOUGH_BALANCE_FOR_FEE: &str = "ERR_NOT_ENOUGH_BALANCE_FOR_FEE"; /// Indicate zero attached balance for promise call @@ -694,11 +692,11 @@ fn get_contract_data(io: &I, suffix: &EthConnectorSt pub fn set_contract_data( io: &mut I, args: SetContractDataCallArgs, -) -> Result { +) -> Result { // Get initial contract arguments let contract_data = EthConnector { prover_account: args.prover_account, - eth_custodian_address: validate_eth_address(args.eth_custodian_address)?, + eth_custodian_address: Address::decode(args.eth_custodian_address)?, }; // Save eth-connector specific data io.write_borsh( @@ -723,7 +721,8 @@ pub fn get_metadata(io: &I) -> Option { } pub mod error { - use crate::prelude::types::{error::BalanceOverflowError, AddressValidationError}; + use crate::prelude::types::error::BalanceOverflowError; + use aurora_engine_types::types_new::address::error::AddressError; use crate::deposit_event::error::ParseOnTransferMessageError; use crate::{deposit_event, fungible_token}; @@ -737,7 +736,7 @@ pub mod error { EventParseFailed(deposit_event::error::ParseError), CustodianAddressMismatch, InsufficientAmountForFee, - InvalidAddress(AddressValidationError), + InvalidAddress(AddressError), } impl AsRef<[u8]> for DepositError { @@ -845,7 +844,7 @@ pub mod error { pub enum InitContractError { AlreadyInitialized, - InvalidCustodianAddress(AddressValidationError), + InvalidCustodianAddress(AddressError), } impl AsRef<[u8]> for InitContractError { diff --git a/engine/src/deposit_event.rs b/engine/src/deposit_event.rs index 4f497f474..fac9eecd3 100644 --- a/engine/src/deposit_event.rs +++ b/engine/src/deposit_event.rs @@ -2,9 +2,10 @@ use crate::deposit_event::error::ParseEventMessageError; use crate::log_entry::LogEntry; use crate::prelude::account_id::AccountId; use crate::prelude::{ - types_new::Address, validate_eth_address, vec, AddressValidationError, Balance, - BorshDeserialize, BorshSerialize, Fee, String, ToString, TryFrom, TryInto, Vec, U256, + types_new::Address, vec, Balance, BorshDeserialize, BorshSerialize, Fee, String, ToString, + TryFrom, TryInto, Vec, U256, }; +use aurora_engine_types::types_new::address::error::AddressError; use byte_slice_cast::AsByteSlice; use ethabi::{Event, EventParam, Hash, Log, ParamType, RawLog}; @@ -96,14 +97,14 @@ impl FtTransferMessageData { recipient .strip_prefix("0x") .ok_or(ParseEventMessageError::EthAddressValidationError( - AddressValidationError::FailedDecodeHex, + AddressError::FailedDecodeHex, ))? .to_string() } else { recipient }; - let recipient_address = validate_eth_address(address) - .map_err(ParseEventMessageError::EthAddressValidationError)?; + let recipient_address = + Address::decode(address).map_err(ParseEventMessageError::EthAddressValidationError)?; // Second data section should contain Eth address data.extend(recipient_address); // Add `:` separator between relayer_id and data message @@ -321,7 +322,7 @@ pub mod error { pub enum ParseEventMessageError { TooManyParts, InvalidAccount, - EthAddressValidationError(AddressValidationError), + EthAddressValidationError(AddressError), ParseMessageError(ParseOnTransferMessageError), } diff --git a/engine/src/engine.rs b/engine/src/engine.rs index 2b293f3f6..a66407bae 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -21,7 +21,7 @@ use crate::prelude::{ }; use crate::transaction::{EthTransactionKind, NormalizedEthTransaction}; use aurora_engine_precompiles::PrecompileConstructorContext; -use aurora_engine_types::types_new::AddressConst; +use aurora_engine_types::types_new::ADDRESS; /// Used as the first byte in the concatenation of data used to compute the blockhash. /// Could be useful in the future as a version byte, or to distinguish different types of blocks. @@ -528,7 +528,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let origin = self.origin(); match args { CallArgs::V2(call_args) => { - let contract = AddressConst(H160(call_args.contract)); + let contract = ADDRESS(H160(call_args.contract)); let value = call_args.value.into(); let input = call_args.input; self.call( @@ -542,7 +542,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { ) } CallArgs::V1(call_args) => { - let contract = AddressConst(H160(call_args.contract)); + let contract = ADDRESS(H160(call_args.contract)); let value = Wei::zero(); let input = call_args.input; self.call( @@ -711,7 +711,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let mut message = args.msg.as_bytes(); assert_or_finish!(message.len() >= 40, output_on_fail, self.io); - let recipient = AddressConst(H160(unwrap_res_or_finish!( + let recipient = ADDRESS(H160(unwrap_res_or_finish!( hex::decode(&message[..40]).unwrap().as_slice().try_into(), output_on_fail, self.io @@ -730,7 +730,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { (recipient, fee) }; - let erc20_token = Address(H160(unwrap_res_or_finish!( + let erc20_token = ADDRESS(H160(unwrap_res_or_finish!( unwrap_res_or_finish!( get_erc20_from_nep141(&self.io, token), output_on_fail, @@ -1039,9 +1039,7 @@ pub fn deploy_erc20_token( handler, ) { Ok(result) => match result.status { - TransactionStatus::Succeed(ret) => { - AddressConst(H160(ret.as_slice().try_into().unwrap())) - } + TransactionStatus::Succeed(ret) => ADDRESS(H160(ret.as_slice().try_into().unwrap())), other => return Err(DeployErc20Error::Failed(other)), }, Err(e) => return Err(DeployErc20Error::Engine(e)), diff --git a/engine/src/transaction/eip_1559.rs b/engine/src/transaction/eip_1559.rs index 22a9ec539..4a7f9dca3 100644 --- a/engine/src/transaction/eip_1559.rs +++ b/engine/src/transaction/eip_1559.rs @@ -2,7 +2,6 @@ use crate::prelude::precompiles::secp256k1::ecrecover; use crate::prelude::{Vec, U256}; use crate::transaction::eip_2930::AccessTuple; use aurora_engine_types::types::Wei; -use ethabi::Address; use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream}; /// Type indicator (per EIP-1559) @@ -19,7 +18,7 @@ pub struct Transaction1559 { pub max_priority_fee_per_gas: U256, pub max_fee_per_gas: U256, pub gas_limit: U256, - pub to: Option
, + pub to: Option, pub value: Wei, pub data: Vec, pub access_list: Vec, @@ -71,7 +70,7 @@ pub struct SignedTransaction1559 { } impl SignedTransaction1559 { - pub fn sender(&self) -> Option
{ + pub fn sender(&self) -> Option { let mut rlp_stream = RlpStream::new(); rlp_stream.append(&TYPE_BYTE); self.transaction.rlp_append_unsigned(&mut rlp_stream); diff --git a/engine/src/transaction/eip_2930.rs b/engine/src/transaction/eip_2930.rs index d6f6c649a..152760978 100644 --- a/engine/src/transaction/eip_2930.rs +++ b/engine/src/transaction/eip_2930.rs @@ -1,6 +1,5 @@ use crate::prelude::precompiles::secp256k1::ecrecover; use crate::prelude::{sdk, Vec, Wei, H256, U256}; -use aurora_engine_types::types_new::Address; use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream}; /// Type indicator (per EIP-2718) for access list transactions diff --git a/engine/src/transaction/mod.rs b/engine/src/transaction/mod.rs index a74f0bdf6..40f77e053 100644 --- a/engine/src/transaction/mod.rs +++ b/engine/src/transaction/mod.rs @@ -190,7 +190,8 @@ fn rlp_extract_to(rlp: &Rlp<'_>, index: usize) -> Result, Decode Err(rlp::DecoderError::RlpExpectedToBeData) } } else { - let v: Address = value.as_val()?; + let addr: ethabi::Address = value.as_val()?; + let v = Address::from_slice(addr.as_bytes()); if v == Address::zero() { Ok(None) } else { From 05f7986cecc6d01304bd5b8456060a9389d41050 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Thu, 16 Dec 2021 00:00:16 +0200 Subject: [PATCH 08/26] Remove old Address type invokes --- engine/src/connector.rs | 12 ++++++------ engine/src/deposit_event.rs | 12 ++++++------ engine/src/engine.rs | 10 ++++++---- engine/src/fungible_token.rs | 6 +++--- engine/src/parameters.rs | 4 ++-- engine/src/transaction/eip_1559.rs | 7 +++++-- engine/src/transaction/eip_2930.rs | 5 +++-- engine/src/transaction/legacy.rs | 4 ++-- engine/src/transaction/mod.rs | 11 ++++++----- 9 files changed, 39 insertions(+), 32 deletions(-) diff --git a/engine/src/connector.rs b/engine/src/connector.rs index f4dfacbd4..644671b45 100644 --- a/engine/src/connector.rs +++ b/engine/src/connector.rs @@ -11,7 +11,7 @@ use crate::parameters::{ use crate::prelude::{ format, sdk, str, types_new::Address, AccountId, Balance, BorshDeserialize, BorshSerialize, EthConnectorStorageId, KeyPrefix, NearGas, PromiseResult, ToString, Vec, WithdrawCallArgs, - ERR_FAILED_PARSE, H160, + ERR_FAILED_PARSE, }; use crate::prelude::{PromiseBatchAction, PromiseCreateArgs, PromiseWithCallbackArgs}; use crate::proof::Proof; @@ -290,7 +290,7 @@ impl EthConnectorContract { address: &Address, amount: Balance, ) -> Result<(), fungible_token::error::WithdrawError> { - self.burn_eth_on_aurora(address.0, amount)?; + self.burn_eth_on_aurora(address, amount)?; self.save_ft_contract(); Ok(()) } @@ -338,7 +338,7 @@ impl EthConnectorContract { /// Burn ETH tokens fn burn_eth_on_aurora( &mut self, - address: Address, + address: &Address, amount: Balance, ) -> Result<(), fungible_token::error::WithdrawError> { sdk::log!(&format!( @@ -411,7 +411,7 @@ impl EthConnectorContract { ) -> Result<(), crate::prelude::types::error::BalanceOverflowError> { let balance = self .ft - .internal_unwrap_balance_of_eth_on_aurora(args.address)?; + .internal_unwrap_balance_of_eth_on_aurora(&args.address)?; sdk::log!(&format!( "Balance of ETH [{}]: {}", hex::encode(args.address), @@ -495,7 +495,7 @@ impl EthConnectorContract { // Note: It can't overflow because the total supply doesn't change during transfer. let amount_for_check = self .ft - .internal_unwrap_balance_of_eth_on_aurora(message_data.recipient) + .internal_unwrap_balance_of_eth_on_aurora(&message_data.recipient) .map_err(error::FtTransferCallError::BalanceOverflow)?; if amount_for_check.checked_add(args.amount).is_none() { return Err(error::FtTransferCallError::Transfer( @@ -602,7 +602,7 @@ impl EthConnectorContract { // Mint fee to relayer let relayer = engine.get_relayer(message_data.relayer.as_bytes()); match (fee, relayer) { - (fee, Some(H160(evm_relayer_address))) if fee > 0 => { + (fee, Some(evm_relayer_address)) if fee > 0 => { self.mint_eth_on_aurora(message_data.recipient, args.amount - fee)?; self.mint_eth_on_aurora(evm_relayer_address, fee)?; } diff --git a/engine/src/deposit_event.rs b/engine/src/deposit_event.rs index fac9eecd3..cc5aa9c33 100644 --- a/engine/src/deposit_event.rs +++ b/engine/src/deposit_event.rs @@ -59,8 +59,7 @@ impl FtTransferMessageData { let fee: Fee = fee_u128.into(); // Get recipient Eth address from message slice - let mut recipient: Address = Default::default(); - recipient.copy_from_slice(&msg[32..52]); + let recipient = Address::from_slice(&msg[32..52]); Ok(FtTransferMessageData { relayer: account_id, @@ -76,7 +75,7 @@ impl FtTransferMessageData { // it means 32 bytes for fee data let mut data = U256::from(self.fee.into_u128()).as_byte_slice().to_vec(); // Second data section should contain Eth address - data.extend(self.recipient); + data.extend(self.recipient.as_bytes()); // Add `:` separator between relayer_id and data message [self.relayer.as_ref(), &hex::encode(data)].join(":") } @@ -106,7 +105,7 @@ impl FtTransferMessageData { let recipient_address = Address::decode(address).map_err(ParseEventMessageError::EthAddressValidationError)?; // Second data section should contain Eth address - data.extend(recipient_address); + data.extend(recipient_address.as_bytes()); // Add `:` separator between relayer_id and data message //Ok([relayer_account_id.as_ref(), &hex::encode(data)].join(":")) Ok(Self { @@ -201,7 +200,7 @@ impl EthEvent { anonymous: false, }; let log_entry: LogEntry = rlp::decode(data).map_err(|_| error::DecodeError::RlpFailed)?; - let eth_custodian_address = log_entry.address.0; + let eth_custodian_address = Address::from_slice(&log_entry.address.0); let topics = log_entry.topics.iter().map(|h| Hash::from(h.0)).collect(); let raw_log = RawLog { @@ -259,12 +258,13 @@ impl DepositedEvent { pub fn from_log_entry_data(data: &[u8]) -> Result { let event = EthEvent::fetch_log_entry_data(DEPOSITED_EVENT, Self::event_params(), data) .map_err(error::ParseError::LogParseFailed)?; - let sender = event.log.params[0] + let raw_sender = event.log.params[0] .value .clone() .into_address() .ok_or(error::ParseError::InvalidSender)? .0; + let sender = Address::from_slice(&raw_sender); // parse_event_message let event_message_data: String = event.log.params[1].value.clone().to_string(); diff --git a/engine/src/engine.rs b/engine/src/engine.rs index a66407bae..cc8aa0beb 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -476,7 +476,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { input: Vec, handler: &mut P, ) -> EngineResult { - let origin = self.origin(); + let origin = Address::new(self.origin()); let value = Wei::zero(); self.deploy_code(origin, value, input, u64::MAX, Vec::new(), handler) } @@ -487,7 +487,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { value: Wei, input: Vec, gas_limit: u64, - access_list: Vec<(Address, Vec)>, // See EIP-2930 + access_list: Vec<(H160, Vec)>, // See EIP-2930 handler: &mut P, ) -> EngineResult { let executor_params = StackExecutorParams::new( @@ -496,9 +496,11 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { self.env.random_seed(), ); let mut executor = executor_params.make_executor(self); - let address = executor.create_address(CreateScheme::Legacy { caller: origin }); + let address = executor.create_address(CreateScheme::Legacy { + caller: origin.raw(), + }); let (exit_reason, result) = ( - executor.transact_create(origin, value.raw(), input, gas_limit, access_list), + executor.transact_create(origin.raw(), value.raw(), input, gas_limit, access_list), address, ); diff --git a/engine/src/fungible_token.rs b/engine/src/fungible_token.rs index 516051a25..68afdc799 100644 --- a/engine/src/fungible_token.rs +++ b/engine/src/fungible_token.rs @@ -147,9 +147,9 @@ impl FungibleTokenOps { /// Balance of ETH (ETH on Aurora) pub fn internal_unwrap_balance_of_eth_on_aurora( &self, - address: Address, + address: &Address, ) -> Result { - engine::get_balance(&self.io, &Address::from_slice(address)).try_into_u128() + engine::get_balance(&self.io, &address).try_into_u128() } /// Internal ETH deposit to NEAR - nETH (NEP-141) @@ -211,7 +211,7 @@ impl FungibleTokenOps { /// Withdraw ETH tokens pub fn internal_withdraw_eth_from_aurora( &mut self, - address: Address, + address: &Address, amount: Balance, ) -> Result<(), error::WithdrawError> { let balance = self diff --git a/engine/src/parameters.rs b/engine/src/parameters.rs index b67534863..7f5c65cfc 100644 --- a/engine/src/parameters.rs +++ b/engine/src/parameters.rs @@ -287,8 +287,8 @@ pub struct IsUsedProofCallArgs { #[cfg_attr(not(target_arch = "wasm32"), derive(BorshDeserialize))] pub struct WithdrawResult { pub amount: Balance, - pub recipient_id: RawAddress, - pub eth_custodian_address: RawAddress, + pub recipient_id: Address, + pub eth_custodian_address: Address, } /// Fungible token storage balance diff --git a/engine/src/transaction/eip_1559.rs b/engine/src/transaction/eip_1559.rs index 4a7f9dca3..5abe03564 100644 --- a/engine/src/transaction/eip_1559.rs +++ b/engine/src/transaction/eip_1559.rs @@ -2,6 +2,8 @@ use crate::prelude::precompiles::secp256k1::ecrecover; use crate::prelude::{Vec, U256}; use crate::transaction::eip_2930::AccessTuple; use aurora_engine_types::types::Wei; +use aurora_engine_types::types_new::Address; +use aurora_engine_types::H160; use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream}; /// Type indicator (per EIP-1559) @@ -18,7 +20,7 @@ pub struct Transaction1559 { pub max_priority_fee_per_gas: U256, pub max_fee_per_gas: U256, pub gas_limit: U256, - pub to: Option, + pub to: Option
, pub value: Wei, pub data: Vec, pub access_list: Vec, @@ -44,7 +46,7 @@ impl Transaction1559 { s.append(&self.gas_limit); match self.to.as_ref() { None => s.append(&""), - Some(address) => s.append(address), + Some(address) => s.append(&address.raw()), }; s.append(&self.value.raw()); s.append(&self.data); @@ -79,6 +81,7 @@ impl SignedTransaction1559 { message_hash, &super::vrs_to_arr(self.parity, self.r, self.s), ) + .map(|v| H160::from_slice(v.as_bytes())) .ok() } } diff --git a/engine/src/transaction/eip_2930.rs b/engine/src/transaction/eip_2930.rs index 152760978..85bc131c5 100644 --- a/engine/src/transaction/eip_2930.rs +++ b/engine/src/transaction/eip_2930.rs @@ -1,5 +1,6 @@ use crate::prelude::precompiles::secp256k1::ecrecover; use crate::prelude::{sdk, Vec, Wei, H256, U256}; +use aurora_engine_types::types_new::Address; use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream}; /// Type indicator (per EIP-2718) for access list transactions @@ -7,7 +8,7 @@ pub const TYPE_BYTE: u8 = 0x01; #[derive(Debug, Eq, PartialEq, Clone)] pub struct AccessTuple { - pub address: Address, + pub address: ethabi::Address, pub storage_keys: Vec, } @@ -55,7 +56,7 @@ impl Transaction2930 { s.append(&self.gas_limit); match self.to.as_ref() { None => s.append(&""), - Some(address) => s.append(address), + Some(address) => s.append(&address.raw()), }; s.append(&self.value.raw()); s.append(&self.data); diff --git a/engine/src/transaction/legacy.rs b/engine/src/transaction/legacy.rs index 09afc1c5f..020a22da4 100644 --- a/engine/src/transaction/legacy.rs +++ b/engine/src/transaction/legacy.rs @@ -27,7 +27,7 @@ impl TransactionLegacy { s.append(&self.gas_limit); match self.to.as_ref() { None => s.append(&""), - Some(address) => s.append(address), + Some(address) => s.append(&address.raw()), }; s.append(&self.value.raw()); s.append(&self.data); @@ -107,7 +107,7 @@ impl Encodable for LegacyEthSignedTransaction { s.append(&self.transaction.gas_limit); match self.transaction.to.as_ref() { None => s.append(&""), - Some(address) => s.append(address), + Some(address) => s.append(&address.raw()), }; s.append(&self.transaction.value.raw()); s.append(&self.transaction.data); diff --git a/engine/src/transaction/mod.rs b/engine/src/transaction/mod.rs index 40f77e053..d7bfdda93 100644 --- a/engine/src/transaction/mod.rs +++ b/engine/src/transaction/mod.rs @@ -1,4 +1,5 @@ use crate::prelude::{vec, TryFrom, Vec, U256}; +use primitive_types::H160; use rlp::{Decodable, DecoderError, Rlp}; pub mod eip_1559; @@ -104,7 +105,7 @@ impl From for NormalizedEthTransaction { access_list: tx.transaction.access_list, }, Eip1559(tx) => Self { - address: tx.sender(), + address: tx.sender().map(|v| Address::from_slice(v.as_bytes())), chain_id: Some(tx.transaction.chain_id), nonce: tx.transaction.nonce, gas_limit: tx.transaction.gas_limit, @@ -190,12 +191,12 @@ fn rlp_extract_to(rlp: &Rlp<'_>, index: usize) -> Result, Decode Err(rlp::DecoderError::RlpExpectedToBeData) } } else { - let addr: ethabi::Address = value.as_val()?; - let v = Address::from_slice(addr.as_bytes()); - if v == Address::zero() { + let v: H160 = value.as_val()?; + let addr = Address::new(v); + if addr == Address::zero() { Ok(None) } else { - Ok(Some(v)) + Ok(Some(addr)) } } } From b98046d073972bbc6e143357cb828094a2b73907 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Thu, 16 Dec 2021 16:07:00 +0200 Subject: [PATCH 09/26] Engine - Address changes --- engine-precompiles/src/native.rs | 2 +- .../src/relayer_db/types.rs | 2 +- engine-types/src/types_new/address.rs | 2 +- engine/src/connector.rs | 2 +- engine/src/engine.rs | 68 ++++++++++++------- engine/src/fungible_token.rs | 2 +- engine/src/lib.rs | 23 ++++--- engine/src/transaction/eip_2930.rs | 3 +- 8 files changed, 63 insertions(+), 41 deletions(-) diff --git a/engine-precompiles/src/native.rs b/engine-precompiles/src/native.rs index 80f14db29..b2aa68700 100644 --- a/engine-precompiles/src/native.rs +++ b/engine-precompiles/src/native.rs @@ -496,7 +496,7 @@ impl Precompile for ExitToEthereum { // There is no way to inject json, given the encoding of both arguments // as decimal and hexadecimal respectively. WithdrawCallArgs { - recipient_address: recipient_address.clone(), + recipient_address, amount: context.apparent_value.as_u128(), } .try_to_vec() diff --git a/engine-standalone-storage/src/relayer_db/types.rs b/engine-standalone-storage/src/relayer_db/types.rs index 0fdc1dc9b..b5d51500a 100644 --- a/engine-standalone-storage/src/relayer_db/types.rs +++ b/engine-standalone-storage/src/relayer_db/types.rs @@ -2,7 +2,7 @@ use aurora_engine::transaction::{ legacy::{LegacyEthSignedTransaction, TransactionLegacy}, EthTransactionKind, }; -use aurora_engine_types::{types::Wei, Address, H256, U256}; +use aurora_engine_types::{types::Wei, types_new::Address, H256, U256}; use std::convert::TryFrom; use std::io::{Cursor, Read}; use std::time::SystemTime; diff --git a/engine-types/src/types_new/address.rs b/engine-types/src/types_new/address.rs index b8d2060a0..e35695e26 100755 --- a/engine-types/src/types_new/address.rs +++ b/engine-types/src/types_new/address.rs @@ -3,7 +3,7 @@ use borsh::maybestd::io; use borsh::{BorshDeserialize, BorshSerialize}; /// Base Eth Address type -#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)] +#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)] pub struct Address(H160); #[allow(non_snake_case, dead_code)] diff --git a/engine/src/connector.rs b/engine/src/connector.rs index 644671b45..4299b4c57 100644 --- a/engine/src/connector.rs +++ b/engine/src/connector.rs @@ -372,7 +372,7 @@ impl EthConnectorContract { Ok(WithdrawResult { recipient_id: args.recipient_address, amount: args.amount, - eth_custodian_address: self.contract.eth_custodian_address, + eth_custodian_address: self.contract.eth_custodian_address.clone(), }) } diff --git a/engine/src/engine.rs b/engine/src/engine.rs index cc8aa0beb..02174da74 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -527,15 +527,15 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { args: CallArgs, handler: &mut P, ) -> EngineResult { - let origin = self.origin(); + let origin = Address::new(self.origin()); match args { CallArgs::V2(call_args) => { let contract = ADDRESS(H160(call_args.contract)); let value = call_args.value.into(); let input = call_args.input; self.call( - origin, - contract, + &origin, + &contract, value, input, u64::MAX, @@ -548,8 +548,8 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let value = Wei::zero(); let input = call_args.input; self.call( - origin, - contract, + &origin, + &contract, value, input, u64::MAX, @@ -563,12 +563,12 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { #[allow(clippy::too_many_arguments)] pub fn call( &mut self, - origin: Address, - contract: Address, + origin: &Address, + contract: &Address, value: Wei, input: Vec, gas_limit: u64, - access_list: Vec<(Address, Vec)>, // See EIP-2930 + access_list: Vec<(H160, Vec)>, // See EIP-2930 handler: &mut P, ) -> EngineResult { let executor_params = StackExecutorParams::new( @@ -577,8 +577,14 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { self.env.random_seed(), ); let mut executor = executor_params.make_executor(self); - let (exit_reason, result) = - executor.transact_call(origin, contract, value.raw(), input, gas_limit, access_list); + let (exit_reason, result) = executor.transact_call( + origin.raw(), + contract.raw(), + value.raw(), + input, + gas_limit, + access_list, + ); let used_gas = executor.used_gas(); let status = match exit_reason.into_result(result) { @@ -620,8 +626,14 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { self.env.random_seed(), ); let mut executor = executor_params.make_executor(self); - let (status, result) = - executor.transact_call(origin, contract, value.raw(), input, gas_limit, Vec::new()); + let (status, result) = executor.transact_call( + origin.raw(), + contract.raw(), + value.raw(), + input, + gas_limit, + Vec::new(), + ); status.into_result(result) } @@ -674,8 +686,8 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { handler: &mut P, ) -> EngineResult { self.call( - sender, - receiver, + &sender, + &receiver, value, Vec::new(), gas_limit, @@ -753,7 +765,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { unwrap_res_or_finish!( self.transfer( - recipient, + recipient.clone(), relayer_address, Wei::new_u64(fee.as_u64()), u64::MAX, @@ -766,15 +778,15 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let selector = ERC20_MINT_SELECTOR; let tail = ethabi::encode(&[ - ethabi::Token::Address(recipient), + ethabi::Token::Address(recipient.raw()), ethabi::Token::Uint(args.amount.into()), ]); let erc20_admin_address = current_address(current_account_id); unwrap_res_or_finish!( self.call( - erc20_admin_address, - erc20_token, + &erc20_admin_address, + &erc20_token, Wei::zero(), [selector, tail.as_slice()].concat(), u64::MAX, @@ -892,8 +904,8 @@ pub fn submit( .collect(); let result = if let Some(receiver) = transaction.to { engine.call( - sender, - receiver, + &sender, + &receiver, transaction.value, transaction.data, gas_limit, @@ -1032,7 +1044,7 @@ pub fn deploy_erc20_token( ethabi::Token::String("Empty".to_string()), ethabi::Token::String("EMPTY".to_string()), ethabi::Token::Uint(ethabi::Uint::from(0)), - ethabi::Token::Address(erc20_admin_address), + ethabi::Token::Address(erc20_admin_address.raw()), ]); let address = match Engine::deploy_code_with_input( @@ -1246,7 +1258,9 @@ where { logs.into_iter() .filter_map(|log| { - if log.address == ExitToNear::ADDRESS || log.address == ExitToEthereum::ADDRESS { + if log.address == ExitToNear::ADDRESS.raw() + || log.address == ExitToEthereum::ADDRESS.raw() + { if log.topics.is_empty() { if let Ok(promise) = PromiseArgs::try_from_slice(&log.data) { match promise { @@ -1302,7 +1316,7 @@ impl<'env, I: IO + Copy, E: Env> evm::backend::Backend for Engine<'env, I, E> { /// Returns the origin address that created the contract. fn origin(&self) -> H160 { - self.origin + self.origin.raw() } /// Returns a block hash from a given index. @@ -1392,11 +1406,12 @@ impl<'env, I: IO + Copy, E: Env> evm::backend::Backend for Engine<'env, I, E> { /// Checks if an address exists. fn exists(&self, address: H160) -> bool { - !is_account_empty(&self.io, &address) + !is_account_empty(&self.io, &Address::new(address)) } /// Returns basic account information. fn basic(&self, address: H160) -> Basic { + let address = Address::new(address); Basic { nonce: get_nonce(&self.io, &address), balance: get_balance(&self.io, &address).raw(), @@ -1410,8 +1425,9 @@ impl<'env, I: IO + Copy, E: Env> evm::backend::Backend for Engine<'env, I, E> { /// Get storage value of address at index. fn storage(&self, address: H160, index: H256) -> H256 { + let address = Address::new(address); let generation = get_generation(&self.io, &address); - get_storage(&self.io, &Address::new(address), &index, generation) + get_storage(&self.io, &address, &index, generation) } /// Get original storage value of address at index, if available. @@ -1442,6 +1458,7 @@ impl<'env, J: IO + Copy, E: Env> ApplyBackend for Engine<'env, J, E> { storage, reset_storage, } => { + let address = Address::new(address); let generation = get_generation(&self.io, &address); set_nonce(&mut self.io, &address, &basic.nonce); set_balance(&mut self.io, &address, &Wei::new(basic.balance)); @@ -1488,6 +1505,7 @@ impl<'env, J: IO + Copy, E: Env> ApplyBackend for Engine<'env, J, E> { } } Apply::Delete { address } => { + let address = Address::new(address); let generation = get_generation(&self.io, &address); remove_account(&mut self.io, &address, generation); writes_counter += 1; diff --git a/engine/src/fungible_token.rs b/engine/src/fungible_token.rs index 68afdc799..c11bcc9f2 100644 --- a/engine/src/fungible_token.rs +++ b/engine/src/fungible_token.rs @@ -177,7 +177,7 @@ impl FungibleTokenOps { amount: Balance, ) -> Result<(), error::DepositError> { let balance = self - .internal_unwrap_balance_of_eth_on_aurora(address) + .internal_unwrap_balance_of_eth_on_aurora(&address) .map_err(|_| error::DepositError::BalanceOverflow)?; let new_balance = balance .checked_add(amount) diff --git a/engine/src/lib.rs b/engine/src/lib.rs index 99efaf88d..c265c0dd1 100644 --- a/engine/src/lib.rs +++ b/engine/src/lib.rs @@ -77,11 +77,11 @@ mod contract { }; #[cfg(feature = "evm_bully")] use crate::parameters::{BeginBlockArgs, BeginChainArgs}; + use crate::prelude::account_id::AccountId; use aurora_engine_sdk::env::Env; use aurora_engine_sdk::io::{StorageIntermediate, IO}; use aurora_engine_sdk::near_runtime::Runtime; use aurora_engine_sdk::promise::PromiseHandler; - use aurora_engine_types::account_id::AccountId; use crate::json::parse_json; use crate::prelude::parameters::RefundCallArgs; @@ -91,8 +91,8 @@ mod contract { use crate::prelude::storage::{bytes_to_key, KeyPrefix}; use crate::prelude::types::{u256_to_arr, ERR_FAILED_PARSE}; use crate::prelude::{ - sdk, vec, PromiseResult, ToString, TryFrom, TryInto, Vec, Wei, ERC20_MINT_SELECTOR, H256, - U256, + sdk, types_new::Address, vec, PromiseResult, ToString, TryFrom, TryInto, Vec, Wei, + ERC20_MINT_SELECTOR, H256, U256, }; #[cfg(feature = "integration-test")] @@ -282,8 +282,8 @@ mod contract { let mut engine = Engine::new_with_state(state, meta_call_args.sender, current_account_id, io, &io); let result = engine.call( - meta_call_args.sender, - meta_call_args.contract_address, + &meta_call_args.sender, + &meta_call_args.contract_address, meta_call_args.value, meta_call_args.input, u64::MAX, // TODO: is there a gas limit with meta calls? @@ -403,7 +403,7 @@ mod contract { engine .call( - erc20_admin_address, + &erc20_admin_address, erc20_address, Wei::zero(), [selector, mint_args.as_slice()].concat(), @@ -418,16 +418,19 @@ mod contract { let exit_address = aurora_engine_precompiles::native::ExitToNear::ADDRESS; let mut engine = Engine::new(exit_address, current_account_id, io, &io).sdk_unwrap(); - let refund_address = Address(args.recipient_address); + let refund_address = args.recipient_address; let amount = Wei::new(U256::from_big_endian(&args.amount)); engine .call( - exit_address, - refund_address, + &exit_address, + &refund_address, amount, Vec::new(), u64::MAX, - vec![(exit_address, Vec::new()), (refund_address, Vec::new())], + vec![ + (exit_address.raw(), Vec::new()), + (refund_address.raw(), Vec::new()), + ], &mut Runtime, ) .sdk_unwrap() diff --git a/engine/src/transaction/eip_2930.rs b/engine/src/transaction/eip_2930.rs index 85bc131c5..6c009eb57 100644 --- a/engine/src/transaction/eip_2930.rs +++ b/engine/src/transaction/eip_2930.rs @@ -1,6 +1,7 @@ use crate::prelude::precompiles::secp256k1::ecrecover; use crate::prelude::{sdk, Vec, Wei, H256, U256}; use aurora_engine_types::types_new::Address; +use aurora_engine_types::H160; use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream}; /// Type indicator (per EIP-2718) for access list transactions @@ -8,7 +9,7 @@ pub const TYPE_BYTE: u8 = 0x01; #[derive(Debug, Eq, PartialEq, Clone)] pub struct AccessTuple { - pub address: ethabi::Address, + pub address: H160, pub storage_keys: Vec, } From 88bba7d930512548b4863d44c5fc640011a267be Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Thu, 16 Dec 2021 17:30:29 +0200 Subject: [PATCH 10/26] Fix Connector, Engine types for Address --- engine/src/connector.rs | 2 +- engine/src/engine.rs | 4 ++-- engine/src/fungible_token.rs | 4 ++-- engine/src/lib.rs | 23 +++++++++++++---------- engine/src/parameters.rs | 2 +- 5 files changed, 19 insertions(+), 16 deletions(-) diff --git a/engine/src/connector.rs b/engine/src/connector.rs index 4299b4c57..644671b45 100644 --- a/engine/src/connector.rs +++ b/engine/src/connector.rs @@ -372,7 +372,7 @@ impl EthConnectorContract { Ok(WithdrawResult { recipient_id: args.recipient_address, amount: args.amount, - eth_custodian_address: self.contract.eth_custodian_address.clone(), + eth_custodian_address: self.contract.eth_custodian_address, }) } diff --git a/engine/src/engine.rs b/engine/src/engine.rs index 02174da74..99aa69204 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -590,7 +590,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let status = match exit_reason.into_result(result) { Ok(status) => status, Err(e) => { - increment_nonce(&mut self.io, &origin); + increment_nonce(&mut self.io, origin); return Err(e.with_gas_used(used_gas)); } }; @@ -765,7 +765,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { unwrap_res_or_finish!( self.transfer( - recipient.clone(), + recipient, relayer_address, Wei::new_u64(fee.as_u64()), u64::MAX, diff --git a/engine/src/fungible_token.rs b/engine/src/fungible_token.rs index c11bcc9f2..1c5bc7768 100644 --- a/engine/src/fungible_token.rs +++ b/engine/src/fungible_token.rs @@ -149,7 +149,7 @@ impl FungibleTokenOps { &self, address: &Address, ) -> Result { - engine::get_balance(&self.io, &address).try_into_u128() + engine::get_balance(&self.io, address).try_into_u128() } /// Internal ETH deposit to NEAR - nETH (NEP-141) @@ -220,7 +220,7 @@ impl FungibleTokenOps { let new_balance = balance .checked_sub(amount) .ok_or(error::WithdrawError::InsufficientFunds)?; - engine::set_balance(&mut self.io, &address, &Wei::new(U256::from(new_balance))); + engine::set_balance(&mut self.io, address, &Wei::new(U256::from(new_balance))); self.total_eth_supply_on_aurora = self .total_eth_supply_on_aurora .checked_sub(amount) diff --git a/engine/src/lib.rs b/engine/src/lib.rs index c265c0dd1..21c200a9b 100644 --- a/engine/src/lib.rs +++ b/engine/src/lib.rs @@ -309,7 +309,10 @@ mod contract { &io, ) .sdk_unwrap(); - engine.register_relayer(predecessor_account_id.as_bytes(), Address(relayer_address)); + engine.register_relayer( + predecessor_account_id.as_bytes(), + Address::from_slice(&relayer_address), + ); } /// Allow receiving NEP141 tokens to the EVM contract. @@ -391,20 +394,20 @@ mod contract { let erc20_admin_address = current_address(¤t_account_id); let mut engine = Engine::new(erc20_admin_address, current_account_id, io, &io).sdk_unwrap(); - let erc20_address = Address(erc20_address); - let refund_address = Address(args.recipient_address); + let erc20_address = erc20_address; + let refund_address = args.recipient_address; let amount = U256::from_big_endian(&args.amount); let selector = ERC20_MINT_SELECTOR; let mint_args = ethabi::encode(&[ - ethabi::Token::Address(refund_address), + ethabi::Token::Address(refund_address.raw()), ethabi::Token::Uint(amount), ]); engine .call( &erc20_admin_address, - erc20_address, + &erc20_address, Wei::zero(), [selector, mint_args.as_slice()].concat(), u64::MAX, @@ -479,7 +482,7 @@ mod contract { pub extern "C" fn get_code() { let mut io = Runtime; let address = io.read_input_arr20().sdk_unwrap(); - let code = engine::get_code(&io, &Address(address)); + let code = engine::get_code(&io, &Address::from_slice(&address)); io.return_output(&code) } @@ -487,7 +490,7 @@ mod contract { pub extern "C" fn get_balance() { let mut io = Runtime; let address = io.read_input_arr20().sdk_unwrap(); - let balance = engine::get_balance(&io, &Address(address)); + let balance = engine::get_balance(&io, &Address::from_slice(&address)); io.return_output(&balance.to_bytes()) } @@ -495,7 +498,7 @@ mod contract { pub extern "C" fn get_nonce() { let mut io = Runtime; let address = io.read_input_arr20().sdk_unwrap(); - let nonce = engine::get_nonce(&io, &Address(address)); + let nonce = engine::get_nonce(&io, &Address::from_slice(&address)); io.return_output(&u256_to_arr(&nonce)) } @@ -503,9 +506,9 @@ mod contract { pub extern "C" fn get_storage_at() { let mut io = Runtime; let args: GetStorageAtArgs = io.read_input_borsh().sdk_unwrap(); - let address = Address(args.address); + let address = args.address; let generation = engine::get_generation(&io, &address); - let value = engine::get_storage(&io, &Address(args.address), &H256(args.key), generation); + let value = engine::get_storage(&io, &args.address, &H256(args.key), generation); io.return_output(&value.0) } diff --git a/engine/src/parameters.rs b/engine/src/parameters.rs index 7f5c65cfc..db45ec920 100644 --- a/engine/src/parameters.rs +++ b/engine/src/parameters.rs @@ -194,7 +194,7 @@ pub type GetErc20FromNep141CallArgs = DeployErc20TokenArgs; /// Borsh-encoded parameters for the `get_storage_at` function. #[derive(BorshSerialize, BorshDeserialize)] pub struct GetStorageAtArgs { - pub address: RawAddress, + pub address: Address, pub key: RawH256, } From 3186c302d570166372eae212c325d13e4a89b63e Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Thu, 16 Dec 2021 19:15:49 +0200 Subject: [PATCH 11/26] Changed tests --- engine-precompiles/src/lib.rs | 14 ++++---- engine-tests/src/benches/nft_pagination.rs | 2 +- engine-tests/src/test_utils/erc20.rs | 2 +- .../src/test_utils/exit_precompile.rs | 2 +- engine-tests/src/test_utils/mod.rs | 2 +- .../test_utils/one_inch/liquidity_protocol.rs | 2 +- engine-tests/src/test_utils/self_destruct.rs | 2 +- engine-tests/src/test_utils/solidity.rs | 2 +- .../src/test_utils/standalone/mocks/mod.rs | 2 +- engine-tests/src/test_utils/standalone/mod.rs | 2 +- engine-tests/src/test_utils/uniswap.rs | 2 +- engine-tests/src/test_utils/weth.rs | 2 +- engine-tests/src/tests/contract_call.rs | 5 ++- engine-tests/src/tests/erc20.rs | 2 +- engine-tests/src/tests/erc20_connector.rs | 22 ++++++------- engine-tests/src/tests/meta_parsing.rs | 4 ++- engine-tests/src/tests/sanity.rs | 2 +- .../src/tests/standalone/json_snapshot.rs | 2 +- engine-tests/src/tests/standalone/sanity.rs | 2 +- engine-tests/src/tests/standalone/storage.rs | 2 +- engine-tests/src/tests/standalone/sync.rs | 2 +- engine-tests/src/tests/standalone/tracing.rs | 2 +- engine-tests/src/tests/uniswap.rs | 2 +- engine-types/src/types.rs | 1 - engine/src/engine.rs | 12 +++---- engine/src/meta_parsing.rs | 14 ++++---- engine/src/parameters.rs | 32 +++++++++---------- engine/src/transaction/legacy.rs | 4 +-- 28 files changed, 74 insertions(+), 72 deletions(-) diff --git a/engine-precompiles/src/lib.rs b/engine-precompiles/src/lib.rs index b967bbd35..566923d8e 100644 --- a/engine-precompiles/src/lib.rs +++ b/engine-precompiles/src/lib.rs @@ -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_new::{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)) } diff --git a/engine-tests/src/benches/nft_pagination.rs b/engine-tests/src/benches/nft_pagination.rs index 8d8e38d65..45b8c4b14 100644 --- a/engine-tests/src/benches/nft_pagination.rs +++ b/engine-tests/src/benches/nft_pagination.rs @@ -1,5 +1,5 @@ use crate::prelude::types::Wei; -use crate::prelude::{Address, U256}; +use crate::prelude::{types_new::Address, U256}; use crate::test_utils::{self, solidity}; use aurora_engine::transaction::legacy::TransactionLegacy; use secp256k1::SecretKey; diff --git a/engine-tests/src/test_utils/erc20.rs b/engine-tests/src/test_utils/erc20.rs index 57cc38f69..6b414fc07 100644 --- a/engine-tests/src/test_utils/erc20.rs +++ b/engine-tests/src/test_utils/erc20.rs @@ -1,4 +1,4 @@ -use crate::prelude::{transaction::legacy::TransactionLegacy, Address, U256}; +use crate::prelude::{transaction::legacy::TransactionLegacy, types_new::Address, U256}; use crate::test_utils::solidity; use std::path::{Path, PathBuf}; use std::sync::Once; diff --git a/engine-tests/src/test_utils/exit_precompile.rs b/engine-tests/src/test_utils/exit_precompile.rs index 76484930e..20708edf4 100644 --- a/engine-tests/src/test_utils/exit_precompile.rs +++ b/engine-tests/src/test_utils/exit_precompile.rs @@ -1,5 +1,5 @@ use crate::prelude::{ - parameters::SubmitResult, transaction::legacy::TransactionLegacy, Address, Wei, U256, + parameters::SubmitResult, transaction::legacy::TransactionLegacy, types_new::Address, Wei, U256, }; use crate::test_utils::{self, solidity, AuroraRunner, Signer}; diff --git a/engine-tests/src/test_utils/mod.rs b/engine-tests/src/test_utils/mod.rs index 50c141073..81d0795c1 100644 --- a/engine-tests/src/test_utils/mod.rs +++ b/engine-tests/src/test_utils/mod.rs @@ -20,7 +20,7 @@ use crate::prelude::transaction::{ eip_2930::{self, SignedTransaction2930, Transaction2930}, legacy::{LegacyEthSignedTransaction, TransactionLegacy}, }; -use crate::prelude::{sdk, Address, Wei, H256, U256}; +use crate::prelude::{sdk, types_new::Address, Wei, H256, U256}; use crate::test_utils::solidity::{ContractConstructor, DeployedContract}; // TODO(Copied from #84): Make sure that there is only one Signer after both PR are merged. diff --git a/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs b/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs index 4de97a372..23218f533 100644 --- a/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs +++ b/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs @@ -1,5 +1,5 @@ use crate::prelude::parameters::SubmitResult; -use crate::prelude::{Address, U256}; +use crate::prelude::{types_new::Address, U256}; use crate::test_utils::{self, solidity, ExecutionProfile}; use std::path::PathBuf; use std::sync::Once; diff --git a/engine-tests/src/test_utils/self_destruct.rs b/engine-tests/src/test_utils/self_destruct.rs index a4acb6947..a86a473ec 100644 --- a/engine-tests/src/test_utils/self_destruct.rs +++ b/engine-tests/src/test_utils/self_destruct.rs @@ -1,6 +1,6 @@ use crate::prelude::{ parameters::CallArgs, parameters::FunctionCallArgsV2, transaction::legacy::TransactionLegacy, - Address, WeiU256, U256, + types_new::Address, WeiU256, U256, }; use crate::test_utils::{self, solidity, AuroraRunner, Signer}; use borsh::BorshSerialize; diff --git a/engine-tests/src/test_utils/solidity.rs b/engine-tests/src/test_utils/solidity.rs index 4ced046cc..2918b8152 100644 --- a/engine-tests/src/test_utils/solidity.rs +++ b/engine-tests/src/test_utils/solidity.rs @@ -1,4 +1,4 @@ -use crate::prelude::{transaction::legacy::TransactionLegacy, Address, U256}; +use crate::prelude::{transaction::legacy::TransactionLegacy, types_new::Address, U256}; use near_sdk::serde_json; use serde::Deserialize; use std::fs; diff --git a/engine-tests/src/test_utils/standalone/mocks/mod.rs b/engine-tests/src/test_utils/standalone/mocks/mod.rs index 07a5d5355..194230849 100644 --- a/engine-tests/src/test_utils/standalone/mocks/mod.rs +++ b/engine-tests/src/test_utils/standalone/mocks/mod.rs @@ -4,7 +4,7 @@ use aurora_engine::parameters::{FinishDepositCallArgs, InitCallArgs, NewCallArgs use aurora_engine_sdk::env::{Env, DEFAULT_PREPAID_GAS}; use aurora_engine_sdk::io::IO; use aurora_engine_types::types::NearGas; -use aurora_engine_types::{account_id::AccountId, types::Wei, Address, H256, U256}; +use aurora_engine_types::{account_id::AccountId, types::Wei, types_new::Address, H256, U256}; use engine_standalone_storage::{BlockMetadata, Storage}; use near_sdk_sim::DEFAULT_GAS; diff --git a/engine-tests/src/test_utils/standalone/mod.rs b/engine-tests/src/test_utils/standalone/mod.rs index f2f3b59ac..5af8e29b2 100644 --- a/engine-tests/src/test_utils/standalone/mod.rs +++ b/engine-tests/src/test_utils/standalone/mod.rs @@ -3,7 +3,7 @@ use aurora_engine::parameters::{CallArgs, DeployErc20TokenArgs, SubmitResult, Tr use aurora_engine::transaction::legacy::{LegacyEthSignedTransaction, TransactionLegacy}; use aurora_engine_sdk::env::{self, Env}; use aurora_engine_types::types::NearGas; -use aurora_engine_types::{types::Wei, Address, H256, U256}; +use aurora_engine_types::{types::Wei, types_new::Address, H256, U256}; use borsh::BorshDeserialize; use engine_standalone_storage::engine_state; use engine_standalone_storage::{BlockMetadata, Diff, Storage}; diff --git a/engine-tests/src/test_utils/uniswap.rs b/engine-tests/src/test_utils/uniswap.rs index 4d951ade8..6615a5fed 100644 --- a/engine-tests/src/test_utils/uniswap.rs +++ b/engine-tests/src/test_utils/uniswap.rs @@ -1,4 +1,4 @@ -use crate::prelude::{Address, U256}; +use crate::prelude::{types_new::Address, U256}; use crate::test_utils::solidity; use aurora_engine::transaction::legacy::TransactionLegacy; use std::ops::Not; diff --git a/engine-tests/src/test_utils/weth.rs b/engine-tests/src/test_utils/weth.rs index da5390cf6..e5c5c3ffa 100644 --- a/engine-tests/src/test_utils/weth.rs +++ b/engine-tests/src/test_utils/weth.rs @@ -1,5 +1,5 @@ use aurora_engine::transaction::legacy::TransactionLegacy; -use aurora_engine_types::{types::Wei, Address, U256}; +use aurora_engine_types::{types::Wei, types_new::Address, U256}; use crate::test_utils::solidity; diff --git a/engine-tests/src/tests/contract_call.rs b/engine-tests/src/tests/contract_call.rs index f52572461..04a8231ba 100644 --- a/engine-tests/src/tests/contract_call.rs +++ b/engine-tests/src/tests/contract_call.rs @@ -1,10 +1,10 @@ -use crate::prelude::{parameters::SubmitResult, vec, Address, Wei, H256, U256}; +use crate::prelude::{parameters::SubmitResult, types_new::Address, vec, Wei, H256, U256}; use crate::test_utils::{origin, AuroraRunner, Signer}; use crate::test_utils; use crate::test_utils::exit_precompile::{Tester, TesterConstructor, DEST_ACCOUNT, DEST_ADDRESS}; -fn setup_test() -> (AuroraRunner, Signer, [u8; 20], Tester) { +fn setup_test() -> (AuroraRunner, Signer, Address, Tester) { let mut runner = AuroraRunner::new(); let token = runner.deploy_erc20_token(&"tt.testnet".to_string()); let mut signer = test_utils::Signer::random(); @@ -49,7 +49,6 @@ fn hello_world_solidity() { #[test] fn withdraw() { let (mut runner, mut signer, token, tester) = setup_test(); - let token = Address(token); let test_data = vec![ (true, "call_contract tt.testnet.ft_transfer"), diff --git a/engine-tests/src/tests/erc20.rs b/engine-tests/src/tests/erc20.rs index 24ce19697..2ae385c79 100644 --- a/engine-tests/src/tests/erc20.rs +++ b/engine-tests/src/tests/erc20.rs @@ -1,5 +1,5 @@ use crate::prelude::Wei; -use crate::prelude::{Address, U256}; +use crate::prelude::{types_new::Address, U256}; use crate::test_utils::{ self, erc20::{ERC20Constructor, ERC20}, diff --git a/engine-tests/src/tests/erc20_connector.rs b/engine-tests/src/tests/erc20_connector.rs index df18be73e..bc21d3bae 100644 --- a/engine-tests/src/tests/erc20_connector.rs +++ b/engine-tests/src/tests/erc20_connector.rs @@ -1,4 +1,4 @@ -use crate::prelude::{Address, Balance, RawAddress, TryInto, Wei, WeiU256, U256}; +use crate::prelude::{types_new::Address, Balance, TryInto, Wei, WeiU256, U256}; use crate::test_utils; use crate::test_utils::{create_eth_transaction, origin, AuroraRunner}; use aurora_engine::parameters::{CallArgs, FunctionCallArgsV2, SubmitResult}; @@ -61,7 +61,7 @@ fn create_ethereum_address() -> Address { pub struct EthereumAddress { pub secret_key: SecretKey, - pub address: RawAddress, + pub address: Address, } impl test_utils::AuroraRunner { @@ -91,7 +91,7 @@ impl test_utils::AuroraRunner { CallResult { outcome, error } } - pub fn evm_call(&mut self, contract: RawAddress, input: Vec, origin: String) -> CallResult { + pub fn evm_call(&mut self, contract: Address, input: Vec, origin: String) -> CallResult { self.make_call( "call", origin, @@ -109,7 +109,7 @@ impl test_utils::AuroraRunner { self.make_call("submit", origin, rlp::encode(&input).to_vec()) } - pub fn deploy_erc20_token(&mut self, nep141: &String) -> RawAddress { + pub fn deploy_erc20_token(&mut self, nep141: &String) -> Address { let result = self.make_call("deploy_erc20_token", origin(), nep141.try_to_vec().unwrap()); result.check_ok(); @@ -131,7 +131,7 @@ impl test_utils::AuroraRunner { } } - pub fn balance_of(&mut self, token: RawAddress, target: RawAddress, origin: String) -> U256 { + pub fn balance_of(&mut self, token: Address, target: Address, origin: String) -> U256 { let input = build_input("balanceOf(address)", &[Token::Address(target.into())]); let result = self.evm_call(token, input, origin); result.check_ok(); @@ -141,8 +141,8 @@ impl test_utils::AuroraRunner { pub fn mint( &mut self, - token: RawAddress, - target: RawAddress, + token: Address, + target: Address, amount: u64, origin: String, ) -> CallResult { @@ -159,7 +159,7 @@ impl test_utils::AuroraRunner { } #[allow(dead_code)] - pub fn admin(&mut self, token: RawAddress, origin: String) -> CallResult { + pub fn admin(&mut self, token: Address, origin: String) -> CallResult { let input = build_input("admin()", &[]); let result = self.evm_call(token, input, origin); result.check_ok(); @@ -168,9 +168,9 @@ impl test_utils::AuroraRunner { pub fn transfer_erc20( &mut self, - token: RawAddress, + token: Address, sender: SecretKey, - receiver: RawAddress, + receiver: Address, amount: u64, origin: String, ) -> CallResult { @@ -390,7 +390,7 @@ fn test_transfer_erc20_token() { // Note: `AuroraRunner` is not suitable for these tests because // it does not execute promises; but `near-sdk-sim` does. mod sim_tests { - use crate::prelude::{types::Wei, Address, WeiU256, U256}; + use crate::prelude::{types::Wei, WeiU256, U256}; use crate::test_utils; use crate::test_utils::erc20::{ERC20Constructor, ERC20}; use crate::test_utils::exit_precompile::TesterConstructor; diff --git a/engine-tests/src/tests/meta_parsing.rs b/engine-tests/src/tests/meta_parsing.rs index 5648cc771..3bd58444d 100644 --- a/engine-tests/src/tests/meta_parsing.rs +++ b/engine-tests/src/tests/meta_parsing.rs @@ -2,7 +2,9 @@ use { crate::prelude::meta_parsing::{near_erc712_domain, parse_meta_call, prepare_meta_call_args}, crate::prelude::parameters::MetaCallArgs, crate::prelude::sdk::keccak, - crate::prelude::{u256_to_arr, Address, BorshSerialize, InternalMetaCallArgs, Wei, U256}, + crate::prelude::{ + types_new::Address, u256_to_arr, BorshSerialize, InternalMetaCallArgs, Wei, U256, + }, near_crypto::{InMemorySigner, KeyType, PublicKey, Signature, Signer}, }; diff --git a/engine-tests/src/tests/sanity.rs b/engine-tests/src/tests/sanity.rs index cd9435ca4..f789bc169 100644 --- a/engine-tests/src/tests/sanity.rs +++ b/engine-tests/src/tests/sanity.rs @@ -1,4 +1,4 @@ -use crate::prelude::{Address, U256}; +use crate::prelude::{types_new::Address, U256}; use crate::prelude::{Wei, ERC20_MINT_SELECTOR}; use crate::test_utils; use crate::tests::state_migration; diff --git a/engine-tests/src/tests/standalone/json_snapshot.rs b/engine-tests/src/tests/standalone/json_snapshot.rs index 45e191089..333ec3c93 100644 --- a/engine-tests/src/tests/standalone/json_snapshot.rs +++ b/engine-tests/src/tests/standalone/json_snapshot.rs @@ -1,5 +1,5 @@ use crate::test_utils::standalone; -use aurora_engine_types::{Address, U256}; +use aurora_engine_types::{types_new::Address, U256}; use engine_standalone_storage::json_snapshot; const NONCE_PREFIX: [u8; 2] = [0x07, 0x01]; diff --git a/engine-tests/src/tests/standalone/sanity.rs b/engine-tests/src/tests/standalone/sanity.rs index b043e6607..05ca9d646 100644 --- a/engine-tests/src/tests/standalone/sanity.rs +++ b/engine-tests/src/tests/standalone/sanity.rs @@ -2,7 +2,7 @@ use crate::test_utils::standalone::mocks::{promise, storage}; use aurora_engine::engine; use aurora_engine_sdk::env::DEFAULT_PREPAID_GAS; use aurora_engine_types::types::Wei; -use aurora_engine_types::{account_id::AccountId, Address, H256, U256}; +use aurora_engine_types::{account_id::AccountId, types_new::Address, H256, U256}; use std::sync::RwLock; #[test] diff --git a/engine-tests/src/tests/standalone/storage.rs b/engine-tests/src/tests/standalone/storage.rs index 5fd0606d4..6d69af6a7 100644 --- a/engine-tests/src/tests/standalone/storage.rs +++ b/engine-tests/src/tests/standalone/storage.rs @@ -1,6 +1,6 @@ use aurora_engine::engine; use aurora_engine_sdk::env::Timestamp; -use aurora_engine_types::{types::Wei, Address, H256, U256}; +use aurora_engine_types::{types::Wei, types_new::Address, H256, U256}; use engine_standalone_storage::BlockMetadata; use crate::test_utils::standalone::{mocks, storage::create_db}; diff --git a/engine-tests/src/tests/standalone/sync.rs b/engine-tests/src/tests/standalone/sync.rs index 00c6de10f..ea3aa9810 100644 --- a/engine-tests/src/tests/standalone/sync.rs +++ b/engine-tests/src/tests/standalone/sync.rs @@ -1,7 +1,7 @@ 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 aurora_engine_types::{account_id::AccountId, types::Wei, types_new::Address, H256, U256}; use borsh::BorshSerialize; use engine_standalone_storage::sync; diff --git a/engine-tests/src/tests/standalone/tracing.rs b/engine-tests/src/tests/standalone/tracing.rs index f6da0e8ee..92354e614 100644 --- a/engine-tests/src/tests/standalone/tracing.rs +++ b/engine-tests/src/tests/standalone/tracing.rs @@ -1,5 +1,5 @@ use aurora_engine_sdk::env::Env; -use aurora_engine_types::{types::Wei, Address, H256, U256}; +use aurora_engine_types::{types::Wei, types_new::Address, H256, U256}; use engine_standalone_tracing::{sputnik, types::TransactionTrace}; use serde::Deserialize; use std::path::Path; diff --git a/engine-tests/src/tests/uniswap.rs b/engine-tests/src/tests/uniswap.rs index ba4a2d94e..d3af55437 100644 --- a/engine-tests/src/tests/uniswap.rs +++ b/engine-tests/src/tests/uniswap.rs @@ -1,4 +1,4 @@ -use crate::prelude::{Address, U256}; +use crate::prelude::{types_new::Address, U256}; use crate::test_utils::{ self, erc20::{ERC20Constructor, ERC20}, diff --git a/engine-types/src/types.rs b/engine-types/src/types.rs index 3a6013bbf..f9f6d4543 100644 --- a/engine-types/src/types.rs +++ b/engine-types/src/types.rs @@ -5,7 +5,6 @@ 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 RawH256 = [u8; 32]; // Unformatted binary data of fixed length. diff --git a/engine/src/engine.rs b/engine/src/engine.rs index 99aa69204..d0e4bee95 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -530,7 +530,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let origin = Address::new(self.origin()); match args { CallArgs::V2(call_args) => { - let contract = ADDRESS(H160(call_args.contract)); + let contract = ADDRESS(call_args.contract.raw()); let value = call_args.value.into(); let input = call_args.input; self.call( @@ -544,7 +544,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { ) } CallArgs::V1(call_args) => { - let contract = ADDRESS(H160(call_args.contract)); + let contract = ADDRESS(call_args.contract.raw()); let value = Wei::zero(); let input = call_args.input; self.call( @@ -606,16 +606,16 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { } pub fn view_with_args(&self, args: ViewCallArgs) -> Result { - let origin = Address::from_slice(&args.sender); - let contract = Address::from_slice(&args.address); + let origin = &args.sender; + let contract = &args.address; let value = U256::from_big_endian(&args.amount); self.view(origin, contract, Wei::new(value), args.input, u64::MAX) } pub fn view( &self, - origin: Address, - contract: Address, + origin: &Address, + contract: &Address, value: Wei, input: Vec, gas_limit: u64, diff --git a/engine/src/meta_parsing.rs b/engine/src/meta_parsing.rs index 269ae454c..4ee537c19 100644 --- a/engine/src/meta_parsing.rs +++ b/engine/src/meta_parsing.rs @@ -1,9 +1,11 @@ use crate::parameters::MetaCallArgs; use crate::prelude::precompiles::secp256k1::ecrecover; use crate::prelude::{ - keccak, u256_to_arr, vec, Address, BorshDeserialize, Box, HashMap, InternalMetaCallArgs, - RawU256, String, ToOwned, ToString, Vec, Wei, H256, U256, + keccak, u256_to_arr, vec, BorshDeserialize, Box, HashMap, InternalMetaCallArgs, RawU256, + String, ToOwned, ToString, Vec, Wei, H256, U256, }; +use aurora_engine_types::types_new::Address; +use aurora_engine_types::H160; use ethabi::{encode, Token as ABIToken}; use logos::Logos; use rlp::{Decodable, DecoderError, Rlp}; @@ -160,7 +162,7 @@ pub fn method_sig_to_abi(method_sig: &str) -> [u8; 4] { pub fn encode_address(addr: Address) -> Vec { let mut bytes = vec![0u8; 12]; - bytes.extend_from_slice(&addr.0); + bytes.extend_from_slice(&addr.raw().as_bytes()); bytes } @@ -447,7 +449,7 @@ fn arg_to_abi_token( value_to_abi_token(arg, |b| Ok(ABIToken::Uint(U256::from_big_endian(b)))) } ArgType::Address => { - value_to_abi_token(arg, |b| Ok(ABIToken::Address(Address::from_slice(b)))) + value_to_abi_token(arg, |b| Ok(ABIToken::Address(H160::from_slice(&b[..])))) } ArgType::Array { inner, @@ -578,8 +580,8 @@ pub fn parse_meta_call( MetaCallArgs::try_from_slice(&args).map_err(|_| ParsingError::ArgumentParseError)?; let nonce = U256::from(meta_tx.nonce); let fee_amount = Wei::new(U256::from(meta_tx.fee_amount)); - let fee_address = Address::from(meta_tx.fee_address); - let contract_address = Address::from(meta_tx.contract_address); + let fee_address = meta_tx.fee_address; + let contract_address = meta_tx.contract_address; let value = Wei::new(U256::from(meta_tx.value)); let mut result = InternalMetaCallArgs { diff --git a/engine/src/parameters.rs b/engine/src/parameters.rs index db45ec920..f081306c1 100644 --- a/engine/src/parameters.rs +++ b/engine/src/parameters.rs @@ -3,8 +3,8 @@ use crate::fungible_token::FungibleTokenMetadata; use crate::json::{JsonError, JsonValue}; use crate::prelude::account_id::AccountId; use crate::prelude::{ - format, types_new::Address, Balance, BorshDeserialize, BorshSerialize, RawAddress, RawH256, - RawU256, String, ToString, TryFrom, Vec, WeiU256, + format, types_new::Address, Balance, BorshDeserialize, BorshSerialize, RawH256, RawU256, + String, ToString, TryFrom, Vec, WeiU256, }; use crate::proof::Proof; use aurora_engine_types::types::Fee; @@ -32,8 +32,8 @@ pub struct MetaCallArgs { pub v: u8, pub nonce: RawU256, pub fee_amount: RawU256, - pub fee_address: RawAddress, - pub contract_address: RawAddress, + pub fee_address: Address, + pub contract_address: Address, pub value: RawU256, pub method_def: String, pub args: Vec, @@ -42,7 +42,7 @@ pub struct MetaCallArgs { /// Borsh-encoded log for use in a `SubmitResult`. #[derive(Debug, BorshSerialize, BorshDeserialize)] pub struct ResultLog { - pub address: RawAddress, + pub address: Address, pub topics: Vec, pub data: Vec, } @@ -55,7 +55,7 @@ impl From for ResultLog { .map(|topic| topic.0) .collect::>(); ResultLog { - address: log.address.0, + address: Address::new(log.address), topics, data: log.data, } @@ -134,7 +134,7 @@ impl SubmitResult { /// Borsh-encoded parameters for the engine `call` function. #[derive(BorshSerialize, BorshDeserialize, Debug, PartialEq, Eq, Clone)] pub struct FunctionCallArgsV2 { - pub contract: RawAddress, + pub contract: Address, /// Wei compatible Borsh-encoded value field to attach an ETH balance to the transaction pub value: WeiU256, pub input: Vec, @@ -143,7 +143,7 @@ pub struct FunctionCallArgsV2 { /// Legacy Borsh-encoded parameters for the engine `call` function, to provide backward type compatibility #[derive(BorshSerialize, BorshDeserialize, Debug, PartialEq, Eq, Clone)] pub struct FunctionCallArgsV1 { - pub contract: RawAddress, + pub contract: Address, pub input: Vec, } @@ -176,8 +176,8 @@ impl CallArgs { /// Borsh-encoded parameters for the `view` function. #[derive(BorshSerialize, BorshDeserialize, Debug, Eq, PartialEq)] pub struct ViewCallArgs { - pub sender: RawAddress, - pub address: RawAddress, + pub sender: Address, + pub address: Address, pub amount: RawU256, pub input: Vec, } @@ -202,7 +202,7 @@ pub struct GetStorageAtArgs { #[cfg(feature = "evm_bully")] #[derive(BorshSerialize, BorshDeserialize)] pub struct AccountBalance { - pub address: RawAddress, + pub address: Address, pub balance: RawU256, } @@ -221,7 +221,7 @@ pub struct BeginBlockArgs { /// The current block's hash (for replayer use). pub hash: RawU256, /// The current block's beneficiary address. - pub coinbase: RawAddress, + pub coinbase: Address, /// The current block's timestamp (in seconds since the Unix epoch). pub timestamp: RawU256, /// The current block's number (the genesis block is number zero). @@ -537,8 +537,8 @@ mod tests { #[test] fn test_roundtrip_view_call() { let x = ViewCallArgs { - sender: [1; 20], - address: [2; 20], + sender: Address::from_slice(&[1; 20]), + address: Address::from_slice(&[2; 20]), amount: [3; 32], input: vec![1, 2, 3], }; @@ -550,12 +550,12 @@ mod tests { #[test] fn test_call_args_deserialize() { let new_input = FunctionCallArgsV2 { - contract: [0u8; 20], + contract: Address::from_slice(&[0u8; 20]), value: WeiU256::default(), input: Vec::new(), }; let legacy_input = FunctionCallArgsV1 { - contract: [0u8; 20], + contract: Address::from_slice(&[0u8; 20]), input: Vec::new(), }; diff --git a/engine/src/transaction/legacy.rs b/engine/src/transaction/legacy.rs index 020a22da4..b839852c3 100644 --- a/engine/src/transaction/legacy.rs +++ b/engine/src/transaction/legacy.rs @@ -200,8 +200,6 @@ mod tests { fn address_from_arr(arr: &[u8]) -> Address { assert_eq!(arr.len(), 20); - let mut address = [0u8; 20]; - address.copy_from_slice(&arr); - Address::from(address) + Address::from_slice(arr) } } From fa23f14b1f1c709d55d70e642644fc40fb850e30 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Thu, 16 Dec 2021 19:35:52 +0200 Subject: [PATCH 12/26] Fix tests --- engine-precompiles/src/native.rs | 4 ++-- engine-tests/src/test_utils/mod.rs | 2 +- engine-tests/src/tests/erc20_connector.rs | 10 +++++----- engine-tests/src/tests/meta_parsing.rs | 4 ++-- engine-tests/src/tests/sanity.rs | 4 ++-- engine-tests/src/tests/standalone/sync.rs | 8 ++++---- engine-types/src/types_new/address.rs | 2 +- engine/src/connector.rs | 12 ++++++------ engine/src/deposit_event.rs | 2 +- engine/src/lib.rs | 12 +++--------- 10 files changed, 27 insertions(+), 33 deletions(-) diff --git a/engine-precompiles/src/native.rs b/engine-precompiles/src/native.rs index b2aa68700..c5b2ee318 100644 --- a/engine-precompiles/src/native.rs +++ b/engine-precompiles/src/native.rs @@ -365,11 +365,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), }; diff --git a/engine-tests/src/test_utils/mod.rs b/engine-tests/src/test_utils/mod.rs index 81d0795c1..7de013205 100644 --- a/engine-tests/src/test_utils/mod.rs +++ b/engine-tests/src/test_utils/mod.rs @@ -419,7 +419,7 @@ impl AuroraRunner { pub fn get_storage(&self, address: Address, key: H256) -> H256 { let input = aurora_engine::parameters::GetStorageAtArgs { - address: address.0, + address, key: key.0, }; let (outcome, maybe_error) = diff --git a/engine-tests/src/tests/erc20_connector.rs b/engine-tests/src/tests/erc20_connector.rs index bc21d3bae..2d428d136 100644 --- a/engine-tests/src/tests/erc20_connector.rs +++ b/engine-tests/src/tests/erc20_connector.rs @@ -603,7 +603,7 @@ mod sim_tests { aurora .call( "mint_account", - &(signer_address.0, signer.nonce, INITIAL_ETH_BALANCE) + &(signer_address, signer.nonce, INITIAL_ETH_BALANCE) .try_to_vec() .unwrap(), ) @@ -651,7 +651,7 @@ mod sim_tests { aurora .call( "mint_account", - &(ft_owner_address.0, 0u64, INITIAL_ETH_BALANCE) + &(ft_owner_address, 0u64, INITIAL_ETH_BALANCE) .try_to_vec() .unwrap(), ) @@ -718,7 +718,7 @@ mod sim_tests { ], ); let call_args = CallArgs::V2(FunctionCallArgsV2 { - contract: erc20.0.address.0, + contract: erc20.0.address, value: WeiU256::default(), input, }); @@ -758,7 +758,7 @@ mod sim_tests { let mint_tx = erc20.mint(dest, amount.into(), 0.into()); let call_args = CallArgs::V2(FunctionCallArgsV2 { - contract: erc20.0.address.0, + contract: erc20.0.address, value: WeiU256::default(), input: mint_tx.data, }); @@ -789,7 +789,7 @@ mod sim_tests { fn erc20_balance(erc20: &ERC20, address: Address, aurora: &AuroraAccount) -> U256 { let balance_tx = erc20.balance_of(address, 0.into()); let call_args = CallArgs::V2(FunctionCallArgsV2 { - contract: erc20.0.address.0, + contract: erc20.0.address, value: WeiU256::default(), input: balance_tx.data, }); diff --git a/engine-tests/src/tests/meta_parsing.rs b/engine-tests/src/tests/meta_parsing.rs index 3bd58444d..7ebb2564d 100644 --- a/engine-tests/src/tests/meta_parsing.rs +++ b/engine-tests/src/tests/meta_parsing.rs @@ -49,8 +49,8 @@ fn encode_meta_call_function_args( v: 27, nonce: u256_to_arr(&nonce), fee_amount: fee_amount.to_bytes(), - fee_address: fee_address.0, - contract_address: contract_address.0, + fee_address, + contract_address, value: value.to_bytes(), method_def: method_def.to_string(), args, diff --git a/engine-tests/src/tests/sanity.rs b/engine-tests/src/tests/sanity.rs index f789bc169..1db43c5da 100644 --- a/engine-tests/src/tests/sanity.rs +++ b/engine-tests/src/tests/sanity.rs @@ -680,7 +680,7 @@ fn initialize_evm_sim() -> (state_migration::AuroraAccount, test_utils::Signer, let signer = test_utils::Signer::random(); let address = test_utils::address_from_secret_key(&signer.secret_key); - let args = (address.0, INITIAL_NONCE, INITIAL_BALANCE.raw().low_u64()); + let args = (address, INITIAL_NONCE, INITIAL_BALANCE.raw().low_u64()); aurora .call("mint_account", &args.try_to_vec().unwrap()) .assert_success(); @@ -703,7 +703,7 @@ fn query_address_sim( method: &str, aurora: &state_migration::AuroraAccount, ) -> U256 { - let x = aurora.call(method, &address.0); + let x = aurora.call(method, address); match &x.outcome().status { near_sdk_sim::transaction::ExecutionStatus::SuccessValue(b) => U256::from_big_endian(&b), other => panic!("Unexpected outcome: {:?}", other), diff --git a/engine-tests/src/tests/standalone/sync.rs b/engine-tests/src/tests/standalone/sync.rs index ea3aa9810..a864af034 100644 --- a/engine-tests/src/tests/standalone/sync.rs +++ b/engine-tests/src/tests/standalone/sync.rs @@ -97,11 +97,11 @@ fn test_consume_deploy_message() { position: 0, }) .unwrap(); - let mut deployed_address = Address([0u8; 20]); + let mut deployed_address = Address::zero(); for (key, value) in diff.iter() { match value.value() { Some(bytes) if bytes == code.as_slice() => { - deployed_address.0.copy_from_slice(&key[2..22]); + deployed_address = Address::from_slice(&key[2..22]); break; } _ => continue, @@ -341,7 +341,7 @@ fn mock_proof(recipient_address: Address, deposit_amount: Wei) -> aurora_engine: .unwrap(); let deposit_event = aurora_engine::deposit_event::DepositedEvent { - eth_custodian_address: eth_custodian_address.0, + eth_custodian_address, sender: [0u8; 20], token_message_data, amount: deposit_amount.raw().as_u128(), @@ -382,7 +382,7 @@ fn simple_transfer_args( transfer_amount: Wei, ) -> aurora_engine::parameters::CallArgs { aurora_engine::parameters::CallArgs::V2(aurora_engine::parameters::FunctionCallArgsV2 { - contract: dest_address.0, + contract: dest_address, value: transfer_amount.to_bytes(), input: Vec::new(), }) diff --git a/engine-types/src/types_new/address.rs b/engine-types/src/types_new/address.rs index e35695e26..008dadb5e 100755 --- a/engine-types/src/types_new/address.rs +++ b/engine-types/src/types_new/address.rs @@ -1,4 +1,4 @@ -use crate::{String, TryFrom, H160}; +use crate::{format, String, TryFrom, H160}; use borsh::maybestd::io; use borsh::{BorshDeserialize, BorshSerialize}; diff --git a/engine/src/connector.rs b/engine/src/connector.rs index 644671b45..7c6281c15 100644 --- a/engine/src/connector.rs +++ b/engine/src/connector.rs @@ -143,7 +143,7 @@ impl EthConnectorContract { sdk::log!(&format!( "Deposit started: from {} to recipient {:?} with amount: {:?} and fee {:?}", - hex::encode(event.sender), + event.sender.encode(), event.token_message_data.get_recipient(), event.amount, event.fee @@ -151,8 +151,8 @@ impl EthConnectorContract { sdk::log!(&format!( "Event's address {}, custodian address {}", - hex::encode(&event.eth_custodian_address), - hex::encode(&self.contract.eth_custodian_address), + event.eth_custodian_address.encode(), + self.contract.eth_custodian_address.encode(), )); if event.eth_custodian_address != self.contract.eth_custodian_address { @@ -330,7 +330,7 @@ impl EthConnectorContract { sdk::log!(&format!( "Mint {} ETH tokens for: {}", amount, - hex::encode(owner_id) + owner_id.encode() )); self.ft.internal_deposit_eth_to_aurora(owner_id, amount) } @@ -344,7 +344,7 @@ impl EthConnectorContract { sdk::log!(&format!( "Burn {} ETH tokens for: {}", amount, - hex::encode(address) + address.encode() )); self.ft.internal_withdraw_eth_from_aurora(address, amount) } @@ -414,7 +414,7 @@ impl EthConnectorContract { .internal_unwrap_balance_of_eth_on_aurora(&args.address)?; sdk::log!(&format!( "Balance of ETH [{}]: {}", - hex::encode(args.address), + args.address.encode(), balance )); self.io diff --git a/engine/src/deposit_event.rs b/engine/src/deposit_event.rs index cc5aa9c33..a1f186f38 100644 --- a/engine/src/deposit_event.rs +++ b/engine/src/deposit_event.rs @@ -200,7 +200,7 @@ impl EthEvent { anonymous: false, }; let log_entry: LogEntry = rlp::decode(data).map_err(|_| error::DecodeError::RlpFailed)?; - let eth_custodian_address = Address::from_slice(&log_entry.address.0); + let eth_custodian_address = Address::new(log_entry.address); let topics = log_entry.topics.iter().map(|h| Hash::from(h.0)).collect(); let raw_log = RawLog { diff --git a/engine/src/lib.rs b/engine/src/lib.rs index 21c200a9b..18e696f7e 100644 --- a/engine/src/lib.rs +++ b/engine/src/lib.rs @@ -454,13 +454,7 @@ mod contract { let mut io = Runtime; let args: ViewCallArgs = io.read_input_borsh().sdk_unwrap(); let current_account_id = io.current_account_id(); - let engine = Engine::new( - Address::from_slice(&args.sender), - current_account_id, - io, - &io, - ) - .sdk_unwrap(); + let engine = Engine::new(args.sender, current_account_id, io, &io).sdk_unwrap(); let result = Engine::view_with_args(&engine, args).sdk_unwrap(); io.return_output(&result.try_to_vec().sdk_expect("ERR_SERIALIZE")); } @@ -858,13 +852,13 @@ mod contract { let mut io = Runtime; let args: ([u8; 20], u64, u64) = io.read_input_borsh().sdk_expect("ERR_ARGS"); - let address = Address(args.0); + let address = Address::from_slice(&args.0); let nonce = U256::from(args.1); let balance = U256::from(args.2); let current_account_id = io.current_account_id(); let mut engine = Engine::new(address, current_account_id, io, &io).sdk_unwrap(); let state_change = evm::backend::Apply::Modify { - address, + address: address.raw(), basic: evm::backend::Basic { balance, nonce }, code: None, storage: core::iter::empty(), From 175f406d70842e4bbd60b7d6c1dd457b81822fee Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Thu, 16 Dec 2021 23:51:07 +0200 Subject: [PATCH 13/26] Fix tests --- engine-tests/src/benches/nft_pagination.rs | 2 +- engine-tests/src/test_utils/erc20.rs | 11 +++--- .../src/test_utils/exit_precompile.rs | 4 +-- engine-tests/src/test_utils/mod.rs | 9 +++-- .../test_utils/one_inch/liquidity_protocol.rs | 16 ++++----- .../src/test_utils/standalone/mocks/mod.rs | 4 +-- engine-tests/src/test_utils/standalone/mod.rs | 4 +-- engine-tests/src/test_utils/uniswap.rs | 26 +++++++------- engine-tests/src/tests/access_lists.rs | 6 ++-- engine-tests/src/tests/contract_call.rs | 14 ++++---- engine-tests/src/tests/eip1559.rs | 4 +-- engine-tests/src/tests/erc20_connector.rs | 1 + engine-tests/src/tests/eth_connector.rs | 36 +++++++++++-------- engine-tests/src/tests/meta_parsing.rs | 4 +-- engine-tests/src/tests/sanity.rs | 14 ++++---- .../src/tests/standalone/json_snapshot.rs | 5 +-- engine-tests/src/tests/standalone/sanity.rs | 5 +-- engine-tests/src/tests/standalone/sync.rs | 21 ++++++----- engine-tests/src/tests/uniswap.rs | 12 ++++--- 19 files changed, 110 insertions(+), 88 deletions(-) diff --git a/engine-tests/src/benches/nft_pagination.rs b/engine-tests/src/benches/nft_pagination.rs index 45b8c4b14..58831d4a1 100644 --- a/engine-tests/src/benches/nft_pagination.rs +++ b/engine-tests/src/benches/nft_pagination.rs @@ -134,7 +134,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()), ], diff --git a/engine-tests/src/test_utils/erc20.rs b/engine-tests/src/test_utils/erc20.rs index 6b414fc07..f72f60c69 100644 --- a/engine-tests/src/test_utils/erc20.rs +++ b/engine-tests/src/test_utils/erc20.rs @@ -78,7 +78,7 @@ impl ERC20 { .function("mint") .unwrap() .encode_input(&[ - ethabi::Token::Address(recipient), + ethabi::Token::Address(recipient.raw()), ethabi::Token::Uint(amount), ]) .unwrap(); @@ -100,7 +100,7 @@ impl ERC20 { .function("transfer") .unwrap() .encode_input(&[ - ethabi::Token::Address(recipient), + ethabi::Token::Address(recipient.raw()), ethabi::Token::Uint(amount), ]) .unwrap(); @@ -120,7 +120,10 @@ impl ERC20 { .abi .function("approve") .unwrap() - .encode_input(&[ethabi::Token::Address(spender), ethabi::Token::Uint(amount)]) + .encode_input(&[ + ethabi::Token::Address(spender.raw()), + ethabi::Token::Uint(amount), + ]) .unwrap(); TransactionLegacy { nonce, @@ -138,7 +141,7 @@ impl ERC20 { .abi .function("balanceOf") .unwrap() - .encode_input(&[ethabi::Token::Address(address)]) + .encode_input(&[ethabi::Token::Address(address.raw())]) .unwrap(); TransactionLegacy { nonce, diff --git a/engine-tests/src/test_utils/exit_precompile.rs b/engine-tests/src/test_utils/exit_precompile.rs index 20708edf4..ecd347b54 100644 --- a/engine-tests/src/test_utils/exit_precompile.rs +++ b/engine-tests/src/test_utils/exit_precompile.rs @@ -30,7 +30,7 @@ impl TesterConstructor { .abi .constructor() .unwrap() - .encode_input(self.0.code.clone(), &[ethabi::Token::Address(token)]) + .encode_input(self.0.code.clone(), &[ethabi::Token::Address(token.raw())]) .unwrap(); TransactionLegacy { @@ -200,7 +200,7 @@ impl Tester { signer, "withdrawEthToEthereum", amount, - &[ethabi::Token::Address(DEST_ADDRESS)], + &[ethabi::Token::Address(DEST_ADDRESS.raw())], ) } } diff --git a/engine-tests/src/test_utils/mod.rs b/engine-tests/src/test_utils/mod.rs index 7de013205..b947f1c56 100644 --- a/engine-tests/src/test_utils/mod.rs +++ b/engine-tests/src/test_utils/mod.rs @@ -1,3 +1,4 @@ +use aurora_engine::parameters::ViewCallArgs; use aurora_engine_types::account_id::AccountId; use borsh::{BorshDeserialize, BorshSerialize}; use near_primitives_core::config::VMConfig; @@ -12,9 +13,7 @@ use rlp::RlpStream; use secp256k1::{self, Message, PublicKey, SecretKey}; use crate::prelude::fungible_token::{FungibleToken, FungibleTokenMetadata}; -use crate::prelude::parameters::{ - InitCallArgs, NewCallArgs, SubmitResult, TransactionStatus, ViewCallArgs, -}; +use crate::prelude::parameters::{InitCallArgs, NewCallArgs, SubmitResult, TransactionStatus}; use crate::prelude::transaction::{ eip_1559::{self, SignedTransaction1559, Transaction1559}, eip_2930::{self, SignedTransaction2930, Transaction2930}, @@ -653,8 +652,8 @@ pub(crate) fn create_eth_transaction( pub(crate) fn as_view_call(tx: TransactionLegacy, sender: Address) -> ViewCallArgs { ViewCallArgs { - sender: sender.0, - address: tx.to.unwrap().0, + sender, + address: tx.to.unwrap(), amount: tx.value.to_bytes(), input: tx.data, } diff --git a/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs b/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs index 23218f533..859411e9b 100644 --- a/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs +++ b/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs @@ -63,9 +63,9 @@ impl<'a> Helper<'a> { constructor.deploy_with_args( nonce, &[ - ethabi::Token::Address(signer_address), - ethabi::Token::Address(pool_deployer.0.address), - ethabi::Token::Address(signer_address), + ethabi::Token::Address(signer_address.raw()), + ethabi::Token::Address(pool_deployer.0.address.raw()), + ethabi::Token::Address(signer_address.raw()), ], ) }) @@ -94,8 +94,8 @@ impl<'a> Helper<'a> { pool_factory.0.call_method_with_args( "deploy", &[ - ethabi::Token::Address(token_a), - ethabi::Token::Address(token_b), + ethabi::Token::Address(token_a.raw()), + ethabi::Token::Address(token_b.raw()), ], nonce, ) @@ -178,11 +178,11 @@ impl<'a> Helper<'a> { pool, "swap", &[ - ethabi::Token::Address(args.src_token), - ethabi::Token::Address(args.dst_token), + ethabi::Token::Address(args.src_token.raw()), + ethabi::Token::Address(args.dst_token.raw()), ethabi::Token::Uint(args.amount), ethabi::Token::Uint(args.min_amount), - ethabi::Token::Address(args.referral), + ethabi::Token::Address(args.referral.raw()), ], ) } diff --git a/engine-tests/src/test_utils/standalone/mocks/mod.rs b/engine-tests/src/test_utils/standalone/mocks/mod.rs index 194230849..61fae5620 100644 --- a/engine-tests/src/test_utils/standalone/mocks/mod.rs +++ b/engine-tests/src/test_utils/standalone/mocks/mod.rs @@ -62,7 +62,7 @@ pub fn init_evm(mut io: I, env: &E, chain_id: u64) { let connector_args = InitCallArgs { prover_account: test_utils::str_to_account_id("prover.near"), - eth_custodian_address: hex::encode(Ð_CUSTODIAN_ADDRESS), + eth_custodian_address: ETH_CUSTODIAN_ADDRESS.encode(), metadata: FungibleTokenMetadata::default(), }; @@ -88,7 +88,7 @@ pub fn mint_evm_account( let aurora_account_id = env.current_account_id(); let mut engine = engine::Engine::new(address, aurora_account_id.clone(), io, env).unwrap(); let state_change = evm::backend::Apply::Modify { - address, + address: address.raw(), basic: evm::backend::Basic { balance: balance.raw(), nonce, diff --git a/engine-tests/src/test_utils/standalone/mod.rs b/engine-tests/src/test_utils/standalone/mod.rs index 5af8e29b2..0e393ba4a 100644 --- a/engine-tests/src/test_utils/standalone/mod.rs +++ b/engine-tests/src/test_utils/standalone/mod.rs @@ -50,7 +50,7 @@ impl StandaloneRunner { let env = &mut self.env; let transaction_hash = { let bytes = [ - address.as_ref(), + address.raw().as_ref(), &balance.to_bytes(), &aurora_engine_types::types::u256_to_arr(&nonce), ] @@ -184,7 +184,7 @@ impl StandaloneRunner { .unwrap(); io.finish().commit(storage, &mut self.cumulative_diff); Ok(SubmitResult::new( - TransactionStatus::Succeed(address.as_ref().to_vec()), + TransactionStatus::Succeed(address.raw().as_ref().to_vec()), 0, Vec::new(), )) diff --git a/engine-tests/src/test_utils/uniswap.rs b/engine-tests/src/test_utils/uniswap.rs index 6615a5fed..c8b826813 100644 --- a/engine-tests/src/test_utils/uniswap.rs +++ b/engine-tests/src/test_utils/uniswap.rs @@ -112,9 +112,9 @@ impl PositionManagerConstructor { .encode_input( self.0.code.clone(), &[ - ethabi::Token::Address(factory), - ethabi::Token::Address(wrapped_eth), - ethabi::Token::Address(token_descriptor), + ethabi::Token::Address(factory.raw()), + ethabi::Token::Address(wrapped_eth.raw()), + ethabi::Token::Address(token_descriptor.raw()), ], ) .unwrap(); @@ -143,8 +143,8 @@ impl Factory { .function("createPool") .unwrap() .encode_input(&[ - ethabi::Token::Address(token_a), - ethabi::Token::Address(token_b), + ethabi::Token::Address(token_a.raw()), + ethabi::Token::Address(token_b.raw()), ethabi::Token::Uint(fee), ]) .unwrap(); @@ -213,8 +213,8 @@ impl PositionManager { .function("mint") .unwrap() .encode_input(&[ethabi::Token::Tuple(vec![ - ethabi::Token::Address(params.token0), - ethabi::Token::Address(params.token1), + ethabi::Token::Address(params.token0.raw()), + ethabi::Token::Address(params.token1.raw()), ethabi::Token::Uint(params.fee.into()), ethabi::Token::Int(tick_lower), ethabi::Token::Int(tick_upper), @@ -222,7 +222,7 @@ impl PositionManager { ethabi::Token::Uint(params.amount1_desired), ethabi::Token::Uint(params.amount0_min), ethabi::Token::Uint(params.amount1_min), - ethabi::Token::Address(params.recipient), + ethabi::Token::Address(params.recipient.raw()), ethabi::Token::Uint(params.deadline), ])]) .unwrap(); @@ -276,8 +276,8 @@ impl SwapRouterConstructor { .encode_input( self.0.code.clone(), &[ - ethabi::Token::Address(factory), - ethabi::Token::Address(wrapped_eth), + ethabi::Token::Address(factory.raw()), + ethabi::Token::Address(wrapped_eth.raw()), ], ) .unwrap(); @@ -315,10 +315,10 @@ impl SwapRouter { .function("exactOutputSingle") .unwrap() .encode_input(&[ethabi::Token::Tuple(vec![ - ethabi::Token::Address(params.token_in), - ethabi::Token::Address(params.token_out), + ethabi::Token::Address(params.token_in.raw()), + ethabi::Token::Address(params.token_out.raw()), ethabi::Token::Uint(params.fee.into()), - ethabi::Token::Address(params.recipient), + ethabi::Token::Address(params.recipient.raw()), ethabi::Token::Uint(params.deadline), ethabi::Token::Uint(params.amount_out), ethabi::Token::Uint(params.amount_in_max), diff --git a/engine-tests/src/tests/access_lists.rs b/engine-tests/src/tests/access_lists.rs index 93ef7f779..35fccaf3a 100644 --- a/engine-tests/src/tests/access_lists.rs +++ b/engine-tests/src/tests/access_lists.rs @@ -26,11 +26,13 @@ fn test_access_list_tx_encoding_decoding() { data: vec![0], access_list: vec![ AccessTuple { - address: test_utils::address_from_hex("0x095e7baea6a6c7c4c2dfeb977efac326af552d87"), + address: test_utils::address_from_hex("0x095e7baea6a6c7c4c2dfeb977efac326af552d87") + .raw(), storage_keys: vec![H256::zero(), one()], }, AccessTuple { - address: test_utils::address_from_hex("0x195e7baea6a6c7c4c2dfeb977efac326af552d87"), + address: test_utils::address_from_hex("0x195e7baea6a6c7c4c2dfeb977efac326af552d87") + .raw(), storage_keys: vec![H256::zero()], }, ], diff --git a/engine-tests/src/tests/contract_call.rs b/engine-tests/src/tests/contract_call.rs index 04a8231ba..20ae8da1d 100644 --- a/engine-tests/src/tests/contract_call.rs +++ b/engine-tests/src/tests/contract_call.rs @@ -88,17 +88,17 @@ fn withdraw() { let address = Address::from_slice(&address); ethabi::LogParam { name: "dest".to_string(), - value: ethabi::Token::Address(address), + value: ethabi::Token::Address(address.raw()), } }; let expected_event = vec![ ethabi::LogParam { name: "sender".to_string(), - value: ethabi::Token::Address(token), + value: ethabi::Token::Address(token.raw()), }, ethabi::LogParam { name: "erc20_address".to_string(), - value: ethabi::Token::Address(token), + value: ethabi::Token::Address(token.raw()), }, dest, ethabi::LogParam { @@ -187,11 +187,13 @@ fn withdraw_eth() { let mut expected_event = vec![ ethabi::LogParam { name: "sender".to_string(), - value: ethabi::Token::Address(tester.contract.address), + value: ethabi::Token::Address(tester.contract.address.raw()), }, ethabi::LogParam { name: "erc20_address".to_string(), - value: ethabi::Token::Address(aurora_engine_precompiles::native::events::ETH_ADDRESS), + value: ethabi::Token::Address( + aurora_engine_precompiles::native::events::ETH_ADDRESS.raw(), + ), }, ethabi::LogParam { name: "dest".to_string(), @@ -214,7 +216,7 @@ fn withdraw_eth() { .unwrap(); expected_event[2] = ethabi::LogParam { name: "dest".to_string(), - value: ethabi::Token::Address(DEST_ADDRESS), + value: ethabi::Token::Address(DEST_ADDRESS.raw()), }; expected_event[3] = ethabi::LogParam { name: "amount".to_string(), diff --git a/engine-tests/src/tests/eip1559.rs b/engine-tests/src/tests/eip1559.rs index 239c5b33b..7c6748898 100644 --- a/engine-tests/src/tests/eip1559.rs +++ b/engine-tests/src/tests/eip1559.rs @@ -43,7 +43,7 @@ fn test_eip_1559_tx_encoding_decoding() { assert_eq!( signed_tx.sender().unwrap(), - test_utils::address_from_secret_key(&secret_key) + test_utils::address_from_secret_key(&secret_key).raw() ) } @@ -132,7 +132,7 @@ fn example_transaction() -> Transaction1559 { value: Wei::zero(), data: vec![0], access_list: vec![AccessTuple { - address: test_utils::address_from_hex(CONTRACT_ADDRESS), + address: test_utils::address_from_hex(CONTRACT_ADDRESS).raw(), storage_keys: vec![H256::zero(), one()], }], } diff --git a/engine-tests/src/tests/erc20_connector.rs b/engine-tests/src/tests/erc20_connector.rs index 2d428d136..86732010f 100644 --- a/engine-tests/src/tests/erc20_connector.rs +++ b/engine-tests/src/tests/erc20_connector.rs @@ -398,6 +398,7 @@ mod sim_tests { use aurora_engine::parameters::{ CallArgs, DeployErc20TokenArgs, FunctionCallArgsV2, SubmitResult, }; + use aurora_engine_types::types_new::Address; use borsh::BorshSerialize; use near_sdk_sim::UserAccount; use serde_json::json; diff --git a/engine-tests/src/tests/eth_connector.rs b/engine-tests/src/tests/eth_connector.rs index ae28465e9..ddcd3814d 100644 --- a/engine-tests/src/tests/eth_connector.rs +++ b/engine-tests/src/tests/eth_connector.rs @@ -101,9 +101,7 @@ fn init_contract( fn validate_eth_address(address: &str) -> Address { let data = hex::decode(address).unwrap(); assert_eq!(data.len(), 20); - let mut result = [0u8; 20]; - result.copy_from_slice(&data); - result + Address::from_slice(&data) } fn call_deposit_eth_to_near( @@ -412,7 +410,11 @@ fn test_ft_transfer_call_eth() { let transfer_amount = 50; 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()); + msg.append( + &mut validate_eth_address(RECIPIENT_ETH_ADDRESS) + .as_bytes() + .to_vec(), + ); let message = [CONTRACT_ACC, hex::encode(msg).as_str()].join(":"); let res = contract.call( @@ -597,15 +599,13 @@ 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] = { - let mut buf = [0u8; 20]; + let eth_custodian_address: Address = { let bytes = hex::decode(CUSTODIAN_ADDRESS).unwrap(); - buf.copy_from_slice(&bytes); - buf + Address::from_slice(&bytes) }; - let recipient_address = [10u8; 20]; + let recipient_address = Address::from_slice(&[10u8; 20]); let deposit_amount = 17; - let recipient_address_encoded = hex::encode(&recipient_address); + let recipient_address_encoded = recipient_address.encode(); // Note the 0x prefix before the deposit address. let message = [CONTRACT_ACC, ":", "0x", &recipient_address_encoded].concat(); @@ -616,7 +616,7 @@ fn test_deposit_with_0x_prefix() { let deposit_event = aurora_engine::deposit_event::DepositedEvent { eth_custodian_address, - sender: [0u8; 20], + sender: Address::zero(), token_message_data, amount: deposit_amount, fee, @@ -628,7 +628,7 @@ fn test_deposit_with_0x_prefix() { anonymous: false, }; let log_entry = aurora_engine::log_entry::LogEntry { - address: eth_custodian_address.into(), + address: eth_custodian_address.raw(), topics: vec![ event_schema.signature(), // the sender is not important @@ -718,7 +718,11 @@ fn test_ft_transfer_call_without_relayer() { let transfer_amount = 50; 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()); + msg.append( + &mut validate_eth_address(RECIPIENT_ETH_ADDRESS) + .as_bytes() + .to_vec(), + ); let relayer_id = "relayer.root"; let message = [relayer_id, hex::encode(msg).as_str()].join(":"); let res = contract.call( @@ -774,7 +778,11 @@ fn test_ft_transfer_call_fee_greater_than_amount() { let transfer_amount = 10; 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()); + msg.append( + &mut validate_eth_address(RECIPIENT_ETH_ADDRESS) + .as_bytes() + .to_vec(), + ); let relayer_id = "relayer.root"; let message = [relayer_id, hex::encode(msg).as_str()].join(":"); let res = contract.call( diff --git a/engine-tests/src/tests/meta_parsing.rs b/engine-tests/src/tests/meta_parsing.rs index 7ebb2564d..5645d1e60 100644 --- a/engine-tests/src/tests/meta_parsing.rs +++ b/engine-tests/src/tests/meta_parsing.rs @@ -67,9 +67,7 @@ fn public_key_to_address(public_key: PublicKey) -> Address { PublicKey::SECP256K1(pubkey) => { let pk: [u8; 64] = pubkey.into(); let bytes = keccak(&pk.to_vec()); - let mut result = Address::zero(); - result.as_bytes_mut().copy_from_slice(&bytes[12..]); - result + Address::from_slice(&bytes[12..]) } } } diff --git a/engine-tests/src/tests/sanity.rs b/engine-tests/src/tests/sanity.rs index 1db43c5da..6c1b3b7c9 100644 --- a/engine-tests/src/tests/sanity.rs +++ b/engine-tests/src/tests/sanity.rs @@ -123,7 +123,7 @@ fn test_log_address() { .submit_with_signer(&mut signer, |nonce| { caller_contract.call_method_with_args( "greet", - &[ethabi::Token::Address(greet_contract.address)], + &[ethabi::Token::Address(greet_contract.address.raw())], nonce, ) }) @@ -132,7 +132,7 @@ fn test_log_address() { // Address included in the log should come from the contract emitting the log, // not the contract that invoked the call. let log_address = result.logs.first().unwrap().address; - assert_eq!(Address(log_address), greet_contract.address); + assert_eq!(log_address, greet_contract.address); } #[test] @@ -237,7 +237,7 @@ fn test_override_state() { }; // Assert the initial state is 0 - assert_eq!(get_address(&runner), Address([0; 20])); + assert_eq!(get_address(&runner), ADDRESS(H160([0; 20]))); post_address(&mut runner, &mut account1); // Assert the address matches the first caller assert_eq!(get_address(&runner), account1_address); @@ -517,6 +517,8 @@ fn initialize_transfer() -> (test_utils::AuroraRunner, test_utils::Signer, Addre (runner, signer, dest_address) } +use aurora_engine_types::types_new::ADDRESS; +use aurora_engine_types::H160; use sha3::Digest; #[test] @@ -621,7 +623,7 @@ fn test_eth_transfer_insufficient_balance_sim() { // Run transaction which will fail (transfer more than current balance) let nonce = signer.use_nonce(); let tx = test_utils::transfer( - Address([1; 20]), + ADDRESS(H160([1; 20])), INITIAL_BALANCE + INITIAL_BALANCE, nonce.into(), ); @@ -652,7 +654,7 @@ fn test_eth_transfer_charging_gas_not_enough_balance_sim() { // Run transaction which will fail (not enough balance to cover gas) let nonce = signer.use_nonce(); - let mut tx = test_utils::transfer(Address([1; 20]), TRANSFER_AMOUNT, nonce.into()); + let mut tx = test_utils::transfer(ADDRESS(H160([1; 20])), TRANSFER_AMOUNT, nonce.into()); tx.gas_limit = 3_000_000.into(); tx.gas_price = GAS_PRICE.into(); let signed_tx = test_utils::sign_transaction( @@ -703,7 +705,7 @@ fn query_address_sim( method: &str, aurora: &state_migration::AuroraAccount, ) -> U256 { - let x = aurora.call(method, address); + let x = aurora.call(method, address.as_bytes()); match &x.outcome().status { near_sdk_sim::transaction::ExecutionStatus::SuccessValue(b) => U256::from_big_endian(&b), other => panic!("Unexpected outcome: {:?}", other), diff --git a/engine-tests/src/tests/standalone/json_snapshot.rs b/engine-tests/src/tests/standalone/json_snapshot.rs index 333ec3c93..ae4962939 100644 --- a/engine-tests/src/tests/standalone/json_snapshot.rs +++ b/engine-tests/src/tests/standalone/json_snapshot.rs @@ -1,5 +1,6 @@ use crate::test_utils::standalone; -use aurora_engine_types::{types_new::Address, U256}; +use aurora_engine_types::types_new::ADDRESS; +use aurora_engine_types::{types_new::Address, H160, U256}; use engine_standalone_storage::json_snapshot; const NONCE_PREFIX: [u8; 2] = [0x07, 0x01]; @@ -40,5 +41,5 @@ fn test_consume_snapshot() { fn address_from_key(key: &[u8]) -> Address { let mut result = [0u8; 20]; result.copy_from_slice(&key[2..22]); - Address(result) + ADDRESS(H160(result)) } diff --git a/engine-tests/src/tests/standalone/sanity.rs b/engine-tests/src/tests/standalone/sanity.rs index 05ca9d646..5d41d1543 100644 --- a/engine-tests/src/tests/standalone/sanity.rs +++ b/engine-tests/src/tests/standalone/sanity.rs @@ -2,7 +2,8 @@ use crate::test_utils::standalone::mocks::{promise, storage}; use aurora_engine::engine; use aurora_engine_sdk::env::DEFAULT_PREPAID_GAS; use aurora_engine_types::types::Wei; -use aurora_engine_types::{account_id::AccountId, types_new::Address, H256, U256}; +use aurora_engine_types::types_new::ADDRESS; +use aurora_engine_types::{account_id::AccountId, types_new::Address, H160, H256, U256}; use std::sync::RwLock; #[test] @@ -20,7 +21,7 @@ fn test_deploy_code() { bridge_prover_id: "mr_the_prover".parse().unwrap(), upgrade_delay_blocks: 0, }; - let origin = Address([0u8; 20]); + let origin = ADDRESS(H160([0u8; 20])); let storage = RwLock::new(storage::Storage::default()); let io = storage::StoragePointer(&storage); let env = aurora_engine_sdk::env::Fixed { diff --git a/engine-tests/src/tests/standalone/sync.rs b/engine-tests/src/tests/standalone/sync.rs index a864af034..bc5986c4a 100644 --- a/engine-tests/src/tests/standalone/sync.rs +++ b/engine-tests/src/tests/standalone/sync.rs @@ -1,7 +1,10 @@ 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, types_new::Address, H256, U256}; +use aurora_engine_types::types_new::ADDRESS; +use aurora_engine_types::{ + account_id::AccountId, types::Wei, types_new::Address, H160, H256, U256, +}; use borsh::BorshSerialize; use engine_standalone_storage::sync; @@ -40,7 +43,7 @@ fn test_consume_block_message() { fn test_consume_deposit_message() { let (mut runner, block_message) = initialize(); - let recipient_address = Address([22u8; 20]); + let recipient_address = ADDRESS(H160([22u8; 20])); let deposit_amount = Wei::new_u64(123_456_789); let proof = mock_proof(recipient_address, deposit_amount); @@ -119,7 +122,7 @@ fn test_consume_deploy_erc20_message() { let token: AccountId = "some_nep141.near".parse().unwrap(); let mint_amount: u128 = 555_555; - let dest_address = Address([170u8; 20]); + let dest_address = ADDRESS(H160([170u8; 20])); let args = aurora_engine::parameters::DeployErc20TokenArgs { nep141: token.clone(), @@ -200,7 +203,7 @@ fn test_consume_ft_on_transfer_message() { let mint_amount = 8_675_309; let fee = Wei::zero(); - let dest_address = Address([221u8; 20]); + let dest_address = ADDRESS(H160([221u8; 20])); // Mint ETH on Aurora per the bridge workflow let args = aurora_engine::parameters::NEP141FtOnTransferArgs { @@ -245,7 +248,7 @@ fn test_consume_call_message() { let initial_balance = Wei::new_u64(800_000); let transfer_amount = Wei::new_u64(115_321); let caller_address = aurora_engine_sdk::types::near_account_to_evm_address(caller.as_bytes()); - let recipient_address = Address([1u8; 20]); + let recipient_address = ADDRESS(H160([1u8; 20])); runner.mint_account(caller_address, initial_balance, U256::zero(), None); runner.env.block_height += 1; @@ -290,7 +293,7 @@ fn test_consume_submit_message() { let initial_balance = Wei::new_u64(800_000); let transfer_amount = Wei::new_u64(115_321); let signer_address = test_utils::address_from_secret_key(&signer.secret_key); - let recipient_address = Address([1u8; 20]); + let recipient_address = ADDRESS(H160([1u8; 20])); runner.mint_account(signer_address, initial_balance, signer.nonce.into(), None); runner.env.block_height += 1; @@ -335,14 +338,14 @@ fn mock_proof(recipient_address: Address, deposit_amount: Wei) -> aurora_engine: 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 message = ["aurora", ":", recipient_address.encode().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, - sender: [0u8; 20], + sender: ADDRESS(H160([0u8; 20])), token_message_data, amount: deposit_amount.raw().as_u128(), fee, @@ -354,7 +357,7 @@ fn mock_proof(recipient_address: Address, deposit_amount: Wei) -> aurora_engine: anonymous: false, }; let log_entry = aurora_engine::log_entry::LogEntry { - address: eth_custodian_address, + address: eth_custodian_address.raw(), topics: vec![ event_schema.signature(), // the sender is not important diff --git a/engine-tests/src/tests/uniswap.rs b/engine-tests/src/tests/uniswap.rs index d3af55437..43345407d 100644 --- a/engine-tests/src/tests/uniswap.rs +++ b/engine-tests/src/tests/uniswap.rs @@ -9,6 +9,8 @@ use crate::test_utils::{ AuroraRunner, ExecutionProfile, Signer, }; use aurora_engine_types::types::Wei; +use aurora_engine_types::types_new::ADDRESS; +use aurora_engine_types::H160; use secp256k1::SecretKey; const INITIAL_BALANCE: u64 = 1000; @@ -96,7 +98,7 @@ impl UniswapTestContext { c.deploy( factory.0.address, weth_address, - Address([0; 20]), + ADDRESS(H160([0; 20])), nonce.into(), ) }, @@ -147,9 +149,8 @@ impl UniswapTestContext { .unwrap(); assert!(result.status.is_ok(), "Failed to create pool"); - let mut address = [0u8; 20]; - address.copy_from_slice(&test_utils::unwrap_success(result)[12..]); - let pool = Pool::from_address(Address(address)); + let address = Address::from_slice(&test_utils::unwrap_success(result)[12..]); + let pool = Pool::from_address(address); // 2^96 corresponds to a price ratio of 1 let result = self @@ -232,7 +233,8 @@ impl UniswapTestContext { token_in: token_in.0.address, token_out: token_out.0.address, fee: POOL_FEE, - recipient: Address([0; 20]), + + recipient: ADDRESS(H160([0; 20])), deadline: U256::MAX, amount_out, amount_in_max: U256::from(100) * amount_out, From f2187af8a923bcca8400860418723205009b77eb Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Thu, 16 Dec 2021 23:58:23 +0200 Subject: [PATCH 14/26] Fix test --- engine-tests/src/tests/erc20_connector.rs | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/engine-tests/src/tests/erc20_connector.rs b/engine-tests/src/tests/erc20_connector.rs index 86732010f..1267ad182 100644 --- a/engine-tests/src/tests/erc20_connector.rs +++ b/engine-tests/src/tests/erc20_connector.rs @@ -114,10 +114,11 @@ impl test_utils::AuroraRunner { result.check_ok(); - Vec::::try_from_slice(result.value().as_slice()) + let raw_address: [u8; 20] = Vec::::try_from_slice(result.value().as_slice()) .unwrap() .try_into() - .unwrap() + .unwrap(); + Address::from_slice(&raw_address) } pub fn create_account(&mut self) -> EthereumAddress { @@ -132,7 +133,7 @@ impl test_utils::AuroraRunner { } pub fn balance_of(&mut self, token: Address, target: Address, origin: String) -> U256 { - let input = build_input("balanceOf(address)", &[Token::Address(target.into())]); + let input = build_input("balanceOf(address)", &[Token::Address(target.raw())]); let result = self.evm_call(token, input, origin); result.check_ok(); let output = test_utils::unwrap_success(result.submit_result()); @@ -149,7 +150,7 @@ impl test_utils::AuroraRunner { let input = build_input( "mint(address,uint256)", &[ - Token::Address(target.into()), + Token::Address(target.raw()), Token::Uint(U256::from(amount).into()), ], ); @@ -178,7 +179,7 @@ impl test_utils::AuroraRunner { let input = build_input( "transfer(address,uint256)", &[ - Token::Address(receiver.into()), + Token::Address(receiver.raw()), Token::Uint(U256::from(amount)), ], ); @@ -222,7 +223,7 @@ impl test_utils::AuroraRunner { self.make_call( "register_relayer", relayer_account_id, - relayer_address.as_fixed_bytes().try_to_vec().unwrap(), + relayer_address.try_to_vec().unwrap(), ) } } @@ -273,7 +274,7 @@ fn test_ft_on_transfer() { let balance = runner.balance_of(token, recipient, origin()); assert_eq!(balance, U256::from(0)); - let res = runner.ft_on_transfer(nep141, alice.clone(), alice, amount, hex::encode(recipient)); + let res = runner.ft_on_transfer(nep141, alice.clone(), alice, amount, recipient.encode()); // Transaction should succeed so return amount is 0 assert_eq!(res, "\"0\""); @@ -290,7 +291,7 @@ fn test_ft_on_transfer_fail() { let recipient = runner.create_account().address; - let res = runner.ft_on_transfer(nep141, alice.clone(), alice, amount, hex::encode(recipient)); + let res = runner.ft_on_transfer(nep141, alice.clone(), alice, amount, recipient.encode()); // Transaction should fail so it must return everything assert_eq!(res, format!("\"{}\"", amount.to_string())); @@ -327,7 +328,7 @@ fn test_relayer_charge_fee() { alice.clone(), alice, amount, - hex::encode(recipient) + &hex::encode(fee_encoded), + recipient.encode() + &hex::encode(fee_encoded), ); let recipient_balance_end = runner.get_balance(recipient.into()); From 2d9434e43b5e9af4d8d166a667e79b5c1682ae7c Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Fri, 17 Dec 2021 00:34:20 +0200 Subject: [PATCH 15/26] Fix Address BorshDeserialize --- engine-types/src/types_new/address.rs | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/engine-types/src/types_new/address.rs b/engine-types/src/types_new/address.rs index 008dadb5e..d7e723204 100755 --- a/engine-types/src/types_new/address.rs +++ b/engine-types/src/types_new/address.rs @@ -66,19 +66,16 @@ impl BorshSerialize for Address { impl BorshDeserialize for Address { fn deserialize(buf: &mut &[u8]) -> io::Result { - if buf.len() != 20 { + if buf.len() < 20 { return Err(io::Error::new( io::ErrorKind::Other, format!("{}", error::AddressError::IncorrectLength), )); } // Guaranty no panics. The length checked early - Ok(Self(H160::from_slice(buf))) - } - - fn try_from_slice(v: &[u8]) -> io::Result { - let mut v_mut = v; - Self::deserialize(&mut v_mut) + let address = Self(H160::from_slice(&buf[..20])); + *buf = &buf[20..]; + Ok(address) } } From d3261b19c8c0145c9f1ff5a5f24f87477f784101 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Fri, 17 Dec 2021 00:43:13 +0200 Subject: [PATCH 16/26] Fix borsh tests --- engine-types/src/types_new/address.rs | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/engine-types/src/types_new/address.rs b/engine-types/src/types_new/address.rs index d7e723204..7e6cf53d1 100755 --- a/engine-types/src/types_new/address.rs +++ b/engine-types/src/types_new/address.rs @@ -107,21 +107,13 @@ mod tests { } #[test] - #[should_panic] fn test_wrong_address_19() { let serialized_addr = [0u8; 19]; let addr = Address::try_from_slice(&serialized_addr); - assert!(addr.is_err()); - - let serialized_addr = [0u8; 21]; - let _ = Address::try_from_slice(&serialized_addr); - } - - #[test] - #[should_panic] - fn test_wrong_address_21() { - let serialized_addr = [0u8; 21]; - let _ = Address::try_from_slice(&serialized_addr); + assert_eq!( + addr.unwrap_err().to_string(), + error::AddressError::IncorrectLength.to_string() + ); } } From 6729ea7bd0fe8b9e3942e2e156c247df79f67275 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Fri, 17 Dec 2021 00:51:04 +0200 Subject: [PATCH 17/26] Fix bully --- engine/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/lib.rs b/engine/src/lib.rs index 18e696f7e..759da19c4 100644 --- a/engine/src/lib.rs +++ b/engine/src/lib.rs @@ -522,7 +522,7 @@ mod contract { for account_balance in args.genesis_alloc { engine::set_balance( &mut io, - &Address(account_balance.address), + &account_balance.address, &crate::prelude::types::Wei::new(U256::from(account_balance.balance)), ) } From 21b1a9cbed4e7275754212a3226e264c5f580bc2 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Mon, 20 Dec 2021 17:54:18 +0200 Subject: [PATCH 18/26] Changed type for SignedTransaction1559. Added test_address_deocde --- engine-tests/src/tests/eip1559.rs | 2 +- engine-types/src/types/address.rs | 28 ++++++++++++++++++++++++++++ engine/src/transaction/eip_1559.rs | 6 +++--- engine/src/transaction/mod.rs | 2 +- 4 files changed, 33 insertions(+), 5 deletions(-) diff --git a/engine-tests/src/tests/eip1559.rs b/engine-tests/src/tests/eip1559.rs index 7c6748898..78092b61b 100644 --- a/engine-tests/src/tests/eip1559.rs +++ b/engine-tests/src/tests/eip1559.rs @@ -43,7 +43,7 @@ fn test_eip_1559_tx_encoding_decoding() { assert_eq!( signed_tx.sender().unwrap(), - test_utils::address_from_secret_key(&secret_key).raw() + test_utils::address_from_secret_key(&secret_key) ) } diff --git a/engine-types/src/types/address.rs b/engine-types/src/types/address.rs index 7e6cf53d1..d91105433 100755 --- a/engine-types/src/types/address.rs +++ b/engine-types/src/types/address.rs @@ -106,6 +106,34 @@ mod tests { ); } + #[test] + fn test_address_deocde() { + // Test compatibility with previous typ RawAddress. + // It was: type RawAddress = [u8;20]; + let eth_address_vec = + hex::decode("096DE9C2B8A5B8c22cEe3289B101f6960d68E51E".to_string()).unwrap(); + let mut eth_address = [0u8; 20]; + eth_address.copy_from_slice(ð_address_vec[..]); + + let aurora_eth_address = + Address::decode("096DE9C2B8A5B8c22cEe3289B101f6960d68E51E".to_string()).unwrap(); + assert_eq!(eth_address, aurora_eth_address.as_bytes()); + + let serialized_addr = eth_address.try_to_vec().unwrap(); + let aurora_serialized_addr = aurora_eth_address.try_to_vec().unwrap(); + + assert_eq!(serialized_addr.len(), 20); + assert_eq!(aurora_serialized_addr.len(), 20); + assert_eq!(serialized_addr, aurora_serialized_addr); + + // Used serialized data from `RawAddress` + let addr = Address::try_from_slice(&serialized_addr).unwrap(); + assert_eq!( + addr.encode(), + "096DE9C2B8A5B8c22cEe3289B101f6960d68E51E".to_lowercase() + ); + } + #[test] fn test_wrong_address_19() { let serialized_addr = [0u8; 19]; diff --git a/engine/src/transaction/eip_1559.rs b/engine/src/transaction/eip_1559.rs index f34079e0c..e264a662d 100644 --- a/engine/src/transaction/eip_1559.rs +++ b/engine/src/transaction/eip_1559.rs @@ -1,5 +1,5 @@ use crate::prelude::precompiles::secp256k1::ecrecover; -use crate::prelude::{Address, Vec, Wei, H160, U256}; +use crate::prelude::{Address, Vec, Wei, U256}; use crate::transaction::eip_2930::AccessTuple; use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream}; @@ -69,7 +69,7 @@ pub struct SignedTransaction1559 { } impl SignedTransaction1559 { - pub fn sender(&self) -> Option { + pub fn sender(&self) -> Option
{ let mut rlp_stream = RlpStream::new(); rlp_stream.append(&TYPE_BYTE); self.transaction.rlp_append_unsigned(&mut rlp_stream); @@ -78,7 +78,7 @@ impl SignedTransaction1559 { message_hash, &super::vrs_to_arr(self.parity, self.r, self.s), ) - .map(|v| H160::from_slice(v.as_bytes())) + .map(|v| Address::from_slice(v.as_bytes())) .ok() } } diff --git a/engine/src/transaction/mod.rs b/engine/src/transaction/mod.rs index 0216bf0db..347c3e780 100644 --- a/engine/src/transaction/mod.rs +++ b/engine/src/transaction/mod.rs @@ -102,7 +102,7 @@ impl From for NormalizedEthTransaction { access_list: tx.transaction.access_list, }, Eip1559(tx) => Self { - address: tx.sender().map(|v| Address::from_slice(v.as_bytes())), + address: tx.sender(), chain_id: Some(tx.transaction.chain_id), nonce: tx.transaction.nonce, gas_limit: tx.transaction.gas_limit, From 2c50149ecd02915c72096d51554a7c4f4b2eaf44 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Mon, 20 Dec 2021 20:06:46 +0200 Subject: [PATCH 19/26] Update engine/src/engine.rs Co-authored-by: Michael Birch --- engine/src/engine.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/engine.rs b/engine/src/engine.rs index 8b105005d..020d3d1af 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -542,7 +542,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { ) } CallArgs::V1(call_args) => { - let contract = ADDRESS(call_args.contract.raw()); + let contract = call_args.contract; let value = Wei::zero(); let input = call_args.input; self.call( From 617bfbe06f9c7caad1cf28f005d34606a2dde45b Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Mon, 20 Dec 2021 21:34:43 +0200 Subject: [PATCH 20/26] Changed method from_array --- engine-precompiles/src/native.rs | 6 +++-- engine-precompiles/src/secp256k1.rs | 4 ++-- engine-sdk/src/lib.rs | 2 +- engine-sdk/src/types.rs | 2 +- .../src/relayer_db/types.rs | 4 ++-- engine-tests/src/test_utils/mod.rs | 6 ++--- .../test_utils/one_inch/liquidity_protocol.rs | 6 ++--- engine-tests/src/test_utils/self_destruct.rs | 2 +- engine-tests/src/tests/contract_call.rs | 2 +- engine-tests/src/tests/erc20_connector.rs | 6 ++--- engine-tests/src/tests/eth_connector.rs | 11 +++------ engine-tests/src/tests/meta_parsing.rs | 6 ++--- engine-tests/src/tests/sanity.rs | 6 ++--- engine-tests/src/tests/standalone/sanity.rs | 2 +- engine-tests/src/tests/standalone/sync.rs | 4 ++-- engine-tests/src/tests/standalone/tracing.rs | 8 +++---- engine-tests/src/tests/uniswap.rs | 2 +- engine-types/src/types/address.rs | 23 +++++++++++-------- engine-types/src/types/mod.rs | 2 +- engine/src/deposit_event.rs | 4 ++-- engine/src/engine.rs | 13 ++++++----- engine/src/lib.rs | 10 ++++---- engine/src/meta_parsing.rs | 2 +- engine/src/parameters.rs | 8 +++---- engine/src/transaction/eip_1559.rs | 1 - engine/src/transaction/legacy.rs | 2 +- 26 files changed, 73 insertions(+), 71 deletions(-) diff --git a/engine-precompiles/src/native.rs b/engine-precompiles/src/native.rs index d4dedd224..2b23d4dba 100644 --- a/engine-precompiles/src/native.rs +++ b/engine-precompiles/src/native.rs @@ -255,7 +255,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"))] @@ -538,7 +538,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 = Address::from_slice(input); + let recipient_address = Address::try_from_slice(input).map_err(|_| { + ExitError::Other(crate::prelude::Cow::from("ERR_WRONG_ADDRESS")) + })?; ( nep141_address, diff --git a/engine-precompiles/src/secp256k1.rs b/engine-precompiles/src/secp256k1.rs index a41665bb9..9cb2a4555 100644 --- a/engine-precompiles/src/secp256k1.rs +++ b/engine-precompiles/src/secp256k1.rs @@ -44,7 +44,7 @@ fn internal_impl(hash: H256, signature: &[u8]) -> Result { 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 Ok(Address::from_array(&r[12..])); } } @@ -132,7 +132,7 @@ mod tests { &hex::decode("b9f0bb08640d3c1c00761cdd0121209268f6fd3816bc98b9e6f3cc77bf82b69812ac7a61788a0fdc0e19180f14c945a8e1088a27d92a74dce81c0981fb6447441b") .unwrap(); let signer = - Address::from_slice(&hex::decode("1563915e194D8CfBA1943570603F7606A3115508").unwrap()); + Address::from_array(&hex::decode("1563915e194D8CfBA1943570603F7606A3115508").unwrap()); assert!(ecverify(hash, &signature, signer)); } diff --git a/engine-sdk/src/lib.rs b/engine-sdk/src/lib.rs index e4d256cc5..ead525f94 100644 --- a/engine-sdk/src/lib.rs +++ b/engine-sdk/src/lib.rs @@ -97,7 +97,7 @@ pub fn ecrecover(hash: H256, signature: &[u8]) -> Result 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) } diff --git a/engine-sdk/src/types.rs b/engine-sdk/src/types.rs index ce595ea69..571019922 100644 --- a/engine-sdk/src/types.rs +++ b/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")] diff --git a/engine-standalone-storage/src/relayer_db/types.rs b/engine-standalone-storage/src/relayer_db/types.rs index 223f6cc73..254ee0a26 100644 --- a/engine-standalone-storage/src/relayer_db/types.rs +++ b/engine-standalone-storage/src/relayer_db/types.rs @@ -178,7 +178,7 @@ impl From for TransactionRow { near_hash, near_receipt_hash, from, - to: to.map(Address::from_slice), + to: to.map(|arr| Address::try_from_slice(arr).unwrap()), nonce, gas_price, gas_limit, @@ -226,7 +226,7 @@ fn get_hash(row: &postgres::Row, field: &str) -> H256 { fn get_address(row: &postgres::Row, field: &str) -> Address { let value: &[u8] = row.get(field); - Address::from_slice(value) + Address::try_from_slice(value).unwrap() } fn get_timestamp(row: &postgres::Row, field: &str) -> Option { diff --git a/engine-tests/src/test_utils/mod.rs b/engine-tests/src/test_utils/mod.rs index 3c836fafe..5383ed47f 100644 --- a/engine-tests/src/test_utils/mod.rs +++ b/engine-tests/src/test_utils/mod.rs @@ -376,7 +376,7 @@ impl AuroraRunner { assert!(maybe_err.is_none()); let submit_result = SubmitResult::try_from_slice(&output.unwrap().return_data.as_value().unwrap()).unwrap(); - let address = Address::from_slice(&unwrap_success(submit_result)); + let address = Address::from_array(&unwrap_success(submit_result)); let contract_constructor: ContractConstructor = contract_constructor.into(); DeployedContract { abi: contract_constructor.abi, @@ -733,7 +733,7 @@ pub(crate) fn sign_eip_1559_transaction( pub(crate) fn address_from_secret_key(sk: &SecretKey) -> Address { let pk = PublicKey::from_secret_key(sk); let hash = sdk::keccak(&pk.serialize()[1..]); - Address::from_slice(&hash[12..]) + Address::from_array(&hash[12..]) } pub(crate) fn parse_eth_gas(output: &VMOutcome) -> u64 { @@ -762,7 +762,7 @@ pub(crate) fn address_from_hex(address: &str) -> Address { hex::decode(address).unwrap() }; - Address::from_slice(&bytes) + Address::from_array(&bytes) } pub(crate) fn as_account_id(account_id: &str) -> near_primitives_core::types::AccountId { diff --git a/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs b/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs index 86d3210ae..e30195fb3 100644 --- a/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs +++ b/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs @@ -38,7 +38,7 @@ impl<'a> Helper<'a> { }) .unwrap(); - let deployer_address = Address::from_slice(test_utils::unwrap_success_slice(&result)); + let deployer_address = Address::from_array(test_utils::unwrap_success_slice(&result)); let deployer = PoolDeployer(solidity::DeployedContract { abi, address: deployer_address, @@ -71,7 +71,7 @@ impl<'a> Helper<'a> { }) .unwrap(); - let address = Address::from_slice(test_utils::unwrap_success_slice(&result)); + let address = Address::from_array(test_utils::unwrap_success_slice(&result)); let pool_factory = PoolFactory(constructor.deployed_at(address)); (result, profile, pool_factory) @@ -102,7 +102,7 @@ impl<'a> Helper<'a> { }) .unwrap(); - let address = Address::from_slice(&test_utils::unwrap_success_slice(&result)[12..32]); + let address = Address::from_array(&test_utils::unwrap_success_slice(&result)[12..32]); let pool = Pool(constructor.deployed_at(address)); (result, profile, pool) diff --git a/engine-tests/src/test_utils/self_destruct.rs b/engine-tests/src/test_utils/self_destruct.rs index a4acb6947..9c499d2f2 100644 --- a/engine-tests/src/test_utils/self_destruct.rs +++ b/engine-tests/src/test_utils/self_destruct.rs @@ -75,7 +75,7 @@ impl SelfDestructFactory { let result = runner.submit_transaction(&signer.secret_key, tx).unwrap(); let result = test_utils::unwrap_success(result); - Address::from_slice(&result[12..]) + Address::from_array(&result[12..]) } } diff --git a/engine-tests/src/tests/contract_call.rs b/engine-tests/src/tests/contract_call.rs index 9bf1abc64..dd70308f7 100644 --- a/engine-tests/src/tests/contract_call.rs +++ b/engine-tests/src/tests/contract_call.rs @@ -85,7 +85,7 @@ fn withdraw() { } else { // transferred to 0xE0f5206BBD039e7b0592d8918820024e2a7437b9 (defined in Tester.sol) let address = hex::decode("E0f5206BBD039e7b0592d8918820024e2a7437b9").unwrap(); - let address = Address::from_slice(&address); + let address = Address::from_array(&address); ethabi::LogParam { name: "dest".to_string(), value: ethabi::Token::Address(address.raw()), diff --git a/engine-tests/src/tests/erc20_connector.rs b/engine-tests/src/tests/erc20_connector.rs index 08778bebd..876722186 100644 --- a/engine-tests/src/tests/erc20_connector.rs +++ b/engine-tests/src/tests/erc20_connector.rs @@ -118,7 +118,7 @@ impl test_utils::AuroraRunner { .unwrap() .try_into() .unwrap(); - Address::from_slice(&raw_address) + Address::from_array(&raw_address) } pub fn create_account(&mut self) -> EthereumAddress { @@ -628,7 +628,7 @@ mod sim_tests { let constructor = TesterConstructor::load(); let deploy_data = constructor.deploy(0, Address::zero()).data; let submit_result: SubmitResult = aurora.call("deploy_code", &deploy_data).unwrap_borsh(); - let tester_address = Address::from_slice(&test_utils::unwrap_success(submit_result)); + let tester_address = Address::from_array(&test_utils::unwrap_success(submit_result)); TestExitToNearEthContext { signer, @@ -809,7 +809,7 @@ mod sim_tests { }; let result = aurora.call("deploy_erc20_token", &args.try_to_vec().unwrap()); let addr_bytes: Vec = result.unwrap_borsh(); - let address = Address::from_slice(&addr_bytes); + let address = Address::from_array(&addr_bytes); let abi = ERC20Constructor::load().0.abi; ERC20(crate::test_utils::solidity::DeployedContract { abi, address }) } diff --git a/engine-tests/src/tests/eth_connector.rs b/engine-tests/src/tests/eth_connector.rs index 5a9adf8b1..d5cab407f 100644 --- a/engine-tests/src/tests/eth_connector.rs +++ b/engine-tests/src/tests/eth_connector.rs @@ -99,9 +99,7 @@ fn init_contract( } fn validate_eth_address(address: &str) -> Address { - let data = hex::decode(address).unwrap(); - assert_eq!(data.len(), 20); - Address::from_slice(&data) + Address::decode(address.to_string()).unwrap() } fn call_deposit_eth_to_near( @@ -599,11 +597,8 @@ fn test_deposit_with_0x_prefix() { use aurora_engine::deposit_event::TokenMessageData; let (master_account, contract) = init(CUSTODIAN_ADDRESS); - let eth_custodian_address: Address = { - let bytes = hex::decode(CUSTODIAN_ADDRESS).unwrap(); - Address::from_slice(&bytes) - }; - let recipient_address = Address::from_slice(&[10u8; 20]); + let eth_custodian_address: Address = Address::decode(CUSTODIAN_ADDRESS.to_string()).unwrap(); + let recipient_address = Address::from_array([10u8; 20]); let deposit_amount = 17; let recipient_address_encoded = recipient_address.encode(); diff --git a/engine-tests/src/tests/meta_parsing.rs b/engine-tests/src/tests/meta_parsing.rs index 9b01b0bbc..e0c6b69dc 100644 --- a/engine-tests/src/tests/meta_parsing.rs +++ b/engine-tests/src/tests/meta_parsing.rs @@ -65,7 +65,7 @@ fn public_key_to_address(public_key: PublicKey) -> Address { PublicKey::SECP256K1(pubkey) => { let pk: [u8; 64] = pubkey.into(); let bytes = keccak(&pk.to_vec()); - Address::from_slice(&bytes[12..]) + Address::from_array(&bytes[12..]) } } } @@ -82,7 +82,7 @@ fn test_meta_parsing() { chain_id, U256::from(14), Wei::new_u64(6), - Address::from_slice(&[0u8; 20]), + Address::from_array(&[0u8; 20]), signer_addr.clone(), Wei::zero(), "adopt(uint256 petId)", @@ -102,7 +102,7 @@ fn test_meta_parsing() { chain_id, U256::from(14), Wei::new_u64(6), - Address::from_slice(&[0u8; 20]), + Address::from_array(&[0u8; 20]), signer_addr.clone(), Wei::zero(), "adopt(uint256 petId,PetObj petObject)PetObj(string petName,address owner)", diff --git a/engine-tests/src/tests/sanity.rs b/engine-tests/src/tests/sanity.rs index 45d81c054..44742e450 100644 --- a/engine-tests/src/tests/sanity.rs +++ b/engine-tests/src/tests/sanity.rs @@ -57,7 +57,7 @@ fn test_deploy_contract() { test_utils::create_deploy_transaction(code.clone(), nonce) }) .unwrap(); - let address = Address::from_slice(test_utils::unwrap_success_slice(&result)); + let address = Address::from_array(test_utils::unwrap_success_slice(&result)); // Confirm the code stored at that address is equal to the input code. let stored_code = runner.get_code(address); @@ -204,7 +204,7 @@ fn test_override_state() { } }) .unwrap(); - let address = Address::from_slice(&test_utils::unwrap_success(result)); + let address = Address::from_array(&test_utils::unwrap_success(result)); let contract = contract.deployed_at(address); // define functions to interact with the contract @@ -217,7 +217,7 @@ fn test_override_state() { .unwrap(); match result { crate::prelude::parameters::TransactionStatus::Succeed(bytes) => { - Address::from_slice(&bytes[12..32]) + Address::from_array(&bytes[12..32]) } _ => panic!("tx failed"), } diff --git a/engine-tests/src/tests/standalone/sanity.rs b/engine-tests/src/tests/standalone/sanity.rs index 3ef462648..6b05a6569 100644 --- a/engine-tests/src/tests/standalone/sanity.rs +++ b/engine-tests/src/tests/standalone/sanity.rs @@ -50,7 +50,7 @@ fn test_deploy_code() { // execution was successful let contract_address = match result.unwrap().status { - aurora_engine::parameters::TransactionStatus::Succeed(bytes) => Address::from_slice(&bytes), + aurora_engine::parameters::TransactionStatus::Succeed(bytes) => Address::from_array(&bytes), other => panic!("Unexpected status: {:?}", other), }; diff --git a/engine-tests/src/tests/standalone/sync.rs b/engine-tests/src/tests/standalone/sync.rs index 884245753..11ea330c6 100644 --- a/engine-tests/src/tests/standalone/sync.rs +++ b/engine-tests/src/tests/standalone/sync.rs @@ -101,7 +101,7 @@ fn test_consume_deploy_message() { for (key, value) in diff.iter() { match value.value() { Some(bytes) if bytes == code.as_slice() => { - deployed_address = Address::from_slice(&key[2..22]); + deployed_address = Address::from_array(&key[2..22]); break; } _ => continue, @@ -180,7 +180,7 @@ fn test_consume_deploy_erc20_message() { let deployed_token = test_utils::erc20::ERC20( test_utils::erc20::ERC20Constructor::load() .0 - .deployed_at(Address::from_slice(&erc20_address)), + .deployed_at(Address::from_array(&erc20_address)), ); let signer = test_utils::Signer::random(); let tx = deployed_token.balance_of(dest_address, signer.nonce.into()); diff --git a/engine-tests/src/tests/standalone/tracing.rs b/engine-tests/src/tests/standalone/tracing.rs index 69b06adbd..9bc6e28b9 100644 --- a/engine-tests/src/tests/standalone/tracing.rs +++ b/engine-tests/src/tests/standalone/tracing.rs @@ -21,9 +21,9 @@ fn test_evm_tracing_with_storage() { let mut signer = test_utils::Signer::random(); let signer_address = test_utils::address_from_secret_key(&signer.secret_key); let sender_address = - Address::from_slice(&hex::decode("304ee8ae14eceb3a544dff53a27eb1bb1aaa471f").unwrap()); + Address::from_array(&hex::decode("304ee8ae14eceb3a544dff53a27eb1bb1aaa471f").unwrap()); let weth_address = - Address::from_slice(&hex::decode("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap()); + Address::from_array(&hex::decode("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap()); // Initialize EVM runner.init_evm_with_chain_id(1); @@ -35,7 +35,7 @@ fn test_evm_tracing_with_storage() { let result = runner .submit_transaction(&signer.secret_key, deploy_tx) .unwrap(); - let contract_address = Address::from_slice(test_utils::unwrap_success_slice(&result)); + let contract_address = Address::from_array(test_utils::unwrap_success_slice(&result)); // Move it over to the same address as it exists on mainnet let mut diff = engine_standalone_storage::Diff::default(); @@ -140,7 +140,7 @@ fn test_evm_tracing() { let result = runner .submit_transaction(&signer.secret_key, deploy_tx) .unwrap(); - let contract_address = Address::from_slice(test_utils::unwrap_success_slice(&result)); + let contract_address = Address::from_array(test_utils::unwrap_success_slice(&result)); // Interact with contract (and trace execution) let tx = aurora_engine::transaction::legacy::TransactionLegacy { diff --git a/engine-tests/src/tests/uniswap.rs b/engine-tests/src/tests/uniswap.rs index 8b087bf84..4044f9b71 100644 --- a/engine-tests/src/tests/uniswap.rs +++ b/engine-tests/src/tests/uniswap.rs @@ -148,7 +148,7 @@ impl UniswapTestContext { .unwrap(); assert!(result.status.is_ok(), "Failed to create pool"); - let address = Address::from_slice(&test_utils::unwrap_success(result)[12..]); + let address = Address::from_array(&test_utils::unwrap_success(result)[12..]); let pool = Pool::from_address(address); // 2^96 corresponds to a price ratio of 1 diff --git a/engine-types/src/types/address.rs b/engine-types/src/types/address.rs index d91105433..fa331eb11 100755 --- a/engine-types/src/types/address.rs +++ b/engine-types/src/types/address.rs @@ -28,12 +28,12 @@ impl Address { } pub fn decode(address: String) -> Result { - let data = hex::decode(address).map_err(|_| error::AddressError::FailedDecodeHex)?; - if data.len() != 20 { + if address.len() != 40 { return Err(error::AddressError::IncorrectLength); } let mut result = [0u8; 20]; - result.copy_from_slice(&data); + hex::decode_to_slice(address, &mut result) + .map_err(|_| error::AddressError::FailedDecodeHex)?; Ok(Address::new(H160(result))) } @@ -41,8 +41,15 @@ impl Address { self.0.as_bytes() } - pub fn from_slice(raw_addr: &[u8]) -> Self { - Self::new(H160::from_slice(raw_addr)) + pub fn try_from_slice(raw_addr: &[u8]) -> Result { + if raw_addr.len() != 20 { + return Err(error::AddressError::IncorrectLength); + } + Ok(Self::new(H160::from_slice(raw_addr))) + } + + pub fn from_array(array: [u8; 20]) -> Self { + Self(H160(array)) } pub const fn zero() -> Self { @@ -138,10 +145,8 @@ mod tests { fn test_wrong_address_19() { let serialized_addr = [0u8; 19]; let addr = Address::try_from_slice(&serialized_addr); - assert_eq!( - addr.unwrap_err().to_string(), - error::AddressError::IncorrectLength.to_string() - ); + let err = addr.unwrap_err(); + matches!(err, error::AddressError::IncorrectLength); } } diff --git a/engine-types/src/types/mod.rs b/engine-types/src/types/mod.rs index afe3b6c70..f33b8c7d9 100644 --- a/engine-types/src/types/mod.rs +++ b/engine-types/src/types/mod.rs @@ -13,7 +13,7 @@ pub use gas::*; pub use wei::*; pub type RawU256 = [u8; 32]; -/// Big-endian large integer type. +// Big-endian large integer type. pub type RawH256 = [u8; 32]; // Unformatted binary data of fixed length. pub type StorageUsage = u64; diff --git a/engine/src/deposit_event.rs b/engine/src/deposit_event.rs index c86cd872d..96d2195d6 100644 --- a/engine/src/deposit_event.rs +++ b/engine/src/deposit_event.rs @@ -59,7 +59,7 @@ impl FtTransferMessageData { let fee: Fee = fee_u128.into(); // Get recipient Eth address from message slice - let recipient = Address::from_slice(&msg[32..52]); + let recipient = Address::try_from_slice(&msg[32..52]).unwrap(); Ok(FtTransferMessageData { relayer: account_id, @@ -264,7 +264,7 @@ impl DepositedEvent { .into_address() .ok_or(error::ParseError::InvalidSender)? .0; - let sender = Address::from_slice(&raw_sender); + let sender = Address::from_array(raw_sender); // parse_event_message let event_message_data: String = event.log.params[1].value.clone().to_string(); diff --git a/engine/src/engine.rs b/engine/src/engine.rs index 8b105005d..562aa9622 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -239,7 +239,9 @@ impl TryFrom> for ERC20Address { fn try_from(bytes: Vec) -> Result { if bytes.len() == 20 { - Ok(Self(Address::from_slice(&bytes))) + Ok(Self( + Address::try_from_slice(&bytes).map_err(|_| AddressParseError)?, + )) } else { Err(AddressParseError) } @@ -646,9 +648,8 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { pub fn get_relayer(&self, account_id: &[u8]) -> Option
{ let key = Self::relayer_key(account_id); - self.io - .read_storage(&key) - .map(|v| Address::from_slice(&v.to_vec())) + let raw_addr = self.io.read_storage(&key).map(|v| v.to_vec())?; + Address::try_from_slice(&raw_addr[..]).ok() } pub fn register_token( @@ -742,7 +743,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { (recipient, fee) }; - let erc20_token = ADDRESS(H160(unwrap_res_or_finish!( + let erc20_token = Address::from_array(unwrap_res_or_finish!( unwrap_res_or_finish!( get_erc20_from_nep141(&self.io, token), output_on_fail, @@ -752,7 +753,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { .try_into(), output_on_fail, self.io - ))); + )); if fee != U256::from(0) { let relayer_address = unwrap_res_or_finish!( diff --git a/engine/src/lib.rs b/engine/src/lib.rs index 04def7ee4..320a08fdb 100644 --- a/engine/src/lib.rs +++ b/engine/src/lib.rs @@ -309,7 +309,7 @@ mod contract { .sdk_unwrap(); engine.register_relayer( predecessor_account_id.as_bytes(), - Address::from_slice(&relayer_address), + Address::from_array(relayer_address), ); } @@ -474,7 +474,7 @@ mod contract { pub extern "C" fn get_code() { let mut io = Runtime; let address = io.read_input_arr20().sdk_unwrap(); - let code = engine::get_code(&io, &Address::from_slice(&address)); + let code = engine::get_code(&io, &Address::from_array(address)); io.return_output(&code) } @@ -482,7 +482,7 @@ mod contract { pub extern "C" fn get_balance() { let mut io = Runtime; let address = io.read_input_arr20().sdk_unwrap(); - let balance = engine::get_balance(&io, &Address::from_slice(&address)); + let balance = engine::get_balance(&io, &Address::from_array(address)); io.return_output(&balance.to_bytes()) } @@ -490,7 +490,7 @@ mod contract { pub extern "C" fn get_nonce() { let mut io = Runtime; let address = io.read_input_arr20().sdk_unwrap(); - let nonce = engine::get_nonce(&io, &Address::from_slice(&address)); + let nonce = engine::get_nonce(&io, &Address::from_array(address)); io.return_output(&u256_to_arr(&nonce)) } @@ -852,7 +852,7 @@ mod contract { let mut io = Runtime; let args: ([u8; 20], u64, u64) = io.read_input_borsh().sdk_expect("ERR_ARGS"); - let address = Address::from_slice(&args.0); + let address = Address::from_array(args.0); let nonce = U256::from(args.1); let balance = NEP141Wei::new(args.2 as u128); let current_account_id = io.current_account_id(); diff --git a/engine/src/meta_parsing.rs b/engine/src/meta_parsing.rs index 6030bf3ef..dc5e3fc9f 100644 --- a/engine/src/meta_parsing.rs +++ b/engine/src/meta_parsing.rs @@ -370,7 +370,7 @@ fn eip_712_hash_argument( Ok(u256_to_arr(&U256::from_big_endian(b)).to_vec()) }), ArgType::Address => { - eip_712_rlp_value(value, |b| Ok(encode_address(Address::from_slice(b)))) + eip_712_rlp_value(value, |b| Ok(encode_address(Address::from_array(b)))) } ArgType::Array { inner, .. } => eip_712_rlp_list(value, |l| { let mut r = vec![]; diff --git a/engine/src/parameters.rs b/engine/src/parameters.rs index df33df488..8bb400659 100644 --- a/engine/src/parameters.rs +++ b/engine/src/parameters.rs @@ -539,8 +539,8 @@ mod tests { #[test] fn test_roundtrip_view_call() { let x = ViewCallArgs { - sender: Address::from_slice(&[1; 20]), - address: Address::from_slice(&[2; 20]), + sender: Address::from_array([1; 20]), + address: Address::from_array([2; 20]), amount: [3; 32], input: vec![1, 2, 3], }; @@ -552,12 +552,12 @@ mod tests { #[test] fn test_call_args_deserialize() { let new_input = FunctionCallArgsV2 { - contract: Address::from_slice(&[0u8; 20]), + contract: Address::from_array([0u8; 20]), value: WeiU256::default(), input: Vec::new(), }; let legacy_input = FunctionCallArgsV1 { - contract: Address::from_slice(&[0u8; 20]), + contract: Address::from_array([0u8; 20]), input: Vec::new(), }; diff --git a/engine/src/transaction/eip_1559.rs b/engine/src/transaction/eip_1559.rs index e264a662d..74bac5d0f 100644 --- a/engine/src/transaction/eip_1559.rs +++ b/engine/src/transaction/eip_1559.rs @@ -78,7 +78,6 @@ impl SignedTransaction1559 { message_hash, &super::vrs_to_arr(self.parity, self.r, self.s), ) - .map(|v| Address::from_slice(v.as_bytes())) .ok() } } diff --git a/engine/src/transaction/legacy.rs b/engine/src/transaction/legacy.rs index ef304874e..96fb7aa06 100644 --- a/engine/src/transaction/legacy.rs +++ b/engine/src/transaction/legacy.rs @@ -199,6 +199,6 @@ mod tests { fn address_from_arr(arr: &[u8]) -> Address { assert_eq!(arr.len(), 20); - Address::from_slice(arr) + Address::from_array(arr) } } From 29b5ed0ca856ff5ff2cb5ac27b5aa9e26291097c Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Mon, 20 Dec 2021 22:50:45 +0200 Subject: [PATCH 21/26] Changed Address from_array --- engine-precompiles/src/secp256k1.rs | 9 ++++++--- engine-tests/src/test_utils/mod.rs | 6 +++--- .../src/test_utils/one_inch/liquidity_protocol.rs | 8 +++++--- engine-tests/src/test_utils/self_destruct.rs | 2 +- engine-tests/src/tests/contract_call.rs | 2 +- engine-tests/src/tests/erc20_connector.rs | 7 ++++--- engine-tests/src/tests/meta_parsing.rs | 6 +++--- engine-tests/src/tests/sanity.rs | 6 +++--- engine-tests/src/tests/standalone/sanity.rs | 4 +++- engine-tests/src/tests/standalone/sync.rs | 4 ++-- engine-tests/src/tests/standalone/tracing.rs | 10 ++++++---- engine-tests/src/tests/uniswap.rs | 2 +- engine/src/meta_parsing.rs | 8 +++++--- engine/src/transaction/legacy.rs | 2 +- 14 files changed, 44 insertions(+), 32 deletions(-) diff --git a/engine-precompiles/src/secp256k1.rs b/engine-precompiles/src/secp256k1.rs index 9cb2a4555..3ef3cd7e8 100644 --- a/engine-precompiles/src/secp256k1.rs +++ b/engine-precompiles/src/secp256k1.rs @@ -44,7 +44,8 @@ fn internal_impl(hash: H256, signature: &[u8]) -> Result { 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_array(&r[12..])); + return Address::try_from_slice(&r[12..]) + .map_err(|_| ExitError::Other(Borrowed("ERR_INCORRECT_ADDRESS"))); } } @@ -131,8 +132,10 @@ mod tests { let signature = &hex::decode("b9f0bb08640d3c1c00761cdd0121209268f6fd3816bc98b9e6f3cc77bf82b69812ac7a61788a0fdc0e19180f14c945a8e1088a27d92a74dce81c0981fb6447441b") .unwrap(); - let signer = - Address::from_array(&hex::decode("1563915e194D8CfBA1943570603F7606A3115508").unwrap()); + let signer = Address::try_from_slice( + &hex::decode("1563915e194D8CfBA1943570603F7606A3115508").unwrap(), + ) + .unwrap(); assert!(ecverify(hash, &signature, signer)); } diff --git a/engine-tests/src/test_utils/mod.rs b/engine-tests/src/test_utils/mod.rs index 5383ed47f..2b97db496 100644 --- a/engine-tests/src/test_utils/mod.rs +++ b/engine-tests/src/test_utils/mod.rs @@ -376,7 +376,7 @@ impl AuroraRunner { assert!(maybe_err.is_none()); let submit_result = SubmitResult::try_from_slice(&output.unwrap().return_data.as_value().unwrap()).unwrap(); - let address = Address::from_array(&unwrap_success(submit_result)); + let address = Address::try_from_slice(&unwrap_success(submit_result)).unwrap(); let contract_constructor: ContractConstructor = contract_constructor.into(); DeployedContract { abi: contract_constructor.abi, @@ -733,7 +733,7 @@ pub(crate) fn sign_eip_1559_transaction( pub(crate) fn address_from_secret_key(sk: &SecretKey) -> Address { let pk = PublicKey::from_secret_key(sk); let hash = sdk::keccak(&pk.serialize()[1..]); - Address::from_array(&hash[12..]) + Address::try_from_slice(&hash[12..]).unwrap() } pub(crate) fn parse_eth_gas(output: &VMOutcome) -> u64 { @@ -762,7 +762,7 @@ pub(crate) fn address_from_hex(address: &str) -> Address { hex::decode(address).unwrap() }; - Address::from_array(&bytes) + Address::try_from_slice(&bytes).unwrap() } pub(crate) fn as_account_id(account_id: &str) -> near_primitives_core::types::AccountId { diff --git a/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs b/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs index e30195fb3..ed2f84833 100644 --- a/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs +++ b/engine-tests/src/test_utils/one_inch/liquidity_protocol.rs @@ -38,7 +38,8 @@ impl<'a> Helper<'a> { }) .unwrap(); - let deployer_address = Address::from_array(test_utils::unwrap_success_slice(&result)); + let deployer_address = + Address::try_from_slice(test_utils::unwrap_success_slice(&result)).unwrap(); let deployer = PoolDeployer(solidity::DeployedContract { abi, address: deployer_address, @@ -71,7 +72,7 @@ impl<'a> Helper<'a> { }) .unwrap(); - let address = Address::from_array(test_utils::unwrap_success_slice(&result)); + let address = Address::try_from_slice(test_utils::unwrap_success_slice(&result)).unwrap(); let pool_factory = PoolFactory(constructor.deployed_at(address)); (result, profile, pool_factory) @@ -102,7 +103,8 @@ impl<'a> Helper<'a> { }) .unwrap(); - let address = Address::from_array(&test_utils::unwrap_success_slice(&result)[12..32]); + let address = + Address::try_from_slice(&test_utils::unwrap_success_slice(&result)[12..32]).unwrap(); let pool = Pool(constructor.deployed_at(address)); (result, profile, pool) diff --git a/engine-tests/src/test_utils/self_destruct.rs b/engine-tests/src/test_utils/self_destruct.rs index 9c499d2f2..1d62e2fdd 100644 --- a/engine-tests/src/test_utils/self_destruct.rs +++ b/engine-tests/src/test_utils/self_destruct.rs @@ -75,7 +75,7 @@ impl SelfDestructFactory { let result = runner.submit_transaction(&signer.secret_key, tx).unwrap(); let result = test_utils::unwrap_success(result); - Address::from_array(&result[12..]) + Address::try_from_slice(&result[12..]).unwrap() } } diff --git a/engine-tests/src/tests/contract_call.rs b/engine-tests/src/tests/contract_call.rs index dd70308f7..83c219f10 100644 --- a/engine-tests/src/tests/contract_call.rs +++ b/engine-tests/src/tests/contract_call.rs @@ -85,7 +85,7 @@ fn withdraw() { } else { // transferred to 0xE0f5206BBD039e7b0592d8918820024e2a7437b9 (defined in Tester.sol) let address = hex::decode("E0f5206BBD039e7b0592d8918820024e2a7437b9").unwrap(); - let address = Address::from_array(&address); + let address = Address::try_from_slice(&address).unwrap(); ethabi::LogParam { name: "dest".to_string(), value: ethabi::Token::Address(address.raw()), diff --git a/engine-tests/src/tests/erc20_connector.rs b/engine-tests/src/tests/erc20_connector.rs index 876722186..8212de2ff 100644 --- a/engine-tests/src/tests/erc20_connector.rs +++ b/engine-tests/src/tests/erc20_connector.rs @@ -118,7 +118,7 @@ impl test_utils::AuroraRunner { .unwrap() .try_into() .unwrap(); - Address::from_array(&raw_address) + Address::try_from_slice(&raw_address).unwrap() } pub fn create_account(&mut self) -> EthereumAddress { @@ -628,7 +628,8 @@ mod sim_tests { let constructor = TesterConstructor::load(); let deploy_data = constructor.deploy(0, Address::zero()).data; let submit_result: SubmitResult = aurora.call("deploy_code", &deploy_data).unwrap_borsh(); - let tester_address = Address::from_array(&test_utils::unwrap_success(submit_result)); + let tester_address = + Address::try_from_slice(&test_utils::unwrap_success(submit_result)).unwrap(); TestExitToNearEthContext { signer, @@ -809,7 +810,7 @@ mod sim_tests { }; let result = aurora.call("deploy_erc20_token", &args.try_to_vec().unwrap()); let addr_bytes: Vec = result.unwrap_borsh(); - let address = Address::from_array(&addr_bytes); + let address = Address::try_from_slice(&addr_bytes).unwrap(); let abi = ERC20Constructor::load().0.abi; ERC20(crate::test_utils::solidity::DeployedContract { abi, address }) } diff --git a/engine-tests/src/tests/meta_parsing.rs b/engine-tests/src/tests/meta_parsing.rs index e0c6b69dc..2c6689018 100644 --- a/engine-tests/src/tests/meta_parsing.rs +++ b/engine-tests/src/tests/meta_parsing.rs @@ -65,7 +65,7 @@ fn public_key_to_address(public_key: PublicKey) -> Address { PublicKey::SECP256K1(pubkey) => { let pk: [u8; 64] = pubkey.into(); let bytes = keccak(&pk.to_vec()); - Address::from_array(&bytes[12..]) + Address::try_from_slice(&bytes[12..]).unwrap() } } } @@ -82,7 +82,7 @@ fn test_meta_parsing() { chain_id, U256::from(14), Wei::new_u64(6), - Address::from_array(&[0u8; 20]), + Address::try_from_slice(&[0u8; 20]).unwrap(), signer_addr.clone(), Wei::zero(), "adopt(uint256 petId)", @@ -102,7 +102,7 @@ fn test_meta_parsing() { chain_id, U256::from(14), Wei::new_u64(6), - Address::from_array(&[0u8; 20]), + Address::try_from_slice(&[0u8; 20]).unwrap(), signer_addr.clone(), Wei::zero(), "adopt(uint256 petId,PetObj petObject)PetObj(string petName,address owner)", diff --git a/engine-tests/src/tests/sanity.rs b/engine-tests/src/tests/sanity.rs index 44742e450..6126aeab1 100644 --- a/engine-tests/src/tests/sanity.rs +++ b/engine-tests/src/tests/sanity.rs @@ -57,7 +57,7 @@ fn test_deploy_contract() { test_utils::create_deploy_transaction(code.clone(), nonce) }) .unwrap(); - let address = Address::from_array(test_utils::unwrap_success_slice(&result)); + let address = Address::try_from_slice(test_utils::unwrap_success_slice(&result)).unwrap(); // Confirm the code stored at that address is equal to the input code. let stored_code = runner.get_code(address); @@ -204,7 +204,7 @@ fn test_override_state() { } }) .unwrap(); - let address = Address::from_array(&test_utils::unwrap_success(result)); + let address = Address::try_from_slice(&test_utils::unwrap_success(result)).unwrap(); let contract = contract.deployed_at(address); // define functions to interact with the contract @@ -217,7 +217,7 @@ fn test_override_state() { .unwrap(); match result { crate::prelude::parameters::TransactionStatus::Succeed(bytes) => { - Address::from_array(&bytes[12..32]) + Address::try_from_slice(&bytes[12..32]).unwrap() } _ => panic!("tx failed"), } diff --git a/engine-tests/src/tests/standalone/sanity.rs b/engine-tests/src/tests/standalone/sanity.rs index 6b05a6569..ac6c292e3 100644 --- a/engine-tests/src/tests/standalone/sanity.rs +++ b/engine-tests/src/tests/standalone/sanity.rs @@ -50,7 +50,9 @@ fn test_deploy_code() { // execution was successful let contract_address = match result.unwrap().status { - aurora_engine::parameters::TransactionStatus::Succeed(bytes) => Address::from_array(&bytes), + aurora_engine::parameters::TransactionStatus::Succeed(bytes) => { + Address::try_from_slice(&bytes).unwrap() + } other => panic!("Unexpected status: {:?}", other), }; diff --git a/engine-tests/src/tests/standalone/sync.rs b/engine-tests/src/tests/standalone/sync.rs index 11ea330c6..161c941fe 100644 --- a/engine-tests/src/tests/standalone/sync.rs +++ b/engine-tests/src/tests/standalone/sync.rs @@ -101,7 +101,7 @@ fn test_consume_deploy_message() { for (key, value) in diff.iter() { match value.value() { Some(bytes) if bytes == code.as_slice() => { - deployed_address = Address::from_array(&key[2..22]); + deployed_address = Address::try_from_slice(&key[2..22]).unwrap(); break; } _ => continue, @@ -180,7 +180,7 @@ fn test_consume_deploy_erc20_message() { let deployed_token = test_utils::erc20::ERC20( test_utils::erc20::ERC20Constructor::load() .0 - .deployed_at(Address::from_array(&erc20_address)), + .deployed_at(Address::try_from_slice(&erc20_address).unwrap()), ); let signer = test_utils::Signer::random(); let tx = deployed_token.balance_of(dest_address, signer.nonce.into()); diff --git a/engine-tests/src/tests/standalone/tracing.rs b/engine-tests/src/tests/standalone/tracing.rs index 9bc6e28b9..7ff23fabe 100644 --- a/engine-tests/src/tests/standalone/tracing.rs +++ b/engine-tests/src/tests/standalone/tracing.rs @@ -21,9 +21,9 @@ fn test_evm_tracing_with_storage() { let mut signer = test_utils::Signer::random(); let signer_address = test_utils::address_from_secret_key(&signer.secret_key); let sender_address = - Address::from_array(&hex::decode("304ee8ae14eceb3a544dff53a27eb1bb1aaa471f").unwrap()); + Address::decode("304ee8ae14eceb3a544dff53a27eb1bb1aaa471f".to_string()).unwrap(); let weth_address = - Address::from_array(&hex::decode("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap()); + Address::decode("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2".to_string()).unwrap(); // Initialize EVM runner.init_evm_with_chain_id(1); @@ -35,7 +35,8 @@ fn test_evm_tracing_with_storage() { let result = runner .submit_transaction(&signer.secret_key, deploy_tx) .unwrap(); - let contract_address = Address::from_array(test_utils::unwrap_success_slice(&result)); + let contract_address = + Address::try_from_slice(test_utils::unwrap_success_slice(&result)).unwrap(); // Move it over to the same address as it exists on mainnet let mut diff = engine_standalone_storage::Diff::default(); @@ -140,7 +141,8 @@ fn test_evm_tracing() { let result = runner .submit_transaction(&signer.secret_key, deploy_tx) .unwrap(); - let contract_address = Address::from_array(test_utils::unwrap_success_slice(&result)); + let contract_address = + Address::try_from_slice(test_utils::unwrap_success_slice(&result)).unwrap(); // Interact with contract (and trace execution) let tx = aurora_engine::transaction::legacy::TransactionLegacy { diff --git a/engine-tests/src/tests/uniswap.rs b/engine-tests/src/tests/uniswap.rs index 4044f9b71..625b2a5cd 100644 --- a/engine-tests/src/tests/uniswap.rs +++ b/engine-tests/src/tests/uniswap.rs @@ -148,7 +148,7 @@ impl UniswapTestContext { .unwrap(); assert!(result.status.is_ok(), "Failed to create pool"); - let address = Address::from_array(&test_utils::unwrap_success(result)[12..]); + let address = Address::try_from_slice(&test_utils::unwrap_success(result)[12..]).unwrap(); let pool = Pool::from_address(address); // 2^96 corresponds to a price ratio of 1 diff --git a/engine/src/meta_parsing.rs b/engine/src/meta_parsing.rs index dc5e3fc9f..f464f36cc 100644 --- a/engine/src/meta_parsing.rs +++ b/engine/src/meta_parsing.rs @@ -369,9 +369,11 @@ fn eip_712_hash_argument( ArgType::Uint | ArgType::Int | ArgType::Bool => eip_712_rlp_value(value, |b| { Ok(u256_to_arr(&U256::from_big_endian(b)).to_vec()) }), - ArgType::Address => { - eip_712_rlp_value(value, |b| Ok(encode_address(Address::from_array(b)))) - } + ArgType::Address => eip_712_rlp_value(value, |b| { + Ok(encode_address( + Address::try_from_slice(b).map_err(|_| ParsingError::ArgumentParseError)?, + )) + }), ArgType::Array { inner, .. } => eip_712_rlp_list(value, |l| { let mut r = vec![]; for element in l { diff --git a/engine/src/transaction/legacy.rs b/engine/src/transaction/legacy.rs index 96fb7aa06..fcc97aaa3 100644 --- a/engine/src/transaction/legacy.rs +++ b/engine/src/transaction/legacy.rs @@ -199,6 +199,6 @@ mod tests { fn address_from_arr(arr: &[u8]) -> Address { assert_eq!(arr.len(), 20); - Address::from_array(arr) + Address::try_from_slice(arr).unwrap() } } From 8fab0e6390a30ad496b747cb282a7d050e21b7a2 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Tue, 21 Dec 2021 10:17:22 +0200 Subject: [PATCH 22/26] Remove and Rename ADDRESS to Address::new --- engine-precompiles/src/lib.rs | 8 ++++---- engine-precompiles/src/native.rs | 7 ++----- engine-tests/src/tests/sanity.rs | 7 +++---- engine-tests/src/tests/standalone/json_snapshot.rs | 4 ++-- engine-tests/src/tests/standalone/sanity.rs | 4 ++-- engine-tests/src/tests/standalone/sync.rs | 14 +++++++------- engine-tests/src/tests/uniswap.rs | 6 +++--- engine-types/src/types/address.rs | 9 ++------- engine/src/engine.rs | 10 ++++++---- 9 files changed, 31 insertions(+), 38 deletions(-) diff --git a/engine-precompiles/src/lib.rs b/engine-precompiles/src/lib.rs index 43f35d1e4..786b31cc8 100644 --- a/engine-precompiles/src/lib.rs +++ b/engine-precompiles/src/lib.rs @@ -265,7 +265,7 @@ impl Precompiles { 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::types::ADDRESS(H160([ + prelude::types::Address::new(H160([ x_bytes[0], x_bytes[1], x_bytes[2], @@ -332,7 +332,7 @@ const fn make_h256(x: u128, y: u128) -> prelude::H256 { mod tests { use crate::prelude::H160; use crate::{prelude, Byzantium, Istanbul}; - use prelude::types::{Address, ADDRESS}; + use prelude::types::Address; use rand::Rng; #[test] @@ -356,7 +356,7 @@ mod tests { let mut rng = rand::thread_rng(); for _ in 0..u8::MAX { - let address = ADDRESS(H160(rng.gen())); + let address = Address::new(H160(rng.gen())); let (x, y) = split_address(address); assert_eq!(address, super::make_address(x, y)) } @@ -365,7 +365,7 @@ mod tests { fn u8_to_address(x: u8) -> Address { let mut bytes = [0u8; 20]; bytes[19] = x; - ADDRESS(H160(bytes)) + Address::new(H160(bytes)) } // Inverse function of `super::make_address`. diff --git a/engine-precompiles/src/native.rs b/engine-precompiles/src/native.rs index 2b23d4dba..a1fb20909 100644 --- a/engine-precompiles/src/native.rs +++ b/engine-precompiles/src/native.rs @@ -44,10 +44,7 @@ mod costs { } pub mod events { - use crate::prelude::{ - types::{Address, ADDRESS}, - vec, String, ToString, H160, 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( @@ -64,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(H160([0; 20])); + pub const ETH_ADDRESS: Address = Address::new(H160([0; 20])); /// ExitToNear( /// Address indexed sender, diff --git a/engine-tests/src/tests/sanity.rs b/engine-tests/src/tests/sanity.rs index 6126aeab1..1c82323ae 100644 --- a/engine-tests/src/tests/sanity.rs +++ b/engine-tests/src/tests/sanity.rs @@ -237,7 +237,7 @@ fn test_override_state() { }; // Assert the initial state is 0 - assert_eq!(get_address(&runner), ADDRESS(H160([0; 20]))); + assert_eq!(get_address(&runner), Address::new(H160([0; 20]))); post_address(&mut runner, &mut account1); // Assert the address matches the first caller assert_eq!(get_address(&runner), account1_address); @@ -517,7 +517,6 @@ fn initialize_transfer() -> (test_utils::AuroraRunner, test_utils::Signer, Addre (runner, signer, dest_address) } -use aurora_engine_types::types::ADDRESS; use aurora_engine_types::H160; use sha3::Digest; @@ -623,7 +622,7 @@ fn test_eth_transfer_insufficient_balance_sim() { // Run transaction which will fail (transfer more than current balance) let nonce = signer.use_nonce(); let tx = test_utils::transfer( - ADDRESS(H160([1; 20])), + Address::new(H160([1; 20])), INITIAL_BALANCE + INITIAL_BALANCE, nonce.into(), ); @@ -654,7 +653,7 @@ fn test_eth_transfer_charging_gas_not_enough_balance_sim() { // Run transaction which will fail (not enough balance to cover gas) let nonce = signer.use_nonce(); - let mut tx = test_utils::transfer(ADDRESS(H160([1; 20])), TRANSFER_AMOUNT, nonce.into()); + let mut tx = test_utils::transfer(Address::new(H160([1; 20])), TRANSFER_AMOUNT, nonce.into()); tx.gas_limit = 3_000_000.into(); tx.gas_price = GAS_PRICE.into(); let signed_tx = test_utils::sign_transaction( diff --git a/engine-tests/src/tests/standalone/json_snapshot.rs b/engine-tests/src/tests/standalone/json_snapshot.rs index 48a0cbae9..0325cd799 100644 --- a/engine-tests/src/tests/standalone/json_snapshot.rs +++ b/engine-tests/src/tests/standalone/json_snapshot.rs @@ -1,5 +1,5 @@ use crate::test_utils::standalone; -use aurora_engine_types::types::{Address, ADDRESS}; +use aurora_engine_types::types::Address; use aurora_engine_types::{H160, U256}; use engine_standalone_storage::json_snapshot; @@ -41,5 +41,5 @@ fn test_consume_snapshot() { fn address_from_key(key: &[u8]) -> Address { let mut result = [0u8; 20]; result.copy_from_slice(&key[2..22]); - ADDRESS(H160(result)) + Address::new(H160(result)) } diff --git a/engine-tests/src/tests/standalone/sanity.rs b/engine-tests/src/tests/standalone/sanity.rs index ac6c292e3..f537951d5 100644 --- a/engine-tests/src/tests/standalone/sanity.rs +++ b/engine-tests/src/tests/standalone/sanity.rs @@ -1,7 +1,7 @@ use crate::test_utils::standalone::mocks::{promise, storage}; use aurora_engine::engine; use aurora_engine_sdk::env::DEFAULT_PREPAID_GAS; -use aurora_engine_types::types::{Address, Wei, ADDRESS}; +use aurora_engine_types::types::{Address, Wei}; use aurora_engine_types::{account_id::AccountId, H160, H256, U256}; use std::sync::RwLock; @@ -20,7 +20,7 @@ fn test_deploy_code() { bridge_prover_id: "mr_the_prover".parse().unwrap(), upgrade_delay_blocks: 0, }; - let origin = ADDRESS(H160([0u8; 20])); + let origin = Address::new(H160([0u8; 20])); let storage = RwLock::new(storage::Storage::default()); let io = storage::StoragePointer(&storage); let env = aurora_engine_sdk::env::Fixed { diff --git a/engine-tests/src/tests/standalone/sync.rs b/engine-tests/src/tests/standalone/sync.rs index 161c941fe..b12a93fd6 100644 --- a/engine-tests/src/tests/standalone/sync.rs +++ b/engine-tests/src/tests/standalone/sync.rs @@ -1,6 +1,6 @@ use aurora_engine::deposit_event::TokenMessageData; use aurora_engine_sdk::env::{Env, Timestamp}; -use aurora_engine_types::types::{Address, Balance, Fee, NEP141Wei, Wei, ADDRESS}; +use aurora_engine_types::types::{Address, Balance, Fee, NEP141Wei, Wei}; use aurora_engine_types::{account_id::AccountId, H160, H256, U256}; use borsh::BorshSerialize; use engine_standalone_storage::sync; @@ -40,7 +40,7 @@ fn test_consume_block_message() { fn test_consume_deposit_message() { let (mut runner, block_message) = initialize(); - let recipient_address = ADDRESS(H160([22u8; 20])); + let recipient_address = Address::new(H160([22u8; 20])); let deposit_amount = Wei::new_u64(123_456_789); let proof = mock_proof(recipient_address, deposit_amount); @@ -119,7 +119,7 @@ fn test_consume_deploy_erc20_message() { let token: AccountId = "some_nep141.near".parse().unwrap(); let mint_amount: u128 = 555_555; - let dest_address = ADDRESS(H160([170u8; 20])); + let dest_address = Address::new(H160([170u8; 20])); let args = aurora_engine::parameters::DeployErc20TokenArgs { nep141: token.clone(), @@ -200,7 +200,7 @@ fn test_consume_ft_on_transfer_message() { let mint_amount = 8_675_309; let fee = Wei::zero(); - let dest_address = ADDRESS(H160([221u8; 20])); + let dest_address = Address::new(H160([221u8; 20])); // Mint ETH on Aurora per the bridge workflow let args = aurora_engine::parameters::NEP141FtOnTransferArgs { @@ -245,7 +245,7 @@ fn test_consume_call_message() { let initial_balance = Wei::new_u64(800_000); let transfer_amount = Wei::new_u64(115_321); let caller_address = aurora_engine_sdk::types::near_account_to_evm_address(caller.as_bytes()); - let recipient_address = ADDRESS(H160([1u8; 20])); + let recipient_address = Address::new(H160([1u8; 20])); runner.mint_account(caller_address, initial_balance, U256::zero(), None); runner.env.block_height += 1; @@ -290,7 +290,7 @@ fn test_consume_submit_message() { let initial_balance = Wei::new_u64(800_000); let transfer_amount = Wei::new_u64(115_321); let signer_address = test_utils::address_from_secret_key(&signer.secret_key); - let recipient_address = ADDRESS(H160([1u8; 20])); + let recipient_address = Address::new(H160([1u8; 20])); runner.mint_account(signer_address, initial_balance, signer.nonce.into(), None); runner.env.block_height += 1; @@ -342,7 +342,7 @@ fn mock_proof(recipient_address: Address, deposit_amount: Wei) -> aurora_engine: let deposit_event = aurora_engine::deposit_event::DepositedEvent { eth_custodian_address, - sender: ADDRESS(H160([0u8; 20])), + sender: Address::new(H160([0u8; 20])), token_message_data, amount: NEP141Wei::new(deposit_amount.raw().as_u128()), fee, diff --git a/engine-tests/src/tests/uniswap.rs b/engine-tests/src/tests/uniswap.rs index 625b2a5cd..3885fa0c8 100644 --- a/engine-tests/src/tests/uniswap.rs +++ b/engine-tests/src/tests/uniswap.rs @@ -8,7 +8,7 @@ use crate::test_utils::{ }, AuroraRunner, ExecutionProfile, Signer, }; -use aurora_engine_types::types::{Wei, ADDRESS}; +use aurora_engine_types::types::Wei; use aurora_engine_types::H160; use secp256k1::SecretKey; @@ -97,7 +97,7 @@ impl UniswapTestContext { c.deploy( factory.0.address, weth_address, - ADDRESS(H160([0; 20])), + Address::new(H160([0; 20])), nonce.into(), ) }, @@ -233,7 +233,7 @@ impl UniswapTestContext { token_out: token_out.0.address, fee: POOL_FEE, - recipient: ADDRESS(H160([0; 20])), + recipient: Address::new(H160([0; 20])), deadline: U256::MAX, amount_out, amount_in_max: U256::from(100) * amount_out, diff --git a/engine-types/src/types/address.rs b/engine-types/src/types/address.rs index fa331eb11..635957c38 100755 --- a/engine-types/src/types/address.rs +++ b/engine-types/src/types/address.rs @@ -6,14 +6,9 @@ use borsh::{BorshDeserialize, BorshSerialize}; #[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)] pub struct Address(H160); -#[allow(non_snake_case, dead_code)] -pub const fn ADDRESS(addr: H160) -> Address { - Address(addr) -} - impl Address { /// Construct Address from H160 - pub fn new(val: H160) -> Self { + pub const fn new(val: H160) -> Self { Self(val) } @@ -53,7 +48,7 @@ impl Address { } pub const fn zero() -> Self { - ADDRESS(H160([0u8; 20])) + Address::new(H160([0u8; 20])) } } diff --git a/engine/src/engine.rs b/engine/src/engine.rs index 88c32e30b..bfbbeb5ed 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -16,7 +16,7 @@ use crate::prelude::precompiles::Precompiles; use crate::prelude::{ address_to_key, bytes_to_key, sdk, storage_to_key, u256_to_arr, vec, AccountId, Address, BorshDeserialize, BorshSerialize, KeyPrefix, PromiseArgs, PromiseCreateArgs, ToString, TryFrom, - TryInto, Vec, Wei, ADDRESS, ERC20_MINT_SELECTOR, H160, H256, U256, + TryInto, Vec, Wei, ERC20_MINT_SELECTOR, H160, H256, U256, }; use crate::transaction::{EthTransactionKind, NormalizedEthTransaction}; use aurora_engine_precompiles::PrecompileConstructorContext; @@ -530,7 +530,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let origin = Address::new(self.origin()); match args { CallArgs::V2(call_args) => { - let contract = ADDRESS(call_args.contract.raw()); + let contract = Address::new(call_args.contract.raw()); let value = call_args.value.into(); let input = call_args.input; self.call( @@ -724,7 +724,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let mut message = args.msg.as_bytes(); assert_or_finish!(message.len() >= 40, output_on_fail, self.io); - let recipient = ADDRESS(H160(unwrap_res_or_finish!( + let recipient = Address::new(H160(unwrap_res_or_finish!( hex::decode(&message[..40]).unwrap().as_slice().try_into(), output_on_fail, self.io @@ -1052,7 +1052,9 @@ pub fn deploy_erc20_token( handler, ) { Ok(result) => match result.status { - TransactionStatus::Succeed(ret) => ADDRESS(H160(ret.as_slice().try_into().unwrap())), + TransactionStatus::Succeed(ret) => { + Address::new(H160(ret.as_slice().try_into().unwrap())) + } other => return Err(DeployErc20Error::Failed(other)), }, Err(e) => return Err(DeployErc20Error::Engine(e)), From 2dfde80dc83c58c20e2efce55dc9f13b0f850187 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Wed, 22 Dec 2021 12:33:03 +0200 Subject: [PATCH 23/26] Update engine-types/src/types/address.rs Co-authored-by: Michael Birch --- engine-types/src/types/address.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine-types/src/types/address.rs b/engine-types/src/types/address.rs index 635957c38..186913507 100755 --- a/engine-types/src/types/address.rs +++ b/engine-types/src/types/address.rs @@ -22,7 +22,7 @@ impl Address { hex::encode(self.0.as_bytes()) } - pub fn decode(address: String) -> Result { + pub fn decode(address: &str) -> Result { if address.len() != 40 { return Err(error::AddressError::IncorrectLength); } From 282d52717e032d44279eb0c217aeb949d7de2cf8 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Wed, 22 Dec 2021 12:34:18 +0200 Subject: [PATCH 24/26] Update engine-types/src/types/address.rs Co-authored-by: Michael Birch --- engine-types/src/types/address.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine-types/src/types/address.rs b/engine-types/src/types/address.rs index 186913507..716b26ace 100755 --- a/engine-types/src/types/address.rs +++ b/engine-types/src/types/address.rs @@ -109,7 +109,7 @@ mod tests { } #[test] - fn test_address_deocde() { + fn test_address_decode() { // Test compatibility with previous typ RawAddress. // It was: type RawAddress = [u8;20]; let eth_address_vec = From 7cf3a3c9ccfee7f1ab1fe5cb5ac29b0cede8e92b Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Wed, 22 Dec 2021 12:34:50 +0200 Subject: [PATCH 25/26] Update engine/src/engine.rs Co-authored-by: Michael Birch --- engine/src/engine.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/engine.rs b/engine/src/engine.rs index bfbbeb5ed..877c3d5c1 100644 --- a/engine/src/engine.rs +++ b/engine/src/engine.rs @@ -530,7 +530,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> { let origin = Address::new(self.origin()); match args { CallArgs::V2(call_args) => { - let contract = Address::new(call_args.contract.raw()); + let contract = call_args.contract; let value = call_args.value.into(); let input = call_args.input; self.call( From 28f0bdaa33d1224a541c044ed3d8a1401cac2e50 Mon Sep 17 00:00:00 2001 From: Evgeny Ukhanov Date: Wed, 22 Dec 2021 12:38:46 +0200 Subject: [PATCH 26/26] Added decode reference --- engine-tests/src/tests/eth_connector.rs | 4 ++-- engine-tests/src/tests/standalone/tracing.rs | 4 ++-- engine-types/src/types/address.rs | 2 +- engine/src/connector.rs | 2 +- engine/src/deposit_event.rs | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/engine-tests/src/tests/eth_connector.rs b/engine-tests/src/tests/eth_connector.rs index d5cab407f..3882dd12b 100644 --- a/engine-tests/src/tests/eth_connector.rs +++ b/engine-tests/src/tests/eth_connector.rs @@ -99,7 +99,7 @@ fn init_contract( } fn validate_eth_address(address: &str) -> Address { - Address::decode(address.to_string()).unwrap() + Address::decode(address).unwrap() } fn call_deposit_eth_to_near( @@ -597,7 +597,7 @@ fn test_deposit_with_0x_prefix() { use aurora_engine::deposit_event::TokenMessageData; let (master_account, contract) = init(CUSTODIAN_ADDRESS); - let eth_custodian_address: Address = Address::decode(CUSTODIAN_ADDRESS.to_string()).unwrap(); + let eth_custodian_address: Address = Address::decode(&CUSTODIAN_ADDRESS.to_string()).unwrap(); let recipient_address = Address::from_array([10u8; 20]); let deposit_amount = 17; let recipient_address_encoded = recipient_address.encode(); diff --git a/engine-tests/src/tests/standalone/tracing.rs b/engine-tests/src/tests/standalone/tracing.rs index 7ff23fabe..b3beb4646 100644 --- a/engine-tests/src/tests/standalone/tracing.rs +++ b/engine-tests/src/tests/standalone/tracing.rs @@ -21,9 +21,9 @@ fn test_evm_tracing_with_storage() { let mut signer = test_utils::Signer::random(); let signer_address = test_utils::address_from_secret_key(&signer.secret_key); let sender_address = - Address::decode("304ee8ae14eceb3a544dff53a27eb1bb1aaa471f".to_string()).unwrap(); + Address::decode(&"304ee8ae14eceb3a544dff53a27eb1bb1aaa471f".to_string()).unwrap(); let weth_address = - Address::decode("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2".to_string()).unwrap(); + Address::decode(&"c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2".to_string()).unwrap(); // Initialize EVM runner.init_evm_with_chain_id(1); diff --git a/engine-types/src/types/address.rs b/engine-types/src/types/address.rs index 716b26ace..1ac94cc31 100755 --- a/engine-types/src/types/address.rs +++ b/engine-types/src/types/address.rs @@ -118,7 +118,7 @@ mod tests { eth_address.copy_from_slice(ð_address_vec[..]); let aurora_eth_address = - Address::decode("096DE9C2B8A5B8c22cEe3289B101f6960d68E51E".to_string()).unwrap(); + Address::decode(&"096DE9C2B8A5B8c22cEe3289B101f6960d68E51E".to_string()).unwrap(); assert_eq!(eth_address, aurora_eth_address.as_bytes()); let serialized_addr = eth_address.try_to_vec().unwrap(); diff --git a/engine/src/connector.rs b/engine/src/connector.rs index 678ac57b5..5451bd577 100644 --- a/engine/src/connector.rs +++ b/engine/src/connector.rs @@ -705,7 +705,7 @@ pub fn set_contract_data( // Get initial contract arguments let contract_data = EthConnector { prover_account: args.prover_account, - eth_custodian_address: Address::decode(args.eth_custodian_address)?, + eth_custodian_address: Address::decode(&args.eth_custodian_address)?, }; // Save eth-connector specific data io.write_borsh( diff --git a/engine/src/deposit_event.rs b/engine/src/deposit_event.rs index 96d2195d6..7b8b886b2 100644 --- a/engine/src/deposit_event.rs +++ b/engine/src/deposit_event.rs @@ -103,7 +103,7 @@ impl FtTransferMessageData { recipient }; let recipient_address = - Address::decode(address).map_err(ParseEventMessageError::EthAddressValidationError)?; + Address::decode(&address).map_err(ParseEventMessageError::EthAddressValidationError)?; // Second data section should contain Eth address data.extend(recipient_address.as_bytes()); // Add `:` separator between relayer_id and data message