# Alloy

Alloy is a high-performance Rust toolkit for Ethereum and EVM-compatible chains.

- [Installation](https://alloy.rs/introduction/installation): Install Alloy with cargo and configure the necessary feature flags for your blockchain development needs
- [Choose a Path](https://alloy.rs/introduction/choose-a-path): Find the shortest Alloy documentation path for a specific Ethereum development task
- [How Alloy Fits Together](https://alloy.rs/introduction/architecture): Understand Alloy's crates and layers before choosing APIs and feature flags
- [Getting Started](https://alloy.rs/introduction/getting-started): Get started with Alloy, the high-performance Rust toolkit for Ethereum and EVM-based blockchains
- [Why Alloy?](https://alloy.rs/introduction/why-alloy): Understand Alloy's modular architecture, performance goals, provider model, and differences from ethers-rs
- [Using Alloy documentation with coding agents](https://alloy.rs/introduction/prompting): Give coding agents current, focused Alloy context and require compilable Rust output
- [Build a fast MEV bot with Alloy's Primitive Types](https://alloy.rs/guides/speed-up-using-u256): Achieve up to 2x faster calculations by using Alloy's optimized U256 primitive types in MEV bots
- [Performant Static and Dynamic ABI Encoding](https://alloy.rs/guides/static-dynamic-abi-in-alloy): Leverage high-performance static and dynamic ABI encoding with up to 10x speed improvements over ethers-rs
- [Multicall and Multicall Batching layer](https://alloy.rs/guides/multicall): Optimize RPC usage by batching multiple smart contract calls using Multicall Builder and Layer
- [Interacting with multiple networks](https://alloy.rs/guides/interacting-with-multiple-networks): Use the Network trait to seamlessly interact with different blockchain networks and handle varying RPC types
- [Signers and EthereumWallet](https://alloy.rs/guides/signers-vs-ethereum-wallet): Choose an Alloy signer, register it with EthereumWallet, and connect it to a provider safely
- [Testing Alloy Applications](https://alloy.rs/guides/testing): Choose mock transports, local execution nodes, forks, and live RPC tests for Alloy code
- [RPC Provider Abstractions](https://alloy.rs/guides/rpc-provider-abstraction): Abstract provider implementations to work seamlessly across different transport layers and connection types
- [Building a High-Priority Transaction Queue with Alloy Fillers](https://alloy.rs/guides/fillers): Build transaction preprocessing pipelines using fillers to automatically fill missing transaction properties
- [Customizing RPC Communication with Alloy's Layers](https://alloy.rs/guides/layers): Customize HTTP-related aspects of RPC communication using Tower-based layers and services
- [RPC Provider](https://alloy.rs/rpc-providers/introduction): Connect to Ethereum networks using the Provider
- [HTTP Provider](https://alloy.rs/rpc-providers/http-provider): Connect to Ethereum RPC endpoints using HTTP transport for synchronous and asynchronous operations
- [WS Provider](https://alloy.rs/rpc-providers/ws-provider): Establish real-time WebSocket connections to Ethereum nodes for live updates and event subscriptions
- [IPC Provider](https://alloy.rs/rpc-providers/ipc-provider): Connect to local Ethereum nodes using Inter-Process Communication for optimal performance
- [Subscriptions and Polling](https://alloy.rs/rpc-providers/subscriptions-and-polling): Choose Alloy WebSocket subscriptions, JSON-RPC filters, or resumable block and log streams
- [Reliability and Retries](https://alloy.rs/rpc-providers/reliability): Configure Alloy connection retries, request backoff, fallbacks, timeouts, and error handling
- [RPC Namespaces](https://alloy.rs/rpc-providers/rpc-namespaces): Use Alloy provider extension traits for debug, trace, txpool, engine, admin, Anvil, MEV, and other RPC APIs
- [Understanding Fillers](https://alloy.rs/rpc-providers/understanding-fillers): Learn how fillers automatically populate transaction fields like nonce, gas price, and chain ID
- [Crafting Transactions](https://alloy.rs/transactions/introduction): Craft and build different types of Ethereum transactions using the TransactionBuilder interface
- [The transaction lifecycle](https://alloy.rs/transactions/transaction-lifecycle): Understand how transactions flow through Alloy's filler system from creation to network dispatch
- [Using the TransactionBuilder](https://alloy.rs/transactions/using-the-transaction-builder): Use the TransactionBuilder to construct transactions with a fluent builder pattern interface
- [Sending a legacy transaction](https://alloy.rs/transactions/sending-a-legacy-transaction): Send legacy transactions with gas price for compatibility with older Ethereum networks
- [Sending an EIP-1559 transaction](https://alloy.rs/transactions/sending-an-EIP-1559-transaction): Send EIP-1559 transactions with dynamic fees using max fee per gas and priority fee settings
- [Sending an EIP-4844 transaction](https://alloy.rs/transactions/sending-an-EIP-4844-transaction): Send EIP-4844 blob transactions with blob sidecars for data availability on Ethereum
- [Sending an EIP-7594 Blob Sidecar](https://alloy.rs/transactions/sending-an-EIP-7594-transaction): Convert and send an EIP-4844 blob transaction with an EIP-7594 PeerDAS cell-proof sidecar
- [Sending an EIP-7702 transaction](https://alloy.rs/transactions/sending-an-EIP-7702-transaction): Send EIP-7702 transactions with authorization lists for account abstraction features
- [Using access lists](https://alloy.rs/transactions/using-access-lists): Send EIP-2930 access list transactions
- [Using the sol! macro](https://alloy.rs/contract-interactions/using-sol!): Generate type-safe Rust bindings from Solidity code using the powerful sol! procedural macro
- [Reading a contract](https://alloy.rs/contract-interactions/read-contract): Call view functions on smart contracts using the sol! macro's CallBuilder for read operations
- [Writing to a contract](https://alloy.rs/contract-interactions/write-contract): Send transactions to smart contracts using the sol! macro's CallBuilder for seamless write operations
- [Querying Contracts](https://alloy.rs/contract-interactions/queries): Query contract storage, deployed bytecode, and event logs from the blockchain
- [Primitives](https://alloy.rs/using-primitive-types/introduction): Work with performant EVM primitive types including Address, U256, and FixedBytes in your applications
- [Basic hash and address types](https://alloy.rs/using-primitive-types/hash-and-address-types): Create, parse, hash, and inspect Alloy byte strings and Ethereum addresses
- [Initializing Big Numbers](https://alloy.rs/using-primitive-types/big-numbers): Initialize Alloy U256 and other fixed-width integer values from common Rust representations
- [Using big numbers](https://alloy.rs/using-primitive-types/using-big-numbers): Perform arithmetic and convert human-readable units with Alloy fixed-width integers
- [Common conversions](https://alloy.rs/using-primitive-types/common-conversions): Convert between Alloy fixed-width integers, byte arrays, strings, and primitive Rust values
- [Comparisons and equivalence](https://alloy.rs/using-primitive-types/comparisons-and-equivalence): Compare Alloy fixed-width integers and reason about equivalent values and representations
- [Feature Flags](https://alloy.rs/reference/feature-flags): Choose Alloy meta-crate features for providers, transports, signers, RPC namespaces, and constrained builds
- [Protocol and RPC Types](https://alloy.rs/reference/protocol-and-rpc-types): Choose Alloy primitives, consensus envelopes, EIP helpers, RPC responses, genesis, trie, and serialization types
- [Example: any_network](https://alloy.rs/examples/advanced/any_network): Example of using AnyNetwork to get a type-safe representation of network-specific data.
- [Example: decoding_json_abi](https://alloy.rs/examples/advanced/decoding_json_abi): Example for deserializing ABI using json_abi.
- [Example: encoding_dyn_abi](https://alloy.rs/examples/advanced/encoding_dyn_abi): Example of EIP712 encoding and decoding via dyn_abi.
- [Example: encoding_sol_static](https://alloy.rs/examples/advanced/encoding_sol_static): Example for static encoding calldata via sol!.
- [Example: foundry_fork_db](https://alloy.rs/examples/advanced/foundry_fork_db): This example demonstrates how to use foundry_fork_db to build a minimal fork with a db that caches responses from the RPC provider.
- [Example: uniswap_u256_alloy_profit](https://alloy.rs/examples/advanced/uniswap_u256_alloy_profit): Uniswap V2 Arbitrage Profit Calculation using alloy U256
- [Example: uniswap_u256_ethers_profit](https://alloy.rs/examples/advanced/uniswap_u256_ethers_profit): Uniswap V2 Arbitrage Profit Calculation using ethers-rs U256
- [Example: uniswap_u256_alloy_simulation](https://alloy.rs/examples/advanced/uniswap_u256_alloy_simulation): Uniswap V2 Arbitrage Simulation using alloy
- [Example: comparison_equivalence](https://alloy.rs/examples/big-numbers/comparison_equivalence): Example of comparison and equivalence of U256 instances.
- [Example: conversion](https://alloy.rs/examples/big-numbers/conversion): Example of converting U256 to native Rust types.
- [Example: create_instances](https://alloy.rs/examples/big-numbers/create_instances): Example of creating instances of U256 from strings and numbers.
- [Example: math_operations](https://alloy.rs/examples/big-numbers/math_operations): Example of performing arithmetic operations with U256.
- [Example: math_utilities](https://alloy.rs/examples/big-numbers/math_utilities): Example of using math utilities to handle big numbers in 'wei' units.
- [Example: compare_new_heads](https://alloy.rs/examples/comparison/compare_new_heads): Example of comparing new block headers from multiple providers.
- [Example: compare_pending_txs](https://alloy.rs/examples/comparison/compare_pending_txs): Example of comparing pending transactions from multiple providers.
- [Example: deploy_from_artifact](https://alloy.rs/examples/contracts/deploy_from_artifact): Example of deploying a contract from an artifact using the sol! macro to Anvil and interacting with it.
- [Example: deploy_from_bytecode](https://alloy.rs/examples/contracts/deploy_from_bytecode): Example of deploying a contract at runtime from Solidity bytecode to Anvil and interacting with it.
- [Example: deploy_from_contract](https://alloy.rs/examples/contracts/deploy_from_contract): Example of deploying a contract from Solidity code using the sol! macro to Anvil and interacting with it.
- [Example: deploy_and_link_library](https://alloy.rs/examples/contracts/deploy_and_link_library): Example of deploying a contract that requires library linking
- [Example: interact_with_abi](https://alloy.rs/examples/contracts/interact_with_abi): Example of generating code from ABI file using the sol! macro to interact with the contract.
- [Example: interact_with_contract_instance](https://alloy.rs/examples/contracts/interact_with_contract_instance): This example demonstrates how to interact with a contract that is already deployed onchain using the ContractInstance interface.
- [Example: jsonrpc_error_decoding](https://alloy.rs/examples/contracts/jsonrpc_error_decoding): This example demonstrates how to decode a custom JSON RPC error.
- [Example: revert_decoding](https://alloy.rs/examples/contracts/revert_decoding): This example demonstrates how to decode revert data into a custom error.
- [Example: unknown_return_types](https://alloy.rs/examples/contracts/unknown_return_types): Example demonstrating how one can handle unknown / complex return types using DynSol.
- [Example: arb_profit_calc](https://alloy.rs/examples/contracts/arb_profit_calc): Simple arbitrage profit calculator for WETH/DAI pools Reads the balaces of the Uniswap V2 and Sushiswap pools and calculates a basic arb opportunity.
- [Example: simulation_uni_v2](https://alloy.rs/examples/contracts/simulation_uni_v2): Simulates an arbitrage between Uniswap V2 and Sushiswap by forking anvil and using the FlashBotsMultiCall contract.
- [Example: address_lookup](https://alloy.rs/examples/ens/address_lookup): Example of looking up ENS names from Ethereum addresses.
- [Example: name_resolution](https://alloy.rs/examples/ens/name_resolution): Example of resolving ENS names to Ethereum addresses.
- [Example: gas_filler](https://alloy.rs/examples/fillers/gas_filler): Example of using the GasFiller in the provider.
- [Example: nonce_filler](https://alloy.rs/examples/fillers/nonce_filler): Example of using the NonceFiller in the provider.
- [Example: recommended_fillers](https://alloy.rs/examples/fillers/recommended_fillers): Example of using the .with_recommended_fillers() method in the provider.
- [Example: wallet_filler](https://alloy.rs/examples/fillers/wallet_filler): Example of using the WalletFiller in the provider.
- [Example: urgent_filler](https://alloy.rs/examples/fillers/urgent_filler): Rolls a custom filler that fetches priority fee information from an external endpoint and fills the EIP-1559 gas fields for urgent inclusion.
- [Example: hyper_http_layer](https://alloy.rs/examples/layers/hyper_http_layer): This example demonstrates how to write a custom layer for the hyper HTTP client that can modify the underlying HTTP request before it is sent.
- [Example: logging_layer](https://alloy.rs/examples/layers/logging_layer): This examples demonstrates how to implement your own custom transport layer. As a demonstration we implement a simple request / response logging layer.
- [Example: retry_layer](https://alloy.rs/examples/layers/retry_layer): This example demonstrates how to use the RetryBackoffLayer in the provider.
- [Example: fallback_layer](https://alloy.rs/examples/layers/fallback_layer): Test the fallback layer provider.
- [Example: delay_layer](https://alloy.rs/examples/layers/delay_layer): Demonstrates how to implement a custom transport layer that delays dispatching the requests.
- [Example: anvil_deploy_contract](https://alloy.rs/examples/node-bindings/anvil_deploy_contract): Example of deploying a contract to a local Anvil node using the ProviderBuilder.
- [Example: anvil_fork_instance](https://alloy.rs/examples/node-bindings/anvil_fork_instance): Example of spinning up a forked Anvil instance and connecting it with a provider.
- [Example: anvil_fork_provider](https://alloy.rs/examples/node-bindings/anvil_fork_provider): Example of spinning up a forked Anvil node using the ProviderBuilder.
- [Example: anvil_local_instance](https://alloy.rs/examples/node-bindings/anvil_local_instance): Example of spinning up a local Anvil instance and connecting it with a provider.
- [Example: anvil_local_provider](https://alloy.rs/examples/node-bindings/anvil_local_provider): Example of spinning up a local Anvil node using the ProviderBuilder.
- [Example: geth_local_instance](https://alloy.rs/examples/node-bindings/geth_local_instance): Example of spinning up a local Geth node instance and connecting it with a provider.
- [Example: reth_local_instance](https://alloy.rs/examples/node-bindings/reth_local_instance): Example of spinning up a local Reth node instance and connecting it with a provider.
- [Example: anvil_set_storage_at](https://alloy.rs/examples/node-bindings/anvil_set_storage_at): Example of mocking WETH balance of a target account using AnvilApi::anvil_set_storage_at.
- [Example: bytes_and_address_types](https://alloy.rs/examples/primitives/bytes_and_address_types): Example of basic usage of bytes and address types and macros.
- [Example: hashing_functions](https://alloy.rs/examples/primitives/hashing_functions): Example of basic usage of hashing functions.
- [Example: builder](https://alloy.rs/examples/providers/builder): Example of using the ProviderBuilder to create a provider with a signer and network.
- [Example: builtin](https://alloy.rs/examples/providers/builtin): Example of using the on_builtin method in the provider.
- [Example: http_with_auth](https://alloy.rs/examples/providers/http_with_auth): Example of using the reqwest HTTP client with an Authorization header to get the latest block number.
- [Example: http](https://alloy.rs/examples/providers/http): Example of using the HTTP provider with the reqwest crate to get the latest block number.
- [Example: ipc](https://alloy.rs/examples/providers/ipc): Example of using the IPC provider to get the latest block number.
- [Example: mocking](https://alloy.rs/examples/providers/mocking): This example shows to how to use the MockTransport to mock the provider responses for testing purposes.
- [Example: wrapped_provider](https://alloy.rs/examples/providers/wrapped_provider): Example demonstrating how to wrap the Provider in a struct and pass it through free functions.
- [Example: dyn_provider](https://alloy.rs/examples/providers/dyn_provider): Demonstrates how to obtain a DynProvider from a Provider.
- [Example: multicall_batching](https://alloy.rs/examples/providers/multicall_batching): Demonstrate the Multicall Batch Layer. Provider layer that aggregates contract calls (eth_call) over a time period into a single Multicall3 contract call. This is useful for reducing the number of requests made to the RPC.
- [Example: multicall](https://alloy.rs/examples/providers/multicall): This example demonstrates how to use the MulticallBuilder to make multicalls using the IMulticall3 contract.
- [Example: ws](https://alloy.rs/examples/providers/ws): Example of using the WS provider to subscribe to new blocks.
- [Example: ws_with_auth](https://alloy.rs/examples/providers/ws_with_auth): Example of using the WS provider with auth to subscribe to new blocks.
- [Example: ws_with_reconnect](https://alloy.rs/examples/providers/ws_with_reconnect): Example of configuring WebSocket connection and reconnection retries.
- [Example: batch_rpc](https://alloy.rs/examples/providers/batch_rpc): Example depicting how to make a Batch RPC request using the HTTP provider.
- [Example: embed_consensus_rpc](https://alloy.rs/examples/providers/embed_consensus_rpc): This example demonstrates how alloy's RPC types and consensus types are tied together.
- [Example: basic_provider](https://alloy.rs/examples/providers/basic_provider): Instantiate a basic provider without any fillers or layers.
- [Example: query_contract_storage](https://alloy.rs/examples/queries/query_contract_storage): Example of querying contract storage from the Ethereum network.
- [Example: query_deployed_bytecode](https://alloy.rs/examples/queries/query_deployed_bytecode): Example of querying deployed bytecode of a contract on the Ethereum network.
- [Example: query_logs](https://alloy.rs/examples/queries/query_logs): Example of querying logs from the Ethereum network.
- [Example: query_logs_chunked](https://alloy.rs/examples/queries/query_logs_chunked): Example of querying event logs over a large block range using chunked().
- [Example: events_errors](https://alloy.rs/examples/sol-macro/events_errors): Example showing how to decode events and errors from a contract using the sol! macro.
- [Example: decode_returns](https://alloy.rs/examples/sol-macro/decode_returns): Example showing how to decode return values from a call to a contract using the sol! macro.
- [Example: structs_enums](https://alloy.rs/examples/sol-macro/structs_enums): Example showing how to use the sol! macro to generate Rust bindings for Solidity structs and enums.
- [Example: user_defined_types](https://alloy.rs/examples/sol-macro/user_defined_types): Example showing defining user defined value types and type aliases using the sol! macro.
- [Example: all_derives](https://alloy.rs/examples/sol-macro/all_derives): This example demonstrates the all_derives attribute in the sol! macro.
- [Example: extra_derives](https://alloy.rs/examples/sol-macro/extra_derives): This example shows how to apply trait derivations globally by specifying the path.
- [Example: subscribe_blocks](https://alloy.rs/examples/subscriptions/subscribe_blocks): Example of subscribing to blocks and watching block headers by polling.
- [Example: watch_canonical_blocks](https://alloy.rs/examples/subscriptions/watch_canonical_blocks): Example of resuming a canonical block stream from a known block number.
- [Example: poll_logs](https://alloy.rs/examples/subscriptions/poll_logs): Example of watching and polling for contract events by WebSocket subscription.
- [Example: subscribe_logs](https://alloy.rs/examples/subscriptions/subscribe_logs): Example of subscribing and listening for specific contract events by WebSocket subscription.
- [Example: subscribe_all_logs](https://alloy.rs/examples/subscriptions/subscribe_all_logs): Example of subscribing and listening for all contract events by WebSocket subscription.
- [Example: subscribe_pending_transactions](https://alloy.rs/examples/subscriptions/subscribe_pending_transactions): Example of subscribing and listening for pending transactions in the public mempool by WebSocket subscription.
- [Example: event_multiplexer](https://alloy.rs/examples/subscriptions/event_multiplexer): Example of multiplexing the watching of event logs.
- [Example: decode_input](https://alloy.rs/examples/transactions/decode_input): Example of how to decode the input of a transaction.
- [Example: decode_receipt_log](https://alloy.rs/examples/transactions/decode_receipt_log): Example depicting how to decode logs present in a transaction receipt.
- [Example: encode_decode_eip1559](https://alloy.rs/examples/transactions/encode_decode_eip1559): Example showing how to encode and decode an EIP-1559 transaction.
- [Example: gas_price_usd](https://alloy.rs/examples/transactions/gas_price_usd): Example of how to get the gas price in USD using the Chainlink ETH/USD feed.
- [Example: debug_trace_call_many](https://alloy.rs/examples/transactions/debug_trace_call_many): Example of how to trace a transaction using debug_trace_call_many.
- [Example: trace_call_many](https://alloy.rs/examples/transactions/trace_call_many): Example of how to trace a transaction using trace_call_many.
- [Example: trace_call](https://alloy.rs/examples/transactions/trace_call): Example of how to trace a transaction using trace_call.
- [Example: trace_transaction](https://alloy.rs/examples/transactions/trace_transaction): Example of how to trace a transaction using trace_transaction.
- [Example: transfer_erc20](https://alloy.rs/examples/transactions/transfer_erc20): Example of how to transfer ERC20 tokens from one account to another.
- [Example: permit2_signature_transfer](https://alloy.rs/examples/transactions/permit2_signature_transfer): Example of how to transfer ERC20 tokens from one account to another using a signed permit.
- [Example: transfer_eth](https://alloy.rs/examples/transactions/transfer_eth): Example of how to transfer ETH from one account to another.
- [Example: send_raw_transaction](https://alloy.rs/examples/transactions/send_raw_transaction): Example of signing, encoding and sending a raw transaction using a wallet.
- [Example: send_legacy_transaction](https://alloy.rs/examples/transactions/send_legacy_transaction): Example showing how to send a legacy transaction.
- [Example: send_eip1559_transaction](https://alloy.rs/examples/transactions/send_eip1559_transaction): Example showing how to send an EIP-1559 transaction.
- [Example: send_eip4844_transaction](https://alloy.rs/examples/transactions/send_eip4844_transaction): Example showing how to send an EIP-4844 transaction.
- [Example: send_eip7594_transaction](https://alloy.rs/examples/transactions/send_eip7594_transaction): Example showing how to send an EIP-7594 transaction.
- [Example: send_eip7702_transaction](https://alloy.rs/examples/transactions/send_eip7702_transaction): Example showing how to send an EIP-7702 transaction.
- [Example: send_private_transaction](https://alloy.rs/examples/transactions/send_private_transaction): Example of sending a private transaction using Flashbots Protect.
- [Example: with_access_list](https://alloy.rs/examples/transactions/with_access_list): Example of sending a EIP-1559 transaction with access list.
- [Example: aws_signer](https://alloy.rs/examples/wallets/aws_signer): Example showing how to use the AWS KMS signer.
- [Example: gcp_signer](https://alloy.rs/examples/wallets/gcp_signer): Example showing how to use the GCP KMS signer.
- [Example: ledger_signer](https://alloy.rs/examples/wallets/ledger_signer): Example of signing and sending a transaction using a Ledger device.
- [Example: private_key_signer](https://alloy.rs/examples/wallets/private_key_signer): Example of using a local wallet to sign and send a transaction.
- [Example: mnemonic_signer](https://alloy.rs/examples/wallets/mnemonic_signer): Example of using MnemonicBuilder to access a wallet from a mnemonic phrase.
- [Example: ethereum_wallet](https://alloy.rs/examples/wallets/ethereum_wallet): Demonstrates how EthereumWallet can use multiple different types of signers.
- [Example: sign_message](https://alloy.rs/examples/wallets/sign_message): Example of signing a message with a signer.
- [Example: verify_message](https://alloy.rs/examples/wallets/verify_message): Example of verifying that a message was signed by the provided address.
- [Example: sign_permit_hash](https://alloy.rs/examples/wallets/sign_permit_hash): Example of signing a permit hash using a wallet.
- [Example: trezor_signer](https://alloy.rs/examples/wallets/trezor_signer): Example of signing and sending a transaction using a Trezor device.
- [Example: turnkey_signer](https://alloy.rs/examples/wallets/turnkey_signer): Example showing how to use the Turnkey managed signer.
- [Example: yubi_signer](https://alloy.rs/examples/wallets/yubi_signer): Example of signing and sending a transaction using a Yubi device.
- [Example: keystore_signer](https://alloy.rs/examples/wallets/keystore_signer): Example of using a keystore wallet to sign and send a transaction.
- [Example: create_keystore](https://alloy.rs/examples/wallets/create_keystore): Example of creating a keystore file from a private key and password, and then reading it back.
- [v1.0 Changes](https://alloy.rs/migrating-to-core-v1): Understand breaking changes in Alloy core v1.0 including sol! macro improvements and ABI encoding updates
- [Removing the T transport generic](https://alloy.rs/migrating-to-core-v1/sol!-changes/removing-T-generic): Removal of the transport generic T from contract and RPC codegen
- [Improving function call return types](https://alloy.rs/migrating-to-core-v1/sol!-changes/improving-function-return-types): Improvements to function return types by removing the need for _0 field access in Alloy 1.0
- [Changes to function call bindings](https://alloy.rs/migrating-to-core-v1/sol!-changes/changes-to-function-call-bindings): Changes to function call bindings from named fields to tuple struct format in alloy 1.0
- [Changes to event bindings](https://alloy.rs/migrating-to-core-v1/sol!-changes/changes-to-event-bindings): Changes to event bindings in Alloy v1.0
- [Changes to error bindings](https://alloy.rs/migrating-to-core-v1/sol!-changes/changes-to-error-bindings): Changes to error bindings and how error handling is updated in Alloy v1.0
- [Encoding return structs](https://alloy.rs/migrating-to-core-v1/encoding-decoding-changes/encoding-return-structs): Learn about changes to ABI encoding for function return structs in alloy 1.0
- [Removing the validate: bool from the abi_decode methods](https://alloy.rs/migrating-to-core-v1/encoding-decoding-changes/removing-validate-bool): Removal of the validate boolean parameter from abi_decode methods in alloy 1.0
- [Other breaking changes](https://alloy.rs/migrating-to-core-v1/other-breaking-changes): Learn about other breaking changes in Alloy core v1.0 beyond sol! macro updates
- [Reference](https://alloy.rs/migrating-from-ethers/reference): Complete reference guide for migrating from ethers-rs to Alloy with crate and type mappings
- [Conversions](https://alloy.rs/migrating-from-ethers/conversions): Use conversion traits to seamlessly convert between ethers-rs and Alloy primitive types
- [alloy · Rust Interface for Ethereum](https://alloy.rs/index): Alloy is a collection of blazing fast and intuitive APIs used to interact with blockchains.
- [Example: deploy_from_contract](https://alloy.rs/examples/sol-macro/contract): Example of deploying a contract from Solidity code using the sol! macro to Anvil and interacting with it.
- [Simply ABI encoding and decoding](https://alloy.rs/migrating-to-core-v1/encoding-decoding-changes/README): Overview of ABI encoding and decoding changes in Alloy  v1.0
- [sol! changes](https://alloy.rs/migrating-to-core-v1/sol!-changes/README): Overview of changes to the sol! macro bindings in Alloy v1.0