Struct FoundryNetwork

Source

pub struct FoundryNetwork {
    _private: (),
}

Expand description

Foundry network type.

This network type supports Foundry-specific transaction types, including op-stack deposit transactions, alongside standard Ethereum transaction types.

Note: This is a basic implementation (“for now”) that provides the core Network trait definitions. Full Foundry-specific RPC types will be implemented in future work. Currently, this uses Ethereum’s Network configuration as a compatibility layer.

Fields§

§_private: ()

FoundryNetwork

Struct FoundryNetwork Copy item path

Fields§

Trait Implementations§

impl Clone for FoundryNetwork

fn clone(&self) -> FoundryNetwork

fn clone_from(&mut self, source: &Self)

impl Debug for FoundryNetwork

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Network for FoundryNetwork

type TxType = FoundryTxType

type TxEnvelope = FoundryTxEnvelope

type UnsignedTx = FoundryTypedTx

type ReceiptEnvelope = FoundryReceiptEnvelope

type Header = Header

type TransactionRequest = FoundryTransactionRequest

type TransactionResponse = Transaction<FoundryTxEnvelope>

type ReceiptResponse = FoundryTxReceipt

type HeaderResponse = Header

type BlockResponse = Block<<FoundryNetwork as Network>::TransactionResponse, <FoundryNetwork as Network>::HeaderResponse>

impl TransactionBuilder<FoundryNetwork> for FoundryTransactionRequest

fn prep_for_submission(&mut self)

fn chain_id(&self) -> Option<ChainId>

fn set_chain_id(&mut self, chain_id: ChainId)

fn nonce(&self) -> Option<u64>

fn set_nonce(&mut self, nonce: u64)

fn take_nonce(&mut self) -> Option<u64>

fn input(&self) -> Option<&Bytes>

fn set_input<T: Into<Bytes>>(&mut self, input: T)

fn set_input_kind<T: Into<Bytes>>( &mut self, input: T, kind: TransactionInputKind, )

fn from(&self) -> Option<Address>

fn set_from(&mut self, from: Address)

fn kind(&self) -> Option<TxKind>

fn clear_kind(&mut self)

fn set_kind(&mut self, kind: TxKind)

fn value(&self) -> Option<U256>

fn set_value(&mut self, value: U256)

fn gas_price(&self) -> Option<u128>

fn set_gas_price(&mut self, gas_price: u128)

fn max_fee_per_gas(&self) -> Option<u128>

fn set_max_fee_per_gas(&mut self, max_fee_per_gas: u128)

fn max_priority_fee_per_gas(&self) -> Option<u128>

fn set_max_priority_fee_per_gas(&mut self, max_priority_fee_per_gas: u128)

fn gas_limit(&self) -> Option<u64>

fn set_gas_limit(&mut self, gas_limit: u64)

fn access_list(&self) -> Option<&AccessList>

fn set_access_list(&mut self, access_list: AccessList)

fn complete_type(&self, ty: FoundryTxType) -> Result<(), Vec<&'static str>>

fn can_submit(&self) -> bool

fn can_build(&self) -> bool

fn output_tx_type(&self) -> FoundryTxType

fn output_tx_type_checked(&self) -> Option<FoundryTxType>

fn build_unsigned(self) -> BuildResult<FoundryTypedTx, FoundryNetwork>

async fn build<W: NetworkWallet<FoundryNetwork>>( self, wallet: &W, ) -> Result<FoundryTxEnvelope, TransactionBuilderError<FoundryNetwork>>

fn with_chain_id(self, chain_id: u64) -> Self

fn with_nonce(self, nonce: u64) -> Self

fn without_nonce(self) -> Self

fn with_input<T>(self, input: T) -> Selfwhere T: Into<Bytes>,

fn with_input_kind<T>(self, input: T, kind: TransactionInputKind) -> Selfwhere T: Into<Bytes>,

fn with_from(self, from: Address) -> Self

fn with_kind(self, kind: TxKind) -> Self

fn to(&self) -> Option<Address>

fn set_to(&mut self, to: Address)

fn with_to(self, to: Address) -> Self

fn set_create(&mut self)

fn into_create(self) -> Self

fn set_deploy_code<T>(&mut self, code: T)where T: Into<Bytes>,

fn with_deploy_code<T>(self, code: T) -> Selfwhere T: Into<Bytes>,

fn set_call<T>(&mut self, t: &T)where T: SolCall,

fn with_call<T>(self, t: &T) -> Selfwhere T: SolCall,

fn calculate_create_address(&self) -> Option<Address>

fn with_value(self, value: Uint<256, 4>) -> Self

fn with_gas_price(self, gas_price: u128) -> Self

fn with_max_fee_per_gas(self, max_fee_per_gas: u128) -> Self

fn with_max_priority_fee_per_gas(self, max_priority_fee_per_gas: u128) -> Self

fn with_gas_limit(self, gas_limit: u64) -> Self

fn with_access_list(self, access_list: AccessList) -> Self

fn complete_preferred(&self) -> Result<(), Vec<&'static str>>

fn assert_preferred(&self, ty: <N as Network>::TxType)

fn assert_preferred_chained(self, ty: <N as Network>::TxType) -> Self

Struct FoundryNetwork

fn with_input<T>(self, input: T) -> Self
where T: Into<Bytes>,

fn with_input_kind<T>(self, input: T, kind: TransactionInputKind) -> Self
where T: Into<Bytes>,

fn set_deploy_code<T>(&mut self, code: T)
where T: Into<Bytes>,

fn with_deploy_code<T>(self, code: T) -> Self
where T: Into<Bytes>,

fn set_call<T>(&mut self, t: &T)
where T: SolCall,

fn with_call<T>(self, t: &T) -> Self
where T: SolCall,

fn apply<F>(self, f: F) -> Self
where F: FnOnce(Self) -> Self,

fn try_apply<F, E>(self, f: F) -> Result<Self, E>
where F: FnOnce(Self) -> Result<Self, E>,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

fn conv<T>(self) -> T
where Self: Into<T>,

impl<T> DynClone for T
where T: Clone,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

impl<TxEnv, T> FromRecoveredTx<&T> for TxEnv
where TxEnv: FromRecoveredTx<T>,

impl<TxEnv, T> FromTxWithEncoded<&T> for TxEnv
where TxEnv: FromTxWithEncoded<T>,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,