Aurora block hashchain

.env/mainnet.env

@@ -1,6 +1,6 @@
 CARGO_FEATURES_BUILD="mainnet"
 CARGO_FEATURES_BUILD_TEST="mainnet,integration-test"
-CARGO_FEATURES_TEST="mainnet-test"
+CARGO_FEATURES_TEST="mainnet-test,integration-test"
 RUSTC_FLAGS_BUILD="-C link-arg=-s"
 NEAR_EVM_ACCOUNT="aurora"
 WASM_FILE="aurora-mainnet.wasm"

.env/testnet.env

@@ -1,6 +1,6 @@
 CARGO_FEATURES_BUILD="testnet"
 CARGO_FEATURES_BUILD_TEST="testnet,integration-test"
-CARGO_FEATURES_TEST="testnet-test"
+CARGO_FEATURES_TEST="testnet-test,integration-test"
 RUSTC_FLAGS_BUILD="-C link-arg=-s"
 NEAR_EVM_ACCOUNT="aurora"
 WASM_FILE="aurora-testnet.wasm"

Cargo.toml

@@ -32,9 +32,11 @@ evm = { git = "https://github.com/aurora-is-near/sputnikvm.git", tag = "v0.38.0-
 evm-core = { git = "https://github.com/aurora-is-near/sputnikvm.git", tag = "v0.38.0-aurora", default-features = false, features = ["std"] }
 evm-gasometer = { git = "https://github.com/aurora-is-near/sputnikvm.git", tag = "v0.38.0-aurora", default-features = false, features = ["std", "tracing"] }
 evm-runtime = { git = "https://github.com/aurora-is-near/sputnikvm.git", tag = "v0.38.0-aurora", default-features = false, features = ["std", "tracing"] }
+fixed-hash = { version = "0.8.0", default-features = false}
 git2 = "0.17"
 hex = { version = "0.4", default-features = false, features = ["alloc"] }
 ibig = { version = "0.3", default-features = false, features = ["num-traits"] }
+impl-serde = { version = "0.4.0", default-features = false}
 libsecp256k1 = { version = "0.7", default-features = false }
 near-crypto = "0.16"
 near-primitives = "0.16"
@@ -54,6 +56,7 @@ serde = { version = "1", default-features = false, features = ["alloc", "derive"
 serde_json = { version = "1", default-features = false, features = ["alloc"] }
 sha2 = { version = "0.10", default-features = false }
 sha3 = { version = "0.10", default-features = false }
+strum = { version = "0.24.1", features = [ "derive" ] }
 tempfile = "3"
 test-case = "3.1"
 walrus = "0.20"

engine-standalone-storage/Cargo.toml

@@ -20,12 +20,14 @@ aurora-engine-modexp = { workspace = true, features = ["std"] }
 aurora-engine-precompiles = { workspace = true, features = ["std"] }
 aurora-engine-sdk = { workspace = true, features = ["std"] }
 aurora-engine-transactions = { workspace = true, features = ["std"] }
+borsh.workspace = true
 evm-core.workspace = true
 hex = { workspace = true, features = ["std"] }
 rocksdb.workspace = true
 postgres.workspace = true
 serde = { workspace = true, features = ["std"] }
 serde_json = { workspace = true, features = ["std"] }
+strum.workspace = true
 
 [features]
 default = ["snappy", "lz4", "zstd", "zlib"]

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

@@ -1,3 +1,7 @@
+use aurora_engine::bloom::{self, Bloom};
+use aurora_engine::hashchain::{
+    self, blockchain_hashchain_error::BlockchainHashchainError, BlockchainHashchain,
+};
 use aurora_engine::parameters::SubmitArgs;
 use aurora_engine::pausables::{
     EnginePrecompilesPauser, PausedPrecompilesManager, PrecompileFlags,
@@ -7,6 +11,7 @@ use aurora_engine_modexp::ModExpAlgorithm;
 use aurora_engine_sdk::env::{self, Env, DEFAULT_PREPAID_GAS};
 use aurora_engine_types::{
     account_id::AccountId,
+    borsh::BorshSerialize,
     parameters::PromiseWithCallbackArgs,
     types::{Address, Yocto},
     H256,
@@ -18,6 +23,8 @@ use crate::engine_state::EngineStateAccess;
 use crate::{BlockMetadata, Diff, Storage};
 use types::{Message, TransactionKind, TransactionMessage};
 
+use self::types::InnerTransactionKind;
+
 pub fn consume_message<M: ModExpAlgorithm + 'static>(
     storage: &mut Storage,
     message: Message,
@@ -51,7 +58,7 @@ pub fn consume_message<M: ModExpAlgorithm + 'static>(
                         transaction_message.as_ref(),
                         block_height,
                         &block_metadata,
-                        engine_account_id,
+                        &engine_account_id,
                         io,
                     )
                 })
@@ -87,7 +94,7 @@ pub fn execute_transaction_message<M: ModExpAlgorithm + 'static>(
             &transaction_message,
             block_height,
             &block_metadata,
-            engine_account_id,
+            &engine_account_id,
             io,
         )
     });
@@ -105,8 +112,8 @@ fn execute_transaction<'db, M: ModExpAlgorithm + 'static>(
     transaction_message: &TransactionMessage,
     block_height: u64,
     block_metadata: &BlockMetadata,
-    engine_account_id: AccountId,
-    io: EngineStateAccess<'db, 'db, 'db>,
+    engine_account_id: &AccountId,
+    mut io: EngineStateAccess<'db, 'db, 'db>,
 ) -> (
     H256,
     Diff,
@@ -117,7 +124,7 @@ fn execute_transaction<'db, M: ModExpAlgorithm + 'static>(
     let relayer_address =
         aurora_engine_sdk::types::near_account_to_evm_address(predecessor_account_id.as_bytes());
     let near_receipt_id = transaction_message.near_receipt_id;
-    let current_account_id = engine_account_id;
+    let current_account_id = engine_account_id.clone();
     let env = env::Fixed {
         signer_account_id,
         current_account_id,
@@ -129,7 +136,7 @@ fn execute_transaction<'db, M: ModExpAlgorithm + 'static>(
         prepaid_gas: DEFAULT_PREPAID_GAS,
     };
 
-    let (tx_hash, result) = match &transaction_message.transaction {
+    let (tx_hash, mut result) = match &transaction_message.transaction {
         TransactionKind::Submit(tx) => {
             // We can ignore promises in the standalone engine because it processes each receipt separately
             // and it is fed a stream of receipts (it does not schedule them)
@@ -193,6 +200,17 @@ fn execute_transaction<'db, M: ModExpAlgorithm + 'static>(
         }
     };
 
+    if let Ok(option_result) = &result {
+        if let Err(e) = update_hashchain(
+            &mut io,
+            block_height,
+            &transaction_message.transaction,
+            option_result,
+        ) {
+            result = Err(e);
+        }
+    }
+
     let diff = io.get_transaction_diff();
 
     (tx_hash, diff, result)
@@ -469,13 +487,127 @@ fn non_submit_execute<'db, M: ModExpAlgorithm + 'static>(
             prev.is_paused = false;
             state::set_state(&mut io, &prev)?;
 
+            None
+        }
+        TransactionKind::StartHashchain(args) => {
+            let mut prev = state::get_state(&io)?;
+            let block_height = env.block_height;
+
+            let mut blockchain_hashchain = BlockchainHashchain::new(
+                prev.chain_id,
+                env.current_account_id.as_bytes().to_vec(),
+                args.block_height + 1,
+                args.block_hashchain,
+            );
+
+            // move hashchain from the args state to the current state
+            if block_height > blockchain_hashchain.get_current_block_height() {
+                blockchain_hashchain.move_to_block(block_height)?;
+            }
+
+            hashchain::storage::set_state(&mut io, &blockchain_hashchain)?;
+            prev.is_paused = false;
+            state::set_state(&mut io, &prev)?;
+
             None
         }
     };
 
     Ok(result)
 }
 
+fn update_hashchain<'db>(
+    io: &mut EngineStateAccess<'db, 'db, 'db>,
+    block_height: u64,
+    transaction: &TransactionKind,
+    result: &Option<TransactionExecutionResult>,
+) -> Result<(), error::Error> {
+    let hashchain_state = hashchain::storage::get_state(io);
+
+    if matches!(hashchain_state, Err(BlockchainHashchainError::NotFound)) {
+        return Ok(());
+    }
+
+    let mut blockchain_hashchain = hashchain_state?;
+
+    let method_name = InnerTransactionKind::from(transaction).to_string();
+    let input = get_input(transaction)?;
+    let (output, log_bloom) = get_output_and_log_bloom(result)?;
+
+    if block_height > blockchain_hashchain.get_current_block_height() {
+        blockchain_hashchain.move_to_block(block_height)?;
+    }
+
+    blockchain_hashchain.add_block_tx(block_height, &method_name, &input, &output, &log_bloom)?;
+
+    Ok(hashchain::storage::set_state(io, &blockchain_hashchain)?)
+}
+
+fn get_input(transaction: &TransactionKind) -> Result<Vec<u8>, error::Error> {
+    match transaction {
+        TransactionKind::Submit(tx) => Ok(tx.into()),
+        TransactionKind::SubmitWithArgs(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::Call(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::PausePrecompiles(args) | TransactionKind::ResumePrecompiles(args) => {
+            args.try_to_vec().map_err(Into::into)
+        }
+        TransactionKind::Deploy(input) => Ok(input.clone()),
+        TransactionKind::DeployErc20(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::FtOnTransfer(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::Deposit(raw_proof) => Ok(raw_proof.clone()),
+        TransactionKind::FtTransferCall(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::FinishDeposit(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::ResolveTransfer(args, _) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::FtTransfer(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::Withdraw(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::StorageDeposit(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::StorageUnregister(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::StorageWithdraw(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::SetOwner(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::SetPausedFlags(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::RegisterRelayer(evm_address) => Ok(evm_address.as_bytes().to_vec()),
+        TransactionKind::RefundOnError(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::SetConnectorData(args) | TransactionKind::NewConnector(args) => {
+            args.try_to_vec().map_err(Into::into)
+        }
+        TransactionKind::NewEngine(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::FactoryUpdate(bytecode) => Ok(bytecode.clone()),
+        TransactionKind::FactoryUpdateAddressVersion(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::FactorySetWNearAddress(address) => Ok(address.as_bytes().to_vec()),
+        TransactionKind::FundXccSubAccound(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::SetUpgradeDelayBlocks(args) => args.try_to_vec().map_err(Into::into),
+        TransactionKind::PauseContract
+        | TransactionKind::ResumeContract
+        | TransactionKind::Unknown => Ok(vec![]),
+        TransactionKind::StartHashchain(args) => args.try_to_vec().map_err(Into::into),
+    }
+}
+
+#[allow(clippy::option_if_let_else)]
+fn get_output_and_log_bloom(
+    result: &Option<TransactionExecutionResult>,
+) -> Result<(Vec<u8>, Bloom), error::Error> {
+    match result {
+        None => Ok((vec![], Bloom::default())),
+        Some(execution_result) => match execution_result {
+            TransactionExecutionResult::Promise(_) => Ok((vec![], Bloom::default())),
+            TransactionExecutionResult::DeployErc20(address) => {
+                Ok((address.as_bytes().try_to_vec().unwrap(), Bloom::default()))
+            }
+            TransactionExecutionResult::Submit(submit) => match submit {
+                Err(e) => Err(e.clone().into()),
+                Ok(submit_result) => {
+                    let result_output = submit_result.try_to_vec();
+                    match result_output {
+                        Err(e) => Err(e.into()),
+                        Ok(output) => Ok((output, bloom::get_logs_bloom(&submit_result.logs))),
+                    }
+                }
+            },
+        },
+    }
+}
+
 #[derive(Debug)]
 pub enum ConsumeMessageOutcome {
     BlockAdded,
@@ -499,7 +631,8 @@ pub enum TransactionExecutionResult {
 }
 
 pub mod error {
-    use aurora_engine::{connector, engine, fungible_token, state, xcc};
+    use aurora_engine::{connector, engine, fungible_token, hashchain, state, xcc};
+    use std::io;
 
     #[derive(Debug)]
     pub enum Error {
@@ -516,6 +649,8 @@ pub mod error {
         ConnectorInit(connector::error::InitContractError),
         ConnectorStorage(connector::error::StorageReadError),
         FundXccError(xcc::FundXccError),
+        BlockchainHashchain(hashchain::blockchain_hashchain_error::BlockchainHashchainError),
+        IO(io::Error),
     }
 
     impl From<state::EngineStateError> for Error {
@@ -595,4 +730,16 @@ pub mod error {
             Self::FundXccError(e)
         }
     }
+
+    impl From<hashchain::blockchain_hashchain_error::BlockchainHashchainError> for Error {
+        fn from(e: hashchain::blockchain_hashchain_error::BlockchainHashchainError) -> Self {
+            Self::BlockchainHashchain(e)
+        }
+    }
+
+    impl From<io::Error> for Error {
+        fn from(e: io::Error) -> Self {
+            Self::IO(e)
+        }
+    }
 }