0xtrails 0.16.2 → 0.17.1

package/dist/types-BK0WkVnx.d.ts

@@ -0,0 +1,2161 @@
+import { TradeType as SwapType, TrailsApi } from "@0xtrails/api";
+import { Abi, Call } from "viem";
+import { Address } from "ox";
+
+//#region src/actions/constants.d.ts
+/** Chain name → Chain, for .onChain("polygon") / .onChain("base") etc.
+ *  Keys are compatible with the Trails API network identifiers. */
+declare const supportedChainsByName: {
+  readonly apechain: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Apescan";
+        readonly url: "https://apescan.io";
+        readonly apiUrl: "https://api.apescan.io/api";
+      };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+        readonly blockCreated: 20889;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 33139;
+    name: "ApeChain";
+    nativeCurrency: {
+      readonly name: "ApeCoin";
+      readonly symbol: "APE";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://rpc.apechain.com/http"];
+        readonly webSocket: readonly ["wss://rpc.apechain.com/ws"];
+      };
+    };
+    sourceId: 42161;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly arbitrum: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Arbiscan";
+        readonly url: "https://arbiscan.io";
+        readonly apiUrl: "https://api.arbiscan.io/api";
+      };
+    };
+    blockTime: 250;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 7654707;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 42161;
+    name: "Arbitrum One";
+    nativeCurrency: {
+      readonly name: "Ether";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly "arbitrum-nova": {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Arbiscan";
+        readonly url: "https://nova.arbiscan.io";
+        readonly apiUrl: "https://api-nova.arbiscan.io/api";
+      };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 1746963;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 42170;
+    name: "Arbitrum Nova";
+    nativeCurrency: {
+      readonly name: "Ether";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://nova.arbitrum.io/rpc"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly avalanche: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "SnowTrace";
+        readonly url: "https://snowtrace.io";
+        readonly apiUrl: "https://api.snowtrace.io";
+      };
+    };
+    blockTime: 1700;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 11907934;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 43114;
+    name: "Avalanche";
+    nativeCurrency: {
+      readonly decimals: 18;
+      readonly name: "Avalanche";
+      readonly symbol: "AVAX";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly "avalanche-c": {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "SnowTrace";
+        readonly url: "https://snowtrace.io";
+        readonly apiUrl: "https://api.snowtrace.io";
+      };
+    };
+    blockTime: 1700;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 11907934;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 43114;
+    name: "Avalanche";
+    nativeCurrency: {
+      readonly decimals: 18;
+      readonly name: "Avalanche";
+      readonly symbol: "AVAX";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly b3: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Blockscout";
+        readonly url: "https://explorer.b3.fun";
+      };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 0;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 8333;
+    name: "B3";
+    nativeCurrency: {
+      readonly name: "Ether";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://mainnet-rpc.b3.fun/http"];
+      };
+    };
+    sourceId: 8453;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly base: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Basescan";
+        readonly url: "https://basescan.org";
+        readonly apiUrl: "https://api.basescan.org/api";
+      };
+    };
+    blockTime: 2000;
+    contracts: {
+      readonly disputeGameFactory: {
+        readonly 1: {
+          readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
+        };
+      };
+      readonly l2OutputOracle: {
+        readonly 1: {
+          readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
+        };
+      };
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 5022;
+      };
+      readonly portal: {
+        readonly 1: {
+          readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
+          readonly blockCreated: 17482143;
+        };
+      };
+      readonly l1StandardBridge: {
+        readonly 1: {
+          readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
+          readonly blockCreated: 17482143;
+        };
+      };
+      readonly gasPriceOracle: {
+        readonly address: "0x420000000000000000000000000000000000000F";
+      };
+      readonly l1Block: {
+        readonly address: "0x4200000000000000000000000000000000000015";
+      };
+      readonly l2CrossDomainMessenger: {
+        readonly address: "0x4200000000000000000000000000000000000007";
+      };
+      readonly l2Erc721Bridge: {
+        readonly address: "0x4200000000000000000000000000000000000014";
+      };
+      readonly l2StandardBridge: {
+        readonly address: "0x4200000000000000000000000000000000000010";
+      };
+      readonly l2ToL1MessagePasser: {
+        readonly address: "0x4200000000000000000000000000000000000016";
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 8453;
+    name: "Base";
+    nativeCurrency: {
+      readonly name: "Ether";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://mainnet.base.org"];
+      };
+    };
+    sourceId: 1;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+      readonly block: {
+        exclude: [] | undefined;
+        format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
+          baseFeePerGas: bigint | null;
+          blobGasUsed: bigint;
+          difficulty: bigint;
+          excessBlobGas: bigint;
+          extraData: import("viem").Hex;
+          gasLimit: bigint;
+          gasUsed: bigint;
+          hash: `0x${string}` | null;
+          logsBloom: `0x${string}` | null;
+          miner: import("viem").Address;
+          mixHash: import("viem").Hash;
+          nonce: `0x${string}` | null;
+          number: bigint | null;
+          parentBeaconBlockRoot?: `0x${string}` | undefined;
+          parentHash: import("viem").Hash;
+          receiptsRoot: import("viem").Hex;
+          sealFields: import("viem").Hex[];
+          sha3Uncles: import("viem").Hash;
+          size: bigint;
+          stateRoot: import("viem").Hash;
+          timestamp: bigint;
+          totalDifficulty: bigint | null;
+          transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+          transactionsRoot: import("viem").Hash;
+          uncles: import("viem").Hash[];
+          withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
+          withdrawalsRoot?: `0x${string}` | undefined;
+        } & {};
+        type: "block";
+      };
+      readonly transaction: {
+        exclude: [] | undefined;
+        format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: boolean;
+          mint?: bigint | undefined | undefined;
+          sourceHash: import("viem").Hex;
+          type: "deposit";
+        } | {
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          v: bigint;
+          to: import("viem").Address | null;
+          from: import("viem").Address;
+          gas: bigint;
+          nonce: number;
+          value: bigint;
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          accessList?: undefined | undefined;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes?: undefined | undefined;
+          chainId?: number | undefined;
+          yParity?: undefined | undefined;
+          type: "legacy";
+          gasPrice: bigint;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas?: undefined | undefined;
+          maxPriorityFeePerGas?: undefined | undefined;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes?: undefined | undefined;
+          chainId: number;
+          type: "eip2930";
+          gasPrice: bigint;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas?: undefined | undefined;
+          maxPriorityFeePerGas?: undefined | undefined;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes?: undefined | undefined;
+          chainId: number;
+          type: "eip1559";
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes: readonly import("viem").Hex[];
+          chainId: number;
+          type: "eip4844";
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas: bigint;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList: import("viem").SignedAuthorizationList;
+          blobVersionedHashes?: undefined | undefined;
+          chainId: number;
+          type: "eip7702";
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        }) & {};
+        type: "transaction";
+      };
+      readonly transactionReceipt: {
+        exclude: [] | undefined;
+        format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
+          blobGasPrice?: bigint | undefined;
+          blobGasUsed?: bigint | undefined;
+          blockHash: import("viem").Hash;
+          blockNumber: bigint;
+          blockTimestamp?: bigint | undefined;
+          contractAddress: import("viem").Address | null | undefined;
+          cumulativeGasUsed: bigint;
+          effectiveGasPrice: bigint;
+          from: import("viem").Address;
+          gasUsed: bigint;
+          logs: import("viem").Log<bigint, number, false>[];
+          logsBloom: import("viem").Hex;
+          root?: `0x${string}` | undefined;
+          status: "success" | "reverted";
+          to: import("viem").Address | null;
+          transactionHash: import("viem").Hash;
+          transactionIndex: number;
+          type: import("viem").TransactionType;
+          l1GasPrice: bigint | null;
+          l1GasUsed: bigint | null;
+          l1Fee: bigint | null;
+          l1FeeScalar: number | null;
+        } & {};
+        type: "transactionReceipt";
+      };
+    };
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers: {
+      readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+    };
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly binance: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "BscScan";
+        readonly url: "https://bscscan.com";
+        readonly apiUrl: "https://api.bscscan.com/api";
+      };
+    };
+    blockTime: 750;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 15921452;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 56;
+    name: "BNB Smart Chain";
+    nativeCurrency: {
+      readonly decimals: 18;
+      readonly name: "BNB";
+      readonly symbol: "BNB";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://56.rpc.thirdweb.com"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly bsc: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "BscScan";
+        readonly url: "https://bscscan.com";
+        readonly apiUrl: "https://api.bscscan.com/api";
+      };
+    };
+    blockTime: 750;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 15921452;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 56;
+    name: "BNB Smart Chain";
+    nativeCurrency: {
+      readonly decimals: 18;
+      readonly name: "BNB";
+      readonly symbol: "BNB";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://56.rpc.thirdweb.com"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly bnb: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "BscScan";
+        readonly url: "https://bscscan.com";
+        readonly apiUrl: "https://api.bscscan.com/api";
+      };
+    };
+    blockTime: 750;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 15921452;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 56;
+    name: "BNB Smart Chain";
+    nativeCurrency: {
+      readonly decimals: 18;
+      readonly name: "BNB";
+      readonly symbol: "BNB";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://56.rpc.thirdweb.com"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly etherlink: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Etherlink";
+        readonly url: "https://explorer.etherlink.com";
+      };
+    };
+    blockTime: 4830;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+        readonly blockCreated: 33899;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 42793;
+    name: "Etherlink";
+    nativeCurrency: {
+      readonly decimals: 18;
+      readonly name: "Tez";
+      readonly symbol: "XTZ";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://node.mainnet.etherlink.com"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly gnosis: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Gnosisscan";
+        readonly url: "https://gnosisscan.io";
+        readonly apiUrl: "https://api.gnosisscan.io/api";
+      };
+    };
+    blockTime: 5000;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 21022491;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 100;
+    name: "Gnosis";
+    nativeCurrency: {
+      readonly decimals: 18;
+      readonly name: "xDAI";
+      readonly symbol: "XDAI";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://rpc.gnosischain.com"];
+        readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly hyperevm: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "HyperEVMScan";
+        readonly url: "https://hyperevmscan.io";
+      };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+        readonly blockCreated: 13051;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 999;
+    name: "HyperEVM";
+    nativeCurrency: {
+      readonly name: "HYPE";
+      readonly symbol: "HYPE";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly katana: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "katana explorer";
+        readonly url: "https://katanascan.com";
+      };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+        readonly blockCreated: 0;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 747474;
+    name: "Katana";
+    nativeCurrency: {
+      readonly name: "Ether";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://rpc.katana.network"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    readonly network: "katana";
+  };
+  readonly mainnet: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Etherscan";
+        readonly url: "https://etherscan.io";
+        readonly apiUrl: "https://api.etherscan.io/api";
+      };
+    };
+    blockTime: 12000;
+    contracts: {
+      readonly ensUniversalResolver: {
+        readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+        readonly blockCreated: 23085558;
+      };
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 14353601;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 1;
+    name: "Ethereum";
+    nativeCurrency: {
+      readonly name: "Ether";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://eth.merkle.io"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly ethereum: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Etherscan";
+        readonly url: "https://etherscan.io";
+        readonly apiUrl: "https://api.etherscan.io/api";
+      };
+    };
+    blockTime: 12000;
+    contracts: {
+      readonly ensUniversalResolver: {
+        readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+        readonly blockCreated: 23085558;
+      };
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 14353601;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 1;
+    name: "Ethereum";
+    nativeCurrency: {
+      readonly name: "Ether";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://eth.merkle.io"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly monad: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "MonadVision";
+        readonly url: "https://monadvision.com";
+      };
+      readonly monadscan: {
+        readonly name: "Monadscan";
+        readonly url: "https://monadscan.com";
+        readonly apiUrl: "https://api.monadscan.com/api";
+      };
+    };
+    blockTime: 400;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+        readonly blockCreated: 9248132;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 143;
+    name: "Monad";
+    nativeCurrency: {
+      readonly name: "Monad";
+      readonly symbol: "MON";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
+        readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly optimism: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Optimism Explorer";
+        readonly url: "https://optimistic.etherscan.io";
+        readonly apiUrl: "https://api-optimistic.etherscan.io/api";
+      };
+    };
+    blockTime: 2000;
+    contracts: {
+      readonly disputeGameFactory: {
+        readonly 1: {
+          readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
+        };
+      };
+      readonly l2OutputOracle: {
+        readonly 1: {
+          readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
+        };
+      };
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 4286263;
+      };
+      readonly portal: {
+        readonly 1: {
+          readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
+        };
+      };
+      readonly l1StandardBridge: {
+        readonly 1: {
+          readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
+        };
+      };
+      readonly gasPriceOracle: {
+        readonly address: "0x420000000000000000000000000000000000000F";
+      };
+      readonly l1Block: {
+        readonly address: "0x4200000000000000000000000000000000000015";
+      };
+      readonly l2CrossDomainMessenger: {
+        readonly address: "0x4200000000000000000000000000000000000007";
+      };
+      readonly l2Erc721Bridge: {
+        readonly address: "0x4200000000000000000000000000000000000014";
+      };
+      readonly l2StandardBridge: {
+        readonly address: "0x4200000000000000000000000000000000000010";
+      };
+      readonly l2ToL1MessagePasser: {
+        readonly address: "0x4200000000000000000000000000000000000016";
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 10;
+    name: "OP Mainnet";
+    nativeCurrency: {
+      readonly name: "Ether";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://mainnet.optimism.io"];
+      };
+    };
+    sourceId: 1;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+      readonly block: {
+        exclude: [] | undefined;
+        format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
+          baseFeePerGas: bigint | null;
+          blobGasUsed: bigint;
+          difficulty: bigint;
+          excessBlobGas: bigint;
+          extraData: import("viem").Hex;
+          gasLimit: bigint;
+          gasUsed: bigint;
+          hash: `0x${string}` | null;
+          logsBloom: `0x${string}` | null;
+          miner: import("viem").Address;
+          mixHash: import("viem").Hash;
+          nonce: `0x${string}` | null;
+          number: bigint | null;
+          parentBeaconBlockRoot?: `0x${string}` | undefined;
+          parentHash: import("viem").Hash;
+          receiptsRoot: import("viem").Hex;
+          sealFields: import("viem").Hex[];
+          sha3Uncles: import("viem").Hash;
+          size: bigint;
+          stateRoot: import("viem").Hash;
+          timestamp: bigint;
+          totalDifficulty: bigint | null;
+          transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+          transactionsRoot: import("viem").Hash;
+          uncles: import("viem").Hash[];
+          withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
+          withdrawalsRoot?: `0x${string}` | undefined;
+        } & {};
+        type: "block";
+      };
+      readonly transaction: {
+        exclude: [] | undefined;
+        format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: boolean;
+          mint?: bigint | undefined | undefined;
+          sourceHash: import("viem").Hex;
+          type: "deposit";
+        } | {
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          v: bigint;
+          to: import("viem").Address | null;
+          from: import("viem").Address;
+          gas: bigint;
+          nonce: number;
+          value: bigint;
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          accessList?: undefined | undefined;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes?: undefined | undefined;
+          chainId?: number | undefined;
+          yParity?: undefined | undefined;
+          type: "legacy";
+          gasPrice: bigint;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas?: undefined | undefined;
+          maxPriorityFeePerGas?: undefined | undefined;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes?: undefined | undefined;
+          chainId: number;
+          type: "eip2930";
+          gasPrice: bigint;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas?: undefined | undefined;
+          maxPriorityFeePerGas?: undefined | undefined;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes?: undefined | undefined;
+          chainId: number;
+          type: "eip1559";
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes: readonly import("viem").Hex[];
+          chainId: number;
+          type: "eip4844";
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas: bigint;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList: import("viem").SignedAuthorizationList;
+          blobVersionedHashes?: undefined | undefined;
+          chainId: number;
+          type: "eip7702";
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        }) & {};
+        type: "transaction";
+      };
+      readonly transactionReceipt: {
+        exclude: [] | undefined;
+        format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
+          blobGasPrice?: bigint | undefined;
+          blobGasUsed?: bigint | undefined;
+          blockHash: import("viem").Hash;
+          blockNumber: bigint;
+          blockTimestamp?: bigint | undefined;
+          contractAddress: import("viem").Address | null | undefined;
+          cumulativeGasUsed: bigint;
+          effectiveGasPrice: bigint;
+          from: import("viem").Address;
+          gasUsed: bigint;
+          logs: import("viem").Log<bigint, number, false>[];
+          logsBloom: import("viem").Hex;
+          root?: `0x${string}` | undefined;
+          status: "success" | "reverted";
+          to: import("viem").Address | null;
+          transactionHash: import("viem").Hash;
+          transactionIndex: number;
+          type: import("viem").TransactionType;
+          l1GasPrice: bigint | null;
+          l1GasUsed: bigint | null;
+          l1Fee: bigint | null;
+          l1FeeScalar: number | null;
+        } & {};
+        type: "transactionReceipt";
+      };
+    };
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers: {
+      readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+    };
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly polygon: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "PolygonScan";
+        readonly url: "https://polygonscan.com";
+        readonly apiUrl: "https://api.etherscan.io/v2/api";
+      };
+    };
+    blockTime: 2000;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 25770160;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 137;
+    name: "Polygon";
+    nativeCurrency: {
+      readonly name: "POL";
+      readonly symbol: "POL";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://polygon.drpc.org"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly soneium: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Blockscout";
+        readonly url: "https://soneium.blockscout.com";
+        readonly apiUrl: "https://soneium.blockscout.com/api";
+      };
+    };
+    blockTime: 2000;
+    contracts: {
+      readonly disputeGameFactory: {
+        readonly 1: {
+          readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
+        };
+      };
+      readonly l2OutputOracle: {
+        readonly 1: {
+          readonly address: "0x0000000000000000000000000000000000000000";
+        };
+      };
+      readonly portal: {
+        readonly 1: {
+          readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
+          readonly blockCreated: 7061266;
+        };
+      };
+      readonly l1StandardBridge: {
+        readonly 1: {
+          readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
+          readonly blockCreated: 7061266;
+        };
+      };
+      readonly multicall3: {
+        readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+        readonly blockCreated: 1;
+      };
+      readonly gasPriceOracle: {
+        readonly address: "0x420000000000000000000000000000000000000F";
+      };
+      readonly l1Block: {
+        readonly address: "0x4200000000000000000000000000000000000015";
+      };
+      readonly l2CrossDomainMessenger: {
+        readonly address: "0x4200000000000000000000000000000000000007";
+      };
+      readonly l2Erc721Bridge: {
+        readonly address: "0x4200000000000000000000000000000000000014";
+      };
+      readonly l2StandardBridge: {
+        readonly address: "0x4200000000000000000000000000000000000010";
+      };
+      readonly l2ToL1MessagePasser: {
+        readonly address: "0x4200000000000000000000000000000000000016";
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 1868;
+    name: "Soneium Mainnet";
+    nativeCurrency: {
+      readonly name: "Ether";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://rpc.soneium.org"];
+      };
+    };
+    sourceId: 1;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+      readonly block: {
+        exclude: [] | undefined;
+        format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
+          baseFeePerGas: bigint | null;
+          blobGasUsed: bigint;
+          difficulty: bigint;
+          excessBlobGas: bigint;
+          extraData: import("viem").Hex;
+          gasLimit: bigint;
+          gasUsed: bigint;
+          hash: `0x${string}` | null;
+          logsBloom: `0x${string}` | null;
+          miner: import("viem").Address;
+          mixHash: import("viem").Hash;
+          nonce: `0x${string}` | null;
+          number: bigint | null;
+          parentBeaconBlockRoot?: `0x${string}` | undefined;
+          parentHash: import("viem").Hash;
+          receiptsRoot: import("viem").Hex;
+          sealFields: import("viem").Hex[];
+          sha3Uncles: import("viem").Hash;
+          size: bigint;
+          stateRoot: import("viem").Hash;
+          timestamp: bigint;
+          totalDifficulty: bigint | null;
+          transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+          transactionsRoot: import("viem").Hash;
+          uncles: import("viem").Hash[];
+          withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
+          withdrawalsRoot?: `0x${string}` | undefined;
+        } & {};
+        type: "block";
+      };
+      readonly transaction: {
+        exclude: [] | undefined;
+        format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: boolean;
+          mint?: bigint | undefined | undefined;
+          sourceHash: import("viem").Hex;
+          type: "deposit";
+        } | {
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          v: bigint;
+          to: import("viem").Address | null;
+          from: import("viem").Address;
+          gas: bigint;
+          nonce: number;
+          value: bigint;
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          accessList?: undefined | undefined;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes?: undefined | undefined;
+          chainId?: number | undefined;
+          yParity?: undefined | undefined;
+          type: "legacy";
+          gasPrice: bigint;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas?: undefined | undefined;
+          maxPriorityFeePerGas?: undefined | undefined;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes?: undefined | undefined;
+          chainId: number;
+          type: "eip2930";
+          gasPrice: bigint;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas?: undefined | undefined;
+          maxPriorityFeePerGas?: undefined | undefined;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes?: undefined | undefined;
+          chainId: number;
+          type: "eip1559";
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList?: undefined | undefined;
+          blobVersionedHashes: readonly import("viem").Hex[];
+          chainId: number;
+          type: "eip4844";
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas: bigint;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        } | {
+          blockHash: `0x${string}` | null;
+          blockNumber: bigint | null;
+          blockTimestamp?: bigint | undefined;
+          from: import("viem").Address;
+          gas: bigint;
+          hash: import("viem").Hash;
+          input: import("viem").Hex;
+          nonce: number;
+          r: import("viem").Hex;
+          s: import("viem").Hex;
+          to: import("viem").Address | null;
+          transactionIndex: number | null;
+          typeHex: import("viem").Hex | null;
+          v: bigint;
+          value: bigint;
+          yParity: number;
+          accessList: import("viem").AccessList;
+          authorizationList: import("viem").SignedAuthorizationList;
+          blobVersionedHashes?: undefined | undefined;
+          chainId: number;
+          type: "eip7702";
+          gasPrice?: undefined | undefined;
+          maxFeePerBlobGas?: undefined | undefined;
+          maxFeePerGas: bigint;
+          maxPriorityFeePerGas: bigint;
+          isSystemTx?: undefined | undefined;
+          mint?: undefined | undefined;
+          sourceHash?: undefined | undefined;
+        }) & {};
+        type: "transaction";
+      };
+      readonly transactionReceipt: {
+        exclude: [] | undefined;
+        format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
+          blobGasPrice?: bigint | undefined;
+          blobGasUsed?: bigint | undefined;
+          blockHash: import("viem").Hash;
+          blockNumber: bigint;
+          blockTimestamp?: bigint | undefined;
+          contractAddress: import("viem").Address | null | undefined;
+          cumulativeGasUsed: bigint;
+          effectiveGasPrice: bigint;
+          from: import("viem").Address;
+          gasUsed: bigint;
+          logs: import("viem").Log<bigint, number, false>[];
+          logsBloom: import("viem").Hex;
+          root?: `0x${string}` | undefined;
+          status: "success" | "reverted";
+          to: import("viem").Address | null;
+          transactionHash: import("viem").Hash;
+          transactionIndex: number;
+          type: import("viem").TransactionType;
+          l1GasPrice: bigint | null;
+          l1GasUsed: bigint | null;
+          l1Fee: bigint | null;
+          l1FeeScalar: number | null;
+        } & {};
+        type: "transactionReceipt";
+      };
+    };
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers: {
+      readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+    };
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+  readonly somnia: {
+    readonly id: 5031;
+    readonly name: "Somnia";
+    readonly nativeCurrency: {
+      readonly decimals: 18;
+      readonly name: "SOMI";
+      readonly symbol: "SOMI";
+    };
+    readonly rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://api.infra.mainnet.somnia.network"];
+      };
+      readonly public: {
+        readonly http: readonly ["https://api.infra.mainnet.somnia.network"];
+      };
+    };
+    readonly blockExplorers: {
+      readonly default: {
+        readonly name: "Somnia Explorer";
+        readonly url: "https://explorer.somnia.network/";
+      };
+    };
+  };
+  readonly sonic: {
+    blockExplorers: {
+      readonly default: {
+        readonly name: "Sonic Explorer";
+        readonly url: "https://sonicscan.org";
+      };
+    };
+    blockTime: 630;
+    contracts: {
+      readonly multicall3: {
+        readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+        readonly blockCreated: 60;
+      };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 146;
+    name: "Sonic";
+    nativeCurrency: {
+      readonly decimals: 18;
+      readonly name: "Sonic";
+      readonly symbol: "S";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://rpc.soniclabs.com"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+      client: import("viem").Client;
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+  };
+};
+type SupportedChainName = keyof typeof supportedChainsByName;
+type SupportedChainId = (typeof supportedChainsByName)[SupportedChainName]["id"];
+//#endregion
+//#region src/actions/resolvers.d.ts
+type SwapProvider = "UNISWAP_V3" | "SUSHISWAP_V3";
+//#endregion
+//#region src/actions/types.d.ts
+type HydrateDataType = "self" | "msg.sender" | "tx.origin" | Address.Address;
+type HydrateTypeAddress = {
+  type: "address";
+  address: HydrateDataType;
+  calldataOffset: number;
+};
+type HydrateTypeBalance = {
+  type: "balance";
+  address: HydrateDataType;
+  calldataOffset: number;
+};
+type HydrateTypeERC20Balance = {
+  type: "erc20Balance";
+  token: Address.Address;
+  address: HydrateDataType;
+  calldataOffset: number;
+};
+type HydrateTypeERC20Allowance = {
+  type: "erc20Allowance";
+  token: Address.Address;
+  address: HydrateDataType;
+  spender: HydrateDataType;
+  calldataOffset: number;
+};
+type HydrateTypeTo = {
+  type: "to";
+  address: HydrateDataType;
+};
+type HydrateTypeValue = {
+  type: "value";
+  address: HydrateDataType;
+};
+type HydrateTypeData = HydrateTypeAddress | HydrateTypeBalance | HydrateTypeERC20Balance | HydrateTypeERC20Allowance | HydrateTypeTo | HydrateTypeValue;
+type Call$1 = Call & {
+  /**
+   * When set, the hydration encoder reads this token's full ERC-20 balance at
+   * execution time and injects it into the calldata slot that contains the
+   * `dynamic()` sentinel.
+   *
+   * Use this for chained actions where the amount depends on a previous step's
+   * output (e.g. swap output fed into a lending supply), and for any custom
+   * call whose calldata carries a `dynamic()` amount.
+   *
+   * **Required** whenever `data` contains a `dynamic()` sentinel, UNLESS the
+   * call itself is an ERC-20 `approve(spender, dynamic())` — in that case
+   * `to` IS the token contract and the encoder infers it. There is no
+   * implicit fallback to the batch destination token; forgetting this field
+   * for a non-approve call makes the encoder throw.
+   */
+  dynamicAmountToken?: Address.Address;
+  /**
+   * ERC-20 balances to use for multiple `dynamic()` amount slots in one call.
+   * Tokens are matched in the same order the dynamic amounts appear in the
+   * encoded call data. Use `dynamicAmountToken` when every slot uses the same
+   * token balance.
+   */
+  dynamicAmountTokens?: Address.Address[];
+  /**
+   * Additional hydration entries for this call. HydrateProxy will apply these
+   * at runtime before executing the call.
+   *
+   * Use this to inject runtime-resolved values (wallet address, ETH balance,
+   * ERC-20 allowance, etc.) into specific calldata offsets.
+   *
+   * Entries are appended after any auto-detected placeholder hydrations.
+   */
+  hydrateEntries?: HydrateTypeData[];
+  /**
+   * Tokens to automatically refund to the user if they get stuck in the intent
+   * wallet.
+   *
+   * Pass the zero address (`0x0000…0000`) to also auto-refund native ETH.
+   *
+   * The SDK handles this automatically when your calldata only touches a
+   * single token, the encoder infers it from the approve target or the
+   * `dynamicAmountToken`, and no extra declaration is needed.
+   *
+   * You only need to fill `sweepTokens` when a call involves more than one
+   * token and the encoder can't see all of them from the calldata alone. The
+   * canonical example is a swap: the input token is visible (via the approve
+   * or `dynamicAmountToken`), but the output token is hidden inside the
+   * swap's calldata, so the integration must declare it here to make sure
+   * any leftover output is refunded instead of stranded.
+   */
+  sweepTokens?: Address.Address[];
+};
+type CallWithData = Call$1 & {
+  data: `0x${string}`;
+};
+type ChainName = SupportedChainName;
+type ChainId = SupportedChainId | (number & {});
+type ChainIdentifier = ChainName | ChainId;
+declare const ERC20_UTIL_TOKENS: {
+  readonly ETH: "ETH";
+  readonly WETH: "WETH";
+  readonly WETHe: "WETH.e";
+  readonly USDC: "USDC";
+  readonly USDT: "USDT";
+  readonly DAI: "DAI";
+  readonly BAT: "BAT";
+  readonly ARB: "ARB";
+  readonly LINK: "LINK";
+  readonly MATIC: "MATIC";
+  readonly POL: "POL";
+  readonly XTZ: "XTZ";
+  readonly WXTZ: "WXTZ";
+  readonly BNB: "BNB";
+  readonly AVAX: "AVAX";
+  readonly SOMI: "SOMI";
+  readonly MON: "MON";
+  readonly WMON: "WMON";
+};
+type SupportedTokenSymbol = (typeof ERC20_UTIL_TOKENS)[keyof typeof ERC20_UTIL_TOKENS];
+type TokenOrAddress = Address.Address | SupportedTokenSymbol;
+type AbiEncodedData = {
+  abi: Abi;
+  functionName: string;
+  args?: readonly unknown[];
+};
+type BuildCallParams = {
+  /** Target contract address. */to: Address.Address; /** Raw hex calldata, or an object that will be ABI-encoded via `encodeFunctionData`. */
+  data: `0x${string}` | AbiEncodedData; /** Optional native value to send with the call. */
+  value?: bigint;
+  /**
+   * Token whose runtime balance replaces the `dynamic()` sentinel in
+   * calldata. Required whenever `data` contains a `dynamic()` amount and the
+   * call is not a bare `approve(spender, dynamic())`. No implicit fallback
+   * to the batch destination token — the encoder throws otherwise.
+   */
+  dynamicAmountToken?: Address.Address;
+  /**
+   * Token sources for multiple `dynamic()` amount slots in `data`, in
+   * encoded calldata order.
+   */
+  dynamicAmountTokens?: Address.Address[]; /** Additional ERC-20 or native assets to sweep after execution. */
+  sweepTokens?: Address.Address[];
+};
+type BuildApproveAndCallParams = {
+  /** ERC-20 token address to approve. */token: Address.Address; /** A single call to prepend with an approval. Provide either `call` or `calls`. */
+  call: Call$1; /** Custom approval amount. Defaults to `maxUint256`. */
+  amount?: bigint;
+};
+type TokenInfo$1 = {
+  address: Address.Address;
+  decimals: number;
+  name: string;
+  imageUrl: string;
+};
+type TokenAccessor = {
+  /** Token address and decimals on the given chain. */onChain: (chain: ChainIdentifier) => TokenInfo$1; /** Token address on the given chain (shorthand when you only need the address). */
+  addressOn: (chain: ChainIdentifier) => Address.Address; /** Token decimals on the given chain. */
+  decimalsOn: (chain: ChainIdentifier) => number;
+};
+type Erc20Utils = {
+  /** Look up a token by symbol (programmatic access).
+   * @example
+   * ```ts
+   * const { address, decimals } = erc20Utils.token("USDC").onChain("base")
+   * ```
+   */
+  token: (symbol: SupportedTokenSymbol) => TokenAccessor; /** Build an ERC-20 `transfer` call. */
+  transfer: (params: TransferParams) => CallWithData; /** Build an ERC-20 `approve` call. */
+  approve: (params: ApproveParams) => CallWithData; /** Build an ERC-20 `transferFrom` call. */
+  transferFrom: (params: TransferFromParams) => CallWithData;
+} & Record<keyof typeof ERC20_UTIL_TOKENS, TokenAccessor>;
+type FeePercent = "0.01" | "0.05" | "0.3" | "1";
+type TransferParams = {
+  tokenAddress: Address.Address;
+  to: Address.Address;
+  amount: bigint;
+};
+type ApproveParams = {
+  tokenAddress: Address.Address;
+  spender: Address.Address;
+  amount: bigint;
+};
+type TransferFromParams = {
+  tokenAddress: Address.Address;
+  from: Address.Address;
+  to: Address.Address;
+  amount: bigint;
+};
+/**
+ * Direction of an earn-style action.
+ *
+ * Only `"enter"` is supported — the action builders and `useQuote` are
+ * intentionally scoped to deposits / supplies. Exits (withdrawals) are not part of the Trails intent pipeline, use
+ * the protocol's own withdrawal flow directly.
+ */
+type ActionDirection = "enter";
+/**
+ * An amount accepted by action builders.
+ *
+ * - `string` — human-readable decimal (e.g. `"0.5"`); parsed with the token's
+ *   decimals by the resolver.
+ * - `bigint` — raw wei; used as-is without scaling.
+ * - `dynamic()` sentinel — resolved to the intent wallet's runtime balance at
+ *   execution time.
+ */
+type ActionAmount = string | bigint;
+type LendActionItem = {
+  type: "lend";
+  marketId: string;
+  amount: ActionAmount;
+  receiverAddress?: `0x${string}`;
+  inputToken?: string;
+  inputTokenNetwork?: string;
+  direction?: ActionDirection;
+};
+type SwapActionItem = {
+  type: "swap";
+  swapType?: SwapType;
+  provider?: SwapProvider;
+  tokenIn: TokenOrAddress;
+  tokenOut: TokenOrAddress;
+  fee: FeePercent; /** EXACT_INPUT input amount. String = human-readable; bigint = raw wei. */
+  amountIn?: ActionAmount; /** EXACT_INPUT minimum output. String = human-readable; bigint = raw wei. */
+  minAmountOut?: ActionAmount; /** EXACT_OUTPUT output amount. String = human-readable; bigint = raw wei. */
+  amountOut?: ActionAmount;
+  /**
+   * EXACT_OUTPUT maximum input. String = human-readable; bigint = raw wei.
+   * Omit or set to `"dynamic"` / `dynamic()` to let Trails inject the available
+   * balance at runtime.
+   */
+  maxAmountIn?: ActionAmount;
+  /**
+   * Destination of the swap output. When omitted the resolver routes output
+   * to the user's wallet for the final action and to `self()` for
+   * intermediate actions so downstream steps can consume it.
+   */
+  recipient?: Address.Address;
+};
+type DepositActionItem = {
+  type: "deposit";
+  marketId: string;
+  amount: ActionAmount;
+  receiverAddress?: `0x${string}`;
+  inputToken?: string;
+  inputTokenNetwork?: string;
+  useMaxAllowance?: boolean;
+  direction?: ActionDirection;
+};
+type CustomActionItem = {
+  type: "custom";
+  to: Address.Address;
+  data: `0x${string}`;
+  value?: bigint;
+  dynamicAmountToken?: Address.Address;
+  dynamicAmountTokens?: Address.Address[];
+  sweepTokens?: Address.Address[];
+  /**
+   * Hydration entries attached to the resolved `Call`. Populated by
+   * `custom()` when the caller asks for runtime-resolved fields
+   * (e.g. `value: dynamic()` synthesises a `{ type: "value", address: "self" }`
+   * entry). Forwarded verbatim by `useResolveActions` into `Call.hydrateEntries`.
+   *
+   * This field is SDK-internal plumbing — callers express hydration needs via
+   * high-level sugar (`dynamic()`, `self()`) on builder params, not by populating
+   * this list directly.
+   */
+  hydrateEntries?: HydrateTypeData[];
+};
+type AssertERC20BalanceItem = {
+  type: "assert";
+  assertType: "erc20Balance";
+  token: TokenOrAddress;
+  gte: ActionAmount;
+};
+type AssertNativeBalanceItem = {
+  type: "assert";
+  assertType: "nativeBalance";
+  gte: ActionAmount;
+};
+type AssertNotExpiredItem = {
+  type: "assert";
+  assertType: "notExpired";
+  deadline: number;
+};
+type AssertERC20AllowanceItem = {
+  type: "assert";
+  assertType: "erc20Allowance";
+  token: TokenOrAddress;
+  spender: `0x${string}`;
+  gte: ActionAmount;
+};
+type AssertActionItem = AssertERC20BalanceItem | AssertNativeBalanceItem | AssertNotExpiredItem | AssertERC20AllowanceItem;
+type ActionItem = LendActionItem | SwapActionItem | DepositActionItem | CustomActionItem | AssertActionItem;
+//#endregion
+export { SupportedChainId as A, SupportedTokenSymbol as C, TokenOrAddress as D, TokenInfo$1 as E, SwapProvider as O, LendActionItem as S, TokenAccessor as T, CustomActionItem as _, AssertActionItem as a, FeePercent as b, AssertNativeBalanceItem as c, BuildCallParams as d, Call$1 as f, ChainName as g, ChainIdentifier as h, ApproveParams as i, SupportedChainName as j, SwapType as k, AssertNotExpiredItem as l, ChainId as m, ActionDirection as n, AssertERC20AllowanceItem as o, CallWithData as p, ActionItem as r, AssertERC20BalanceItem as s, ActionAmount as t, BuildApproveAndCallParams as u, DepositActionItem as v, SwapActionItem as w, HydrateTypeData as x, Erc20Utils as y };