Feat(engine): Get promise results precompile

engine-precompiles/src/lib.rs

@@ -12,6 +12,7 @@ pub mod modexp;
 pub mod native;
 mod prelude;
 pub mod prepaid_gas;
+pub mod promise_result;
 pub mod random;
 pub mod secp256k1;
 mod utils;
@@ -30,10 +31,12 @@ use crate::random::RandomSeed;
 use crate::secp256k1::ECRecover;
 use aurora_engine_sdk::env::Env;
 use aurora_engine_sdk::io::IO;
+use aurora_engine_sdk::promise::ReadOnlyPromiseHandler;
 use aurora_engine_types::{account_id::AccountId, types::Address, vec, BTreeMap, Box};
 use evm::backend::Log;
 use evm::executor::{self, stack::PrecompileHandle};
 use evm::{Context, ExitError, ExitSucceed};
+use promise_result::PromiseResult;
 
 #[derive(Debug, Default)]
 pub struct PrecompileOutput {
@@ -94,17 +97,20 @@ impl HardFork for Istanbul {}
 
 impl HardFork for Berlin {}
 
-pub struct Precompiles<'a, I, E> {
+pub struct Precompiles<'a, I, E, H> {
     pub generic_precompiles: prelude::BTreeMap<Address, Box<dyn Precompile>>,
     // Cannot be part of the generic precompiles because the `dyn` type-erasure messes with
     // with the lifetime requirements on the type parameter `I`.
     pub near_exit: ExitToNear<I>,
     pub ethereum_exit: ExitToEthereum<I>,
     pub predecessor_account_id: PredecessorAccount<'a, E>,
     pub prepaid_gas: PrepaidGas<'a, E>,
+    pub promise_results: PromiseResult<H>,
 }
 
-impl<'a, I: IO + Copy, E: Env> executor::stack::PrecompileSet for Precompiles<'a, I, E> {
+impl<'a, I: IO + Copy, E: Env, H: ReadOnlyPromiseHandler> executor::stack::PrecompileSet
+    for Precompiles<'a, I, E, H>
+{
     fn execute(
         &self,
         handle: &mut impl PrecompileHandle,
@@ -139,16 +145,17 @@ impl<'a, I: IO + Copy, E: Env> executor::stack::PrecompileSet for Precompiles<'a
     }
 }
 
-pub struct PrecompileConstructorContext<'a, I, E> {
+pub struct PrecompileConstructorContext<'a, I, E, H> {
     pub current_account_id: AccountId,
     pub random_seed: H256,
     pub io: I,
     pub env: &'a E,
+    pub promise_handler: H,
 }
 
-impl<'a, I: IO + Copy, E: Env> Precompiles<'a, I, E> {
+impl<'a, I: IO + Copy, E: Env, H: ReadOnlyPromiseHandler> Precompiles<'a, I, E, H> {
     #[allow(dead_code)]
-    pub fn new_homestead(ctx: PrecompileConstructorContext<'a, I, E>) -> Self {
+    pub fn new_homestead(ctx: PrecompileConstructorContext<'a, I, E, H>) -> Self {
         let addresses = vec![
             ECRecover::ADDRESS,
             SHA256::ADDRESS,
@@ -168,7 +175,7 @@ impl<'a, I: IO + Copy, E: Env> Precompiles<'a, I, E> {
     }
 
     #[allow(dead_code)]
-    pub fn new_byzantium(ctx: PrecompileConstructorContext<'a, I, E>) -> Self {
+    pub fn new_byzantium(ctx: PrecompileConstructorContext<'a, I, E, H>) -> Self {
         let addresses = vec![
             ECRecover::ADDRESS,
             SHA256::ADDRESS,
@@ -198,7 +205,7 @@ impl<'a, I: IO + Copy, E: Env> Precompiles<'a, I, E> {
         Self::with_generic_precompiles(map, ctx)
     }
 
-    pub fn new_istanbul(ctx: PrecompileConstructorContext<'a, I, E>) -> Self {
+    pub fn new_istanbul(ctx: PrecompileConstructorContext<'a, I, E, H>) -> Self {
         let addresses = vec![
             ECRecover::ADDRESS,
             SHA256::ADDRESS,
@@ -230,7 +237,7 @@ impl<'a, I: IO + Copy, E: Env> Precompiles<'a, I, E> {
         Self::with_generic_precompiles(map, ctx)
     }
 
-    pub fn new_berlin(ctx: PrecompileConstructorContext<'a, I, E>) -> Self {
+    pub fn new_berlin(ctx: PrecompileConstructorContext<'a, I, E, H>) -> Self {
         let addresses = vec![
             ECRecover::ADDRESS,
             SHA256::ADDRESS,
@@ -262,26 +269,28 @@ impl<'a, I: IO + Copy, E: Env> Precompiles<'a, I, E> {
         Self::with_generic_precompiles(map, ctx)
     }
 
-    pub fn new_london(ctx: PrecompileConstructorContext<'a, I, E>) -> Self {
+    pub fn new_london(ctx: PrecompileConstructorContext<'a, I, E, H>) -> Self {
         // no precompile changes in London HF
         Self::new_berlin(ctx)
     }
 
     fn with_generic_precompiles(
         generic_precompiles: BTreeMap<Address, Box<dyn Precompile>>,
-        ctx: PrecompileConstructorContext<'a, I, E>,
+        ctx: PrecompileConstructorContext<'a, I, E, H>,
     ) -> Self {
         let near_exit = ExitToNear::new(ctx.current_account_id.clone(), ctx.io);
         let ethereum_exit = ExitToEthereum::new(ctx.current_account_id, ctx.io);
         let predecessor_account_id = PredecessorAccount::new(ctx.env);
         let prepaid_gas = PrepaidGas::new(ctx.env);
+        let promise_results = PromiseResult::new(ctx.promise_handler);
 
         Self {
             generic_precompiles,
             near_exit,
             ethereum_exit,
             predecessor_account_id,
             prepaid_gas,
+            promise_results,
         }
     }
 
@@ -298,6 +307,8 @@ impl<'a, I: IO + Copy, E: Env> Precompiles<'a, I, E> {
             return Some(f(&self.predecessor_account_id));
         } else if address == prepaid_gas::ADDRESS {
             return Some(f(&self.prepaid_gas));
+        } else if address == promise_result::ADDRESS {
+            return Some(f(&self.promise_results));
         }
         self.generic_precompiles
             .get(&address)

engine-precompiles/src/prepaid_gas.rs

@@ -5,7 +5,7 @@ use aurora_engine_sdk::env::Env;
 use aurora_engine_types::{vec, U256};
 use evm::{Context, ExitError};
 
-/// predecessor_account_id precompile address
+/// prepaid_gas precompile address
 ///
 /// Address: `0x536822d27de53629ef1f84c60555689e9488609f`
 /// This address is computed as: `&keccak("prepaidGas")[12..]`

engine-precompiles/src/promise_result.rs

@@ -0,0 +1,90 @@
+use super::{EvmPrecompileResult, Precompile};
+use crate::prelude::types::{Address, EthGas};
+use crate::PrecompileOutput;
+use aurora_engine_sdk::promise::ReadOnlyPromiseHandler;
+use aurora_engine_types::{Cow, Vec};
+use borsh::BorshSerialize;
+use evm::{Context, ExitError};
+
+/// get_promise_results precompile address
+///
+/// Address: `0x0a3540f79be10ef14890e87c1a0040a68cc6af71`
+/// This address is computed as: `&keccak("getPromiseResults")[12..]`
+pub const ADDRESS: Address = crate::make_address(0x0a3540f7, 0x9be10ef14890e87c1a0040a68cc6af71);
+
+pub mod costs {
+    use crate::prelude::types::EthGas;
+
+    /// This cost is always charged for calling this precompile.
+    pub const PROMISE_RESULT_BASE_COST: EthGas = EthGas::new(125);
+    /// This is the cost per byte of promise result data.
+    pub const PROMISE_RESULT_BYTE_COST: EthGas = EthGas::new(1);
+}
+
+pub struct PromiseResult<H> {
+    handler: H,
+}
+
+impl<H> PromiseResult<H> {
+    pub fn new(handler: H) -> Self {
+        Self { handler }
+    }
+}
+
+impl<H: ReadOnlyPromiseHandler> Precompile for PromiseResult<H> {
+    fn required_gas(_input: &[u8]) -> Result<EthGas, ExitError> {
+        // Only gives the cost we can know without reading any promise data.
+        // This allows failing fast in the case the base cost cannot even be covered.
+        Ok(costs::PROMISE_RESULT_BASE_COST)
+    }
+
+    fn run(
+        &self,
+        input: &[u8],
+        target_gas: Option<EthGas>,
+        _context: &Context,
+        _is_static: bool,
+    ) -> EvmPrecompileResult {
+        let mut cost = Self::required_gas(input)?;
+        let check_cost = |cost: EthGas| -> Result<(), ExitError> {
+            if let Some(target_gas) = target_gas {
+                if cost > target_gas {
+                    return Err(ExitError::OutOfGas);
+                }
+            }
+            Ok(())
+        };
+        check_cost(cost)?;
+
+        let num_promises = self.handler.ro_promise_results_count();
+        let n_usize = usize::try_from(num_promises).map_err(crate::utils::err_usize_conv)?;
+        let mut results = Vec::with_capacity(n_usize);
+        for i in 0..num_promises {
+            if let Some(result) = self.handler.ro_promise_result(i) {
+                let n_bytes = u64::try_from(result.size()).map_err(crate::utils::err_usize_conv)?;
+                cost += n_bytes * costs::PROMISE_RESULT_BYTE_COST;
+                check_cost(cost)?;
+                results.push(result);
+            }
+        }
+
+        let bytes = results
+            .try_to_vec()
+            .map_err(|_| ExitError::Other(Cow::Borrowed("ERR_PROMISE_RESULT_SERIALIZATION")))?;
+        Ok(PrecompileOutput::without_logs(cost, bytes))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::prelude::sdk::types::near_account_to_evm_address;
+    use crate::promise_result;
+
+    #[test]
+    fn test_get_promise_results_precompile_id() {
+        assert_eq!(
+            promise_result::ADDRESS,
+            near_account_to_evm_address("getPromiseResults".as_bytes())
+        );
+    }
+}

engine-sdk/src/near_runtime.rs

@@ -260,6 +260,8 @@ impl crate::env::Env for Runtime {
 }
 
 impl crate::promise::PromiseHandler for Runtime {
+    type ReadOnly = Self;
+
     fn promise_results_count(&self) -> u64 {
         unsafe { exports::promise_results_count() }
     }
@@ -379,6 +381,10 @@ impl crate::promise::PromiseHandler for Runtime {
             exports::promise_return(promise.raw());
         }
     }
+
+    fn read_only(&self) -> Self::ReadOnly {
+        Self
+    }
 }
 
 /// Some host functions are not usable in NEAR view calls.

engine-sdk/src/promise.rs

@@ -17,6 +17,8 @@ impl PromiseId {
 }
 
 pub trait PromiseHandler {
+    type ReadOnly: ReadOnlyPromiseHandler;
+
     fn promise_results_count(&self) -> u64;
     fn promise_result(&self, index: u64) -> Option<PromiseResult>;
 
@@ -33,4 +35,59 @@ pub trait PromiseHandler {
         let base = self.promise_create_call(&args.base);
         self.promise_attach_callback(base, &args.callback)
     }
+
+    fn read_only(&self) -> Self::ReadOnly;
+}
+
+pub trait ReadOnlyPromiseHandler {
+    fn ro_promise_results_count(&self) -> u64;
+    fn ro_promise_result(&self, index: u64) -> Option<PromiseResult>;
+}
+
+impl<T: PromiseHandler> ReadOnlyPromiseHandler for T {
+    fn ro_promise_results_count(&self) -> u64 {
+        self.promise_results_count()
+    }
+
+    fn ro_promise_result(&self, index: u64) -> Option<PromiseResult> {
+        self.promise_result(index)
+    }
+}
+
+/// A promise handler which does nothing. Should only be used when promises can be safely ignored.
+#[derive(Debug, Copy, Clone)]
+pub struct Noop;
+
+impl PromiseHandler for Noop {
+    type ReadOnly = Self;
+
+    fn promise_results_count(&self) -> u64 {
+        0
+    }
+
+    fn promise_result(&self, _index: u64) -> Option<PromiseResult> {
+        None
+    }
+
+    fn promise_create_call(&mut self, _args: &PromiseCreateArgs) -> PromiseId {
+        PromiseId::new(0)
+    }
+
+    fn promise_attach_callback(
+        &mut self,
+        _base: PromiseId,
+        _callback: &PromiseCreateArgs,
+    ) -> PromiseId {
+        PromiseId::new(0)
+    }
+
+    fn promise_create_batch(&mut self, _args: &PromiseBatchAction) -> PromiseId {
+        PromiseId::new(0)
+    }
+
+    fn promise_return(&mut self, _promise: PromiseId) {}
+
+    fn read_only(&self) -> Self::ReadOnly {
+        Self
+    }
 }

engine-standalone-storage/src/promise.rs

@@ -2,16 +2,31 @@ use aurora_engine_sdk::promise::{PromiseHandler, PromiseId};
 use aurora_engine_types::parameters::{PromiseBatchAction, PromiseCreateArgs};
 use aurora_engine_types::types::PromiseResult;
 
-/// A promise handler which does nothing. Should only be used when promises can be safely ignored.
-pub struct Noop;
+/// Implements `PromiseHandler` so that it can be used in the standalone engine implementation of
+/// methods like `call`, however since the standalone engine cannot schedule promises in a
+/// meaningful way, the mutable implementations are no-ops. Functionally, this is only an implementation
+/// of `ReadOnlyPromiseHandler`, which is needed for the standalone engine to properly serve the
+/// EVM precompile that gives back information on the results of promises (possibly scheduled using
+/// the cross-contract calls feature).
+#[derive(Debug, Clone, Copy)]
+pub struct NoScheduler<'a> {
+    pub promise_data: &'a [Option<Vec<u8>>],
+}
+
+impl<'a> PromiseHandler for NoScheduler<'a> {
+    type ReadOnly = Self;
 
-impl PromiseHandler for Noop {
     fn promise_results_count(&self) -> u64 {
-        0
+        u64::try_from(self.promise_data.len()).unwrap_or_default()
     }
 
-    fn promise_result(&self, _index: u64) -> Option<PromiseResult> {
-        None
+    fn promise_result(&self, index: u64) -> Option<PromiseResult> {
+        let i = usize::try_from(index).ok()?;
+        let result = match self.promise_data.get(i)? {
+            Some(bytes) => PromiseResult::Successful(bytes.clone()),
+            None => PromiseResult::Failed,
+        };
+        Some(result)
     }
 
     fn promise_create_call(&mut self, _args: &PromiseCreateArgs) -> PromiseId {
@@ -31,4 +46,8 @@ impl PromiseHandler for Noop {
     }
 
     fn promise_return(&mut self, _promise: PromiseId) {}
+
+    fn read_only(&self) -> Self::ReadOnly {
+        *self
+    }
 }

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

@@ -83,7 +83,8 @@ where
         random_seed: H256::zero(),
         prepaid_gas: DEFAULT_PREPAID_GAS,
     };
-    let mut handler = crate::promise::Noop;
+    // We use the Noop handler here since the relayer DB does not contain any promise information.
+    let mut handler = aurora_engine_sdk::promise::Noop;
 
     while let Some(row) = rows.next()? {
         let near_tx_hash = row.near_hash;
@@ -150,6 +151,7 @@ where
             caller: env.predecessor_account_id(),
             attached_near: 0,
             transaction: crate::sync::types::TransactionKind::Submit(tx),
+            promise_data: Vec::new(),
         };
         storage.set_transaction_included(tx_hash, &tx_msg, &diff)?;
     }
@@ -256,6 +258,7 @@ mod test {
                         caller: "aurora".parse().unwrap(),
                         attached_near: 0,
                         transaction: TransactionKind::Unknown,
+                        promise_data: Vec::new(),
                     },
                     &diff,
                 )