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

package/bindings/src/logger.rs

@@ -0,0 +1,110 @@
+use mainsail_evm_core::logger::{LogLevel, Logger};
+use napi::bindgen_prelude::*;
+use napi::threadsafe_function::{ThreadsafeCallContext, ThreadsafeFunctionCallMode};
+use napi_derive::napi;
+use std::sync::mpsc::{Receiver, Sender, channel};
+use std::thread::{self, JoinHandle};
+
+#[napi(js_name = "LogLevel")]
+pub enum JsLogLevel {
+    Info,
+    Debug,
+    Notice,
+    Alert,
+    Warn,
+}
+
+impl From<LogLevel> for JsLogLevel {
+    fn from(value: LogLevel) -> Self {
+        match value {
+            LogLevel::Info => Self::Info,
+            LogLevel::Debug => Self::Debug,
+            LogLevel::Notice => Self::Notice,
+            LogLevel::Alert => Self::Alert,
+            LogLevel::Warn => Self::Warn,
+        }
+    }
+}
+
+#[napi(object)]
+pub struct JsLogMessage {
+    pub level: JsLogLevel,
+    pub message: String,
+}
+
+pub struct JsLogger {
+    internal_logger: Logger,
+    logger_handle: Option<JoinHandle<()>>,
+}
+
+impl JsLogger {
+    const DROP_MESSAGE: &'static str = "DROP";
+
+    pub fn new(logger_callback: Option<Function<'static, JsLogMessage, ()>>) -> Result<Self> {
+        let mut logger_sender: Option<Sender<(LogLevel, String)>> = None;
+        let mut logger_handle: Option<JoinHandle<()>> = None;
+
+        if let Some(logger_callback) = logger_callback {
+            let (sender, receiver): (Sender<(LogLevel, String)>, Receiver<(LogLevel, String)>) =
+                channel();
+
+            let tsfn = logger_callback.build_threadsafe_function().build_callback(
+                |ctx: ThreadsafeCallContext<JsLogMessage>| -> Result<JsLogMessage> {
+                    Ok(ctx.value)
+                },
+            )?;
+
+            // Spawn a thread to listen for log messages and invoke the JS callback
+            let handle = thread::spawn({
+                //   let tsfn = tsfn.clone();
+                move || {
+                    for (level, message) in receiver {
+                        if level == LogLevel::Notice && message == Self::DROP_MESSAGE {
+                            break;
+                        }
+
+                        tsfn.call(
+                            JsLogMessage {
+                                level: level.into(),
+                                message,
+                            },
+                            ThreadsafeFunctionCallMode::NonBlocking,
+                        );
+                    }
+
+                    ()
+                }
+            });
+
+            logger_sender.replace(sender.clone());
+            logger_handle.replace(handle);
+        }
+
+        let internal_logger = Logger::new(logger_sender);
+
+        Ok(Self {
+            internal_logger,
+            logger_handle,
+        })
+    }
+
+    pub fn inner(&self) -> Logger {
+        self.internal_logger.clone()
+    }
+
+    pub fn log(&self, level: LogLevel, message: String) {
+        self.internal_logger.log(level, message);
+    }
+}
+
+impl Drop for JsLogger {
+    fn drop(&mut self) {
+        if let Some(handle) = self.logger_handle.take() {
+            if let Some(sender) = self.internal_logger.sender.as_ref() {
+                let _ = sender.send((LogLevel::Notice, Self::DROP_MESSAGE.into()));
+            }
+
+            handle.join().expect("failed to join logger thread");
+        }
+    }
+}

package/bindings/src/result.rs

@@ -0,0 +1,542 @@
+use mainsail_evm_core::{
+    account::AccountInfoExtended,
+    db::{BlockHeaderData, ProofData, TransactionData},
+    legacy::{LegacyAccountAttributes, LegacyColdWallet, LegacyMultiSignatureAttribute},
+    receipt::TxReceipt,
+    state_changes::AccountUpdate,
+};
+use napi::bindgen_prelude::{BigInt, Buffer};
+use napi_derive::napi;
+use revm::{
+    primitives::{B256, Bytes, hex::ToHexExt},
+    state::AccountInfo,
+};
+
+use crate::{
+    ctx::{JsBlockHeaderData, JsCommitData, JsProofData, JsTransactionData},
+    utils,
+};
+
+#[napi(object)]
+pub struct JsProcessResult {
+    pub receipt: JsTransactionReceipt,
+}
+impl JsProcessResult {
+    pub fn new(receipt: TxReceipt) -> Self {
+        Self {
+            receipt: JsTransactionReceipt::new(receipt),
+        }
+    }
+}
+
+#[napi(object)]
+pub struct JsSimulateResult {
+    pub receipt: JsTransactionReceipt,
+}
+impl JsSimulateResult {
+    pub fn new(receipt: TxReceipt) -> Self {
+        Self {
+            receipt: JsTransactionReceipt::new(receipt),
+        }
+    }
+}
+
+#[napi(object, object_from_js = false)]
+pub struct JsCommitResult {
+    pub dirty_accounts: Vec<JsAccountUpdate>,
+}
+
+impl JsCommitResult {
+    pub fn new(result: CommitResult) -> anyhow::Result<Self> {
+        let mut dirty_accounts = Vec::with_capacity(result.dirty_accounts.len());
+        for item in result.dirty_accounts {
+            dirty_accounts.push(JsAccountUpdate::new(item));
+        }
+
+        Ok(Self { dirty_accounts })
+    }
+}
+
+#[napi(object)]
+pub struct JsViewResult {
+    pub success: bool,
+    pub output: Option<Buffer>,
+}
+impl JsViewResult {
+    pub fn new(result: TxViewResult) -> anyhow::Result<Self> {
+        Ok(Self {
+            success: result.success,
+            output: result.output.map(|o| utils::convert_bytes_to_js_buffer(o)),
+        })
+    }
+}
+
+#[napi(object)]
+pub struct JsPreverifyTransactionResult {
+    pub success: bool,
+    pub initial_gas_used: BigInt,
+    pub error: Option<String>,
+}
+
+impl JsPreverifyTransactionResult {
+    pub fn new(result: PreverifyTxResult) -> Self {
+        Self {
+            success: result.success,
+            initial_gas_used: result.initial_gas_used.into(),
+            error: result.error,
+        }
+    }
+}
+
+#[napi(object)]
+pub struct JsTransactionReceipt {
+    pub block_number: Option<BigInt>,
+    pub tx_hash: Option<String>,
+
+    pub gas_used: BigInt,
+    pub cumulative_gas_used: BigInt,
+    pub gas_refunded: BigInt,
+    pub status: u8,
+    pub contract_address: Option<String>,
+
+    pub logs: serde_json::Value,
+    pub output: Option<Buffer>,
+}
+
+#[derive(Default)]
+pub struct CommitResult {
+    pub dirty_accounts: Vec<AccountUpdate>,
+}
+
+pub struct TxViewResult {
+    pub success: bool,
+    pub output: Option<Bytes>,
+}
+
+#[derive(Default)]
+pub struct PreverifyTxResult {
+    pub success: bool,
+    pub initial_gas_used: u64,
+    pub error: Option<String>,
+}
+
+impl JsTransactionReceipt {
+    pub fn new(receipt: TxReceipt) -> Self {
+        JsTransactionReceipt {
+            gas_used: receipt.gas_used.into(),
+            cumulative_gas_used: receipt.cumulative_gas_used.into(),
+            gas_refunded: receipt.gas_refunded.into(),
+            status: receipt.success as u8,
+            contract_address: receipt.contract_address,
+            logs: receipt
+                .logs
+                .map(|l| serde_json::to_value(l).unwrap())
+                .unwrap_or_else(|| serde_json::Value::Null), // TODO: check if null is correct
+            output: receipt.output.map(|o| utils::convert_bytes_to_js_buffer(o)),
+            block_number: None,
+            tx_hash: None,
+        }
+    }
+}
+
+impl JsCommitData {
+    pub fn new(
+        proof: ProofData,
+        header: BlockHeaderData,
+        transactions: Vec<TransactionData>,
+    ) -> Self {
+        JsCommitData {
+            proof: JsProofData::new(proof),
+            header: JsBlockHeaderData::new(header),
+            transactions: transactions
+                .into_iter()
+                .map(|tx| JsTransactionData::new(tx))
+                .collect(),
+        }
+    }
+}
+
+impl JsProofData {
+    pub fn new(proof: ProofData) -> Self {
+        JsProofData {
+            round: proof.round,
+            signature: proof.signature.encode_hex(),
+            validator_set: proof.validator_set.into(),
+        }
+    }
+}
+
+impl JsBlockHeaderData {
+    pub fn new(header: BlockHeaderData) -> Self {
+        JsBlockHeaderData {
+            version: header.version,
+            timestamp: header.timestamp.into(),
+            number: header.number,
+            round: header.round,
+            hash: format!("{:x}", header.hash),
+            parent_hash: format!("{:x}", header.parent_hash),
+            state_root: format!("{:x}", header.state_root),
+            logs_bloom: header.logs_bloom.encode_hex(),
+            transactions_root: format!("{:x}", header.transactions_root),
+            transactions_count: header.transactions_count,
+            gas_used: header.gas_used,
+            fee: utils::convert_u256_to_bigint(header.fee),
+            reward: utils::convert_u256_to_bigint(header.reward),
+            payload_size: header.payload_size,
+            proposer: header.proposer.to_string(),
+        }
+    }
+}
+
+impl JsTransactionData {
+    pub fn new(tx: TransactionData) -> Self {
+        JsTransactionData {
+            block_number: tx.block_number,
+            tx_hash: format!("{:x}", tx.tx_hash),
+            from: tx.from.to_string(),
+            sender_public_key: tx.sender_public_key,
+            legacy_address: tx.legacy_address.map(|address| address.to_string()),
+            to: tx.to.map(|address| address.to_string()),
+            gas_limit: tx.gas_limit.into(),
+            gas_price: tx.gas_price.into(),
+            value: utils::convert_u256_to_bigint(tx.value),
+            nonce: tx.nonce.into(),
+            data: utils::convert_bytes_to_js_buffer(tx.data),
+            v: tx.v,
+            r: utils::convert_u256_to_hex(tx.r),
+            s: utils::convert_u256_to_hex(tx.s),
+            legacy_second_signature: tx.legacy_second_signature,
+            index: tx.index,
+        }
+    }
+}
+
+#[napi(object)]
+pub struct JsAccountInfo {
+    pub balance: BigInt,
+    pub nonce: BigInt,
+}
+
+impl JsAccountInfo {
+    pub fn new(account_info: AccountInfo) -> anyhow::Result<Self> {
+        Ok(JsAccountInfo {
+            nonce: account_info.nonce.into(),
+            balance: utils::convert_u256_to_bigint(account_info.balance),
+        })
+    }
+}
+
+impl TryInto<AccountInfo> for JsAccountInfo {
+    type Error = anyhow::Error;
+
+    fn try_into(self) -> Result<AccountInfo, Self::Error> {
+        Ok(AccountInfo {
+            balance: utils::convert_bigint_to_u256(self.balance)?,
+            nonce: self.nonce.get_u64().1,
+            ..Default::default()
+        })
+    }
+}
+
+#[napi(object)]
+pub struct JsAccountUpdate {
+    pub address: String,
+    pub balance: BigInt,
+    pub nonce: BigInt,
+    pub vote: Option<String>,
+    pub unvote: Option<String>,
+    pub username: Option<String>,
+    pub username_resigned: bool,
+    pub legacy_merge_info: Option<JsAccountMergeInfo>,
+}
+
+impl JsAccountUpdate {
+    pub fn new(account_update: AccountUpdate) -> Self {
+        let vote = account_update.vote.map(|vote| vote.to_string());
+        let unvote = account_update.unvote.map(|unvote| unvote.to_string());
+        let username = account_update.username.map(|username| username.to_string());
+
+        let legacy_merge_info = match &account_update.merge_info {
+            Some(legacy_merge_info) => Some(JsAccountMergeInfo {
+                address: legacy_merge_info.legacy_address.to_string(),
+                tx_hash: legacy_merge_info.transaction_hash.to_string(),
+            }),
+            None => None,
+        };
+
+        JsAccountUpdate {
+            address: account_update.address.to_checksum(None),
+            nonce: account_update.nonce.into(),
+            balance: utils::convert_u256_to_bigint(account_update.balance),
+            vote,
+            unvote,
+            username,
+            username_resigned: account_update.username_resigned,
+            legacy_merge_info,
+        }
+    }
+}
+
+#[napi(object)]
+pub struct JsAccountInfoExtended {
+    pub address: String,
+    pub balance: BigInt,
+    pub nonce: BigInt,
+    pub legacy_attributes: JsLegacyAttributes,
+}
+
+#[napi(object)]
+pub struct JsLegacyColdWallet {
+    pub address: String,
+    pub balance: BigInt,
+    pub legacy_attributes: JsLegacyAttributes,
+    pub merge_info: Option<JsAccountMergeInfo>,
+}
+
+#[napi(object)]
+pub struct JsAccountMergeInfo {
+    pub address: String,
+    pub tx_hash: String,
+}
+
+impl JsLegacyColdWallet {
+    pub fn new(wallet: LegacyColdWallet) -> Self {
+        let merge_info = if let Some(merged_account) = wallet.merge_info {
+            Some(JsAccountMergeInfo {
+                address: merged_account.1.to_string(),
+                tx_hash: merged_account.0.to_string(),
+            })
+        } else {
+            None
+        };
+
+        JsLegacyColdWallet {
+            address: wallet.address.to_string(),
+            balance: utils::convert_u256_to_bigint(wallet.balance),
+            legacy_attributes: JsLegacyAttributes::new(wallet.legacy_attributes),
+            merge_info,
+        }
+    }
+}
+
+#[napi(object)]
+pub struct JsLegacyAttributes {
+    pub legacy_nonce: Option<BigInt>,
+    pub second_public_key: Option<String>,
+    pub multi_signature: Option<JsLegacyMultiSignatureAttribute>,
+}
+
+#[napi(object)]
+pub struct JsLegacyMultiSignatureAttribute {
+    pub min: u32,
+    pub public_keys: Vec<String>,
+}
+
+impl JsAccountInfoExtended {
+    pub fn new(account_info_extended: AccountInfoExtended) -> Self {
+        JsAccountInfoExtended {
+            address: account_info_extended.address.to_string(),
+            nonce: account_info_extended.info.nonce.into(),
+            balance: utils::convert_u256_to_bigint(account_info_extended.info.balance),
+            legacy_attributes: JsLegacyAttributes::new(account_info_extended.legacy_attributes),
+        }
+    }
+}
+
+impl TryInto<AccountInfoExtended> for JsAccountInfoExtended {
+    type Error = crate::Error;
+
+    fn try_into(self) -> Result<AccountInfoExtended, Self::Error> {
+        Ok(AccountInfoExtended {
+            address: utils::create_address_from_string(&self.address)?,
+            info: AccountInfo {
+                balance: utils::convert_bigint_to_u256(self.balance)?,
+                nonce: self.nonce.get_u64().1,
+                ..Default::default()
+            },
+            legacy_attributes: self.legacy_attributes.try_into()?,
+        })
+    }
+}
+
+impl TryInto<LegacyColdWallet> for JsLegacyColdWallet {
+    type Error = crate::Error;
+
+    fn try_into(self) -> Result<LegacyColdWallet, Self::Error> {
+        let merge_info = if let Some(merge_info) = self.merge_info {
+            Some((
+                utils::convert_string_to_b256(merge_info.tx_hash)?,
+                utils::create_address_from_string(&merge_info.address)?,
+            ))
+        } else {
+            None
+        };
+
+        Ok(LegacyColdWallet {
+            address: utils::create_legacy_address_from_string(&self.address)?,
+            balance: utils::convert_bigint_to_u256(self.balance)?,
+            legacy_attributes: self.legacy_attributes.try_into()?,
+            merge_info,
+        })
+    }
+}
+
+impl JsLegacyAttributes {
+    pub fn new(legacy_attributes: LegacyAccountAttributes) -> Self {
+        let multi_signature = if let Some(multi_signature) = legacy_attributes.multi_signature {
+            Some(JsLegacyMultiSignatureAttribute {
+                min: multi_signature.min as u32,
+                public_keys: multi_signature.public_keys,
+            })
+        } else {
+            None
+        };
+
+        JsLegacyAttributes {
+            legacy_nonce: legacy_attributes.legacy_nonce.map(|nonce| nonce.into()),
+            second_public_key: legacy_attributes.second_public_key,
+            multi_signature,
+        }
+    }
+}
+
+impl Into<LegacyAccountAttributes> for JsLegacyAttributes {
+    fn into(self) -> LegacyAccountAttributes {
+        LegacyAccountAttributes {
+            legacy_nonce: self.legacy_nonce.map(|nonce| nonce.get_u64().1),
+            second_public_key: self.second_public_key,
+            multi_signature: self.multi_signature.map(Into::into),
+        }
+    }
+}
+
+impl Into<LegacyMultiSignatureAttribute> for JsLegacyMultiSignatureAttribute {
+    fn into(self) -> LegacyMultiSignatureAttribute {
+        LegacyMultiSignatureAttribute {
+            min: self.min as usize,
+            public_keys: self.public_keys,
+        }
+    }
+}
+
+#[napi(object)]
+pub struct JsGetAccounts {
+    pub next_offset: Option<BigInt>,
+    pub accounts: Vec<JsAccountInfoExtended>,
+}
+
+impl JsGetAccounts {
+    pub fn new(next_offset: Option<u64>, accounts: Vec<AccountInfoExtended>) -> Self {
+        let next_offset = match next_offset {
+            Some(next_offset) => Some(next_offset.into()),
+            None => None,
+        };
+
+        let mut mapped = Vec::with_capacity(accounts.len());
+        for account in accounts {
+            mapped.push(JsAccountInfoExtended::new(account));
+        }
+
+        JsGetAccounts {
+            next_offset,
+            accounts: mapped,
+        }
+    }
+}
+
+#[napi(object)]
+pub struct JsGetLegacyColdWallets {
+    pub next_offset: Option<BigInt>,
+    pub wallets: Vec<JsLegacyColdWallet>,
+}
+
+impl JsGetLegacyColdWallets {
+    pub fn new(next_offset: Option<u64>, wallets: Vec<LegacyColdWallet>) -> Self {
+        let next_offset = match next_offset {
+            Some(next_offset) => Some(next_offset.into()),
+            None => None,
+        };
+
+        let mut mapped = Vec::with_capacity(wallets.len());
+        for wallet in wallets {
+            mapped.push(JsLegacyColdWallet::new(wallet));
+        }
+
+        JsGetLegacyColdWallets {
+            next_offset,
+            wallets: mapped,
+        }
+    }
+}
+
+#[napi(object)]
+pub struct JsGetReceipts {
+    pub next_offset: Option<BigInt>,
+    pub receipts: Vec<JsTransactionReceipt>,
+}
+
+impl JsGetReceipts {
+    pub fn new(
+        next_offset: Option<u64>,
+        receipts_by_block_number: Vec<(u64, Vec<(B256, TxReceipt)>)>,
+    ) -> anyhow::Result<Self> {
+        let next_offset = match next_offset {
+            Some(next_offset) => Some(next_offset.into()),
+            None => None,
+        };
+
+        let mut mapped = vec![];
+        for (block_number, tx_receipts) in receipts_by_block_number {
+            for (hash, tx_receipt) in tx_receipts {
+                let mut receipt = JsTransactionReceipt::new(tx_receipt);
+
+                receipt.block_number = Some(block_number.into());
+                receipt.tx_hash = Some(format!("{:x}", hash));
+
+                mapped.push(receipt);
+            }
+        }
+
+        Ok(JsGetReceipts {
+            next_offset,
+            receipts: mapped,
+        })
+    }
+}
+
+#[napi(object)]
+pub struct JsGetReceipt {
+    pub receipt: Option<JsTransactionReceipt>,
+}
+
+impl JsGetReceipt {
+    pub fn new(receipt: Option<TxReceipt>, block_number: u64, tx_hash: B256) -> Self {
+        let receipt = match receipt {
+            Some(receipt) => {
+                let mut receipt = JsTransactionReceipt::new(receipt);
+                receipt.block_number = Some(block_number.into());
+                receipt.tx_hash = Some(tx_hash.to_string());
+
+                Some(receipt)
+            }
+            None => None,
+        };
+
+        JsGetReceipt { receipt }
+    }
+}
+
+#[napi(object)]
+pub struct JsGetState {
+    pub block_number: BigInt,
+    pub total_round: BigInt,
+}
+
+impl JsGetState {
+    pub fn new(state: (u64, u64)) -> Self {
+        JsGetState {
+            block_number: state.0.into(),
+            total_round: state.1.into(),
+        }
+    }
+}

package/bindings/src/utils.rs

@@ -0,0 +1,71 @@
+use anyhow;
+use mainsail_evm_core::{db::BlsSig, legacy::LegacyAddress};
+use napi::bindgen_prelude::{BigInt, Buffer};
+use revm::primitives::{Address, B256, Bytes, U256, hex};
+use std::str::FromStr;
+
+pub(crate) fn create_address_from_string(str: &str) -> anyhow::Result<Address> {
+    Ok(Address::from_str(str)?)
+}
+
+pub(crate) fn create_legacy_address_from_string(str: &str) -> anyhow::Result<LegacyAddress> {
+    LegacyAddress::try_from(str).map_err(|err| anyhow::anyhow!("legacy address parse: {:?}", err))
+}
+
+pub(crate) fn convert_js_buffer_to_bytes(buffer: Buffer) -> Bytes {
+    Bytes::from_iter(buffer.as_ref())
+}
+
+pub(crate) fn convert_string_to_b256(str: String) -> anyhow::Result<B256> {
+    Ok(B256::try_from(
+        &Bytes::from_str(str.as_str())?.as_ref()[..],
+    )?)
+}
+
+pub(crate) fn convert_string_to_bls_sig(str: String) -> anyhow::Result<BlsSig> {
+    Ok(BlsSig::try_from(
+        &Bytes::from_str(str.as_str())?.as_ref()[..],
+    )?)
+}
+
+pub(crate) fn convert_hex_to_u256(str: &str) -> U256 {
+    U256::from_le_slice(&hex::decode(&str).expect("valid hex")[..])
+}
+
+pub(crate) fn convert_u256_to_hex(value: U256) -> String {
+    hex::encode(value.to_le_bytes_vec())
+}
+
+pub(crate) fn convert_bigint_to_u256(bigint: BigInt) -> anyhow::Result<U256> {
+    let bytes: Vec<u8> = bigint
+        .words
+        .iter()
+        .flat_map(|word| word.to_le_bytes())
+        .collect();
+
+    U256::try_from_le_slice(&bytes[..]).ok_or_else(|| anyhow::anyhow!("invalid bigint"))
+}
+
+pub(crate) fn convert_bytes_to_js_buffer(bytes: Bytes) -> Buffer {
+    Into::<Vec<u8>>::into(bytes).into()
+}
+
+pub(crate) fn convert_u256_to_bigint(value: U256) -> BigInt {
+    let slice = value.as_le_slice();
+
+    const WORD_SIZE: usize = 8;
+    assert!(slice.len() % WORD_SIZE == 0);
+
+    // https://nodejs.org/api/n-api.html#n_api_napi_create_bigint_words
+    let mut words: Vec<u64> = Vec::with_capacity(slice.len() / WORD_SIZE);
+    for chunk in slice.chunks_exact(WORD_SIZE) {
+        let mut bytes = [0; 8];
+        bytes.copy_from_slice(chunk);
+        words.push(u64::from_le_bytes(bytes));
+    }
+
+    BigInt {
+        words,
+        sign_bit: false,
+    }
+}