diff --git a/Cargo.lock b/Cargo.lock index 2da00ddbe..188eb339e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1556,6 +1556,7 @@ dependencies = [ "rocksdb", "serde", "serde_json", + "strum 0.25.0", ] [[package]] @@ -3129,7 +3130,7 @@ dependencies = [ "opentelemetry-semantic-conventions", "prometheus", "serde", - "strum", + "strum 0.24.1", "thiserror", "tokio", "tracing", @@ -3163,7 +3164,7 @@ dependencies = [ "serde", "serde_json", "smart-default", - "strum", + "strum 0.24.1", "thiserror", ] @@ -3193,7 +3194,7 @@ dependencies = [ "serde", "serde_json", "smart-default", - "strum", + "strum 0.24.1", "thiserror", ] @@ -3228,7 +3229,7 @@ dependencies = [ "serde_with", "serde_yaml", "smart-default", - "strum", + "strum 0.24.1", "thiserror", "time 0.3.23", "tracing", @@ -3248,7 +3249,7 @@ dependencies = [ "num-rational 0.3.2", "serde", "sha2 0.10.7", - "strum", + "strum 0.24.1", ] [[package]] @@ -3266,7 +3267,7 @@ dependencies = [ "serde", "serde_repr", "sha2 0.10.7", - "strum", + "strum 0.24.1", ] [[package]] @@ -3287,7 +3288,7 @@ dependencies = [ "serde_repr", "serde_with", "sha2 0.10.7", - "strum", + "strum 0.24.1", "thiserror", ] @@ -3480,7 +3481,7 @@ dependencies = [ "near-account-id 0.15.0", "near-rpc-error-macro 0.15.0", "serde", - "strum", + "strum 0.24.1", ] [[package]] @@ -3493,7 +3494,7 @@ dependencies = [ "near-account-id 0.17.0", "near-rpc-error-macro 0.17.0", "serde", - "strum", + "strum 0.24.1", "thiserror", ] @@ -5220,7 +5221,16 @@ version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f" dependencies = [ - "strum_macros", + "strum_macros 0.24.3", +] + +[[package]] +name = "strum" +version = "0.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125" +dependencies = [ + "strum_macros 0.25.1", ] [[package]] @@ -5236,6 +5246,19 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "strum_macros" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6069ca09d878a33f883cc06aaa9718ede171841d3832450354410b718b097232" +dependencies = [ + "heck 0.4.1", + "proc-macro2", + "quote", + "rustversion", + "syn 2.0.26", +] + [[package]] name = "subtle" version = "2.5.0" diff --git a/Cargo.toml b/Cargo.toml index fea7dc915..e87602606 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -59,6 +59,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.25", features = ["derive"] } tempfile = "3" tokio = { version = "1", default-features = false, features = ["macros"] } test-case = "3.1" diff --git a/engine-standalone-storage/Cargo.toml b/engine-standalone-storage/Cargo.toml index cacf5e388..c0cc78c1e 100644 --- a/engine-standalone-storage/Cargo.toml +++ b/engine-standalone-storage/Cargo.toml @@ -26,6 +26,7 @@ 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"] diff --git a/engine-standalone-storage/src/error.rs b/engine-standalone-storage/src/error.rs index 39ff93f21..75481cb75 100644 --- a/engine-standalone-storage/src/error.rs +++ b/engine-standalone-storage/src/error.rs @@ -1,6 +1,6 @@ +use crate::{sync::types::TransactionKindTag, TransactionIncluded}; use aurora_engine_types::H256; - -use crate::TransactionIncluded; +use std::fmt; #[derive(Debug, PartialEq, Clone)] pub enum Error { @@ -25,3 +25,47 @@ impl From for Error { Self::Borsh(e.to_string()) } } + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ParseTransactionKindError { + UnknownMethodName { + name: String, + }, + FailedDeserialization { + transaction_kind_tag: TransactionKindTag, + error_message: String, + }, +} + +impl ParseTransactionKindError { + pub fn failed_deserialization( + tag: TransactionKindTag, + error: Option, + ) -> Self { + Self::FailedDeserialization { + transaction_kind_tag: tag, + error_message: error.map(|e| format!("{e:?}")).unwrap_or_default(), + } + } +} + +impl fmt::Display for ParseTransactionKindError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::UnknownMethodName { name } => { + write!( + f, + "Error parsing transaction kind: Unknown method name {name}" + ) + } + Self::FailedDeserialization { + transaction_kind_tag, + error_message, + } => { + write!(f, "Error deserializing args for transaction of kind {transaction_kind_tag:?}. Error message: {error_message:?}") + } + } + } +} + +impl std::error::Error for ParseTransactionKindError {} diff --git a/engine-standalone-storage/src/sync/mod.rs b/engine-standalone-storage/src/sync/mod.rs index 0f32b33ba..407804dc8 100644 --- a/engine-standalone-storage/src/sync/mod.rs +++ b/engine-standalone-storage/src/sync/mod.rs @@ -2,21 +2,229 @@ use aurora_engine::parameters::SubmitArgs; use aurora_engine::pausables::{ EnginePrecompilesPauser, PausedPrecompilesManager, PrecompileFlags, }; -use aurora_engine::{connector, engine, parameters::SubmitResult, state, xcc}; +use aurora_engine::{ + connector, engine, + parameters::{self, SubmitResult}, + state, xcc, +}; use aurora_engine_modexp::ModExpAlgorithm; use aurora_engine_sdk::env::{self, Env, DEFAULT_PREPAID_GAS}; +use aurora_engine_transactions::EthTransactionKind; use aurora_engine_types::{ account_id::AccountId, + borsh::BorshDeserialize, parameters::PromiseWithCallbackArgs, types::{Address, Yocto}, H256, }; +use std::{io, str::FromStr}; pub mod types; use crate::engine_state::EngineStateAccess; -use crate::{BlockMetadata, Diff, Storage}; -use types::{Message, TransactionKind, TransactionMessage}; +use crate::{error::ParseTransactionKindError, BlockMetadata, Diff, Storage}; +use types::{Message, TransactionKind, TransactionKindTag, TransactionMessage}; + +/// Try to parse an Aurora transaction from raw information available in a Near action +/// (method name, input bytes, data returned from promises). +#[allow(clippy::too_many_lines)] +pub fn parse_transaction_kind( + method_name: &str, + bytes: Vec, + promise_data: &[Option>], +) -> Result { + let tx_kind_tag = TransactionKindTag::from_str(method_name).map_err(|_| { + ParseTransactionKindError::UnknownMethodName { + name: method_name.into(), + } + })?; + let f = |e: io::Error| ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)); + + let tx_kind = match tx_kind_tag { + TransactionKindTag::Submit => { + let eth_tx = EthTransactionKind::try_from(bytes.as_slice()).map_err(|e| { + ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)) + })?; + TransactionKind::Submit(eth_tx) + } + TransactionKindTag::SubmitWithArgs => { + let args = parameters::SubmitArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::SubmitWithArgs(args) + } + TransactionKindTag::Call => { + let call_args = parameters::CallArgs::deserialize(&bytes).ok_or_else(|| { + ParseTransactionKindError::failed_deserialization::(tx_kind_tag, None) + })?; + TransactionKind::Call(call_args) + } + TransactionKindTag::PausePrecompiles => { + let args = parameters::PausePrecompilesCallArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::PausePrecompiles(args) + } + TransactionKindTag::ResumePrecompiles => { + let args = parameters::PausePrecompilesCallArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::ResumePrecompiles(args) + } + TransactionKindTag::SetOwner => { + let args = parameters::SetOwnerArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::SetOwner(args) + } + TransactionKindTag::Deploy => TransactionKind::Deploy(bytes), + TransactionKindTag::DeployErc20 => { + let deploy_args = + parameters::DeployErc20TokenArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::DeployErc20(deploy_args) + } + TransactionKindTag::FtOnTransfer => { + let transfer_args: parameters::NEP141FtOnTransferArgs = + serde_json::from_slice(bytes.as_slice()).map_err(|e| { + ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)) + })?; + + TransactionKind::FtOnTransfer(transfer_args) + } + TransactionKindTag::Deposit => TransactionKind::Deposit(bytes), + TransactionKindTag::FtTransferCall => { + let transfer_args: parameters::TransferCallCallArgs = + serde_json::from_slice(bytes.as_slice()).map_err(|e| { + ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)) + })?; + + TransactionKind::FtTransferCall(transfer_args) + } + TransactionKindTag::FinishDeposit => { + let args = parameters::FinishDepositCallArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::FinishDeposit(args) + } + TransactionKindTag::ResolveTransfer => { + let args = parameters::ResolveTransferCallArgs::try_from_slice(&bytes).map_err(f)?; + let promise_result = promise_data + .first() + .and_then(Option::as_ref) + .map_or(aurora_engine_types::types::PromiseResult::Failed, |bytes| { + aurora_engine_types::types::PromiseResult::Successful(bytes.clone()) + }); + TransactionKind::ResolveTransfer(args, promise_result) + } + TransactionKindTag::FtTransfer => { + let args: parameters::TransferCallArgs = serde_json::from_slice(bytes.as_slice()) + .map_err(|e| { + ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)) + })?; + + TransactionKind::FtTransfer(args) + } + TransactionKindTag::Withdraw => { + let args = aurora_engine_types::parameters::WithdrawCallArgs::try_from_slice(&bytes) + .map_err(f)?; + TransactionKind::Withdraw(args) + } + TransactionKindTag::StorageDeposit => { + let args: parameters::StorageDepositCallArgs = serde_json::from_slice(bytes.as_slice()) + .map_err(|e| { + ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)) + })?; + + TransactionKind::StorageDeposit(args) + } + TransactionKindTag::StorageUnregister => { + let json_args: serde_json::Value = + serde_json::from_slice(bytes.as_slice()).map_err(|e| { + ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)) + })?; + let force = json_args + .as_object() + .and_then(|x| x.get("force")) + .and_then(serde_json::Value::as_bool); + + TransactionKind::StorageUnregister(force) + } + TransactionKindTag::StorageWithdraw => { + let args: parameters::StorageWithdrawCallArgs = + serde_json::from_slice(bytes.as_slice()).map_err(|e| { + ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)) + })?; + + TransactionKind::StorageWithdraw(args) + } + TransactionKindTag::SetPausedFlags => { + let args = parameters::PauseEthConnectorCallArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::SetPausedFlags(args) + } + TransactionKindTag::RegisterRelayer => { + let address = Address::try_from_slice(&bytes).map_err(|e| { + ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)) + })?; + TransactionKind::RegisterRelayer(address) + } + TransactionKindTag::RefundOnError => match promise_data.first().and_then(Option::as_ref) { + None => TransactionKind::RefundOnError(None), + Some(_) => { + let args = aurora_engine_types::parameters::RefundCallArgs::try_from_slice(&bytes) + .map_err(f)?; + TransactionKind::RefundOnError(Some(args)) + } + }, + TransactionKindTag::SetConnectorData => { + let args = parameters::SetContractDataCallArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::SetConnectorData(args) + } + TransactionKindTag::NewConnector => { + let args = parameters::InitCallArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::NewConnector(args) + } + TransactionKindTag::NewEngine => { + let args = parameters::NewCallArgs::deserialize(&bytes).map_err(|e| { + ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)) + })?; + TransactionKind::NewEngine(args) + } + TransactionKindTag::FactoryUpdate => TransactionKind::FactoryUpdate(bytes), + TransactionKindTag::FactoryUpdateAddressVersion => { + let args = + aurora_engine::xcc::AddressVersionUpdateArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::FactoryUpdateAddressVersion(args) + } + TransactionKindTag::FactorySetWNearAddress => { + let address = Address::try_from_slice(&bytes).map_err(|e| { + ParseTransactionKindError::failed_deserialization(tx_kind_tag, Some(e)) + })?; + TransactionKind::FactorySetWNearAddress(address) + } + TransactionKindTag::SetUpgradeDelayBlocks => { + let args = aurora_engine::parameters::SetUpgradeDelayBlocksArgs::try_from_slice(&bytes) + .map_err(f)?; + TransactionKind::SetUpgradeDelayBlocks(args) + } + TransactionKindTag::FundXccSubAccound => { + let args = aurora_engine::xcc::FundXccArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::FundXccSubAccound(args) + } + TransactionKindTag::PauseContract => TransactionKind::PauseContract, + TransactionKindTag::ResumeContract => TransactionKind::ResumeContract, + TransactionKindTag::SetKeyManager => { + let args = aurora_engine::parameters::RelayerKeyManagerArgs::try_from_slice(&bytes) + .map_err(f)?; + TransactionKind::SetKeyManager(args) + } + TransactionKindTag::AddRelayerKey => { + let args = + aurora_engine::parameters::RelayerKeyArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::AddRelayerKey(args) + } + TransactionKindTag::RemoveRelayerKey => { + let args = + aurora_engine::parameters::RelayerKeyArgs::try_from_slice(&bytes).map_err(f)?; + TransactionKind::RemoveRelayerKey(args) + } + TransactionKindTag::Unknown => { + return Err(ParseTransactionKindError::UnknownMethodName { + name: method_name.into(), + }); + } + }; + Ok(tx_kind) +} pub fn consume_message( storage: &mut Storage, diff --git a/engine-standalone-storage/src/sync/types.rs b/engine-standalone-storage/src/sync/types.rs index 1c702aa8b..cab2209a8 100644 --- a/engine-standalone-storage/src/sync/types.rs +++ b/engine-standalone-storage/src/sync/types.rs @@ -10,6 +10,7 @@ use aurora_engine_types::{ H256, U256, }; use std::borrow::Cow; +use strum::EnumString; /// Type describing the format of messages sent to the storage layer for keeping /// it in sync with the blockchain. @@ -407,6 +408,122 @@ impl TransactionKind { } } +#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumString)] +pub enum TransactionKindTag { + #[strum(serialize = "submit")] + Submit, + #[strum(serialize = "call")] + Call, + #[strum(serialize = "pause_precompiles")] + PausePrecompiles, + #[strum(serialize = "resume_precompiles")] + ResumePrecompiles, + #[strum(serialize = "deploy_code")] + Deploy, + #[strum(serialize = "deploy_erc20_token")] + DeployErc20, + #[strum(serialize = "ft_on_transfer")] + FtOnTransfer, + #[strum(serialize = "deposit")] + Deposit, + #[strum(serialize = "ft_transfer_call")] + FtTransferCall, + #[strum(serialize = "finish_deposit")] + FinishDeposit, + #[strum(serialize = "ft_resolve_transfer")] + ResolveTransfer, + #[strum(serialize = "ft_transfer")] + FtTransfer, + #[strum(serialize = "withdraw")] + Withdraw, + #[strum(serialize = "storage_deposit")] + StorageDeposit, + #[strum(serialize = "storage_unregister")] + StorageUnregister, + #[strum(serialize = "storage_withdraw")] + StorageWithdraw, + #[strum(serialize = "set_paused_flags")] + SetPausedFlags, + #[strum(serialize = "register_relayer")] + RegisterRelayer, + #[strum(serialize = "refund_on_error")] + RefundOnError, + #[strum(serialize = "set_eth_connector_contract_data")] + SetConnectorData, + #[strum(serialize = "new_eth_connector")] + NewConnector, + #[strum(serialize = "new")] + NewEngine, + #[strum(serialize = "factory_update")] + FactoryUpdate, + #[strum(serialize = "factory_update_address_version")] + FactoryUpdateAddressVersion, + #[strum(serialize = "factory_set_wnear_address")] + FactorySetWNearAddress, + #[strum(serialize = "set_owner")] + SetOwner, + #[strum(serialize = "submit_with_args")] + SubmitWithArgs, + #[strum(serialize = "set_upgrade_delay_blocks")] + SetUpgradeDelayBlocks, + #[strum(serialize = "fund_xcc_sub_account")] + FundXccSubAccound, + #[strum(serialize = "pause_contract")] + PauseContract, + #[strum(serialize = "resume_contract")] + ResumeContract, + #[strum(serialize = "set_key_manager")] + SetKeyManager, + #[strum(serialize = "add_relayer_key")] + AddRelayerKey, + #[strum(serialize = "remove_relayer_key")] + RemoveRelayerKey, + Unknown, +} + +/// Used to make sure `TransactionKindTag` is kept in sync with `TransactionKind` +impl From<&TransactionKind> for TransactionKindTag { + fn from(tx: &TransactionKind) -> Self { + match tx { + TransactionKind::Submit(_) => Self::Submit, + TransactionKind::Call(_) => Self::Call, + TransactionKind::PausePrecompiles(_) => Self::PausePrecompiles, + TransactionKind::ResumePrecompiles(_) => Self::ResumePrecompiles, + TransactionKind::Deploy(_) => Self::Deploy, + TransactionKind::DeployErc20(_) => Self::DeployErc20, + TransactionKind::FtOnTransfer(_) => Self::FtOnTransfer, + TransactionKind::Deposit(_) => Self::Deposit, + TransactionKind::FtTransferCall(_) => Self::FtTransferCall, + TransactionKind::FinishDeposit(_) => Self::FinishDeposit, + TransactionKind::ResolveTransfer(_, _) => Self::ResolveTransfer, + TransactionKind::FtTransfer(_) => Self::FtTransfer, + TransactionKind::Withdraw(_) => Self::Withdraw, + TransactionKind::StorageDeposit(_) => Self::StorageDeposit, + TransactionKind::StorageUnregister(_) => Self::StorageUnregister, + TransactionKind::StorageWithdraw(_) => Self::StorageWithdraw, + TransactionKind::SetPausedFlags(_) => Self::SetPausedFlags, + TransactionKind::RegisterRelayer(_) => Self::RegisterRelayer, + TransactionKind::RefundOnError(_) => Self::RefundOnError, + TransactionKind::SetConnectorData(_) => Self::SetConnectorData, + TransactionKind::NewConnector(_) => Self::NewConnector, + TransactionKind::NewEngine(_) => Self::NewEngine, + TransactionKind::FactoryUpdate(_) => Self::FactoryUpdate, + TransactionKind::FactoryUpdateAddressVersion(_) => Self::FactoryUpdateAddressVersion, + TransactionKind::FactorySetWNearAddress(_) => Self::FactorySetWNearAddress, + TransactionKind::SetOwner(_) => Self::SetOwner, + TransactionKind::SubmitWithArgs(_) => Self::SubmitWithArgs, + TransactionKind::SetUpgradeDelayBlocks(_) => Self::SetUpgradeDelayBlocks, + TransactionKind::FundXccSubAccound(_) => Self::FundXccSubAccound, + TransactionKind::PauseContract => Self::PauseContract, + TransactionKind::ResumeContract => Self::ResumeContract, + TransactionKind::SetKeyManager(_) => Self::SetKeyManager, + TransactionKind::AddRelayerKey(_) => Self::AddRelayerKey, + TransactionKind::RemoveRelayerKey(_) => Self::RemoveRelayerKey, + TransactionKind::Unknown => Self::Unknown, + } + } +} + /// This data type represents `TransactionMessage` above in the way consistent with how it is /// stored on disk (in the DB). This type implements borsh (de)serialization. The purpose of /// having a private struct for borsh, which is separate from the main `TransactionMessage` diff --git a/engine-tests/src/tests/contract_call.rs b/engine-tests/src/tests/contract_call.rs index d061059f5..f8856cb79 100644 --- a/engine-tests/src/tests/contract_call.rs +++ b/engine-tests/src/tests/contract_call.rs @@ -2,7 +2,7 @@ use crate::prelude::{parameters::SubmitResult, vec, Address, Wei, H256, U256}; use crate::utils::solidity::exit_precompile::{ Tester, TesterConstructor, DEST_ACCOUNT, DEST_ADDRESS, }; -use crate::utils::{self, AuroraRunner, Signer, ORIGIN}; +use crate::utils::{self, AuroraRunner, Signer, DEFAULT_AURORA_ACCOUNT_ID}; fn setup_test() -> (AuroraRunner, Signer, Address, Tester) { let mut runner = AuroraRunner::new(); @@ -26,7 +26,12 @@ fn setup_test() -> (AuroraRunner, Signer, Address, Tester) { .into(); runner - .mint(token, tester.contract.address, 1_000_000_000, ORIGIN) + .mint( + token, + tester.contract.address, + 1_000_000_000, + DEFAULT_AURORA_ACCOUNT_ID, + ) .unwrap(); (runner, signer, token, tester) diff --git a/engine-tests/src/tests/erc20_connector.rs b/engine-tests/src/tests/erc20_connector.rs index 9bddd2305..8578ece1b 100644 --- a/engine-tests/src/tests/erc20_connector.rs +++ b/engine-tests/src/tests/erc20_connector.rs @@ -1,5 +1,5 @@ use crate::prelude::{Address, Balance, Wei, WeiU256, U256}; -use crate::utils::{self, create_eth_transaction, AuroraRunner, ORIGIN}; +use crate::utils::{self, create_eth_transaction, AuroraRunner, DEFAULT_AURORA_ACCOUNT_ID}; use aurora_engine::engine::EngineError; use aurora_engine::parameters::{CallArgs, FunctionCallArgsV2}; use aurora_engine_transactions::legacy::LegacyEthSignedTransaction; @@ -92,7 +92,11 @@ impl AuroraRunner { pub fn deploy_erc20_token(&mut self, nep141: &str) -> Address { let result = self - .make_call("deploy_erc20_token", ORIGIN, nep141.try_to_vec().unwrap()) + .make_call( + "deploy_erc20_token", + DEFAULT_AURORA_ACCOUNT_ID, + nep141.try_to_vec().unwrap(), + ) .unwrap(); Vec::try_from_slice(&result.return_data.as_value().unwrap()) @@ -217,11 +221,11 @@ fn test_mint() { let mut runner = AuroraRunner::new(); let token = runner.deploy_erc20_token("tt.testnet"); let address = runner.create_account().address; - let balance = runner.balance_of(token, address, ORIGIN); + let balance = runner.balance_of(token, address, DEFAULT_AURORA_ACCOUNT_ID); assert_eq!(balance, U256::from(0)); let amount = 10; - let _result = runner.mint(token, address, amount, ORIGIN); - let balance = runner.balance_of(token, address, ORIGIN); + let _result = runner.mint(token, address, amount, DEFAULT_AURORA_ACCOUNT_ID); + let balance = runner.balance_of(token, address, DEFAULT_AURORA_ACCOUNT_ID); assert_eq!(balance, U256::from(amount)); } @@ -230,11 +234,11 @@ fn test_mint_not_admin() { let mut runner = AuroraRunner::new(); let token = runner.deploy_erc20_token("tt.testnet"); let address = runner.create_account().address; - let balance = runner.balance_of(token, address, ORIGIN); + let balance = runner.balance_of(token, address, DEFAULT_AURORA_ACCOUNT_ID); assert_eq!(balance, U256::from(0)); let amount = 10; runner.mint(token, address, amount, "not_admin").unwrap(); - let balance = runner.balance_of(token, address, ORIGIN); + let balance = runner.balance_of(token, address, DEFAULT_AURORA_ACCOUNT_ID); assert_eq!(balance, U256::from(0)); } @@ -249,14 +253,14 @@ fn test_ft_on_transfer() { let amount = Balance::new(10); let recipient = runner.create_account().address; - let balance = runner.balance_of(token, recipient, ORIGIN); + let balance = runner.balance_of(token, recipient, DEFAULT_AURORA_ACCOUNT_ID); assert_eq!(balance, U256::from(0)); let res = runner.ft_on_transfer(nep141, alice, alice, amount, &recipient.encode()); // Transaction should succeed so return amount is 0 assert_eq!(res, "\"0\""); - let balance = runner.balance_of(token, recipient, ORIGIN); + let balance = runner.balance_of(token, recipient, DEFAULT_AURORA_ACCOUNT_ID); assert_eq!(balance, U256::from(amount.as_u128())); } @@ -294,7 +298,7 @@ fn test_relayer_charge_fee() { let relayer_balance = runner.get_balance(relayer); assert_eq!(relayer_balance, Wei::zero()); - let balance = runner.balance_of(token, recipient, ORIGIN); + let balance = runner.balance_of(token, recipient, DEFAULT_AURORA_ACCOUNT_ID); assert_eq!(balance, U256::from(0)); let fee_encoded = &mut [0; 32]; @@ -316,7 +320,7 @@ fn test_relayer_charge_fee() { let relayer_balance = runner.get_balance(relayer); assert_eq!(relayer_balance, Wei::new_u64(fee)); - let balance = runner.balance_of(token, recipient, ORIGIN); + let balance = runner.balance_of(token, recipient, DEFAULT_AURORA_ACCOUNT_ID); assert_eq!(balance, U256::from(amount.as_u128())); } @@ -331,31 +335,39 @@ fn test_transfer_erc20_token() { let to_transfer = 43; assert_eq!( - runner.balance_of(token, peer0.address, ORIGIN), + runner.balance_of(token, peer0.address, DEFAULT_AURORA_ACCOUNT_ID), U256::zero() ); assert_eq!( - runner.balance_of(token, peer1.address, ORIGIN), + runner.balance_of(token, peer1.address, DEFAULT_AURORA_ACCOUNT_ID), U256::zero() ); - runner.mint(token, peer0.address, to_mint, ORIGIN).unwrap(); + runner + .mint(token, peer0.address, to_mint, DEFAULT_AURORA_ACCOUNT_ID) + .unwrap(); assert_eq!( - runner.balance_of(token, peer0.address, ORIGIN), + runner.balance_of(token, peer0.address, DEFAULT_AURORA_ACCOUNT_ID), U256::from(to_mint) ); runner - .transfer_erc20(token, peer0.secret_key, peer1.address, to_transfer, ORIGIN) + .transfer_erc20( + token, + peer0.secret_key, + peer1.address, + to_transfer, + DEFAULT_AURORA_ACCOUNT_ID, + ) .unwrap(); assert_eq!( - runner.balance_of(token, peer0.address, ORIGIN), + runner.balance_of(token, peer0.address, DEFAULT_AURORA_ACCOUNT_ID), U256::from(to_mint - to_transfer) ); assert_eq!( - runner.balance_of(token, peer1.address, ORIGIN), + runner.balance_of(token, peer1.address, DEFAULT_AURORA_ACCOUNT_ID), U256::from(to_transfer) ); } diff --git a/engine-tests/src/tests/modexp.rs b/engine-tests/src/tests/modexp.rs index eb37cbe76..07c1bc4f8 100644 --- a/engine-tests/src/tests/modexp.rs +++ b/engine-tests/src/tests/modexp.rs @@ -318,6 +318,8 @@ impl Default for ModExpBenchContext { std::fs::read(output_path).unwrap() }; + // Standalone not relevant here because this is not an Aurora Engine instance + inner.standalone_runner = None; inner.wasm_config.limit_config.max_gas_burnt = u64::MAX; inner.code = ContractCode::new(bench_contract_bytes, None); diff --git a/engine-tests/src/tests/pausable_precompiles.rs b/engine-tests/src/tests/pausable_precompiles.rs index 7d86820c1..bd975d9e3 100644 --- a/engine-tests/src/tests/pausable_precompiles.rs +++ b/engine-tests/src/tests/pausable_precompiles.rs @@ -1,7 +1,8 @@ use crate::prelude::{Address, U256}; use crate::utils::solidity::exit_precompile::{Tester, TesterConstructor}; use crate::utils::{ - self, AuroraRunner, Signer, ORIGIN, PAUSED_PRECOMPILES, PAUSE_PRECOMPILES, RESUME_PRECOMPILES, + self, AuroraRunner, Signer, DEFAULT_AURORA_ACCOUNT_ID, PAUSED_PRECOMPILES, PAUSE_PRECOMPILES, + RESUME_PRECOMPILES, }; use aurora_engine::engine::EngineErrorKind; use aurora_engine::parameters::{PausePrecompilesCallArgs, TransactionStatus}; @@ -24,6 +25,7 @@ fn test_paused_precompile_is_shown_when_viewing() { let _res = runner.call(PAUSE_PRECOMPILES, CALLED_ACCOUNT_ID, input.clone()); let result = runner + .one_shot() .call(PAUSED_PRECOMPILES, CALLED_ACCOUNT_ID, Vec::new()) .unwrap(); let output = result.return_data.as_value().unwrap(); @@ -130,7 +132,12 @@ fn setup_test() -> (AuroraRunner, Signer, Address, Tester) { .into(); runner - .mint(token, tester.contract.address, 1_000_000_000, ORIGIN) + .mint( + token, + tester.contract.address, + 1_000_000_000, + DEFAULT_AURORA_ACCOUNT_ID, + ) .unwrap(); (runner, signer, token, tester) diff --git a/engine-tests/src/tests/pause_contract.rs b/engine-tests/src/tests/pause_contract.rs index 5d810f6b2..ce068ab72 100644 --- a/engine-tests/src/tests/pause_contract.rs +++ b/engine-tests/src/tests/pause_contract.rs @@ -73,7 +73,9 @@ fn test_pause_contract() { .unwrap(); // contract is running by default, gets and sets should work - let result = runner.call("get_upgrade_delay_blocks", &aurora_account_id, vec![]); + let result = runner + .one_shot() + .call("get_upgrade_delay_blocks", &aurora_account_id, vec![]); assert!(result.is_ok()); let result = runner.call("set_upgrade_delay_blocks", &aurora_account_id, set.clone()); @@ -84,7 +86,9 @@ fn test_pause_contract() { assert!(result.is_ok()); // contract is paused, gets should still work but sets should fail - let result = runner.call("get_upgrade_delay_blocks", &aurora_account_id, vec![]); + let result = runner + .one_shot() + .call("get_upgrade_delay_blocks", &aurora_account_id, vec![]); assert!(result.is_ok()); let result = runner.call("set_upgrade_delay_blocks", &aurora_account_id, set); @@ -110,7 +114,9 @@ fn test_resume_contract() { assert!(result.is_ok()); // contract is running again, gets and sets should work - let result = runner.call("get_upgrade_delay_blocks", &aurora_account_id, vec![]); + let result = runner + .one_shot() + .call("get_upgrade_delay_blocks", &aurora_account_id, vec![]); assert!(result.is_ok()); let result = runner.call("set_upgrade_delay_blocks", &aurora_account_id, set); diff --git a/engine-tests/src/tests/repro.rs b/engine-tests/src/tests/repro.rs index 6aa643d8e..fbc58722b 100644 --- a/engine-tests/src/tests/repro.rs +++ b/engine-tests/src/tests/repro.rs @@ -1,7 +1,6 @@ //! A module containing tests which reproduce transactions sent to live networks. -use crate::utils::{standalone, ORIGIN}; -use crate::utils::{AuroraRunner, ExecutionProfile}; +use crate::utils::{standalone, AuroraRunner, ExecutionProfile}; use aurora_engine::parameters::SubmitResult; use aurora_engine_types::borsh::{BorshDeserialize, BorshSerialize}; use engine_standalone_storage::json_snapshot; @@ -142,7 +141,10 @@ fn repro_common(context: &ReproContext) { let snapshot = json_snapshot::types::JsonSnapshot::load_from_file(snapshot_path).unwrap(); - let mut runner = AuroraRunner::default(); + let mut runner = AuroraRunner { + standalone_runner: None, // Turn off standalone here, validated separately below + ..Default::default() + }; runner.wasm_config.limit_config.max_gas_burnt = 3_000_000_000_000_000; runner.context.storage_usage = 1_000_000_000; runner.consume_json_snapshot(snapshot.clone()); @@ -167,10 +169,6 @@ fn repro_common(context: &ReproContext) { // Also validate the SubmitResult in the standalone engine let mut standalone = standalone::StandaloneRunner::default(); - standalone - .storage - .set_engine_account_id(&ORIGIN.parse().unwrap()) - .unwrap(); json_snapshot::initialize_engine_state(&mut standalone.storage, snapshot).unwrap(); let standalone_result = standalone .submit_raw("submit", &runner.context, &[]) diff --git a/engine-tests/src/tests/sanity.rs b/engine-tests/src/tests/sanity.rs index d5e6539fa..a7f2abf9a 100644 --- a/engine-tests/src/tests/sanity.rs +++ b/engine-tests/src/tests/sanity.rs @@ -44,8 +44,10 @@ fn test_total_supply_accounting() { constructor.deployed_at(contract_address) }; - let get_total_supply = |runner: &mut utils::AuroraRunner| -> Wei { - let result = runner.call("ft_total_eth_supply_on_aurora", "aurora", Vec::new()); + let get_total_supply = |runner: &utils::AuroraRunner| -> Wei { + let result = runner + .one_shot() + .call("ft_total_eth_supply_on_aurora", "aurora", Vec::new()); let amount: u128 = String::from_utf8(result.unwrap().return_data.as_value().unwrap()) .unwrap() .replace('"', "") @@ -897,9 +899,10 @@ fn test_block_hash() { #[test] fn test_block_hash_api() { - let mut runner = utils::deploy_runner(); + let runner = utils::deploy_runner(); let block_height: u64 = 10; let outcome = runner + .one_shot() .call( "get_block_hash", "any.near", @@ -941,9 +944,12 @@ fn test_block_hash_contract() { #[test] fn test_ft_metadata() { - let mut runner = utils::deploy_runner(); + let runner = utils::deploy_runner(); let account_id: String = runner.context.signer_account_id.clone().into(); - let outcome = runner.call("ft_metadata", &account_id, Vec::new()).unwrap(); + let outcome = runner + .one_shot() + .call("ft_metadata", &account_id, Vec::new()) + .unwrap(); let metadata = serde_json::from_slice::(&outcome.return_data.as_value().unwrap()) .unwrap(); @@ -1009,6 +1015,7 @@ fn test_set_owner() { // get owner to see if the owner_id property has changed let outcome = runner + .one_shot() .call("get_owner", &aurora_account_id, vec![]) .unwrap(); @@ -1064,7 +1071,9 @@ fn test_set_upgrade_delay_blocks() { assert!(result.is_ok()); // get upgrade_delay_blocks to see if the upgrade_delay_blocks property has changed - let result = runner.call("get_upgrade_delay_blocks", &aurora_account_id, vec![]); + let result = runner + .one_shot() + .call("get_upgrade_delay_blocks", &aurora_account_id, vec![]); // check if the query goes through the standalone runner assert!(result.is_ok()); diff --git a/engine-tests/src/tests/xcc.rs b/engine-tests/src/tests/xcc.rs index 9b6f9e5de..0b16e5335 100644 --- a/engine-tests/src/tests/xcc.rs +++ b/engine-tests/src/tests/xcc.rs @@ -1,5 +1,5 @@ use crate::utils::solidity::erc20::{ERC20Constructor, ERC20}; -use crate::utils::{self, AuroraRunner, ORIGIN}; +use crate::utils::{self, AuroraRunner, DEFAULT_AURORA_ACCOUNT_ID}; use aurora_engine_precompiles::xcc::{costs, cross_contract_call}; use aurora_engine_transactions::legacy::TransactionLegacy; use aurora_engine_types::account_id::AccountId; @@ -24,7 +24,7 @@ fn test_xcc_eth_gas_cost() { let mut runner = utils::deploy_runner(); runner.standalone_runner = None; let xcc_wasm_bytes = contract_bytes(); - let _res = runner.call("factory_update", ORIGIN, xcc_wasm_bytes); + let _res = runner.call("factory_update", DEFAULT_AURORA_ACCOUNT_ID, xcc_wasm_bytes); let mut signer = utils::Signer::random(); let mut baseline_signer = utils::Signer::random(); runner.context.block_height = aurora_engine::engine::ZERO_ADDRESS_FIX_HEIGHT + 1; @@ -44,7 +44,7 @@ fn test_xcc_eth_gas_cost() { ); let _res = runner.call( "factory_set_wnear_address", - ORIGIN, + DEFAULT_AURORA_ACCOUNT_ID, wnear_erc20.0.address.as_bytes().to_vec(), ); @@ -189,7 +189,7 @@ fn test_xcc_schedule_gas() { let outcome = router .call( "schedule", - ORIGIN, + DEFAULT_AURORA_ACCOUNT_ID, PromiseArgs::Create(promise).try_to_vec().unwrap(), ) .unwrap(); @@ -231,7 +231,11 @@ fn test_xcc_exec_gas() { let args = PromiseArgs::Recursive(x); let outcome = router - .call("execute", ORIGIN, args.try_to_vec().unwrap()) + .call( + "execute", + DEFAULT_AURORA_ACCOUNT_ID, + args.try_to_vec().unwrap(), + ) .unwrap(); let callback_count = args.promise_count() - 1; let router_exec_cost = costs::ROUTER_EXEC_BASE @@ -273,12 +277,18 @@ fn deploy_router() -> AuroraRunner { ..Default::default() }; + // Standalone not relevant here because this is not an Aurora Engine instance + router.standalone_runner = None; router.context.current_account_id = "some_address.aurora".parse().unwrap(); - router.context.predecessor_account_id = ORIGIN.parse().unwrap(); + router.context.predecessor_account_id = DEFAULT_AURORA_ACCOUNT_ID.parse().unwrap(); let init_args = r#"{"wnear_account": "wrap.near", "must_register": true}"#; let outcome = router - .call("initialize", ORIGIN, init_args.as_bytes().to_vec()) + .call( + "initialize", + DEFAULT_AURORA_ACCOUNT_ID, + init_args.as_bytes().to_vec(), + ) .unwrap(); assert!(outcome.used_gas < aurora_engine::xcc::INITIALIZE_GAS.as_u64()); diff --git a/engine-tests/src/utils/mod.rs b/engine-tests/src/utils/mod.rs index 2a0087f60..b314d01be 100644 --- a/engine-tests/src/utils/mod.rs +++ b/engine-tests/src/utils/mod.rs @@ -31,20 +31,13 @@ use crate::prelude::transactions::{ use crate::prelude::{sdk, Address, Wei, H256, U256}; use crate::utils::solidity::{ContractConstructor, DeployedContract}; -// TODO(Copied from #84): Make sure that there is only one Signer after both PR are merged. -pub const ORIGIN: &str = "aurora"; +pub const DEFAULT_AURORA_ACCOUNT_ID: &str = "aurora"; pub const SUBMIT: &str = "submit"; pub const SUBMIT_WITH_ARGS: &str = "submit_with_args"; -pub const CALL: &str = "call"; -pub const DEPLOY_ERC20: &str = "deploy_erc20_token"; pub const PAUSE_PRECOMPILES: &str = "pause_precompiles"; pub const PAUSED_PRECOMPILES: &str = "paused_precompiles"; pub const RESUME_PRECOMPILES: &str = "resume_precompiles"; -pub const SET_OWNER: &str = "set_owner"; -pub const SET_UPGRADE_DELAY_BLOCKS: &str = "set_upgrade_delay_blocks"; -pub const PAUSE_CONTRACT: &str = "pause_contract"; -pub const RESUME_CONTRACT: &str = "resume_contract"; -pub const SET_KEY_MANAGER: &str = "set_key_manager"; +pub const DEFAULT_CHAIN_ID: u64 = 1_313_161_556; // NEAR localnet const CALLER_ACCOUNT_ID: &str = "some-account.near"; @@ -234,21 +227,8 @@ impl AuroraRunner { self.previous_logs = outcome.logs.clone(); if let Some(standalone_runner) = &mut self.standalone_runner { - if method_name == SUBMIT - || method_name == SUBMIT_WITH_ARGS - || method_name == CALL - || method_name == DEPLOY_ERC20 - || method_name == PAUSE_PRECOMPILES - || method_name == RESUME_PRECOMPILES - || method_name == SET_OWNER - || method_name == SET_UPGRADE_DELAY_BLOCKS - || method_name == PAUSE_CONTRACT - || method_name == RESUME_CONTRACT - || method_name == SET_KEY_MANAGER - { - standalone_runner.submit_raw(method_name, &self.context, &self.promise_results)?; - self.validate_standalone(); - } + standalone_runner.submit_raw(method_name, &self.context, &self.promise_results)?; + self.validate_standalone(); } Ok(outcome) @@ -575,11 +555,12 @@ impl Default for AuroraRunner { let runtime_config_store = RuntimeConfigStore::new(None); let runtime_config = runtime_config_store.get_config(PROTOCOL_VERSION); let wasm_config = runtime_config.wasm_config.clone(); - let origin_account_id: near_primitives::types::AccountId = ORIGIN.parse().unwrap(); + let origin_account_id: near_primitives::types::AccountId = + DEFAULT_AURORA_ACCOUNT_ID.parse().unwrap(); Self { - aurora_account_id: ORIGIN.to_string(), - chain_id: 1_313_161_556, // NEAR localnet, + aurora_account_id: DEFAULT_AURORA_ACCOUNT_ID.to_string(), + chain_id: DEFAULT_CHAIN_ID, code: ContractCode::new(evm_wasm_bytes, None), cache: MockCompiledContractCache::default(), ext: mocked_external::MockedExternalWithTrie::new(MockedExternal::default()), @@ -605,7 +586,7 @@ impl Default for AuroraRunner { fees_config: RuntimeFeesConfig::test(), current_protocol_version: u32::MAX, previous_logs: Vec::new(), - standalone_runner: None, + standalone_runner: Some(standalone::StandaloneRunner::default()), promise_results: Vec::new(), } } @@ -659,12 +640,6 @@ pub fn deploy_runner() -> AuroraRunner { assert!(result.is_ok()); - let mut standalone_runner = standalone::StandaloneRunner::default(); - standalone_runner.init_evm(); - - runner.standalone_runner = Some(standalone_runner); - runner.validate_standalone(); - runner } diff --git a/engine-tests/src/utils/standalone/mocks/mod.rs b/engine-tests/src/utils/standalone/mocks/mod.rs index 0d1f35249..f43864a57 100644 --- a/engine-tests/src/utils/standalone/mocks/mod.rs +++ b/engine-tests/src/utils/standalone/mocks/mod.rs @@ -32,10 +32,7 @@ pub fn insert_block(storage: &mut Storage, block_height: u64) { } pub fn default_env(block_height: u64) -> aurora_engine_sdk::env::Fixed { - let aurora_id: AccountId = utils::AuroraRunner::default() - .aurora_account_id - .parse() - .unwrap(); + let aurora_id: AccountId = utils::DEFAULT_AURORA_ACCOUNT_ID.parse().unwrap(); aurora_engine_sdk::env::Fixed { signer_account_id: aurora_id.clone(), current_account_id: aurora_id.clone(), diff --git a/engine-tests/src/utils/standalone/mod.rs b/engine-tests/src/utils/standalone/mod.rs index 8a41ed5f7..0663d5a30 100644 --- a/engine-tests/src/utils/standalone/mod.rs +++ b/engine-tests/src/utils/standalone/mod.rs @@ -1,13 +1,8 @@ use aurora_engine::engine; -use aurora_engine::parameters::{ - CallArgs, DeployErc20TokenArgs, PausePrecompilesCallArgs, SetOwnerArgs, - SetUpgradeDelayBlocksArgs, SubmitArgs, SubmitResult, TransactionStatus, -}; +use aurora_engine::parameters::{SubmitResult, TransactionStatus}; use aurora_engine_modexp::AuroraModExp; use aurora_engine_sdk::env::{self, Env}; use aurora_engine_transactions::legacy::{LegacyEthSignedTransaction, TransactionLegacy}; -use aurora_engine_types::borsh::BorshDeserialize; -use aurora_engine_types::parameters::engine::RelayerKeyManagerArgs; use aurora_engine_types::types::{Address, NearGas, PromiseResult, Wei}; use aurora_engine_types::{H256, U256}; use engine_standalone_storage::{ @@ -202,195 +197,46 @@ impl StandaloneRunner { env.signer_account_id = ctx.signer_account_id.as_ref().parse().unwrap(); env.prepaid_gas = NearGas::new(ctx.prepaid_gas); + let promise_data: Vec<_> = promise_results + .iter() + .map(|r| match r { + PromiseResult::Successful(bytes) => Some(bytes.clone()), + PromiseResult::Failed | PromiseResult::NotReady => None, + }) + .collect(); + let transaction_kind = engine_standalone_storage::sync::parse_transaction_kind( + method_name, + ctx.input.clone(), + &promise_data, + ) + .expect("All method names must be known by standalone"); + + let transaction_hash = if let TransactionKind::SubmitWithArgs(args) = &transaction_kind { + aurora_engine_sdk::keccak(&args.tx_data) + } else { + aurora_engine_sdk::keccak(&ctx.input) + }; + let storage = &mut self.storage; - if method_name == utils::SUBMIT { - let transaction_bytes = &ctx.input; - Self::internal_submit_transaction( - transaction_bytes, - 0, - storage, - &mut env, - &mut self.cumulative_diff, - promise_results, - ) - } else if method_name == utils::SUBMIT_WITH_ARGS { - let submit_args = SubmitArgs::try_from_slice(&ctx.input).unwrap(); - let transaction_hash = aurora_engine_sdk::keccak(&submit_args.tx_data); - let mut tx_msg = - Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); - tx_msg.transaction = TransactionKind::SubmitWithArgs(submit_args); - - let outcome = - sync::execute_transaction_message::(storage, tx_msg).unwrap(); - self.cumulative_diff.append(outcome.diff.clone()); - storage::commit(storage, &outcome); - - unwrap_result(outcome) - } else if method_name == utils::CALL { - let call_args = CallArgs::try_from_slice(&ctx.input).unwrap(); - let transaction_hash = aurora_engine_sdk::keccak(&ctx.input); - let mut tx_msg = - Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); - tx_msg.transaction = TransactionKind::Call(call_args); - - let outcome = - sync::execute_transaction_message::(storage, tx_msg).unwrap(); - self.cumulative_diff.append(outcome.diff.clone()); - storage::commit(storage, &outcome); - - unwrap_result(outcome) - } else if method_name == utils::DEPLOY_ERC20 { - let deploy_args = DeployErc20TokenArgs::try_from_slice(&ctx.input).unwrap(); - let transaction_hash = aurora_engine_sdk::keccak(&ctx.input); - let mut tx_msg = - Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); - tx_msg.transaction = TransactionKind::DeployErc20(deploy_args); - - let outcome = - sync::execute_transaction_message::(storage, tx_msg).unwrap(); - self.cumulative_diff.append(outcome.diff.clone()); - storage::commit(storage, &outcome); - - let sync::TransactionExecutionResult::DeployErc20(address) = outcome.maybe_result.unwrap().unwrap() else { unreachable!() }; - - Ok(SubmitResult::new( + let mut tx_msg = Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); + tx_msg.transaction = transaction_kind; + + let outcome = sync::execute_transaction_message::(storage, tx_msg).unwrap(); + self.cumulative_diff.append(outcome.diff.clone()); + storage::commit(storage, &outcome); + + match outcome.maybe_result.unwrap() { + Some(sync::TransactionExecutionResult::Submit(result)) => result, + Some(sync::TransactionExecutionResult::DeployErc20(address)) => Ok(SubmitResult::new( TransactionStatus::Succeed(address.raw().as_ref().to_vec()), 0, Vec::new(), - )) - } else if method_name == utils::RESUME_PRECOMPILES { - let input = &ctx.input[..]; - let call_args = PausePrecompilesCallArgs::try_from_slice(input) - .expect("Unable to parse input as PausePrecompilesCallArgs"); - - let transaction_hash = aurora_engine_sdk::keccak(&ctx.input); - let mut tx_msg = - Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); - tx_msg.transaction = TransactionKind::ResumePrecompiles(call_args); - - let outcome = - sync::execute_transaction_message::(storage, tx_msg).unwrap(); - self.cumulative_diff.append(outcome.diff.clone()); - storage::commit(storage, &outcome); - - Ok(SubmitResult::new( - TransactionStatus::Succeed(Vec::new()), - 0, - Vec::new(), - )) - } else if method_name == utils::PAUSE_PRECOMPILES { - let input = &ctx.input[..]; - let call_args = PausePrecompilesCallArgs::try_from_slice(input) - .expect("Unable to parse input as PausePrecompilesCallArgs"); - - let transaction_hash = aurora_engine_sdk::keccak(&ctx.input); - let mut tx_msg = - Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); - tx_msg.transaction = TransactionKind::PausePrecompiles(call_args); - - let outcome = - sync::execute_transaction_message::(storage, tx_msg).unwrap(); - self.cumulative_diff.append(outcome.diff.clone()); - storage::commit(storage, &outcome); - - Ok(SubmitResult::new( + )), + _ => Ok(SubmitResult::new( TransactionStatus::Succeed(Vec::new()), 0, Vec::new(), - )) - } else if method_name == utils::SET_OWNER { - let input = &ctx.input[..]; - let call_args = - SetOwnerArgs::try_from_slice(input).expect("Unable to parse input as SetOwnerArgs"); - - let transaction_hash = aurora_engine_sdk::keccak(&ctx.input); - let mut tx_msg = - Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); - tx_msg.transaction = TransactionKind::SetOwner(call_args); - - let outcome = - sync::execute_transaction_message::(storage, tx_msg).unwrap(); - self.cumulative_diff.append(outcome.diff.clone()); - storage::commit(storage, &outcome); - - Ok(SubmitResult::new( - TransactionStatus::Succeed(Vec::new()), - 0, - Vec::new(), - )) - } else if method_name == utils::SET_UPGRADE_DELAY_BLOCKS { - let input = &ctx.input; - let call_args = SetUpgradeDelayBlocksArgs::try_from_slice(input) - .expect("Unable to parse input as SetUpgradeDelayBlocksArgs"); - - let transaction_hash = aurora_engine_sdk::keccak(&ctx.input); - let mut tx_msg = - Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); - tx_msg.transaction = TransactionKind::SetUpgradeDelayBlocks(call_args); - - let outcome = - sync::execute_transaction_message::(storage, tx_msg).unwrap(); - self.cumulative_diff.append(outcome.diff.clone()); - storage::commit(storage, &outcome); - - Ok(SubmitResult::new( - TransactionStatus::Succeed(Vec::new()), - 0, - Vec::new(), - )) - } else if method_name == utils::PAUSE_CONTRACT { - let transaction_hash = aurora_engine_sdk::keccak(&ctx.input); - let mut tx_msg = - Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); - tx_msg.transaction = TransactionKind::PauseContract; - - let outcome = - sync::execute_transaction_message::(storage, tx_msg).unwrap(); - self.cumulative_diff.append(outcome.diff.clone()); - storage::commit(storage, &outcome); - - Ok(SubmitResult::new( - TransactionStatus::Succeed(Vec::new()), - 0, - Vec::new(), - )) - } else if method_name == utils::RESUME_CONTRACT { - let transaction_hash = aurora_engine_sdk::keccak(&ctx.input); - let mut tx_msg = - Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); - tx_msg.transaction = TransactionKind::ResumeContract; - - let outcome = - sync::execute_transaction_message::(storage, tx_msg).unwrap(); - self.cumulative_diff.append(outcome.diff.clone()); - storage::commit(storage, &outcome); - - Ok(SubmitResult::new( - TransactionStatus::Succeed(Vec::new()), - 0, - Vec::new(), - )) - } else if method_name == utils::SET_KEY_MANAGER { - let transaction_hash = aurora_engine_sdk::keccak(&ctx.input); - let call_args: RelayerKeyManagerArgs = serde_json::from_slice(&ctx.input) - .expect("Unable to parse input as RelayerKeyManagerArgs"); - - let mut tx_msg = - Self::template_tx_msg(storage, &env, 0, transaction_hash, promise_results); - tx_msg.transaction = TransactionKind::SetKeyManager(call_args); - - let outcome = - sync::execute_transaction_message::(storage, tx_msg).unwrap(); - self.cumulative_diff.append(outcome.diff.clone()); - storage::commit(storage, &outcome); - - Ok(SubmitResult::new( - TransactionStatus::Succeed(Vec::new()), - 0, - Vec::new(), - )) - } else { - panic!("Unsupported standalone method {method_name}"); + )), } } @@ -500,14 +346,16 @@ fn unwrap_result( impl Default for StandaloneRunner { fn default() -> Self { - let (storage_dir, storage) = storage::create_db(); + let (storage_dir, mut storage) = storage::create_db(); let env = mocks::default_env(0); - let chain_id = utils::AuroraRunner::default().chain_id; + storage + .set_engine_account_id(&env.current_account_id) + .unwrap(); Self { storage_dir, storage, env, - chain_id, + chain_id: utils::DEFAULT_CHAIN_ID, cumulative_diff: Diff::default(), } }