Feat(Engine): Precompiles for predecessor_account_id and current_acco…

…unt_id (#462)

engine-precompiles/src/account_ids.rs

@@ -0,0 +1,124 @@
+use super::{EvmPrecompileResult, Precompile};
+use crate::prelude::types::{Address, EthGas};
+use crate::PrecompileOutput;
+use aurora_engine_types::account_id::AccountId;
+use evm::{Context, ExitError};
+
+mod costs {
+ use crate::prelude::types::EthGas;
+
+ // TODO(#51): Determine the correct amount of gas
+ pub(super) const PREDECESSOR_ACCOUNT_GAS: EthGas = EthGas::new(0);
+ // TODO(#51): Determine the correct amount of gas
+ pub(super) const CURRENT_ACCOUNT_GAS: EthGas = EthGas::new(0);
+}
+
+pub struct PredecessorAccount {
+ predecessor_account_id: AccountId,
+}
+
+impl PredecessorAccount {
+ /// predecessor_account_id precompile address
+ ///
+ /// Address: `0x723ffbaba940e75e7bf5f6d61dcbf8d9a4de0fd7`
+ /// This address is computed as: `&keccak("predecessorAccountId")[12..]`
+ pub const ADDRESS: Address =
+ super::make_address(0x723ffbab, 0xa940e75e7bf5f6d61dcbf8d9a4de0fd7);
+
+ pub fn new(predecessor_account_id: AccountId) -> Self {
+ Self {
+ predecessor_account_id,
+ }
+ }
+}
+
+impl Precompile for PredecessorAccount {
+ fn required_gas(_input: &[u8]) -> Result<EthGas, ExitError> {
+ Ok(costs::PREDECESSOR_ACCOUNT_GAS)
+ }
+
+ fn run(
+ &self,
+ input: &[u8],
+ target_gas: Option<EthGas>,
+ _context: &Context,
+ _is_static: bool,
+ ) -> EvmPrecompileResult {
+ let cost = Self::required_gas(input)?;
+ if let Some(target_gas) = target_gas {
+ if cost > target_gas {
+ return Err(ExitError::OutOfGas);
+ }
+ }
+
+ Ok(
+ PrecompileOutput::without_logs(cost, self.predecessor_account_id.as_bytes().to_vec())
+ .into(),
+ )
+ }
+}
+
+pub struct CurrentAccount {
+ current_account_id: AccountId,
+}
+
+impl CurrentAccount {
+ /// current_account_id precompile address
+ ///
+ /// Address: `0xfefae79e4180eb0284f261205e3f8cea737aff56`
+ /// This address is computed as: `&keccak("currentAccountId")[12..]`
+ pub const ADDRESS: Address =
+ super::make_address(0xfefae79e, 0x4180eb0284f261205e3f8cea737aff56);
+
+ pub fn new(current_account_id: AccountId) -> Self {
+ Self { current_account_id }
+ }
+}
+
+impl Precompile for CurrentAccount {
+ fn required_gas(_input: &[u8]) -> Result<EthGas, ExitError> {
+ Ok(costs::PREDECESSOR_ACCOUNT_GAS)
+ }
+
+ fn run(
+ &self,
+ input: &[u8],
+ target_gas: Option<EthGas>,
+ _context: &Context,
+ _is_static: bool,
+ ) -> EvmPrecompileResult {
+ let cost = Self::required_gas(input)?;
+ if let Some(target_gas) = target_gas {
+ if cost > target_gas {
+ return Err(ExitError::OutOfGas);
+ }
+ }
+
+ Ok(
+ PrecompileOutput::without_logs(cost, self.current_account_id.as_bytes().to_vec())
+ .into(),
+ )
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use crate::account_ids::{CurrentAccount, PredecessorAccount};
+ use crate::prelude::sdk::types::near_account_to_evm_address;
+
+ #[test]
+ fn test_predecessor_account_precompile_id() {
+ assert_eq!(
+ PredecessorAccount::ADDRESS,
+ near_account_to_evm_address("predecessorAccountId".as_bytes())
+ );
+ }
+
+ #[test]
+ fn test_curent_account_precompile_id() {
+ assert_eq!(
+ CurrentAccount::ADDRESS,
+ near_account_to_evm_address("currentAccountId".as_bytes())
+ );
+ }
+}

engine-precompiles/src/lib.rs

@@ -3,6 +3,7 @@
 #![cfg_attr(not(feature = "std"), feature(alloc_error_handler))]
 #![cfg_attr(feature = "log", feature(panic_info_message))]
 
+pub mod account_ids;
 pub mod blake2;
 pub mod bn128;
 pub mod hash;
@@ -15,6 +16,7 @@ pub mod secp256k1;
 #[cfg(test)]
 mod utils;
 
+use crate::account_ids::{CurrentAccount, PredecessorAccount};
 use crate::blake2::Blake2F;
 use crate::bn128::{Bn128Add, Bn128Mul, Bn128Pair};
 use crate::hash::{RIPEMD160, SHA256};
@@ -125,6 +127,7 @@ impl executor::stack::PrecompileSet for Precompiles {
 pub struct PrecompileConstructorContext {
  pub current_account_id: AccountId,
  pub random_seed: H256,
+ pub predecessor_account_id: AccountId,
 }
 
 impl Precompiles {
@@ -137,14 +140,18 @@ impl Precompiles {
  ExitToNear::ADDRESS,
  ExitToEthereum::ADDRESS,
  RandomSeed::ADDRESS,
+ CurrentAccount::ADDRESS,
+ PredecessorAccount::ADDRESS,
  ];
  let fun: prelude::Vec<Box<dyn Precompile>> = vec![
  Box::new(ECRecover),
  Box::new(SHA256),
  Box::new(RIPEMD160),
  Box::new(ExitToNear::new(ctx.current_account_id.clone())),
- Box::new(ExitToEthereum::new(ctx.current_account_id)),
+ Box::new(ExitToEthereum::new(ctx.current_account_id.clone())),
  Box::new(RandomSeed::new(ctx.random_seed)),
+ Box::new(CurrentAccount::new(ctx.current_account_id)),
+ Box::new(PredecessorAccount::new(ctx.predecessor_account_id)),
  ];
  let map: BTreeMap<Address, Box<dyn Precompile>> = addresses.into_iter().zip(fun).collect();
 
@@ -165,6 +172,8 @@ impl Precompiles {
  ExitToNear::ADDRESS,
  ExitToEthereum::ADDRESS,
  RandomSeed::ADDRESS,
+ CurrentAccount::ADDRESS,
+ PredecessorAccount::ADDRESS,
  ];
  let fun: prelude::Vec<Box<dyn Precompile>> = vec![
  Box::new(ECRecover),
@@ -176,8 +185,10 @@ impl Precompiles {
  Box::new(Bn128Mul::<Byzantium>::new()),
  Box::new(Bn128Pair::<Byzantium>::new()),
  Box::new(ExitToNear::new(ctx.current_account_id.clone())),
- Box::new(ExitToEthereum::new(ctx.current_account_id)),
+ Box::new(ExitToEthereum::new(ctx.current_account_id.clone())),
  Box::new(RandomSeed::new(ctx.random_seed)),
+ Box::new(CurrentAccount::new(ctx.current_account_id)),
+ Box::new(PredecessorAccount::new(ctx.predecessor_account_id)),
  ];
  let map: BTreeMap<Address, Box<dyn Precompile>> = addresses.into_iter().zip(fun).collect();
 
@@ -198,6 +209,8 @@ impl Precompiles {
  ExitToNear::ADDRESS,
  ExitToEthereum::ADDRESS,
  RandomSeed::ADDRESS,
+ CurrentAccount::ADDRESS,
+ PredecessorAccount::ADDRESS,
  ];
  let fun: prelude::Vec<Box<dyn Precompile>> = vec![
  Box::new(ECRecover),
@@ -210,8 +223,10 @@ impl Precompiles {
  Box::new(Bn128Pair::<Istanbul>::new()),
  Box::new(Blake2F),
  Box::new(ExitToNear::new(ctx.current_account_id.clone())),
- Box::new(ExitToEthereum::new(ctx.current_account_id)),
+ Box::new(ExitToEthereum::new(ctx.current_account_id.clone())),
  Box::new(RandomSeed::new(ctx.random_seed)),
+ Box::new(CurrentAccount::new(ctx.current_account_id)),
+ Box::new(PredecessorAccount::new(ctx.predecessor_account_id)),
  ];
  let map: BTreeMap<Address, Box<dyn Precompile>> = addresses.into_iter().zip(fun).collect();
 
@@ -232,6 +247,8 @@ impl Precompiles {
  ExitToNear::ADDRESS,
  ExitToEthereum::ADDRESS,
  RandomSeed::ADDRESS,
+ CurrentAccount::ADDRESS,
+ PredecessorAccount::ADDRESS,
  ];
  let fun: prelude::Vec<Box<dyn Precompile>> = vec![
  Box::new(ECRecover),
@@ -244,8 +261,10 @@ impl Precompiles {
  Box::new(Bn128Pair::<Istanbul>::new()),
  Box::new(Blake2F),
  Box::new(ExitToNear::new(ctx.current_account_id.clone())),
- Box::new(ExitToEthereum::new(ctx.current_account_id)),
+ Box::new(ExitToEthereum::new(ctx.current_account_id.clone())),
  Box::new(RandomSeed::new(ctx.random_seed)),
+ Box::new(CurrentAccount::new(ctx.current_account_id)),
+ Box::new(PredecessorAccount::new(ctx.predecessor_account_id)),
  ];
  let map: BTreeMap<Address, Box<dyn Precompile>> = addresses.into_iter().zip(fun).collect();
 

engine-tests/src/tests/account_id_precompiles.rs

@@ -0,0 +1,69 @@
+use crate::test_utils::{self, standalone};
+use aurora_engine::parameters::SubmitResult;
+
+#[test]
+fn test_account_id_precompiles() {
+ let mut signer = test_utils::Signer::random();
+ let mut runner = test_utils::deploy_evm();
+ let mut standalone = standalone::StandaloneRunner::default();
+
+ standalone.init_evm();
+ runner.standalone_runner = Some(standalone);
+
+ let constructor = test_utils::solidity::ContractConstructor::compile_from_source(
+ "src/tests/res",
+ "target/solidity_build",
+ "AccountIds.sol",
+ "AccountIds",
+ );
+
+ // deploy contract
+ let nonce = signer.use_nonce();
+ let contract = runner.deploy_contract(
+ &signer.secret_key,
+ |c| c.deploy_without_constructor(nonce.into()),
+ constructor,
+ );
+
+ // check current_account_id is correct
+ let result = runner
+ .submit_with_signer(&mut signer, |nonce| {
+ contract.call_method_without_args("currentAccountId", nonce)
+ })
+ .unwrap();
+ assert_eq!(unwrap_ethabi_string(&result), "aurora");
+
+ // check predecessor_account_id is correct
+ let result = runner
+ .submit_with_signer(&mut signer, |nonce| {
+ contract.call_method_without_args("predecessorAccountId", nonce)
+ })
+ .unwrap();
+ assert_eq!(unwrap_ethabi_string(&result), "some-account.near");
+
+ // double check the case where account_id is the full 64 bytes
+ let account_id = "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789";
+ assert_eq!(account_id.len(), 64);
+ runner.standalone_runner.as_mut().unwrap().env.block_height += 1000;
+ runner
+ .standalone_runner
+ .as_mut()
+ .unwrap()
+ .env
+ .current_account_id = account_id.parse().unwrap();
+ let nonce = signer.use_nonce();
+ let tx = contract.call_method_without_args("currentAccountId", nonce.into());
+ let result = runner
+ .standalone_runner
+ .as_mut()
+ .unwrap()
+ .submit_transaction(&signer.secret_key, tx)
+ .unwrap();
+ assert_eq!(unwrap_ethabi_string(&result), account_id);
+}
+
+fn unwrap_ethabi_string(result: &SubmitResult) -> String {
+ let bytes = test_utils::unwrap_success_slice(result);
+ let mut tokens = ethabi::decode(&[ethabi::ParamType::String], &bytes).unwrap();
+ tokens.pop().unwrap().into_string().unwrap()
+}

engine-tests/src/tests/mod.rs

@@ -1,4 +1,5 @@
 mod access_lists;
+mod account_id_precompiles;
 mod contract_call;
 mod eip1559;
 mod erc20;

engine-tests/src/tests/res/AccountIds.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: CC0-1.0
+pragma solidity ^0.8.0;
+
+contract AccountIds {
+ function currentAccountId() public returns (string memory) {
+ // Near accounts are at most 64 1-byte characters (see https://docs.near.org/docs/concepts/account#account-id-rules)
+ bytes32[2] memory value;
+
+ assembly {
+ let ret := call(gas(), 0xfefae79e4180eb0284f261205e3f8cea737aff56, 0, 0, 0, value, 64)
+ }
+
+ return bytes64ToString(value);
+ }
+
+ function predecessorAccountId() public returns (string memory) {
+ // Near accounts are at most 64 1-byte characters (see https://docs.near.org/docs/concepts/account#account-id-rules)
+ bytes32[2] memory value;
+
+ assembly {
+ let ret := call(gas(), 0x723ffbaba940e75e7bf5f6d61dcbf8d9a4de0fd7, 0, 0, 0, value, 64)
+ }
+
+ return bytes64ToString(value);
+ }
+
+ function bytes64ToString(bytes32[2] memory value) private pure returns (string memory) {
+ uint8 result_len = 0;
+ while((result_len < 32 && value[0][result_len] != 0) || (result_len >= 32 && result_len < 64 && value[1][result_len - 32] != 0)) {
+ result_len++;
+ }
+ bytes memory result = new bytes(result_len);
+ uint8 i = 0;
+ for (i = 0; i < 32 && value[0][i] != 0; i++) {
+ result[i] = value[0][i];
+ }
+ if (result_len > 32) {
+ for (i = 0; i < 32 && value[1][i] != 0; i++) {
+ result[i + 32] = value[1][i];
+ }
+ }
+
+ return string(result);
+ }
+}

engine/src/engine.rs

@@ -346,11 +346,17 @@ struct StackExecutorParams {
 }
 
 impl StackExecutorParams {
- fn new(gas_limit: u64, current_account_id: AccountId, random_seed: H256) -> Self {
+ fn new(
+ gas_limit: u64,
+ current_account_id: AccountId,
+ predecessor_account_id: AccountId,
+ random_seed: H256,
+ ) -> Self {
  Self {
  precompiles: Precompiles::new_london(PrecompileConstructorContext {
  current_account_id,
  random_seed,
+ predecessor_account_id,
  }),
  gas_limit,
  }
@@ -510,6 +516,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> {
  let executor_params = StackExecutorParams::new(
  gas_limit,
  self.current_account_id.clone(),
+ self.env.predecessor_account_id(),
  self.env.random_seed(),
  );
  let mut executor = executor_params.make_executor(self);
@@ -594,6 +601,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> {
  let executor_params = StackExecutorParams::new(
  gas_limit,
  self.current_account_id.clone(),
+ self.env.predecessor_account_id(),
  self.env.random_seed(),
  );
  let mut executor = executor_params.make_executor(self);
@@ -643,6 +651,7 @@ impl<'env, I: IO + Copy, E: Env> Engine<'env, I, E> {
  let executor_params = StackExecutorParams::new(
  gas_limit,
  self.current_account_id.clone(),
+ self.env.predecessor_account_id(),
  self.env.random_seed(),
  );
  let mut executor = executor_params.make_executor(self);