@mainsail/evm 0.0.1-evm.51 → 0.0.1-evm.53

package/core/src/receipt.rs

@@ -0,0 +1,153 @@
+use revm::{
+    context::result::{ExecutionResult, Output},
+    primitives::{Bytes, Log},
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct TxReceipt {
+    pub gas_used: u64,
+    pub cumulative_gas_used: u64,
+    pub gas_refunded: u64,
+    pub success: u8,
+    pub contract_address: Option<String>,
+    pub logs: Option<Vec<Log>>,
+    pub output: Option<Bytes>,
+}
+
+pub fn map_execution_result(result: ExecutionResult, cumulative_gas_used: u64) -> TxReceipt {
+    match result {
+        ExecutionResult::Success {
+            gas, output, logs, ..
+        } => match output {
+            Output::Call(output) => TxReceipt {
+                gas_used: gas.tx_gas_used(),
+                gas_refunded: gas.inner_refunded(),
+                cumulative_gas_used,
+                success: 1,
+                contract_address: None,
+                logs: Some(logs),
+                output: Some(output),
+            },
+            Output::Create(output, address) => TxReceipt {
+                gas_used: gas.tx_gas_used(),
+                gas_refunded: gas.inner_refunded(),
+                cumulative_gas_used,
+                success: 1,
+                contract_address: address.map(|address| address.to_string()),
+                logs: Some(logs),
+                output: Some(output),
+            },
+        },
+        ExecutionResult::Revert { gas, output, .. } => TxReceipt {
+            gas_used: gas.tx_gas_used(),
+            success: 0,
+            cumulative_gas_used,
+            gas_refunded: 0,
+            contract_address: None,
+            logs: None,
+            output: Some(output),
+        },
+        ExecutionResult::Halt { gas, .. } => TxReceipt {
+            gas_used: gas.tx_gas_used(),
+            success: 0,
+            cumulative_gas_used,
+            gas_refunded: 0,
+            contract_address: None,
+            logs: None,
+            output: None,
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::receipt::map_execution_result;
+    use alloy_primitives::address;
+    use bytes::Bytes;
+    use revm::context::result::{ExecutionResult, HaltReason, Output, ResultGas, SuccessReason};
+
+    #[test]
+    fn test_map_execution_result_call() {
+        let result = ExecutionResult::Success {
+            reason: SuccessReason::Stop,
+            gas: ResultGas::new_with_state_gas(25000, 2100, 0, 0),
+            logs: vec![],
+            output: Output::Call(alloy_primitives::Bytes(Bytes::new())),
+        };
+
+        let output = map_execution_result(result, 0);
+
+        assert_eq!(output.contract_address, None);
+        assert_eq!(output.gas_used, 22900);
+        assert_eq!(output.cumulative_gas_used, 0);
+        assert_eq!(output.gas_refunded, 2100);
+        assert_eq!(output.logs, Some(vec![]));
+        assert_eq!(output.output, Some(alloy_primitives::Bytes(Bytes::new())));
+        assert_eq!(output.success, 1);
+    }
+
+    #[test]
+    fn test_map_execution_result_create() {
+        let result = ExecutionResult::Success {
+            reason: SuccessReason::Stop,
+            gas: ResultGas::new_with_state_gas(355_000, 0, 0, 0),
+            logs: vec![],
+            output: Output::Create(
+                alloy_primitives::Bytes(Bytes::new()),
+                Some(address!("0000000000000000000000000000000000000001")),
+            ),
+        };
+
+        let output = map_execution_result(result, 0);
+
+        assert_eq!(
+            output.contract_address,
+            Some(address!("0000000000000000000000000000000000000001").to_string())
+        );
+        assert_eq!(output.gas_used, 355_000);
+        assert_eq!(output.cumulative_gas_used, 0);
+        assert_eq!(output.gas_refunded, 0);
+        assert_eq!(output.logs, Some(vec![]));
+        assert_eq!(output.output, Some(alloy_primitives::Bytes(Bytes::new())));
+        assert_eq!(output.success, 1);
+    }
+
+    #[test]
+    fn test_map_execution_result_revert() {
+        let result = ExecutionResult::Revert {
+            gas: ResultGas::new_with_state_gas(30000, 0, 0, 0),
+            logs: vec![],
+            output: alloy_primitives::Bytes(Bytes::new()),
+        };
+
+        let output = map_execution_result(result, 0);
+
+        assert_eq!(output.contract_address, None);
+        assert_eq!(output.gas_used, 30000);
+        assert_eq!(output.cumulative_gas_used, 0);
+        assert_eq!(output.gas_refunded, 0);
+        assert_eq!(output.logs, None);
+        assert_eq!(output.output, Some(alloy_primitives::Bytes(Bytes::new())));
+        assert_eq!(output.success, 0);
+    }
+
+    #[test]
+    fn test_map_execution_result_halt() {
+        let result = ExecutionResult::Halt {
+            reason: HaltReason::StackOverflow,
+            gas: ResultGas::new_with_state_gas(30000, 0, 0, 0),
+            logs: vec![],
+        };
+
+        let output = map_execution_result(result, 0);
+
+        assert_eq!(output.contract_address, None);
+        assert_eq!(output.gas_used, 30000);
+        assert_eq!(output.cumulative_gas_used, 0);
+        assert_eq!(output.gas_refunded, 0);
+        assert_eq!(output.logs, None);
+        assert_eq!(output.output, None);
+        assert_eq!(output.success, 0);
+    }
+}

package/core/src/state_changes.rs

@@ -0,0 +1,122 @@
+use std::collections::BTreeMap;
+
+use revm::{
+    database::{BundleState, OriginalValuesKnown, states::StorageSlot},
+    primitives::{Address, B256, KECCAK_EMPTY, U256},
+    state::{AccountInfo, Bytecode},
+};
+use serde::Serialize;
+
+use crate::legacy::{LegacyAccountAttributes, LegacyAddress, LegacyColdWallet};
+
+/// Loosely based on https://github.com/bluealloy/revm/blob/v36/crates/revm/src/db/states/changes.rs and https://github.com/bluealloy/revm/blob/v36/crates/revm/src/db/states/bundle_state.rs#L449
+//
+/// The only change being that we preserve the old storage value.
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct StateChangeset {
+    /// Vector of **not** sorted accounts information.
+    pub accounts: Vec<(Address, Option<AccountInfo>)>,
+    /// Vector of **not** sorted storage.
+    pub storage: Vec<StorageChangeset>,
+    /// Vector of contracts by bytecode hash. **not** sorted.
+    pub contracts: Vec<(B256, Bytecode)>,
+    // Map of legacy attributes
+    pub legacy_attributes: BTreeMap<Address, LegacyAccountAttributes>,
+    // Map of legacy cold wallet
+    pub legacy_cold_wallets: BTreeMap<LegacyAddress, LegacyColdWallet>,
+    // Map of merged legacy cold wallets
+    pub merged_legacy_cold_wallets: BTreeMap<Address, (B256, LegacyAddress)>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
+pub struct StorageChangeset {
+    /// Address of account
+    pub address: Address,
+    /// Wipe storage,
+    pub wipe_storage: bool,
+    /// Storage key value pairs.
+    pub storage: Vec<(U256, StorageSlot)>,
+}
+
+#[derive(Default, Debug, PartialEq, Eq)]
+pub struct AccountUpdate {
+    pub address: Address,
+    pub balance: U256,
+    pub nonce: u64,
+    // Set when commit receipt contains "Voted" event
+    pub vote: Option<Address>,
+    // Set when commit receipt contains "Unvoted" event
+    pub unvote: Option<Address>,
+    // Set when commit receipt contains "UsernameRegistered" event
+    pub username: Option<String>,
+    // Set when commit receipt contains "UsernameResigned" event
+    pub username_resigned: bool,
+    // Set when merge with legacy cold wallet happened
+    pub merge_info: Option<AccountMergeInfo>,
+}
+
+#[derive(Default, Debug, PartialEq, Eq)]
+pub struct AccountMergeInfo {
+    pub legacy_address: LegacyAddress,
+    pub transaction_hash: B256,
+}
+
+pub fn bundle_into_change_set(bundle_state: BundleState) -> StateChangeset {
+    let is_value_known = OriginalValuesKnown::Yes;
+
+    let state_len = bundle_state.state.len();
+    let mut accounts = Vec::with_capacity(state_len);
+    let mut storage = Vec::with_capacity(state_len);
+
+    for (address, account) in bundle_state.state {
+        // append account info if it is changed.
+        let was_destroyed = account.was_destroyed();
+        if is_value_known.is_not_known() || account.is_info_changed() {
+            let info = account.info.map(AccountInfo::without_code);
+            accounts.push((address, info));
+        }
+
+        // append storage changes
+
+        // NOTE: Assumption is that revert is going to remove whole plain storage from
+        // database so we can check if plain state was wiped or not.
+        let mut account_storage_changed = Vec::with_capacity(account.storage.len());
+
+        for (key, slot) in account.storage {
+            // If storage was destroyed that means that storage was wiped.
+            // In that case we need to check if present storage value is different then ZERO.
+            let destroyed_and_not_zero = was_destroyed && slot.present_value != U256::ZERO;
+
+            // If account is not destroyed check if original values was changed,
+            // so we can update it.
+            let not_destroyed_and_changed = !was_destroyed && slot.is_changed();
+
+            if is_value_known.is_not_known() || destroyed_and_not_zero || not_destroyed_and_changed
+            {
+                account_storage_changed.push((key, slot));
+            }
+        }
+
+        if !account_storage_changed.is_empty() || was_destroyed {
+            // append storage changes to account.
+            storage.push(StorageChangeset {
+                address,
+                wipe_storage: was_destroyed,
+                storage: account_storage_changed,
+            });
+        }
+    }
+    let contracts = bundle_state
+        .contracts
+        .into_iter()
+        // remove empty bytecodes
+        .filter(|(b, _)| *b != KECCAK_EMPTY)
+        .collect::<Vec<_>>();
+
+    StateChangeset {
+        accounts,
+        storage,
+        contracts,
+        ..Default::default()
+    }
+}