94 lines
3.2 KiB
Rust
94 lines
3.2 KiB
Rust
#![allow(deprecated)]
|
|
|
|
use env_logger::Env;
|
|
use ethers::prelude::*;
|
|
use std::{path::PathBuf, sync::Arc};
|
|
|
|
use helios::{
|
|
client::{Client, ClientBuilder, FileDB},
|
|
config::networks::Network,
|
|
types::{BlockTag, CallOpts},
|
|
};
|
|
|
|
// Generate the type-safe contract bindings with an ABI
|
|
abigen!(
|
|
Renderer,
|
|
r#"[
|
|
function renderBroker(uint256) external view returns (string memory)
|
|
function renderBroker(uint256, uint256) external view returns (string memory)
|
|
]"#,
|
|
event_derives(serde::Deserialize, serde::Serialize)
|
|
);
|
|
|
|
#[tokio::main]
|
|
async fn main() -> eyre::Result<()> {
|
|
env_logger::Builder::from_env(Env::default().default_filter_or("debug")).init();
|
|
|
|
// Load the rpc url using the `MAINNET_RPC_URL` environment variable
|
|
let eth_rpc_url = std::env::var("MAINNET_RPC_URL")?;
|
|
let consensus_rpc = "https://www.lightclientdata.org";
|
|
log::info!("Consensus RPC URL: {}", consensus_rpc);
|
|
|
|
// Construct the client
|
|
let data_dir = PathBuf::from("/tmp/helios");
|
|
let mut client: Client<FileDB> = ClientBuilder::new()
|
|
.network(Network::MAINNET)
|
|
.data_dir(data_dir)
|
|
.consensus_rpc(consensus_rpc)
|
|
.execution_rpc(ð_rpc_url)
|
|
.load_external_fallback()
|
|
.build()?;
|
|
log::info!(
|
|
"[\"{}\"] Client built with external checkpoint fallbacks",
|
|
Network::MAINNET
|
|
);
|
|
|
|
// Start the client
|
|
client.start().await?;
|
|
|
|
// Call the erroneous account method
|
|
// The expected asset is: https://0x8bb9a8baeec177ae55ac410c429cbbbbb9198cac.w3eth.io/renderBroker/5
|
|
// Retrieved by calling `renderBroker(5)` on the contract: https://etherscan.io/address/0x8bb9a8baeec177ae55ac410c429cbbbbb9198cac#code
|
|
let account = "0x8bb9a8baeec177ae55ac410c429cbbbbb9198cac";
|
|
let method = "renderBroker(uint256)";
|
|
let method2 = "renderBroker(uint256, uint256)";
|
|
let argument = U256::from(5);
|
|
let address = account.parse::<Address>()?;
|
|
let block = BlockTag::Latest;
|
|
let provider = Provider::<Http>::try_from(eth_rpc_url)?;
|
|
let render = Renderer::new(address, Arc::new(provider.clone()));
|
|
log::debug!("Context: call @ {account}::{method} <{argument}>");
|
|
|
|
// Call using abigen
|
|
let result = render.render_broker_0(argument).call().await?;
|
|
log::info!(
|
|
"[ABIGEN] {account}::{method} -> Response Length: {:?}",
|
|
result.len()
|
|
);
|
|
let render = Renderer::new(address, Arc::new(provider.clone()));
|
|
let result = render
|
|
.render_broker_1(argument, U256::from(10))
|
|
.call()
|
|
.await?;
|
|
log::info!(
|
|
"[ABIGEN] {account}::{method2} -> Response Length: {:?}",
|
|
result.len()
|
|
);
|
|
|
|
// Call on helios client
|
|
let encoded_call = render.render_broker_0(argument).calldata().unwrap();
|
|
let call_opts = CallOpts {
|
|
from: Some("0xBE0eB53F46cd790Cd13851d5EFf43D12404d33E8".parse::<Address>()?),
|
|
to: Some(address),
|
|
gas: Some(U256::from(U64::MAX.as_u64())),
|
|
gas_price: None,
|
|
value: None,
|
|
data: Some(encoded_call.to_vec()),
|
|
};
|
|
log::debug!("Calling helios client on block: {block:?}");
|
|
let result = client.call(&call_opts, block).await?;
|
|
log::info!("[HELIOS] {account}::{method} ->{:?}", result.len());
|
|
|
|
Ok(())
|
|
}
|