2022-09-14 17:57:48 +00:00
|
|
|
use std::collections::BTreeMap;
|
2022-09-10 04:01:23 +00:00
|
|
|
use std::sync::Arc;
|
2022-09-28 20:48:24 +00:00
|
|
|
use std::time::Duration;
|
2022-09-10 04:01:23 +00:00
|
|
|
|
|
|
|
use ethers::prelude::{Address, U256};
|
|
|
|
use ethers::types::{Transaction, TransactionReceipt, H256};
|
2022-09-12 23:23:37 +00:00
|
|
|
use eyre::{eyre, Result};
|
2022-09-10 04:01:23 +00:00
|
|
|
|
2022-09-29 23:35:43 +00:00
|
|
|
use common::errors::BlockNotFoundError;
|
|
|
|
use common::types::BlockTag;
|
2022-09-10 04:01:23 +00:00
|
|
|
use config::Config;
|
|
|
|
use consensus::rpc::nimbus_rpc::NimbusRpc;
|
|
|
|
use consensus::types::{ExecutionPayload, Header};
|
|
|
|
use consensus::ConsensusClient;
|
|
|
|
use execution::evm::Evm;
|
|
|
|
use execution::rpc::http_rpc::HttpRpc;
|
|
|
|
use execution::types::{CallOpts, ExecutionBlock};
|
|
|
|
use execution::ExecutionClient;
|
|
|
|
|
|
|
|
pub struct Node {
|
|
|
|
consensus: ConsensusClient<NimbusRpc>,
|
2022-11-02 19:26:15 +00:00
|
|
|
execution: Arc<ExecutionClient<HttpRpc>>,
|
2022-09-10 04:01:23 +00:00
|
|
|
config: Arc<Config>,
|
2022-09-14 17:57:48 +00:00
|
|
|
payloads: BTreeMap<u64, ExecutionPayload>,
|
|
|
|
finalized_payloads: BTreeMap<u64, ExecutionPayload>,
|
|
|
|
history_size: usize,
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Node {
|
2022-11-03 19:24:17 +00:00
|
|
|
pub fn new(config: Arc<Config>) -> Result<Self> {
|
2022-10-05 17:52:07 +00:00
|
|
|
let consensus_rpc = &config.consensus_rpc;
|
|
|
|
let checkpoint_hash = &config.checkpoint;
|
|
|
|
let execution_rpc = &config.execution_rpc;
|
2022-09-10 04:01:23 +00:00
|
|
|
|
2022-11-03 19:24:17 +00:00
|
|
|
let consensus = ConsensusClient::new(consensus_rpc, checkpoint_hash, config.clone())?;
|
2022-11-02 19:26:15 +00:00
|
|
|
let execution = Arc::new(ExecutionClient::new(execution_rpc)?);
|
2022-09-10 04:01:23 +00:00
|
|
|
|
2022-09-14 17:57:48 +00:00
|
|
|
let payloads = BTreeMap::new();
|
|
|
|
let finalized_payloads = BTreeMap::new();
|
2022-09-10 04:01:23 +00:00
|
|
|
|
|
|
|
Ok(Node {
|
|
|
|
consensus,
|
|
|
|
execution,
|
|
|
|
config,
|
|
|
|
payloads,
|
2022-09-14 17:57:48 +00:00
|
|
|
finalized_payloads,
|
|
|
|
history_size: 64,
|
2022-09-10 04:01:23 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn sync(&mut self) -> Result<()> {
|
|
|
|
self.consensus.sync().await?;
|
2022-09-12 23:23:37 +00:00
|
|
|
self.update_payloads().await
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn advance(&mut self) -> Result<()> {
|
|
|
|
self.consensus.advance().await?;
|
2022-09-12 23:23:37 +00:00
|
|
|
self.update_payloads().await
|
|
|
|
}
|
2022-09-10 04:01:23 +00:00
|
|
|
|
2022-09-28 20:48:24 +00:00
|
|
|
pub fn duration_until_next_update(&self) -> Duration {
|
|
|
|
self.consensus
|
|
|
|
.duration_until_next_update()
|
|
|
|
.to_std()
|
|
|
|
.unwrap()
|
|
|
|
}
|
|
|
|
|
2022-09-12 23:23:37 +00:00
|
|
|
async fn update_payloads(&mut self) -> Result<()> {
|
|
|
|
let latest_header = self.consensus.get_header();
|
|
|
|
let latest_payload = self
|
2022-09-10 04:01:23 +00:00
|
|
|
.consensus
|
2022-09-12 23:23:37 +00:00
|
|
|
.get_execution_payload(&Some(latest_header.slot))
|
2022-09-10 04:01:23 +00:00
|
|
|
.await?;
|
|
|
|
|
2022-09-12 23:23:37 +00:00
|
|
|
let finalized_header = self.consensus.get_finalized_header();
|
|
|
|
let finalized_payload = self
|
|
|
|
.consensus
|
|
|
|
.get_execution_payload(&Some(finalized_header.slot))
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
self.payloads
|
2022-09-14 17:57:48 +00:00
|
|
|
.insert(latest_payload.block_number, latest_payload);
|
|
|
|
self.payloads
|
|
|
|
.insert(finalized_payload.block_number, finalized_payload.clone());
|
|
|
|
self.finalized_payloads
|
2022-09-12 23:23:37 +00:00
|
|
|
.insert(finalized_payload.block_number, finalized_payload);
|
2022-09-10 04:01:23 +00:00
|
|
|
|
2022-09-14 17:57:48 +00:00
|
|
|
while self.payloads.len() > self.history_size {
|
|
|
|
self.payloads.pop_first();
|
|
|
|
}
|
|
|
|
|
2022-11-02 03:52:28 +00:00
|
|
|
// only save one finalized block per epoch
|
|
|
|
// finality updates only occur on epoch boundries
|
2022-09-14 17:57:48 +00:00
|
|
|
while self.finalized_payloads.len() > usize::max(self.history_size / 32, 1) {
|
|
|
|
self.finalized_payloads.pop_first();
|
|
|
|
}
|
|
|
|
|
2022-09-10 04:01:23 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2022-11-02 19:26:15 +00:00
|
|
|
pub async fn call(&self, opts: &CallOpts, block: &BlockTag) -> Result<Vec<u8>> {
|
2022-09-28 21:50:39 +00:00
|
|
|
self.check_blocktag_age(block)?;
|
|
|
|
|
2022-09-10 04:01:23 +00:00
|
|
|
let payload = self.get_payload(block)?;
|
2022-09-14 17:57:48 +00:00
|
|
|
let mut evm = Evm::new(self.execution.clone(), payload.clone(), self.chain_id());
|
2022-11-02 19:26:15 +00:00
|
|
|
evm.call(opts).await
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
|
2022-11-02 19:26:15 +00:00
|
|
|
pub async fn estimate_gas(&self, opts: &CallOpts) -> Result<u64> {
|
2022-09-28 21:50:39 +00:00
|
|
|
self.check_head_age()?;
|
|
|
|
|
2022-09-12 23:23:37 +00:00
|
|
|
let payload = self.get_payload(&BlockTag::Latest)?;
|
2022-09-14 17:57:48 +00:00
|
|
|
let mut evm = Evm::new(self.execution.clone(), payload.clone(), self.chain_id());
|
2022-11-02 19:26:15 +00:00
|
|
|
evm.estimate_gas(opts).await
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
|
2022-09-12 23:23:37 +00:00
|
|
|
pub async fn get_balance(&self, address: &Address, block: &BlockTag) -> Result<U256> {
|
2022-09-28 21:50:39 +00:00
|
|
|
self.check_blocktag_age(block)?;
|
|
|
|
|
2022-09-10 04:01:23 +00:00
|
|
|
let payload = self.get_payload(block)?;
|
2022-09-14 17:57:48 +00:00
|
|
|
let account = self.execution.get_account(&address, None, payload).await?;
|
2022-09-10 04:01:23 +00:00
|
|
|
Ok(account.balance)
|
|
|
|
}
|
|
|
|
|
2022-09-12 23:23:37 +00:00
|
|
|
pub async fn get_nonce(&self, address: &Address, block: &BlockTag) -> Result<u64> {
|
2022-09-28 21:50:39 +00:00
|
|
|
self.check_blocktag_age(block)?;
|
|
|
|
|
2022-09-10 04:01:23 +00:00
|
|
|
let payload = self.get_payload(block)?;
|
2022-09-14 17:57:48 +00:00
|
|
|
let account = self.execution.get_account(&address, None, payload).await?;
|
2022-09-10 04:01:23 +00:00
|
|
|
Ok(account.nonce)
|
|
|
|
}
|
|
|
|
|
2022-09-12 23:23:37 +00:00
|
|
|
pub async fn get_code(&self, address: &Address, block: &BlockTag) -> Result<Vec<u8>> {
|
2022-09-28 21:50:39 +00:00
|
|
|
self.check_blocktag_age(block)?;
|
|
|
|
|
2022-09-10 04:01:23 +00:00
|
|
|
let payload = self.get_payload(block)?;
|
2022-09-23 23:40:01 +00:00
|
|
|
let account = self.execution.get_account(&address, None, payload).await?;
|
|
|
|
Ok(account.code)
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn get_storage_at(&self, address: &Address, slot: H256) -> Result<U256> {
|
2022-09-28 21:50:39 +00:00
|
|
|
self.check_head_age()?;
|
|
|
|
|
2022-09-12 23:23:37 +00:00
|
|
|
let payload = self.get_payload(&BlockTag::Latest)?;
|
2022-09-10 04:01:23 +00:00
|
|
|
let account = self
|
|
|
|
.execution
|
2022-09-14 17:57:48 +00:00
|
|
|
.get_account(address, Some(&[slot]), payload)
|
2022-09-10 04:01:23 +00:00
|
|
|
.await?;
|
2022-09-14 17:57:48 +00:00
|
|
|
|
2022-09-10 04:01:23 +00:00
|
|
|
let value = account.slots.get(&slot);
|
|
|
|
match value {
|
|
|
|
Some(value) => Ok(*value),
|
2022-09-29 23:35:43 +00:00
|
|
|
None => Err(eyre!("slot not found")),
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn send_raw_transaction(&self, bytes: &Vec<u8>) -> Result<H256> {
|
|
|
|
self.execution.send_raw_transaction(bytes).await
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn get_transaction_receipt(
|
|
|
|
&self,
|
|
|
|
tx_hash: &H256,
|
|
|
|
) -> Result<Option<TransactionReceipt>> {
|
|
|
|
self.execution
|
|
|
|
.get_transaction_receipt(tx_hash, &self.payloads)
|
|
|
|
.await
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn get_transaction_by_hash(&self, tx_hash: &H256) -> Result<Option<Transaction>> {
|
|
|
|
self.execution
|
|
|
|
.get_transaction(tx_hash, &self.payloads)
|
|
|
|
.await
|
|
|
|
}
|
|
|
|
|
2022-11-02 03:52:28 +00:00
|
|
|
// assumes tip of 1 gwei to prevent having to prove out every tx in the block
|
2022-09-10 04:01:23 +00:00
|
|
|
pub fn get_gas_price(&self) -> Result<U256> {
|
2022-09-28 21:50:39 +00:00
|
|
|
self.check_head_age()?;
|
|
|
|
|
2022-09-12 23:23:37 +00:00
|
|
|
let payload = self.get_payload(&BlockTag::Latest)?;
|
2022-09-10 04:01:23 +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-11-02 03:52:28 +00:00
|
|
|
// assumes tip of 1 gwei to prevent having to prove out every tx in the block
|
2022-09-10 04:01:23 +00:00
|
|
|
pub fn get_priority_fee(&self) -> Result<U256> {
|
|
|
|
let tip = U256::from(10_u64.pow(9));
|
|
|
|
Ok(tip)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_block_number(&self) -> Result<u64> {
|
2022-09-28 21:50:39 +00:00
|
|
|
self.check_head_age()?;
|
|
|
|
|
2022-09-12 23:23:37 +00:00
|
|
|
let payload = self.get_payload(&BlockTag::Latest)?;
|
2022-09-10 04:01:23 +00:00
|
|
|
Ok(payload.block_number)
|
|
|
|
}
|
|
|
|
|
2022-10-27 17:46:32 +00:00
|
|
|
pub async fn get_block_by_number(
|
|
|
|
&self,
|
|
|
|
block: &BlockTag,
|
|
|
|
full_tx: bool,
|
|
|
|
) -> Result<Option<ExecutionBlock>> {
|
2022-09-28 21:50:39 +00:00
|
|
|
self.check_blocktag_age(block)?;
|
|
|
|
|
2022-09-23 03:19:24 +00:00
|
|
|
match self.get_payload(block) {
|
2022-10-27 17:46:32 +00:00
|
|
|
Ok(payload) => self
|
|
|
|
.execution
|
|
|
|
.get_block(payload, full_tx)
|
|
|
|
.await
|
|
|
|
.map(|b| Some(b)),
|
2022-09-23 03:19:24 +00:00
|
|
|
Err(_) => Ok(None),
|
|
|
|
}
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
|
2022-10-27 17:46:32 +00:00
|
|
|
pub async fn get_block_by_hash(
|
|
|
|
&self,
|
|
|
|
hash: &Vec<u8>,
|
|
|
|
full_tx: bool,
|
|
|
|
) -> Result<Option<ExecutionBlock>> {
|
2022-09-14 17:57:48 +00:00
|
|
|
let payloads = self
|
|
|
|
.payloads
|
|
|
|
.iter()
|
|
|
|
.filter(|entry| &entry.1.block_hash.to_vec() == hash)
|
|
|
|
.collect::<Vec<(&u64, &ExecutionPayload)>>();
|
|
|
|
|
2022-11-02 03:52:28 +00:00
|
|
|
if let Some(payload_entry) = payloads.get(0) {
|
|
|
|
self.execution
|
2022-10-27 17:46:32 +00:00
|
|
|
.get_block(payload_entry.1, full_tx)
|
|
|
|
.await
|
2022-11-02 03:52:28 +00:00
|
|
|
.map(|b| Some(b))
|
|
|
|
} else {
|
|
|
|
Ok(None)
|
2022-09-23 03:19:24 +00:00
|
|
|
}
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn chain_id(&self) -> u64 {
|
2022-10-05 17:52:07 +00:00
|
|
|
self.config.chain.chain_id
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
|
2022-09-28 21:50:39 +00:00
|
|
|
pub fn get_header(&self) -> Result<Header> {
|
|
|
|
self.check_head_age()?;
|
|
|
|
Ok(self.consensus.get_header().clone())
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
|
2022-09-16 19:32:15 +00:00
|
|
|
pub fn get_last_checkpoint(&self) -> Option<Vec<u8>> {
|
|
|
|
self.consensus.last_checkpoint.clone()
|
|
|
|
}
|
|
|
|
|
2022-09-14 17:57:48 +00:00
|
|
|
fn get_payload(&self, block: &BlockTag) -> Result<&ExecutionPayload> {
|
2022-09-10 04:01:23 +00:00
|
|
|
match block {
|
2022-09-12 23:23:37 +00:00
|
|
|
BlockTag::Latest => {
|
2022-09-14 17:57:48 +00:00
|
|
|
let payload = self.payloads.last_key_value();
|
2022-09-29 23:35:43 +00:00
|
|
|
Ok(payload.ok_or(BlockNotFoundError::new(BlockTag::Latest))?.1)
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
2022-09-12 23:23:37 +00:00
|
|
|
BlockTag::Finalized => {
|
2022-09-14 17:57:48 +00:00
|
|
|
let payload = self.finalized_payloads.last_key_value();
|
2022-09-29 23:35:43 +00:00
|
|
|
Ok(payload
|
|
|
|
.ok_or(BlockNotFoundError::new(BlockTag::Finalized))?
|
|
|
|
.1)
|
2022-09-12 23:23:37 +00:00
|
|
|
}
|
|
|
|
BlockTag::Number(num) => {
|
2022-09-14 17:57:48 +00:00
|
|
|
let payload = self.payloads.get(num);
|
2022-09-29 23:35:43 +00:00
|
|
|
payload.ok_or(BlockNotFoundError::new(BlockTag::Number(*num)).into())
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-09-28 21:50:39 +00:00
|
|
|
|
|
|
|
fn check_head_age(&self) -> Result<()> {
|
|
|
|
let synced_slot = self.consensus.get_header().slot;
|
|
|
|
let expected_slot = self.consensus.expected_current_slot();
|
|
|
|
let slot_delay = expected_slot - synced_slot;
|
|
|
|
|
|
|
|
if slot_delay > 10 {
|
2022-09-29 23:35:43 +00:00
|
|
|
return Err(eyre!("out of sync"));
|
2022-09-28 21:50:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_blocktag_age(&self, block: &BlockTag) -> Result<()> {
|
|
|
|
match block {
|
|
|
|
BlockTag::Latest => self.check_head_age(),
|
|
|
|
BlockTag::Finalized => Ok(()),
|
|
|
|
BlockTag::Number(_) => Ok(()),
|
|
|
|
}
|
|
|
|
}
|
2022-09-10 04:01:23 +00:00
|
|
|
}
|