Struct Cast 

pub struct Cast<P> {
    pub(crate) provider: P,
}

Fields

provider: P

Implementations

impl<P: Provider<AnyNetwork> + Clone + Unpin> Cast<P>

pub fn new(provider: P) -> Self

Creates a new Cast instance from the provided client

Example

use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);

pub async fn call( &self, req: &WithOtherFields<TransactionRequest>, func: Option<&Function>, block: Option<BlockId>, state_override: Option<StateOverride>, block_override: Option<BlockOverrides>, ) -> Result<String>

Makes a read-only call to the specified address

Example

use alloy_primitives::{Address, U256, Bytes};
use alloy_rpc_types::{TransactionRequest, BlockOverrides, state::{StateOverride, AccountOverride}};
use alloy_serde::WithOtherFields;
use cast::Cast;
use alloy_provider::{RootProvider, ProviderBuilder, network::AnyNetwork};
use std::{str::FromStr, collections::HashMap};
use alloy_rpc_types::state::StateOverridesBuilder;
use alloy_sol_types::{sol, SolCall};

sol!(
    function greeting(uint256 i) public returns (string);
);

let alloy_provider = ProviderBuilder::<_,_, AnyNetwork>::default().connect("http://localhost:8545").await?;;
let to = Address::from_str("0xB3C95ff08316fb2F2e3E52Ee82F8e7b605Aa1304")?;
let greeting = greetingCall { i: U256::from(5) }.abi_encode();
let bytes = Bytes::from_iter(greeting.iter());
let tx = TransactionRequest::default().to(to).input(bytes.into());
let tx = WithOtherFields::new(tx);

// Create state overrides
let mut state_override = StateOverride::default();
let mut account_override = AccountOverride::default();
account_override.balance = Some(U256::from(1000));
state_override.insert(to, account_override);
let state_override_object = StateOverridesBuilder::default().build();
let block_override_object = BlockOverrides::default();

let cast = Cast::new(alloy_provider);
let data = cast.call(&tx, None, None, Some(state_override_object), Some(block_override_object)).await?;
println!("{}", data);

pub async fn access_list( &self, req: &WithOtherFields<TransactionRequest>, block: Option<BlockId>, ) -> Result<String>

Generates an access list for the specified transaction

Example

use cast::{Cast};
use alloy_primitives::{Address, U256, Bytes};
use alloy_rpc_types::{TransactionRequest};
use alloy_serde::WithOtherFields;
use alloy_provider::{RootProvider, ProviderBuilder, network::AnyNetwork};
use std::str::FromStr;
use alloy_sol_types::{sol, SolCall};

sol!(
    function greeting(uint256 i) public returns (string);
);

let provider = ProviderBuilder::<_,_, AnyNetwork>::default().connect("http://localhost:8545").await?;;
let to = Address::from_str("0xB3C95ff08316fb2F2e3E52Ee82F8e7b605Aa1304")?;
let greeting = greetingCall { i: U256::from(5) }.abi_encode();
let bytes = Bytes::from_iter(greeting.iter());
let tx = TransactionRequest::default().to(to).input(bytes.into());
let tx = WithOtherFields::new(tx);
let cast = Cast::new(&provider);
let access_list = cast.access_list(&tx, None).await?;
println!("{}", access_list);

pub async fn balance( &self, who: Address, block: Option<BlockId>, ) -> Result<U256>

pub async fn send( &self, tx: WithOtherFields<TransactionRequest>, ) -> Result<PendingTransactionBuilder<AnyNetwork>>

Sends a transaction to the specified address

Example

use cast::{Cast};
use alloy_primitives::{Address, U256, Bytes};
use alloy_serde::WithOtherFields;
use alloy_rpc_types::{TransactionRequest};
use alloy_provider::{RootProvider, ProviderBuilder, network::AnyNetwork};
use std::str::FromStr;
use alloy_sol_types::{sol, SolCall};

sol!(
    function greet(string greeting) public;
);

let provider = ProviderBuilder::<_,_, AnyNetwork>::default().connect("http://localhost:8545").await?;;
let from = Address::from_str("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")?;
let to = Address::from_str("0xB3C95ff08316fb2F2e3E52Ee82F8e7b605Aa1304")?;
let greeting = greetCall { greeting: "hello".to_string() }.abi_encode();
let bytes = Bytes::from_iter(greeting.iter());
let gas = U256::from_str("200000").unwrap();
let value = U256::from_str("1").unwrap();
let nonce = U256::from_str("1").unwrap();
let tx = TransactionRequest::default().to(to).input(bytes.into()).from(from);
let tx = WithOtherFields::new(tx);
let cast = Cast::new(provider);
let data = cast.send(tx).await?;
println!("{:#?}", data);

pub async fn publish( &self, raw_tx: String, ) -> Result<PendingTransactionBuilder<AnyNetwork>>

Publishes a raw transaction to the network

Example

use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let res = cast.publish("0x1234".to_string()).await?;
println!("{:?}", res);

pub async fn send_sync( &self, tx: WithOtherFields<TransactionRequest>, ) -> Result<String>

Sends a transaction and waits for receipt synchronously

pub(crate) fn format_receipt( &self, receipt: TransactionReceiptWithRevertReason, field: Option<String>, ) -> Result<String>

Helper method to format transaction receipts consistently

pub async fn block<B: Into<BlockId>>( &self, block: B, full: bool, fields: Vec<String>, raw: bool, ) -> Result<String>

Example

use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let block = cast.block(5, true, vec![], false).await?;
println!("{}", block);

pub(crate) async fn block_field_as_num<B: Into<BlockId>>( &self, block: B, field: String, ) -> Result<U256>

pub async fn base_fee<B: Into<BlockId>>(&self, block: B) -> Result<U256>

pub async fn age<B: Into<BlockId>>(&self, block: B) -> Result<String>

pub async fn timestamp<B: Into<BlockId>>(&self, block: B) -> Result<U256>

pub async fn chain(&self) -> Result<&str>

pub async fn chain_id(&self) -> Result<u64>

pub async fn block_number(&self) -> Result<u64>

pub async fn gas_price(&self) -> Result<u128>

pub async fn nonce(&self, who: Address, block: Option<BlockId>) -> Result<u64>

Example

use alloy_primitives::Address;
use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;
use std::str::FromStr;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let addr = Address::from_str("0x7eD52863829AB99354F3a0503A622e82AcD5F7d3")?;
let nonce = cast.nonce(addr, None).await?;
println!("{}", nonce);

pub async fn codehash( &self, who: Address, slots: Vec<B256>, block: Option<BlockId>, ) -> Result<String>

#Example

use alloy_primitives::{Address, FixedBytes};
use alloy_provider::{network::AnyNetwork, ProviderBuilder, RootProvider};
use cast::Cast;
use std::str::FromStr;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let addr = Address::from_str("0x7eD52863829AB99354F3a0503A622e82AcD5F7d3")?;
let slots = vec![FixedBytes::from_str("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")?];
let codehash = cast.codehash(addr, slots, None).await?;
println!("{}", codehash);

pub async fn storage_root( &self, who: Address, slots: Vec<B256>, block: Option<BlockId>, ) -> Result<String>

#Example

use alloy_primitives::{Address, FixedBytes};
use alloy_provider::{network::AnyNetwork, ProviderBuilder, RootProvider};
use cast::Cast;
use std::str::FromStr;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let addr = Address::from_str("0x7eD52863829AB99354F3a0503A622e82AcD5F7d3")?;
let slots = vec![FixedBytes::from_str("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")?];
let storage_root = cast.storage_root(addr, slots, None).await?;
println!("{}", storage_root);

pub async fn implementation( &self, who: Address, is_beacon: bool, block: Option<BlockId>, ) -> Result<String>

Example

use alloy_primitives::Address;
use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;
use std::str::FromStr;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let addr = Address::from_str("0x7eD52863829AB99354F3a0503A622e82AcD5F7d3")?;
let implementation = cast.implementation(addr, false, None).await?;
println!("{}", implementation);

pub async fn admin( &self, who: Address, block: Option<BlockId>, ) -> Result<String>

Example

use alloy_primitives::Address;
use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;
use std::str::FromStr;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let addr = Address::from_str("0x7eD52863829AB99354F3a0503A622e82AcD5F7d3")?;
let admin = cast.admin(addr, None).await?;
println!("{}", admin);

pub async fn compute_address( &self, address: Address, nonce: Option<u64>, ) -> Result<Address>

Example

use alloy_primitives::{Address, U256};
use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;
use std::str::FromStr;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let addr = Address::from_str("7eD52863829AB99354F3a0503A622e82AcD5F7d3")?;
let computed_address = cast.compute_address(addr, None).await?;
println!("Computed address for address {addr}: {computed_address}");

pub async fn code( &self, who: Address, block: Option<BlockId>, disassemble: bool, ) -> Result<String>

Example

use alloy_primitives::Address;
use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;
use std::str::FromStr;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let addr = Address::from_str("0x00000000219ab540356cbb839cbe05303d7705fa")?;
let code = cast.code(addr, None, false).await?;
println!("{}", code);

pub async fn codesize( &self, who: Address, block: Option<BlockId>, ) -> Result<String>

Example

use alloy_primitives::Address;
use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;
use std::str::FromStr;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let addr = Address::from_str("0x00000000219ab540356cbb839cbe05303d7705fa")?;
let codesize = cast.codesize(addr, None).await?;
println!("{}", codesize);

pub async fn transaction( &self, tx_hash: Option<String>, from: Option<NameOrAddress>, nonce: Option<u64>, field: Option<String>, raw: bool, to_request: bool, ) -> Result<String>

Example

use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let tx_hash = "0xf8d1713ea15a81482958fb7ddf884baee8d3bcc478c5f2f604e008dc788ee4fc";
let tx = cast.transaction(Some(tx_hash.to_string()), None, None, None, false, false).await?;
println!("{}", tx);

pub async fn receipt( &self, tx_hash: String, field: Option<String>, confs: u64, timeout: Option<u64>, cast_async: bool, ) -> Result<String>

Example

use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let tx_hash = "0xf8d1713ea15a81482958fb7ddf884baee8d3bcc478c5f2f604e008dc788ee4fc";
let receipt = cast.receipt(tx_hash.to_string(), None, 1, None, false).await?;
println!("{}", receipt);

pub async fn rpc<V>(&self, method: &str, params: V) -> Result<String>

where V: RpcSend,

Perform a raw JSON-RPC request

Example

use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let result = cast
    .rpc("eth_getBalance", &["0xc94770007dda54cF92009BFF0dE90c06F603a09f", "latest"])
    .await?;
println!("{}", result);

pub async fn storage( &self, from: Address, slot: B256, block: Option<BlockId>, ) -> Result<String>

Returns the slot

Example

use alloy_primitives::{Address, B256};
use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use cast::Cast;
use std::str::FromStr;

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);
let addr = Address::from_str("0x00000000006c3852cbEf3e08E8dF289169EdE581")?;
let slot = B256::ZERO;
let storage = cast.storage(addr, slot, None).await?;
println!("{}", storage);

pub async fn filter_logs(&self, filter: Filter) -> Result<String>

pub async fn filter_logs_chunked( &self, filter: Filter, chunk_size: u64, ) -> Result<String>

Retrieves logs using chunked requests to handle large block ranges.

Automatically divides large block ranges into smaller chunks to avoid provider limits and processes them with controlled concurrency to prevent rate limiting.

pub(crate) fn format_logs(logs: Vec<Log>) -> Result<String>

pub(crate) fn extract_block_range(filter: &Filter) -> (Option<u64>, Option<u64>)

pub(crate) async fn get_logs_chunked( &self, filter: &Filter, chunk_size: u64, ) -> Result<Vec<Log>>

where P: Clone + Unpin,

Retrieves logs with automatic chunking fallback.

First tries to fetch logs for the entire range. If that fails, falls back to concurrent chunked requests with rate limiting.

pub(crate) async fn get_logs_chunked_concurrent( &self, filter: &Filter, chunk_size: u64, ) -> Result<Vec<Log>>

where P: Clone + Unpin,

Retrieves logs using concurrent chunked requests with rate limiting.

Divides the block range into chunks and processes them with a maximum of 5 concurrent requests. Falls back to single-block queries if chunks fail.

pub async fn convert_block_number( &self, block: Option<BlockId>, ) -> Result<Option<BlockNumberOrTag>, Error>

Converts a block identifier into a block number.

If the block identifier is a block number, then this function returns the block number. If the block identifier is a block hash, then this function returns the block number of that block hash. If the block identifier is None, then this function returns None.

Example

use alloy_primitives::fixed_bytes;
use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use alloy_rpc_types::{BlockId, BlockNumberOrTag};
use cast::Cast;
use std::{convert::TryFrom, str::FromStr};

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("http://localhost:8545").await?;
let cast = Cast::new(provider);

let block_number = cast.convert_block_number(Some(BlockId::number(5))).await?;
assert_eq!(block_number, Some(BlockNumberOrTag::Number(5)));

let block_number = cast
    .convert_block_number(Some(BlockId::hash(fixed_bytes!(
        "0000000000000000000000000000000000000000000000000000000000001234"
    ))))
    .await?;
assert_eq!(block_number, Some(BlockNumberOrTag::Number(4660)));

let block_number = cast.convert_block_number(None).await?;
assert_eq!(block_number, None);

pub async fn subscribe( &self, filter: Filter, output: &mut dyn Write, ) -> Result<()>

Sets up a subscription to the given filter and writes the logs to the given output.

Example

use alloy_primitives::Address;
use alloy_provider::{ProviderBuilder, RootProvider, network::AnyNetwork};
use alloy_rpc_types::Filter;
use alloy_transport::BoxTransport;
use cast::Cast;
use std::{io, str::FromStr};

let provider =
    ProviderBuilder::<_, _, AnyNetwork>::default().connect("wss://localhost:8545").await?;
let cast = Cast::new(provider);

let filter =
    Filter::new().address(Address::from_str("0x00000000006c3852cbEf3e08E8dF289169EdE581")?);
let mut output = io::stdout();
cast.subscribe(filter, &mut output).await?;

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.