447 lines
16 KiB
Rust
447 lines
16 KiB
Rust
//! Helper functions for turning ether's BlockNumber into numbers and updating incoming queries to match.
|
|
use crate::rpcs::many::Web3Rpcs;
|
|
use crate::{
|
|
errors::{Web3ProxyError, Web3ProxyResult},
|
|
rpcs::blockchain::Web3ProxyBlock,
|
|
};
|
|
use anyhow::Context;
|
|
use derive_more::From;
|
|
use ethers::{
|
|
prelude::{BlockNumber, U64},
|
|
types::H256,
|
|
};
|
|
use serde_json::json;
|
|
use tracing::{error, trace, warn};
|
|
|
|
#[allow(non_snake_case)]
|
|
pub fn BlockNumber_to_U64(block_num: BlockNumber, latest_block: &U64) -> (U64, bool) {
|
|
match block_num {
|
|
BlockNumber::Earliest => (U64::zero(), false),
|
|
BlockNumber::Finalized => {
|
|
warn!("finalized block requested! not yet implemented!");
|
|
(*latest_block - 10, false)
|
|
}
|
|
BlockNumber::Latest => {
|
|
// change "latest" to a number
|
|
(*latest_block, true)
|
|
}
|
|
BlockNumber::Number(x) => {
|
|
// we already have a number
|
|
(x, false)
|
|
}
|
|
BlockNumber::Pending => {
|
|
// modified is false because we want the backend to see "pending"
|
|
// TODO: think more about how to handle Pending
|
|
(*latest_block, false)
|
|
}
|
|
BlockNumber::Safe => {
|
|
warn!("safe block requested! not yet implemented!");
|
|
(*latest_block - 3, false)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Eq, From, PartialEq)]
|
|
pub struct BlockNumAndHash(U64, H256);
|
|
|
|
impl BlockNumAndHash {
|
|
pub fn num(&self) -> &U64 {
|
|
&self.0
|
|
}
|
|
pub fn hash(&self) -> &H256 {
|
|
&self.1
|
|
}
|
|
}
|
|
|
|
impl From<&Web3ProxyBlock> for BlockNumAndHash {
|
|
fn from(value: &Web3ProxyBlock) -> Self {
|
|
let n = *value.number();
|
|
let h = *value.hash();
|
|
|
|
Self(n, h)
|
|
}
|
|
}
|
|
|
|
/// modify params to always have a block hash and not "latest"
|
|
/// TODO: this should replace all block numbers with hashes, not just "latest"
|
|
pub async fn clean_block_number(
|
|
params: &mut serde_json::Value,
|
|
block_param_id: usize,
|
|
latest_block: &Web3ProxyBlock,
|
|
rpcs: &Web3Rpcs,
|
|
) -> Web3ProxyResult<BlockNumAndHash> {
|
|
match params.as_array_mut() {
|
|
None => {
|
|
// TODO: this needs the correct error code in the response
|
|
Err(anyhow::anyhow!("params not an array").into())
|
|
}
|
|
Some(params) => match params.get_mut(block_param_id) {
|
|
None => {
|
|
if params.len() == block_param_id {
|
|
// add the latest block number to the end of the params
|
|
params.push(json!(latest_block.number()));
|
|
} else {
|
|
// don't modify the request. only cache with current block
|
|
// TODO: more useful log that include the
|
|
warn!("unexpected params length");
|
|
}
|
|
|
|
// don't modify params, just cache with the current block
|
|
Ok(latest_block.into())
|
|
}
|
|
Some(x) => {
|
|
// dig into the json value to find a BlockNumber or similar block identifier
|
|
trace!(?x, "inspecting");
|
|
|
|
let (block, change) = if let Some(obj) = x.as_object_mut() {
|
|
// it might be a Map like `{"blockHash": String("0xa5626dc20d3a0a209b1de85521717a3e859698de8ce98bca1b16822b7501f74b")}`
|
|
if let Some(block_hash) = obj.get("blockHash").cloned() {
|
|
let block_hash: H256 =
|
|
serde_json::from_value(block_hash).context("decoding blockHash")?;
|
|
|
|
let block = rpcs
|
|
.block(&block_hash, None, None)
|
|
.await
|
|
.context("fetching block number from hash")?;
|
|
|
|
(BlockNumAndHash::from(&block), false)
|
|
} else {
|
|
return Err(anyhow::anyhow!("blockHash missing").into());
|
|
}
|
|
} else {
|
|
// it might be a string like "latest" or a block number or a block hash
|
|
// TODO: "BlockNumber" needs a better name
|
|
// TODO: move this to a helper function?
|
|
if let Ok(block_num) = serde_json::from_value::<U64>(x.clone()) {
|
|
let (block_hash, _) = rpcs
|
|
.block_hash(&block_num)
|
|
.await
|
|
.context("fetching block hash from number")?;
|
|
|
|
let block = rpcs
|
|
.block(&block_hash, None, None)
|
|
.await
|
|
.context("fetching block from hash")?;
|
|
|
|
// TODO: do true here? will that work for **all** methods on **all** chains? if not we need something smarter
|
|
(BlockNumAndHash::from(&block), false)
|
|
} else if let Ok(block_number) =
|
|
serde_json::from_value::<BlockNumber>(x.clone())
|
|
{
|
|
let (block_num, change) =
|
|
BlockNumber_to_U64(block_number, latest_block.number());
|
|
|
|
if block_num == *latest_block.number() {
|
|
(latest_block.into(), change)
|
|
} else {
|
|
let (block_hash, _) = rpcs
|
|
.block_hash(&block_num)
|
|
.await
|
|
.context("fetching block hash from number")?;
|
|
|
|
let block = rpcs
|
|
.block(&block_hash, None, None)
|
|
.await
|
|
.context("fetching block from hash")?;
|
|
|
|
(BlockNumAndHash::from(&block), change)
|
|
}
|
|
} else if let Ok(block_hash) = serde_json::from_value::<H256>(x.clone()) {
|
|
let block = rpcs
|
|
.block(&block_hash, None, None)
|
|
.await
|
|
.context("fetching block number from hash")?;
|
|
|
|
(BlockNumAndHash::from(&block), false)
|
|
} else {
|
|
return Err(anyhow::anyhow!(
|
|
"param not a block identifier, block number, or block hash"
|
|
)
|
|
.into());
|
|
}
|
|
};
|
|
|
|
// if we changed "latest" to an actual block, update the params to match
|
|
// TODO: should we do hash or number? some functions work with either, but others need a number :cry:
|
|
if change {
|
|
trace!(old=%x, new=%block.num(), "changing block number");
|
|
*x = json!(block.num());
|
|
}
|
|
|
|
Ok(block)
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
/// TODO: change this to also return the hash needed?
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
pub enum CacheMode {
|
|
CacheSuccessForever,
|
|
CacheNever,
|
|
Cache {
|
|
block: BlockNumAndHash,
|
|
/// cache jsonrpc errors (server errors are never cached)
|
|
cache_errors: bool,
|
|
},
|
|
CacheRange {
|
|
from_block: BlockNumAndHash,
|
|
to_block: BlockNumAndHash,
|
|
/// cache jsonrpc errors (server errors are never cached)
|
|
cache_errors: bool,
|
|
},
|
|
}
|
|
|
|
fn get_block_param_id(method: &str) -> Option<usize> {
|
|
match method {
|
|
"debug_traceBlockByHash" => Some(0),
|
|
"debug_traceBlockByNumber" => Some(0),
|
|
"debug_traceCall" => Some(1),
|
|
"debug_traceTransaction" => None,
|
|
"eth_call" => Some(1),
|
|
"eth_estimateGas" => Some(1),
|
|
"eth_feeHistory" => Some(1),
|
|
"eth_getBalance" => Some(1),
|
|
"eth_getBlockReceipts" => Some(0),
|
|
"eth_getBlockTransactionCountByNumber" => Some(0),
|
|
"eth_getCode" => Some(1),
|
|
"eth_getStorageAt" => Some(2),
|
|
"eth_getTransactionByBlockNumberAndIndex" => Some(0),
|
|
"eth_getTransactionCount" => Some(1),
|
|
"eth_getUncleByBlockNumberAndIndex" => Some(0),
|
|
"eth_getUncleCountByBlockNumber" => Some(0),
|
|
"trace_call" => Some(2),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
impl CacheMode {
|
|
pub async fn new(
|
|
method: &str,
|
|
params: &mut serde_json::Value,
|
|
head_block: &Web3ProxyBlock,
|
|
rpcs: &Web3Rpcs,
|
|
) -> Self {
|
|
match Self::try_new(method, params, head_block, rpcs).await {
|
|
Ok(x) => x,
|
|
Err(Web3ProxyError::NoBlocksKnown) => {
|
|
warn!(%method, ?params, "no servers available to get block from params. caching with head block");
|
|
CacheMode::Cache {
|
|
block: head_block.into(),
|
|
cache_errors: true,
|
|
}
|
|
}
|
|
Err(err) => {
|
|
error!(%method, ?params, ?err, "could not get block from params. caching with head block");
|
|
CacheMode::Cache {
|
|
block: head_block.into(),
|
|
cache_errors: true,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn try_new(
|
|
method: &str,
|
|
params: &mut serde_json::Value,
|
|
head_block: &Web3ProxyBlock,
|
|
rpcs: &Web3Rpcs,
|
|
) -> Web3ProxyResult<Self> {
|
|
if matches!(params, serde_json::Value::Null) {
|
|
// no params given. cache with the head block
|
|
return Ok(Self::Cache {
|
|
block: head_block.into(),
|
|
cache_errors: true,
|
|
});
|
|
}
|
|
|
|
match method {
|
|
"debug_traceBlockByHash" => {
|
|
todo!();
|
|
}
|
|
"debug_traceTransaction" => {
|
|
todo!();
|
|
}
|
|
"eth_gasPrice" => Ok(CacheMode::Cache {
|
|
block: head_block.into(),
|
|
cache_errors: false,
|
|
}),
|
|
"eth_getBlockByHash" => {
|
|
// TODO: double check that any node can serve this
|
|
// TODO: can a block change? like what if it gets orphaned?
|
|
// TODO: make sure re-orgs work properly!
|
|
Ok(CacheMode::CacheSuccessForever)
|
|
}
|
|
"eth_getBlockByNumber" => {
|
|
// TODO: double check that any node can serve this
|
|
// TODO: CacheSuccessForever if the block is old enough
|
|
// TODO: make sure re-orgs work properly!
|
|
Ok(CacheMode::Cache {
|
|
block: head_block.into(),
|
|
cache_errors: true,
|
|
})
|
|
}
|
|
"eth_getBlockTransactionCountByHash" => {
|
|
// TODO: double check that any node can serve this
|
|
Ok(CacheMode::CacheSuccessForever)
|
|
}
|
|
"eth_getLogs" => {
|
|
// TODO: think about this more
|
|
// TODO: jsonrpc has a specific code for this
|
|
let obj = params
|
|
.get_mut(0)
|
|
.ok_or_else(|| Web3ProxyError::BadRequest("invalid format. no params".into()))?
|
|
.as_object_mut()
|
|
.ok_or_else(|| {
|
|
Web3ProxyError::BadRequest("invalid format. params not object".into())
|
|
})?;
|
|
|
|
if obj.contains_key("blockHash") {
|
|
Ok(CacheMode::CacheSuccessForever)
|
|
} else {
|
|
let from_block = if let Some(x) = obj.get_mut("fromBlock") {
|
|
// TODO: use .take instead of clone
|
|
// what if its a hash?
|
|
let block_num: BlockNumber = serde_json::from_value(x.clone())?;
|
|
|
|
let (block_num, change) =
|
|
BlockNumber_to_U64(block_num, head_block.number());
|
|
|
|
if change {
|
|
// TODO: include the hash instead of the number?
|
|
trace!("changing fromBlock in eth_getLogs. {} -> {}", x, block_num);
|
|
*x = json!(block_num);
|
|
}
|
|
|
|
let (block_hash, _) = rpcs.block_hash(&block_num).await?;
|
|
|
|
BlockNumAndHash(block_num, block_hash)
|
|
} else {
|
|
BlockNumAndHash(U64::zero(), H256::zero())
|
|
};
|
|
|
|
let to_block = if let Some(x) = obj.get_mut("toBlock") {
|
|
// TODO: use .take instead of clone
|
|
// what if its a hash?
|
|
let block_num: BlockNumber = serde_json::from_value(x.clone())?;
|
|
|
|
let (block_num, change) =
|
|
BlockNumber_to_U64(block_num, head_block.number());
|
|
|
|
if change {
|
|
trace!("changing toBlock in eth_getLogs. {} -> {}", x, block_num);
|
|
*x = json!(block_num);
|
|
}
|
|
|
|
let (block_hash, _) = rpcs.block_hash(&block_num).await?;
|
|
|
|
BlockNumAndHash(block_num, block_hash)
|
|
} else {
|
|
head_block.into()
|
|
};
|
|
|
|
Ok(CacheMode::CacheRange {
|
|
from_block,
|
|
to_block,
|
|
cache_errors: true,
|
|
})
|
|
}
|
|
}
|
|
"eth_getTransactionByHash" => {
|
|
// TODO: not sure how best to look these up
|
|
// try full nodes first. retry will use archive
|
|
Ok(CacheMode::Cache {
|
|
block: head_block.into(),
|
|
cache_errors: true,
|
|
})
|
|
}
|
|
"eth_getTransactionByBlockHashAndIndex" => {
|
|
// TODO: check a Cache of recent hashes
|
|
// try full nodes first. retry will use archive
|
|
Ok(CacheMode::CacheSuccessForever)
|
|
}
|
|
"eth_getTransactionReceipt" => {
|
|
// TODO: not sure how best to look these up
|
|
// try full nodes first. retry will use archive
|
|
Ok(CacheMode::Cache {
|
|
block: head_block.into(),
|
|
cache_errors: true,
|
|
})
|
|
}
|
|
"eth_getUncleByBlockHashAndIndex" => {
|
|
// TODO: check a Cache of recent hashes
|
|
// try full nodes first. retry will use archive
|
|
// TODO: what happens if this block is uncled later?
|
|
Ok(CacheMode::CacheSuccessForever)
|
|
}
|
|
"eth_getUncleCountByBlockHash" => {
|
|
// TODO: check a Cache of recent hashes
|
|
// try full nodes first. retry will use archive
|
|
// TODO: what happens if this block is uncled later?
|
|
Ok(CacheMode::CacheSuccessForever)
|
|
}
|
|
"eth_maxPriorityFeePerGas" => {
|
|
// TODO: this might be too aggressive. i think it can change before a block is mined
|
|
Ok(CacheMode::Cache {
|
|
block: head_block.into(),
|
|
cache_errors: false,
|
|
})
|
|
}
|
|
method => match get_block_param_id(method) {
|
|
Some(block_param_id) => {
|
|
let block =
|
|
clean_block_number(params, block_param_id, head_block, rpcs).await?;
|
|
|
|
Ok(CacheMode::Cache {
|
|
block,
|
|
cache_errors: true,
|
|
})
|
|
}
|
|
None => Err(Web3ProxyError::UnhandledMethod(method.to_string().into())),
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::CacheMode;
|
|
use crate::rpcs::{blockchain::Web3ProxyBlock, many::Web3Rpcs};
|
|
use ethers::types::{Block, H256};
|
|
use serde_json::json;
|
|
use std::sync::Arc;
|
|
|
|
#[test_log::test(tokio::test)]
|
|
async fn test_fee_history() {
|
|
let method = "eth_feeHistory";
|
|
let mut params = json!([4, "latest", [25, 75]]);
|
|
|
|
let head_block = Block {
|
|
number: Some(1.into()),
|
|
hash: Some(H256::random()),
|
|
..Default::default()
|
|
};
|
|
|
|
let head_block = Web3ProxyBlock::try_new(Arc::new(head_block)).unwrap();
|
|
|
|
let (empty, _handle, _ranked_rpc_reciver) =
|
|
Web3Rpcs::spawn(1, None, 1, 1, "test".into(), None)
|
|
.await
|
|
.unwrap();
|
|
|
|
let x = CacheMode::try_new(method, &mut params, &head_block, &empty)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
x,
|
|
CacheMode::Cache {
|
|
block: (&head_block).into(),
|
|
cache_errors: true
|
|
}
|
|
);
|
|
|
|
assert_eq!(params.get(1), Some(&json!(head_block.number())));
|
|
}
|
|
}
|