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

package/core/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "mainsail_evm_core"
+rust-version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+version.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+ethers-contract = { workspace = true }
+ethers-core = { workspace = true }
+ethers-providers = { workspace = true }
+revm = { workspace = true }
+alloy-sol-types = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+bincode = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
+#heed = { version = "0.20.0", features = [] }
+#heed = { path = "../../../../heed/heed", features = [] }
+heed = { git = "https://github.com/ArkEcosystem/heed.git", rev = "7a7a030113664e004b082e6805431381d9e9140a", features = [
+] }
+blst = { version = "0.3.16" }
+rayon = "1.10.0"
+derive_more = { version = "2" }
+bytes = { version = "1.0" }
+bs58 = { version = "0.5.1" }
+sha2 = { version = "0.10.8" }
+zstd = { version = "0.13.3" }
+
+[dev-dependencies]
+tempfile = "3"

package/core/src/account.rs

@@ -0,0 +1,112 @@
+use alloy_primitives::{B256, U256};
+use revm::{primitives::Address, state::AccountInfo};
+use serde::{Deserialize, Serialize};
+
+use crate::legacy::LegacyAccountAttributes;
+
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct AccountInfoExtended {
+    pub address: Address,
+    pub info: AccountInfo,
+    pub legacy_attributes: LegacyAccountAttributes,
+}
+
+impl AccountInfoExtended {
+    pub fn into_parts(self) -> (Address, AccountInfo, Option<LegacyAccountAttributes>) {
+        (
+            self.address,
+            self.info,
+            if self.legacy_attributes.is_empty() {
+                None
+            } else {
+                Some(self.legacy_attributes)
+            },
+        )
+    }
+}
+
+#[derive(Default, Debug, Serialize, Deserialize)]
+pub(crate) struct StoredAccountInfo {
+    pub balance: U256,
+    pub nonce: u64,
+    pub code_hash: B256,
+}
+
+impl StoredAccountInfo {
+    pub fn new(balance: U256, nonce: u64, code_hash: B256) -> Self {
+        Self {
+            balance,
+            nonce,
+            code_hash,
+        }
+    }
+}
+
+impl From<StoredAccountInfo> for AccountInfo {
+    fn from(stored: StoredAccountInfo) -> Self {
+        AccountInfo {
+            balance: stored.balance,
+            nonce: stored.nonce,
+            code_hash: stored.code_hash,
+            account_id: None,
+            code: None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{account::AccountInfoExtended, legacy::LegacyAccountAttributes};
+    use alloy_primitives::{U256, address, b256};
+    use revm::state::AccountInfo;
+
+    #[test]
+    fn test_account_info_parts() {
+        let info = AccountInfo {
+            balance: U256::ONE,
+            nonce: 1,
+            code_hash: b256!("0000000000000000000000000000000000000000000000000000000000000001"),
+            account_id: None,
+            code: None,
+        };
+
+        let attributes = LegacyAccountAttributes {
+            legacy_nonce: Some(0),
+            second_public_key: Some("key".into()),
+            multi_signature: None,
+        };
+
+        let account_info = AccountInfoExtended {
+            address: address!("0000000000000000000000000000000000000001"),
+            info: info.clone(),
+            legacy_attributes: attributes.clone(),
+        };
+
+        let (address, info_part, legacy_attributes) = account_info.into_parts();
+
+        assert_eq!(
+            address,
+            address!("0000000000000000000000000000000000000001")
+        );
+        assert_eq!(info, info_part);
+        assert_eq!(legacy_attributes, Some(attributes));
+
+        let account_info = AccountInfoExtended {
+            address: address!("0000000000000000000000000000000000000001"),
+            info: info.clone(),
+            legacy_attributes: LegacyAccountAttributes {
+                legacy_nonce: None,
+                second_public_key: None,
+                multi_signature: None,
+            },
+        };
+
+        let (address, info_part, legacy_attributes) = account_info.into_parts();
+        assert_eq!(
+            address,
+            address!("0000000000000000000000000000000000000001")
+        );
+        assert_eq!(info, info_part);
+        assert_eq!(legacy_attributes, None);
+    }
+}

package/core/src/bytecode.rs

@@ -0,0 +1,39 @@
+use alloy_primitives::Bytes;
+use revm::{bytecode::BytecodeDecodeError, state::Bytecode};
+use serde::{Deserialize, Serialize};
+
+#[derive(Default, Debug, Serialize, Deserialize)]
+pub struct StoredBytecode {
+    pub raw: Bytes,
+}
+
+impl From<Bytecode> for StoredBytecode {
+    fn from(code: Bytecode) -> Self {
+        Self {
+            raw: code.original_bytes(),
+        }
+    }
+}
+
+impl TryFrom<StoredBytecode> for Bytecode {
+    type Error = BytecodeDecodeError;
+
+    fn try_from(stored: StoredBytecode) -> Result<Self, Self::Error> {
+        Bytecode::new_raw_checked(stored.raw)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::bytecode::StoredBytecode;
+    use alloy_primitives::Bytes;
+    use revm::state::Bytecode;
+
+    #[test]
+    fn test_bytecode() {
+        let raw_bytecode = Bytecode::new_raw(Bytes::from_static(&[1, 2, 3, 4]));
+        let stored = StoredBytecode::from(raw_bytecode);
+
+        assert_eq!(stored.raw, Bytes::from_static(&[1, 2, 3, 4]));
+    }
+}

package/core/src/compression.rs

@@ -0,0 +1,158 @@
+use std::{borrow::Cow, ops::Deref};
+
+// First byte of every stored value tags how the remainder is encoded:
+//   TAG_RAW:  [0][raw bincode]                      (uncompressed)
+//   TAG_ZSTD: [1][orig_len: u32 LE][zstd payload]   (compressed)
+const TAG_RAW: u8 = 0;
+const TAG_ZSTD: u8 = 1;
+
+const ZSTD_LEVEL: i32 = 3;
+
+// Compression is only attempted for serialized values at least this large. The frequently-written
+// values are poor candidates for two independent reasons:
+//   - small size (accounts ~70 B, proofs ~120 B): too little context, and zstd's frame overhead
+//     plus the 4-byte length header outweigh any gain;
+//   - high-entropy content: keccak code hashes and BLS signatures are effectively random, so there
+//     is no redundancy to exploit at any size.
+// The threshold skips the first case cheaply; the "keep raw unless actually smaller" check on the
+// result handles the second. Larger structured values (headers with a sparse logs bloom,
+// ABI-padded calldata, receipt logs, bytecode) still compress and are kept only when it shrinks them.
+const MIN_COMPRESS_LEN: usize = 256;
+
+#[derive(Debug)]
+pub struct CompactBincode<T>(pub T);
+impl<'a, T: serde::Serialize + 'a> heed::BytesEncode<'a> for CompactBincode<T> {
+    type EItem = CompactBincode<&'a T>;
+
+    fn bytes_encode(item: &'a Self::EItem) -> Result<Cow<'a, [u8]>, heed::BoxedError> {
+        let raw = bincode::serialize(&item.0)?;
+
+        if raw.len() >= MIN_COMPRESS_LEN {
+            let compressed = zstd::bulk::compress(&raw, ZSTD_LEVEL)?;
+
+            // The compressed layout carries an extra 4-byte original-length header; only keep it
+            // when the result is genuinely smaller than storing raw (both forms share the 1-byte
+            // tag, so it cancels out of the comparison).
+            if compressed.len() + 4 < raw.len() {
+                let mut out = Vec::with_capacity(1 + 4 + compressed.len());
+                out.push(TAG_ZSTD);
+                out.extend_from_slice(&(raw.len() as u32).to_le_bytes());
+                out.extend_from_slice(&compressed);
+                return Ok(Cow::Owned(out));
+            }
+        }
+
+        // Store raw. A value is therefore never persisted larger than its bincode encoding plus the
+        // single tag byte.
+        let mut out = Vec::with_capacity(1 + raw.len());
+        out.push(TAG_RAW);
+        out.extend_from_slice(&raw);
+        Ok(Cow::Owned(out))
+    }
+}
+
+impl<'a, T: serde::de::DeserializeOwned + 'a> heed::BytesDecode<'a> for CompactBincode<T> {
+    type DItem = CompactBincode<T>;
+
+    fn bytes_decode(bytes: &'_ [u8]) -> Result<Self::DItem, heed::BoxedError> {
+        let (&tag, payload) = bytes
+            .split_first()
+            .ok_or("CompressedBincode: empty value")?;
+
+        let deserialized = match tag {
+            TAG_ZSTD => {
+                if payload.len() < 4 {
+                    return Err("CompressedBincode: truncated zstd header".into());
+                }
+                let (len_bytes, compressed) = payload.split_at(4);
+                let orig_len = u32::from_le_bytes(len_bytes.try_into().unwrap()) as usize;
+                let decompressed = zstd::bulk::decompress(compressed, orig_len)?;
+                bincode::deserialize(&decompressed)?
+            }
+            TAG_RAW => bincode::deserialize(payload)?,
+            other => return Err(format!("CompressedBincode: unknown tag {other}").into()),
+        };
+
+        Ok(CompactBincode(deserialized))
+    }
+}
+
+impl<T> Deref for CompactBincode<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use heed::{BytesDecode, BytesEncode};
+
+    use super::*;
+
+    fn encode(value: &Vec<u8>) -> Vec<u8> {
+        let item = CompactBincode(value);
+        <CompactBincode<Vec<u8>> as BytesEncode>::bytes_encode(&item)
+            .unwrap()
+            .into_owned()
+    }
+
+    fn decode(bytes: &[u8]) -> Vec<u8> {
+        <CompactBincode<Vec<u8>> as BytesDecode>::bytes_decode(bytes)
+            .unwrap()
+            .0
+    }
+
+    #[test]
+    fn small_value_is_stored_raw() {
+        let value = vec![1u8, 2, 3, 4, 5];
+        let encoded = encode(&value);
+        assert_eq!(encoded[0], TAG_RAW);
+        assert_eq!(decode(&encoded), value);
+    }
+
+    #[test]
+    fn large_compressible_value_is_stored_zstd_and_smaller() {
+        let value = vec![7u8; 4096];
+        let encoded = encode(&value);
+        assert_eq!(encoded[0], TAG_ZSTD);
+        assert!(encoded.len() < value.len());
+        assert_eq!(decode(&encoded), value);
+    }
+
+    #[test]
+    fn output_never_exceeds_raw_plus_tag() {
+        // A large, hard-to-compress value: compression is attempted but must fall back to raw
+        // rather than store something bigger.
+        let value: Vec<u8> = (0..2048u32)
+            .map(|i| (i.wrapping_mul(2_654_435_761) >> 13) as u8)
+            .collect();
+        let raw_len = bincode::serialize(&value).unwrap().len();
+
+        let encoded = encode(&value);
+        assert!(
+            encoded.len() <= raw_len + 1,
+            "encoded {} raw {}",
+            encoded.len(),
+            raw_len
+        );
+        assert_eq!(decode(&encoded), value);
+    }
+
+    #[test]
+    fn empty_input_is_an_error_not_a_panic() {
+        assert!(<CompactBincode<Vec<u8>> as BytesDecode>::bytes_decode(&[]).is_err());
+    }
+
+    #[test]
+    fn truncated_zstd_header_is_an_error_not_a_panic() {
+        // TAG_ZSTD with fewer than the four orig_len header bytes must error, not panic on the slice.
+        assert!(<CompactBincode<Vec<u8>> as BytesDecode>::bytes_decode(&[TAG_ZSTD, 1, 2]).is_err());
+    }
+
+    #[test]
+    fn unknown_tag_is_an_error_not_a_panic() {
+        assert!(<CompactBincode<Vec<u8>> as BytesDecode>::bytes_decode(&[9, 0, 0]).is_err());
+    }
+}