├── src ├── utils │ ├── mod.rs │ └── error.rs ├── evm │ ├── mod.rs │ ├── executor │ │ ├── backend │ │ │ ├── mod.rs │ │ │ ├── snapshot.rs │ │ │ └── error.rs │ │ ├── mod.rs │ │ ├── inspector │ │ │ ├── mod.rs │ │ │ └── access_list.rs │ │ └── fork │ │ │ ├── mod.rs │ │ │ ├── cache.rs │ │ │ └── backend.rs │ └── utils.rs ├── lib.rs ├── constants.rs └── main.rs ├── .gitignore ├── Cargo.toml ├── README.md └── Cargo.lock /src/utils/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod error; 2 | -------------------------------------------------------------------------------- /src/evm/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod executor; 2 | pub mod utils; 3 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .env 2 | 3 | /target 4 | 5 | .idea/ 6 | .DS_Store -------------------------------------------------------------------------------- /src/evm/executor/backend/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod error; 2 | pub mod snapshot; 3 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod constants; 2 | pub mod evm; 3 | pub mod utils; 4 | -------------------------------------------------------------------------------- /src/evm/executor/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod backend; 2 | pub mod fork; 3 | pub mod inspector; 4 | -------------------------------------------------------------------------------- /src/evm/executor/inspector/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod access_list; 2 | 3 | pub use access_list::{get_precompiles_for, AccessListTracer}; 4 | -------------------------------------------------------------------------------- /src/evm/executor/fork/mod.rs: -------------------------------------------------------------------------------- 1 | mod backend; 2 | 3 | pub use backend::{BackendHandler, SharedBackend}; 4 | 5 | mod cache; 6 | pub use cache::{BlockchainDb, BlockchainDbMeta, JsonBlockCacheDB, MemDb}; 7 | -------------------------------------------------------------------------------- /src/utils/error.rs: -------------------------------------------------------------------------------- 1 | //! error handling and support 2 | 3 | use ethers_core::{abi::AbiEncode, types::Bytes}; 4 | use std::fmt::Display; 5 | 6 | /// Solidity revert prefix. 7 | /// 8 | /// `keccak256("Error(String)")[..4] == 0x08c379a0` 9 | pub const REVERT_PREFIX: [u8; 4] = [8, 195, 121, 160]; 10 | 11 | /// Custom Cheatcode error prefix. 12 | /// 13 | /// `keccak256("CheatCodeError")[..4] == 0x0bc44503` 14 | pub const ERROR_PREFIX: [u8; 4] = [11, 196, 69, 3]; 15 | 16 | /// An extension trait for `std::error::Error` that can abi-encode itself 17 | pub trait SolError: std::error::Error { 18 | /// Returns the abi-encoded custom error 19 | /// 20 | /// Same as `encode_string` but prefixed with `ERROR_PREFIX` 21 | fn encode_error(&self) -> Bytes { 22 | encode_error(self) 23 | } 24 | 25 | /// Returns the error as abi-encoded String 26 | /// 27 | /// See also [`AbiEncode`](ethers::abi::AbiEncode) 28 | fn encode_string(&self) -> Bytes { 29 | self.to_string().encode().into() 30 | } 31 | } 32 | 33 | /// Encodes the given messages as solidity custom error 34 | pub fn encode_error(reason: impl Display) -> Bytes { 35 | [ 36 | ERROR_PREFIX.as_slice(), 37 | reason.to_string().encode().as_slice(), 38 | ] 39 | .concat() 40 | .into() 41 | } 42 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "foundry-evm-mini" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | # Error handling 10 | anyhow = "1.0.70" 11 | eyre = "0.6" 12 | thiserror = "1" 13 | 14 | # Encoding/decoding 15 | serde_json = "1" 16 | serde = "1" 17 | 18 | # Threading/futures 19 | tokio = { version = "1", features = ["time", "macros"] } 20 | parking_lot = "0.12" 21 | futures = "0.3" 22 | once_cell = "1" 23 | 24 | # Logging 25 | tracing = "0.1" 26 | 27 | url = "2" 28 | 29 | ethers = { version = "2.0.7", features = ["ethers-solc"] } 30 | ethers-addressbook = "2.0.7" 31 | ethers-core = "2.0.7" 32 | ethers-contract = "2.0.7" 33 | ethers-contract-abigen = "2.0.7" 34 | ethers-providers = "2.0.7" 35 | ethers-signers = "2.0.7" 36 | ethers-middleware = "2.0.7" 37 | ethers-etherscan = "2.0.7" 38 | ethers-solc = "2.0.7" 39 | 40 | # EVM 41 | bytes = "1" 42 | hashbrown = { version = "0.13", features = ["serde"] } 43 | revm = { version = "3", default-features = false, features = [ 44 | "std", 45 | "serde", 46 | "memory_limit", 47 | "optional_eip3607", 48 | "optional_block_gas_limit", 49 | "optional_no_base_fee", 50 | ] } 51 | 52 | [patch.crates-io] 53 | revm = { git = "https://github.com/bluealloy/revm/", rev = "80c909d6f242886cb26e6103a01d1a4bf9468426" } -------------------------------------------------------------------------------- /src/constants.rs: -------------------------------------------------------------------------------- 1 | //! Commonly used constants 2 | 3 | use std::time::Duration; 4 | 5 | /// The dev chain-id, inherited from hardhat 6 | pub const DEV_CHAIN_ID: u64 = 31337; 7 | 8 | /// The first four bytes of the call data for a function call specifies the function to be called. 9 | pub const SELECTOR_LEN: usize = 4; 10 | 11 | /// Maximum size in bytes (0x6000) that a contract can have. 12 | pub const CONTRACT_MAX_SIZE: usize = 24576; 13 | 14 | /// Default request timeout for http requests 15 | /// 16 | /// Note: this is only used so that connections, that are discarded on the server side won't stay 17 | /// open forever. We assume some nodes may have some backoff baked into them and will delay some 18 | /// responses. This timeout should be a reasonable amount of time to wait for a request. 19 | pub const REQUEST_TIMEOUT: Duration = Duration::from_secs(45); 20 | 21 | /// Alchemy free tier cups 22 | pub const ALCHEMY_FREE_TIER_CUPS: u64 = 330; 23 | 24 | /// Logged when an error is indicative that the user is trying to fork from a non-archive node. 25 | pub const NON_ARCHIVE_NODE_WARNING: &str = "\ 26 | It looks like you're trying to fork from an older block with a non-archive node which is not \ 27 | supported. Please try to change your RPC url to an archive node if the issue persists."; 28 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Foundry EVM Mini 2 | 3 | A copy of https://github.com/foundry-rs/foundry 4 | 5 | Foundry introduces new changes to their repo everyday, and this can cause projects using foundry-evm break every once in a while. 6 | 7 | This foundry-evm-mini project is an attempt to take a snapshot of the library so that it never breaks again. 8 | 9 | Currently supports: 10 | 11 | - SharedBackend (evm/executor/fork) 12 | - BlockchainDB (evm/executor/fork) 13 | - BlockchainDBMeta (evm/executor/fork) 14 | 15 | Updated (2023.11.04): 16 | 17 | - AccessListTracer (evm/executor/inspector) 18 | 19 | --- 20 | 21 | * How to use? 22 | 23 | To use this repo, you can configure your Cargo.toml as below: 24 | 25 | ``` 26 | [dependencies] 27 | ethers = { version = "2.0", features = ["ethers-solc"] } 28 | 29 | # EVM 30 | bytes = "1" 31 | hashbrown = { version = "0.13", features = ["serde"] } 32 | revm = { version = "3", default-features = false, features = [ 33 | "std", 34 | "serde", 35 | "memory_limit", 36 | "optional_eip3607", 37 | "optional_block_gas_limit", 38 | "optional_no_base_fee", 39 | ] } 40 | 41 | foundry-evm-mini = { git = "https://github.com/solidquant/foundry-evm-mini.git" } 42 | 43 | [patch.crates-io] 44 | revm = { git = "https://github.com/bluealloy/revm/", rev = "80c909d6f242886cb26e6103a01d1a4bf9468426" } 45 | ``` 46 | 47 | Make sure **revm** version is patched to the commit at: 80c909d6f242886cb26e6103a01d1a4bf9468426 (v3.4) -------------------------------------------------------------------------------- /src/evm/executor/backend/snapshot.rs: -------------------------------------------------------------------------------- 1 | use revm::{ 2 | primitives::{AccountInfo, Env, HashMap as Map, B160, B256, U256}, 3 | JournaledState, 4 | }; 5 | use serde::{Deserialize, Serialize}; 6 | 7 | /// A minimal abstraction of a state at a certain point in time 8 | #[derive(Default, Clone, Debug, Serialize, Deserialize)] 9 | pub struct StateSnapshot { 10 | pub accounts: Map, 11 | pub storage: Map>, 12 | pub block_hashes: Map, 13 | } 14 | 15 | /// Represents a snapshot taken during evm execution 16 | #[derive(Clone, Debug)] 17 | pub struct BackendSnapshot { 18 | pub db: T, 19 | /// The journaled_state state at a specific point 20 | pub journaled_state: JournaledState, 21 | /// Contains the env at the time of the snapshot 22 | pub env: Env, 23 | } 24 | 25 | // === impl BackendSnapshot === 26 | 27 | impl BackendSnapshot { 28 | /// Takes a new snapshot 29 | pub fn new(db: T, journaled_state: JournaledState, env: Env) -> Self { 30 | Self { 31 | db, 32 | journaled_state, 33 | env, 34 | } 35 | } 36 | 37 | /// Called when this snapshot is reverted. 38 | /// 39 | /// Since we want to keep all additional logs that were emitted since the snapshot was taken 40 | /// we'll merge additional logs into the snapshot's `revm::JournaledState`. Additional logs are 41 | /// those logs that are missing in the snapshot's journaled_state, since the current 42 | /// journaled_state includes the same logs, we can simply replace use that See also 43 | /// `DatabaseExt::revert` 44 | pub fn merge(&mut self, current: &JournaledState) { 45 | self.journaled_state.logs = current.logs.clone(); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/main.rs: -------------------------------------------------------------------------------- 1 | use anyhow::{anyhow, Result}; 2 | use ethers::abi::parse_abi; 3 | use ethers::providers::{Middleware, Provider, Ws}; 4 | use ethers::types::{BlockNumber, H160}; 5 | use ethers_contract::BaseContract; 6 | use revm::{ 7 | db::CacheDB, 8 | primitives::{ExecutionResult, Output, TransactTo, U256 as rU256}, 9 | EVM, 10 | }; 11 | use std::{collections::BTreeSet, str::FromStr, sync::Arc}; 12 | 13 | use foundry_evm_mini::evm::executor::{ 14 | fork::{BlockchainDb, BlockchainDbMeta, SharedBackend}, 15 | inspector::{get_precompiles_for, AccessListTracer}, 16 | }; 17 | 18 | #[tokio::main] 19 | async fn main() -> Result<()> { 20 | let wss_url = "wss://eth-mainnet.g.alchemy.com/v2/ainc64D6aQZ6i7QwDkYqUkSVj754iwGz"; 21 | let ws = Ws::connect(wss_url).await.unwrap(); 22 | let provider = Arc::new(Provider::new(ws)); 23 | 24 | let block = provider 25 | .get_block(BlockNumber::Latest) 26 | .await 27 | .unwrap() 28 | .unwrap(); 29 | 30 | let shared_backend = SharedBackend::spawn_backend_thread( 31 | provider.clone(), 32 | BlockchainDb::new( 33 | BlockchainDbMeta { 34 | cfg_env: Default::default(), 35 | block_env: Default::default(), 36 | hosts: BTreeSet::from(["".to_string()]), 37 | }, 38 | None, 39 | ), 40 | Some(block.number.unwrap().into()), 41 | ); 42 | let db = CacheDB::new(shared_backend); 43 | 44 | let mut evm = EVM::new(); 45 | evm.database(db); 46 | 47 | evm.env.cfg.limit_contract_code_size = Some(0x100000); 48 | evm.env.cfg.disable_block_gas_limit = true; 49 | evm.env.cfg.disable_base_fee = true; 50 | 51 | evm.env.block.number = rU256::from(block.number.unwrap().as_u64() + 1); 52 | 53 | let uniswap_v2_factory = BaseContract::from(parse_abi(&[ 54 | "function getPair(address,address) external view returns (address)", 55 | ])?); 56 | 57 | let factory = H160::from_str("0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f").unwrap(); 58 | let weth = H160::from_str("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap(); 59 | let usdt = H160::from_str("0xdac17f958d2ee523a2206206994597c13d831ec7").unwrap(); 60 | 61 | let calldata = uniswap_v2_factory.encode("getPair", (weth, usdt))?; 62 | 63 | evm.env.tx.caller = H160::from_str("0xD90Ed9c2679C6a9EA85A89F9af0b7b0690D530B6") 64 | .unwrap() 65 | .into(); 66 | evm.env.tx.transact_to = TransactTo::Call(factory.into()); 67 | evm.env.tx.data = calldata.0; 68 | evm.env.tx.value = rU256::ZERO; 69 | evm.env.tx.gas_limit = 5000000; 70 | 71 | let ref_tx = evm.transact_ref()?; 72 | let result = ref_tx.result; 73 | 74 | match result { 75 | ExecutionResult::Success { output, logs, .. } => match output { 76 | Output::Call(o) => { 77 | let pair_address: H160 = uniswap_v2_factory.decode_output("getPair", o)?; 78 | println!("Pair address: {:?}", pair_address); 79 | 80 | for log in logs { 81 | println!("{:?}", log); 82 | } 83 | } 84 | _ => {} 85 | }, 86 | _ => {} 87 | }; 88 | 89 | // get access list example 90 | let mut access_list_inspector = AccessListTracer::new( 91 | Default::default(), 92 | evm.env.tx.caller.into(), 93 | factory, 94 | get_precompiles_for(evm.env.cfg.spec_id), 95 | ); 96 | evm.inspect_ref(&mut access_list_inspector) 97 | .map_err(|e| anyhow!("[EVM ERROR] access list: {:?}", (e)))?; 98 | let access_list = access_list_inspector.access_list(); 99 | println!("{:?}", access_list); 100 | 101 | Ok(()) 102 | } 103 | -------------------------------------------------------------------------------- /src/evm/executor/backend/error.rs: -------------------------------------------------------------------------------- 1 | use crate::utils::error::SolError; 2 | use ethers::types::{Address, BlockId, H256, U256}; 3 | use futures::channel::mpsc::{SendError, TrySendError}; 4 | use std::{ 5 | convert::Infallible, 6 | fmt, 7 | sync::{mpsc::RecvError, Arc}, 8 | }; 9 | 10 | /// Result alias with `DatabaseError` as error 11 | pub type DatabaseResult = Result; 12 | 13 | /// Errors that can happen when working with [`revm::Database`] 14 | #[derive(Debug, thiserror::Error)] 15 | pub enum DatabaseError { 16 | #[error("Failed to fetch AccountInfo {0:?}")] 17 | MissingAccount(Address), 18 | #[error("Could should already be loaded: {0:?}")] 19 | MissingCode(H256), 20 | #[error(transparent)] 21 | Recv(#[from] RecvError), 22 | #[error(transparent)] 23 | Send(#[from] SendError), 24 | #[error("{0}")] 25 | Message(String), 26 | #[error("Failed to get account for {0:?}: {0:?}")] 27 | GetAccount(Address, Arc), 28 | #[error("Failed to get storage for {0:?} at {1:?}: {2:?}")] 29 | GetStorage(Address, U256, Arc), 30 | #[error("Failed to get block hash for {0}: {1:?}")] 31 | GetBlockHash(u64, Arc), 32 | #[error("Failed to get full block for {0:?}: {1:?}")] 33 | GetFullBlock(BlockId, Arc), 34 | #[error("Block {0:?} does not exist")] 35 | BlockNotFound(BlockId), 36 | #[error("Failed to get transaction {0:?}: {1:?}")] 37 | GetTransaction(H256, Arc), 38 | #[error("Transaction {0:?} not found")] 39 | TransactionNotFound(H256), 40 | #[error( 41 | "CREATE2 Deployer not present on this chain. [0x4e59b44847b379578588920ca78fbf26c0b4956c]" 42 | )] 43 | MissingCreate2Deployer, 44 | #[error(transparent)] 45 | JoinError(#[from] tokio::task::JoinError), 46 | } 47 | 48 | impl DatabaseError { 49 | /// Create a new error with a message 50 | pub fn msg(msg: impl Into) -> Self { 51 | DatabaseError::Message(msg.into()) 52 | } 53 | 54 | fn get_rpc_error(&self) -> Option<&eyre::Error> { 55 | match self { 56 | Self::GetAccount(_, err) => Some(err), 57 | Self::GetStorage(_, _, err) => Some(err), 58 | Self::GetBlockHash(_, err) => Some(err), 59 | Self::GetFullBlock(_, err) => Some(err), 60 | Self::GetTransaction(_, err) => Some(err), 61 | // Enumerate explicitly to make sure errors are updated if a new one is added. 62 | Self::MissingAccount(_) 63 | | Self::MissingCode(_) 64 | | Self::Recv(_) 65 | | Self::Send(_) 66 | | Self::Message(_) 67 | | Self::BlockNotFound(_) 68 | | Self::TransactionNotFound(_) 69 | | Self::MissingCreate2Deployer 70 | | Self::JoinError(_) => None, 71 | } 72 | } 73 | 74 | /// Whether the error is potentially caused by the user forking from an older block in a 75 | /// non-archive node. 76 | pub fn is_possibly_non_archive_node_error(&self) -> bool { 77 | static GETH_MESSAGE: &str = "missing trie node"; 78 | 79 | self.get_rpc_error() 80 | .map(|err| err.to_string().to_lowercase().contains(GETH_MESSAGE)) 81 | .unwrap_or(false) 82 | } 83 | } 84 | 85 | impl SolError for DatabaseError {} 86 | 87 | impl From> for DatabaseError { 88 | fn from(err: TrySendError) -> Self { 89 | err.into_send_error().into() 90 | } 91 | } 92 | 93 | impl From for DatabaseError { 94 | fn from(never: Infallible) -> Self { 95 | match never {} 96 | } 97 | } 98 | 99 | /// Error thrown when the address is not allowed to execute cheatcodes 100 | /// 101 | /// See also [`DatabaseExt`](crate::executor::DatabaseExt) 102 | #[derive(Debug, Clone, Copy)] 103 | pub struct NoCheatcodeAccessError(pub Address); 104 | 105 | impl fmt::Display for NoCheatcodeAccessError { 106 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 107 | write!( 108 | f, 109 | "No cheatcode access granted for: {:?}, see `vm.allowCheatcodes()`", 110 | self.0 111 | ) 112 | } 113 | } 114 | 115 | impl std::error::Error for NoCheatcodeAccessError {} 116 | 117 | impl SolError for NoCheatcodeAccessError {} 118 | -------------------------------------------------------------------------------- /src/evm/executor/inspector/access_list.rs: -------------------------------------------------------------------------------- 1 | use ethers::{ 2 | abi::{ethereum_types::BigEndianHash, Address}, 3 | types::{ 4 | transaction::eip2930::{AccessList, AccessListItem}, 5 | H160, H256, 6 | }, 7 | }; 8 | use hashbrown::{HashMap, HashSet}; 9 | use revm::{ 10 | interpreter::{opcode, InstructionResult, Interpreter}, 11 | precompile::Precompiles, 12 | primitives::SpecId, 13 | Database, EVMData, Inspector, 14 | }; 15 | use std::fmt; 16 | 17 | use crate::evm::utils::{b160_to_h160, ru256_to_u256}; 18 | 19 | pub fn get_precompiles_for(spec_id: SpecId) -> Vec
{ 20 | Precompiles::new(to_precompile_id(spec_id)) 21 | .addresses() 22 | .into_iter() 23 | .map(|item| H160::from_slice(item)) 24 | .collect() 25 | } 26 | 27 | /// wrapper type that displays byte as hex 28 | pub struct HexDisplay<'a>(&'a [u8]); 29 | 30 | pub fn hex_fmt_many(i: I) -> String 31 | where 32 | I: IntoIterator, 33 | T: AsRef<[u8]>, 34 | { 35 | i.into_iter() 36 | .map(|item| HexDisplay::from(item.as_ref()).to_string()) 37 | .collect::>() 38 | .join(", ") 39 | } 40 | 41 | impl<'a> HexDisplay<'a> { 42 | pub fn from(b: &'a [u8]) -> Self { 43 | HexDisplay(b) 44 | } 45 | } 46 | 47 | impl<'a> fmt::Display for HexDisplay<'a> { 48 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 49 | if self.0.len() < 1027 { 50 | for byte in self.0 { 51 | f.write_fmt(format_args!("{byte:02x}"))?; 52 | } 53 | } else { 54 | for byte in &self.0[0..512] { 55 | f.write_fmt(format_args!("{byte:02x}"))?; 56 | } 57 | f.write_str("...")?; 58 | for byte in &self.0[self.0.len() - 512..] { 59 | f.write_fmt(format_args!("{byte:02x}"))?; 60 | } 61 | } 62 | Ok(()) 63 | } 64 | } 65 | 66 | impl<'a> fmt::Debug for HexDisplay<'a> { 67 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 68 | for byte in self.0 { 69 | f.write_fmt(format_args!("{byte:02x}"))?; 70 | } 71 | Ok(()) 72 | } 73 | } 74 | 75 | pub fn to_precompile_id(spec_id: SpecId) -> revm::precompile::SpecId { 76 | match spec_id { 77 | SpecId::FRONTIER 78 | | SpecId::FRONTIER_THAWING 79 | | SpecId::HOMESTEAD 80 | | SpecId::DAO_FORK 81 | | SpecId::TANGERINE 82 | | SpecId::SPURIOUS_DRAGON => revm::precompile::SpecId::HOMESTEAD, 83 | SpecId::BYZANTIUM | SpecId::CONSTANTINOPLE | SpecId::PETERSBURG => { 84 | revm::precompile::SpecId::BYZANTIUM 85 | } 86 | SpecId::ISTANBUL | SpecId::MUIR_GLACIER => revm::precompile::SpecId::ISTANBUL, 87 | SpecId::BERLIN 88 | | SpecId::LONDON 89 | | SpecId::ARROW_GLACIER 90 | | SpecId::GRAY_GLACIER 91 | | SpecId::MERGE 92 | | SpecId::SHANGHAI 93 | | SpecId::CANCUN 94 | | SpecId::LATEST => revm::precompile::SpecId::BERLIN, 95 | } 96 | } 97 | 98 | /// An inspector that collects touched accounts and storage slots. 99 | #[derive(Default, Debug)] 100 | pub struct AccessListTracer { 101 | excluded: HashSet
, 102 | access_list: HashMap>, 103 | } 104 | 105 | impl AccessListTracer { 106 | pub fn new( 107 | access_list: AccessList, 108 | from: Address, 109 | to: Address, 110 | precompiles: Vec
, 111 | ) -> Self { 112 | AccessListTracer { 113 | excluded: [from, to] 114 | .iter() 115 | .chain(precompiles.iter()) 116 | .copied() 117 | .collect(), 118 | access_list: access_list 119 | .0 120 | .iter() 121 | .map(|v| (v.address, v.storage_keys.iter().copied().collect())) 122 | .collect(), 123 | } 124 | } 125 | 126 | pub fn access_list(&self) -> AccessList { 127 | AccessList::from( 128 | self.access_list 129 | .iter() 130 | .map(|(address, slots)| AccessListItem { 131 | address: *address, 132 | storage_keys: slots.iter().copied().collect(), 133 | }) 134 | .collect::>(), 135 | ) 136 | } 137 | } 138 | 139 | impl Inspector for AccessListTracer { 140 | #[inline] 141 | fn step( 142 | &mut self, 143 | interpreter: &mut Interpreter, 144 | _data: &mut EVMData<'_, DB>, 145 | ) -> InstructionResult { 146 | let pc = interpreter.program_counter(); 147 | let op = interpreter.contract.bytecode.bytecode()[pc]; 148 | 149 | match op { 150 | opcode::SLOAD | opcode::SSTORE => { 151 | if let Ok(slot) = interpreter.stack().peek(0) { 152 | let cur_contract = interpreter.contract.address; 153 | self.access_list 154 | .entry(b160_to_h160(cur_contract)) 155 | .or_default() 156 | .insert(H256::from_uint(&ru256_to_u256(slot))); 157 | } 158 | } 159 | opcode::EXTCODECOPY 160 | | opcode::EXTCODEHASH 161 | | opcode::EXTCODESIZE 162 | | opcode::BALANCE 163 | | opcode::SELFDESTRUCT => { 164 | if let Ok(slot) = interpreter.stack().peek(0) { 165 | let addr: Address = H256::from_uint(&ru256_to_u256(slot)).into(); 166 | if !self.excluded.contains(&addr) { 167 | self.access_list.entry(addr).or_default(); 168 | } 169 | } 170 | } 171 | opcode::DELEGATECALL | opcode::CALL | opcode::STATICCALL | opcode::CALLCODE => { 172 | if let Ok(slot) = interpreter.stack().peek(1) { 173 | let addr: Address = H256::from_uint(&ru256_to_u256(slot)).into(); 174 | if !self.excluded.contains(&addr) { 175 | self.access_list.entry(addr).or_default(); 176 | } 177 | } 178 | } 179 | _ => (), 180 | } 181 | 182 | InstructionResult::Continue 183 | } 184 | } 185 | -------------------------------------------------------------------------------- /src/evm/utils.rs: -------------------------------------------------------------------------------- 1 | use ethers::{ 2 | abi::{Abi, FixedBytes, Function}, 3 | solc::EvmVersion, 4 | types::{Block, Chain, H256, U256}, 5 | }; 6 | use eyre::ContextCompat; 7 | use revm::{ 8 | interpreter::{opcode, opcode::spec_opcode_gas, InstructionResult}, 9 | primitives::{Eval, Halt, SpecId}, 10 | }; 11 | use std::collections::BTreeMap; 12 | 13 | /// Small helper function to convert [U256] into [H256]. 14 | #[inline] 15 | pub fn u256_to_h256_le(u: U256) -> H256 { 16 | let mut h = H256::default(); 17 | u.to_little_endian(h.as_mut()); 18 | h 19 | } 20 | 21 | /// Small helper function to convert [U256] into [H256]. 22 | #[inline] 23 | pub fn u256_to_h256_be(u: U256) -> H256 { 24 | let mut h = H256::default(); 25 | u.to_big_endian(h.as_mut()); 26 | h 27 | } 28 | 29 | /// Small helper function to convert [H256] into [U256]. 30 | #[inline] 31 | pub fn h256_to_u256_be(storage: H256) -> U256 { 32 | U256::from_big_endian(storage.as_bytes()) 33 | } 34 | 35 | /// Small helper function to convert [H256] into [U256]. 36 | #[inline] 37 | pub fn h256_to_u256_le(storage: H256) -> U256 { 38 | U256::from_little_endian(storage.as_bytes()) 39 | } 40 | 41 | /// Small helper function to convert revm's [B160] into ethers's [H160]. 42 | #[inline] 43 | pub fn b160_to_h160(b: revm::primitives::B160) -> ethers::types::H160 { 44 | ethers::types::H160(b.0) 45 | } 46 | 47 | /// Small helper function to convert ethers's [H160] into revm's [B160]. 48 | #[inline] 49 | pub fn h160_to_b160(h: ethers::types::H160) -> revm::primitives::B160 { 50 | revm::primitives::B160(h.0) 51 | } 52 | 53 | /// Small helper function to convert revm's [B256] into ethers's [H256]. 54 | #[inline] 55 | pub fn b256_to_h256(b: revm::primitives::B256) -> ethers::types::H256 { 56 | ethers::types::H256(b.0) 57 | } 58 | 59 | /// Small helper function to convert ether's [H256] into revm's [B256]. 60 | #[inline] 61 | pub fn h256_to_b256(h: ethers::types::H256) -> revm::primitives::B256 { 62 | revm::primitives::B256(h.0) 63 | } 64 | 65 | /// Small helper function to convert ether's [U256] into revm's [U256]. 66 | #[inline] 67 | pub fn u256_to_ru256(u: ethers::types::U256) -> revm::primitives::U256 { 68 | let mut buffer = [0u8; 32]; 69 | u.to_little_endian(buffer.as_mut_slice()); 70 | revm::primitives::U256::from_le_bytes(buffer) 71 | } 72 | 73 | /// Small helper function to convert revm's [U256] into ethers's [U256]. 74 | #[inline] 75 | pub fn ru256_to_u256(u: revm::primitives::U256) -> ethers::types::U256 { 76 | ethers::types::U256::from_little_endian(&u.as_le_bytes()) 77 | } 78 | 79 | /// Small helper function to convert an Eval into an InstructionResult 80 | #[inline] 81 | pub fn eval_to_instruction_result(eval: Eval) -> InstructionResult { 82 | match eval { 83 | Eval::Return => InstructionResult::Return, 84 | Eval::Stop => InstructionResult::Stop, 85 | Eval::SelfDestruct => InstructionResult::SelfDestruct, 86 | } 87 | } 88 | 89 | /// Small helper function to convert a Halt into an InstructionResult 90 | #[inline] 91 | pub fn halt_to_instruction_result(halt: Halt) -> InstructionResult { 92 | match halt { 93 | Halt::OutOfGas(_) => InstructionResult::OutOfGas, 94 | Halt::OpcodeNotFound => InstructionResult::OpcodeNotFound, 95 | Halt::InvalidFEOpcode => InstructionResult::InvalidFEOpcode, 96 | Halt::InvalidJump => InstructionResult::InvalidJump, 97 | Halt::NotActivated => InstructionResult::NotActivated, 98 | Halt::StackOverflow => InstructionResult::StackOverflow, 99 | Halt::StackUnderflow => InstructionResult::StackUnderflow, 100 | Halt::OutOfOffset => InstructionResult::OutOfOffset, 101 | Halt::CreateCollision => InstructionResult::CreateCollision, 102 | Halt::PrecompileError => InstructionResult::PrecompileError, 103 | Halt::NonceOverflow => InstructionResult::NonceOverflow, 104 | Halt::CreateContractSizeLimit => InstructionResult::CreateContractSizeLimit, 105 | Halt::CreateContractStartingWithEF => InstructionResult::CreateContractStartingWithEF, 106 | Halt::CreateInitcodeSizeLimit => InstructionResult::CreateInitcodeSizeLimit, 107 | Halt::OverflowPayment => InstructionResult::OverflowPayment, 108 | Halt::StateChangeDuringStaticCall => InstructionResult::StateChangeDuringStaticCall, 109 | Halt::CallNotAllowedInsideStatic => InstructionResult::CallNotAllowedInsideStatic, 110 | Halt::OutOfFund => InstructionResult::OutOfFund, 111 | Halt::CallTooDeep => InstructionResult::CallTooDeep, 112 | } 113 | } 114 | 115 | /// Converts an `EvmVersion` into a `SpecId`. 116 | #[inline] 117 | pub fn evm_spec(evm: EvmVersion) -> SpecId { 118 | match evm { 119 | EvmVersion::Homestead => SpecId::HOMESTEAD, 120 | EvmVersion::TangerineWhistle => SpecId::TANGERINE, 121 | EvmVersion::SpuriousDragon => SpecId::SPURIOUS_DRAGON, 122 | EvmVersion::Byzantium => SpecId::BYZANTIUM, 123 | EvmVersion::Constantinople => SpecId::CONSTANTINOPLE, 124 | EvmVersion::Petersburg => SpecId::PETERSBURG, 125 | EvmVersion::Istanbul => SpecId::ISTANBUL, 126 | EvmVersion::Berlin => SpecId::BERLIN, 127 | EvmVersion::London => SpecId::LONDON, 128 | EvmVersion::Paris => SpecId::MERGE, 129 | EvmVersion::Shanghai => SpecId::SHANGHAI, 130 | } 131 | } 132 | 133 | /// Depending on the configured chain id and block number this should apply any specific changes 134 | /// 135 | /// This checks for: 136 | /// - prevrandao mixhash after merge 137 | pub fn apply_chain_and_block_specific_env_changes( 138 | env: &mut revm::primitives::Env, 139 | block: &Block, 140 | ) { 141 | if let Ok(chain) = Chain::try_from(U256::from(env.cfg.chain_id)) { 142 | let block_number = block.number.unwrap_or_default(); 143 | 144 | match chain { 145 | Chain::Mainnet => { 146 | // after merge difficulty is supplanted with prevrandao EIP-4399 147 | if block_number.as_u64() >= 15_537_351u64 { 148 | env.block.difficulty = env.block.prevrandao.unwrap_or_default().into(); 149 | } 150 | 151 | return; 152 | } 153 | Chain::Arbitrum 154 | | Chain::ArbitrumGoerli 155 | | Chain::ArbitrumNova 156 | | Chain::ArbitrumTestnet => { 157 | // on arbitrum `block.number` is the L1 block which is included in the 158 | // `l1BlockNumber` field 159 | if let Some(l1_block_number) = block.other.get("l1BlockNumber").cloned() { 160 | if let Ok(l1_block_number) = serde_json::from_value::(l1_block_number) { 161 | env.block.number = l1_block_number.into(); 162 | } 163 | } 164 | } 165 | _ => {} 166 | } 167 | } 168 | 169 | // if difficulty is `0` we assume it's past merge 170 | if block.difficulty.is_zero() { 171 | env.block.difficulty = env.block.prevrandao.unwrap_or_default().into(); 172 | } 173 | } 174 | 175 | /// A map of program counters to instruction counters. 176 | pub type PCICMap = BTreeMap; 177 | 178 | /// Builds a mapping from program counters to instruction counters. 179 | pub fn build_pc_ic_map(spec: SpecId, code: &[u8]) -> PCICMap { 180 | let opcode_infos = spec_opcode_gas(spec); 181 | let mut pc_ic_map: PCICMap = BTreeMap::new(); 182 | 183 | let mut i = 0; 184 | let mut cumulative_push_size = 0; 185 | while i < code.len() { 186 | let op = code[i]; 187 | pc_ic_map.insert(i, i - cumulative_push_size); 188 | if opcode_infos[op as usize].is_push() { 189 | // Skip the push bytes. 190 | // 191 | // For more context on the math, see: https://github.com/bluealloy/revm/blob/007b8807b5ad7705d3cacce4d92b89d880a83301/crates/revm/src/interpreter/contract.rs#L114-L115 192 | i += (op - opcode::PUSH1 + 1) as usize; 193 | cumulative_push_size += (op - opcode::PUSH1 + 1) as usize; 194 | } 195 | i += 1; 196 | } 197 | 198 | pc_ic_map 199 | } 200 | 201 | /// A map of instruction counters to program counters. 202 | pub type ICPCMap = BTreeMap; 203 | 204 | /// Builds a mapping from instruction counters to program counters. 205 | pub fn build_ic_pc_map(spec: SpecId, code: &[u8]) -> ICPCMap { 206 | let opcode_infos = spec_opcode_gas(spec); 207 | let mut ic_pc_map: ICPCMap = ICPCMap::new(); 208 | 209 | let mut i = 0; 210 | let mut cumulative_push_size = 0; 211 | while i < code.len() { 212 | let op = code[i]; 213 | ic_pc_map.insert(i - cumulative_push_size, i); 214 | if opcode_infos[op as usize].is_push() { 215 | // Skip the push bytes. 216 | // 217 | // For more context on the math, see: https://github.com/bluealloy/revm/blob/007b8807b5ad7705d3cacce4d92b89d880a83301/crates/revm/src/interpreter/contract.rs#L114-L115 218 | i += (op - opcode::PUSH1 + 1) as usize; 219 | cumulative_push_size += (op - opcode::PUSH1 + 1) as usize; 220 | } 221 | i += 1; 222 | } 223 | 224 | ic_pc_map 225 | } 226 | 227 | /// Given an ABI and selector, it tries to find the respective function. 228 | pub fn get_function( 229 | contract_name: &str, 230 | selector: &FixedBytes, 231 | abi: &Abi, 232 | ) -> eyre::Result { 233 | abi.functions() 234 | .find(|func| func.short_signature().as_slice() == selector.as_slice()) 235 | .cloned() 236 | .wrap_err(format!( 237 | "{contract_name} does not have the selector {selector:?}" 238 | )) 239 | } 240 | 241 | // TODO: Add this once solc is removed from this crate 242 | pub use ethers::solc::utils::RuntimeOrHandle; 243 | 244 | /* 245 | use tokio::runtime::{Handle, Runtime}; 246 | 247 | #[derive(Debug)] 248 | pub enum RuntimeOrHandle { 249 | Runtime(Runtime), 250 | Handle(Handle), 251 | } 252 | 253 | impl Default for RuntimeOrHandle { 254 | fn default() -> Self { 255 | Self::new() 256 | } 257 | } 258 | 259 | impl RuntimeOrHandle { 260 | pub fn new() -> RuntimeOrHandle { 261 | match Handle::try_current() { 262 | Ok(handle) => RuntimeOrHandle::Handle(handle), 263 | Err(_) => RuntimeOrHandle::Runtime(Runtime::new().expect("Failed to start runtime")), 264 | } 265 | } 266 | 267 | pub fn block_on(&self, f: F) -> F::Output { 268 | match &self { 269 | RuntimeOrHandle::Runtime(runtime) => runtime.block_on(f), 270 | RuntimeOrHandle::Handle(handle) => tokio::task::block_in_place(|| handle.block_on(f)), 271 | } 272 | } 273 | } 274 | */ 275 | -------------------------------------------------------------------------------- /src/evm/executor/fork/cache.rs: -------------------------------------------------------------------------------- 1 | //! Cache related abstraction 2 | use crate::evm::executor::backend::snapshot::StateSnapshot; 3 | use parking_lot::RwLock; 4 | use revm::{ 5 | primitives::{ 6 | Account, AccountInfo, AccountStatus, HashMap as Map, B160, B256, KECCAK_EMPTY, U256, 7 | }, 8 | DatabaseCommit, 9 | }; 10 | use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer}; 11 | use std::{ 12 | collections::BTreeSet, 13 | fs, 14 | io::{BufWriter, Write}, 15 | path::PathBuf, 16 | sync::Arc, 17 | }; 18 | use tracing::{trace, warn}; 19 | 20 | use url::Url; 21 | 22 | pub type StorageInfo = Map; 23 | 24 | /// A shareable Block database 25 | #[derive(Clone, Debug)] 26 | pub struct BlockchainDb { 27 | /// Contains all the data 28 | db: Arc, 29 | /// metadata of the current config 30 | meta: Arc>, 31 | /// the cache that can be flushed 32 | cache: Arc, 33 | } 34 | 35 | impl BlockchainDb { 36 | /// Creates a new instance of the [BlockchainDb] 37 | /// 38 | /// if a `cache_path` is provided it attempts to load a previously stored [JsonBlockCacheData] 39 | /// and will try to use the cached entries it holds. 40 | /// 41 | /// This will return a new and empty [MemDb] if 42 | /// - `cache_path` is `None` 43 | /// - the file the `cache_path` points to, does not exist 44 | /// - the file contains malformed data, or if it couldn't be read 45 | /// - the provided `meta` differs from [BlockchainDbMeta] that's stored on disk 46 | pub fn new(meta: BlockchainDbMeta, cache_path: Option) -> Self { 47 | Self::new_db(meta, cache_path, false) 48 | } 49 | 50 | /// Creates a new instance of the [BlockchainDb] and skips check when comparing meta 51 | /// This is useful for offline-start mode when we don't want to fetch metadata of `block`. 52 | /// 53 | /// if a `cache_path` is provided it attempts to load a previously stored [JsonBlockCacheData] 54 | /// and will try to use the cached entries it holds. 55 | /// 56 | /// This will return a new and empty [MemDb] if 57 | /// - `cache_path` is `None` 58 | /// - the file the `cache_path` points to, does not exist 59 | /// - the file contains malformed data, or if it couldn't be read 60 | /// - the provided `meta` differs from [BlockchainDbMeta] that's stored on disk 61 | pub fn new_skip_check(meta: BlockchainDbMeta, cache_path: Option) -> Self { 62 | Self::new_db(meta, cache_path, true) 63 | } 64 | 65 | fn new_db(meta: BlockchainDbMeta, cache_path: Option, skip_check: bool) -> Self { 66 | trace!(target : "forge::cache", cache=?cache_path, "initialising blockchain db"); 67 | // read cache and check if metadata matches 68 | let cache = cache_path 69 | .as_ref() 70 | .and_then(|p| { 71 | JsonBlockCacheDB::load(p).ok().filter(|cache| { 72 | if skip_check { 73 | return true; 74 | } 75 | let mut existing = cache.meta().write(); 76 | existing.hosts.extend(meta.hosts.clone()); 77 | if meta != *existing { 78 | warn!(target : "cache", "non-matching block metadata"); 79 | false 80 | } else { 81 | true 82 | } 83 | }) 84 | }) 85 | .unwrap_or_else(|| JsonBlockCacheDB::new(Arc::new(RwLock::new(meta)), cache_path)); 86 | 87 | Self { 88 | db: Arc::clone(cache.db()), 89 | meta: Arc::clone(cache.meta()), 90 | cache: Arc::new(cache), 91 | } 92 | } 93 | 94 | /// Returns the map that holds the account related info 95 | pub fn accounts(&self) -> &RwLock> { 96 | &self.db.accounts 97 | } 98 | 99 | /// Returns the map that holds the storage related info 100 | pub fn storage(&self) -> &RwLock> { 101 | &self.db.storage 102 | } 103 | 104 | /// Returns the map that holds all the block hashes 105 | pub fn block_hashes(&self) -> &RwLock> { 106 | &self.db.block_hashes 107 | } 108 | 109 | /// Returns the [revm::Env] related metadata 110 | pub fn meta(&self) -> &Arc> { 111 | &self.meta 112 | } 113 | 114 | /// Returns the inner cache 115 | pub fn cache(&self) -> &Arc { 116 | &self.cache 117 | } 118 | 119 | /// Returns the underlying storage 120 | pub fn db(&self) -> &Arc { 121 | &self.db 122 | } 123 | } 124 | 125 | /// relevant identifying markers in the context of [BlockchainDb] 126 | #[derive(Debug, Clone, Eq, Serialize)] 127 | pub struct BlockchainDbMeta { 128 | pub cfg_env: revm::primitives::CfgEnv, 129 | pub block_env: revm::primitives::BlockEnv, 130 | /// all the hosts used to connect to 131 | pub hosts: BTreeSet, 132 | } 133 | 134 | impl BlockchainDbMeta { 135 | /// Creates a new instance 136 | pub fn new(env: revm::primitives::Env, url: String) -> Self { 137 | let host = Url::parse(&url) 138 | .ok() 139 | .and_then(|url| url.host().map(|host| host.to_string())) 140 | .unwrap_or(url); 141 | 142 | BlockchainDbMeta { 143 | cfg_env: env.cfg.clone(), 144 | block_env: env.block, 145 | hosts: BTreeSet::from([host]), 146 | } 147 | } 148 | } 149 | 150 | // ignore hosts to not invalidate the cache when different endpoints are used, as it's commonly the 151 | // case for http vs ws endpoints 152 | impl PartialEq for BlockchainDbMeta { 153 | fn eq(&self, other: &Self) -> bool { 154 | self.cfg_env == other.cfg_env && self.block_env == other.block_env 155 | } 156 | } 157 | 158 | impl<'de> Deserialize<'de> for BlockchainDbMeta { 159 | fn deserialize(deserializer: D) -> Result 160 | where 161 | D: Deserializer<'de>, 162 | { 163 | /// A backwards compatible representation of [revm::CfgEnv] 164 | /// 165 | /// This prevents deserialization errors of cache files caused by breaking changes to the 166 | /// default [revm::CfgEnv], for example enabling an optional feature. 167 | /// By hand rolling deserialize impl we can prevent cache file issues 168 | struct CfgEnvBackwardsCompat { 169 | inner: revm::primitives::CfgEnv, 170 | } 171 | 172 | impl<'de> Deserialize<'de> for CfgEnvBackwardsCompat { 173 | fn deserialize(deserializer: D) -> Result 174 | where 175 | D: Deserializer<'de>, 176 | { 177 | let mut value = serde_json::Value::deserialize(deserializer)?; 178 | 179 | // we check for breaking changes here 180 | if let Some(obj) = value.as_object_mut() { 181 | // additional field `disable_eip3607` enabled by the `optional_eip3607` feature 182 | let key = "disable_eip3607"; 183 | if !obj.contains_key(key) { 184 | obj.insert(key.to_string(), true.into()); 185 | } 186 | // additional field `disable_block_gas_limit` enabled by the 187 | // `optional_block_gas_limit` feature 188 | let key = "disable_block_gas_limit"; 189 | if !obj.contains_key(key) { 190 | // keep default value 191 | obj.insert(key.to_string(), false.into()); 192 | } 193 | let key = "disable_base_fee"; 194 | if !obj.contains_key(key) { 195 | // keep default value 196 | obj.insert(key.to_string(), false.into()); 197 | } 198 | } 199 | 200 | let cfg_env: revm::primitives::CfgEnv = 201 | serde_json::from_value(value).map_err(serde::de::Error::custom)?; 202 | Ok(Self { inner: cfg_env }) 203 | } 204 | } 205 | 206 | // custom deserialize impl to not break existing cache files 207 | #[derive(Deserialize)] 208 | struct Meta { 209 | cfg_env: CfgEnvBackwardsCompat, 210 | block_env: revm::primitives::BlockEnv, 211 | /// all the hosts used to connect to 212 | #[serde(alias = "host")] 213 | hosts: Hosts, 214 | } 215 | 216 | #[derive(Deserialize)] 217 | #[serde(untagged)] 218 | enum Hosts { 219 | Multi(BTreeSet), 220 | Single(String), 221 | } 222 | 223 | let Meta { 224 | cfg_env, 225 | block_env, 226 | hosts, 227 | } = Meta::deserialize(deserializer)?; 228 | Ok(Self { 229 | cfg_env: cfg_env.inner, 230 | block_env, 231 | hosts: match hosts { 232 | Hosts::Multi(hosts) => hosts, 233 | Hosts::Single(host) => BTreeSet::from([host]), 234 | }, 235 | }) 236 | } 237 | } 238 | 239 | /// In Memory cache containing all fetched accounts and storage slots 240 | /// and their values from RPC 241 | #[derive(Debug, Default)] 242 | pub struct MemDb { 243 | /// Account related data 244 | pub accounts: RwLock>, 245 | /// Storage related data 246 | pub storage: RwLock>, 247 | /// All retrieved block hashes 248 | pub block_hashes: RwLock>, 249 | } 250 | 251 | impl MemDb { 252 | /// Clears all data stored in this db 253 | pub fn clear(&self) { 254 | self.accounts.write().clear(); 255 | self.storage.write().clear(); 256 | self.block_hashes.write().clear(); 257 | } 258 | 259 | // Inserts the account, replacing it if it exists already 260 | pub fn do_insert_account(&self, address: B160, account: AccountInfo) { 261 | self.accounts.write().insert(address, account); 262 | } 263 | 264 | /// The implementation of [DatabaseCommit::commit()] 265 | pub fn do_commit(&self, changes: Map) { 266 | let mut storage = self.storage.write(); 267 | let mut accounts = self.accounts.write(); 268 | for (add, mut acc) in changes { 269 | if acc.is_empty() || acc.is_selfdestructed() { 270 | accounts.remove(&add); 271 | storage.remove(&add); 272 | } else { 273 | // insert account 274 | if let Some(code_hash) = acc 275 | .info 276 | .code 277 | .as_ref() 278 | .filter(|code| !code.is_empty()) 279 | .map(|code| code.hash_slow()) 280 | { 281 | acc.info.code_hash = code_hash; 282 | } else if acc.info.code_hash.is_zero() { 283 | acc.info.code_hash = KECCAK_EMPTY; 284 | } 285 | accounts.insert(add, acc.info); 286 | 287 | let acc_storage = storage.entry(add).or_default(); 288 | if acc.status.contains(AccountStatus::Created) { 289 | acc_storage.clear(); 290 | } 291 | for (index, value) in acc.storage { 292 | if value.present_value() == U256::from(0) { 293 | acc_storage.remove(&index); 294 | } else { 295 | acc_storage.insert(index, value.present_value()); 296 | } 297 | } 298 | if acc_storage.is_empty() { 299 | storage.remove(&add); 300 | } 301 | } 302 | } 303 | } 304 | } 305 | 306 | impl Clone for MemDb { 307 | fn clone(&self) -> Self { 308 | Self { 309 | storage: RwLock::new(self.storage.read().clone()), 310 | accounts: RwLock::new(self.accounts.read().clone()), 311 | block_hashes: RwLock::new(self.block_hashes.read().clone()), 312 | } 313 | } 314 | } 315 | 316 | impl DatabaseCommit for MemDb { 317 | fn commit(&mut self, changes: Map) { 318 | self.do_commit(changes) 319 | } 320 | } 321 | 322 | /// A [BlockCacheDB] that stores the cached content in a json file 323 | #[derive(Debug)] 324 | pub struct JsonBlockCacheDB { 325 | /// Where this cache file is stored. 326 | /// 327 | /// If this is a [None] then caching is disabled 328 | cache_path: Option, 329 | /// Object that's stored in a json file 330 | data: JsonBlockCacheData, 331 | } 332 | 333 | impl JsonBlockCacheDB { 334 | /// Creates a new instance. 335 | fn new(meta: Arc>, cache_path: Option) -> Self { 336 | Self { 337 | cache_path, 338 | data: JsonBlockCacheData { 339 | meta, 340 | data: Arc::new(Default::default()), 341 | }, 342 | } 343 | } 344 | 345 | /// Loads the contents of the diskmap file and returns the read object 346 | /// 347 | /// # Errors 348 | /// This will fail if 349 | /// - the `path` does not exist 350 | /// - the format does not match [JsonBlockCacheData] 351 | pub fn load(path: impl Into) -> eyre::Result { 352 | let path = path.into(); 353 | trace!(target : "cache", ?path, "reading json cache"); 354 | let contents = std::fs::read_to_string(&path).map_err(|err| { 355 | warn!(?err, ?path, "Failed to read cache file"); 356 | err 357 | })?; 358 | let data = serde_json::from_str(&contents).map_err(|err| { 359 | warn!(target : "cache", ?err, ?path, "Failed to deserialize cache data"); 360 | err 361 | })?; 362 | Ok(Self { 363 | cache_path: Some(path), 364 | data, 365 | }) 366 | } 367 | 368 | /// Returns the [MemDb] it holds access to 369 | pub fn db(&self) -> &Arc { 370 | &self.data.data 371 | } 372 | 373 | /// Metadata stored alongside the data 374 | pub fn meta(&self) -> &Arc> { 375 | &self.data.meta 376 | } 377 | 378 | /// Returns `true` if this is a transient cache and nothing will be flushed 379 | pub fn is_transient(&self) -> bool { 380 | self.cache_path.is_none() 381 | } 382 | 383 | /// Flushes the DB to disk if caching is enabled. 384 | #[tracing::instrument(level = "warn", skip_all, fields(path = ?self.cache_path))] 385 | pub fn flush(&self) { 386 | let Some(path) = &self.cache_path else { return }; 387 | trace!(target: "cache", "saving json cache"); 388 | 389 | if let Some(parent) = path.parent() { 390 | let _ = fs::create_dir_all(parent); 391 | } 392 | 393 | let file = match fs::File::create(path) { 394 | Ok(file) => file, 395 | Err(e) => return warn!(target: "cache", %e, "Failed to open json cache for writing"), 396 | }; 397 | 398 | let mut writer = BufWriter::new(file); 399 | if let Err(e) = serde_json::to_writer(&mut writer, &self.data) { 400 | return warn!(target: "cache", %e, "Failed to write to json cache"); 401 | } 402 | if let Err(e) = writer.flush() { 403 | return warn!(target: "cache", %e, "Failed to flush to json cache"); 404 | } 405 | 406 | trace!(target: "cache", "saved json cache"); 407 | } 408 | } 409 | 410 | /// The Data the [JsonBlockCacheDB] can read and flush 411 | /// 412 | /// This will be deserialized in a JSON object with the keys: 413 | /// `["meta", "accounts", "storage", "block_hashes"]` 414 | #[derive(Debug)] 415 | pub struct JsonBlockCacheData { 416 | pub meta: Arc>, 417 | pub data: Arc, 418 | } 419 | 420 | impl Serialize for JsonBlockCacheData { 421 | fn serialize(&self, serializer: S) -> Result 422 | where 423 | S: Serializer, 424 | { 425 | let mut map = serializer.serialize_map(Some(4))?; 426 | 427 | let meta = self.meta.read(); 428 | map.serialize_entry("meta", &*meta)?; 429 | drop(meta); 430 | 431 | let accounts = self.data.accounts.read(); 432 | map.serialize_entry("accounts", &*accounts)?; 433 | drop(accounts); 434 | 435 | let storage = self.data.storage.read(); 436 | map.serialize_entry("storage", &*storage)?; 437 | drop(storage); 438 | 439 | let block_hashes = self.data.block_hashes.read(); 440 | map.serialize_entry("block_hashes", &*block_hashes)?; 441 | drop(block_hashes); 442 | 443 | map.end() 444 | } 445 | } 446 | 447 | impl<'de> Deserialize<'de> for JsonBlockCacheData { 448 | fn deserialize(deserializer: D) -> Result 449 | where 450 | D: Deserializer<'de>, 451 | { 452 | #[derive(Deserialize)] 453 | struct Data { 454 | meta: BlockchainDbMeta, 455 | #[serde(flatten)] 456 | data: StateSnapshot, 457 | } 458 | 459 | let Data { 460 | meta, 461 | data: 462 | StateSnapshot { 463 | accounts, 464 | storage, 465 | block_hashes, 466 | }, 467 | } = Data::deserialize(deserializer)?; 468 | 469 | Ok(JsonBlockCacheData { 470 | meta: Arc::new(RwLock::new(meta)), 471 | data: Arc::new(MemDb { 472 | accounts: RwLock::new(accounts), 473 | storage: RwLock::new(storage), 474 | block_hashes: RwLock::new(block_hashes), 475 | }), 476 | }) 477 | } 478 | } 479 | 480 | /// A type that flushes a `JsonBlockCacheDB` on drop 481 | /// 482 | /// This type intentionally does not implement `Clone` since it's intended that there's only once 483 | /// instance that will flush the cache. 484 | #[derive(Debug)] 485 | pub struct FlushJsonBlockCacheDB(pub Arc); 486 | 487 | impl Drop for FlushJsonBlockCacheDB { 488 | fn drop(&mut self) { 489 | trace!(target: "fork::cache", "flushing cache"); 490 | self.0.flush(); 491 | trace!(target: "fork::cache", "flushed cache"); 492 | } 493 | } 494 | 495 | #[cfg(test)] 496 | mod tests { 497 | use super::*; 498 | 499 | #[test] 500 | fn can_deserialize_cache() { 501 | let s = r#"{ 502 | "meta": { 503 | "cfg_env": { 504 | "chain_id": "0x539", 505 | "spec_id": "LATEST", 506 | "perf_all_precompiles_have_balance": false, 507 | "disable_coinbase_tip": false, 508 | "perf_analyse_created_bytecodes": "Analyse", 509 | "limit_contract_code_size": 18446744073709551615, 510 | "memory_limit": 4294967295 511 | }, 512 | "block_env": { 513 | "number": "0xed3ddf", 514 | "coinbase": "0x0000000000000000000000000000000000000000", 515 | "timestamp": "0x6324bc3f", 516 | "difficulty": "0x0", 517 | "basefee": "0x2e5fda223", 518 | "gas_limit": "0x1c9c380" 519 | }, 520 | "hosts": [ 521 | "eth-mainnet.alchemyapi.io" 522 | ] 523 | }, 524 | "accounts": { 525 | "0xb8ffc3cd6e7cf5a098a1c92f48009765b24088dc": { 526 | "balance": "0x0", 527 | "nonce": 10, 528 | "code_hash": "0x3ac64c95eedf82e5d821696a12daac0e1b22c8ee18a9fd688b00cfaf14550aad", 529 | "code": { 530 | "bytecode": "0x60806040526004361061006c5763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416634555d5c9811461012b5780634558850c1461015257806348a0c8dd146101965780635c60da1b146101bf57806386070cfe146101d4575b6127107f665fd576fbbe6f247aff98f5c94a561e3f71ec2d3c988d56f12d342396c50cea6000825a10156100e15760003411361583541616156100dc576040513381523460208201527f15eeaa57c7bd188c1388020bcadc2c436ec60d647d36ef5b9eb3c742217ddee1604082a1005b600080fd5b6100e96101e9565b9050610126816000368080601f0160208091040260200160405190810160405280939291908181526020018383808284375061026c945050505050565b505050005b34801561013757600080fd5b506101406102ad565b60408051918252519081900360200190f35b34801561015e57600080fd5b5061016d6004356024356102b2565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b3480156101a257600080fd5b506101ab6102e2565b604080519115158252519081900360200190f35b3480156101cb57600080fd5b5061016d6101e9565b3480156101e057600080fd5b50610140610312565b7f3b4bf6bf3ad5000ecf0f989d5befde585c6860fea3e574a4fab4c49d1c177d9c6000527fc67454ed56db7ff90a4bb32fc9a8de1ab3174b221e5fecea22b7503a3111791f6020527f8e2ed18767e9c33b25344c240cdf92034fae56be99e2c07f3d9946d949ffede45473ffffffffffffffffffffffffffffffffffffffff1690565b600061027783610318565b151561028257600080fd5b612710905060008083516020850186855a03f43d604051816000823e8280156102a9578282f35b8282fd5b600290565b600060208181529281526040808220909352908152205473ffffffffffffffffffffffffffffffffffffffff1681565b600061030d7f665fd576fbbe6f247aff98f5c94a561e3f71ec2d3c988d56f12d342396c50cea610352565b905090565b60015481565b60008073ffffffffffffffffffffffffffffffffffffffff83161515610341576000915061034c565b823b90506000811191505b50919050565b54905600a165627a7a72305820968d404e148c1ec7bb58c8df6cbdcaad4978b93a804e00a1f0e97a5e789eacd40029000000000000000000000000000000000000000000000000000000000000000000", 531 | "hash": "0x3ac64c95eedf82e5d821696a12daac0e1b22c8ee18a9fd688b00cfaf14550aad", 532 | "state": { 533 | "Checked": { 534 | "len": 898 535 | } 536 | } 537 | } 538 | } 539 | }, 540 | "storage": { 541 | "0xa354f35829ae975e850e23e9615b11da1b3dc4de": { 542 | "0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e564": "0x5553444320795661756c74000000000000000000000000000000000000000000", 543 | "0x10": "0x37fd60ff8346", 544 | "0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563": "0xb", 545 | "0x6": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", 546 | "0x5": "0x36ff5b93162e", 547 | "0x14": "0x29d635a8e000", 548 | "0x11": "0x63224c73", 549 | "0x2": "0x6" 550 | } 551 | }, 552 | "block_hashes": { 553 | "0xed3deb": "0xbf7be3174b261ea3c377b6aba4a1e05d5fae7eee7aab5691087c20cf353e9877", 554 | "0xed3de9": "0xba1c3648e0aee193e7d00dffe4e9a5e420016b4880455641085a4731c1d32eef", 555 | "0xed3de8": "0x61d1491c03a9295fb13395cca18b17b4fa5c64c6b8e56ee9cc0a70c3f6cf9855", 556 | "0xed3de7": "0xb54560b5baeccd18350d56a3bee4035432294dc9d2b7e02f157813e1dee3a0be", 557 | "0xed3dea": "0x816f124480b9661e1631c6ec9ee39350bda79f0cbfc911f925838d88e3d02e4b" 558 | } 559 | }"#; 560 | 561 | let cache: JsonBlockCacheData = serde_json::from_str(s).unwrap(); 562 | assert_eq!(cache.data.accounts.read().len(), 1); 563 | assert_eq!(cache.data.storage.read().len(), 1); 564 | assert_eq!(cache.data.block_hashes.read().len(), 5); 565 | 566 | let _s = serde_json::to_string(&cache).unwrap(); 567 | } 568 | } 569 | -------------------------------------------------------------------------------- /src/evm/executor/fork/backend.rs: -------------------------------------------------------------------------------- 1 | //! Smart caching and deduplication of requests when using a forking provider 2 | use crate::constants::NON_ARCHIVE_NODE_WARNING; 3 | use crate::evm::{ 4 | executor::{ 5 | backend::error::{DatabaseError, DatabaseResult}, 6 | fork::cache::{BlockchainDb, FlushJsonBlockCacheDB}, 7 | }, 8 | utils::{b160_to_h160, b256_to_h256, h160_to_b160, h256_to_b256, ru256_to_u256, u256_to_ru256}, 9 | }; 10 | use ethers::{ 11 | core::abi::ethereum_types::BigEndianHash, 12 | providers::Middleware, 13 | types::{Address, Block, BlockId, Bytes, Transaction, H256, U256}, 14 | utils::keccak256, 15 | }; 16 | use futures::{ 17 | channel::mpsc::{channel, Receiver, Sender}, 18 | stream::Stream, 19 | task::{Context, Poll}, 20 | Future, FutureExt, 21 | }; 22 | use revm::{ 23 | db::DatabaseRef, 24 | primitives::{AccountInfo, Bytecode, B160, B256, KECCAK_EMPTY, U256 as rU256}, 25 | }; 26 | use std::{ 27 | collections::{hash_map::Entry, HashMap, VecDeque}, 28 | pin::Pin, 29 | sync::{ 30 | mpsc::{channel as oneshot_channel, Sender as OneshotSender}, 31 | Arc, 32 | }, 33 | }; 34 | use tracing::{error, trace, warn}; 35 | 36 | // Various future/request type aliases 37 | 38 | type AccountFuture = 39 | Pin, Address)> + Send>>; 40 | type StorageFuture = Pin, Address, U256)> + Send>>; 41 | type BlockHashFuture = Pin, u64)> + Send>>; 42 | type FullBlockFuture = Pin< 43 | Box< 44 | dyn Future< 45 | Output = ( 46 | FullBlockSender, 47 | Result>, Err>, 48 | BlockId, 49 | ), 50 | > + Send, 51 | >, 52 | >; 53 | type TransactionFuture = Pin< 54 | Box, Err>, H256)> + Send>, 55 | >; 56 | 57 | type AccountInfoSender = OneshotSender>; 58 | type StorageSender = OneshotSender>; 59 | type BlockHashSender = OneshotSender>; 60 | type FullBlockSender = OneshotSender>>; 61 | type TransactionSender = OneshotSender>; 62 | 63 | /// Request variants that are executed by the provider 64 | enum ProviderRequest { 65 | Account(AccountFuture), 66 | Storage(StorageFuture), 67 | BlockHash(BlockHashFuture), 68 | FullBlock(FullBlockFuture), 69 | Transaction(TransactionFuture), 70 | } 71 | 72 | /// The Request type the Backend listens for 73 | #[derive(Debug)] 74 | enum BackendRequest { 75 | /// Fetch the account info 76 | Basic(Address, AccountInfoSender), 77 | /// Fetch a storage slot 78 | Storage(Address, U256, StorageSender), 79 | /// Fetch a block hash 80 | BlockHash(u64, BlockHashSender), 81 | /// Fetch an entire block with transactions 82 | FullBlock(BlockId, FullBlockSender), 83 | /// Fetch a transaction 84 | Transaction(H256, TransactionSender), 85 | /// Sets the pinned block to fetch data from 86 | SetPinnedBlock(BlockId), 87 | } 88 | 89 | /// Handles an internal provider and listens for requests. 90 | /// 91 | /// This handler will remain active as long as it is reachable (request channel still open) and 92 | /// requests are in progress. 93 | #[must_use = "BackendHandler does nothing unless polled."] 94 | pub struct BackendHandler { 95 | provider: M, 96 | /// Stores all the data. 97 | db: BlockchainDb, 98 | /// Requests currently in progress 99 | pending_requests: Vec>, 100 | /// Listeners that wait for a `get_account` related response 101 | account_requests: HashMap>, 102 | /// Listeners that wait for a `get_storage_at` response 103 | storage_requests: HashMap<(Address, U256), Vec>, 104 | /// Listeners that wait for a `get_block` response 105 | block_requests: HashMap>, 106 | /// Incoming commands. 107 | incoming: Receiver, 108 | /// unprocessed queued requests 109 | queued_requests: VecDeque, 110 | /// The block to fetch data from. 111 | // This is an `Option` so that we can have less code churn in the functions below 112 | block_id: Option, 113 | } 114 | 115 | impl BackendHandler 116 | where 117 | M: Middleware + Clone + 'static, 118 | { 119 | fn new( 120 | provider: M, 121 | db: BlockchainDb, 122 | rx: Receiver, 123 | block_id: Option, 124 | ) -> Self { 125 | Self { 126 | provider, 127 | db, 128 | pending_requests: Default::default(), 129 | account_requests: Default::default(), 130 | storage_requests: Default::default(), 131 | block_requests: Default::default(), 132 | queued_requests: Default::default(), 133 | incoming: rx, 134 | block_id, 135 | } 136 | } 137 | 138 | /// handle the request in queue in the future. 139 | /// 140 | /// We always check: 141 | /// 1. if the requested value is already stored in the cache, then answer the sender 142 | /// 2. otherwise, fetch it via the provider but check if a request for that value is already in 143 | /// progress (e.g. another Sender just requested the same account) 144 | fn on_request(&mut self, req: BackendRequest) { 145 | match req { 146 | BackendRequest::Basic(addr, sender) => { 147 | trace!(target: "backendhandler", "received request basic address={:?}", addr); 148 | let acc = self.db.accounts().read().get(&h160_to_b160(addr)).cloned(); 149 | if let Some(basic) = acc { 150 | let _ = sender.send(Ok(basic)); 151 | } else { 152 | self.request_account(addr, sender); 153 | } 154 | } 155 | BackendRequest::BlockHash(number, sender) => { 156 | let hash = self 157 | .db 158 | .block_hashes() 159 | .read() 160 | .get(&rU256::from(number)) 161 | .cloned(); 162 | if let Some(hash) = hash { 163 | let _ = sender.send(Ok(hash.into())); 164 | } else { 165 | self.request_hash(number, sender); 166 | } 167 | } 168 | BackendRequest::FullBlock(number, sender) => { 169 | self.request_full_block(number, sender); 170 | } 171 | BackendRequest::Transaction(tx, sender) => { 172 | self.request_transaction(tx, sender); 173 | } 174 | BackendRequest::Storage(addr, idx, sender) => { 175 | // account is already stored in the cache 176 | let value = self 177 | .db 178 | .storage() 179 | .read() 180 | .get(&h160_to_b160(addr)) 181 | .and_then(|acc| acc.get(&u256_to_ru256(idx)).copied()); 182 | if let Some(value) = value { 183 | let _ = sender.send(Ok(ru256_to_u256(value))); 184 | } else { 185 | // account present but not storage -> fetch storage 186 | self.request_account_storage(addr, idx, sender); 187 | } 188 | } 189 | BackendRequest::SetPinnedBlock(block_id) => { 190 | self.block_id = Some(block_id); 191 | } 192 | } 193 | } 194 | 195 | /// process a request for account's storage 196 | fn request_account_storage(&mut self, address: Address, idx: U256, listener: StorageSender) { 197 | match self.storage_requests.entry((address, idx)) { 198 | Entry::Occupied(mut entry) => { 199 | entry.get_mut().push(listener); 200 | } 201 | Entry::Vacant(entry) => { 202 | trace!(target: "backendhandler", "preparing storage request, address={:?}, idx={}", address, idx); 203 | entry.insert(vec![listener]); 204 | let provider = self.provider.clone(); 205 | let block_id = self.block_id; 206 | let fut = Box::pin(async move { 207 | // serialize & deserialize back to U256 208 | let idx_req = H256::from_uint(&idx); 209 | let storage = provider.get_storage_at(address, idx_req, block_id).await; 210 | let storage = storage.map(|storage| storage.into_uint()); 211 | (storage, address, idx) 212 | }); 213 | self.pending_requests.push(ProviderRequest::Storage(fut)); 214 | } 215 | } 216 | } 217 | 218 | /// returns the future that fetches the account data 219 | fn get_account_req(&self, address: Address) -> ProviderRequest { 220 | trace!(target: "backendhandler", "preparing account request, address={:?}", address); 221 | let provider = self.provider.clone(); 222 | let block_id = self.block_id; 223 | let fut = Box::pin(async move { 224 | let balance = provider.get_balance(address, block_id); 225 | let nonce = provider.get_transaction_count(address, block_id); 226 | let code = provider.get_code(address, block_id); 227 | let resp = tokio::try_join!(balance, nonce, code); 228 | (resp, address) 229 | }); 230 | ProviderRequest::Account(fut) 231 | } 232 | 233 | /// process a request for an account 234 | fn request_account(&mut self, address: Address, listener: AccountInfoSender) { 235 | match self.account_requests.entry(address) { 236 | Entry::Occupied(mut entry) => { 237 | entry.get_mut().push(listener); 238 | } 239 | Entry::Vacant(entry) => { 240 | entry.insert(vec![listener]); 241 | self.pending_requests.push(self.get_account_req(address)); 242 | } 243 | } 244 | } 245 | 246 | /// process a request for an entire block 247 | fn request_full_block(&mut self, number: BlockId, sender: FullBlockSender) { 248 | let provider = self.provider.clone(); 249 | let fut = Box::pin(async move { 250 | let block = provider.get_block_with_txs(number).await; 251 | (sender, block, number) 252 | }); 253 | 254 | self.pending_requests.push(ProviderRequest::FullBlock(fut)); 255 | } 256 | 257 | /// process a request for a transactions 258 | fn request_transaction(&mut self, tx: H256, sender: TransactionSender) { 259 | let provider = self.provider.clone(); 260 | let fut = Box::pin(async move { 261 | let block = provider.get_transaction(tx).await; 262 | (sender, block, tx) 263 | }); 264 | 265 | self.pending_requests 266 | .push(ProviderRequest::Transaction(fut)); 267 | } 268 | 269 | /// process a request for a block hash 270 | fn request_hash(&mut self, number: u64, listener: BlockHashSender) { 271 | match self.block_requests.entry(number) { 272 | Entry::Occupied(mut entry) => { 273 | entry.get_mut().push(listener); 274 | } 275 | Entry::Vacant(entry) => { 276 | trace!(target: "backendhandler", "preparing block hash request, number={}", number); 277 | entry.insert(vec![listener]); 278 | let provider = self.provider.clone(); 279 | let fut = Box::pin(async move { 280 | let block = provider.get_block(number).await; 281 | 282 | let block_hash = match block { 283 | Ok(Some(block)) => Ok(block 284 | .hash 285 | .expect("empty block hash on mined block, this should never happen")), 286 | Ok(None) => { 287 | warn!(target: "backendhandler", ?number, "block not found"); 288 | // if no block was returned then the block does not exist, in which case 289 | // we return empty hash 290 | Ok(b256_to_h256(KECCAK_EMPTY)) 291 | } 292 | Err(err) => { 293 | error!(target: "backendhandler", ?err, ?number, "failed to get block"); 294 | Err(err) 295 | } 296 | }; 297 | (block_hash, number) 298 | }); 299 | self.pending_requests.push(ProviderRequest::BlockHash(fut)); 300 | } 301 | } 302 | } 303 | } 304 | 305 | impl Future for BackendHandler 306 | where 307 | M: Middleware + Clone + Unpin + 'static, 308 | { 309 | type Output = (); 310 | 311 | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { 312 | let pin = self.get_mut(); 313 | loop { 314 | // Drain queued requests first. 315 | while let Some(req) = pin.queued_requests.pop_front() { 316 | pin.on_request(req) 317 | } 318 | 319 | // receive new requests to delegate to the underlying provider 320 | loop { 321 | match Pin::new(&mut pin.incoming).poll_next(cx) { 322 | Poll::Ready(Some(req)) => { 323 | pin.queued_requests.push_back(req); 324 | } 325 | Poll::Ready(None) => { 326 | trace!(target: "backendhandler", "last sender dropped, ready to drop (&flush cache)"); 327 | return Poll::Ready(()); 328 | } 329 | Poll::Pending => break, 330 | } 331 | } 332 | 333 | // poll all requests in progress 334 | for n in (0..pin.pending_requests.len()).rev() { 335 | let mut request = pin.pending_requests.swap_remove(n); 336 | match &mut request { 337 | ProviderRequest::Account(fut) => { 338 | if let Poll::Ready((resp, addr)) = fut.poll_unpin(cx) { 339 | // get the response 340 | let (balance, nonce, code) = match resp { 341 | Ok(res) => res, 342 | Err(err) => { 343 | let err = Arc::new(eyre::Error::new(err)); 344 | if let Some(listeners) = pin.account_requests.remove(&addr) { 345 | listeners.into_iter().for_each(|l| { 346 | let _ = l.send(Err(DatabaseError::GetAccount( 347 | addr, 348 | Arc::clone(&err), 349 | ))); 350 | }) 351 | } 352 | continue; 353 | } 354 | }; 355 | 356 | // convert it to revm-style types 357 | let (code, code_hash) = if !code.0.is_empty() { 358 | (Some(code.0.clone()), keccak256(&code).into()) 359 | } else { 360 | (Some(bytes::Bytes::default()), KECCAK_EMPTY) 361 | }; 362 | 363 | // update the cache 364 | let acc = AccountInfo { 365 | nonce: nonce.as_u64(), 366 | balance: balance.into(), 367 | code: code.map(|bytes| Bytecode::new_raw(bytes).to_checked()), 368 | code_hash, 369 | }; 370 | pin.db.accounts().write().insert(addr.into(), acc.clone()); 371 | 372 | // notify all listeners 373 | if let Some(listeners) = pin.account_requests.remove(&addr) { 374 | listeners.into_iter().for_each(|l| { 375 | let _ = l.send(Ok(acc.clone())); 376 | }) 377 | } 378 | continue; 379 | } 380 | } 381 | ProviderRequest::Storage(fut) => { 382 | if let Poll::Ready((resp, addr, idx)) = fut.poll_unpin(cx) { 383 | let value = match resp { 384 | Ok(value) => value, 385 | Err(err) => { 386 | // notify all listeners 387 | let err = Arc::new(eyre::Error::new(err)); 388 | if let Some(listeners) = 389 | pin.storage_requests.remove(&(addr, idx)) 390 | { 391 | listeners.into_iter().for_each(|l| { 392 | let _ = l.send(Err(DatabaseError::GetStorage( 393 | addr, 394 | idx, 395 | Arc::clone(&err), 396 | ))); 397 | }) 398 | } 399 | continue; 400 | } 401 | }; 402 | 403 | // update the cache 404 | pin.db 405 | .storage() 406 | .write() 407 | .entry(addr.into()) 408 | .or_default() 409 | .insert(idx.into(), value.into()); 410 | 411 | // notify all listeners 412 | if let Some(listeners) = pin.storage_requests.remove(&(addr, idx)) { 413 | listeners.into_iter().for_each(|l| { 414 | let _ = l.send(Ok(value)); 415 | }) 416 | } 417 | continue; 418 | } 419 | } 420 | ProviderRequest::BlockHash(fut) => { 421 | if let Poll::Ready((block_hash, number)) = fut.poll_unpin(cx) { 422 | let value = match block_hash { 423 | Ok(value) => value, 424 | Err(err) => { 425 | let err = Arc::new(eyre::Error::new(err)); 426 | // notify all listeners 427 | if let Some(listeners) = pin.block_requests.remove(&number) { 428 | listeners.into_iter().for_each(|l| { 429 | let _ = l.send(Err(DatabaseError::GetBlockHash( 430 | number, 431 | Arc::clone(&err), 432 | ))); 433 | }) 434 | } 435 | continue; 436 | } 437 | }; 438 | 439 | // update the cache 440 | pin.db 441 | .block_hashes() 442 | .write() 443 | .insert(rU256::from(number), value.into()); 444 | 445 | // notify all listeners 446 | if let Some(listeners) = pin.block_requests.remove(&number) { 447 | listeners.into_iter().for_each(|l| { 448 | let _ = l.send(Ok(value)); 449 | }) 450 | } 451 | continue; 452 | } 453 | } 454 | ProviderRequest::FullBlock(fut) => { 455 | if let Poll::Ready((sender, resp, number)) = fut.poll_unpin(cx) { 456 | let msg = match resp { 457 | Ok(Some(block)) => Ok(block), 458 | Ok(None) => Err(DatabaseError::BlockNotFound(number)), 459 | Err(err) => { 460 | let err = Arc::new(eyre::Error::new(err)); 461 | Err(DatabaseError::GetFullBlock(number, err)) 462 | } 463 | }; 464 | let _ = sender.send(msg); 465 | continue; 466 | } 467 | } 468 | ProviderRequest::Transaction(fut) => { 469 | if let Poll::Ready((sender, tx, tx_hash)) = fut.poll_unpin(cx) { 470 | let msg = match tx { 471 | Ok(Some(tx)) => Ok(tx), 472 | Ok(None) => Err(DatabaseError::TransactionNotFound(tx_hash)), 473 | Err(err) => { 474 | let err = Arc::new(eyre::Error::new(err)); 475 | Err(DatabaseError::GetTransaction(tx_hash, err)) 476 | } 477 | }; 478 | let _ = sender.send(msg); 479 | continue; 480 | } 481 | } 482 | } 483 | // not ready, insert and poll again 484 | pin.pending_requests.push(request); 485 | } 486 | 487 | // If no new requests have been queued, break to 488 | // be polled again later. 489 | if pin.queued_requests.is_empty() { 490 | return Poll::Pending; 491 | } 492 | } 493 | } 494 | } 495 | 496 | /// A cloneable backend type that shares access to the backend data with all its clones. 497 | /// 498 | /// This backend type is connected to the `BackendHandler` via a mpsc channel. The `BackendHandler` 499 | /// is spawned on a tokio task and listens for incoming commands on the receiver half of the 500 | /// channel. A `SharedBackend` holds a sender for that channel, which is `Clone`, so there can be 501 | /// multiple `SharedBackend`s communicating with the same `BackendHandler`, hence this `Backend` 502 | /// type is thread safe. 503 | /// 504 | /// All `Backend` trait functions are delegated as a `BackendRequest` via the channel to the 505 | /// `BackendHandler`. All `BackendRequest` variants include a sender half of an additional channel 506 | /// that is used by the `BackendHandler` to send the result of an executed `BackendRequest` back to 507 | /// `SharedBackend`. 508 | /// 509 | /// The `BackendHandler` holds an ethers `Provider` to look up missing accounts or storage slots 510 | /// from remote (e.g. infura). It detects duplicate requests from multiple `SharedBackend`s and 511 | /// bundles them together, so that always only one provider request is executed. For example, there 512 | /// are two `SharedBackend`s, `A` and `B`, both request the basic account info of account 513 | /// `0xasd9sa7d...` at the same time. After the `BackendHandler` receives the request from `A`, it 514 | /// sends a new provider request to the provider's endpoint, then it reads the identical request 515 | /// from `B` and simply adds it as an additional listener for the request already in progress, 516 | /// instead of sending another one. So that after the provider returns the response all listeners 517 | /// (`A` and `B`) get notified. 518 | // **Note**: the implementation makes use of [tokio::task::block_in_place()] when interacting with 519 | // the underlying [BackendHandler] which runs on a separate spawned tokio task. 520 | // [tokio::task::block_in_place()] 521 | // > Runs the provided blocking function on the current thread without blocking the executor. 522 | // This prevents issues (hangs) we ran into were the [SharedBackend] itself is called from a spawned 523 | // task. 524 | #[derive(Debug, Clone)] 525 | pub struct SharedBackend { 526 | /// channel used for sending commands related to database operations 527 | backend: Sender, 528 | /// Ensures that the underlying cache gets flushed once the last `SharedBackend` is dropped. 529 | /// 530 | /// There is only one instance of the type, so as soon as the last `SharedBackend` is deleted, 531 | /// `FlushJsonBlockCacheDB` is also deleted and the cache is flushed. 532 | cache: Arc, 533 | } 534 | 535 | impl SharedBackend { 536 | /// _Spawns_ a new `BackendHandler` on a `tokio::task` that listens for requests from any 537 | /// `SharedBackend`. Missing values get inserted in the `db`. 538 | /// 539 | /// The spawned `BackendHandler` finishes once the last `SharedBackend` connected to it is 540 | /// dropped. 541 | /// 542 | /// NOTE: this should be called with `Arc` 543 | pub async fn spawn_backend(provider: M, db: BlockchainDb, pin_block: Option) -> Self 544 | where 545 | M: Middleware + Unpin + 'static + Clone, 546 | { 547 | let (shared, handler) = Self::new(provider, db, pin_block); 548 | // spawn the provider handler to a task 549 | trace!(target: "backendhandler", "spawning Backendhandler task"); 550 | tokio::spawn(handler); 551 | shared 552 | } 553 | 554 | /// Same as `Self::spawn_backend` but spawns the `BackendHandler` on a separate `std::thread` in 555 | /// its own `tokio::Runtime` 556 | pub fn spawn_backend_thread( 557 | provider: M, 558 | db: BlockchainDb, 559 | pin_block: Option, 560 | ) -> Self 561 | where 562 | M: Middleware + Unpin + 'static + Clone, 563 | { 564 | let (shared, handler) = Self::new(provider, db, pin_block); 565 | 566 | // spawn a light-weight thread with a thread-local async runtime just for 567 | // sending and receiving data from the remote client 568 | std::thread::Builder::new() 569 | .name("fork-backend".into()) 570 | .spawn(move || { 571 | let rt = tokio::runtime::Builder::new_current_thread() 572 | .enable_all() 573 | .build() 574 | .expect("failed to build tokio runtime"); 575 | 576 | rt.block_on(handler); 577 | }) 578 | .expect("failed to spawn thread"); 579 | trace!(target: "backendhandler", "spawned Backendhandler thread"); 580 | 581 | shared 582 | } 583 | 584 | /// Returns a new `SharedBackend` and the `BackendHandler` 585 | pub fn new( 586 | provider: M, 587 | db: BlockchainDb, 588 | pin_block: Option, 589 | ) -> (Self, BackendHandler) 590 | where 591 | M: Middleware + Unpin + 'static + Clone, 592 | { 593 | let (backend, backend_rx) = channel(1); 594 | let cache = Arc::new(FlushJsonBlockCacheDB(Arc::clone(db.cache()))); 595 | let handler = BackendHandler::new(provider, db, backend_rx, pin_block); 596 | (Self { backend, cache }, handler) 597 | } 598 | 599 | /// Updates the pinned block to fetch data from 600 | pub fn set_pinned_block(&self, block: impl Into) -> eyre::Result<()> { 601 | let req = BackendRequest::SetPinnedBlock(block.into()); 602 | self.backend 603 | .clone() 604 | .try_send(req) 605 | .map_err(|e| eyre::eyre!("{:?}", e)) 606 | } 607 | 608 | /// Returns the full block for the given block identifier 609 | pub fn get_full_block(&self, block: impl Into) -> DatabaseResult> { 610 | tokio::task::block_in_place(|| { 611 | let (sender, rx) = oneshot_channel(); 612 | let req = BackendRequest::FullBlock(block.into(), sender); 613 | self.backend.clone().try_send(req)?; 614 | rx.recv()? 615 | }) 616 | } 617 | 618 | /// Returns the transaction for the hash 619 | pub fn get_transaction(&self, tx: H256) -> DatabaseResult { 620 | tokio::task::block_in_place(|| { 621 | let (sender, rx) = oneshot_channel(); 622 | let req = BackendRequest::Transaction(tx, sender); 623 | self.backend.clone().try_send(req)?; 624 | rx.recv()? 625 | }) 626 | } 627 | 628 | fn do_get_basic(&self, address: Address) -> DatabaseResult> { 629 | tokio::task::block_in_place(|| { 630 | let (sender, rx) = oneshot_channel(); 631 | let req = BackendRequest::Basic(address, sender); 632 | self.backend.clone().try_send(req)?; 633 | rx.recv()?.map(Some) 634 | }) 635 | } 636 | 637 | fn do_get_storage(&self, address: Address, index: U256) -> DatabaseResult { 638 | tokio::task::block_in_place(|| { 639 | let (sender, rx) = oneshot_channel(); 640 | let req = BackendRequest::Storage(address, index, sender); 641 | self.backend.clone().try_send(req)?; 642 | rx.recv()? 643 | }) 644 | } 645 | 646 | fn do_get_block_hash(&self, number: u64) -> DatabaseResult { 647 | tokio::task::block_in_place(|| { 648 | let (sender, rx) = oneshot_channel(); 649 | let req = BackendRequest::BlockHash(number, sender); 650 | self.backend.clone().try_send(req)?; 651 | rx.recv()? 652 | }) 653 | } 654 | 655 | /// Flushes the DB to disk if caching is enabled 656 | pub(crate) fn flush_cache(&self) { 657 | self.cache.0.flush(); 658 | } 659 | } 660 | 661 | impl DatabaseRef for SharedBackend { 662 | type Error = DatabaseError; 663 | 664 | fn basic(&self, address: B160) -> Result, Self::Error> { 665 | trace!( target: "sharedbackend", "request basic {:?}", address); 666 | self.do_get_basic(b160_to_h160(address)).map_err(|err| { 667 | error!(target: "sharedbackend", ?err, ?address, "Failed to send/recv `basic`"); 668 | if err.is_possibly_non_archive_node_error() { 669 | error!(target: "sharedbackend", "{NON_ARCHIVE_NODE_WARNING}"); 670 | } 671 | err 672 | }) 673 | } 674 | 675 | fn code_by_hash(&self, hash: B256) -> Result { 676 | Err(DatabaseError::MissingCode(b256_to_h256(hash))) 677 | } 678 | 679 | fn storage(&self, address: B160, index: rU256) -> Result { 680 | trace!( target: "sharedbackend", "request storage {:?} at {:?}", address, index); 681 | match self.do_get_storage(b160_to_h160(address), index.into()).map_err(|err| { 682 | error!( target: "sharedbackend", ?err, ?address, ?index, "Failed to send/recv `storage`"); 683 | if err.is_possibly_non_archive_node_error() { 684 | error!(target: "sharedbackend", "{NON_ARCHIVE_NODE_WARNING}"); 685 | } 686 | err 687 | }) { 688 | Ok(val) => Ok(val.into()), 689 | Err(err) => Err(err), 690 | } 691 | } 692 | 693 | fn block_hash(&self, number: rU256) -> Result { 694 | if number > rU256::from(u64::MAX) { 695 | return Ok(KECCAK_EMPTY); 696 | } 697 | let number: U256 = number.into(); 698 | let number = number.as_u64(); 699 | trace!( target: "sharedbackend", "request block hash for number {:?}", number); 700 | match self.do_get_block_hash(number).map_err(|err| { 701 | error!(target: "sharedbackend",?err, ?number, "Failed to send/recv `block_hash`"); 702 | if err.is_possibly_non_archive_node_error() { 703 | error!(target: "sharedbackend", "{NON_ARCHIVE_NODE_WARNING}"); 704 | } 705 | err 706 | }) { 707 | Ok(val) => Ok(h256_to_b256(val)), 708 | Err(err) => Err(err), 709 | } 710 | } 711 | } 712 | -------------------------------------------------------------------------------- /Cargo.lock: -------------------------------------------------------------------------------- 1 | # This file is automatically @generated by Cargo. 2 | # It is not intended for manual editing. 3 | version = 3 4 | 5 | [[package]] 6 | name = "Inflector" 7 | version = "0.11.4" 8 | source = "registry+https://github.com/rust-lang/crates.io-index" 9 | checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3" 10 | dependencies = [ 11 | "lazy_static", 12 | "regex", 13 | ] 14 | 15 | [[package]] 16 | name = "addr2line" 17 | version = "0.21.0" 18 | source = "registry+https://github.com/rust-lang/crates.io-index" 19 | checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" 20 | dependencies = [ 21 | "gimli", 22 | ] 23 | 24 | [[package]] 25 | name = "adler" 26 | version = "1.0.2" 27 | source = "registry+https://github.com/rust-lang/crates.io-index" 28 | checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" 29 | 30 | [[package]] 31 | name = "aes" 32 | version = "0.8.3" 33 | source = "registry+https://github.com/rust-lang/crates.io-index" 34 | checksum = "ac1f845298e95f983ff1944b728ae08b8cebab80d684f0a832ed0fc74dfa27e2" 35 | dependencies = [ 36 | "cfg-if", 37 | "cipher", 38 | "cpufeatures", 39 | ] 40 | 41 | [[package]] 42 | name = "ahash" 43 | version = "0.8.6" 44 | source = "registry+https://github.com/rust-lang/crates.io-index" 45 | checksum = "91429305e9f0a25f6205c5b8e0d2db09e0708a7a6df0f42212bb56c32c8ac97a" 46 | dependencies = [ 47 | "cfg-if", 48 | "once_cell", 49 | "version_check", 50 | "zerocopy", 51 | ] 52 | 53 | [[package]] 54 | name = "aho-corasick" 55 | version = "1.1.2" 56 | source = "registry+https://github.com/rust-lang/crates.io-index" 57 | checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0" 58 | dependencies = [ 59 | "memchr", 60 | ] 61 | 62 | [[package]] 63 | name = "allocator-api2" 64 | version = "0.2.16" 65 | source = "registry+https://github.com/rust-lang/crates.io-index" 66 | checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5" 67 | 68 | [[package]] 69 | name = "anyhow" 70 | version = "1.0.75" 71 | source = "registry+https://github.com/rust-lang/crates.io-index" 72 | checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6" 73 | 74 | [[package]] 75 | name = "arrayvec" 76 | version = "0.7.4" 77 | source = "registry+https://github.com/rust-lang/crates.io-index" 78 | checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" 79 | 80 | [[package]] 81 | name = "ascii-canvas" 82 | version = "3.0.0" 83 | source = "registry+https://github.com/rust-lang/crates.io-index" 84 | checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6" 85 | dependencies = [ 86 | "term", 87 | ] 88 | 89 | [[package]] 90 | name = "async-trait" 91 | version = "0.1.74" 92 | source = "registry+https://github.com/rust-lang/crates.io-index" 93 | checksum = "a66537f1bb974b254c98ed142ff995236e81b9d0fe4db0575f46612cb15eb0f9" 94 | dependencies = [ 95 | "proc-macro2", 96 | "quote", 97 | "syn 2.0.38", 98 | ] 99 | 100 | [[package]] 101 | name = "async_io_stream" 102 | version = "0.3.3" 103 | source = "registry+https://github.com/rust-lang/crates.io-index" 104 | checksum = "b6d7b9decdf35d8908a7e3ef02f64c5e9b1695e230154c0e8de3969142d9b94c" 105 | dependencies = [ 106 | "futures", 107 | "pharos", 108 | "rustc_version", 109 | ] 110 | 111 | [[package]] 112 | name = "auto_impl" 113 | version = "1.1.0" 114 | source = "registry+https://github.com/rust-lang/crates.io-index" 115 | checksum = "fee3da8ef1276b0bee5dd1c7258010d8fffd31801447323115a25560e1327b89" 116 | dependencies = [ 117 | "proc-macro-error", 118 | "proc-macro2", 119 | "quote", 120 | "syn 1.0.109", 121 | ] 122 | 123 | [[package]] 124 | name = "autocfg" 125 | version = "1.1.0" 126 | source = "registry+https://github.com/rust-lang/crates.io-index" 127 | checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" 128 | 129 | [[package]] 130 | name = "backtrace" 131 | version = "0.3.69" 132 | source = "registry+https://github.com/rust-lang/crates.io-index" 133 | checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" 134 | dependencies = [ 135 | "addr2line", 136 | "cc", 137 | "cfg-if", 138 | "libc", 139 | "miniz_oxide", 140 | "object", 141 | "rustc-demangle", 142 | ] 143 | 144 | [[package]] 145 | name = "base16ct" 146 | version = "0.2.0" 147 | source = "registry+https://github.com/rust-lang/crates.io-index" 148 | checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" 149 | 150 | [[package]] 151 | name = "base64" 152 | version = "0.13.1" 153 | source = "registry+https://github.com/rust-lang/crates.io-index" 154 | checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" 155 | 156 | [[package]] 157 | name = "base64" 158 | version = "0.21.5" 159 | source = "registry+https://github.com/rust-lang/crates.io-index" 160 | checksum = "35636a1494ede3b646cc98f74f8e62c773a38a659ebc777a2cf26b9b74171df9" 161 | 162 | [[package]] 163 | name = "base64ct" 164 | version = "1.6.0" 165 | source = "registry+https://github.com/rust-lang/crates.io-index" 166 | checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" 167 | 168 | [[package]] 169 | name = "bech32" 170 | version = "0.9.1" 171 | source = "registry+https://github.com/rust-lang/crates.io-index" 172 | checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445" 173 | 174 | [[package]] 175 | name = "bindgen" 176 | version = "0.66.1" 177 | source = "registry+https://github.com/rust-lang/crates.io-index" 178 | checksum = "f2b84e06fc203107bfbad243f4aba2af864eb7db3b1cf46ea0a023b0b433d2a7" 179 | dependencies = [ 180 | "bitflags 2.4.1", 181 | "cexpr", 182 | "clang-sys", 183 | "lazy_static", 184 | "lazycell", 185 | "log", 186 | "peeking_take_while", 187 | "prettyplease", 188 | "proc-macro2", 189 | "quote", 190 | "regex", 191 | "rustc-hash", 192 | "shlex", 193 | "syn 2.0.38", 194 | "which", 195 | ] 196 | 197 | [[package]] 198 | name = "bit-set" 199 | version = "0.5.3" 200 | source = "registry+https://github.com/rust-lang/crates.io-index" 201 | checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1" 202 | dependencies = [ 203 | "bit-vec", 204 | ] 205 | 206 | [[package]] 207 | name = "bit-vec" 208 | version = "0.6.3" 209 | source = "registry+https://github.com/rust-lang/crates.io-index" 210 | checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" 211 | 212 | [[package]] 213 | name = "bitflags" 214 | version = "1.3.2" 215 | source = "registry+https://github.com/rust-lang/crates.io-index" 216 | checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" 217 | 218 | [[package]] 219 | name = "bitflags" 220 | version = "2.4.1" 221 | source = "registry+https://github.com/rust-lang/crates.io-index" 222 | checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07" 223 | dependencies = [ 224 | "serde", 225 | ] 226 | 227 | [[package]] 228 | name = "bitvec" 229 | version = "1.0.1" 230 | source = "registry+https://github.com/rust-lang/crates.io-index" 231 | checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c" 232 | dependencies = [ 233 | "funty", 234 | "radium", 235 | "serde", 236 | "tap", 237 | "wyz", 238 | ] 239 | 240 | [[package]] 241 | name = "block-buffer" 242 | version = "0.10.4" 243 | source = "registry+https://github.com/rust-lang/crates.io-index" 244 | checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" 245 | dependencies = [ 246 | "generic-array", 247 | ] 248 | 249 | [[package]] 250 | name = "blst" 251 | version = "0.3.11" 252 | source = "registry+https://github.com/rust-lang/crates.io-index" 253 | checksum = "c94087b935a822949d3291a9989ad2b2051ea141eda0fd4e478a75f6aa3e604b" 254 | dependencies = [ 255 | "cc", 256 | "glob", 257 | "threadpool", 258 | "zeroize", 259 | ] 260 | 261 | [[package]] 262 | name = "bs58" 263 | version = "0.5.0" 264 | source = "registry+https://github.com/rust-lang/crates.io-index" 265 | checksum = "f5353f36341f7451062466f0b755b96ac3a9547e4d7f6b70d603fc721a7d7896" 266 | dependencies = [ 267 | "sha2", 268 | "tinyvec", 269 | ] 270 | 271 | [[package]] 272 | name = "bumpalo" 273 | version = "3.14.0" 274 | source = "registry+https://github.com/rust-lang/crates.io-index" 275 | checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec" 276 | 277 | [[package]] 278 | name = "byte-slice-cast" 279 | version = "1.2.2" 280 | source = "registry+https://github.com/rust-lang/crates.io-index" 281 | checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c" 282 | 283 | [[package]] 284 | name = "byteorder" 285 | version = "1.5.0" 286 | source = "registry+https://github.com/rust-lang/crates.io-index" 287 | checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" 288 | 289 | [[package]] 290 | name = "bytes" 291 | version = "1.5.0" 292 | source = "registry+https://github.com/rust-lang/crates.io-index" 293 | checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" 294 | dependencies = [ 295 | "serde", 296 | ] 297 | 298 | [[package]] 299 | name = "bzip2" 300 | version = "0.4.4" 301 | source = "registry+https://github.com/rust-lang/crates.io-index" 302 | checksum = "bdb116a6ef3f6c3698828873ad02c3014b3c85cadb88496095628e3ef1e347f8" 303 | dependencies = [ 304 | "bzip2-sys", 305 | "libc", 306 | ] 307 | 308 | [[package]] 309 | name = "bzip2-sys" 310 | version = "0.1.11+1.0.8" 311 | source = "registry+https://github.com/rust-lang/crates.io-index" 312 | checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc" 313 | dependencies = [ 314 | "cc", 315 | "libc", 316 | "pkg-config", 317 | ] 318 | 319 | [[package]] 320 | name = "c-kzg" 321 | version = "0.1.1" 322 | source = "registry+https://github.com/rust-lang/crates.io-index" 323 | checksum = "ac926d808fb72fe09ebf471a091d6d72918876ccf0b4989766093d2d0d24a0ef" 324 | dependencies = [ 325 | "bindgen", 326 | "blst", 327 | "cc", 328 | "glob", 329 | "hex", 330 | "libc", 331 | "serde", 332 | ] 333 | 334 | [[package]] 335 | name = "camino" 336 | version = "1.1.6" 337 | source = "registry+https://github.com/rust-lang/crates.io-index" 338 | checksum = "c59e92b5a388f549b863a7bea62612c09f24c8393560709a54558a9abdfb3b9c" 339 | dependencies = [ 340 | "serde", 341 | ] 342 | 343 | [[package]] 344 | name = "cargo-platform" 345 | version = "0.1.4" 346 | source = "registry+https://github.com/rust-lang/crates.io-index" 347 | checksum = "12024c4645c97566567129c204f65d5815a8c9aecf30fcbe682b2fe034996d36" 348 | dependencies = [ 349 | "serde", 350 | ] 351 | 352 | [[package]] 353 | name = "cargo_metadata" 354 | version = "0.17.0" 355 | source = "registry+https://github.com/rust-lang/crates.io-index" 356 | checksum = "e7daec1a2a2129eeba1644b220b4647ec537b0b5d4bfd6876fcc5a540056b592" 357 | dependencies = [ 358 | "camino", 359 | "cargo-platform", 360 | "semver", 361 | "serde", 362 | "serde_json", 363 | "thiserror", 364 | ] 365 | 366 | [[package]] 367 | name = "cc" 368 | version = "1.0.83" 369 | source = "registry+https://github.com/rust-lang/crates.io-index" 370 | checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" 371 | dependencies = [ 372 | "jobserver", 373 | "libc", 374 | ] 375 | 376 | [[package]] 377 | name = "cexpr" 378 | version = "0.6.0" 379 | source = "registry+https://github.com/rust-lang/crates.io-index" 380 | checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" 381 | dependencies = [ 382 | "nom", 383 | ] 384 | 385 | [[package]] 386 | name = "cfg-if" 387 | version = "1.0.0" 388 | source = "registry+https://github.com/rust-lang/crates.io-index" 389 | checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" 390 | 391 | [[package]] 392 | name = "chrono" 393 | version = "0.4.31" 394 | source = "registry+https://github.com/rust-lang/crates.io-index" 395 | checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38" 396 | dependencies = [ 397 | "num-traits", 398 | ] 399 | 400 | [[package]] 401 | name = "cipher" 402 | version = "0.4.4" 403 | source = "registry+https://github.com/rust-lang/crates.io-index" 404 | checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" 405 | dependencies = [ 406 | "crypto-common", 407 | "inout", 408 | ] 409 | 410 | [[package]] 411 | name = "clang-sys" 412 | version = "1.6.1" 413 | source = "registry+https://github.com/rust-lang/crates.io-index" 414 | checksum = "c688fc74432808e3eb684cae8830a86be1d66a2bd58e1f248ed0960a590baf6f" 415 | dependencies = [ 416 | "glob", 417 | "libc", 418 | "libloading", 419 | ] 420 | 421 | [[package]] 422 | name = "coins-bip32" 423 | version = "0.8.7" 424 | source = "registry+https://github.com/rust-lang/crates.io-index" 425 | checksum = "3b6be4a5df2098cd811f3194f64ddb96c267606bffd9689ac7b0160097b01ad3" 426 | dependencies = [ 427 | "bs58", 428 | "coins-core", 429 | "digest", 430 | "hmac", 431 | "k256", 432 | "serde", 433 | "sha2", 434 | "thiserror", 435 | ] 436 | 437 | [[package]] 438 | name = "coins-bip39" 439 | version = "0.8.7" 440 | source = "registry+https://github.com/rust-lang/crates.io-index" 441 | checksum = "3db8fba409ce3dc04f7d804074039eb68b960b0829161f8e06c95fea3f122528" 442 | dependencies = [ 443 | "bitvec", 444 | "coins-bip32", 445 | "hmac", 446 | "once_cell", 447 | "pbkdf2 0.12.2", 448 | "rand", 449 | "sha2", 450 | "thiserror", 451 | ] 452 | 453 | [[package]] 454 | name = "coins-core" 455 | version = "0.8.7" 456 | source = "registry+https://github.com/rust-lang/crates.io-index" 457 | checksum = "5286a0843c21f8367f7be734f89df9b822e0321d8bcce8d6e735aadff7d74979" 458 | dependencies = [ 459 | "base64 0.21.5", 460 | "bech32", 461 | "bs58", 462 | "digest", 463 | "generic-array", 464 | "hex", 465 | "ripemd", 466 | "serde", 467 | "serde_derive", 468 | "sha2", 469 | "sha3", 470 | "thiserror", 471 | ] 472 | 473 | [[package]] 474 | name = "const-hex" 475 | version = "1.10.0" 476 | source = "registry+https://github.com/rust-lang/crates.io-index" 477 | checksum = "a5104de16b218eddf8e34ffe2f86f74bfa4e61e95a1b89732fccf6325efd0557" 478 | dependencies = [ 479 | "cfg-if", 480 | "cpufeatures", 481 | "hex", 482 | "proptest", 483 | "serde", 484 | ] 485 | 486 | [[package]] 487 | name = "const-oid" 488 | version = "0.9.5" 489 | source = "registry+https://github.com/rust-lang/crates.io-index" 490 | checksum = "28c122c3980598d243d63d9a704629a2d748d101f278052ff068be5a4423ab6f" 491 | 492 | [[package]] 493 | name = "constant_time_eq" 494 | version = "0.1.5" 495 | source = "registry+https://github.com/rust-lang/crates.io-index" 496 | checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" 497 | 498 | [[package]] 499 | name = "convert_case" 500 | version = "0.4.0" 501 | source = "registry+https://github.com/rust-lang/crates.io-index" 502 | checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" 503 | 504 | [[package]] 505 | name = "core-foundation" 506 | version = "0.9.3" 507 | source = "registry+https://github.com/rust-lang/crates.io-index" 508 | checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146" 509 | dependencies = [ 510 | "core-foundation-sys", 511 | "libc", 512 | ] 513 | 514 | [[package]] 515 | name = "core-foundation-sys" 516 | version = "0.8.4" 517 | source = "registry+https://github.com/rust-lang/crates.io-index" 518 | checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa" 519 | 520 | [[package]] 521 | name = "cpufeatures" 522 | version = "0.2.11" 523 | source = "registry+https://github.com/rust-lang/crates.io-index" 524 | checksum = "ce420fe07aecd3e67c5f910618fe65e94158f6dcc0adf44e00d69ce2bdfe0fd0" 525 | dependencies = [ 526 | "libc", 527 | ] 528 | 529 | [[package]] 530 | name = "crc32fast" 531 | version = "1.3.2" 532 | source = "registry+https://github.com/rust-lang/crates.io-index" 533 | checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" 534 | dependencies = [ 535 | "cfg-if", 536 | ] 537 | 538 | [[package]] 539 | name = "crossbeam-deque" 540 | version = "0.8.3" 541 | source = "registry+https://github.com/rust-lang/crates.io-index" 542 | checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef" 543 | dependencies = [ 544 | "cfg-if", 545 | "crossbeam-epoch", 546 | "crossbeam-utils", 547 | ] 548 | 549 | [[package]] 550 | name = "crossbeam-epoch" 551 | version = "0.9.15" 552 | source = "registry+https://github.com/rust-lang/crates.io-index" 553 | checksum = "ae211234986c545741a7dc064309f67ee1e5ad243d0e48335adc0484d960bcc7" 554 | dependencies = [ 555 | "autocfg", 556 | "cfg-if", 557 | "crossbeam-utils", 558 | "memoffset", 559 | "scopeguard", 560 | ] 561 | 562 | [[package]] 563 | name = "crossbeam-utils" 564 | version = "0.8.16" 565 | source = "registry+https://github.com/rust-lang/crates.io-index" 566 | checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294" 567 | dependencies = [ 568 | "cfg-if", 569 | ] 570 | 571 | [[package]] 572 | name = "crunchy" 573 | version = "0.2.2" 574 | source = "registry+https://github.com/rust-lang/crates.io-index" 575 | checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" 576 | 577 | [[package]] 578 | name = "crypto-bigint" 579 | version = "0.5.3" 580 | source = "registry+https://github.com/rust-lang/crates.io-index" 581 | checksum = "740fe28e594155f10cfc383984cbefd529d7396050557148f79cb0f621204124" 582 | dependencies = [ 583 | "generic-array", 584 | "rand_core", 585 | "subtle", 586 | "zeroize", 587 | ] 588 | 589 | [[package]] 590 | name = "crypto-common" 591 | version = "0.1.6" 592 | source = "registry+https://github.com/rust-lang/crates.io-index" 593 | checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" 594 | dependencies = [ 595 | "generic-array", 596 | "typenum", 597 | ] 598 | 599 | [[package]] 600 | name = "ctr" 601 | version = "0.9.2" 602 | source = "registry+https://github.com/rust-lang/crates.io-index" 603 | checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835" 604 | dependencies = [ 605 | "cipher", 606 | ] 607 | 608 | [[package]] 609 | name = "data-encoding" 610 | version = "2.4.0" 611 | source = "registry+https://github.com/rust-lang/crates.io-index" 612 | checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308" 613 | 614 | [[package]] 615 | name = "der" 616 | version = "0.7.8" 617 | source = "registry+https://github.com/rust-lang/crates.io-index" 618 | checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c" 619 | dependencies = [ 620 | "const-oid", 621 | "zeroize", 622 | ] 623 | 624 | [[package]] 625 | name = "deranged" 626 | version = "0.3.9" 627 | source = "registry+https://github.com/rust-lang/crates.io-index" 628 | checksum = "0f32d04922c60427da6f9fef14d042d9edddef64cb9d4ce0d64d0685fbeb1fd3" 629 | dependencies = [ 630 | "powerfmt", 631 | ] 632 | 633 | [[package]] 634 | name = "derive_more" 635 | version = "0.99.17" 636 | source = "registry+https://github.com/rust-lang/crates.io-index" 637 | checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" 638 | dependencies = [ 639 | "convert_case", 640 | "proc-macro2", 641 | "quote", 642 | "rustc_version", 643 | "syn 1.0.109", 644 | ] 645 | 646 | [[package]] 647 | name = "diff" 648 | version = "0.1.13" 649 | source = "registry+https://github.com/rust-lang/crates.io-index" 650 | checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" 651 | 652 | [[package]] 653 | name = "digest" 654 | version = "0.10.7" 655 | source = "registry+https://github.com/rust-lang/crates.io-index" 656 | checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" 657 | dependencies = [ 658 | "block-buffer", 659 | "const-oid", 660 | "crypto-common", 661 | "subtle", 662 | ] 663 | 664 | [[package]] 665 | name = "dirs" 666 | version = "5.0.1" 667 | source = "registry+https://github.com/rust-lang/crates.io-index" 668 | checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225" 669 | dependencies = [ 670 | "dirs-sys", 671 | ] 672 | 673 | [[package]] 674 | name = "dirs-next" 675 | version = "2.0.0" 676 | source = "registry+https://github.com/rust-lang/crates.io-index" 677 | checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1" 678 | dependencies = [ 679 | "cfg-if", 680 | "dirs-sys-next", 681 | ] 682 | 683 | [[package]] 684 | name = "dirs-sys" 685 | version = "0.4.1" 686 | source = "registry+https://github.com/rust-lang/crates.io-index" 687 | checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c" 688 | dependencies = [ 689 | "libc", 690 | "option-ext", 691 | "redox_users", 692 | "windows-sys", 693 | ] 694 | 695 | [[package]] 696 | name = "dirs-sys-next" 697 | version = "0.1.2" 698 | source = "registry+https://github.com/rust-lang/crates.io-index" 699 | checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" 700 | dependencies = [ 701 | "libc", 702 | "redox_users", 703 | "winapi", 704 | ] 705 | 706 | [[package]] 707 | name = "dunce" 708 | version = "1.0.4" 709 | source = "registry+https://github.com/rust-lang/crates.io-index" 710 | checksum = "56ce8c6da7551ec6c462cbaf3bfbc75131ebbfa1c944aeaa9dab51ca1c5f0c3b" 711 | 712 | [[package]] 713 | name = "ecdsa" 714 | version = "0.16.8" 715 | source = "registry+https://github.com/rust-lang/crates.io-index" 716 | checksum = "a4b1e0c257a9e9f25f90ff76d7a68360ed497ee519c8e428d1825ef0000799d4" 717 | dependencies = [ 718 | "der", 719 | "digest", 720 | "elliptic-curve", 721 | "rfc6979", 722 | "signature", 723 | "spki", 724 | ] 725 | 726 | [[package]] 727 | name = "either" 728 | version = "1.9.0" 729 | source = "registry+https://github.com/rust-lang/crates.io-index" 730 | checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" 731 | 732 | [[package]] 733 | name = "elliptic-curve" 734 | version = "0.13.6" 735 | source = "registry+https://github.com/rust-lang/crates.io-index" 736 | checksum = "d97ca172ae9dc9f9b779a6e3a65d308f2af74e5b8c921299075bdb4a0370e914" 737 | dependencies = [ 738 | "base16ct", 739 | "crypto-bigint", 740 | "digest", 741 | "ff", 742 | "generic-array", 743 | "group", 744 | "pkcs8", 745 | "rand_core", 746 | "sec1", 747 | "subtle", 748 | "zeroize", 749 | ] 750 | 751 | [[package]] 752 | name = "ena" 753 | version = "0.14.2" 754 | source = "registry+https://github.com/rust-lang/crates.io-index" 755 | checksum = "c533630cf40e9caa44bd91aadc88a75d75a4c3a12b4cfde353cbed41daa1e1f1" 756 | dependencies = [ 757 | "log", 758 | ] 759 | 760 | [[package]] 761 | name = "encoding_rs" 762 | version = "0.8.33" 763 | source = "registry+https://github.com/rust-lang/crates.io-index" 764 | checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1" 765 | dependencies = [ 766 | "cfg-if", 767 | ] 768 | 769 | [[package]] 770 | name = "enr" 771 | version = "0.9.1" 772 | source = "registry+https://github.com/rust-lang/crates.io-index" 773 | checksum = "fe81b5c06ecfdbc71dd845216f225f53b62a10cb8a16c946836a3467f701d05b" 774 | dependencies = [ 775 | "base64 0.21.5", 776 | "bytes", 777 | "hex", 778 | "k256", 779 | "log", 780 | "rand", 781 | "rlp", 782 | "serde", 783 | "sha3", 784 | "zeroize", 785 | ] 786 | 787 | [[package]] 788 | name = "enumn" 789 | version = "0.1.12" 790 | source = "registry+https://github.com/rust-lang/crates.io-index" 791 | checksum = "c2ad8cef1d801a4686bfd8919f0b30eac4c8e48968c437a6405ded4fb5272d2b" 792 | dependencies = [ 793 | "proc-macro2", 794 | "quote", 795 | "syn 2.0.38", 796 | ] 797 | 798 | [[package]] 799 | name = "equivalent" 800 | version = "1.0.1" 801 | source = "registry+https://github.com/rust-lang/crates.io-index" 802 | checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" 803 | 804 | [[package]] 805 | name = "errno" 806 | version = "0.3.5" 807 | source = "registry+https://github.com/rust-lang/crates.io-index" 808 | checksum = "ac3e13f66a2f95e32a39eaa81f6b95d42878ca0e1db0c7543723dfe12557e860" 809 | dependencies = [ 810 | "libc", 811 | "windows-sys", 812 | ] 813 | 814 | [[package]] 815 | name = "eth-keystore" 816 | version = "0.5.0" 817 | source = "registry+https://github.com/rust-lang/crates.io-index" 818 | checksum = "1fda3bf123be441da5260717e0661c25a2fd9cb2b2c1d20bf2e05580047158ab" 819 | dependencies = [ 820 | "aes", 821 | "ctr", 822 | "digest", 823 | "hex", 824 | "hmac", 825 | "pbkdf2 0.11.0", 826 | "rand", 827 | "scrypt", 828 | "serde", 829 | "serde_json", 830 | "sha2", 831 | "sha3", 832 | "thiserror", 833 | "uuid", 834 | ] 835 | 836 | [[package]] 837 | name = "ethabi" 838 | version = "18.0.0" 839 | source = "registry+https://github.com/rust-lang/crates.io-index" 840 | checksum = "7413c5f74cc903ea37386a8965a936cbeb334bd270862fdece542c1b2dcbc898" 841 | dependencies = [ 842 | "ethereum-types", 843 | "hex", 844 | "once_cell", 845 | "regex", 846 | "serde", 847 | "serde_json", 848 | "sha3", 849 | "thiserror", 850 | "uint", 851 | ] 852 | 853 | [[package]] 854 | name = "ethbloom" 855 | version = "0.13.0" 856 | source = "registry+https://github.com/rust-lang/crates.io-index" 857 | checksum = "c22d4b5885b6aa2fe5e8b9329fb8d232bf739e434e6b87347c63bdd00c120f60" 858 | dependencies = [ 859 | "crunchy", 860 | "fixed-hash", 861 | "impl-codec", 862 | "impl-rlp", 863 | "impl-serde", 864 | "scale-info", 865 | "tiny-keccak", 866 | ] 867 | 868 | [[package]] 869 | name = "ethereum-types" 870 | version = "0.14.1" 871 | source = "registry+https://github.com/rust-lang/crates.io-index" 872 | checksum = "02d215cbf040552efcbe99a38372fe80ab9d00268e20012b79fcd0f073edd8ee" 873 | dependencies = [ 874 | "ethbloom", 875 | "fixed-hash", 876 | "impl-codec", 877 | "impl-rlp", 878 | "impl-serde", 879 | "primitive-types", 880 | "scale-info", 881 | "uint", 882 | ] 883 | 884 | [[package]] 885 | name = "ethers" 886 | version = "2.0.10" 887 | source = "registry+https://github.com/rust-lang/crates.io-index" 888 | checksum = "1ad13497f6e0a24292fc7b408e30d22fe9dc262da1f40d7b542c3a44e7fc0476" 889 | dependencies = [ 890 | "ethers-addressbook", 891 | "ethers-contract", 892 | "ethers-core", 893 | "ethers-etherscan", 894 | "ethers-middleware", 895 | "ethers-providers", 896 | "ethers-signers", 897 | "ethers-solc", 898 | ] 899 | 900 | [[package]] 901 | name = "ethers-addressbook" 902 | version = "2.0.10" 903 | source = "registry+https://github.com/rust-lang/crates.io-index" 904 | checksum = "c6e9e8acd0ed348403cc73a670c24daba3226c40b98dc1a41903766b3ab6240a" 905 | dependencies = [ 906 | "ethers-core", 907 | "once_cell", 908 | "serde", 909 | "serde_json", 910 | ] 911 | 912 | [[package]] 913 | name = "ethers-contract" 914 | version = "2.0.10" 915 | source = "registry+https://github.com/rust-lang/crates.io-index" 916 | checksum = "d79269278125006bb0552349c03593ffa9702112ca88bc7046cc669f148fb47c" 917 | dependencies = [ 918 | "const-hex", 919 | "ethers-contract-abigen", 920 | "ethers-contract-derive", 921 | "ethers-core", 922 | "ethers-providers", 923 | "futures-util", 924 | "once_cell", 925 | "pin-project", 926 | "serde", 927 | "serde_json", 928 | "thiserror", 929 | ] 930 | 931 | [[package]] 932 | name = "ethers-contract-abigen" 933 | version = "2.0.10" 934 | source = "registry+https://github.com/rust-lang/crates.io-index" 935 | checksum = "ce95a43c939b2e4e2f3191c5ad4a1f279780b8a39139c9905b43a7433531e2ab" 936 | dependencies = [ 937 | "Inflector", 938 | "const-hex", 939 | "dunce", 940 | "ethers-core", 941 | "ethers-etherscan", 942 | "eyre", 943 | "prettyplease", 944 | "proc-macro2", 945 | "quote", 946 | "regex", 947 | "reqwest", 948 | "serde", 949 | "serde_json", 950 | "syn 2.0.38", 951 | "toml", 952 | "walkdir", 953 | ] 954 | 955 | [[package]] 956 | name = "ethers-contract-derive" 957 | version = "2.0.10" 958 | source = "registry+https://github.com/rust-lang/crates.io-index" 959 | checksum = "8e9ce44906fc871b3ee8c69a695ca7ec7f70e50cb379c9b9cb5e532269e492f6" 960 | dependencies = [ 961 | "Inflector", 962 | "const-hex", 963 | "ethers-contract-abigen", 964 | "ethers-core", 965 | "proc-macro2", 966 | "quote", 967 | "serde_json", 968 | "syn 2.0.38", 969 | ] 970 | 971 | [[package]] 972 | name = "ethers-core" 973 | version = "2.0.10" 974 | source = "registry+https://github.com/rust-lang/crates.io-index" 975 | checksum = "c0a17f0708692024db9956b31d7a20163607d2745953f5ae8125ab368ba280ad" 976 | dependencies = [ 977 | "arrayvec", 978 | "bytes", 979 | "cargo_metadata", 980 | "chrono", 981 | "const-hex", 982 | "elliptic-curve", 983 | "ethabi", 984 | "generic-array", 985 | "k256", 986 | "num_enum", 987 | "once_cell", 988 | "open-fastrlp", 989 | "rand", 990 | "rlp", 991 | "serde", 992 | "serde_json", 993 | "strum", 994 | "syn 2.0.38", 995 | "tempfile", 996 | "thiserror", 997 | "tiny-keccak", 998 | "unicode-xid", 999 | ] 1000 | 1001 | [[package]] 1002 | name = "ethers-etherscan" 1003 | version = "2.0.10" 1004 | source = "registry+https://github.com/rust-lang/crates.io-index" 1005 | checksum = "0e53451ea4a8128fbce33966da71132cf9e1040dcfd2a2084fd7733ada7b2045" 1006 | dependencies = [ 1007 | "ethers-core", 1008 | "ethers-solc", 1009 | "reqwest", 1010 | "semver", 1011 | "serde", 1012 | "serde_json", 1013 | "thiserror", 1014 | "tracing", 1015 | ] 1016 | 1017 | [[package]] 1018 | name = "ethers-middleware" 1019 | version = "2.0.10" 1020 | source = "registry+https://github.com/rust-lang/crates.io-index" 1021 | checksum = "473f1ccd0c793871bbc248729fa8df7e6d2981d6226e4343e3bbaa9281074d5d" 1022 | dependencies = [ 1023 | "async-trait", 1024 | "auto_impl", 1025 | "ethers-contract", 1026 | "ethers-core", 1027 | "ethers-etherscan", 1028 | "ethers-providers", 1029 | "ethers-signers", 1030 | "futures-channel", 1031 | "futures-locks", 1032 | "futures-util", 1033 | "instant", 1034 | "reqwest", 1035 | "serde", 1036 | "serde_json", 1037 | "thiserror", 1038 | "tokio", 1039 | "tracing", 1040 | "tracing-futures", 1041 | "url", 1042 | ] 1043 | 1044 | [[package]] 1045 | name = "ethers-providers" 1046 | version = "2.0.10" 1047 | source = "registry+https://github.com/rust-lang/crates.io-index" 1048 | checksum = "6838fa110e57d572336178b7c79e94ff88ef976306852d8cb87d9e5b1fc7c0b5" 1049 | dependencies = [ 1050 | "async-trait", 1051 | "auto_impl", 1052 | "base64 0.21.5", 1053 | "bytes", 1054 | "const-hex", 1055 | "enr", 1056 | "ethers-core", 1057 | "futures-channel", 1058 | "futures-core", 1059 | "futures-timer", 1060 | "futures-util", 1061 | "hashers", 1062 | "http", 1063 | "instant", 1064 | "jsonwebtoken", 1065 | "once_cell", 1066 | "pin-project", 1067 | "reqwest", 1068 | "serde", 1069 | "serde_json", 1070 | "thiserror", 1071 | "tokio", 1072 | "tokio-tungstenite", 1073 | "tracing", 1074 | "tracing-futures", 1075 | "url", 1076 | "wasm-bindgen", 1077 | "wasm-bindgen-futures", 1078 | "web-sys", 1079 | "ws_stream_wasm", 1080 | ] 1081 | 1082 | [[package]] 1083 | name = "ethers-signers" 1084 | version = "2.0.10" 1085 | source = "registry+https://github.com/rust-lang/crates.io-index" 1086 | checksum = "5ea44bec930f12292866166f9ddbea6aa76304850e4d8dcd66dc492b43d00ff1" 1087 | dependencies = [ 1088 | "async-trait", 1089 | "coins-bip32", 1090 | "coins-bip39", 1091 | "const-hex", 1092 | "elliptic-curve", 1093 | "eth-keystore", 1094 | "ethers-core", 1095 | "rand", 1096 | "sha2", 1097 | "thiserror", 1098 | "tracing", 1099 | ] 1100 | 1101 | [[package]] 1102 | name = "ethers-solc" 1103 | version = "2.0.10" 1104 | source = "registry+https://github.com/rust-lang/crates.io-index" 1105 | checksum = "de34e484e7ae3cab99fbfd013d6c5dc7f9013676a4e0e414d8b12e1213e8b3ba" 1106 | dependencies = [ 1107 | "cfg-if", 1108 | "const-hex", 1109 | "dirs", 1110 | "dunce", 1111 | "ethers-core", 1112 | "glob", 1113 | "home", 1114 | "md-5", 1115 | "num_cpus", 1116 | "once_cell", 1117 | "path-slash", 1118 | "rayon", 1119 | "regex", 1120 | "semver", 1121 | "serde", 1122 | "serde_json", 1123 | "solang-parser", 1124 | "svm-rs", 1125 | "thiserror", 1126 | "tiny-keccak", 1127 | "tokio", 1128 | "tracing", 1129 | "walkdir", 1130 | "yansi", 1131 | ] 1132 | 1133 | [[package]] 1134 | name = "eyre" 1135 | version = "0.6.8" 1136 | source = "registry+https://github.com/rust-lang/crates.io-index" 1137 | checksum = "4c2b6b5a29c02cdc822728b7d7b8ae1bab3e3b05d44522770ddd49722eeac7eb" 1138 | dependencies = [ 1139 | "indenter", 1140 | "once_cell", 1141 | ] 1142 | 1143 | [[package]] 1144 | name = "fastrand" 1145 | version = "2.0.1" 1146 | source = "registry+https://github.com/rust-lang/crates.io-index" 1147 | checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5" 1148 | 1149 | [[package]] 1150 | name = "ff" 1151 | version = "0.13.0" 1152 | source = "registry+https://github.com/rust-lang/crates.io-index" 1153 | checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449" 1154 | dependencies = [ 1155 | "rand_core", 1156 | "subtle", 1157 | ] 1158 | 1159 | [[package]] 1160 | name = "fixed-hash" 1161 | version = "0.8.0" 1162 | source = "registry+https://github.com/rust-lang/crates.io-index" 1163 | checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534" 1164 | dependencies = [ 1165 | "byteorder", 1166 | "rand", 1167 | "rustc-hex", 1168 | "static_assertions", 1169 | ] 1170 | 1171 | [[package]] 1172 | name = "fixedbitset" 1173 | version = "0.4.2" 1174 | source = "registry+https://github.com/rust-lang/crates.io-index" 1175 | checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" 1176 | 1177 | [[package]] 1178 | name = "flate2" 1179 | version = "1.0.28" 1180 | source = "registry+https://github.com/rust-lang/crates.io-index" 1181 | checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e" 1182 | dependencies = [ 1183 | "crc32fast", 1184 | "miniz_oxide", 1185 | ] 1186 | 1187 | [[package]] 1188 | name = "fnv" 1189 | version = "1.0.7" 1190 | source = "registry+https://github.com/rust-lang/crates.io-index" 1191 | checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" 1192 | 1193 | [[package]] 1194 | name = "form_urlencoded" 1195 | version = "1.2.0" 1196 | source = "registry+https://github.com/rust-lang/crates.io-index" 1197 | checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652" 1198 | dependencies = [ 1199 | "percent-encoding", 1200 | ] 1201 | 1202 | [[package]] 1203 | name = "foundry-evm-mini" 1204 | version = "0.1.0" 1205 | dependencies = [ 1206 | "anyhow", 1207 | "bytes", 1208 | "ethers", 1209 | "ethers-addressbook", 1210 | "ethers-contract", 1211 | "ethers-contract-abigen", 1212 | "ethers-core", 1213 | "ethers-etherscan", 1214 | "ethers-middleware", 1215 | "ethers-providers", 1216 | "ethers-signers", 1217 | "ethers-solc", 1218 | "eyre", 1219 | "futures", 1220 | "hashbrown 0.13.2", 1221 | "once_cell", 1222 | "parking_lot", 1223 | "revm", 1224 | "serde", 1225 | "serde_json", 1226 | "thiserror", 1227 | "tokio", 1228 | "tracing", 1229 | "url", 1230 | ] 1231 | 1232 | [[package]] 1233 | name = "fs2" 1234 | version = "0.4.3" 1235 | source = "registry+https://github.com/rust-lang/crates.io-index" 1236 | checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213" 1237 | dependencies = [ 1238 | "libc", 1239 | "winapi", 1240 | ] 1241 | 1242 | [[package]] 1243 | name = "funty" 1244 | version = "2.0.0" 1245 | source = "registry+https://github.com/rust-lang/crates.io-index" 1246 | checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" 1247 | 1248 | [[package]] 1249 | name = "futures" 1250 | version = "0.3.29" 1251 | source = "registry+https://github.com/rust-lang/crates.io-index" 1252 | checksum = "da0290714b38af9b4a7b094b8a37086d1b4e61f2df9122c3cad2577669145335" 1253 | dependencies = [ 1254 | "futures-channel", 1255 | "futures-core", 1256 | "futures-executor", 1257 | "futures-io", 1258 | "futures-sink", 1259 | "futures-task", 1260 | "futures-util", 1261 | ] 1262 | 1263 | [[package]] 1264 | name = "futures-channel" 1265 | version = "0.3.29" 1266 | source = "registry+https://github.com/rust-lang/crates.io-index" 1267 | checksum = "ff4dd66668b557604244583e3e1e1eada8c5c2e96a6d0d6653ede395b78bbacb" 1268 | dependencies = [ 1269 | "futures-core", 1270 | "futures-sink", 1271 | ] 1272 | 1273 | [[package]] 1274 | name = "futures-core" 1275 | version = "0.3.29" 1276 | source = "registry+https://github.com/rust-lang/crates.io-index" 1277 | checksum = "eb1d22c66e66d9d72e1758f0bd7d4fd0bee04cad842ee34587d68c07e45d088c" 1278 | 1279 | [[package]] 1280 | name = "futures-executor" 1281 | version = "0.3.29" 1282 | source = "registry+https://github.com/rust-lang/crates.io-index" 1283 | checksum = "0f4fb8693db0cf099eadcca0efe2a5a22e4550f98ed16aba6c48700da29597bc" 1284 | dependencies = [ 1285 | "futures-core", 1286 | "futures-task", 1287 | "futures-util", 1288 | ] 1289 | 1290 | [[package]] 1291 | name = "futures-io" 1292 | version = "0.3.29" 1293 | source = "registry+https://github.com/rust-lang/crates.io-index" 1294 | checksum = "8bf34a163b5c4c52d0478a4d757da8fb65cabef42ba90515efee0f6f9fa45aaa" 1295 | 1296 | [[package]] 1297 | name = "futures-locks" 1298 | version = "0.7.1" 1299 | source = "registry+https://github.com/rust-lang/crates.io-index" 1300 | checksum = "45ec6fe3675af967e67c5536c0b9d44e34e6c52f86bedc4ea49c5317b8e94d06" 1301 | dependencies = [ 1302 | "futures-channel", 1303 | "futures-task", 1304 | ] 1305 | 1306 | [[package]] 1307 | name = "futures-macro" 1308 | version = "0.3.29" 1309 | source = "registry+https://github.com/rust-lang/crates.io-index" 1310 | checksum = "53b153fd91e4b0147f4aced87be237c98248656bb01050b96bf3ee89220a8ddb" 1311 | dependencies = [ 1312 | "proc-macro2", 1313 | "quote", 1314 | "syn 2.0.38", 1315 | ] 1316 | 1317 | [[package]] 1318 | name = "futures-sink" 1319 | version = "0.3.29" 1320 | source = "registry+https://github.com/rust-lang/crates.io-index" 1321 | checksum = "e36d3378ee38c2a36ad710c5d30c2911d752cb941c00c72dbabfb786a7970817" 1322 | 1323 | [[package]] 1324 | name = "futures-task" 1325 | version = "0.3.29" 1326 | source = "registry+https://github.com/rust-lang/crates.io-index" 1327 | checksum = "efd193069b0ddadc69c46389b740bbccdd97203899b48d09c5f7969591d6bae2" 1328 | 1329 | [[package]] 1330 | name = "futures-timer" 1331 | version = "3.0.2" 1332 | source = "registry+https://github.com/rust-lang/crates.io-index" 1333 | checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c" 1334 | dependencies = [ 1335 | "gloo-timers", 1336 | "send_wrapper 0.4.0", 1337 | ] 1338 | 1339 | [[package]] 1340 | name = "futures-util" 1341 | version = "0.3.29" 1342 | source = "registry+https://github.com/rust-lang/crates.io-index" 1343 | checksum = "a19526d624e703a3179b3d322efec918b6246ea0fa51d41124525f00f1cc8104" 1344 | dependencies = [ 1345 | "futures-channel", 1346 | "futures-core", 1347 | "futures-io", 1348 | "futures-macro", 1349 | "futures-sink", 1350 | "futures-task", 1351 | "memchr", 1352 | "pin-project-lite", 1353 | "pin-utils", 1354 | "slab", 1355 | ] 1356 | 1357 | [[package]] 1358 | name = "fxhash" 1359 | version = "0.2.1" 1360 | source = "registry+https://github.com/rust-lang/crates.io-index" 1361 | checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" 1362 | dependencies = [ 1363 | "byteorder", 1364 | ] 1365 | 1366 | [[package]] 1367 | name = "generic-array" 1368 | version = "0.14.7" 1369 | source = "registry+https://github.com/rust-lang/crates.io-index" 1370 | checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" 1371 | dependencies = [ 1372 | "typenum", 1373 | "version_check", 1374 | "zeroize", 1375 | ] 1376 | 1377 | [[package]] 1378 | name = "getrandom" 1379 | version = "0.2.10" 1380 | source = "registry+https://github.com/rust-lang/crates.io-index" 1381 | checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427" 1382 | dependencies = [ 1383 | "cfg-if", 1384 | "libc", 1385 | "wasi", 1386 | ] 1387 | 1388 | [[package]] 1389 | name = "gimli" 1390 | version = "0.28.0" 1391 | source = "registry+https://github.com/rust-lang/crates.io-index" 1392 | checksum = "6fb8d784f27acf97159b40fc4db5ecd8aa23b9ad5ef69cdd136d3bc80665f0c0" 1393 | 1394 | [[package]] 1395 | name = "glob" 1396 | version = "0.3.1" 1397 | source = "registry+https://github.com/rust-lang/crates.io-index" 1398 | checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" 1399 | 1400 | [[package]] 1401 | name = "gloo-timers" 1402 | version = "0.2.6" 1403 | source = "registry+https://github.com/rust-lang/crates.io-index" 1404 | checksum = "9b995a66bb87bebce9a0f4a95aed01daca4872c050bfcb21653361c03bc35e5c" 1405 | dependencies = [ 1406 | "futures-channel", 1407 | "futures-core", 1408 | "js-sys", 1409 | "wasm-bindgen", 1410 | ] 1411 | 1412 | [[package]] 1413 | name = "group" 1414 | version = "0.13.0" 1415 | source = "registry+https://github.com/rust-lang/crates.io-index" 1416 | checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" 1417 | dependencies = [ 1418 | "ff", 1419 | "rand_core", 1420 | "subtle", 1421 | ] 1422 | 1423 | [[package]] 1424 | name = "h2" 1425 | version = "0.3.21" 1426 | source = "registry+https://github.com/rust-lang/crates.io-index" 1427 | checksum = "91fc23aa11be92976ef4729127f1a74adf36d8436f7816b185d18df956790833" 1428 | dependencies = [ 1429 | "bytes", 1430 | "fnv", 1431 | "futures-core", 1432 | "futures-sink", 1433 | "futures-util", 1434 | "http", 1435 | "indexmap 1.9.3", 1436 | "slab", 1437 | "tokio", 1438 | "tokio-util", 1439 | "tracing", 1440 | ] 1441 | 1442 | [[package]] 1443 | name = "hashbrown" 1444 | version = "0.12.3" 1445 | source = "registry+https://github.com/rust-lang/crates.io-index" 1446 | checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" 1447 | 1448 | [[package]] 1449 | name = "hashbrown" 1450 | version = "0.13.2" 1451 | source = "registry+https://github.com/rust-lang/crates.io-index" 1452 | checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" 1453 | dependencies = [ 1454 | "ahash", 1455 | "serde", 1456 | ] 1457 | 1458 | [[package]] 1459 | name = "hashbrown" 1460 | version = "0.14.2" 1461 | source = "registry+https://github.com/rust-lang/crates.io-index" 1462 | checksum = "f93e7192158dbcda357bdec5fb5788eebf8bbac027f3f33e719d29135ae84156" 1463 | dependencies = [ 1464 | "ahash", 1465 | "allocator-api2", 1466 | "serde", 1467 | ] 1468 | 1469 | [[package]] 1470 | name = "hashers" 1471 | version = "1.0.1" 1472 | source = "registry+https://github.com/rust-lang/crates.io-index" 1473 | checksum = "b2bca93b15ea5a746f220e56587f71e73c6165eab783df9e26590069953e3c30" 1474 | dependencies = [ 1475 | "fxhash", 1476 | ] 1477 | 1478 | [[package]] 1479 | name = "heck" 1480 | version = "0.4.1" 1481 | source = "registry+https://github.com/rust-lang/crates.io-index" 1482 | checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" 1483 | 1484 | [[package]] 1485 | name = "hermit-abi" 1486 | version = "0.3.3" 1487 | source = "registry+https://github.com/rust-lang/crates.io-index" 1488 | checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7" 1489 | 1490 | [[package]] 1491 | name = "hex" 1492 | version = "0.4.3" 1493 | source = "registry+https://github.com/rust-lang/crates.io-index" 1494 | checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" 1495 | dependencies = [ 1496 | "serde", 1497 | ] 1498 | 1499 | [[package]] 1500 | name = "hex-literal" 1501 | version = "0.4.1" 1502 | source = "registry+https://github.com/rust-lang/crates.io-index" 1503 | checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46" 1504 | 1505 | [[package]] 1506 | name = "hmac" 1507 | version = "0.12.1" 1508 | source = "registry+https://github.com/rust-lang/crates.io-index" 1509 | checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" 1510 | dependencies = [ 1511 | "digest", 1512 | ] 1513 | 1514 | [[package]] 1515 | name = "home" 1516 | version = "0.5.5" 1517 | source = "registry+https://github.com/rust-lang/crates.io-index" 1518 | checksum = "5444c27eef6923071f7ebcc33e3444508466a76f7a2b93da00ed6e19f30c1ddb" 1519 | dependencies = [ 1520 | "windows-sys", 1521 | ] 1522 | 1523 | [[package]] 1524 | name = "http" 1525 | version = "0.2.9" 1526 | source = "registry+https://github.com/rust-lang/crates.io-index" 1527 | checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482" 1528 | dependencies = [ 1529 | "bytes", 1530 | "fnv", 1531 | "itoa", 1532 | ] 1533 | 1534 | [[package]] 1535 | name = "http-body" 1536 | version = "0.4.5" 1537 | source = "registry+https://github.com/rust-lang/crates.io-index" 1538 | checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1" 1539 | dependencies = [ 1540 | "bytes", 1541 | "http", 1542 | "pin-project-lite", 1543 | ] 1544 | 1545 | [[package]] 1546 | name = "httparse" 1547 | version = "1.8.0" 1548 | source = "registry+https://github.com/rust-lang/crates.io-index" 1549 | checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904" 1550 | 1551 | [[package]] 1552 | name = "httpdate" 1553 | version = "1.0.3" 1554 | source = "registry+https://github.com/rust-lang/crates.io-index" 1555 | checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" 1556 | 1557 | [[package]] 1558 | name = "hyper" 1559 | version = "0.14.27" 1560 | source = "registry+https://github.com/rust-lang/crates.io-index" 1561 | checksum = "ffb1cfd654a8219eaef89881fdb3bb3b1cdc5fa75ded05d6933b2b382e395468" 1562 | dependencies = [ 1563 | "bytes", 1564 | "futures-channel", 1565 | "futures-core", 1566 | "futures-util", 1567 | "h2", 1568 | "http", 1569 | "http-body", 1570 | "httparse", 1571 | "httpdate", 1572 | "itoa", 1573 | "pin-project-lite", 1574 | "socket2 0.4.10", 1575 | "tokio", 1576 | "tower-service", 1577 | "tracing", 1578 | "want", 1579 | ] 1580 | 1581 | [[package]] 1582 | name = "hyper-rustls" 1583 | version = "0.24.2" 1584 | source = "registry+https://github.com/rust-lang/crates.io-index" 1585 | checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" 1586 | dependencies = [ 1587 | "futures-util", 1588 | "http", 1589 | "hyper", 1590 | "rustls", 1591 | "tokio", 1592 | "tokio-rustls", 1593 | ] 1594 | 1595 | [[package]] 1596 | name = "idna" 1597 | version = "0.4.0" 1598 | source = "registry+https://github.com/rust-lang/crates.io-index" 1599 | checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c" 1600 | dependencies = [ 1601 | "unicode-bidi", 1602 | "unicode-normalization", 1603 | ] 1604 | 1605 | [[package]] 1606 | name = "impl-codec" 1607 | version = "0.6.0" 1608 | source = "registry+https://github.com/rust-lang/crates.io-index" 1609 | checksum = "ba6a270039626615617f3f36d15fc827041df3b78c439da2cadfa47455a77f2f" 1610 | dependencies = [ 1611 | "parity-scale-codec", 1612 | ] 1613 | 1614 | [[package]] 1615 | name = "impl-rlp" 1616 | version = "0.3.0" 1617 | source = "registry+https://github.com/rust-lang/crates.io-index" 1618 | checksum = "f28220f89297a075ddc7245cd538076ee98b01f2a9c23a53a4f1105d5a322808" 1619 | dependencies = [ 1620 | "rlp", 1621 | ] 1622 | 1623 | [[package]] 1624 | name = "impl-serde" 1625 | version = "0.4.0" 1626 | source = "registry+https://github.com/rust-lang/crates.io-index" 1627 | checksum = "ebc88fc67028ae3db0c853baa36269d398d5f45b6982f95549ff5def78c935cd" 1628 | dependencies = [ 1629 | "serde", 1630 | ] 1631 | 1632 | [[package]] 1633 | name = "impl-trait-for-tuples" 1634 | version = "0.2.2" 1635 | source = "registry+https://github.com/rust-lang/crates.io-index" 1636 | checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb" 1637 | dependencies = [ 1638 | "proc-macro2", 1639 | "quote", 1640 | "syn 1.0.109", 1641 | ] 1642 | 1643 | [[package]] 1644 | name = "indenter" 1645 | version = "0.3.3" 1646 | source = "registry+https://github.com/rust-lang/crates.io-index" 1647 | checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683" 1648 | 1649 | [[package]] 1650 | name = "indexmap" 1651 | version = "1.9.3" 1652 | source = "registry+https://github.com/rust-lang/crates.io-index" 1653 | checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" 1654 | dependencies = [ 1655 | "autocfg", 1656 | "hashbrown 0.12.3", 1657 | ] 1658 | 1659 | [[package]] 1660 | name = "indexmap" 1661 | version = "2.1.0" 1662 | source = "registry+https://github.com/rust-lang/crates.io-index" 1663 | checksum = "d530e1a18b1cb4c484e6e34556a0d948706958449fca0cab753d649f2bce3d1f" 1664 | dependencies = [ 1665 | "equivalent", 1666 | "hashbrown 0.14.2", 1667 | ] 1668 | 1669 | [[package]] 1670 | name = "inout" 1671 | version = "0.1.3" 1672 | source = "registry+https://github.com/rust-lang/crates.io-index" 1673 | checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5" 1674 | dependencies = [ 1675 | "generic-array", 1676 | ] 1677 | 1678 | [[package]] 1679 | name = "instant" 1680 | version = "0.1.12" 1681 | source = "registry+https://github.com/rust-lang/crates.io-index" 1682 | checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" 1683 | dependencies = [ 1684 | "cfg-if", 1685 | ] 1686 | 1687 | [[package]] 1688 | name = "ipnet" 1689 | version = "2.9.0" 1690 | source = "registry+https://github.com/rust-lang/crates.io-index" 1691 | checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" 1692 | 1693 | [[package]] 1694 | name = "is-terminal" 1695 | version = "0.4.9" 1696 | source = "registry+https://github.com/rust-lang/crates.io-index" 1697 | checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b" 1698 | dependencies = [ 1699 | "hermit-abi", 1700 | "rustix", 1701 | "windows-sys", 1702 | ] 1703 | 1704 | [[package]] 1705 | name = "itertools" 1706 | version = "0.10.5" 1707 | source = "registry+https://github.com/rust-lang/crates.io-index" 1708 | checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" 1709 | dependencies = [ 1710 | "either", 1711 | ] 1712 | 1713 | [[package]] 1714 | name = "itertools" 1715 | version = "0.11.0" 1716 | source = "registry+https://github.com/rust-lang/crates.io-index" 1717 | checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57" 1718 | dependencies = [ 1719 | "either", 1720 | ] 1721 | 1722 | [[package]] 1723 | name = "itoa" 1724 | version = "1.0.9" 1725 | source = "registry+https://github.com/rust-lang/crates.io-index" 1726 | checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38" 1727 | 1728 | [[package]] 1729 | name = "jobserver" 1730 | version = "0.1.27" 1731 | source = "registry+https://github.com/rust-lang/crates.io-index" 1732 | checksum = "8c37f63953c4c63420ed5fd3d6d398c719489b9f872b9fa683262f8edd363c7d" 1733 | dependencies = [ 1734 | "libc", 1735 | ] 1736 | 1737 | [[package]] 1738 | name = "js-sys" 1739 | version = "0.3.65" 1740 | source = "registry+https://github.com/rust-lang/crates.io-index" 1741 | checksum = "54c0c35952f67de54bb584e9fd912b3023117cbafc0a77d8f3dee1fb5f572fe8" 1742 | dependencies = [ 1743 | "wasm-bindgen", 1744 | ] 1745 | 1746 | [[package]] 1747 | name = "jsonwebtoken" 1748 | version = "8.3.0" 1749 | source = "registry+https://github.com/rust-lang/crates.io-index" 1750 | checksum = "6971da4d9c3aa03c3d8f3ff0f4155b534aad021292003895a469716b2a230378" 1751 | dependencies = [ 1752 | "base64 0.21.5", 1753 | "pem", 1754 | "ring 0.16.20", 1755 | "serde", 1756 | "serde_json", 1757 | "simple_asn1", 1758 | ] 1759 | 1760 | [[package]] 1761 | name = "k256" 1762 | version = "0.13.1" 1763 | source = "registry+https://github.com/rust-lang/crates.io-index" 1764 | checksum = "cadb76004ed8e97623117f3df85b17aaa6626ab0b0831e6573f104df16cd1bcc" 1765 | dependencies = [ 1766 | "cfg-if", 1767 | "ecdsa", 1768 | "elliptic-curve", 1769 | "once_cell", 1770 | "sha2", 1771 | "signature", 1772 | ] 1773 | 1774 | [[package]] 1775 | name = "keccak" 1776 | version = "0.1.4" 1777 | source = "registry+https://github.com/rust-lang/crates.io-index" 1778 | checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940" 1779 | dependencies = [ 1780 | "cpufeatures", 1781 | ] 1782 | 1783 | [[package]] 1784 | name = "lalrpop" 1785 | version = "0.20.0" 1786 | source = "registry+https://github.com/rust-lang/crates.io-index" 1787 | checksum = "da4081d44f4611b66c6dd725e6de3169f9f63905421e8626fcb86b6a898998b8" 1788 | dependencies = [ 1789 | "ascii-canvas", 1790 | "bit-set", 1791 | "diff", 1792 | "ena", 1793 | "is-terminal", 1794 | "itertools 0.10.5", 1795 | "lalrpop-util", 1796 | "petgraph", 1797 | "regex", 1798 | "regex-syntax 0.7.5", 1799 | "string_cache", 1800 | "term", 1801 | "tiny-keccak", 1802 | "unicode-xid", 1803 | ] 1804 | 1805 | [[package]] 1806 | name = "lalrpop-util" 1807 | version = "0.20.0" 1808 | source = "registry+https://github.com/rust-lang/crates.io-index" 1809 | checksum = "3f35c735096c0293d313e8f2a641627472b83d01b937177fe76e5e2708d31e0d" 1810 | 1811 | [[package]] 1812 | name = "lazy_static" 1813 | version = "1.4.0" 1814 | source = "registry+https://github.com/rust-lang/crates.io-index" 1815 | checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" 1816 | dependencies = [ 1817 | "spin 0.5.2", 1818 | ] 1819 | 1820 | [[package]] 1821 | name = "lazycell" 1822 | version = "1.3.0" 1823 | source = "registry+https://github.com/rust-lang/crates.io-index" 1824 | checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" 1825 | 1826 | [[package]] 1827 | name = "libc" 1828 | version = "0.2.149" 1829 | source = "registry+https://github.com/rust-lang/crates.io-index" 1830 | checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b" 1831 | 1832 | [[package]] 1833 | name = "libloading" 1834 | version = "0.7.4" 1835 | source = "registry+https://github.com/rust-lang/crates.io-index" 1836 | checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f" 1837 | dependencies = [ 1838 | "cfg-if", 1839 | "winapi", 1840 | ] 1841 | 1842 | [[package]] 1843 | name = "libm" 1844 | version = "0.2.8" 1845 | source = "registry+https://github.com/rust-lang/crates.io-index" 1846 | checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058" 1847 | 1848 | [[package]] 1849 | name = "linux-raw-sys" 1850 | version = "0.4.10" 1851 | source = "registry+https://github.com/rust-lang/crates.io-index" 1852 | checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f" 1853 | 1854 | [[package]] 1855 | name = "lock_api" 1856 | version = "0.4.11" 1857 | source = "registry+https://github.com/rust-lang/crates.io-index" 1858 | checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45" 1859 | dependencies = [ 1860 | "autocfg", 1861 | "scopeguard", 1862 | ] 1863 | 1864 | [[package]] 1865 | name = "log" 1866 | version = "0.4.20" 1867 | source = "registry+https://github.com/rust-lang/crates.io-index" 1868 | checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" 1869 | 1870 | [[package]] 1871 | name = "md-5" 1872 | version = "0.10.6" 1873 | source = "registry+https://github.com/rust-lang/crates.io-index" 1874 | checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf" 1875 | dependencies = [ 1876 | "cfg-if", 1877 | "digest", 1878 | ] 1879 | 1880 | [[package]] 1881 | name = "memchr" 1882 | version = "2.6.4" 1883 | source = "registry+https://github.com/rust-lang/crates.io-index" 1884 | checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167" 1885 | 1886 | [[package]] 1887 | name = "memoffset" 1888 | version = "0.9.0" 1889 | source = "registry+https://github.com/rust-lang/crates.io-index" 1890 | checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c" 1891 | dependencies = [ 1892 | "autocfg", 1893 | ] 1894 | 1895 | [[package]] 1896 | name = "mime" 1897 | version = "0.3.17" 1898 | source = "registry+https://github.com/rust-lang/crates.io-index" 1899 | checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" 1900 | 1901 | [[package]] 1902 | name = "minimal-lexical" 1903 | version = "0.2.1" 1904 | source = "registry+https://github.com/rust-lang/crates.io-index" 1905 | checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" 1906 | 1907 | [[package]] 1908 | name = "miniz_oxide" 1909 | version = "0.7.1" 1910 | source = "registry+https://github.com/rust-lang/crates.io-index" 1911 | checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7" 1912 | dependencies = [ 1913 | "adler", 1914 | ] 1915 | 1916 | [[package]] 1917 | name = "mio" 1918 | version = "0.8.9" 1919 | source = "registry+https://github.com/rust-lang/crates.io-index" 1920 | checksum = "3dce281c5e46beae905d4de1870d8b1509a9142b62eedf18b443b011ca8343d0" 1921 | dependencies = [ 1922 | "libc", 1923 | "wasi", 1924 | "windows-sys", 1925 | ] 1926 | 1927 | [[package]] 1928 | name = "new_debug_unreachable" 1929 | version = "1.0.4" 1930 | source = "registry+https://github.com/rust-lang/crates.io-index" 1931 | checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54" 1932 | 1933 | [[package]] 1934 | name = "nom" 1935 | version = "7.1.3" 1936 | source = "registry+https://github.com/rust-lang/crates.io-index" 1937 | checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" 1938 | dependencies = [ 1939 | "memchr", 1940 | "minimal-lexical", 1941 | ] 1942 | 1943 | [[package]] 1944 | name = "num" 1945 | version = "0.4.1" 1946 | source = "registry+https://github.com/rust-lang/crates.io-index" 1947 | checksum = "b05180d69e3da0e530ba2a1dae5110317e49e3b7f3d41be227dc5f92e49ee7af" 1948 | dependencies = [ 1949 | "num-bigint", 1950 | "num-complex", 1951 | "num-integer", 1952 | "num-iter", 1953 | "num-rational", 1954 | "num-traits", 1955 | ] 1956 | 1957 | [[package]] 1958 | name = "num-bigint" 1959 | version = "0.4.4" 1960 | source = "registry+https://github.com/rust-lang/crates.io-index" 1961 | checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0" 1962 | dependencies = [ 1963 | "autocfg", 1964 | "num-integer", 1965 | "num-traits", 1966 | ] 1967 | 1968 | [[package]] 1969 | name = "num-complex" 1970 | version = "0.4.4" 1971 | source = "registry+https://github.com/rust-lang/crates.io-index" 1972 | checksum = "1ba157ca0885411de85d6ca030ba7e2a83a28636056c7c699b07c8b6f7383214" 1973 | dependencies = [ 1974 | "num-traits", 1975 | ] 1976 | 1977 | [[package]] 1978 | name = "num-integer" 1979 | version = "0.1.45" 1980 | source = "registry+https://github.com/rust-lang/crates.io-index" 1981 | checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" 1982 | dependencies = [ 1983 | "autocfg", 1984 | "num-traits", 1985 | ] 1986 | 1987 | [[package]] 1988 | name = "num-iter" 1989 | version = "0.1.43" 1990 | source = "registry+https://github.com/rust-lang/crates.io-index" 1991 | checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252" 1992 | dependencies = [ 1993 | "autocfg", 1994 | "num-integer", 1995 | "num-traits", 1996 | ] 1997 | 1998 | [[package]] 1999 | name = "num-rational" 2000 | version = "0.4.1" 2001 | source = "registry+https://github.com/rust-lang/crates.io-index" 2002 | checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0" 2003 | dependencies = [ 2004 | "autocfg", 2005 | "num-bigint", 2006 | "num-integer", 2007 | "num-traits", 2008 | ] 2009 | 2010 | [[package]] 2011 | name = "num-traits" 2012 | version = "0.2.17" 2013 | source = "registry+https://github.com/rust-lang/crates.io-index" 2014 | checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c" 2015 | dependencies = [ 2016 | "autocfg", 2017 | "libm", 2018 | ] 2019 | 2020 | [[package]] 2021 | name = "num_cpus" 2022 | version = "1.16.0" 2023 | source = "registry+https://github.com/rust-lang/crates.io-index" 2024 | checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" 2025 | dependencies = [ 2026 | "hermit-abi", 2027 | "libc", 2028 | ] 2029 | 2030 | [[package]] 2031 | name = "num_enum" 2032 | version = "0.7.1" 2033 | source = "registry+https://github.com/rust-lang/crates.io-index" 2034 | checksum = "683751d591e6d81200c39fb0d1032608b77724f34114db54f571ff1317b337c0" 2035 | dependencies = [ 2036 | "num_enum_derive", 2037 | ] 2038 | 2039 | [[package]] 2040 | name = "num_enum_derive" 2041 | version = "0.7.1" 2042 | source = "registry+https://github.com/rust-lang/crates.io-index" 2043 | checksum = "6c11e44798ad209ccdd91fc192f0526a369a01234f7373e1b141c96d7cee4f0e" 2044 | dependencies = [ 2045 | "proc-macro-crate 2.0.0", 2046 | "proc-macro2", 2047 | "quote", 2048 | "syn 2.0.38", 2049 | ] 2050 | 2051 | [[package]] 2052 | name = "object" 2053 | version = "0.32.1" 2054 | source = "registry+https://github.com/rust-lang/crates.io-index" 2055 | checksum = "9cf5f9dd3933bd50a9e1f149ec995f39ae2c496d31fd772c1fd45ebc27e902b0" 2056 | dependencies = [ 2057 | "memchr", 2058 | ] 2059 | 2060 | [[package]] 2061 | name = "once_cell" 2062 | version = "1.18.0" 2063 | source = "registry+https://github.com/rust-lang/crates.io-index" 2064 | checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d" 2065 | 2066 | [[package]] 2067 | name = "open-fastrlp" 2068 | version = "0.1.4" 2069 | source = "registry+https://github.com/rust-lang/crates.io-index" 2070 | checksum = "786393f80485445794f6043fd3138854dd109cc6c4bd1a6383db304c9ce9b9ce" 2071 | dependencies = [ 2072 | "arrayvec", 2073 | "auto_impl", 2074 | "bytes", 2075 | "ethereum-types", 2076 | "open-fastrlp-derive", 2077 | ] 2078 | 2079 | [[package]] 2080 | name = "open-fastrlp-derive" 2081 | version = "0.1.1" 2082 | source = "registry+https://github.com/rust-lang/crates.io-index" 2083 | checksum = "003b2be5c6c53c1cfeb0a238b8a1c3915cd410feb684457a36c10038f764bb1c" 2084 | dependencies = [ 2085 | "bytes", 2086 | "proc-macro2", 2087 | "quote", 2088 | "syn 1.0.109", 2089 | ] 2090 | 2091 | [[package]] 2092 | name = "option-ext" 2093 | version = "0.2.0" 2094 | source = "registry+https://github.com/rust-lang/crates.io-index" 2095 | checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" 2096 | 2097 | [[package]] 2098 | name = "parity-scale-codec" 2099 | version = "3.6.5" 2100 | source = "registry+https://github.com/rust-lang/crates.io-index" 2101 | checksum = "0dec8a8073036902368c2cdc0387e85ff9a37054d7e7c98e592145e0c92cd4fb" 2102 | dependencies = [ 2103 | "arrayvec", 2104 | "bitvec", 2105 | "byte-slice-cast", 2106 | "impl-trait-for-tuples", 2107 | "parity-scale-codec-derive", 2108 | "serde", 2109 | ] 2110 | 2111 | [[package]] 2112 | name = "parity-scale-codec-derive" 2113 | version = "3.6.5" 2114 | source = "registry+https://github.com/rust-lang/crates.io-index" 2115 | checksum = "312270ee71e1cd70289dacf597cab7b207aa107d2f28191c2ae45b2ece18a260" 2116 | dependencies = [ 2117 | "proc-macro-crate 1.3.1", 2118 | "proc-macro2", 2119 | "quote", 2120 | "syn 1.0.109", 2121 | ] 2122 | 2123 | [[package]] 2124 | name = "parking_lot" 2125 | version = "0.12.1" 2126 | source = "registry+https://github.com/rust-lang/crates.io-index" 2127 | checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" 2128 | dependencies = [ 2129 | "lock_api", 2130 | "parking_lot_core", 2131 | ] 2132 | 2133 | [[package]] 2134 | name = "parking_lot_core" 2135 | version = "0.9.9" 2136 | source = "registry+https://github.com/rust-lang/crates.io-index" 2137 | checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e" 2138 | dependencies = [ 2139 | "cfg-if", 2140 | "libc", 2141 | "redox_syscall 0.4.1", 2142 | "smallvec", 2143 | "windows-targets", 2144 | ] 2145 | 2146 | [[package]] 2147 | name = "password-hash" 2148 | version = "0.4.2" 2149 | source = "registry+https://github.com/rust-lang/crates.io-index" 2150 | checksum = "7676374caaee8a325c9e7a2ae557f216c5563a171d6997b0ef8a65af35147700" 2151 | dependencies = [ 2152 | "base64ct", 2153 | "rand_core", 2154 | "subtle", 2155 | ] 2156 | 2157 | [[package]] 2158 | name = "path-slash" 2159 | version = "0.2.1" 2160 | source = "registry+https://github.com/rust-lang/crates.io-index" 2161 | checksum = "1e91099d4268b0e11973f036e885d652fb0b21fedcf69738c627f94db6a44f42" 2162 | 2163 | [[package]] 2164 | name = "pbkdf2" 2165 | version = "0.11.0" 2166 | source = "registry+https://github.com/rust-lang/crates.io-index" 2167 | checksum = "83a0692ec44e4cf1ef28ca317f14f8f07da2d95ec3fa01f86e4467b725e60917" 2168 | dependencies = [ 2169 | "digest", 2170 | "hmac", 2171 | "password-hash", 2172 | "sha2", 2173 | ] 2174 | 2175 | [[package]] 2176 | name = "pbkdf2" 2177 | version = "0.12.2" 2178 | source = "registry+https://github.com/rust-lang/crates.io-index" 2179 | checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2" 2180 | dependencies = [ 2181 | "digest", 2182 | "hmac", 2183 | ] 2184 | 2185 | [[package]] 2186 | name = "peeking_take_while" 2187 | version = "0.1.2" 2188 | source = "registry+https://github.com/rust-lang/crates.io-index" 2189 | checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099" 2190 | 2191 | [[package]] 2192 | name = "pem" 2193 | version = "1.1.1" 2194 | source = "registry+https://github.com/rust-lang/crates.io-index" 2195 | checksum = "a8835c273a76a90455d7344889b0964598e3316e2a79ede8e36f16bdcf2228b8" 2196 | dependencies = [ 2197 | "base64 0.13.1", 2198 | ] 2199 | 2200 | [[package]] 2201 | name = "percent-encoding" 2202 | version = "2.3.0" 2203 | source = "registry+https://github.com/rust-lang/crates.io-index" 2204 | checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94" 2205 | 2206 | [[package]] 2207 | name = "petgraph" 2208 | version = "0.6.4" 2209 | source = "registry+https://github.com/rust-lang/crates.io-index" 2210 | checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9" 2211 | dependencies = [ 2212 | "fixedbitset", 2213 | "indexmap 2.1.0", 2214 | ] 2215 | 2216 | [[package]] 2217 | name = "pharos" 2218 | version = "0.5.3" 2219 | source = "registry+https://github.com/rust-lang/crates.io-index" 2220 | checksum = "e9567389417feee6ce15dd6527a8a1ecac205ef62c2932bcf3d9f6fc5b78b414" 2221 | dependencies = [ 2222 | "futures", 2223 | "rustc_version", 2224 | ] 2225 | 2226 | [[package]] 2227 | name = "phf" 2228 | version = "0.11.2" 2229 | source = "registry+https://github.com/rust-lang/crates.io-index" 2230 | checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc" 2231 | dependencies = [ 2232 | "phf_macros", 2233 | "phf_shared 0.11.2", 2234 | ] 2235 | 2236 | [[package]] 2237 | name = "phf_generator" 2238 | version = "0.11.2" 2239 | source = "registry+https://github.com/rust-lang/crates.io-index" 2240 | checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0" 2241 | dependencies = [ 2242 | "phf_shared 0.11.2", 2243 | "rand", 2244 | ] 2245 | 2246 | [[package]] 2247 | name = "phf_macros" 2248 | version = "0.11.2" 2249 | source = "registry+https://github.com/rust-lang/crates.io-index" 2250 | checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b" 2251 | dependencies = [ 2252 | "phf_generator", 2253 | "phf_shared 0.11.2", 2254 | "proc-macro2", 2255 | "quote", 2256 | "syn 2.0.38", 2257 | ] 2258 | 2259 | [[package]] 2260 | name = "phf_shared" 2261 | version = "0.10.0" 2262 | source = "registry+https://github.com/rust-lang/crates.io-index" 2263 | checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096" 2264 | dependencies = [ 2265 | "siphasher", 2266 | ] 2267 | 2268 | [[package]] 2269 | name = "phf_shared" 2270 | version = "0.11.2" 2271 | source = "registry+https://github.com/rust-lang/crates.io-index" 2272 | checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b" 2273 | dependencies = [ 2274 | "siphasher", 2275 | ] 2276 | 2277 | [[package]] 2278 | name = "pin-project" 2279 | version = "1.1.3" 2280 | source = "registry+https://github.com/rust-lang/crates.io-index" 2281 | checksum = "fda4ed1c6c173e3fc7a83629421152e01d7b1f9b7f65fb301e490e8cfc656422" 2282 | dependencies = [ 2283 | "pin-project-internal", 2284 | ] 2285 | 2286 | [[package]] 2287 | name = "pin-project-internal" 2288 | version = "1.1.3" 2289 | source = "registry+https://github.com/rust-lang/crates.io-index" 2290 | checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405" 2291 | dependencies = [ 2292 | "proc-macro2", 2293 | "quote", 2294 | "syn 2.0.38", 2295 | ] 2296 | 2297 | [[package]] 2298 | name = "pin-project-lite" 2299 | version = "0.2.13" 2300 | source = "registry+https://github.com/rust-lang/crates.io-index" 2301 | checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" 2302 | 2303 | [[package]] 2304 | name = "pin-utils" 2305 | version = "0.1.0" 2306 | source = "registry+https://github.com/rust-lang/crates.io-index" 2307 | checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" 2308 | 2309 | [[package]] 2310 | name = "pkcs8" 2311 | version = "0.10.2" 2312 | source = "registry+https://github.com/rust-lang/crates.io-index" 2313 | checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7" 2314 | dependencies = [ 2315 | "der", 2316 | "spki", 2317 | ] 2318 | 2319 | [[package]] 2320 | name = "pkg-config" 2321 | version = "0.3.27" 2322 | source = "registry+https://github.com/rust-lang/crates.io-index" 2323 | checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964" 2324 | 2325 | [[package]] 2326 | name = "powerfmt" 2327 | version = "0.2.0" 2328 | source = "registry+https://github.com/rust-lang/crates.io-index" 2329 | checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" 2330 | 2331 | [[package]] 2332 | name = "ppv-lite86" 2333 | version = "0.2.17" 2334 | source = "registry+https://github.com/rust-lang/crates.io-index" 2335 | checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" 2336 | 2337 | [[package]] 2338 | name = "precomputed-hash" 2339 | version = "0.1.1" 2340 | source = "registry+https://github.com/rust-lang/crates.io-index" 2341 | checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" 2342 | 2343 | [[package]] 2344 | name = "prettyplease" 2345 | version = "0.2.15" 2346 | source = "registry+https://github.com/rust-lang/crates.io-index" 2347 | checksum = "ae005bd773ab59b4725093fd7df83fd7892f7d8eafb48dbd7de6e024e4215f9d" 2348 | dependencies = [ 2349 | "proc-macro2", 2350 | "syn 2.0.38", 2351 | ] 2352 | 2353 | [[package]] 2354 | name = "primitive-types" 2355 | version = "0.12.2" 2356 | source = "registry+https://github.com/rust-lang/crates.io-index" 2357 | checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2" 2358 | dependencies = [ 2359 | "fixed-hash", 2360 | "impl-codec", 2361 | "impl-rlp", 2362 | "impl-serde", 2363 | "scale-info", 2364 | "uint", 2365 | ] 2366 | 2367 | [[package]] 2368 | name = "proc-macro-crate" 2369 | version = "1.3.1" 2370 | source = "registry+https://github.com/rust-lang/crates.io-index" 2371 | checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919" 2372 | dependencies = [ 2373 | "once_cell", 2374 | "toml_edit 0.19.15", 2375 | ] 2376 | 2377 | [[package]] 2378 | name = "proc-macro-crate" 2379 | version = "2.0.0" 2380 | source = "registry+https://github.com/rust-lang/crates.io-index" 2381 | checksum = "7e8366a6159044a37876a2b9817124296703c586a5c92e2c53751fa06d8d43e8" 2382 | dependencies = [ 2383 | "toml_edit 0.20.7", 2384 | ] 2385 | 2386 | [[package]] 2387 | name = "proc-macro-error" 2388 | version = "1.0.4" 2389 | source = "registry+https://github.com/rust-lang/crates.io-index" 2390 | checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" 2391 | dependencies = [ 2392 | "proc-macro-error-attr", 2393 | "proc-macro2", 2394 | "quote", 2395 | "syn 1.0.109", 2396 | "version_check", 2397 | ] 2398 | 2399 | [[package]] 2400 | name = "proc-macro-error-attr" 2401 | version = "1.0.4" 2402 | source = "registry+https://github.com/rust-lang/crates.io-index" 2403 | checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" 2404 | dependencies = [ 2405 | "proc-macro2", 2406 | "quote", 2407 | "version_check", 2408 | ] 2409 | 2410 | [[package]] 2411 | name = "proc-macro2" 2412 | version = "1.0.69" 2413 | source = "registry+https://github.com/rust-lang/crates.io-index" 2414 | checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da" 2415 | dependencies = [ 2416 | "unicode-ident", 2417 | ] 2418 | 2419 | [[package]] 2420 | name = "proptest" 2421 | version = "1.3.1" 2422 | source = "registry+https://github.com/rust-lang/crates.io-index" 2423 | checksum = "7c003ac8c77cb07bb74f5f198bce836a689bcd5a42574612bf14d17bfd08c20e" 2424 | dependencies = [ 2425 | "bitflags 2.4.1", 2426 | "lazy_static", 2427 | "num-traits", 2428 | "rand", 2429 | "rand_chacha", 2430 | "rand_xorshift", 2431 | "regex-syntax 0.7.5", 2432 | "unarray", 2433 | ] 2434 | 2435 | [[package]] 2436 | name = "quote" 2437 | version = "1.0.33" 2438 | source = "registry+https://github.com/rust-lang/crates.io-index" 2439 | checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" 2440 | dependencies = [ 2441 | "proc-macro2", 2442 | ] 2443 | 2444 | [[package]] 2445 | name = "radium" 2446 | version = "0.7.0" 2447 | source = "registry+https://github.com/rust-lang/crates.io-index" 2448 | checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" 2449 | 2450 | [[package]] 2451 | name = "rand" 2452 | version = "0.8.5" 2453 | source = "registry+https://github.com/rust-lang/crates.io-index" 2454 | checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" 2455 | dependencies = [ 2456 | "libc", 2457 | "rand_chacha", 2458 | "rand_core", 2459 | ] 2460 | 2461 | [[package]] 2462 | name = "rand_chacha" 2463 | version = "0.3.1" 2464 | source = "registry+https://github.com/rust-lang/crates.io-index" 2465 | checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" 2466 | dependencies = [ 2467 | "ppv-lite86", 2468 | "rand_core", 2469 | ] 2470 | 2471 | [[package]] 2472 | name = "rand_core" 2473 | version = "0.6.4" 2474 | source = "registry+https://github.com/rust-lang/crates.io-index" 2475 | checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" 2476 | dependencies = [ 2477 | "getrandom", 2478 | ] 2479 | 2480 | [[package]] 2481 | name = "rand_xorshift" 2482 | version = "0.3.0" 2483 | source = "registry+https://github.com/rust-lang/crates.io-index" 2484 | checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f" 2485 | dependencies = [ 2486 | "rand_core", 2487 | ] 2488 | 2489 | [[package]] 2490 | name = "rayon" 2491 | version = "1.8.0" 2492 | source = "registry+https://github.com/rust-lang/crates.io-index" 2493 | checksum = "9c27db03db7734835b3f53954b534c91069375ce6ccaa2e065441e07d9b6cdb1" 2494 | dependencies = [ 2495 | "either", 2496 | "rayon-core", 2497 | ] 2498 | 2499 | [[package]] 2500 | name = "rayon-core" 2501 | version = "1.12.0" 2502 | source = "registry+https://github.com/rust-lang/crates.io-index" 2503 | checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed" 2504 | dependencies = [ 2505 | "crossbeam-deque", 2506 | "crossbeam-utils", 2507 | ] 2508 | 2509 | [[package]] 2510 | name = "redox_syscall" 2511 | version = "0.2.16" 2512 | source = "registry+https://github.com/rust-lang/crates.io-index" 2513 | checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a" 2514 | dependencies = [ 2515 | "bitflags 1.3.2", 2516 | ] 2517 | 2518 | [[package]] 2519 | name = "redox_syscall" 2520 | version = "0.4.1" 2521 | source = "registry+https://github.com/rust-lang/crates.io-index" 2522 | checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" 2523 | dependencies = [ 2524 | "bitflags 1.3.2", 2525 | ] 2526 | 2527 | [[package]] 2528 | name = "redox_users" 2529 | version = "0.4.3" 2530 | source = "registry+https://github.com/rust-lang/crates.io-index" 2531 | checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b" 2532 | dependencies = [ 2533 | "getrandom", 2534 | "redox_syscall 0.2.16", 2535 | "thiserror", 2536 | ] 2537 | 2538 | [[package]] 2539 | name = "regex" 2540 | version = "1.10.2" 2541 | source = "registry+https://github.com/rust-lang/crates.io-index" 2542 | checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343" 2543 | dependencies = [ 2544 | "aho-corasick", 2545 | "memchr", 2546 | "regex-automata", 2547 | "regex-syntax 0.8.2", 2548 | ] 2549 | 2550 | [[package]] 2551 | name = "regex-automata" 2552 | version = "0.4.3" 2553 | source = "registry+https://github.com/rust-lang/crates.io-index" 2554 | checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f" 2555 | dependencies = [ 2556 | "aho-corasick", 2557 | "memchr", 2558 | "regex-syntax 0.8.2", 2559 | ] 2560 | 2561 | [[package]] 2562 | name = "regex-syntax" 2563 | version = "0.7.5" 2564 | source = "registry+https://github.com/rust-lang/crates.io-index" 2565 | checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da" 2566 | 2567 | [[package]] 2568 | name = "regex-syntax" 2569 | version = "0.8.2" 2570 | source = "registry+https://github.com/rust-lang/crates.io-index" 2571 | checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f" 2572 | 2573 | [[package]] 2574 | name = "reqwest" 2575 | version = "0.11.22" 2576 | source = "registry+https://github.com/rust-lang/crates.io-index" 2577 | checksum = "046cd98826c46c2ac8ddecae268eb5c2e58628688a5fc7a2643704a73faba95b" 2578 | dependencies = [ 2579 | "base64 0.21.5", 2580 | "bytes", 2581 | "encoding_rs", 2582 | "futures-core", 2583 | "futures-util", 2584 | "h2", 2585 | "http", 2586 | "http-body", 2587 | "hyper", 2588 | "hyper-rustls", 2589 | "ipnet", 2590 | "js-sys", 2591 | "log", 2592 | "mime", 2593 | "once_cell", 2594 | "percent-encoding", 2595 | "pin-project-lite", 2596 | "rustls", 2597 | "rustls-pemfile", 2598 | "serde", 2599 | "serde_json", 2600 | "serde_urlencoded", 2601 | "system-configuration", 2602 | "tokio", 2603 | "tokio-rustls", 2604 | "tower-service", 2605 | "url", 2606 | "wasm-bindgen", 2607 | "wasm-bindgen-futures", 2608 | "web-sys", 2609 | "webpki-roots", 2610 | "winreg", 2611 | ] 2612 | 2613 | [[package]] 2614 | name = "revm" 2615 | version = "3.4.0" 2616 | source = "git+https://github.com/bluealloy/revm/?rev=80c909d6f242886cb26e6103a01d1a4bf9468426#80c909d6f242886cb26e6103a01d1a4bf9468426" 2617 | dependencies = [ 2618 | "auto_impl", 2619 | "revm-interpreter", 2620 | "revm-precompile", 2621 | "serde", 2622 | "serde_json", 2623 | ] 2624 | 2625 | [[package]] 2626 | name = "revm-interpreter" 2627 | version = "1.2.0" 2628 | source = "git+https://github.com/bluealloy/revm/?rev=80c909d6f242886cb26e6103a01d1a4bf9468426#80c909d6f242886cb26e6103a01d1a4bf9468426" 2629 | dependencies = [ 2630 | "derive_more", 2631 | "enumn", 2632 | "revm-primitives", 2633 | "serde", 2634 | "sha3", 2635 | ] 2636 | 2637 | [[package]] 2638 | name = "revm-precompile" 2639 | version = "2.1.0" 2640 | source = "git+https://github.com/bluealloy/revm/?rev=80c909d6f242886cb26e6103a01d1a4bf9468426#80c909d6f242886cb26e6103a01d1a4bf9468426" 2641 | dependencies = [ 2642 | "c-kzg", 2643 | "hex", 2644 | "k256", 2645 | "num", 2646 | "once_cell", 2647 | "revm-primitives", 2648 | "ripemd", 2649 | "secp256k1", 2650 | "sha2", 2651 | "sha3", 2652 | "substrate-bn", 2653 | ] 2654 | 2655 | [[package]] 2656 | name = "revm-primitives" 2657 | version = "1.2.0" 2658 | source = "git+https://github.com/bluealloy/revm/?rev=80c909d6f242886cb26e6103a01d1a4bf9468426#80c909d6f242886cb26e6103a01d1a4bf9468426" 2659 | dependencies = [ 2660 | "auto_impl", 2661 | "bitflags 2.4.1", 2662 | "bitvec", 2663 | "bytes", 2664 | "c-kzg", 2665 | "derive_more", 2666 | "enumn", 2667 | "fixed-hash", 2668 | "hashbrown 0.14.2", 2669 | "hex", 2670 | "hex-literal", 2671 | "once_cell", 2672 | "primitive-types", 2673 | "rlp", 2674 | "ruint", 2675 | "serde", 2676 | "sha3", 2677 | ] 2678 | 2679 | [[package]] 2680 | name = "rfc6979" 2681 | version = "0.4.0" 2682 | source = "registry+https://github.com/rust-lang/crates.io-index" 2683 | checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" 2684 | dependencies = [ 2685 | "hmac", 2686 | "subtle", 2687 | ] 2688 | 2689 | [[package]] 2690 | name = "ring" 2691 | version = "0.16.20" 2692 | source = "registry+https://github.com/rust-lang/crates.io-index" 2693 | checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc" 2694 | dependencies = [ 2695 | "cc", 2696 | "libc", 2697 | "once_cell", 2698 | "spin 0.5.2", 2699 | "untrusted 0.7.1", 2700 | "web-sys", 2701 | "winapi", 2702 | ] 2703 | 2704 | [[package]] 2705 | name = "ring" 2706 | version = "0.17.5" 2707 | source = "registry+https://github.com/rust-lang/crates.io-index" 2708 | checksum = "fb0205304757e5d899b9c2e448b867ffd03ae7f988002e47cd24954391394d0b" 2709 | dependencies = [ 2710 | "cc", 2711 | "getrandom", 2712 | "libc", 2713 | "spin 0.9.8", 2714 | "untrusted 0.9.0", 2715 | "windows-sys", 2716 | ] 2717 | 2718 | [[package]] 2719 | name = "ripemd" 2720 | version = "0.1.3" 2721 | source = "registry+https://github.com/rust-lang/crates.io-index" 2722 | checksum = "bd124222d17ad93a644ed9d011a40f4fb64aa54275c08cc216524a9ea82fb09f" 2723 | dependencies = [ 2724 | "digest", 2725 | ] 2726 | 2727 | [[package]] 2728 | name = "rlp" 2729 | version = "0.5.2" 2730 | source = "registry+https://github.com/rust-lang/crates.io-index" 2731 | checksum = "bb919243f34364b6bd2fc10ef797edbfa75f33c252e7998527479c6d6b47e1ec" 2732 | dependencies = [ 2733 | "bytes", 2734 | "rlp-derive", 2735 | "rustc-hex", 2736 | ] 2737 | 2738 | [[package]] 2739 | name = "rlp-derive" 2740 | version = "0.1.0" 2741 | source = "registry+https://github.com/rust-lang/crates.io-index" 2742 | checksum = "e33d7b2abe0c340d8797fe2907d3f20d3b5ea5908683618bfe80df7f621f672a" 2743 | dependencies = [ 2744 | "proc-macro2", 2745 | "quote", 2746 | "syn 1.0.109", 2747 | ] 2748 | 2749 | [[package]] 2750 | name = "ruint" 2751 | version = "1.11.0" 2752 | source = "registry+https://github.com/rust-lang/crates.io-index" 2753 | checksum = "724fd11728a3804e9944b14cab63825024c40bf42f8af87c8b5d97c4bbacf426" 2754 | dependencies = [ 2755 | "primitive-types", 2756 | "proptest", 2757 | "rand", 2758 | "rlp", 2759 | "ruint-macro", 2760 | "serde", 2761 | "valuable", 2762 | "zeroize", 2763 | ] 2764 | 2765 | [[package]] 2766 | name = "ruint-macro" 2767 | version = "1.1.0" 2768 | source = "registry+https://github.com/rust-lang/crates.io-index" 2769 | checksum = "e666a5496a0b2186dbcd0ff6106e29e093c15591bde62c20d3842007c6978a09" 2770 | 2771 | [[package]] 2772 | name = "rustc-demangle" 2773 | version = "0.1.23" 2774 | source = "registry+https://github.com/rust-lang/crates.io-index" 2775 | checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76" 2776 | 2777 | [[package]] 2778 | name = "rustc-hash" 2779 | version = "1.1.0" 2780 | source = "registry+https://github.com/rust-lang/crates.io-index" 2781 | checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" 2782 | 2783 | [[package]] 2784 | name = "rustc-hex" 2785 | version = "2.1.0" 2786 | source = "registry+https://github.com/rust-lang/crates.io-index" 2787 | checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6" 2788 | 2789 | [[package]] 2790 | name = "rustc_version" 2791 | version = "0.4.0" 2792 | source = "registry+https://github.com/rust-lang/crates.io-index" 2793 | checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" 2794 | dependencies = [ 2795 | "semver", 2796 | ] 2797 | 2798 | [[package]] 2799 | name = "rustix" 2800 | version = "0.38.21" 2801 | source = "registry+https://github.com/rust-lang/crates.io-index" 2802 | checksum = "2b426b0506e5d50a7d8dafcf2e81471400deb602392c7dd110815afb4eaf02a3" 2803 | dependencies = [ 2804 | "bitflags 2.4.1", 2805 | "errno", 2806 | "libc", 2807 | "linux-raw-sys", 2808 | "windows-sys", 2809 | ] 2810 | 2811 | [[package]] 2812 | name = "rustls" 2813 | version = "0.21.8" 2814 | source = "registry+https://github.com/rust-lang/crates.io-index" 2815 | checksum = "446e14c5cda4f3f30fe71863c34ec70f5ac79d6087097ad0bb433e1be5edf04c" 2816 | dependencies = [ 2817 | "log", 2818 | "ring 0.17.5", 2819 | "rustls-webpki", 2820 | "sct", 2821 | ] 2822 | 2823 | [[package]] 2824 | name = "rustls-pemfile" 2825 | version = "1.0.3" 2826 | source = "registry+https://github.com/rust-lang/crates.io-index" 2827 | checksum = "2d3987094b1d07b653b7dfdc3f70ce9a1da9c51ac18c1b06b662e4f9a0e9f4b2" 2828 | dependencies = [ 2829 | "base64 0.21.5", 2830 | ] 2831 | 2832 | [[package]] 2833 | name = "rustls-webpki" 2834 | version = "0.101.7" 2835 | source = "registry+https://github.com/rust-lang/crates.io-index" 2836 | checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" 2837 | dependencies = [ 2838 | "ring 0.17.5", 2839 | "untrusted 0.9.0", 2840 | ] 2841 | 2842 | [[package]] 2843 | name = "rustversion" 2844 | version = "1.0.14" 2845 | source = "registry+https://github.com/rust-lang/crates.io-index" 2846 | checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4" 2847 | 2848 | [[package]] 2849 | name = "ryu" 2850 | version = "1.0.15" 2851 | source = "registry+https://github.com/rust-lang/crates.io-index" 2852 | checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741" 2853 | 2854 | [[package]] 2855 | name = "salsa20" 2856 | version = "0.10.2" 2857 | source = "registry+https://github.com/rust-lang/crates.io-index" 2858 | checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213" 2859 | dependencies = [ 2860 | "cipher", 2861 | ] 2862 | 2863 | [[package]] 2864 | name = "same-file" 2865 | version = "1.0.6" 2866 | source = "registry+https://github.com/rust-lang/crates.io-index" 2867 | checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" 2868 | dependencies = [ 2869 | "winapi-util", 2870 | ] 2871 | 2872 | [[package]] 2873 | name = "scale-info" 2874 | version = "2.10.0" 2875 | source = "registry+https://github.com/rust-lang/crates.io-index" 2876 | checksum = "7f7d66a1128282b7ef025a8ead62a4a9fcf017382ec53b8ffbf4d7bf77bd3c60" 2877 | dependencies = [ 2878 | "cfg-if", 2879 | "derive_more", 2880 | "parity-scale-codec", 2881 | "scale-info-derive", 2882 | ] 2883 | 2884 | [[package]] 2885 | name = "scale-info-derive" 2886 | version = "2.10.0" 2887 | source = "registry+https://github.com/rust-lang/crates.io-index" 2888 | checksum = "abf2c68b89cafb3b8d918dd07b42be0da66ff202cf1155c5739a4e0c1ea0dc19" 2889 | dependencies = [ 2890 | "proc-macro-crate 1.3.1", 2891 | "proc-macro2", 2892 | "quote", 2893 | "syn 1.0.109", 2894 | ] 2895 | 2896 | [[package]] 2897 | name = "scopeguard" 2898 | version = "1.2.0" 2899 | source = "registry+https://github.com/rust-lang/crates.io-index" 2900 | checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" 2901 | 2902 | [[package]] 2903 | name = "scrypt" 2904 | version = "0.10.0" 2905 | source = "registry+https://github.com/rust-lang/crates.io-index" 2906 | checksum = "9f9e24d2b632954ded8ab2ef9fea0a0c769ea56ea98bddbafbad22caeeadf45d" 2907 | dependencies = [ 2908 | "hmac", 2909 | "pbkdf2 0.11.0", 2910 | "salsa20", 2911 | "sha2", 2912 | ] 2913 | 2914 | [[package]] 2915 | name = "sct" 2916 | version = "0.7.1" 2917 | source = "registry+https://github.com/rust-lang/crates.io-index" 2918 | checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" 2919 | dependencies = [ 2920 | "ring 0.17.5", 2921 | "untrusted 0.9.0", 2922 | ] 2923 | 2924 | [[package]] 2925 | name = "sec1" 2926 | version = "0.7.3" 2927 | source = "registry+https://github.com/rust-lang/crates.io-index" 2928 | checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" 2929 | dependencies = [ 2930 | "base16ct", 2931 | "der", 2932 | "generic-array", 2933 | "pkcs8", 2934 | "subtle", 2935 | "zeroize", 2936 | ] 2937 | 2938 | [[package]] 2939 | name = "secp256k1" 2940 | version = "0.27.0" 2941 | source = "registry+https://github.com/rust-lang/crates.io-index" 2942 | checksum = "25996b82292a7a57ed3508f052cfff8640d38d32018784acd714758b43da9c8f" 2943 | dependencies = [ 2944 | "secp256k1-sys", 2945 | ] 2946 | 2947 | [[package]] 2948 | name = "secp256k1-sys" 2949 | version = "0.8.1" 2950 | source = "registry+https://github.com/rust-lang/crates.io-index" 2951 | checksum = "70a129b9e9efbfb223753b9163c4ab3b13cff7fd9c7f010fbac25ab4099fa07e" 2952 | dependencies = [ 2953 | "cc", 2954 | ] 2955 | 2956 | [[package]] 2957 | name = "semver" 2958 | version = "1.0.20" 2959 | source = "registry+https://github.com/rust-lang/crates.io-index" 2960 | checksum = "836fa6a3e1e547f9a2c4040802ec865b5d85f4014efe00555d7090a3dcaa1090" 2961 | dependencies = [ 2962 | "serde", 2963 | ] 2964 | 2965 | [[package]] 2966 | name = "send_wrapper" 2967 | version = "0.4.0" 2968 | source = "registry+https://github.com/rust-lang/crates.io-index" 2969 | checksum = "f638d531eccd6e23b980caf34876660d38e265409d8e99b397ab71eb3612fad0" 2970 | 2971 | [[package]] 2972 | name = "send_wrapper" 2973 | version = "0.6.0" 2974 | source = "registry+https://github.com/rust-lang/crates.io-index" 2975 | checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73" 2976 | 2977 | [[package]] 2978 | name = "serde" 2979 | version = "1.0.190" 2980 | source = "registry+https://github.com/rust-lang/crates.io-index" 2981 | checksum = "91d3c334ca1ee894a2c6f6ad698fe8c435b76d504b13d436f0685d648d6d96f7" 2982 | dependencies = [ 2983 | "serde_derive", 2984 | ] 2985 | 2986 | [[package]] 2987 | name = "serde_derive" 2988 | version = "1.0.190" 2989 | source = "registry+https://github.com/rust-lang/crates.io-index" 2990 | checksum = "67c5609f394e5c2bd7fc51efda478004ea80ef42fee983d5c67a65e34f32c0e3" 2991 | dependencies = [ 2992 | "proc-macro2", 2993 | "quote", 2994 | "syn 2.0.38", 2995 | ] 2996 | 2997 | [[package]] 2998 | name = "serde_json" 2999 | version = "1.0.108" 3000 | source = "registry+https://github.com/rust-lang/crates.io-index" 3001 | checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b" 3002 | dependencies = [ 3003 | "indexmap 2.1.0", 3004 | "itoa", 3005 | "ryu", 3006 | "serde", 3007 | ] 3008 | 3009 | [[package]] 3010 | name = "serde_spanned" 3011 | version = "0.6.4" 3012 | source = "registry+https://github.com/rust-lang/crates.io-index" 3013 | checksum = "12022b835073e5b11e90a14f86838ceb1c8fb0325b72416845c487ac0fa95e80" 3014 | dependencies = [ 3015 | "serde", 3016 | ] 3017 | 3018 | [[package]] 3019 | name = "serde_urlencoded" 3020 | version = "0.7.1" 3021 | source = "registry+https://github.com/rust-lang/crates.io-index" 3022 | checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" 3023 | dependencies = [ 3024 | "form_urlencoded", 3025 | "itoa", 3026 | "ryu", 3027 | "serde", 3028 | ] 3029 | 3030 | [[package]] 3031 | name = "sha1" 3032 | version = "0.10.6" 3033 | source = "registry+https://github.com/rust-lang/crates.io-index" 3034 | checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" 3035 | dependencies = [ 3036 | "cfg-if", 3037 | "cpufeatures", 3038 | "digest", 3039 | ] 3040 | 3041 | [[package]] 3042 | name = "sha2" 3043 | version = "0.10.8" 3044 | source = "registry+https://github.com/rust-lang/crates.io-index" 3045 | checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8" 3046 | dependencies = [ 3047 | "cfg-if", 3048 | "cpufeatures", 3049 | "digest", 3050 | ] 3051 | 3052 | [[package]] 3053 | name = "sha3" 3054 | version = "0.10.8" 3055 | source = "registry+https://github.com/rust-lang/crates.io-index" 3056 | checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60" 3057 | dependencies = [ 3058 | "digest", 3059 | "keccak", 3060 | ] 3061 | 3062 | [[package]] 3063 | name = "shlex" 3064 | version = "1.2.0" 3065 | source = "registry+https://github.com/rust-lang/crates.io-index" 3066 | checksum = "a7cee0529a6d40f580e7a5e6c495c8fbfe21b7b52795ed4bb5e62cdf92bc6380" 3067 | 3068 | [[package]] 3069 | name = "signature" 3070 | version = "2.1.0" 3071 | source = "registry+https://github.com/rust-lang/crates.io-index" 3072 | checksum = "5e1788eed21689f9cf370582dfc467ef36ed9c707f073528ddafa8d83e3b8500" 3073 | dependencies = [ 3074 | "digest", 3075 | "rand_core", 3076 | ] 3077 | 3078 | [[package]] 3079 | name = "simple_asn1" 3080 | version = "0.6.2" 3081 | source = "registry+https://github.com/rust-lang/crates.io-index" 3082 | checksum = "adc4e5204eb1910f40f9cfa375f6f05b68c3abac4b6fd879c8ff5e7ae8a0a085" 3083 | dependencies = [ 3084 | "num-bigint", 3085 | "num-traits", 3086 | "thiserror", 3087 | "time", 3088 | ] 3089 | 3090 | [[package]] 3091 | name = "siphasher" 3092 | version = "0.3.11" 3093 | source = "registry+https://github.com/rust-lang/crates.io-index" 3094 | checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d" 3095 | 3096 | [[package]] 3097 | name = "slab" 3098 | version = "0.4.9" 3099 | source = "registry+https://github.com/rust-lang/crates.io-index" 3100 | checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" 3101 | dependencies = [ 3102 | "autocfg", 3103 | ] 3104 | 3105 | [[package]] 3106 | name = "smallvec" 3107 | version = "1.11.1" 3108 | source = "registry+https://github.com/rust-lang/crates.io-index" 3109 | checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a" 3110 | 3111 | [[package]] 3112 | name = "socket2" 3113 | version = "0.4.10" 3114 | source = "registry+https://github.com/rust-lang/crates.io-index" 3115 | checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d" 3116 | dependencies = [ 3117 | "libc", 3118 | "winapi", 3119 | ] 3120 | 3121 | [[package]] 3122 | name = "socket2" 3123 | version = "0.5.5" 3124 | source = "registry+https://github.com/rust-lang/crates.io-index" 3125 | checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9" 3126 | dependencies = [ 3127 | "libc", 3128 | "windows-sys", 3129 | ] 3130 | 3131 | [[package]] 3132 | name = "solang-parser" 3133 | version = "0.3.2" 3134 | source = "registry+https://github.com/rust-lang/crates.io-index" 3135 | checksum = "7cb9fa2fa2fa6837be8a2495486ff92e3ffe68a99b6eeba288e139efdd842457" 3136 | dependencies = [ 3137 | "itertools 0.11.0", 3138 | "lalrpop", 3139 | "lalrpop-util", 3140 | "phf", 3141 | "thiserror", 3142 | "unicode-xid", 3143 | ] 3144 | 3145 | [[package]] 3146 | name = "spin" 3147 | version = "0.5.2" 3148 | source = "registry+https://github.com/rust-lang/crates.io-index" 3149 | checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" 3150 | 3151 | [[package]] 3152 | name = "spin" 3153 | version = "0.9.8" 3154 | source = "registry+https://github.com/rust-lang/crates.io-index" 3155 | checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" 3156 | 3157 | [[package]] 3158 | name = "spki" 3159 | version = "0.7.2" 3160 | source = "registry+https://github.com/rust-lang/crates.io-index" 3161 | checksum = "9d1e996ef02c474957d681f1b05213dfb0abab947b446a62d37770b23500184a" 3162 | dependencies = [ 3163 | "base64ct", 3164 | "der", 3165 | ] 3166 | 3167 | [[package]] 3168 | name = "static_assertions" 3169 | version = "1.1.0" 3170 | source = "registry+https://github.com/rust-lang/crates.io-index" 3171 | checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" 3172 | 3173 | [[package]] 3174 | name = "string_cache" 3175 | version = "0.8.7" 3176 | source = "registry+https://github.com/rust-lang/crates.io-index" 3177 | checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b" 3178 | dependencies = [ 3179 | "new_debug_unreachable", 3180 | "once_cell", 3181 | "parking_lot", 3182 | "phf_shared 0.10.0", 3183 | "precomputed-hash", 3184 | ] 3185 | 3186 | [[package]] 3187 | name = "strum" 3188 | version = "0.25.0" 3189 | source = "registry+https://github.com/rust-lang/crates.io-index" 3190 | checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125" 3191 | dependencies = [ 3192 | "strum_macros", 3193 | ] 3194 | 3195 | [[package]] 3196 | name = "strum_macros" 3197 | version = "0.25.3" 3198 | source = "registry+https://github.com/rust-lang/crates.io-index" 3199 | checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0" 3200 | dependencies = [ 3201 | "heck", 3202 | "proc-macro2", 3203 | "quote", 3204 | "rustversion", 3205 | "syn 2.0.38", 3206 | ] 3207 | 3208 | [[package]] 3209 | name = "substrate-bn" 3210 | version = "0.6.0" 3211 | source = "registry+https://github.com/rust-lang/crates.io-index" 3212 | checksum = "72b5bbfa79abbae15dd642ea8176a21a635ff3c00059961d1ea27ad04e5b441c" 3213 | dependencies = [ 3214 | "byteorder", 3215 | "crunchy", 3216 | "lazy_static", 3217 | "rand", 3218 | "rustc-hex", 3219 | ] 3220 | 3221 | [[package]] 3222 | name = "subtle" 3223 | version = "2.5.0" 3224 | source = "registry+https://github.com/rust-lang/crates.io-index" 3225 | checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc" 3226 | 3227 | [[package]] 3228 | name = "svm-rs" 3229 | version = "0.3.2" 3230 | source = "registry+https://github.com/rust-lang/crates.io-index" 3231 | checksum = "d0cc95be7cc2c384a2f57cac56548d2178650905ebe5725bc8970ccc25529060" 3232 | dependencies = [ 3233 | "dirs", 3234 | "fs2", 3235 | "hex", 3236 | "once_cell", 3237 | "reqwest", 3238 | "semver", 3239 | "serde", 3240 | "serde_json", 3241 | "sha2", 3242 | "thiserror", 3243 | "url", 3244 | "zip", 3245 | ] 3246 | 3247 | [[package]] 3248 | name = "syn" 3249 | version = "1.0.109" 3250 | source = "registry+https://github.com/rust-lang/crates.io-index" 3251 | checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" 3252 | dependencies = [ 3253 | "proc-macro2", 3254 | "quote", 3255 | "unicode-ident", 3256 | ] 3257 | 3258 | [[package]] 3259 | name = "syn" 3260 | version = "2.0.38" 3261 | source = "registry+https://github.com/rust-lang/crates.io-index" 3262 | checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b" 3263 | dependencies = [ 3264 | "proc-macro2", 3265 | "quote", 3266 | "unicode-ident", 3267 | ] 3268 | 3269 | [[package]] 3270 | name = "system-configuration" 3271 | version = "0.5.1" 3272 | source = "registry+https://github.com/rust-lang/crates.io-index" 3273 | checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7" 3274 | dependencies = [ 3275 | "bitflags 1.3.2", 3276 | "core-foundation", 3277 | "system-configuration-sys", 3278 | ] 3279 | 3280 | [[package]] 3281 | name = "system-configuration-sys" 3282 | version = "0.5.0" 3283 | source = "registry+https://github.com/rust-lang/crates.io-index" 3284 | checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9" 3285 | dependencies = [ 3286 | "core-foundation-sys", 3287 | "libc", 3288 | ] 3289 | 3290 | [[package]] 3291 | name = "tap" 3292 | version = "1.0.1" 3293 | source = "registry+https://github.com/rust-lang/crates.io-index" 3294 | checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" 3295 | 3296 | [[package]] 3297 | name = "tempfile" 3298 | version = "3.8.1" 3299 | source = "registry+https://github.com/rust-lang/crates.io-index" 3300 | checksum = "7ef1adac450ad7f4b3c28589471ade84f25f731a7a0fe30d71dfa9f60fd808e5" 3301 | dependencies = [ 3302 | "cfg-if", 3303 | "fastrand", 3304 | "redox_syscall 0.4.1", 3305 | "rustix", 3306 | "windows-sys", 3307 | ] 3308 | 3309 | [[package]] 3310 | name = "term" 3311 | version = "0.7.0" 3312 | source = "registry+https://github.com/rust-lang/crates.io-index" 3313 | checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f" 3314 | dependencies = [ 3315 | "dirs-next", 3316 | "rustversion", 3317 | "winapi", 3318 | ] 3319 | 3320 | [[package]] 3321 | name = "thiserror" 3322 | version = "1.0.50" 3323 | source = "registry+https://github.com/rust-lang/crates.io-index" 3324 | checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2" 3325 | dependencies = [ 3326 | "thiserror-impl", 3327 | ] 3328 | 3329 | [[package]] 3330 | name = "thiserror-impl" 3331 | version = "1.0.50" 3332 | source = "registry+https://github.com/rust-lang/crates.io-index" 3333 | checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8" 3334 | dependencies = [ 3335 | "proc-macro2", 3336 | "quote", 3337 | "syn 2.0.38", 3338 | ] 3339 | 3340 | [[package]] 3341 | name = "threadpool" 3342 | version = "1.8.1" 3343 | source = "registry+https://github.com/rust-lang/crates.io-index" 3344 | checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa" 3345 | dependencies = [ 3346 | "num_cpus", 3347 | ] 3348 | 3349 | [[package]] 3350 | name = "time" 3351 | version = "0.3.30" 3352 | source = "registry+https://github.com/rust-lang/crates.io-index" 3353 | checksum = "c4a34ab300f2dee6e562c10a046fc05e358b29f9bf92277f30c3c8d82275f6f5" 3354 | dependencies = [ 3355 | "deranged", 3356 | "itoa", 3357 | "powerfmt", 3358 | "serde", 3359 | "time-core", 3360 | "time-macros", 3361 | ] 3362 | 3363 | [[package]] 3364 | name = "time-core" 3365 | version = "0.1.2" 3366 | source = "registry+https://github.com/rust-lang/crates.io-index" 3367 | checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" 3368 | 3369 | [[package]] 3370 | name = "time-macros" 3371 | version = "0.2.15" 3372 | source = "registry+https://github.com/rust-lang/crates.io-index" 3373 | checksum = "4ad70d68dba9e1f8aceda7aa6711965dfec1cac869f311a51bd08b3a2ccbce20" 3374 | dependencies = [ 3375 | "time-core", 3376 | ] 3377 | 3378 | [[package]] 3379 | name = "tiny-keccak" 3380 | version = "2.0.2" 3381 | source = "registry+https://github.com/rust-lang/crates.io-index" 3382 | checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" 3383 | dependencies = [ 3384 | "crunchy", 3385 | ] 3386 | 3387 | [[package]] 3388 | name = "tinyvec" 3389 | version = "1.6.0" 3390 | source = "registry+https://github.com/rust-lang/crates.io-index" 3391 | checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" 3392 | dependencies = [ 3393 | "tinyvec_macros", 3394 | ] 3395 | 3396 | [[package]] 3397 | name = "tinyvec_macros" 3398 | version = "0.1.1" 3399 | source = "registry+https://github.com/rust-lang/crates.io-index" 3400 | checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" 3401 | 3402 | [[package]] 3403 | name = "tokio" 3404 | version = "1.33.0" 3405 | source = "registry+https://github.com/rust-lang/crates.io-index" 3406 | checksum = "4f38200e3ef7995e5ef13baec2f432a6da0aa9ac495b2c0e8f3b7eec2c92d653" 3407 | dependencies = [ 3408 | "backtrace", 3409 | "bytes", 3410 | "libc", 3411 | "mio", 3412 | "num_cpus", 3413 | "pin-project-lite", 3414 | "socket2 0.5.5", 3415 | "tokio-macros", 3416 | "windows-sys", 3417 | ] 3418 | 3419 | [[package]] 3420 | name = "tokio-macros" 3421 | version = "2.1.0" 3422 | source = "registry+https://github.com/rust-lang/crates.io-index" 3423 | checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e" 3424 | dependencies = [ 3425 | "proc-macro2", 3426 | "quote", 3427 | "syn 2.0.38", 3428 | ] 3429 | 3430 | [[package]] 3431 | name = "tokio-rustls" 3432 | version = "0.24.1" 3433 | source = "registry+https://github.com/rust-lang/crates.io-index" 3434 | checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" 3435 | dependencies = [ 3436 | "rustls", 3437 | "tokio", 3438 | ] 3439 | 3440 | [[package]] 3441 | name = "tokio-tungstenite" 3442 | version = "0.20.1" 3443 | source = "registry+https://github.com/rust-lang/crates.io-index" 3444 | checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c" 3445 | dependencies = [ 3446 | "futures-util", 3447 | "log", 3448 | "rustls", 3449 | "tokio", 3450 | "tokio-rustls", 3451 | "tungstenite", 3452 | "webpki-roots", 3453 | ] 3454 | 3455 | [[package]] 3456 | name = "tokio-util" 3457 | version = "0.7.10" 3458 | source = "registry+https://github.com/rust-lang/crates.io-index" 3459 | checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15" 3460 | dependencies = [ 3461 | "bytes", 3462 | "futures-core", 3463 | "futures-sink", 3464 | "pin-project-lite", 3465 | "tokio", 3466 | "tracing", 3467 | ] 3468 | 3469 | [[package]] 3470 | name = "toml" 3471 | version = "0.7.8" 3472 | source = "registry+https://github.com/rust-lang/crates.io-index" 3473 | checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257" 3474 | dependencies = [ 3475 | "serde", 3476 | "serde_spanned", 3477 | "toml_datetime", 3478 | "toml_edit 0.19.15", 3479 | ] 3480 | 3481 | [[package]] 3482 | name = "toml_datetime" 3483 | version = "0.6.5" 3484 | source = "registry+https://github.com/rust-lang/crates.io-index" 3485 | checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1" 3486 | dependencies = [ 3487 | "serde", 3488 | ] 3489 | 3490 | [[package]] 3491 | name = "toml_edit" 3492 | version = "0.19.15" 3493 | source = "registry+https://github.com/rust-lang/crates.io-index" 3494 | checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421" 3495 | dependencies = [ 3496 | "indexmap 2.1.0", 3497 | "serde", 3498 | "serde_spanned", 3499 | "toml_datetime", 3500 | "winnow", 3501 | ] 3502 | 3503 | [[package]] 3504 | name = "toml_edit" 3505 | version = "0.20.7" 3506 | source = "registry+https://github.com/rust-lang/crates.io-index" 3507 | checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81" 3508 | dependencies = [ 3509 | "indexmap 2.1.0", 3510 | "toml_datetime", 3511 | "winnow", 3512 | ] 3513 | 3514 | [[package]] 3515 | name = "tower-service" 3516 | version = "0.3.2" 3517 | source = "registry+https://github.com/rust-lang/crates.io-index" 3518 | checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" 3519 | 3520 | [[package]] 3521 | name = "tracing" 3522 | version = "0.1.40" 3523 | source = "registry+https://github.com/rust-lang/crates.io-index" 3524 | checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" 3525 | dependencies = [ 3526 | "pin-project-lite", 3527 | "tracing-attributes", 3528 | "tracing-core", 3529 | ] 3530 | 3531 | [[package]] 3532 | name = "tracing-attributes" 3533 | version = "0.1.27" 3534 | source = "registry+https://github.com/rust-lang/crates.io-index" 3535 | checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" 3536 | dependencies = [ 3537 | "proc-macro2", 3538 | "quote", 3539 | "syn 2.0.38", 3540 | ] 3541 | 3542 | [[package]] 3543 | name = "tracing-core" 3544 | version = "0.1.32" 3545 | source = "registry+https://github.com/rust-lang/crates.io-index" 3546 | checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" 3547 | dependencies = [ 3548 | "once_cell", 3549 | ] 3550 | 3551 | [[package]] 3552 | name = "tracing-futures" 3553 | version = "0.2.5" 3554 | source = "registry+https://github.com/rust-lang/crates.io-index" 3555 | checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2" 3556 | dependencies = [ 3557 | "pin-project", 3558 | "tracing", 3559 | ] 3560 | 3561 | [[package]] 3562 | name = "try-lock" 3563 | version = "0.2.4" 3564 | source = "registry+https://github.com/rust-lang/crates.io-index" 3565 | checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed" 3566 | 3567 | [[package]] 3568 | name = "tungstenite" 3569 | version = "0.20.1" 3570 | source = "registry+https://github.com/rust-lang/crates.io-index" 3571 | checksum = "9e3dac10fd62eaf6617d3a904ae222845979aec67c615d1c842b4002c7666fb9" 3572 | dependencies = [ 3573 | "byteorder", 3574 | "bytes", 3575 | "data-encoding", 3576 | "http", 3577 | "httparse", 3578 | "log", 3579 | "rand", 3580 | "rustls", 3581 | "sha1", 3582 | "thiserror", 3583 | "url", 3584 | "utf-8", 3585 | ] 3586 | 3587 | [[package]] 3588 | name = "typenum" 3589 | version = "1.17.0" 3590 | source = "registry+https://github.com/rust-lang/crates.io-index" 3591 | checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" 3592 | 3593 | [[package]] 3594 | name = "uint" 3595 | version = "0.9.5" 3596 | source = "registry+https://github.com/rust-lang/crates.io-index" 3597 | checksum = "76f64bba2c53b04fcab63c01a7d7427eadc821e3bc48c34dc9ba29c501164b52" 3598 | dependencies = [ 3599 | "byteorder", 3600 | "crunchy", 3601 | "hex", 3602 | "static_assertions", 3603 | ] 3604 | 3605 | [[package]] 3606 | name = "unarray" 3607 | version = "0.1.4" 3608 | source = "registry+https://github.com/rust-lang/crates.io-index" 3609 | checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" 3610 | 3611 | [[package]] 3612 | name = "unicode-bidi" 3613 | version = "0.3.13" 3614 | source = "registry+https://github.com/rust-lang/crates.io-index" 3615 | checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460" 3616 | 3617 | [[package]] 3618 | name = "unicode-ident" 3619 | version = "1.0.12" 3620 | source = "registry+https://github.com/rust-lang/crates.io-index" 3621 | checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" 3622 | 3623 | [[package]] 3624 | name = "unicode-normalization" 3625 | version = "0.1.22" 3626 | source = "registry+https://github.com/rust-lang/crates.io-index" 3627 | checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921" 3628 | dependencies = [ 3629 | "tinyvec", 3630 | ] 3631 | 3632 | [[package]] 3633 | name = "unicode-xid" 3634 | version = "0.2.4" 3635 | source = "registry+https://github.com/rust-lang/crates.io-index" 3636 | checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c" 3637 | 3638 | [[package]] 3639 | name = "untrusted" 3640 | version = "0.7.1" 3641 | source = "registry+https://github.com/rust-lang/crates.io-index" 3642 | checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a" 3643 | 3644 | [[package]] 3645 | name = "untrusted" 3646 | version = "0.9.0" 3647 | source = "registry+https://github.com/rust-lang/crates.io-index" 3648 | checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" 3649 | 3650 | [[package]] 3651 | name = "url" 3652 | version = "2.4.1" 3653 | source = "registry+https://github.com/rust-lang/crates.io-index" 3654 | checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5" 3655 | dependencies = [ 3656 | "form_urlencoded", 3657 | "idna", 3658 | "percent-encoding", 3659 | ] 3660 | 3661 | [[package]] 3662 | name = "utf-8" 3663 | version = "0.7.6" 3664 | source = "registry+https://github.com/rust-lang/crates.io-index" 3665 | checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" 3666 | 3667 | [[package]] 3668 | name = "uuid" 3669 | version = "0.8.2" 3670 | source = "registry+https://github.com/rust-lang/crates.io-index" 3671 | checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7" 3672 | dependencies = [ 3673 | "getrandom", 3674 | "serde", 3675 | ] 3676 | 3677 | [[package]] 3678 | name = "valuable" 3679 | version = "0.1.0" 3680 | source = "registry+https://github.com/rust-lang/crates.io-index" 3681 | checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" 3682 | 3683 | [[package]] 3684 | name = "version_check" 3685 | version = "0.9.4" 3686 | source = "registry+https://github.com/rust-lang/crates.io-index" 3687 | checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" 3688 | 3689 | [[package]] 3690 | name = "walkdir" 3691 | version = "2.4.0" 3692 | source = "registry+https://github.com/rust-lang/crates.io-index" 3693 | checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee" 3694 | dependencies = [ 3695 | "same-file", 3696 | "winapi-util", 3697 | ] 3698 | 3699 | [[package]] 3700 | name = "want" 3701 | version = "0.3.1" 3702 | source = "registry+https://github.com/rust-lang/crates.io-index" 3703 | checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" 3704 | dependencies = [ 3705 | "try-lock", 3706 | ] 3707 | 3708 | [[package]] 3709 | name = "wasi" 3710 | version = "0.11.0+wasi-snapshot-preview1" 3711 | source = "registry+https://github.com/rust-lang/crates.io-index" 3712 | checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" 3713 | 3714 | [[package]] 3715 | name = "wasm-bindgen" 3716 | version = "0.2.88" 3717 | source = "registry+https://github.com/rust-lang/crates.io-index" 3718 | checksum = "7daec296f25a1bae309c0cd5c29c4b260e510e6d813c286b19eaadf409d40fce" 3719 | dependencies = [ 3720 | "cfg-if", 3721 | "wasm-bindgen-macro", 3722 | ] 3723 | 3724 | [[package]] 3725 | name = "wasm-bindgen-backend" 3726 | version = "0.2.88" 3727 | source = "registry+https://github.com/rust-lang/crates.io-index" 3728 | checksum = "e397f4664c0e4e428e8313a469aaa58310d302159845980fd23b0f22a847f217" 3729 | dependencies = [ 3730 | "bumpalo", 3731 | "log", 3732 | "once_cell", 3733 | "proc-macro2", 3734 | "quote", 3735 | "syn 2.0.38", 3736 | "wasm-bindgen-shared", 3737 | ] 3738 | 3739 | [[package]] 3740 | name = "wasm-bindgen-futures" 3741 | version = "0.4.38" 3742 | source = "registry+https://github.com/rust-lang/crates.io-index" 3743 | checksum = "9afec9963e3d0994cac82455b2b3502b81a7f40f9a0d32181f7528d9f4b43e02" 3744 | dependencies = [ 3745 | "cfg-if", 3746 | "js-sys", 3747 | "wasm-bindgen", 3748 | "web-sys", 3749 | ] 3750 | 3751 | [[package]] 3752 | name = "wasm-bindgen-macro" 3753 | version = "0.2.88" 3754 | source = "registry+https://github.com/rust-lang/crates.io-index" 3755 | checksum = "5961017b3b08ad5f3fe39f1e79877f8ee7c23c5e5fd5eb80de95abc41f1f16b2" 3756 | dependencies = [ 3757 | "quote", 3758 | "wasm-bindgen-macro-support", 3759 | ] 3760 | 3761 | [[package]] 3762 | name = "wasm-bindgen-macro-support" 3763 | version = "0.2.88" 3764 | source = "registry+https://github.com/rust-lang/crates.io-index" 3765 | checksum = "c5353b8dab669f5e10f5bd76df26a9360c748f054f862ff5f3f8aae0c7fb3907" 3766 | dependencies = [ 3767 | "proc-macro2", 3768 | "quote", 3769 | "syn 2.0.38", 3770 | "wasm-bindgen-backend", 3771 | "wasm-bindgen-shared", 3772 | ] 3773 | 3774 | [[package]] 3775 | name = "wasm-bindgen-shared" 3776 | version = "0.2.88" 3777 | source = "registry+https://github.com/rust-lang/crates.io-index" 3778 | checksum = "0d046c5d029ba91a1ed14da14dca44b68bf2f124cfbaf741c54151fdb3e0750b" 3779 | 3780 | [[package]] 3781 | name = "web-sys" 3782 | version = "0.3.65" 3783 | source = "registry+https://github.com/rust-lang/crates.io-index" 3784 | checksum = "5db499c5f66323272151db0e666cd34f78617522fb0c1604d31a27c50c206a85" 3785 | dependencies = [ 3786 | "js-sys", 3787 | "wasm-bindgen", 3788 | ] 3789 | 3790 | [[package]] 3791 | name = "webpki-roots" 3792 | version = "0.25.2" 3793 | source = "registry+https://github.com/rust-lang/crates.io-index" 3794 | checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc" 3795 | 3796 | [[package]] 3797 | name = "which" 3798 | version = "4.4.2" 3799 | source = "registry+https://github.com/rust-lang/crates.io-index" 3800 | checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7" 3801 | dependencies = [ 3802 | "either", 3803 | "home", 3804 | "once_cell", 3805 | "rustix", 3806 | ] 3807 | 3808 | [[package]] 3809 | name = "winapi" 3810 | version = "0.3.9" 3811 | source = "registry+https://github.com/rust-lang/crates.io-index" 3812 | checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" 3813 | dependencies = [ 3814 | "winapi-i686-pc-windows-gnu", 3815 | "winapi-x86_64-pc-windows-gnu", 3816 | ] 3817 | 3818 | [[package]] 3819 | name = "winapi-i686-pc-windows-gnu" 3820 | version = "0.4.0" 3821 | source = "registry+https://github.com/rust-lang/crates.io-index" 3822 | checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" 3823 | 3824 | [[package]] 3825 | name = "winapi-util" 3826 | version = "0.1.6" 3827 | source = "registry+https://github.com/rust-lang/crates.io-index" 3828 | checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596" 3829 | dependencies = [ 3830 | "winapi", 3831 | ] 3832 | 3833 | [[package]] 3834 | name = "winapi-x86_64-pc-windows-gnu" 3835 | version = "0.4.0" 3836 | source = "registry+https://github.com/rust-lang/crates.io-index" 3837 | checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" 3838 | 3839 | [[package]] 3840 | name = "windows-sys" 3841 | version = "0.48.0" 3842 | source = "registry+https://github.com/rust-lang/crates.io-index" 3843 | checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" 3844 | dependencies = [ 3845 | "windows-targets", 3846 | ] 3847 | 3848 | [[package]] 3849 | name = "windows-targets" 3850 | version = "0.48.5" 3851 | source = "registry+https://github.com/rust-lang/crates.io-index" 3852 | checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" 3853 | dependencies = [ 3854 | "windows_aarch64_gnullvm", 3855 | "windows_aarch64_msvc", 3856 | "windows_i686_gnu", 3857 | "windows_i686_msvc", 3858 | "windows_x86_64_gnu", 3859 | "windows_x86_64_gnullvm", 3860 | "windows_x86_64_msvc", 3861 | ] 3862 | 3863 | [[package]] 3864 | name = "windows_aarch64_gnullvm" 3865 | version = "0.48.5" 3866 | source = "registry+https://github.com/rust-lang/crates.io-index" 3867 | checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" 3868 | 3869 | [[package]] 3870 | name = "windows_aarch64_msvc" 3871 | version = "0.48.5" 3872 | source = "registry+https://github.com/rust-lang/crates.io-index" 3873 | checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" 3874 | 3875 | [[package]] 3876 | name = "windows_i686_gnu" 3877 | version = "0.48.5" 3878 | source = "registry+https://github.com/rust-lang/crates.io-index" 3879 | checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" 3880 | 3881 | [[package]] 3882 | name = "windows_i686_msvc" 3883 | version = "0.48.5" 3884 | source = "registry+https://github.com/rust-lang/crates.io-index" 3885 | checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" 3886 | 3887 | [[package]] 3888 | name = "windows_x86_64_gnu" 3889 | version = "0.48.5" 3890 | source = "registry+https://github.com/rust-lang/crates.io-index" 3891 | checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" 3892 | 3893 | [[package]] 3894 | name = "windows_x86_64_gnullvm" 3895 | version = "0.48.5" 3896 | source = "registry+https://github.com/rust-lang/crates.io-index" 3897 | checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" 3898 | 3899 | [[package]] 3900 | name = "windows_x86_64_msvc" 3901 | version = "0.48.5" 3902 | source = "registry+https://github.com/rust-lang/crates.io-index" 3903 | checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" 3904 | 3905 | [[package]] 3906 | name = "winnow" 3907 | version = "0.5.19" 3908 | source = "registry+https://github.com/rust-lang/crates.io-index" 3909 | checksum = "829846f3e3db426d4cee4510841b71a8e58aa2a76b1132579487ae430ccd9c7b" 3910 | dependencies = [ 3911 | "memchr", 3912 | ] 3913 | 3914 | [[package]] 3915 | name = "winreg" 3916 | version = "0.50.0" 3917 | source = "registry+https://github.com/rust-lang/crates.io-index" 3918 | checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" 3919 | dependencies = [ 3920 | "cfg-if", 3921 | "windows-sys", 3922 | ] 3923 | 3924 | [[package]] 3925 | name = "ws_stream_wasm" 3926 | version = "0.7.4" 3927 | source = "registry+https://github.com/rust-lang/crates.io-index" 3928 | checksum = "7999f5f4217fe3818726b66257a4475f71e74ffd190776ad053fa159e50737f5" 3929 | dependencies = [ 3930 | "async_io_stream", 3931 | "futures", 3932 | "js-sys", 3933 | "log", 3934 | "pharos", 3935 | "rustc_version", 3936 | "send_wrapper 0.6.0", 3937 | "thiserror", 3938 | "wasm-bindgen", 3939 | "wasm-bindgen-futures", 3940 | "web-sys", 3941 | ] 3942 | 3943 | [[package]] 3944 | name = "wyz" 3945 | version = "0.5.1" 3946 | source = "registry+https://github.com/rust-lang/crates.io-index" 3947 | checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" 3948 | dependencies = [ 3949 | "tap", 3950 | ] 3951 | 3952 | [[package]] 3953 | name = "yansi" 3954 | version = "0.5.1" 3955 | source = "registry+https://github.com/rust-lang/crates.io-index" 3956 | checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec" 3957 | 3958 | [[package]] 3959 | name = "zerocopy" 3960 | version = "0.7.25" 3961 | source = "registry+https://github.com/rust-lang/crates.io-index" 3962 | checksum = "8cd369a67c0edfef15010f980c3cbe45d7f651deac2cd67ce097cd801de16557" 3963 | dependencies = [ 3964 | "zerocopy-derive", 3965 | ] 3966 | 3967 | [[package]] 3968 | name = "zerocopy-derive" 3969 | version = "0.7.25" 3970 | source = "registry+https://github.com/rust-lang/crates.io-index" 3971 | checksum = "c2f140bda219a26ccc0cdb03dba58af72590c53b22642577d88a927bc5c87d6b" 3972 | dependencies = [ 3973 | "proc-macro2", 3974 | "quote", 3975 | "syn 2.0.38", 3976 | ] 3977 | 3978 | [[package]] 3979 | name = "zeroize" 3980 | version = "1.6.0" 3981 | source = "registry+https://github.com/rust-lang/crates.io-index" 3982 | checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9" 3983 | dependencies = [ 3984 | "zeroize_derive", 3985 | ] 3986 | 3987 | [[package]] 3988 | name = "zeroize_derive" 3989 | version = "1.4.2" 3990 | source = "registry+https://github.com/rust-lang/crates.io-index" 3991 | checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" 3992 | dependencies = [ 3993 | "proc-macro2", 3994 | "quote", 3995 | "syn 2.0.38", 3996 | ] 3997 | 3998 | [[package]] 3999 | name = "zip" 4000 | version = "0.6.6" 4001 | source = "registry+https://github.com/rust-lang/crates.io-index" 4002 | checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261" 4003 | dependencies = [ 4004 | "aes", 4005 | "byteorder", 4006 | "bzip2", 4007 | "constant_time_eq", 4008 | "crc32fast", 4009 | "crossbeam-utils", 4010 | "flate2", 4011 | "hmac", 4012 | "pbkdf2 0.11.0", 4013 | "sha1", 4014 | "time", 4015 | "zstd", 4016 | ] 4017 | 4018 | [[package]] 4019 | name = "zstd" 4020 | version = "0.11.2+zstd.1.5.2" 4021 | source = "registry+https://github.com/rust-lang/crates.io-index" 4022 | checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4" 4023 | dependencies = [ 4024 | "zstd-safe", 4025 | ] 4026 | 4027 | [[package]] 4028 | name = "zstd-safe" 4029 | version = "5.0.2+zstd.1.5.2" 4030 | source = "registry+https://github.com/rust-lang/crates.io-index" 4031 | checksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db" 4032 | dependencies = [ 4033 | "libc", 4034 | "zstd-sys", 4035 | ] 4036 | 4037 | [[package]] 4038 | name = "zstd-sys" 4039 | version = "2.0.9+zstd.1.5.5" 4040 | source = "registry+https://github.com/rust-lang/crates.io-index" 4041 | checksum = "9e16efa8a874a0481a574084d34cc26fdb3b99627480f785888deb6386506656" 4042 | dependencies = [ 4043 | "cc", 4044 | "pkg-config", 4045 | ] 4046 | --------------------------------------------------------------------------------