Expand description
§alloy-networks
Ethereum blockchain RPC behavior abstraction.
This crate contains a simple abstraction of the RPC behavior of an Ethereum-like blockchain. It is intended to be used by the Alloy client to provide a consistent interface to the rest of the library, regardless of changes the underlying blockchain makes to the RPC interface.
§Core Model
This crate handles abstracting RPC types. It does not handle the actual networking. The core model is as follows:
Transaction
- A trait that defines an abstract interface for EVM-like transactions.Network
- A trait that defines the RPC types for a given blockchain. Providers are parameterized by aNetwork
type, and use the associated types to define the input and output types of the RPC methods.- TODO: More!!!
§Usage
This crate is not intended to be used directly. It is used by the alloy-provider library and reth to modify the input and output types of the RPC methods.
This crate will primarily be used by blockchain maintainers to add bespoke RPC
types to the Alloy provider. This is done by implementing the Network
trait,
and then parameterizing the Provider
type with the new network type.
For example, to add a new network called Foo
:
// Foo must be a ZST. It is a compile error to use a non-ZST type.
struct Foo;
impl Network for Foo {
type Transaction = FooTransaction;
type Block = FooBlock;
type Header = FooHeader;
type Receipt = FooReceipt;
// etc.
}
The user may then instantiate a Provider<Foo>
and use it as normal. This
allows the user to use the same API for all networks, regardless of the
underlying RPC types.
Note: If you need to also add custom methods to your network, you should
make an extension trait for Provider<N>
as follows:
#[async_trait]
trait FooProviderExt: Provider<Foo> {
async fn custom_foo_method(&self) -> RpcResult<Something, TransportError>;
async fn another_custom_method(&self) -> RpcResult<Something, TransportError>;
}
Re-exports§
pub use alloy_network_primitives as primitives;
Modules§
- EIP-2718 traits.
Structs§
- Block header representation with certain fields made optional to account for possible differencies in network implementations.
- Types for a catch-all network.
- Receipt envelope, as defined in EIP-2718.
- Transaction type for a catch-all network.
- Types for a mainnet-like Ethereum network.
- A wallet capable of signing any transaction for the Ethereum network.
- An unbuilt transaction, along with some error.
- A transaction envelope from an unknown network.
- A typed transaction of an unknown Network
Enums§
- Transaction envelope for a catch-all network.
- Unsigned transaction type for a catch-all network.
- Error type for transaction builders.
Traits§
- Block JSON-RPC response.
- Captures type info for network-specific RPC requests/responses.
- A wallet capable of signing any transaction for the given network.
- Receipt JSON-RPC response.
- A Transaction builder for a network.
- Transaction builder type supporting EIP-4844 transaction fields.
- Transaction builder type supporting EIP-7702 transaction fields.
- Transaction JSON-RPC response. Aggregates transaction data with its block and signer context.
- Asynchronous transaction signer, capable of signing any
SignableTransaction
for the givenSignature
type. - Synchronous transaction signer, capable of signing any
SignableTransaction
for the givenSignature
type.
Type Aliases§
- A catch-all block type for handling blocks on multiple networks.
- A catch-all header type for handling headers on multiple networks.
- A catch-all transaction type for handling transactions on multiple networks.
- Alias for a catch-all receipt type.
- Result type for transaction builders