2022-08-31 21:40:44 +00:00
|
|
|
use std::collections::HashMap;
|
2022-08-27 00:05:12 +00:00
|
|
|
use std::sync::Arc;
|
|
|
|
|
2022-08-21 13:13:56 +00:00
|
|
|
use ethers::prelude::{Address, U256};
|
|
|
|
use eyre::Result;
|
|
|
|
|
2022-08-29 20:54:58 +00:00
|
|
|
use config::Config;
|
2022-08-31 21:40:44 +00:00
|
|
|
use consensus::types::{ExecutionPayload, Header};
|
2022-08-29 17:31:17 +00:00
|
|
|
use consensus::ConsensusClient;
|
|
|
|
use execution::evm::Evm;
|
2022-09-01 19:58:45 +00:00
|
|
|
use execution::types::{CallOpts, ExecutionBlock};
|
2022-08-29 17:31:17 +00:00
|
|
|
use execution::ExecutionClient;
|
2022-08-21 13:13:56 +00:00
|
|
|
|
|
|
|
pub struct Client {
|
|
|
|
consensus: ConsensusClient,
|
2022-08-26 22:13:35 +00:00
|
|
|
execution: ExecutionClient,
|
2022-08-27 00:05:12 +00:00
|
|
|
config: Arc<Config>,
|
2022-08-31 21:40:44 +00:00
|
|
|
payloads: HashMap<u64, ExecutionPayload>,
|
|
|
|
block_head: u64,
|
2022-08-21 13:13:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Client {
|
2022-08-27 00:05:12 +00:00
|
|
|
pub async fn new(config: Arc<Config>) -> Result<Self> {
|
|
|
|
let consensus_rpc = &config.general.consensus_rpc;
|
|
|
|
let checkpoint_hash = &config.general.checkpoint;
|
|
|
|
let execution_rpc = &config.general.execution_rpc;
|
|
|
|
|
|
|
|
let consensus =
|
|
|
|
ConsensusClient::new(consensus_rpc, checkpoint_hash, config.clone()).await?;
|
2022-08-21 13:13:56 +00:00
|
|
|
let execution = ExecutionClient::new(execution_rpc);
|
|
|
|
|
2022-08-31 21:40:44 +00:00
|
|
|
let payloads = HashMap::new();
|
|
|
|
|
2022-08-21 13:13:56 +00:00
|
|
|
Ok(Client {
|
|
|
|
consensus,
|
2022-08-26 22:13:35 +00:00
|
|
|
execution,
|
2022-08-27 00:05:12 +00:00
|
|
|
config,
|
2022-08-31 21:40:44 +00:00
|
|
|
payloads,
|
|
|
|
block_head: 0,
|
2022-08-21 13:13:56 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn sync(&mut self) -> Result<()> {
|
2022-08-31 21:40:44 +00:00
|
|
|
self.consensus.sync().await?;
|
|
|
|
|
|
|
|
let head = self.consensus.get_head();
|
|
|
|
let payload = self
|
|
|
|
.consensus
|
|
|
|
.get_execution_payload(&Some(head.slot))
|
|
|
|
.await?;
|
|
|
|
self.block_head = payload.block_number;
|
|
|
|
self.payloads.insert(payload.block_number, payload);
|
|
|
|
|
|
|
|
Ok(())
|
2022-08-21 13:13:56 +00:00
|
|
|
}
|
|
|
|
|
2022-08-31 00:31:58 +00:00
|
|
|
pub async fn advance(&mut self) -> Result<()> {
|
2022-08-31 21:40:44 +00:00
|
|
|
self.consensus.advance().await?;
|
|
|
|
|
|
|
|
let head = self.consensus.get_head();
|
|
|
|
let payload = self
|
|
|
|
.consensus
|
|
|
|
.get_execution_payload(&Some(head.slot))
|
|
|
|
.await?;
|
|
|
|
self.block_head = payload.block_number;
|
|
|
|
self.payloads.insert(payload.block_number, payload);
|
|
|
|
|
|
|
|
Ok(())
|
2022-08-31 00:31:58 +00:00
|
|
|
}
|
|
|
|
|
2022-09-01 19:58:45 +00:00
|
|
|
pub fn call(&self, opts: &CallOpts, block: &Option<u64>) -> Result<Vec<u8>> {
|
2022-08-31 21:40:44 +00:00
|
|
|
let payload = self.get_payload(block)?;
|
2022-08-24 01:33:48 +00:00
|
|
|
let mut evm = Evm::new(self.execution.clone(), payload);
|
2022-09-01 19:58:45 +00:00
|
|
|
evm.call(opts)
|
2022-08-24 01:33:48 +00:00
|
|
|
}
|
|
|
|
|
2022-09-01 19:58:45 +00:00
|
|
|
pub fn estimate_gas(&self, opts: &CallOpts) -> Result<u64> {
|
2022-08-31 21:40:44 +00:00
|
|
|
let payload = self.get_payload(&None)?;
|
2022-08-27 20:43:27 +00:00
|
|
|
let mut evm = Evm::new(self.execution.clone(), payload);
|
2022-09-01 19:58:45 +00:00
|
|
|
evm.estimate_gas(opts)
|
2022-08-27 20:43:27 +00:00
|
|
|
}
|
|
|
|
|
2022-08-31 21:40:44 +00:00
|
|
|
pub async fn get_balance(&self, address: &Address, block: &Option<u64>) -> Result<U256> {
|
|
|
|
let payload = self.get_payload(block)?;
|
2022-08-21 21:51:11 +00:00
|
|
|
let account = self.execution.get_account(&address, None, &payload).await?;
|
2022-08-21 13:13:56 +00:00
|
|
|
Ok(account.balance)
|
|
|
|
}
|
|
|
|
|
2022-08-31 21:40:44 +00:00
|
|
|
pub async fn get_nonce(&self, address: &Address, block: &Option<u64>) -> Result<U256> {
|
|
|
|
let payload = self.get_payload(block)?;
|
2022-08-21 21:51:11 +00:00
|
|
|
let account = self.execution.get_account(&address, None, &payload).await?;
|
2022-08-21 13:13:56 +00:00
|
|
|
Ok(account.nonce)
|
|
|
|
}
|
|
|
|
|
2022-08-31 21:40:44 +00:00
|
|
|
pub async fn get_code(&self, address: &Address, block: &Option<u64>) -> Result<Vec<u8>> {
|
|
|
|
let payload = self.get_payload(block)?;
|
2022-08-21 16:59:47 +00:00
|
|
|
self.execution.get_code(&address, &payload).await
|
|
|
|
}
|
|
|
|
|
2022-08-26 01:18:47 +00:00
|
|
|
pub async fn get_storage_at(&self, address: &Address, slot: U256) -> Result<U256> {
|
2022-08-31 21:40:44 +00:00
|
|
|
let payload = self.get_payload(&None)?;
|
2022-08-21 21:51:11 +00:00
|
|
|
let account = self
|
|
|
|
.execution
|
|
|
|
.get_account(address, Some(&[slot]), &payload)
|
|
|
|
.await?;
|
|
|
|
let value = account.slots.get(&slot);
|
|
|
|
match value {
|
|
|
|
Some(value) => Ok(*value),
|
|
|
|
None => Err(eyre::eyre!("Slot Not Found")),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-01 21:07:30 +00:00
|
|
|
pub async fn send_raw_transaction(&self, bytes: &Vec<u8>) -> Result<Vec<u8>> {
|
|
|
|
self.execution.send_raw_transaction(bytes).await
|
|
|
|
}
|
|
|
|
|
2022-08-31 21:40:44 +00:00
|
|
|
pub fn get_gas_price(&self) -> Result<U256> {
|
|
|
|
let payload = self.get_payload(&None)?;
|
2022-08-29 15:59:02 +00:00
|
|
|
let base_fee = U256::from_little_endian(&payload.base_fee_per_gas.to_bytes_le());
|
|
|
|
let tip = U256::from(10_u64.pow(9));
|
|
|
|
Ok(base_fee + tip)
|
|
|
|
}
|
|
|
|
|
2022-08-31 21:40:44 +00:00
|
|
|
pub fn get_priority_fee(&self) -> Result<U256> {
|
2022-08-29 15:59:02 +00:00
|
|
|
let tip = U256::from(10_u64.pow(9));
|
|
|
|
Ok(tip)
|
|
|
|
}
|
|
|
|
|
2022-08-31 21:40:44 +00:00
|
|
|
pub fn get_block_number(&self) -> Result<u64> {
|
|
|
|
let payload = self.get_payload(&None)?;
|
2022-08-29 16:06:50 +00:00
|
|
|
Ok(payload.block_number)
|
|
|
|
}
|
|
|
|
|
2022-08-31 21:40:44 +00:00
|
|
|
pub fn get_block_by_number(&self, block: &Option<u64>) -> Result<ExecutionBlock> {
|
|
|
|
let payload = self.get_payload(block)?;
|
|
|
|
self.execution.get_block(&payload)
|
|
|
|
}
|
|
|
|
|
2022-08-27 00:05:12 +00:00
|
|
|
pub fn chain_id(&self) -> u64 {
|
|
|
|
self.config.general.chain_id
|
|
|
|
}
|
|
|
|
|
2022-08-21 13:13:56 +00:00
|
|
|
pub fn get_header(&self) -> &Header {
|
|
|
|
self.consensus.get_head()
|
|
|
|
}
|
2022-08-31 21:40:44 +00:00
|
|
|
|
|
|
|
fn get_payload(&self, block: &Option<u64>) -> Result<ExecutionPayload> {
|
|
|
|
match block {
|
|
|
|
Some(block) => {
|
|
|
|
let payload = self.payloads.get(block);
|
|
|
|
match payload {
|
|
|
|
Some(payload) => Ok(payload.clone()),
|
|
|
|
None => Err(eyre::eyre!("Block Not Found")),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
None => {
|
|
|
|
let payload = self.payloads.get(&self.block_head);
|
|
|
|
match payload {
|
|
|
|
Some(payload) => Ok(payload.clone()),
|
|
|
|
None => Err(eyre::eyre!("Block Not Found")),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-08-21 13:13:56 +00:00
|
|
|
}
|