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

package/core/src/events.rs

@@ -0,0 +1,9 @@
+use alloy_sol_types::sol;
+
+sol! {
+    event Voted(address voter, address validator);
+    event Unvoted(address voter, address validator);
+
+    event UsernameRegistered(address addr, string username, string previousUsername);
+    event UsernameResigned(address addr, string username);
+}

package/core/src/historical.rs

@@ -0,0 +1,544 @@
+use std::collections::BTreeMap;
+
+use heed::{RoTxn, RwTxn};
+use revm::{
+    primitives::{Address, B256, U256},
+    state::AccountInfo,
+};
+
+use crate::{compression::CompactBincode, db::Error};
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct HistoricalAccountData {
+    pub balance: U256,
+    pub nonce: u64,
+    pub code_hash: B256,
+}
+
+impl From<AccountInfo> for HistoricalAccountData {
+    fn from(value: AccountInfo) -> Self {
+        HistoricalAccountData {
+            balance: value.balance,
+            nonce: value.nonce,
+            code_hash: value.code_hash,
+        }
+    }
+}
+
+pub struct AccountHistory {
+    capacity: u64,
+}
+
+impl AccountHistory {
+    pub fn new(capacity: u64) -> Self {
+        Self { capacity }
+    }
+
+    pub fn insert(
+        &self,
+        txn: &mut RwTxn,
+        database: &heed::Database<
+            heed::types::U64<heed::byteorder::BigEndian>,
+            CompactBincode<BTreeMap<Address, HistoricalAccountData>>,
+        >,
+        block_number: u64,
+        accounts: Vec<(Address, AccountInfo)>,
+    ) -> Result<(), Error> {
+        assert!(database.get(txn, &block_number)?.is_none());
+
+        let count = database.len(txn)?;
+        if count >= self.capacity {
+            // delete oldest entries
+            let range = ..=block_number.saturating_sub(self.capacity);
+            database.delete_range(txn, &range)?;
+        }
+
+        let data = accounts
+            .into_iter()
+            .map(|a| (a.0, HistoricalAccountData::from(a.1)))
+            .collect::<BTreeMap<Address, HistoricalAccountData>>();
+
+        database.put(txn, &block_number, &CompactBincode(&data))?;
+
+        Ok(())
+    }
+
+    pub fn get_by_block_and_address(
+        &self,
+        txn: &RoTxn,
+        database: &heed::Database<
+            heed::types::U64<heed::byteorder::BigEndian>,
+            CompactBincode<BTreeMap<Address, HistoricalAccountData>>,
+        >,
+        block_number: u64,
+        address: &Address,
+    ) -> Result<(Option<HistoricalAccountData>, bool), Error> {
+        let mut iter = database.rev_range(txn, &..=block_number)?;
+
+        let mut missing_fallback = false;
+
+        while let Some((_, history)) = iter.next().transpose()? {
+            if let Some(data) = history.get(address) {
+                return Ok((Some(data.clone()), false));
+            }
+
+            missing_fallback = true;
+        }
+
+        Ok((None, missing_fallback))
+    }
+}
+
+#[test]
+fn test_account_history() {
+    let path = tempfile::Builder::new()
+        .prefix("evm.mdb")
+        .tempdir()
+        .unwrap();
+
+    let db = crate::db::PersistentDB::new(
+        crate::db::PersistentDBOptions::new(path.path().to_path_buf()).with_history_size(10),
+    )
+    .expect("database");
+
+    let history = AccountHistory::new(10);
+    let mut txn = db.env.write_txn().unwrap();
+
+    let history_db = &db.inner.borrow().accounts_history.unwrap();
+
+    // Block 1
+    history
+        .insert(
+            &mut txn,
+            history_db,
+            1,
+            vec![
+                (
+                    revm::primitives::address!("0000000000000000000000000000000000000001"),
+                    AccountInfo {
+                        balance: U256::from(1),
+                        nonce: 1,
+                        ..Default::default()
+                    },
+                ),
+                (
+                    revm::primitives::address!("0000000000000000000000000000000000000002"),
+                    AccountInfo {
+                        balance: U256::from(2),
+                        nonce: 1,
+                        ..Default::default()
+                    },
+                ),
+            ],
+        )
+        .unwrap();
+
+    // Block 2
+    history
+        .insert(
+            &mut txn,
+            history_db,
+            2,
+            vec![
+                (
+                    revm::primitives::address!("0000000000000000000000000000000000000001"),
+                    AccountInfo {
+                        balance: U256::from(2),
+                        nonce: 1,
+                        ..Default::default()
+                    },
+                ),
+                (
+                    revm::primitives::address!("0000000000000000000000000000000000000003"),
+                    AccountInfo {
+                        balance: U256::from(3),
+                        nonce: 3,
+                        ..Default::default()
+                    },
+                ),
+            ],
+        )
+        .unwrap();
+
+    // Block 3 - 4 (empty)
+    history.insert(&mut txn, history_db, 3, vec![]).unwrap();
+    history.insert(&mut txn, history_db, 4, vec![]).unwrap();
+
+    // Block 5
+    history
+        .insert(
+            &mut txn,
+            history_db,
+            5,
+            vec![
+                (
+                    revm::primitives::address!("0000000000000000000000000000000000000001"),
+                    AccountInfo {
+                        balance: U256::from(5),
+                        nonce: 5,
+                        ..Default::default()
+                    },
+                ),
+                (
+                    revm::primitives::address!("0000000000000000000000000000000000000004"),
+                    AccountInfo {
+                        balance: U256::from(4),
+                        nonce: 4,
+                        ..Default::default()
+                    },
+                ),
+            ],
+        )
+        .unwrap();
+
+    // Assert Account 1 at respective blocks (1 - 5)
+    for (block_number, address, balance, nonce) in vec![
+        // Block 1
+        (
+            1,
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+            U256::from(1),
+            1,
+        ),
+        // Block 2
+        (
+            2,
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+            U256::from(2),
+            1,
+        ),
+        // Block 3 (unchanged since block_number 2)
+        (
+            3,
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+            U256::from(2),
+            1,
+        ),
+        // Block 4 (unchanged since block_number 2)
+        (
+            4,
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+            U256::from(2),
+            1,
+        ),
+        // Block 5
+        (
+            5,
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+            U256::from(5),
+            5,
+        ),
+    ] {
+        let account = history
+            .get_by_block_and_address(&mut txn, history_db, block_number, &address)
+            .unwrap();
+
+        assert!(account.0.is_some_and(|a| a
+            == HistoricalAccountData {
+                balance: balance,
+                nonce: nonce,
+                code_hash: revm::primitives::KECCAK_EMPTY,
+            }));
+        assert_eq!(account.1, false);
+    }
+
+    // Assert Account 2 at respective block_numbers (1 - 5)
+    for (block_number, address, balance, nonce) in vec![
+        // Block 1
+        (
+            1,
+            revm::primitives::address!("0000000000000000000000000000000000000002"),
+            U256::from(2),
+            1,
+        ),
+        // Block 2 (unchanged since block_number 1)
+        (
+            2,
+            revm::primitives::address!("0000000000000000000000000000000000000002"),
+            U256::from(2),
+            1,
+        ),
+        // Block 3 (unchanged since block_number 1)
+        (
+            3,
+            revm::primitives::address!("0000000000000000000000000000000000000002"),
+            U256::from(2),
+            1,
+        ),
+        // Block 4 (unchanged since block_number 1)
+        (
+            4,
+            revm::primitives::address!("0000000000000000000000000000000000000002"),
+            U256::from(2),
+            1,
+        ),
+        // Block 5 (unchanged since block_number 1)
+        (
+            5,
+            revm::primitives::address!("0000000000000000000000000000000000000002"),
+            U256::from(2),
+            1,
+        ),
+    ] {
+        let account = history
+            .get_by_block_and_address(&mut txn, history_db, block_number, &address)
+            .unwrap();
+
+        assert!(account.0.is_some_and(|a| a
+            == HistoricalAccountData {
+                balance: balance,
+                nonce: nonce,
+                code_hash: revm::primitives::KECCAK_EMPTY,
+            }));
+        assert_eq!(account.1, false);
+    }
+
+    // Assert Account 3 at respective block_numbers (1 - 5)
+    for (block_number, address) in vec![
+        // Block 1 - non existent
+        (
+            1,
+            revm::primitives::address!("0000000000000000000000000000000000000003"),
+        ),
+    ] {
+        let account = history
+            .get_by_block_and_address(&mut txn, history_db, block_number, &address)
+            .unwrap();
+        assert_eq!(account, (None, true));
+    }
+
+    for (block_number, address, balance, nonce) in vec![
+        // Block 2
+        (
+            2,
+            revm::primitives::address!("0000000000000000000000000000000000000003"),
+            U256::from(3),
+            3,
+        ),
+        // Block 3 (unchanged since block_number 2)
+        (
+            3,
+            revm::primitives::address!("0000000000000000000000000000000000000003"),
+            U256::from(3),
+            3,
+        ),
+        // Block 4 (unchanged since block_number 2)
+        (
+            4,
+            revm::primitives::address!("0000000000000000000000000000000000000003"),
+            U256::from(3),
+            3,
+        ),
+        // Block 5 (unchanged since block_number 2)
+        (
+            5,
+            revm::primitives::address!("0000000000000000000000000000000000000003"),
+            U256::from(3),
+            3,
+        ),
+    ] {
+        let account = history
+            .get_by_block_and_address(&mut txn, history_db, block_number, &address)
+            .unwrap();
+
+        assert!(account.0.is_some_and(|a| a
+            == HistoricalAccountData {
+                balance: balance,
+                nonce: nonce,
+                code_hash: revm::primitives::KECCAK_EMPTY,
+            }));
+        assert_eq!(account.1, false);
+    }
+
+    // Assert Account 4 at respective block_numbers (1 - 5)
+    for (block_number, address) in vec![
+        // Block 1 - non existent
+        (
+            1,
+            revm::primitives::address!("0000000000000000000000000000000000000004"),
+        ),
+        (
+            2,
+            revm::primitives::address!("0000000000000000000000000000000000000004"),
+        ),
+        (
+            3,
+            revm::primitives::address!("0000000000000000000000000000000000000004"),
+        ),
+        (
+            4,
+            revm::primitives::address!("0000000000000000000000000000000000000004"),
+        ),
+    ] {
+        let account = history
+            .get_by_block_and_address(&mut txn, history_db, block_number, &address)
+            .unwrap();
+        assert!(account.0.is_none());
+        assert_eq!(account.1, true);
+    }
+
+    for (block_number, address, balance, nonce) in vec![
+        // Block 5
+        (
+            5,
+            revm::primitives::address!("0000000000000000000000000000000000000004"),
+            U256::from(4),
+            4,
+        ),
+    ] {
+        let account = history
+            .get_by_block_and_address(&mut txn, history_db, block_number, &address)
+            .unwrap();
+
+        assert!(account.0.is_some_and(|a| a
+            == HistoricalAccountData {
+                balance: balance,
+                nonce: nonce,
+                code_hash: revm::primitives::KECCAK_EMPTY,
+            }));
+        assert_eq!(account.1, false);
+    }
+}
+
+#[test]
+fn test_accounts_history_capacity() {
+    let path = tempfile::Builder::new()
+        .prefix("evm.mdb")
+        .tempdir()
+        .unwrap();
+
+    let db = crate::db::PersistentDB::new(
+        crate::db::PersistentDBOptions::new(path.path().to_path_buf()).with_history_size(3),
+    )
+    .expect("database");
+
+    let history = AccountHistory::new(3);
+    let mut txn = db.env.write_txn().unwrap();
+
+    let history_db = &db.inner.borrow().accounts_history.unwrap();
+
+    for i in 0..5 {
+        println!("writing i... {}", i);
+        // Block 1
+        history
+            .insert(
+                &mut txn,
+                history_db,
+                i as u64,
+                vec![
+                    (
+                        revm::primitives::address!("0000000000000000000000000000000000000001"),
+                        AccountInfo {
+                            balance: U256::from(i),
+                            nonce: i,
+                            ..Default::default()
+                        },
+                    ),
+                    (
+                        revm::primitives::address!("0000000000000000000000000000000000000002"),
+                        AccountInfo {
+                            balance: U256::from(i + 2),
+                            nonce: i + 2,
+                            ..Default::default()
+                        },
+                    ),
+                ],
+            )
+            .unwrap();
+    }
+
+    // Assert accounts not available below capacity
+    for (block_number, address) in vec![
+        // Block 0
+        (
+            0,
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+        ),
+        // Block 1
+        (
+            1,
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+        ),
+    ] {
+        let account = history
+            .get_by_block_and_address(&mut txn, history_db, block_number, &address)
+            .unwrap();
+        assert_eq!(account, (None, false));
+    }
+
+    // Assert accounts found at respective block_numbers (2+)
+    for (block_number, address, balance, nonce) in vec![
+        // Block 2
+        (
+            2,
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+            U256::from(2),
+            2,
+        ),
+        (
+            2,
+            revm::primitives::address!("0000000000000000000000000000000000000002"),
+            U256::from(4),
+            4,
+        ),
+        // Block 3
+        (
+            3,
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+            U256::from(3),
+            3,
+        ),
+        (
+            3,
+            revm::primitives::address!("0000000000000000000000000000000000000002"),
+            U256::from(5),
+            5,
+        ),
+        // Block 4
+        (
+            4,
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+            U256::from(4),
+            4,
+        ),
+        (
+            4,
+            revm::primitives::address!("0000000000000000000000000000000000000002"),
+            U256::from(6),
+            6,
+        ),
+    ] {
+        let account = history
+            .get_by_block_and_address(&mut txn, history_db, block_number, &address)
+            .unwrap();
+
+        assert!(account.0.is_some_and(|a| a
+            == HistoricalAccountData {
+                balance: balance,
+                nonce: nonce,
+                code_hash: revm::primitives::KECCAK_EMPTY,
+            }));
+        assert!(account.1 == false);
+    }
+
+    // Write empty blocks until everything is evicted
+    for i in 5..10 {
+        // Block 1
+        history
+            .insert(&mut txn, history_db, i as u64, vec![])
+            .unwrap();
+    }
+
+    // Assert no accounts in history left
+    for i in 0..10 {
+        for address in vec![
+            revm::primitives::address!("0000000000000000000000000000000000000001"),
+            revm::primitives::address!("0000000000000000000000000000000000000002"),
+        ] {
+            let account = history
+                .get_by_block_and_address(&mut txn, history_db, i, &address)
+                .unwrap();
+            assert_eq!(account, (None, i >= 10 - history.capacity));
+        }
+    }
+}

package/core/src/legacy.rs

@@ -0,0 +1,153 @@
+use alloy_primitives::wrap_fixed_bytes;
+use bs58;
+use revm::primitives::{Address, B256, U256};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct LegacyColdWallet {
+    pub address: LegacyAddress,
+    pub balance: U256,
+    pub legacy_attributes: LegacyAccountAttributes,
+    pub merge_info: Option<(B256, Address)>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct LegacyAccountAttributes {
+    pub legacy_nonce: Option<u64>,
+    pub second_public_key: Option<String>,
+    pub multi_signature: Option<LegacyMultiSignatureAttribute>,
+}
+
+impl LegacyAccountAttributes {
+    pub fn is_empty(&self) -> bool {
+        self.second_public_key.is_none() && self.multi_signature.is_none()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct LegacyMultiSignatureAttribute {
+    pub min: usize,
+    pub public_keys: Vec<String>,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum LegacyAddressError {
+    InvalidSize,
+    InvalidBase58,
+    InvalidChecksum,
+    InvalidBytes,
+}
+
+wrap_fixed_bytes!(
+    extra_derives: [],
+    // A legacy 21-byte ARK address
+    pub struct LegacyAddress<21>;
+);
+
+impl std::fmt::Display for LegacyAddress {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let checksum = encode_base58check(&self[..]);
+        f.write_str(&checksum)
+    }
+}
+
+impl TryFrom<&str> for LegacyAddress {
+    type Error = LegacyAddressError;
+
+    #[inline]
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        let decoded = decode_base58check(value)?;
+        Self::try_from(&decoded[..]).map_err(|_| LegacyAddressError::InvalidBytes)
+    }
+}
+
+#[inline]
+fn decode_base58check(encoded: &str) -> Result<Vec<u8>, LegacyAddressError> {
+    let decoded = bs58::decode(encoded)
+        .into_vec()
+        .map_err(|e| e.to_string())
+        .map_err(|_| LegacyAddressError::InvalidBase58)?;
+
+    if decoded.len() < 4 {
+        return Err(LegacyAddressError::InvalidSize);
+    }
+
+    let (data, checksum) = decoded.split_at(decoded.len() - 4);
+    let computed_checksum = Sha256::digest(&Sha256::digest(data));
+    if &computed_checksum[..4] != checksum {
+        return Err(LegacyAddressError::InvalidChecksum);
+    }
+
+    Ok(data.to_vec())
+}
+
+#[inline]
+fn encode_base58check(data: &[u8]) -> String {
+    let checksum = Sha256::digest(&Sha256::digest(data));
+    let mut extended_data = data.to_vec();
+    extended_data.extend_from_slice(&checksum[..4]);
+
+    bs58::encode(extended_data).into_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::legacy::{
+        LegacyAddress, LegacyAddressError, decode_base58check, encode_base58check,
+    };
+
+    #[test]
+    fn test_encode() {
+        let address = "DJmvhhiQFSrEQCq9FUxvcLcpcBjx7K3yLt";
+
+        let decoded: [u8; 21] = [
+            30, 149, 144, 208, 106, 80, 8, 63, 148, 59, 207, 233, 127, 161, 7, 27, 208, 185, 40,
+            87, 19,
+        ];
+
+        let actual = encode_base58check(&decoded);
+        assert_eq!(actual, address);
+    }
+
+    #[test]
+    fn test_decode() {
+        let address = "DJmvhhiQFSrEQCq9FUxvcLcpcBjx7K3yLt";
+
+        let decoded: [u8; 21] = [
+            30, 149, 144, 208, 106, 80, 8, 63, 148, 59, 207, 233, 127, 161, 7, 27, 208, 185, 40,
+            87, 19,
+        ];
+
+        let actual = decode_base58check(address).expect("ok");
+        assert_eq!(actual, decoded);
+    }
+
+    #[test]
+    fn test_from_str() {
+        let address: LegacyAddress = "DJmvhhiQFSrEQCq9FUxvcLcpcBjx7K3yLt".try_into().expect("ok");
+
+        let decoded: [u8; 21] = [
+            30, 149, 144, 208, 106, 80, 8, 63, 148, 59, 207, 233, 127, 161, 7, 27, 208, 185, 40,
+            87, 19,
+        ];
+
+        assert_eq!(&address[..], decoded);
+    }
+
+    #[test]
+    fn test_decode_failure() {
+        let address = "_!@@@";
+        let err = decode_base58check(address).expect_err("must err");
+        assert_eq!(err, LegacyAddressError::InvalidBase58);
+
+        let address = "DJm";
+        let err = decode_base58check(address).expect_err("must err");
+        assert_eq!(err, LegacyAddressError::InvalidSize);
+
+        let address = "DjmvhhiqfSrEQCq9FUxvcLcpcBjx7K3yLt";
+        let err = decode_base58check(address).expect_err("must err");
+        assert_eq!(err, LegacyAddressError::InvalidChecksum);
+    }
+}