@rhinestone/shared-configs 1.6.2 → 1.6.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (14) hide show
  1. package/dist/configs/chains.json +114 -0
  2. package/dist/configs/mainnets.json +12 -0
  3. package/dist/configs/oft.json +3 -0
  4. package/dist/configs/providers.json +6 -0
  5. package/dist/src/chains.d.ts.map +1 -1
  6. package/dist/src/chains.js +122 -0
  7. package/dist/src/generated/contracts.d.ts.map +1 -1
  8. package/dist/src/generated/contracts.dev.d.ts.map +1 -1
  9. package/dist/src/generated/contracts.dev.js +22 -0
  10. package/dist/src/generated/contracts.js +22 -0
  11. package/dist/src/generated/networks.d.ts +2654 -730
  12. package/dist/src/generated/networks.d.ts.map +1 -1
  13. package/dist/src/generated/networks.js +3 -1
  14. package/package.json +1 -1
package/dist/src/generated/networks.d.ts CHANGED
@@ -1659,6 +1659,967 @@ declare const mainnetChains: ({
1659
1659
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
1660
1660
  };
1661
1661
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1662
+ } | {
1663
+ blockExplorers: {
1664
+ readonly default: {
1665
+ readonly name: "katana explorer";
1666
+ readonly url: "https://katanascan.com";
1667
+ };
1668
+ };
1669
+ blockTime?: number | undefined | undefined;
1670
+ contracts?: {
1671
+ [x: string]: import("viem").ChainContract | {
1672
+ [sourceId: number]: import("viem").ChainContract | undefined;
1673
+ } | undefined;
1674
+ ensRegistry?: import("viem").ChainContract | undefined;
1675
+ ensUniversalResolver?: import("viem").ChainContract | undefined;
1676
+ multicall3?: import("viem").ChainContract | undefined;
1677
+ erc6492Verifier?: import("viem").ChainContract | undefined;
1678
+ } | undefined;
1679
+ ensTlds?: readonly string[] | undefined;
1680
+ id: 747474;
1681
+ name: "Katana";
1682
+ nativeCurrency: {
1683
+ readonly name: "Ether";
1684
+ readonly symbol: "ETH";
1685
+ readonly decimals: 18;
1686
+ };
1687
+ experimental_preconfirmationTime?: number | undefined | undefined;
1688
+ rpcUrls: {
1689
+ readonly default: {
1690
+ readonly http: readonly ["https://rpc.katana.network"];
1691
+ };
1692
+ };
1693
+ sourceId?: number | undefined | undefined;
1694
+ testnet: false;
1695
+ custom?: Record<string, unknown> | undefined;
1696
+ extendSchema?: Record<string, unknown> | undefined;
1697
+ fees?: import("viem").ChainFees<undefined> | undefined;
1698
+ formatters?: undefined;
1699
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1700
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1701
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1702
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1703
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1704
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1705
+ }] | undefined;
1706
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1707
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1708
+ readonly network: "katana";
1709
+ } | {
1710
+ blockExplorers: {
1711
+ readonly default: {
1712
+ readonly name: "Tempo Explorer";
1713
+ readonly url: "https://explore.mainnet.tempo.xyz";
1714
+ };
1715
+ };
1716
+ blockTime: 1000;
1717
+ contracts?: {
1718
+ [x: string]: import("viem").ChainContract | {
1719
+ [sourceId: number]: import("viem").ChainContract | undefined;
1720
+ } | undefined;
1721
+ ensRegistry?: import("viem").ChainContract | undefined;
1722
+ ensUniversalResolver?: import("viem").ChainContract | undefined;
1723
+ multicall3?: import("viem").ChainContract | undefined;
1724
+ erc6492Verifier?: import("viem").ChainContract | undefined;
1725
+ } | undefined;
1726
+ ensTlds?: readonly string[] | undefined;
1727
+ id: 4217;
1728
+ name: "Tempo Mainnet";
1729
+ nativeCurrency: {
1730
+ readonly name: "USD";
1731
+ readonly symbol: "USD";
1732
+ readonly decimals: 6;
1733
+ };
1734
+ experimental_preconfirmationTime?: number | undefined | undefined;
1735
+ rpcUrls: {
1736
+ readonly default: {
1737
+ readonly http: readonly ["https://rpc.presto.tempo.xyz"];
1738
+ readonly webSocket: readonly ["wss://rpc.presto.tempo.xyz"];
1739
+ };
1740
+ };
1741
+ sourceId?: number | undefined | undefined;
1742
+ testnet?: boolean | undefined | undefined;
1743
+ custom?: Record<string, unknown> | undefined;
1744
+ extendSchema: {
1745
+ feeToken?: import("ox/tempo/TokenId").TokenIdOrAddress | undefined;
1746
+ };
1747
+ fees?: import("viem").ChainFees<undefined> | undefined;
1748
+ formatters: {
1749
+ readonly transaction: {
1750
+ exclude: never[] | undefined;
1751
+ format: (args: import("viem/_types/tempo/Transaction").TransactionRpc, action?: string | undefined) => ({
1752
+ r: import("viem").Hex;
1753
+ s: import("viem").Hex;
1754
+ v: bigint;
1755
+ to: import("abitype").Address | null;
1756
+ from: import("abitype").Address;
1757
+ gas: bigint;
1758
+ nonce: number;
1759
+ value: bigint;
1760
+ blockHash: `0x${string}` | null;
1761
+ blockNumber: bigint | null;
1762
+ hash: import("viem").Hash;
1763
+ input: import("viem").Hex;
1764
+ transactionIndex: number | null;
1765
+ typeHex: import("viem").Hex | null;
1766
+ accessList?: undefined | undefined;
1767
+ authorizationList?: undefined | undefined;
1768
+ blobVersionedHashes?: undefined | undefined;
1769
+ chainId?: number | undefined;
1770
+ yParity?: undefined | undefined;
1771
+ type: "legacy";
1772
+ gasPrice: bigint;
1773
+ maxFeePerBlobGas?: undefined | undefined;
1774
+ maxFeePerGas?: undefined | undefined;
1775
+ maxPriorityFeePerGas?: undefined | undefined;
1776
+ signature?: undefined;
1777
+ calls?: undefined;
1778
+ nonceKey?: undefined;
1779
+ validAfter?: undefined;
1780
+ feeToken?: undefined;
1781
+ feePayerSignature?: undefined;
1782
+ keyAuthorization?: undefined;
1783
+ validBefore?: undefined;
1784
+ } | {
1785
+ blockHash: `0x${string}` | null;
1786
+ blockNumber: bigint | null;
1787
+ from: import("abitype").Address;
1788
+ gas: bigint;
1789
+ hash: import("viem").Hash;
1790
+ input: import("viem").Hex;
1791
+ nonce: number;
1792
+ r: import("viem").Hex;
1793
+ s: import("viem").Hex;
1794
+ to: import("abitype").Address | null;
1795
+ transactionIndex: number | null;
1796
+ typeHex: import("viem").Hex | null;
1797
+ v: bigint;
1798
+ value: bigint;
1799
+ yParity: number;
1800
+ accessList: import("viem").AccessList;
1801
+ authorizationList?: undefined | undefined;
1802
+ blobVersionedHashes?: undefined | undefined;
1803
+ chainId: number;
1804
+ type: "eip2930";
1805
+ gasPrice: bigint;
1806
+ maxFeePerBlobGas?: undefined | undefined;
1807
+ maxFeePerGas?: undefined | undefined;
1808
+ maxPriorityFeePerGas?: undefined | undefined;
1809
+ signature?: undefined;
1810
+ calls?: undefined;
1811
+ nonceKey?: undefined;
1812
+ validAfter?: undefined;
1813
+ feeToken?: undefined;
1814
+ feePayerSignature?: undefined;
1815
+ keyAuthorization?: undefined;
1816
+ validBefore?: undefined;
1817
+ } | {
1818
+ blockHash: `0x${string}` | null;
1819
+ blockNumber: bigint | null;
1820
+ from: import("abitype").Address;
1821
+ gas: bigint;
1822
+ hash: import("viem").Hash;
1823
+ input: import("viem").Hex;
1824
+ nonce: number;
1825
+ r: import("viem").Hex;
1826
+ s: import("viem").Hex;
1827
+ to: import("abitype").Address | null;
1828
+ transactionIndex: number | null;
1829
+ typeHex: import("viem").Hex | null;
1830
+ v: bigint;
1831
+ value: bigint;
1832
+ yParity: number;
1833
+ accessList: import("viem").AccessList;
1834
+ authorizationList?: undefined | undefined;
1835
+ blobVersionedHashes?: undefined | undefined;
1836
+ chainId: number;
1837
+ type: "eip1559";
1838
+ gasPrice?: undefined | undefined;
1839
+ maxFeePerBlobGas?: undefined | undefined;
1840
+ maxFeePerGas: bigint;
1841
+ maxPriorityFeePerGas: bigint;
1842
+ signature?: undefined;
1843
+ calls?: undefined;
1844
+ nonceKey?: undefined;
1845
+ validAfter?: undefined;
1846
+ feeToken?: undefined;
1847
+ feePayerSignature?: undefined;
1848
+ keyAuthorization?: undefined;
1849
+ validBefore?: undefined;
1850
+ } | {
1851
+ blockHash: `0x${string}` | null;
1852
+ blockNumber: bigint | null;
1853
+ from: import("abitype").Address;
1854
+ gas: bigint;
1855
+ hash: import("viem").Hash;
1856
+ input: import("viem").Hex;
1857
+ nonce: number;
1858
+ r: import("viem").Hex;
1859
+ s: import("viem").Hex;
1860
+ to: import("abitype").Address | null;
1861
+ transactionIndex: number | null;
1862
+ typeHex: import("viem").Hex | null;
1863
+ v: bigint;
1864
+ value: bigint;
1865
+ yParity: number;
1866
+ accessList: import("viem").AccessList;
1867
+ authorizationList?: undefined | undefined;
1868
+ blobVersionedHashes: readonly import("viem").Hex[];
1869
+ chainId: number;
1870
+ type: "eip4844";
1871
+ gasPrice?: undefined | undefined;
1872
+ maxFeePerBlobGas: bigint;
1873
+ maxFeePerGas: bigint;
1874
+ maxPriorityFeePerGas: bigint;
1875
+ signature?: undefined;
1876
+ calls?: undefined;
1877
+ nonceKey?: undefined;
1878
+ validAfter?: undefined;
1879
+ feeToken?: undefined;
1880
+ feePayerSignature?: undefined;
1881
+ keyAuthorization?: undefined;
1882
+ validBefore?: undefined;
1883
+ } | {
1884
+ blockHash: `0x${string}` | null;
1885
+ blockNumber: bigint | null;
1886
+ from: import("abitype").Address;
1887
+ gas: bigint;
1888
+ hash: import("viem").Hash;
1889
+ input: import("viem").Hex;
1890
+ nonce: number;
1891
+ r: import("viem").Hex;
1892
+ s: import("viem").Hex;
1893
+ to: import("abitype").Address | null;
1894
+ transactionIndex: number | null;
1895
+ typeHex: import("viem").Hex | null;
1896
+ v: bigint;
1897
+ value: bigint;
1898
+ yParity: number;
1899
+ accessList: import("viem").AccessList;
1900
+ authorizationList: import("viem").SignedAuthorizationList;
1901
+ blobVersionedHashes?: undefined | undefined;
1902
+ chainId: number;
1903
+ type: "eip7702";
1904
+ gasPrice?: undefined | undefined;
1905
+ maxFeePerBlobGas?: undefined | undefined;
1906
+ maxFeePerGas: bigint;
1907
+ maxPriorityFeePerGas: bigint;
1908
+ signature?: undefined;
1909
+ calls?: undefined;
1910
+ nonceKey?: undefined;
1911
+ validAfter?: undefined;
1912
+ feeToken?: undefined;
1913
+ feePayerSignature?: undefined;
1914
+ keyAuthorization?: undefined;
1915
+ validBefore?: undefined;
1916
+ } | {
1917
+ from: import("abitype").Address;
1918
+ gas: bigint;
1919
+ nonce: number;
1920
+ blockHash: `0x${string}` | null;
1921
+ blockNumber: bigint | null;
1922
+ hash: import("viem").Hash;
1923
+ transactionIndex: number | null;
1924
+ typeHex: import("viem").Hex | null;
1925
+ r?: `0x${string}` | undefined;
1926
+ s?: `0x${string}` | undefined;
1927
+ v?: bigint | undefined;
1928
+ yParity?: number | undefined;
1929
+ accessList: import("viem").AccessList;
1930
+ authorizationList?: readonly {
1931
+ address: import("ox/_types/core/Address").Address;
1932
+ chainId: number;
1933
+ nonce: bigint;
1934
+ signature: import("ox/tempo/SignatureEnvelope").SignatureEnvelope<bigint, number>;
1935
+ }[] | undefined;
1936
+ calls: readonly import("ox/tempo/TxEnvelopeTempo").Call<bigint>[];
1937
+ chainId: number;
1938
+ feeToken?: `0x${string}` | undefined;
1939
+ feePayerSignature?: import("viem").Signature | undefined;
1940
+ keyAuthorization?: import("ox/tempo/KeyAuthorization").Signed<bigint, number> | null | undefined;
1941
+ nonceKey?: bigint | undefined;
1942
+ signature: import("ox/tempo/SignatureEnvelope").SignatureEnvelope;
1943
+ type: "tempo";
1944
+ validBefore?: number | undefined;
1945
+ validAfter?: number | undefined;
1946
+ gasPrice?: undefined | undefined;
1947
+ maxFeePerBlobGas?: undefined | undefined;
1948
+ maxFeePerGas: bigint;
1949
+ maxPriorityFeePerGas: bigint;
1950
+ to?: undefined;
1951
+ value?: undefined;
1952
+ blobVersionedHashes?: undefined;
1953
+ input?: undefined;
1954
+ }) & {};
1955
+ type: "transaction";
1956
+ };
1957
+ readonly transactionReceipt: {
1958
+ exclude: [] | undefined;
1959
+ format: (args: import("viem/_types/tempo/Transaction").TransactionReceiptRpc, action?: string | undefined) => {
1960
+ blobGasPrice?: bigint | undefined;
1961
+ blobGasUsed?: bigint | undefined;
1962
+ blockHash: import("viem").Hash;
1963
+ blockNumber: bigint;
1964
+ contractAddress: import("abitype").Address | null | undefined;
1965
+ cumulativeGasUsed: bigint;
1966
+ effectiveGasPrice: bigint;
1967
+ from: import("abitype").Address;
1968
+ gasUsed: bigint;
1969
+ logs: import("viem").Log<bigint, number, false>[];
1970
+ logsBloom: import("viem").Hex;
1971
+ root?: `0x${string}` | undefined;
1972
+ status: "success" | "reverted";
1973
+ to: import("abitype").Address | null;
1974
+ transactionHash: import("viem").Hash;
1975
+ transactionIndex: number;
1976
+ type: import("viem/_types/tempo/Transaction").TransactionType;
1977
+ feePayer?: `0x${string}` | undefined;
1978
+ feeToken?: `0x${string}` | undefined;
1979
+ } & {};
1980
+ type: "transactionReceipt";
1981
+ };
1982
+ readonly transactionRequest: {
1983
+ exclude: [] | undefined;
1984
+ format: (args: import("viem/_types/tempo/Transaction").TransactionRequest, action?: string | undefined) => ({
1985
+ data?: `0x${string}` | undefined;
1986
+ from?: `0x${string}` | undefined;
1987
+ gas?: `0x${string}` | undefined;
1988
+ nonce?: `0x${string}` | undefined;
1989
+ to?: `0x${string}` | null | undefined;
1990
+ type?: "0x0" | undefined;
1991
+ value?: `0x${string}` | undefined;
1992
+ gasPrice?: `0x${string}` | undefined;
1993
+ maxFeePerBlobGas?: undefined | undefined;
1994
+ maxFeePerGas?: undefined | undefined;
1995
+ maxPriorityFeePerGas?: undefined | undefined;
1996
+ blobs?: undefined;
1997
+ blobVersionedHashes?: undefined;
1998
+ kzg?: undefined;
1999
+ accessList?: undefined;
2000
+ sidecars?: undefined;
2001
+ authorizationList?: undefined;
2002
+ calls?: undefined;
2003
+ nonceKey?: undefined;
2004
+ validAfter?: undefined;
2005
+ feeToken?: undefined;
2006
+ keyAuthorization?: undefined;
2007
+ validBefore?: undefined;
2008
+ feePayer?: undefined;
2009
+ } | {
2010
+ data?: `0x${string}` | undefined;
2011
+ from?: `0x${string}` | undefined;
2012
+ gas?: `0x${string}` | undefined;
2013
+ nonce?: `0x${string}` | undefined;
2014
+ to?: `0x${string}` | null | undefined;
2015
+ type?: "0x1" | undefined;
2016
+ value?: `0x${string}` | undefined;
2017
+ gasPrice?: `0x${string}` | undefined;
2018
+ maxFeePerBlobGas?: undefined | undefined;
2019
+ maxFeePerGas?: undefined | undefined;
2020
+ maxPriorityFeePerGas?: undefined | undefined;
2021
+ accessList?: import("viem").AccessList | undefined;
2022
+ blobs?: undefined;
2023
+ blobVersionedHashes?: undefined;
2024
+ kzg?: undefined;
2025
+ sidecars?: undefined;
2026
+ authorizationList?: undefined;
2027
+ calls?: undefined;
2028
+ nonceKey?: undefined;
2029
+ validAfter?: undefined;
2030
+ feeToken?: undefined;
2031
+ keyAuthorization?: undefined;
2032
+ validBefore?: undefined;
2033
+ feePayer?: undefined;
2034
+ } | {
2035
+ data?: `0x${string}` | undefined;
2036
+ from?: `0x${string}` | undefined;
2037
+ gas?: `0x${string}` | undefined;
2038
+ nonce?: `0x${string}` | undefined;
2039
+ to?: `0x${string}` | null | undefined;
2040
+ type?: "0x2" | undefined;
2041
+ value?: `0x${string}` | undefined;
2042
+ gasPrice?: undefined | undefined;
2043
+ maxFeePerBlobGas?: undefined | undefined;
2044
+ maxFeePerGas?: `0x${string}` | undefined;
2045
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2046
+ accessList?: import("viem").AccessList | undefined;
2047
+ blobs?: undefined;
2048
+ blobVersionedHashes?: undefined;
2049
+ kzg?: undefined;
2050
+ sidecars?: undefined;
2051
+ authorizationList?: undefined;
2052
+ calls?: undefined;
2053
+ nonceKey?: undefined;
2054
+ validAfter?: undefined;
2055
+ feeToken?: undefined;
2056
+ keyAuthorization?: undefined;
2057
+ validBefore?: undefined;
2058
+ feePayer?: undefined;
2059
+ } | {
2060
+ type?: "0x3" | undefined;
2061
+ data?: `0x${string}` | undefined;
2062
+ from?: `0x${string}` | undefined;
2063
+ gas?: `0x${string}` | undefined;
2064
+ nonce?: `0x${string}` | undefined;
2065
+ value?: `0x${string}` | undefined;
2066
+ to: `0x${string}` | null;
2067
+ gasPrice?: undefined | undefined;
2068
+ maxFeePerBlobGas?: `0x${string}` | undefined;
2069
+ maxFeePerGas?: `0x${string}` | undefined;
2070
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2071
+ accessList?: import("viem").AccessList | undefined;
2072
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
2073
+ blobs?: readonly `0x${string}`[] | readonly import("viem").ByteArray[] | undefined;
2074
+ blobVersionedHashes: readonly import("viem").Hex[];
2075
+ kzg?: undefined;
2076
+ authorizationList?: undefined;
2077
+ calls?: undefined;
2078
+ nonceKey?: undefined;
2079
+ validAfter?: undefined;
2080
+ feeToken?: undefined;
2081
+ keyAuthorization?: undefined;
2082
+ validBefore?: undefined;
2083
+ feePayer?: undefined;
2084
+ } | {
2085
+ type?: "0x3" | undefined;
2086
+ data?: `0x${string}` | undefined;
2087
+ from?: `0x${string}` | undefined;
2088
+ gas?: `0x${string}` | undefined;
2089
+ nonce?: `0x${string}` | undefined;
2090
+ value?: `0x${string}` | undefined;
2091
+ to: `0x${string}` | null;
2092
+ gasPrice?: undefined | undefined;
2093
+ maxFeePerBlobGas?: `0x${string}` | undefined;
2094
+ maxFeePerGas?: `0x${string}` | undefined;
2095
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2096
+ accessList?: import("viem").AccessList | undefined;
2097
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
2098
+ blobs: readonly import("viem").Hex[] | readonly import("viem").ByteArray[];
2099
+ blobVersionedHashes?: readonly `0x${string}`[] | undefined;
2100
+ kzg?: import("viem").Kzg | undefined;
2101
+ authorizationList?: undefined;
2102
+ calls?: undefined;
2103
+ nonceKey?: undefined;
2104
+ validAfter?: undefined;
2105
+ feeToken?: undefined;
2106
+ keyAuthorization?: undefined;
2107
+ validBefore?: undefined;
2108
+ feePayer?: undefined;
2109
+ } | {
2110
+ type?: "0x4" | undefined;
2111
+ gasPrice?: undefined | undefined;
2112
+ maxFeePerBlobGas?: undefined | undefined;
2113
+ maxFeePerGas?: `0x${string}` | undefined;
2114
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2115
+ to?: `0x${string}` | null | undefined;
2116
+ data?: `0x${string}` | undefined;
2117
+ from?: `0x${string}` | undefined;
2118
+ gas?: `0x${string}` | undefined;
2119
+ nonce?: `0x${string}` | undefined;
2120
+ value?: `0x${string}` | undefined;
2121
+ accessList?: import("viem").AccessList | undefined;
2122
+ authorizationList?: import("viem").RpcAuthorizationList | undefined;
2123
+ blobs?: undefined;
2124
+ blobVersionedHashes?: undefined;
2125
+ kzg?: undefined;
2126
+ sidecars?: undefined;
2127
+ calls?: undefined;
2128
+ nonceKey?: undefined;
2129
+ validAfter?: undefined;
2130
+ feeToken?: undefined;
2131
+ keyAuthorization?: undefined;
2132
+ validBefore?: undefined;
2133
+ feePayer?: undefined;
2134
+ } | {
2135
+ data?: `0x${string}` | undefined;
2136
+ from?: `0x${string}` | undefined;
2137
+ gas?: `0x${string}` | undefined;
2138
+ nonce?: `0x${string}` | undefined;
2139
+ to?: `0x${string}` | null | undefined;
2140
+ type?: "0x76" | undefined;
2141
+ value?: `0x${string}` | undefined;
2142
+ gasPrice?: undefined | undefined;
2143
+ maxFeePerBlobGas?: undefined | undefined;
2144
+ maxFeePerGas?: `0x${string}` | undefined;
2145
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2146
+ accessList?: import("viem").AccessList | undefined;
2147
+ keyAuthorization?: import("ox/tempo/KeyAuthorization").Signed<`0x${string}`, `0x${string}`> | undefined;
2148
+ calls?: readonly import("ox/tempo/TxEnvelopeTempo").Call<`0x${string}`>[] | undefined;
2149
+ feePayer?: true | import("viem").Account | undefined;
2150
+ feeToken?: bigint | `0x${string}` | undefined;
2151
+ nonceKey?: `0x${string}` | "expiring" | undefined;
2152
+ validBefore?: `0x${string}` | undefined;
2153
+ validAfter?: `0x${string}` | undefined;
2154
+ blobs?: undefined;
2155
+ blobVersionedHashes?: undefined;
2156
+ kzg?: undefined;
2157
+ sidecars?: undefined;
2158
+ authorizationList?: undefined;
2159
+ }) & {};
2160
+ type: "transactionRequest";
2161
+ };
2162
+ };
2163
+ prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { phase }: {
2164
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2165
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
2166
+ readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
2167
+ }];
2168
+ serializers: {
2169
+ readonly transaction: import("viem").SerializeTransactionFn;
2170
+ };
2171
+ verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
2172
+ extend: <const extended_1 extends {
2173
+ feeToken?: import("ox/tempo/TokenId").TokenIdOrAddress | undefined;
2174
+ }>(extended: extended_1) => import("viem/chains").Assign<import("viem/chains").Assign<import("viem/chains").Chain<undefined>, {
2175
+ readonly id: 4217;
2176
+ readonly blockExplorers: {
2177
+ readonly default: {
2178
+ readonly name: "Tempo Explorer";
2179
+ readonly url: "https://explore.mainnet.tempo.xyz";
2180
+ };
2181
+ };
2182
+ readonly name: "Tempo Mainnet";
2183
+ readonly nativeCurrency: {
2184
+ readonly name: "USD";
2185
+ readonly symbol: "USD";
2186
+ readonly decimals: 6;
2187
+ };
2188
+ readonly rpcUrls: {
2189
+ readonly default: {
2190
+ readonly http: readonly ["https://rpc.presto.tempo.xyz"];
2191
+ readonly webSocket: readonly ["wss://rpc.presto.tempo.xyz"];
2192
+ };
2193
+ };
2194
+ readonly blockTime: 1000;
2195
+ readonly extendSchema: {
2196
+ feeToken?: import("ox/tempo/TokenId").TokenIdOrAddress | undefined;
2197
+ };
2198
+ readonly formatters: {
2199
+ readonly transaction: {
2200
+ exclude: never[] | undefined;
2201
+ format: (args: import("viem/_types/tempo/Transaction").TransactionRpc, action?: string | undefined) => ({
2202
+ r: import("viem").Hex;
2203
+ s: import("viem").Hex;
2204
+ v: bigint;
2205
+ to: import("abitype").Address | null;
2206
+ from: import("abitype").Address;
2207
+ gas: bigint;
2208
+ nonce: number;
2209
+ value: bigint;
2210
+ blockHash: `0x${string}` | null;
2211
+ blockNumber: bigint | null;
2212
+ hash: import("viem").Hash;
2213
+ input: import("viem").Hex;
2214
+ transactionIndex: number | null;
2215
+ typeHex: import("viem").Hex | null;
2216
+ accessList?: undefined | undefined;
2217
+ authorizationList?: undefined | undefined;
2218
+ blobVersionedHashes?: undefined | undefined;
2219
+ chainId?: number | undefined;
2220
+ yParity?: undefined | undefined;
2221
+ type: "legacy";
2222
+ gasPrice: bigint;
2223
+ maxFeePerBlobGas?: undefined | undefined;
2224
+ maxFeePerGas?: undefined | undefined;
2225
+ maxPriorityFeePerGas?: undefined | undefined;
2226
+ signature?: undefined;
2227
+ calls?: undefined;
2228
+ nonceKey?: undefined;
2229
+ validAfter?: undefined;
2230
+ feeToken?: undefined;
2231
+ feePayerSignature?: undefined;
2232
+ keyAuthorization?: undefined;
2233
+ validBefore?: undefined;
2234
+ } | {
2235
+ blockHash: `0x${string}` | null;
2236
+ blockNumber: bigint | null;
2237
+ from: import("abitype").Address;
2238
+ gas: bigint;
2239
+ hash: import("viem").Hash;
2240
+ input: import("viem").Hex;
2241
+ nonce: number;
2242
+ r: import("viem").Hex;
2243
+ s: import("viem").Hex;
2244
+ to: import("abitype").Address | null;
2245
+ transactionIndex: number | null;
2246
+ typeHex: import("viem").Hex | null;
2247
+ v: bigint;
2248
+ value: bigint;
2249
+ yParity: number;
2250
+ accessList: import("viem").AccessList;
2251
+ authorizationList?: undefined | undefined;
2252
+ blobVersionedHashes?: undefined | undefined;
2253
+ chainId: number;
2254
+ type: "eip2930";
2255
+ gasPrice: bigint;
2256
+ maxFeePerBlobGas?: undefined | undefined;
2257
+ maxFeePerGas?: undefined | undefined;
2258
+ maxPriorityFeePerGas?: undefined | undefined;
2259
+ signature?: undefined;
2260
+ calls?: undefined;
2261
+ nonceKey?: undefined;
2262
+ validAfter?: undefined;
2263
+ feeToken?: undefined;
2264
+ feePayerSignature?: undefined;
2265
+ keyAuthorization?: undefined;
2266
+ validBefore?: undefined;
2267
+ } | {
2268
+ blockHash: `0x${string}` | null;
2269
+ blockNumber: bigint | null;
2270
+ from: import("abitype").Address;
2271
+ gas: bigint;
2272
+ hash: import("viem").Hash;
2273
+ input: import("viem").Hex;
2274
+ nonce: number;
2275
+ r: import("viem").Hex;
2276
+ s: import("viem").Hex;
2277
+ to: import("abitype").Address | null;
2278
+ transactionIndex: number | null;
2279
+ typeHex: import("viem").Hex | null;
2280
+ v: bigint;
2281
+ value: bigint;
2282
+ yParity: number;
2283
+ accessList: import("viem").AccessList;
2284
+ authorizationList?: undefined | undefined;
2285
+ blobVersionedHashes?: undefined | undefined;
2286
+ chainId: number;
2287
+ type: "eip1559";
2288
+ gasPrice?: undefined | undefined;
2289
+ maxFeePerBlobGas?: undefined | undefined;
2290
+ maxFeePerGas: bigint;
2291
+ maxPriorityFeePerGas: bigint;
2292
+ signature?: undefined;
2293
+ calls?: undefined;
2294
+ nonceKey?: undefined;
2295
+ validAfter?: undefined;
2296
+ feeToken?: undefined;
2297
+ feePayerSignature?: undefined;
2298
+ keyAuthorization?: undefined;
2299
+ validBefore?: undefined;
2300
+ } | {
2301
+ blockHash: `0x${string}` | null;
2302
+ blockNumber: bigint | null;
2303
+ from: import("abitype").Address;
2304
+ gas: bigint;
2305
+ hash: import("viem").Hash;
2306
+ input: import("viem").Hex;
2307
+ nonce: number;
2308
+ r: import("viem").Hex;
2309
+ s: import("viem").Hex;
2310
+ to: import("abitype").Address | null;
2311
+ transactionIndex: number | null;
2312
+ typeHex: import("viem").Hex | null;
2313
+ v: bigint;
2314
+ value: bigint;
2315
+ yParity: number;
2316
+ accessList: import("viem").AccessList;
2317
+ authorizationList?: undefined | undefined;
2318
+ blobVersionedHashes: readonly import("viem").Hex[];
2319
+ chainId: number;
2320
+ type: "eip4844";
2321
+ gasPrice?: undefined | undefined;
2322
+ maxFeePerBlobGas: bigint;
2323
+ maxFeePerGas: bigint;
2324
+ maxPriorityFeePerGas: bigint;
2325
+ signature?: undefined;
2326
+ calls?: undefined;
2327
+ nonceKey?: undefined;
2328
+ validAfter?: undefined;
2329
+ feeToken?: undefined;
2330
+ feePayerSignature?: undefined;
2331
+ keyAuthorization?: undefined;
2332
+ validBefore?: undefined;
2333
+ } | {
2334
+ blockHash: `0x${string}` | null;
2335
+ blockNumber: bigint | null;
2336
+ from: import("abitype").Address;
2337
+ gas: bigint;
2338
+ hash: import("viem").Hash;
2339
+ input: import("viem").Hex;
2340
+ nonce: number;
2341
+ r: import("viem").Hex;
2342
+ s: import("viem").Hex;
2343
+ to: import("abitype").Address | null;
2344
+ transactionIndex: number | null;
2345
+ typeHex: import("viem").Hex | null;
2346
+ v: bigint;
2347
+ value: bigint;
2348
+ yParity: number;
2349
+ accessList: import("viem").AccessList;
2350
+ authorizationList: import("viem").SignedAuthorizationList;
2351
+ blobVersionedHashes?: undefined | undefined;
2352
+ chainId: number;
2353
+ type: "eip7702";
2354
+ gasPrice?: undefined | undefined;
2355
+ maxFeePerBlobGas?: undefined | undefined;
2356
+ maxFeePerGas: bigint;
2357
+ maxPriorityFeePerGas: bigint;
2358
+ signature?: undefined;
2359
+ calls?: undefined;
2360
+ nonceKey?: undefined;
2361
+ validAfter?: undefined;
2362
+ feeToken?: undefined;
2363
+ feePayerSignature?: undefined;
2364
+ keyAuthorization?: undefined;
2365
+ validBefore?: undefined;
2366
+ } | {
2367
+ from: import("abitype").Address;
2368
+ gas: bigint;
2369
+ nonce: number;
2370
+ blockHash: `0x${string}` | null;
2371
+ blockNumber: bigint | null;
2372
+ hash: import("viem").Hash;
2373
+ transactionIndex: number | null;
2374
+ typeHex: import("viem").Hex | null;
2375
+ r?: `0x${string}` | undefined;
2376
+ s?: `0x${string}` | undefined;
2377
+ v?: bigint | undefined;
2378
+ yParity?: number | undefined;
2379
+ accessList: import("viem").AccessList;
2380
+ authorizationList?: readonly {
2381
+ address: import("ox/_types/core/Address").Address;
2382
+ chainId: number;
2383
+ nonce: bigint;
2384
+ signature: import("ox/tempo/SignatureEnvelope").SignatureEnvelope<bigint, number>;
2385
+ }[] | undefined;
2386
+ calls: readonly import("ox/tempo/TxEnvelopeTempo").Call<bigint>[];
2387
+ chainId: number;
2388
+ feeToken?: `0x${string}` | undefined;
2389
+ feePayerSignature?: import("viem").Signature | undefined;
2390
+ keyAuthorization?: import("ox/tempo/KeyAuthorization").Signed<bigint, number> | null | undefined;
2391
+ nonceKey?: bigint | undefined;
2392
+ signature: import("ox/tempo/SignatureEnvelope").SignatureEnvelope;
2393
+ type: "tempo";
2394
+ validBefore?: number | undefined;
2395
+ validAfter?: number | undefined;
2396
+ gasPrice?: undefined | undefined;
2397
+ maxFeePerBlobGas?: undefined | undefined;
2398
+ maxFeePerGas: bigint;
2399
+ maxPriorityFeePerGas: bigint;
2400
+ to?: undefined;
2401
+ value?: undefined;
2402
+ blobVersionedHashes?: undefined;
2403
+ input?: undefined;
2404
+ }) & {};
2405
+ type: "transaction";
2406
+ };
2407
+ readonly transactionReceipt: {
2408
+ exclude: [] | undefined;
2409
+ format: (args: import("viem/_types/tempo/Transaction").TransactionReceiptRpc, action?: string | undefined) => {
2410
+ blobGasPrice?: bigint | undefined;
2411
+ blobGasUsed?: bigint | undefined;
2412
+ blockHash: import("viem").Hash;
2413
+ blockNumber: bigint;
2414
+ contractAddress: import("abitype").Address | null | undefined;
2415
+ cumulativeGasUsed: bigint;
2416
+ effectiveGasPrice: bigint;
2417
+ from: import("abitype").Address;
2418
+ gasUsed: bigint;
2419
+ logs: import("viem").Log<bigint, number, false>[];
2420
+ logsBloom: import("viem").Hex;
2421
+ root?: `0x${string}` | undefined;
2422
+ status: "success" | "reverted";
2423
+ to: import("abitype").Address | null;
2424
+ transactionHash: import("viem").Hash;
2425
+ transactionIndex: number;
2426
+ type: import("viem/_types/tempo/Transaction").TransactionType;
2427
+ feePayer?: `0x${string}` | undefined;
2428
+ feeToken?: `0x${string}` | undefined;
2429
+ } & {};
2430
+ type: "transactionReceipt";
2431
+ };
2432
+ readonly transactionRequest: {
2433
+ exclude: [] | undefined;
2434
+ format: (args: import("viem/_types/tempo/Transaction").TransactionRequest, action?: string | undefined) => ({
2435
+ data?: `0x${string}` | undefined;
2436
+ from?: `0x${string}` | undefined;
2437
+ gas?: `0x${string}` | undefined;
2438
+ nonce?: `0x${string}` | undefined;
2439
+ to?: `0x${string}` | null | undefined;
2440
+ type?: "0x0" | undefined;
2441
+ value?: `0x${string}` | undefined;
2442
+ gasPrice?: `0x${string}` | undefined;
2443
+ maxFeePerBlobGas?: undefined | undefined;
2444
+ maxFeePerGas?: undefined | undefined;
2445
+ maxPriorityFeePerGas?: undefined | undefined;
2446
+ blobs?: undefined;
2447
+ blobVersionedHashes?: undefined;
2448
+ kzg?: undefined;
2449
+ accessList?: undefined;
2450
+ sidecars?: undefined;
2451
+ authorizationList?: undefined;
2452
+ calls?: undefined;
2453
+ nonceKey?: undefined;
2454
+ validAfter?: undefined;
2455
+ feeToken?: undefined;
2456
+ keyAuthorization?: undefined;
2457
+ validBefore?: undefined;
2458
+ feePayer?: undefined;
2459
+ } | {
2460
+ data?: `0x${string}` | undefined;
2461
+ from?: `0x${string}` | undefined;
2462
+ gas?: `0x${string}` | undefined;
2463
+ nonce?: `0x${string}` | undefined;
2464
+ to?: `0x${string}` | null | undefined;
2465
+ type?: "0x1" | undefined;
2466
+ value?: `0x${string}` | undefined;
2467
+ gasPrice?: `0x${string}` | undefined;
2468
+ maxFeePerBlobGas?: undefined | undefined;
2469
+ maxFeePerGas?: undefined | undefined;
2470
+ maxPriorityFeePerGas?: undefined | undefined;
2471
+ accessList?: import("viem").AccessList | undefined;
2472
+ blobs?: undefined;
2473
+ blobVersionedHashes?: undefined;
2474
+ kzg?: undefined;
2475
+ sidecars?: undefined;
2476
+ authorizationList?: undefined;
2477
+ calls?: undefined;
2478
+ nonceKey?: undefined;
2479
+ validAfter?: undefined;
2480
+ feeToken?: undefined;
2481
+ keyAuthorization?: undefined;
2482
+ validBefore?: undefined;
2483
+ feePayer?: undefined;
2484
+ } | {
2485
+ data?: `0x${string}` | undefined;
2486
+ from?: `0x${string}` | undefined;
2487
+ gas?: `0x${string}` | undefined;
2488
+ nonce?: `0x${string}` | undefined;
2489
+ to?: `0x${string}` | null | undefined;
2490
+ type?: "0x2" | undefined;
2491
+ value?: `0x${string}` | undefined;
2492
+ gasPrice?: undefined | undefined;
2493
+ maxFeePerBlobGas?: undefined | undefined;
2494
+ maxFeePerGas?: `0x${string}` | undefined;
2495
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2496
+ accessList?: import("viem").AccessList | undefined;
2497
+ blobs?: undefined;
2498
+ blobVersionedHashes?: undefined;
2499
+ kzg?: undefined;
2500
+ sidecars?: undefined;
2501
+ authorizationList?: undefined;
2502
+ calls?: undefined;
2503
+ nonceKey?: undefined;
2504
+ validAfter?: undefined;
2505
+ feeToken?: undefined;
2506
+ keyAuthorization?: undefined;
2507
+ validBefore?: undefined;
2508
+ feePayer?: undefined;
2509
+ } | {
2510
+ type?: "0x3" | undefined;
2511
+ data?: `0x${string}` | undefined;
2512
+ from?: `0x${string}` | undefined;
2513
+ gas?: `0x${string}` | undefined;
2514
+ nonce?: `0x${string}` | undefined;
2515
+ value?: `0x${string}` | undefined;
2516
+ to: `0x${string}` | null;
2517
+ gasPrice?: undefined | undefined;
2518
+ maxFeePerBlobGas?: `0x${string}` | undefined;
2519
+ maxFeePerGas?: `0x${string}` | undefined;
2520
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2521
+ accessList?: import("viem").AccessList | undefined;
2522
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
2523
+ blobs?: readonly `0x${string}`[] | readonly import("viem").ByteArray[] | undefined;
2524
+ blobVersionedHashes: readonly import("viem").Hex[];
2525
+ kzg?: undefined;
2526
+ authorizationList?: undefined;
2527
+ calls?: undefined;
2528
+ nonceKey?: undefined;
2529
+ validAfter?: undefined;
2530
+ feeToken?: undefined;
2531
+ keyAuthorization?: undefined;
2532
+ validBefore?: undefined;
2533
+ feePayer?: undefined;
2534
+ } | {
2535
+ type?: "0x3" | undefined;
2536
+ data?: `0x${string}` | undefined;
2537
+ from?: `0x${string}` | undefined;
2538
+ gas?: `0x${string}` | undefined;
2539
+ nonce?: `0x${string}` | undefined;
2540
+ value?: `0x${string}` | undefined;
2541
+ to: `0x${string}` | null;
2542
+ gasPrice?: undefined | undefined;
2543
+ maxFeePerBlobGas?: `0x${string}` | undefined;
2544
+ maxFeePerGas?: `0x${string}` | undefined;
2545
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2546
+ accessList?: import("viem").AccessList | undefined;
2547
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
2548
+ blobs: readonly import("viem").Hex[] | readonly import("viem").ByteArray[];
2549
+ blobVersionedHashes?: readonly `0x${string}`[] | undefined;
2550
+ kzg?: import("viem").Kzg | undefined;
2551
+ authorizationList?: undefined;
2552
+ calls?: undefined;
2553
+ nonceKey?: undefined;
2554
+ validAfter?: undefined;
2555
+ feeToken?: undefined;
2556
+ keyAuthorization?: undefined;
2557
+ validBefore?: undefined;
2558
+ feePayer?: undefined;
2559
+ } | {
2560
+ type?: "0x4" | undefined;
2561
+ gasPrice?: undefined | undefined;
2562
+ maxFeePerBlobGas?: undefined | undefined;
2563
+ maxFeePerGas?: `0x${string}` | undefined;
2564
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2565
+ to?: `0x${string}` | null | undefined;
2566
+ data?: `0x${string}` | undefined;
2567
+ from?: `0x${string}` | undefined;
2568
+ gas?: `0x${string}` | undefined;
2569
+ nonce?: `0x${string}` | undefined;
2570
+ value?: `0x${string}` | undefined;
2571
+ accessList?: import("viem").AccessList | undefined;
2572
+ authorizationList?: import("viem").RpcAuthorizationList | undefined;
2573
+ blobs?: undefined;
2574
+ blobVersionedHashes?: undefined;
2575
+ kzg?: undefined;
2576
+ sidecars?: undefined;
2577
+ calls?: undefined;
2578
+ nonceKey?: undefined;
2579
+ validAfter?: undefined;
2580
+ feeToken?: undefined;
2581
+ keyAuthorization?: undefined;
2582
+ validBefore?: undefined;
2583
+ feePayer?: undefined;
2584
+ } | {
2585
+ data?: `0x${string}` | undefined;
2586
+ from?: `0x${string}` | undefined;
2587
+ gas?: `0x${string}` | undefined;
2588
+ nonce?: `0x${string}` | undefined;
2589
+ to?: `0x${string}` | null | undefined;
2590
+ type?: "0x76" | undefined;
2591
+ value?: `0x${string}` | undefined;
2592
+ gasPrice?: undefined | undefined;
2593
+ maxFeePerBlobGas?: undefined | undefined;
2594
+ maxFeePerGas?: `0x${string}` | undefined;
2595
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2596
+ accessList?: import("viem").AccessList | undefined;
2597
+ keyAuthorization?: import("ox/tempo/KeyAuthorization").Signed<`0x${string}`, `0x${string}`> | undefined;
2598
+ calls?: readonly import("ox/tempo/TxEnvelopeTempo").Call<`0x${string}`>[] | undefined;
2599
+ feePayer?: true | import("viem").Account | undefined;
2600
+ feeToken?: bigint | `0x${string}` | undefined;
2601
+ nonceKey?: `0x${string}` | "expiring" | undefined;
2602
+ validBefore?: `0x${string}` | undefined;
2603
+ validAfter?: `0x${string}` | undefined;
2604
+ blobs?: undefined;
2605
+ blobVersionedHashes?: undefined;
2606
+ kzg?: undefined;
2607
+ sidecars?: undefined;
2608
+ authorizationList?: undefined;
2609
+ }) & {};
2610
+ type: "transactionRequest";
2611
+ };
2612
+ };
2613
+ readonly prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { phase }: {
2614
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2615
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
2616
+ readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
2617
+ }];
2618
+ readonly serializers: {
2619
+ readonly transaction: import("viem").SerializeTransactionFn;
2620
+ };
2621
+ readonly verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
2622
+ }>, extended_1>;
1662
2623
  })[];
1663
2624
  declare const testnetChains: ({
1664
2625
  blockExplorers: {
@@ -1678,27 +2639,339 @@ declare const testnetChains: ({
1678
2639
  readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
1679
2640
  readonly blockCreated: 8928790;
1680
2641
  };
1681
- };
1682
- ensTlds?: readonly string[] | undefined;
1683
- id: 11155111;
1684
- name: "Sepolia";
1685
- nativeCurrency: {
1686
- readonly name: "Sepolia Ether";
1687
- readonly symbol: "ETH";
1688
- readonly decimals: 18;
1689
- };
1690
- experimental_preconfirmationTime?: number | undefined | undefined;
1691
- rpcUrls: {
1692
- readonly default: {
1693
- readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
2642
+ };
2643
+ ensTlds?: readonly string[] | undefined;
2644
+ id: 11155111;
2645
+ name: "Sepolia";
2646
+ nativeCurrency: {
2647
+ readonly name: "Sepolia Ether";
2648
+ readonly symbol: "ETH";
2649
+ readonly decimals: 18;
2650
+ };
2651
+ experimental_preconfirmationTime?: number | undefined | undefined;
2652
+ rpcUrls: {
2653
+ readonly default: {
2654
+ readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
2655
+ };
2656
+ };
2657
+ sourceId?: number | undefined | undefined;
2658
+ testnet: true;
2659
+ custom?: Record<string, unknown> | undefined;
2660
+ extendSchema?: Record<string, unknown> | undefined;
2661
+ fees?: import("viem").ChainFees<undefined> | undefined;
2662
+ formatters?: undefined;
2663
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2664
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2665
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2666
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2667
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2668
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2669
+ }] | undefined;
2670
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2671
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2672
+ } | {
2673
+ blockExplorers: {
2674
+ readonly default: {
2675
+ readonly name: "Blockscout";
2676
+ readonly url: "https://optimism-sepolia.blockscout.com";
2677
+ readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
2678
+ };
2679
+ };
2680
+ blockTime: 2000;
2681
+ contracts: {
2682
+ readonly disputeGameFactory: {
2683
+ readonly 11155111: {
2684
+ readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
2685
+ };
2686
+ };
2687
+ readonly l2OutputOracle: {
2688
+ readonly 11155111: {
2689
+ readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
2690
+ };
2691
+ };
2692
+ readonly multicall3: {
2693
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2694
+ readonly blockCreated: 1620204;
2695
+ };
2696
+ readonly portal: {
2697
+ readonly 11155111: {
2698
+ readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
2699
+ };
2700
+ };
2701
+ readonly l1StandardBridge: {
2702
+ readonly 11155111: {
2703
+ readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
2704
+ };
2705
+ };
2706
+ readonly gasPriceOracle: {
2707
+ readonly address: "0x420000000000000000000000000000000000000F";
2708
+ };
2709
+ readonly l1Block: {
2710
+ readonly address: "0x4200000000000000000000000000000000000015";
2711
+ };
2712
+ readonly l2CrossDomainMessenger: {
2713
+ readonly address: "0x4200000000000000000000000000000000000007";
2714
+ };
2715
+ readonly l2Erc721Bridge: {
2716
+ readonly address: "0x4200000000000000000000000000000000000014";
2717
+ };
2718
+ readonly l2StandardBridge: {
2719
+ readonly address: "0x4200000000000000000000000000000000000010";
2720
+ };
2721
+ readonly l2ToL1MessagePasser: {
2722
+ readonly address: "0x4200000000000000000000000000000000000016";
2723
+ };
2724
+ };
2725
+ ensTlds?: readonly string[] | undefined;
2726
+ id: 11155420;
2727
+ name: "OP Sepolia";
2728
+ nativeCurrency: {
2729
+ readonly name: "Sepolia Ether";
2730
+ readonly symbol: "ETH";
2731
+ readonly decimals: 18;
2732
+ };
2733
+ experimental_preconfirmationTime?: number | undefined | undefined;
2734
+ rpcUrls: {
2735
+ readonly default: {
2736
+ readonly http: readonly ["https://sepolia.optimism.io"];
2737
+ };
2738
+ };
2739
+ sourceId: 11155111;
2740
+ testnet: true;
2741
+ custom?: Record<string, unknown> | undefined;
2742
+ extendSchema?: Record<string, unknown> | undefined;
2743
+ fees?: import("viem").ChainFees<undefined> | undefined;
2744
+ formatters: {
2745
+ readonly block: {
2746
+ exclude: [] | undefined;
2747
+ format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
2748
+ baseFeePerGas: bigint | null;
2749
+ blobGasUsed: bigint;
2750
+ difficulty: bigint;
2751
+ excessBlobGas: bigint;
2752
+ extraData: import("viem").Hex;
2753
+ gasLimit: bigint;
2754
+ gasUsed: bigint;
2755
+ hash: `0x${string}` | null;
2756
+ logsBloom: `0x${string}` | null;
2757
+ miner: import("abitype").Address;
2758
+ mixHash: import("viem").Hash;
2759
+ nonce: `0x${string}` | null;
2760
+ number: bigint | null;
2761
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
2762
+ parentHash: import("viem").Hash;
2763
+ receiptsRoot: import("viem").Hex;
2764
+ sealFields: import("viem").Hex[];
2765
+ sha3Uncles: import("viem").Hash;
2766
+ size: bigint;
2767
+ stateRoot: import("viem").Hash;
2768
+ timestamp: bigint;
2769
+ totalDifficulty: bigint | null;
2770
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
2771
+ transactionsRoot: import("viem").Hash;
2772
+ uncles: import("viem").Hash[];
2773
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
2774
+ withdrawalsRoot?: `0x${string}` | undefined;
2775
+ } & {};
2776
+ type: "block";
2777
+ };
2778
+ readonly transaction: {
2779
+ exclude: [] | undefined;
2780
+ format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
2781
+ blockHash: `0x${string}` | null;
2782
+ blockNumber: bigint | null;
2783
+ from: import("abitype").Address;
2784
+ gas: bigint;
2785
+ hash: import("viem").Hash;
2786
+ input: import("viem").Hex;
2787
+ nonce: number;
2788
+ r: import("viem").Hex;
2789
+ s: import("viem").Hex;
2790
+ to: import("abitype").Address | null;
2791
+ transactionIndex: number | null;
2792
+ typeHex: import("viem").Hex | null;
2793
+ v: bigint;
2794
+ value: bigint;
2795
+ yParity: number;
2796
+ gasPrice?: undefined | undefined;
2797
+ maxFeePerBlobGas?: undefined | undefined;
2798
+ maxFeePerGas: bigint;
2799
+ maxPriorityFeePerGas: bigint;
2800
+ isSystemTx?: boolean;
2801
+ mint?: bigint | undefined | undefined;
2802
+ sourceHash: import("viem").Hex;
2803
+ type: "deposit";
2804
+ } | {
2805
+ r: import("viem").Hex;
2806
+ s: import("viem").Hex;
2807
+ v: bigint;
2808
+ to: import("abitype").Address | null;
2809
+ from: import("abitype").Address;
2810
+ gas: bigint;
2811
+ nonce: number;
2812
+ value: bigint;
2813
+ blockHash: `0x${string}` | null;
2814
+ blockNumber: bigint | null;
2815
+ hash: import("viem").Hash;
2816
+ input: import("viem").Hex;
2817
+ transactionIndex: number | null;
2818
+ typeHex: import("viem").Hex | null;
2819
+ accessList?: undefined | undefined;
2820
+ authorizationList?: undefined | undefined;
2821
+ blobVersionedHashes?: undefined | undefined;
2822
+ chainId?: number | undefined;
2823
+ yParity?: undefined | undefined;
2824
+ type: "legacy";
2825
+ gasPrice: bigint;
2826
+ maxFeePerBlobGas?: undefined | undefined;
2827
+ maxFeePerGas?: undefined | undefined;
2828
+ maxPriorityFeePerGas?: undefined | undefined;
2829
+ isSystemTx?: undefined | undefined;
2830
+ mint?: undefined | undefined;
2831
+ sourceHash?: undefined | undefined;
2832
+ } | {
2833
+ blockHash: `0x${string}` | null;
2834
+ blockNumber: bigint | null;
2835
+ from: import("abitype").Address;
2836
+ gas: bigint;
2837
+ hash: import("viem").Hash;
2838
+ input: import("viem").Hex;
2839
+ nonce: number;
2840
+ r: import("viem").Hex;
2841
+ s: import("viem").Hex;
2842
+ to: import("abitype").Address | null;
2843
+ transactionIndex: number | null;
2844
+ typeHex: import("viem").Hex | null;
2845
+ v: bigint;
2846
+ value: bigint;
2847
+ yParity: number;
2848
+ accessList: import("viem").AccessList;
2849
+ authorizationList?: undefined | undefined;
2850
+ blobVersionedHashes?: undefined | undefined;
2851
+ chainId: number;
2852
+ type: "eip2930";
2853
+ gasPrice: bigint;
2854
+ maxFeePerBlobGas?: undefined | undefined;
2855
+ maxFeePerGas?: undefined | undefined;
2856
+ maxPriorityFeePerGas?: undefined | undefined;
2857
+ isSystemTx?: undefined | undefined;
2858
+ mint?: undefined | undefined;
2859
+ sourceHash?: undefined | undefined;
2860
+ } | {
2861
+ blockHash: `0x${string}` | null;
2862
+ blockNumber: bigint | null;
2863
+ from: import("abitype").Address;
2864
+ gas: bigint;
2865
+ hash: import("viem").Hash;
2866
+ input: import("viem").Hex;
2867
+ nonce: number;
2868
+ r: import("viem").Hex;
2869
+ s: import("viem").Hex;
2870
+ to: import("abitype").Address | null;
2871
+ transactionIndex: number | null;
2872
+ typeHex: import("viem").Hex | null;
2873
+ v: bigint;
2874
+ value: bigint;
2875
+ yParity: number;
2876
+ accessList: import("viem").AccessList;
2877
+ authorizationList?: undefined | undefined;
2878
+ blobVersionedHashes?: undefined | undefined;
2879
+ chainId: number;
2880
+ type: "eip1559";
2881
+ gasPrice?: undefined | undefined;
2882
+ maxFeePerBlobGas?: undefined | undefined;
2883
+ maxFeePerGas: bigint;
2884
+ maxPriorityFeePerGas: bigint;
2885
+ isSystemTx?: undefined | undefined;
2886
+ mint?: undefined | undefined;
2887
+ sourceHash?: undefined | undefined;
2888
+ } | {
2889
+ blockHash: `0x${string}` | null;
2890
+ blockNumber: bigint | null;
2891
+ from: import("abitype").Address;
2892
+ gas: bigint;
2893
+ hash: import("viem").Hash;
2894
+ input: import("viem").Hex;
2895
+ nonce: number;
2896
+ r: import("viem").Hex;
2897
+ s: import("viem").Hex;
2898
+ to: import("abitype").Address | null;
2899
+ transactionIndex: number | null;
2900
+ typeHex: import("viem").Hex | null;
2901
+ v: bigint;
2902
+ value: bigint;
2903
+ yParity: number;
2904
+ accessList: import("viem").AccessList;
2905
+ authorizationList?: undefined | undefined;
2906
+ blobVersionedHashes: readonly import("viem").Hex[];
2907
+ chainId: number;
2908
+ type: "eip4844";
2909
+ gasPrice?: undefined | undefined;
2910
+ maxFeePerBlobGas: bigint;
2911
+ maxFeePerGas: bigint;
2912
+ maxPriorityFeePerGas: bigint;
2913
+ isSystemTx?: undefined | undefined;
2914
+ mint?: undefined | undefined;
2915
+ sourceHash?: undefined | undefined;
2916
+ } | {
2917
+ blockHash: `0x${string}` | null;
2918
+ blockNumber: bigint | null;
2919
+ from: import("abitype").Address;
2920
+ gas: bigint;
2921
+ hash: import("viem").Hash;
2922
+ input: import("viem").Hex;
2923
+ nonce: number;
2924
+ r: import("viem").Hex;
2925
+ s: import("viem").Hex;
2926
+ to: import("abitype").Address | null;
2927
+ transactionIndex: number | null;
2928
+ typeHex: import("viem").Hex | null;
2929
+ v: bigint;
2930
+ value: bigint;
2931
+ yParity: number;
2932
+ accessList: import("viem").AccessList;
2933
+ authorizationList: import("viem").SignedAuthorizationList;
2934
+ blobVersionedHashes?: undefined | undefined;
2935
+ chainId: number;
2936
+ type: "eip7702";
2937
+ gasPrice?: undefined | undefined;
2938
+ maxFeePerBlobGas?: undefined | undefined;
2939
+ maxFeePerGas: bigint;
2940
+ maxPriorityFeePerGas: bigint;
2941
+ isSystemTx?: undefined | undefined;
2942
+ mint?: undefined | undefined;
2943
+ sourceHash?: undefined | undefined;
2944
+ }) & {};
2945
+ type: "transaction";
2946
+ };
2947
+ readonly transactionReceipt: {
2948
+ exclude: [] | undefined;
2949
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
2950
+ blobGasPrice?: bigint | undefined;
2951
+ blobGasUsed?: bigint | undefined;
2952
+ blockHash: import("viem").Hash;
2953
+ blockNumber: bigint;
2954
+ contractAddress: import("abitype").Address | null | undefined;
2955
+ cumulativeGasUsed: bigint;
2956
+ effectiveGasPrice: bigint;
2957
+ from: import("abitype").Address;
2958
+ gasUsed: bigint;
2959
+ logs: import("viem").Log<bigint, number, false>[];
2960
+ logsBloom: import("viem").Hex;
2961
+ root?: `0x${string}` | undefined;
2962
+ status: "success" | "reverted";
2963
+ to: import("abitype").Address | null;
2964
+ transactionHash: import("viem").Hash;
2965
+ transactionIndex: number;
2966
+ type: import("viem").TransactionType;
2967
+ l1GasPrice: bigint | null;
2968
+ l1GasUsed: bigint | null;
2969
+ l1Fee: bigint | null;
2970
+ l1FeeScalar: number | null;
2971
+ } & {};
2972
+ type: "transactionReceipt";
1694
2973
  };
1695
2974
  };
1696
- sourceId?: number | undefined | undefined;
1697
- testnet: true;
1698
- custom?: Record<string, unknown> | undefined;
1699
- extendSchema?: Record<string, unknown> | undefined;
1700
- fees?: import("viem").ChainFees<undefined> | undefined;
1701
- formatters?: undefined;
1702
2975
  prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1703
2976
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1704
2977
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
@@ -1706,42 +2979,46 @@ declare const testnetChains: ({
1706
2979
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1707
2980
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1708
2981
  }] | undefined;
1709
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2982
+ serializers: {
2983
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2984
+ };
1710
2985
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1711
2986
  } | {
1712
2987
  blockExplorers: {
1713
2988
  readonly default: {
1714
- readonly name: "Blockscout";
1715
- readonly url: "https://optimism-sepolia.blockscout.com";
1716
- readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
2989
+ readonly name: "Basescan";
2990
+ readonly url: "https://sepolia.basescan.org";
2991
+ readonly apiUrl: "https://api-sepolia.basescan.org/api";
1717
2992
  };
1718
2993
  };
1719
2994
  blockTime: 2000;
1720
2995
  contracts: {
1721
2996
  readonly disputeGameFactory: {
1722
2997
  readonly 11155111: {
1723
- readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
2998
+ readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
1724
2999
  };
1725
3000
  };
1726
3001
  readonly l2OutputOracle: {
1727
3002
  readonly 11155111: {
1728
- readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
3003
+ readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
1729
3004
  };
1730
3005
  };
1731
- readonly multicall3: {
1732
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1733
- readonly blockCreated: 1620204;
1734
- };
1735
3006
  readonly portal: {
1736
3007
  readonly 11155111: {
1737
- readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
3008
+ readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
3009
+ readonly blockCreated: 4446677;
1738
3010
  };
1739
3011
  };
1740
3012
  readonly l1StandardBridge: {
1741
3013
  readonly 11155111: {
1742
- readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
3014
+ readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
3015
+ readonly blockCreated: 4446677;
1743
3016
  };
1744
3017
  };
3018
+ readonly multicall3: {
3019
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3020
+ readonly blockCreated: 1059647;
3021
+ };
1745
3022
  readonly gasPriceOracle: {
1746
3023
  readonly address: "0x420000000000000000000000000000000000000F";
1747
3024
  };
@@ -1762,8 +3039,8 @@ declare const testnetChains: ({
1762
3039
  };
1763
3040
  };
1764
3041
  ensTlds?: readonly string[] | undefined;
1765
- id: 11155420;
1766
- name: "OP Sepolia";
3042
+ id: 84532;
3043
+ name: "Base Sepolia";
1767
3044
  nativeCurrency: {
1768
3045
  readonly name: "Sepolia Ether";
1769
3046
  readonly symbol: "ETH";
@@ -1772,7 +3049,7 @@ declare const testnetChains: ({
1772
3049
  experimental_preconfirmationTime?: number | undefined | undefined;
1773
3050
  rpcUrls: {
1774
3051
  readonly default: {
1775
- readonly http: readonly ["https://sepolia.optimism.io"];
3052
+ readonly http: readonly ["https://sepolia.base.org"];
1776
3053
  };
1777
3054
  };
1778
3055
  sourceId: 11155111;
@@ -2018,46 +3295,181 @@ declare const testnetChains: ({
2018
3295
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2019
3296
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2020
3297
  }] | undefined;
2021
- serializers: {
2022
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3298
+ serializers: {
3299
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3300
+ };
3301
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3302
+ readonly network: "base-sepolia";
3303
+ } | {
3304
+ blockExplorers: {
3305
+ readonly default: {
3306
+ readonly name: "Arbiscan";
3307
+ readonly url: "https://sepolia.arbiscan.io";
3308
+ readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
3309
+ };
3310
+ };
3311
+ blockTime: 250;
3312
+ contracts: {
3313
+ readonly multicall3: {
3314
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3315
+ readonly blockCreated: 81930;
3316
+ };
3317
+ };
3318
+ ensTlds?: readonly string[] | undefined;
3319
+ id: 421614;
3320
+ name: "Arbitrum Sepolia";
3321
+ nativeCurrency: {
3322
+ readonly name: "Arbitrum Sepolia Ether";
3323
+ readonly symbol: "ETH";
3324
+ readonly decimals: 18;
3325
+ };
3326
+ experimental_preconfirmationTime?: number | undefined | undefined;
3327
+ rpcUrls: {
3328
+ readonly default: {
3329
+ readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
3330
+ };
3331
+ };
3332
+ sourceId?: number | undefined | undefined;
3333
+ testnet: true;
3334
+ custom?: Record<string, unknown> | undefined;
3335
+ extendSchema?: Record<string, unknown> | undefined;
3336
+ fees?: import("viem").ChainFees<undefined> | undefined;
3337
+ formatters?: undefined;
3338
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3339
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3340
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3341
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3342
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3343
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3344
+ }] | undefined;
3345
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3346
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3347
+ } | {
3348
+ blockExplorers: {
3349
+ readonly default: {
3350
+ readonly name: "RouteScan";
3351
+ readonly url: "https://testnet.plasmascan.to";
3352
+ };
3353
+ };
3354
+ blockTime?: number | undefined | undefined;
3355
+ contracts: {
3356
+ readonly multicall3: {
3357
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3358
+ readonly blockCreated: 0;
3359
+ };
3360
+ };
3361
+ ensTlds?: readonly string[] | undefined;
3362
+ id: 9746;
3363
+ name: "Plasma Testnet";
3364
+ nativeCurrency: {
3365
+ readonly name: "Testnet Plasma";
3366
+ readonly symbol: "XPL";
3367
+ readonly decimals: 18;
3368
+ };
3369
+ experimental_preconfirmationTime?: number | undefined | undefined;
3370
+ rpcUrls: {
3371
+ readonly default: {
3372
+ readonly http: readonly ["https://testnet-rpc.plasma.to"];
3373
+ };
3374
+ };
3375
+ sourceId?: number | undefined | undefined;
3376
+ testnet: true;
3377
+ custom?: Record<string, unknown> | undefined;
3378
+ extendSchema?: Record<string, unknown> | undefined;
3379
+ fees?: import("viem").ChainFees<undefined> | undefined;
3380
+ formatters?: undefined;
3381
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3382
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3383
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3384
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3385
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3386
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3387
+ }] | undefined;
3388
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3389
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3390
+ })[];
3391
+ declare const chains: ({
3392
+ blockExplorers: {
3393
+ readonly default: {
3394
+ readonly name: "Etherscan";
3395
+ readonly url: "https://etherscan.io";
3396
+ readonly apiUrl: "https://api.etherscan.io/api";
3397
+ };
3398
+ };
3399
+ blockTime: 12000;
3400
+ contracts: {
3401
+ readonly ensUniversalResolver: {
3402
+ readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
3403
+ readonly blockCreated: 23085558;
3404
+ };
3405
+ readonly multicall3: {
3406
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3407
+ readonly blockCreated: 14353601;
3408
+ };
2023
3409
  };
3410
+ ensTlds?: readonly string[] | undefined;
3411
+ id: 1;
3412
+ name: "Ethereum";
3413
+ nativeCurrency: {
3414
+ readonly name: "Ether";
3415
+ readonly symbol: "ETH";
3416
+ readonly decimals: 18;
3417
+ };
3418
+ experimental_preconfirmationTime?: number | undefined | undefined;
3419
+ rpcUrls: {
3420
+ readonly default: {
3421
+ readonly http: readonly ["https://eth.merkle.io"];
3422
+ };
3423
+ };
3424
+ sourceId?: number | undefined | undefined;
3425
+ testnet?: boolean | undefined | undefined;
3426
+ custom?: Record<string, unknown> | undefined;
3427
+ extendSchema?: Record<string, unknown> | undefined;
3428
+ fees?: import("viem").ChainFees<undefined> | undefined;
3429
+ formatters?: undefined;
3430
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3431
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3432
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3433
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3434
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3435
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3436
+ }] | undefined;
3437
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2024
3438
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2025
3439
  } | {
2026
3440
  blockExplorers: {
2027
3441
  readonly default: {
2028
- readonly name: "Basescan";
2029
- readonly url: "https://sepolia.basescan.org";
2030
- readonly apiUrl: "https://api-sepolia.basescan.org/api";
3442
+ readonly name: "Optimism Explorer";
3443
+ readonly url: "https://optimistic.etherscan.io";
3444
+ readonly apiUrl: "https://api-optimistic.etherscan.io/api";
2031
3445
  };
2032
3446
  };
2033
3447
  blockTime: 2000;
2034
3448
  contracts: {
2035
3449
  readonly disputeGameFactory: {
2036
- readonly 11155111: {
2037
- readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
3450
+ readonly 1: {
3451
+ readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
2038
3452
  };
2039
3453
  };
2040
3454
  readonly l2OutputOracle: {
2041
- readonly 11155111: {
2042
- readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
3455
+ readonly 1: {
3456
+ readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
2043
3457
  };
2044
3458
  };
3459
+ readonly multicall3: {
3460
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3461
+ readonly blockCreated: 4286263;
3462
+ };
2045
3463
  readonly portal: {
2046
- readonly 11155111: {
2047
- readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
2048
- readonly blockCreated: 4446677;
3464
+ readonly 1: {
3465
+ readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
2049
3466
  };
2050
3467
  };
2051
3468
  readonly l1StandardBridge: {
2052
- readonly 11155111: {
2053
- readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
2054
- readonly blockCreated: 4446677;
3469
+ readonly 1: {
3470
+ readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
2055
3471
  };
2056
3472
  };
2057
- readonly multicall3: {
2058
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2059
- readonly blockCreated: 1059647;
2060
- };
2061
3473
  readonly gasPriceOracle: {
2062
3474
  readonly address: "0x420000000000000000000000000000000000000F";
2063
3475
  };
@@ -2078,21 +3490,21 @@ declare const testnetChains: ({
2078
3490
  };
2079
3491
  };
2080
3492
  ensTlds?: readonly string[] | undefined;
2081
- id: 84532;
2082
- name: "Base Sepolia";
3493
+ id: 10;
3494
+ name: "OP Mainnet";
2083
3495
  nativeCurrency: {
2084
- readonly name: "Sepolia Ether";
3496
+ readonly name: "Ether";
2085
3497
  readonly symbol: "ETH";
2086
3498
  readonly decimals: 18;
2087
3499
  };
2088
3500
  experimental_preconfirmationTime?: number | undefined | undefined;
2089
3501
  rpcUrls: {
2090
3502
  readonly default: {
2091
- readonly http: readonly ["https://sepolia.base.org"];
3503
+ readonly http: readonly ["https://mainnet.optimism.io"];
2092
3504
  };
2093
3505
  };
2094
- sourceId: 11155111;
2095
- testnet: true;
3506
+ sourceId: 1;
3507
+ testnet?: boolean | undefined | undefined;
2096
3508
  custom?: Record<string, unknown> | undefined;
2097
3509
  extendSchema?: Record<string, unknown> | undefined;
2098
3510
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -2259,164 +3671,74 @@ declare const testnetChains: ({
2259
3671
  accessList: import("viem").AccessList;
2260
3672
  authorizationList?: undefined | undefined;
2261
3673
  blobVersionedHashes: readonly import("viem").Hex[];
2262
- chainId: number;
2263
- type: "eip4844";
2264
- gasPrice?: undefined | undefined;
2265
- maxFeePerBlobGas: bigint;
2266
- maxFeePerGas: bigint;
2267
- maxPriorityFeePerGas: bigint;
2268
- isSystemTx?: undefined | undefined;
2269
- mint?: undefined | undefined;
2270
- sourceHash?: undefined | undefined;
2271
- } | {
2272
- blockHash: `0x${string}` | null;
2273
- blockNumber: bigint | null;
2274
- from: import("abitype").Address;
2275
- gas: bigint;
2276
- hash: import("viem").Hash;
2277
- input: import("viem").Hex;
2278
- nonce: number;
2279
- r: import("viem").Hex;
2280
- s: import("viem").Hex;
2281
- to: import("abitype").Address | null;
2282
- transactionIndex: number | null;
2283
- typeHex: import("viem").Hex | null;
2284
- v: bigint;
2285
- value: bigint;
2286
- yParity: number;
2287
- accessList: import("viem").AccessList;
2288
- authorizationList: import("viem").SignedAuthorizationList;
2289
- blobVersionedHashes?: undefined | undefined;
2290
- chainId: number;
2291
- type: "eip7702";
2292
- gasPrice?: undefined | undefined;
2293
- maxFeePerBlobGas?: undefined | undefined;
2294
- maxFeePerGas: bigint;
2295
- maxPriorityFeePerGas: bigint;
2296
- isSystemTx?: undefined | undefined;
2297
- mint?: undefined | undefined;
2298
- sourceHash?: undefined | undefined;
2299
- }) & {};
2300
- type: "transaction";
2301
- };
2302
- readonly transactionReceipt: {
2303
- exclude: [] | undefined;
2304
- format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
2305
- blobGasPrice?: bigint | undefined;
2306
- blobGasUsed?: bigint | undefined;
2307
- blockHash: import("viem").Hash;
2308
- blockNumber: bigint;
2309
- contractAddress: import("abitype").Address | null | undefined;
2310
- cumulativeGasUsed: bigint;
2311
- effectiveGasPrice: bigint;
2312
- from: import("abitype").Address;
2313
- gasUsed: bigint;
2314
- logs: import("viem").Log<bigint, number, false>[];
2315
- logsBloom: import("viem").Hex;
2316
- root?: `0x${string}` | undefined;
2317
- status: "success" | "reverted";
2318
- to: import("abitype").Address | null;
2319
- transactionHash: import("viem").Hash;
2320
- transactionIndex: number;
2321
- type: import("viem").TransactionType;
2322
- l1GasPrice: bigint | null;
2323
- l1GasUsed: bigint | null;
2324
- l1Fee: bigint | null;
2325
- l1FeeScalar: number | null;
2326
- } & {};
2327
- type: "transactionReceipt";
2328
- };
2329
- };
2330
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2331
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2332
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2333
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2334
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2335
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2336
- }] | undefined;
2337
- serializers: {
2338
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2339
- };
2340
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2341
- readonly network: "base-sepolia";
2342
- } | {
2343
- blockExplorers: {
2344
- readonly default: {
2345
- readonly name: "Arbiscan";
2346
- readonly url: "https://sepolia.arbiscan.io";
2347
- readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
2348
- };
2349
- };
2350
- blockTime: 250;
2351
- contracts: {
2352
- readonly multicall3: {
2353
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2354
- readonly blockCreated: 81930;
2355
- };
2356
- };
2357
- ensTlds?: readonly string[] | undefined;
2358
- id: 421614;
2359
- name: "Arbitrum Sepolia";
2360
- nativeCurrency: {
2361
- readonly name: "Arbitrum Sepolia Ether";
2362
- readonly symbol: "ETH";
2363
- readonly decimals: 18;
2364
- };
2365
- experimental_preconfirmationTime?: number | undefined | undefined;
2366
- rpcUrls: {
2367
- readonly default: {
2368
- readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
2369
- };
2370
- };
2371
- sourceId?: number | undefined | undefined;
2372
- testnet: true;
2373
- custom?: Record<string, unknown> | undefined;
2374
- extendSchema?: Record<string, unknown> | undefined;
2375
- fees?: import("viem").ChainFees<undefined> | undefined;
2376
- formatters?: undefined;
2377
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2378
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2379
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2380
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2381
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2382
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2383
- }] | undefined;
2384
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2385
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2386
- } | {
2387
- blockExplorers: {
2388
- readonly default: {
2389
- readonly name: "RouteScan";
2390
- readonly url: "https://testnet.plasmascan.to";
2391
- };
2392
- };
2393
- blockTime?: number | undefined | undefined;
2394
- contracts: {
2395
- readonly multicall3: {
2396
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
2397
- readonly blockCreated: 0;
3674
+ chainId: number;
3675
+ type: "eip4844";
3676
+ gasPrice?: undefined | undefined;
3677
+ maxFeePerBlobGas: bigint;
3678
+ maxFeePerGas: bigint;
3679
+ maxPriorityFeePerGas: bigint;
3680
+ isSystemTx?: undefined | undefined;
3681
+ mint?: undefined | undefined;
3682
+ sourceHash?: undefined | undefined;
3683
+ } | {
3684
+ blockHash: `0x${string}` | null;
3685
+ blockNumber: bigint | null;
3686
+ from: import("abitype").Address;
3687
+ gas: bigint;
3688
+ hash: import("viem").Hash;
3689
+ input: import("viem").Hex;
3690
+ nonce: number;
3691
+ r: import("viem").Hex;
3692
+ s: import("viem").Hex;
3693
+ to: import("abitype").Address | null;
3694
+ transactionIndex: number | null;
3695
+ typeHex: import("viem").Hex | null;
3696
+ v: bigint;
3697
+ value: bigint;
3698
+ yParity: number;
3699
+ accessList: import("viem").AccessList;
3700
+ authorizationList: import("viem").SignedAuthorizationList;
3701
+ blobVersionedHashes?: undefined | undefined;
3702
+ chainId: number;
3703
+ type: "eip7702";
3704
+ gasPrice?: undefined | undefined;
3705
+ maxFeePerBlobGas?: undefined | undefined;
3706
+ maxFeePerGas: bigint;
3707
+ maxPriorityFeePerGas: bigint;
3708
+ isSystemTx?: undefined | undefined;
3709
+ mint?: undefined | undefined;
3710
+ sourceHash?: undefined | undefined;
3711
+ }) & {};
3712
+ type: "transaction";
2398
3713
  };
2399
- };
2400
- ensTlds?: readonly string[] | undefined;
2401
- id: 9746;
2402
- name: "Plasma Testnet";
2403
- nativeCurrency: {
2404
- readonly name: "Testnet Plasma";
2405
- readonly symbol: "XPL";
2406
- readonly decimals: 18;
2407
- };
2408
- experimental_preconfirmationTime?: number | undefined | undefined;
2409
- rpcUrls: {
2410
- readonly default: {
2411
- readonly http: readonly ["https://testnet-rpc.plasma.to"];
3714
+ readonly transactionReceipt: {
3715
+ exclude: [] | undefined;
3716
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
3717
+ blobGasPrice?: bigint | undefined;
3718
+ blobGasUsed?: bigint | undefined;
3719
+ blockHash: import("viem").Hash;
3720
+ blockNumber: bigint;
3721
+ contractAddress: import("abitype").Address | null | undefined;
3722
+ cumulativeGasUsed: bigint;
3723
+ effectiveGasPrice: bigint;
3724
+ from: import("abitype").Address;
3725
+ gasUsed: bigint;
3726
+ logs: import("viem").Log<bigint, number, false>[];
3727
+ logsBloom: import("viem").Hex;
3728
+ root?: `0x${string}` | undefined;
3729
+ status: "success" | "reverted";
3730
+ to: import("abitype").Address | null;
3731
+ transactionHash: import("viem").Hash;
3732
+ transactionIndex: number;
3733
+ type: import("viem").TransactionType;
3734
+ l1GasPrice: bigint | null;
3735
+ l1GasUsed: bigint | null;
3736
+ l1Fee: bigint | null;
3737
+ l1FeeScalar: number | null;
3738
+ } & {};
3739
+ type: "transactionReceipt";
2412
3740
  };
2413
3741
  };
2414
- sourceId?: number | undefined | undefined;
2415
- testnet: true;
2416
- custom?: Record<string, unknown> | undefined;
2417
- extendSchema?: Record<string, unknown> | undefined;
2418
- fees?: import("viem").ChainFees<undefined> | undefined;
2419
- formatters?: undefined;
2420
3742
  prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2421
3743
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2422
3744
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
@@ -2424,89 +3746,44 @@ declare const testnetChains: ({
2424
3746
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2425
3747
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2426
3748
  }] | undefined;
2427
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2428
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2429
- })[];
2430
- declare const chains: ({
2431
- blockExplorers: {
2432
- readonly default: {
2433
- readonly name: "Etherscan";
2434
- readonly url: "https://etherscan.io";
2435
- readonly apiUrl: "https://api.etherscan.io/api";
2436
- };
2437
- };
2438
- blockTime: 12000;
2439
- contracts: {
2440
- readonly ensUniversalResolver: {
2441
- readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
2442
- readonly blockCreated: 23085558;
2443
- };
2444
- readonly multicall3: {
2445
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2446
- readonly blockCreated: 14353601;
2447
- };
2448
- };
2449
- ensTlds?: readonly string[] | undefined;
2450
- id: 1;
2451
- name: "Ethereum";
2452
- nativeCurrency: {
2453
- readonly name: "Ether";
2454
- readonly symbol: "ETH";
2455
- readonly decimals: 18;
2456
- };
2457
- experimental_preconfirmationTime?: number | undefined | undefined;
2458
- rpcUrls: {
2459
- readonly default: {
2460
- readonly http: readonly ["https://eth.merkle.io"];
2461
- };
3749
+ serializers: {
3750
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2462
3751
  };
2463
- sourceId?: number | undefined | undefined;
2464
- testnet?: boolean | undefined | undefined;
2465
- custom?: Record<string, unknown> | undefined;
2466
- extendSchema?: Record<string, unknown> | undefined;
2467
- fees?: import("viem").ChainFees<undefined> | undefined;
2468
- formatters?: undefined;
2469
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2470
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2471
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2472
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2473
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2474
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2475
- }] | undefined;
2476
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2477
3752
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2478
3753
  } | {
2479
3754
  blockExplorers: {
2480
3755
  readonly default: {
2481
- readonly name: "Optimism Explorer";
2482
- readonly url: "https://optimistic.etherscan.io";
2483
- readonly apiUrl: "https://api-optimistic.etherscan.io/api";
3756
+ readonly name: "Basescan";
3757
+ readonly url: "https://basescan.org";
3758
+ readonly apiUrl: "https://api.basescan.org/api";
2484
3759
  };
2485
3760
  };
2486
3761
  blockTime: 2000;
2487
3762
  contracts: {
2488
3763
  readonly disputeGameFactory: {
2489
3764
  readonly 1: {
2490
- readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
3765
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
2491
3766
  };
2492
3767
  };
2493
3768
  readonly l2OutputOracle: {
2494
3769
  readonly 1: {
2495
- readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
3770
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
2496
3771
  };
2497
3772
  };
2498
3773
  readonly multicall3: {
2499
3774
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2500
- readonly blockCreated: 4286263;
3775
+ readonly blockCreated: 5022;
2501
3776
  };
2502
3777
  readonly portal: {
2503
3778
  readonly 1: {
2504
- readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
3779
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
3780
+ readonly blockCreated: 17482143;
2505
3781
  };
2506
3782
  };
2507
3783
  readonly l1StandardBridge: {
2508
3784
  readonly 1: {
2509
- readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
3785
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
3786
+ readonly blockCreated: 17482143;
2510
3787
  };
2511
3788
  };
2512
3789
  readonly gasPriceOracle: {
@@ -2529,8 +3806,8 @@ declare const chains: ({
2529
3806
  };
2530
3807
  };
2531
3808
  ensTlds?: readonly string[] | undefined;
2532
- id: 10;
2533
- name: "OP Mainnet";
3809
+ id: 8453;
3810
+ name: "Base";
2534
3811
  nativeCurrency: {
2535
3812
  readonly name: "Ether";
2536
3813
  readonly symbol: "ETH";
@@ -2539,7 +3816,7 @@ declare const chains: ({
2539
3816
  experimental_preconfirmationTime?: number | undefined | undefined;
2540
3817
  rpcUrls: {
2541
3818
  readonly default: {
2542
- readonly http: readonly ["https://mainnet.optimism.io"];
3819
+ readonly http: readonly ["https://mainnet.base.org"];
2543
3820
  };
2544
3821
  };
2545
3822
  sourceId: 1;
@@ -2792,39 +4069,127 @@ declare const chains: ({
2792
4069
  } | {
2793
4070
  blockExplorers: {
2794
4071
  readonly default: {
2795
- readonly name: "Basescan";
2796
- readonly url: "https://basescan.org";
2797
- readonly apiUrl: "https://api.basescan.org/api";
4072
+ readonly name: "Arbiscan";
4073
+ readonly url: "https://arbiscan.io";
4074
+ readonly apiUrl: "https://api.arbiscan.io/api";
4075
+ };
4076
+ };
4077
+ blockTime: 250;
4078
+ contracts: {
4079
+ readonly multicall3: {
4080
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4081
+ readonly blockCreated: 7654707;
4082
+ };
4083
+ };
4084
+ ensTlds?: readonly string[] | undefined;
4085
+ id: 42161;
4086
+ name: "Arbitrum One";
4087
+ nativeCurrency: {
4088
+ readonly name: "Ether";
4089
+ readonly symbol: "ETH";
4090
+ readonly decimals: 18;
4091
+ };
4092
+ experimental_preconfirmationTime?: number | undefined | undefined;
4093
+ rpcUrls: {
4094
+ readonly default: {
4095
+ readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
4096
+ };
4097
+ };
4098
+ sourceId?: number | undefined | undefined;
4099
+ testnet?: boolean | undefined | undefined;
4100
+ custom?: Record<string, unknown> | undefined;
4101
+ extendSchema?: Record<string, unknown> | undefined;
4102
+ fees?: import("viem").ChainFees<undefined> | undefined;
4103
+ formatters?: undefined;
4104
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4105
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4106
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4107
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4108
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4109
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4110
+ }] | undefined;
4111
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4112
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4113
+ } | {
4114
+ blockExplorers: {
4115
+ readonly default: {
4116
+ readonly name: "PolygonScan";
4117
+ readonly url: "https://polygonscan.com";
4118
+ readonly apiUrl: "https://api.etherscan.io/v2/api";
4119
+ };
4120
+ };
4121
+ blockTime: 2000;
4122
+ contracts: {
4123
+ readonly multicall3: {
4124
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4125
+ readonly blockCreated: 25770160;
4126
+ };
4127
+ };
4128
+ ensTlds?: readonly string[] | undefined;
4129
+ id: 137;
4130
+ name: "Polygon";
4131
+ nativeCurrency: {
4132
+ readonly name: "POL";
4133
+ readonly symbol: "POL";
4134
+ readonly decimals: 18;
4135
+ };
4136
+ experimental_preconfirmationTime?: number | undefined | undefined;
4137
+ rpcUrls: {
4138
+ readonly default: {
4139
+ readonly http: readonly ["https://polygon-rpc.com"];
4140
+ };
4141
+ };
4142
+ sourceId?: number | undefined | undefined;
4143
+ testnet?: boolean | undefined | undefined;
4144
+ custom?: Record<string, unknown> | undefined;
4145
+ extendSchema?: Record<string, unknown> | undefined;
4146
+ fees?: import("viem").ChainFees<undefined> | undefined;
4147
+ formatters?: undefined;
4148
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4149
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4150
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4151
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4152
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4153
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4154
+ }] | undefined;
4155
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4156
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4157
+ } | {
4158
+ blockExplorers: {
4159
+ readonly default: {
4160
+ readonly name: "Blockscout";
4161
+ readonly url: "https://soneium.blockscout.com";
4162
+ readonly apiUrl: "https://soneium.blockscout.com/api";
2798
4163
  };
2799
4164
  };
2800
4165
  blockTime: 2000;
2801
4166
  contracts: {
2802
4167
  readonly disputeGameFactory: {
2803
4168
  readonly 1: {
2804
- readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
4169
+ readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
2805
4170
  };
2806
4171
  };
2807
4172
  readonly l2OutputOracle: {
2808
4173
  readonly 1: {
2809
- readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
4174
+ readonly address: "0x0000000000000000000000000000000000000000";
2810
4175
  };
2811
4176
  };
2812
- readonly multicall3: {
2813
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2814
- readonly blockCreated: 5022;
2815
- };
2816
4177
  readonly portal: {
2817
4178
  readonly 1: {
2818
- readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
2819
- readonly blockCreated: 17482143;
4179
+ readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
4180
+ readonly blockCreated: 7061266;
2820
4181
  };
2821
4182
  };
2822
4183
  readonly l1StandardBridge: {
2823
4184
  readonly 1: {
2824
- readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
2825
- readonly blockCreated: 17482143;
4185
+ readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
4186
+ readonly blockCreated: 7061266;
2826
4187
  };
2827
4188
  };
4189
+ readonly multicall3: {
4190
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4191
+ readonly blockCreated: 1;
4192
+ };
2828
4193
  readonly gasPriceOracle: {
2829
4194
  readonly address: "0x420000000000000000000000000000000000000F";
2830
4195
  };
@@ -2845,8 +4210,8 @@ declare const chains: ({
2845
4210
  };
2846
4211
  };
2847
4212
  ensTlds?: readonly string[] | undefined;
2848
- id: 8453;
2849
- name: "Base";
4213
+ id: 1868;
4214
+ name: "Soneium Mainnet";
2850
4215
  nativeCurrency: {
2851
4216
  readonly name: "Ether";
2852
4217
  readonly symbol: "ETH";
@@ -2855,7 +4220,7 @@ declare const chains: ({
2855
4220
  experimental_preconfirmationTime?: number | undefined | undefined;
2856
4221
  rpcUrls: {
2857
4222
  readonly default: {
2858
- readonly http: readonly ["https://mainnet.base.org"];
4223
+ readonly http: readonly ["https://rpc.soneium.org"];
2859
4224
  };
2860
4225
  };
2861
4226
  sourceId: 1;
@@ -3108,30 +4473,72 @@ declare const chains: ({
3108
4473
  } | {
3109
4474
  blockExplorers: {
3110
4475
  readonly default: {
3111
- readonly name: "Arbiscan";
3112
- readonly url: "https://arbiscan.io";
3113
- readonly apiUrl: "https://api.arbiscan.io/api";
4476
+ readonly name: "Sonic Explorer";
4477
+ readonly url: "https://sonicscan.org";
3114
4478
  };
3115
4479
  };
3116
- blockTime: 250;
4480
+ blockTime: 630;
3117
4481
  contracts: {
3118
4482
  readonly multicall3: {
3119
4483
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3120
- readonly blockCreated: 7654707;
4484
+ readonly blockCreated: 60;
3121
4485
  };
3122
4486
  };
3123
4487
  ensTlds?: readonly string[] | undefined;
3124
- id: 42161;
3125
- name: "Arbitrum One";
4488
+ id: 146;
4489
+ name: "Sonic";
3126
4490
  nativeCurrency: {
3127
- readonly name: "Ether";
3128
- readonly symbol: "ETH";
3129
4491
  readonly decimals: 18;
4492
+ readonly name: "Sonic";
4493
+ readonly symbol: "S";
3130
4494
  };
3131
4495
  experimental_preconfirmationTime?: number | undefined | undefined;
3132
4496
  rpcUrls: {
3133
4497
  readonly default: {
3134
- readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
4498
+ readonly http: readonly ["https://rpc.soniclabs.com"];
4499
+ };
4500
+ };
4501
+ sourceId?: number | undefined | undefined;
4502
+ testnet: false;
4503
+ custom?: Record<string, unknown> | undefined;
4504
+ extendSchema?: Record<string, unknown> | undefined;
4505
+ fees?: import("viem").ChainFees<undefined> | undefined;
4506
+ formatters?: undefined;
4507
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4508
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4509
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4510
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4511
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4512
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4513
+ }] | undefined;
4514
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4515
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4516
+ } | {
4517
+ blockExplorers: {
4518
+ readonly default: {
4519
+ readonly name: "PlasmaScan";
4520
+ readonly url: "https://plasmascan.to";
4521
+ };
4522
+ };
4523
+ blockTime: 1000;
4524
+ contracts: {
4525
+ readonly multicall3: {
4526
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4527
+ readonly blockCreated: 0;
4528
+ };
4529
+ };
4530
+ ensTlds?: readonly string[] | undefined;
4531
+ id: 9745;
4532
+ name: "Plasma";
4533
+ nativeCurrency: {
4534
+ readonly name: "Plasma";
4535
+ readonly symbol: "XPL";
4536
+ readonly decimals: 18;
4537
+ };
4538
+ experimental_preconfirmationTime?: number | undefined | undefined;
4539
+ rpcUrls: {
4540
+ readonly default: {
4541
+ readonly http: readonly ["https://rpc.plasma.to"];
3135
4542
  };
3136
4543
  };
3137
4544
  sourceId?: number | undefined | undefined;
@@ -3152,30 +4559,31 @@ declare const chains: ({
3152
4559
  } | {
3153
4560
  blockExplorers: {
3154
4561
  readonly default: {
3155
- readonly name: "PolygonScan";
3156
- readonly url: "https://polygonscan.com";
3157
- readonly apiUrl: "https://api.etherscan.io/v2/api";
4562
+ readonly name: "Gnosisscan";
4563
+ readonly url: "https://gnosisscan.io";
4564
+ readonly apiUrl: "https://api.gnosisscan.io/api";
3158
4565
  };
3159
4566
  };
3160
- blockTime: 2000;
4567
+ blockTime: 5000;
3161
4568
  contracts: {
3162
4569
  readonly multicall3: {
3163
4570
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3164
- readonly blockCreated: 25770160;
4571
+ readonly blockCreated: 21022491;
3165
4572
  };
3166
4573
  };
3167
4574
  ensTlds?: readonly string[] | undefined;
3168
- id: 137;
3169
- name: "Polygon";
4575
+ id: 100;
4576
+ name: "Gnosis";
3170
4577
  nativeCurrency: {
3171
- readonly name: "POL";
3172
- readonly symbol: "POL";
3173
4578
  readonly decimals: 18;
4579
+ readonly name: "xDAI";
4580
+ readonly symbol: "XDAI";
3174
4581
  };
3175
4582
  experimental_preconfirmationTime?: number | undefined | undefined;
3176
4583
  rpcUrls: {
3177
4584
  readonly default: {
3178
- readonly http: readonly ["https://polygon-rpc.com"];
4585
+ readonly http: readonly ["https://rpc.gnosischain.com"];
4586
+ readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
3179
4587
  };
3180
4588
  };
3181
4589
  sourceId?: number | undefined | undefined;
@@ -3196,39 +4604,171 @@ declare const chains: ({
3196
4604
  } | {
3197
4605
  blockExplorers: {
3198
4606
  readonly default: {
3199
- readonly name: "Blockscout";
3200
- readonly url: "https://soneium.blockscout.com";
3201
- readonly apiUrl: "https://soneium.blockscout.com/api";
4607
+ readonly name: "BscScan";
4608
+ readonly url: "https://bscscan.com";
4609
+ readonly apiUrl: "https://api.bscscan.com/api";
3202
4610
  };
3203
4611
  };
3204
- blockTime: 2000;
4612
+ blockTime: 750;
3205
4613
  contracts: {
3206
- readonly disputeGameFactory: {
3207
- readonly 1: {
3208
- readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
3209
- };
4614
+ readonly multicall3: {
4615
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4616
+ readonly blockCreated: 15921452;
4617
+ };
4618
+ };
4619
+ ensTlds?: readonly string[] | undefined;
4620
+ id: 56;
4621
+ name: "BNB Smart Chain";
4622
+ nativeCurrency: {
4623
+ readonly decimals: 18;
4624
+ readonly name: "BNB";
4625
+ readonly symbol: "BNB";
4626
+ };
4627
+ experimental_preconfirmationTime?: number | undefined | undefined;
4628
+ rpcUrls: {
4629
+ readonly default: {
4630
+ readonly http: readonly ["https://56.rpc.thirdweb.com"];
4631
+ };
4632
+ };
4633
+ sourceId?: number | undefined | undefined;
4634
+ testnet?: boolean | undefined | undefined;
4635
+ custom?: Record<string, unknown> | undefined;
4636
+ extendSchema?: Record<string, unknown> | undefined;
4637
+ fees?: import("viem").ChainFees<undefined> | undefined;
4638
+ formatters?: undefined;
4639
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4640
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4641
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4642
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4643
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4644
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4645
+ }] | undefined;
4646
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4647
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4648
+ } | {
4649
+ blockExplorers: {
4650
+ readonly default: {
4651
+ readonly name: "HyperEVMScan";
4652
+ readonly url: "https://hyperevmscan.io";
4653
+ };
4654
+ };
4655
+ blockTime?: number | undefined | undefined;
4656
+ contracts?: {
4657
+ [x: string]: import("viem").ChainContract | {
4658
+ [sourceId: number]: import("viem").ChainContract | undefined;
4659
+ } | undefined;
4660
+ ensRegistry?: import("viem").ChainContract | undefined;
4661
+ ensUniversalResolver?: import("viem").ChainContract | undefined;
4662
+ multicall3?: import("viem").ChainContract | undefined;
4663
+ erc6492Verifier?: import("viem").ChainContract | undefined;
4664
+ } | undefined;
4665
+ ensTlds?: readonly string[] | undefined;
4666
+ id: 999;
4667
+ name: "HyperEVM";
4668
+ nativeCurrency: {
4669
+ readonly name: "HYPE";
4670
+ readonly symbol: "HYPE";
4671
+ readonly decimals: 18;
4672
+ };
4673
+ experimental_preconfirmationTime?: number | undefined | undefined;
4674
+ rpcUrls: {
4675
+ readonly default: {
4676
+ readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
4677
+ };
4678
+ };
4679
+ sourceId?: number | undefined | undefined;
4680
+ testnet: false;
4681
+ custom?: Record<string, unknown> | undefined;
4682
+ extendSchema?: Record<string, unknown> | undefined;
4683
+ fees?: import("viem").ChainFees<undefined> | undefined;
4684
+ formatters?: undefined;
4685
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4686
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4687
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4688
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4689
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4690
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4691
+ }] | undefined;
4692
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4693
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4694
+ } | {
4695
+ blockExplorers: {
4696
+ readonly default: {
4697
+ readonly name: "MonadVision";
4698
+ readonly url: "https://monadvision.com";
4699
+ };
4700
+ readonly monadscan: {
4701
+ readonly name: "Monadscan";
4702
+ readonly url: "https://monadscan.com";
4703
+ readonly apiUrl: "https://api.monadscan.com/api";
4704
+ };
4705
+ };
4706
+ blockTime: 400;
4707
+ contracts: {
4708
+ readonly multicall3: {
4709
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4710
+ readonly blockCreated: 9248132;
4711
+ };
4712
+ };
4713
+ ensTlds?: readonly string[] | undefined;
4714
+ id: 143;
4715
+ name: "Monad";
4716
+ nativeCurrency: {
4717
+ readonly name: "Monad";
4718
+ readonly symbol: "MON";
4719
+ readonly decimals: 18;
4720
+ };
4721
+ experimental_preconfirmationTime?: number | undefined | undefined;
4722
+ rpcUrls: {
4723
+ readonly default: {
4724
+ readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
4725
+ readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
4726
+ };
4727
+ };
4728
+ sourceId?: number | undefined | undefined;
4729
+ testnet: false;
4730
+ custom?: Record<string, unknown> | undefined;
4731
+ extendSchema?: Record<string, unknown> | undefined;
4732
+ fees?: import("viem").ChainFees<undefined> | undefined;
4733
+ formatters?: undefined;
4734
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4735
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4736
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4737
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4738
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4739
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4740
+ }] | undefined;
4741
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4742
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4743
+ } | {
4744
+ blockExplorers: {
4745
+ readonly default: {
4746
+ readonly name: "Uniscan";
4747
+ readonly url: "https://uniscan.xyz";
4748
+ readonly apiUrl: "https://api.uniscan.xyz/api";
4749
+ };
4750
+ };
4751
+ blockTime: 1000;
4752
+ contracts: {
4753
+ readonly multicall3: {
4754
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4755
+ readonly blockCreated: 0;
3210
4756
  };
3211
- readonly l2OutputOracle: {
4757
+ readonly disputeGameFactory: {
3212
4758
  readonly 1: {
3213
- readonly address: "0x0000000000000000000000000000000000000000";
4759
+ readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
3214
4760
  };
3215
4761
  };
3216
4762
  readonly portal: {
3217
4763
  readonly 1: {
3218
- readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
3219
- readonly blockCreated: 7061266;
4764
+ readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
3220
4765
  };
3221
4766
  };
3222
4767
  readonly l1StandardBridge: {
3223
4768
  readonly 1: {
3224
- readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
3225
- readonly blockCreated: 7061266;
4769
+ readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
3226
4770
  };
3227
4771
  };
3228
- readonly multicall3: {
3229
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3230
- readonly blockCreated: 1;
3231
- };
3232
4772
  readonly gasPriceOracle: {
3233
4773
  readonly address: "0x420000000000000000000000000000000000000F";
3234
4774
  };
@@ -3249,8 +4789,8 @@ declare const chains: ({
3249
4789
  };
3250
4790
  };
3251
4791
  ensTlds?: readonly string[] | undefined;
3252
- id: 1868;
3253
- name: "Soneium Mainnet";
4792
+ id: 130;
4793
+ name: "Unichain";
3254
4794
  nativeCurrency: {
3255
4795
  readonly name: "Ether";
3256
4796
  readonly symbol: "ETH";
@@ -3259,7 +4799,7 @@ declare const chains: ({
3259
4799
  experimental_preconfirmationTime?: number | undefined | undefined;
3260
4800
  rpcUrls: {
3261
4801
  readonly default: {
3262
- readonly http: readonly ["https://rpc.soneium.org"];
4802
+ readonly http: readonly ["https://mainnet.unichain.org/"];
3263
4803
  };
3264
4804
  };
3265
4805
  sourceId: 1;
@@ -3481,246 +5021,23 @@ declare const chains: ({
3481
5021
  cumulativeGasUsed: bigint;
3482
5022
  effectiveGasPrice: bigint;
3483
5023
  from: import("abitype").Address;
3484
- gasUsed: bigint;
3485
- logs: import("viem").Log<bigint, number, false>[];
3486
- logsBloom: import("viem").Hex;
3487
- root?: `0x${string}` | undefined;
3488
- status: "success" | "reverted";
3489
- to: import("abitype").Address | null;
3490
- transactionHash: import("viem").Hash;
3491
- transactionIndex: number;
3492
- type: import("viem").TransactionType;
3493
- l1GasPrice: bigint | null;
3494
- l1GasUsed: bigint | null;
3495
- l1Fee: bigint | null;
3496
- l1FeeScalar: number | null;
3497
- } & {};
3498
- type: "transactionReceipt";
3499
- };
3500
- };
3501
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3502
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3503
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3504
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3505
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3506
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3507
- }] | undefined;
3508
- serializers: {
3509
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3510
- };
3511
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3512
- } | {
3513
- blockExplorers: {
3514
- readonly default: {
3515
- readonly name: "Sonic Explorer";
3516
- readonly url: "https://sonicscan.org";
3517
- };
3518
- };
3519
- blockTime: 630;
3520
- contracts: {
3521
- readonly multicall3: {
3522
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3523
- readonly blockCreated: 60;
3524
- };
3525
- };
3526
- ensTlds?: readonly string[] | undefined;
3527
- id: 146;
3528
- name: "Sonic";
3529
- nativeCurrency: {
3530
- readonly decimals: 18;
3531
- readonly name: "Sonic";
3532
- readonly symbol: "S";
3533
- };
3534
- experimental_preconfirmationTime?: number | undefined | undefined;
3535
- rpcUrls: {
3536
- readonly default: {
3537
- readonly http: readonly ["https://rpc.soniclabs.com"];
3538
- };
3539
- };
3540
- sourceId?: number | undefined | undefined;
3541
- testnet: false;
3542
- custom?: Record<string, unknown> | undefined;
3543
- extendSchema?: Record<string, unknown> | undefined;
3544
- fees?: import("viem").ChainFees<undefined> | undefined;
3545
- formatters?: undefined;
3546
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3547
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3548
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3549
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3550
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3551
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3552
- }] | undefined;
3553
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3554
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3555
- } | {
3556
- blockExplorers: {
3557
- readonly default: {
3558
- readonly name: "PlasmaScan";
3559
- readonly url: "https://plasmascan.to";
3560
- };
3561
- };
3562
- blockTime: 1000;
3563
- contracts: {
3564
- readonly multicall3: {
3565
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3566
- readonly blockCreated: 0;
3567
- };
3568
- };
3569
- ensTlds?: readonly string[] | undefined;
3570
- id: 9745;
3571
- name: "Plasma";
3572
- nativeCurrency: {
3573
- readonly name: "Plasma";
3574
- readonly symbol: "XPL";
3575
- readonly decimals: 18;
3576
- };
3577
- experimental_preconfirmationTime?: number | undefined | undefined;
3578
- rpcUrls: {
3579
- readonly default: {
3580
- readonly http: readonly ["https://rpc.plasma.to"];
3581
- };
3582
- };
3583
- sourceId?: number | undefined | undefined;
3584
- testnet?: boolean | undefined | undefined;
3585
- custom?: Record<string, unknown> | undefined;
3586
- extendSchema?: Record<string, unknown> | undefined;
3587
- fees?: import("viem").ChainFees<undefined> | undefined;
3588
- formatters?: undefined;
3589
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3590
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3591
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3592
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3593
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3594
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3595
- }] | undefined;
3596
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3597
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3598
- } | {
3599
- blockExplorers: {
3600
- readonly default: {
3601
- readonly name: "Gnosisscan";
3602
- readonly url: "https://gnosisscan.io";
3603
- readonly apiUrl: "https://api.gnosisscan.io/api";
3604
- };
3605
- };
3606
- blockTime: 5000;
3607
- contracts: {
3608
- readonly multicall3: {
3609
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3610
- readonly blockCreated: 21022491;
3611
- };
3612
- };
3613
- ensTlds?: readonly string[] | undefined;
3614
- id: 100;
3615
- name: "Gnosis";
3616
- nativeCurrency: {
3617
- readonly decimals: 18;
3618
- readonly name: "xDAI";
3619
- readonly symbol: "XDAI";
3620
- };
3621
- experimental_preconfirmationTime?: number | undefined | undefined;
3622
- rpcUrls: {
3623
- readonly default: {
3624
- readonly http: readonly ["https://rpc.gnosischain.com"];
3625
- readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
3626
- };
3627
- };
3628
- sourceId?: number | undefined | undefined;
3629
- testnet?: boolean | undefined | undefined;
3630
- custom?: Record<string, unknown> | undefined;
3631
- extendSchema?: Record<string, unknown> | undefined;
3632
- fees?: import("viem").ChainFees<undefined> | undefined;
3633
- formatters?: undefined;
3634
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3635
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3636
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3637
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3638
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3639
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3640
- }] | undefined;
3641
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3642
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3643
- } | {
3644
- blockExplorers: {
3645
- readonly default: {
3646
- readonly name: "BscScan";
3647
- readonly url: "https://bscscan.com";
3648
- readonly apiUrl: "https://api.bscscan.com/api";
3649
- };
3650
- };
3651
- blockTime: 750;
3652
- contracts: {
3653
- readonly multicall3: {
3654
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3655
- readonly blockCreated: 15921452;
3656
- };
3657
- };
3658
- ensTlds?: readonly string[] | undefined;
3659
- id: 56;
3660
- name: "BNB Smart Chain";
3661
- nativeCurrency: {
3662
- readonly decimals: 18;
3663
- readonly name: "BNB";
3664
- readonly symbol: "BNB";
3665
- };
3666
- experimental_preconfirmationTime?: number | undefined | undefined;
3667
- rpcUrls: {
3668
- readonly default: {
3669
- readonly http: readonly ["https://56.rpc.thirdweb.com"];
3670
- };
3671
- };
3672
- sourceId?: number | undefined | undefined;
3673
- testnet?: boolean | undefined | undefined;
3674
- custom?: Record<string, unknown> | undefined;
3675
- extendSchema?: Record<string, unknown> | undefined;
3676
- fees?: import("viem").ChainFees<undefined> | undefined;
3677
- formatters?: undefined;
3678
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3679
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3680
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3681
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3682
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3683
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3684
- }] | undefined;
3685
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3686
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3687
- } | {
3688
- blockExplorers: {
3689
- readonly default: {
3690
- readonly name: "HyperEVMScan";
3691
- readonly url: "https://hyperevmscan.io";
3692
- };
3693
- };
3694
- blockTime?: number | undefined | undefined;
3695
- contracts?: {
3696
- [x: string]: import("viem").ChainContract | {
3697
- [sourceId: number]: import("viem").ChainContract | undefined;
3698
- } | undefined;
3699
- ensRegistry?: import("viem").ChainContract | undefined;
3700
- ensUniversalResolver?: import("viem").ChainContract | undefined;
3701
- multicall3?: import("viem").ChainContract | undefined;
3702
- erc6492Verifier?: import("viem").ChainContract | undefined;
3703
- } | undefined;
3704
- ensTlds?: readonly string[] | undefined;
3705
- id: 999;
3706
- name: "HyperEVM";
3707
- nativeCurrency: {
3708
- readonly name: "HYPE";
3709
- readonly symbol: "HYPE";
3710
- readonly decimals: 18;
3711
- };
3712
- experimental_preconfirmationTime?: number | undefined | undefined;
3713
- rpcUrls: {
3714
- readonly default: {
3715
- readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
5024
+ gasUsed: bigint;
5025
+ logs: import("viem").Log<bigint, number, false>[];
5026
+ logsBloom: import("viem").Hex;
5027
+ root?: `0x${string}` | undefined;
5028
+ status: "success" | "reverted";
5029
+ to: import("abitype").Address | null;
5030
+ transactionHash: import("viem").Hash;
5031
+ transactionIndex: number;
5032
+ type: import("viem").TransactionType;
5033
+ l1GasPrice: bigint | null;
5034
+ l1GasUsed: bigint | null;
5035
+ l1Fee: bigint | null;
5036
+ l1FeeScalar: number | null;
5037
+ } & {};
5038
+ type: "transactionReceipt";
3716
5039
  };
3717
5040
  };
3718
- sourceId?: number | undefined | undefined;
3719
- testnet: false;
3720
- custom?: Record<string, unknown> | undefined;
3721
- extendSchema?: Record<string, unknown> | undefined;
3722
- fees?: import("viem").ChainFees<undefined> | undefined;
3723
- formatters?: undefined;
3724
5041
  prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3725
5042
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3726
5043
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
@@ -3728,40 +5045,39 @@ declare const chains: ({
3728
5045
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3729
5046
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3730
5047
  }] | undefined;
3731
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
5048
+ serializers: {
5049
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
5050
+ };
3732
5051
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3733
5052
  } | {
3734
5053
  blockExplorers: {
3735
5054
  readonly default: {
3736
- readonly name: "MonadVision";
3737
- readonly url: "https://monadvision.com";
3738
- };
3739
- readonly monadscan: {
3740
- readonly name: "Monadscan";
3741
- readonly url: "https://monadscan.com";
3742
- readonly apiUrl: "https://api.monadscan.com/api";
3743
- };
3744
- };
3745
- blockTime: 400;
3746
- contracts: {
3747
- readonly multicall3: {
3748
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3749
- readonly blockCreated: 9248132;
5055
+ readonly name: "katana explorer";
5056
+ readonly url: "https://katanascan.com";
3750
5057
  };
3751
5058
  };
5059
+ blockTime?: number | undefined | undefined;
5060
+ contracts?: {
5061
+ [x: string]: import("viem").ChainContract | {
5062
+ [sourceId: number]: import("viem").ChainContract | undefined;
5063
+ } | undefined;
5064
+ ensRegistry?: import("viem").ChainContract | undefined;
5065
+ ensUniversalResolver?: import("viem").ChainContract | undefined;
5066
+ multicall3?: import("viem").ChainContract | undefined;
5067
+ erc6492Verifier?: import("viem").ChainContract | undefined;
5068
+ } | undefined;
3752
5069
  ensTlds?: readonly string[] | undefined;
3753
- id: 143;
3754
- name: "Monad";
5070
+ id: 747474;
5071
+ name: "Katana";
3755
5072
  nativeCurrency: {
3756
- readonly name: "Monad";
3757
- readonly symbol: "MON";
5073
+ readonly name: "Ether";
5074
+ readonly symbol: "ETH";
3758
5075
  readonly decimals: 18;
3759
5076
  };
3760
5077
  experimental_preconfirmationTime?: number | undefined | undefined;
3761
5078
  rpcUrls: {
3762
5079
  readonly default: {
3763
- readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
3764
- readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
5080
+ readonly http: readonly ["https://rpc.katana.network"];
3765
5081
  };
3766
5082
  };
3767
5083
  sourceId?: number | undefined | undefined;
@@ -3779,134 +5095,50 @@ declare const chains: ({
3779
5095
  }] | undefined;
3780
5096
  serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3781
5097
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
5098
+ readonly network: "katana";
3782
5099
  } | {
3783
5100
  blockExplorers: {
3784
5101
  readonly default: {
3785
- readonly name: "Uniscan";
3786
- readonly url: "https://uniscan.xyz";
3787
- readonly apiUrl: "https://api.uniscan.xyz/api";
5102
+ readonly name: "Tempo Explorer";
5103
+ readonly url: "https://explore.mainnet.tempo.xyz";
3788
5104
  };
3789
5105
  };
3790
5106
  blockTime: 1000;
3791
- contracts: {
3792
- readonly multicall3: {
3793
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3794
- readonly blockCreated: 0;
3795
- };
3796
- readonly disputeGameFactory: {
3797
- readonly 1: {
3798
- readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
3799
- };
3800
- };
3801
- readonly portal: {
3802
- readonly 1: {
3803
- readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
3804
- };
3805
- };
3806
- readonly l1StandardBridge: {
3807
- readonly 1: {
3808
- readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
3809
- };
3810
- };
3811
- readonly gasPriceOracle: {
3812
- readonly address: "0x420000000000000000000000000000000000000F";
3813
- };
3814
- readonly l1Block: {
3815
- readonly address: "0x4200000000000000000000000000000000000015";
3816
- };
3817
- readonly l2CrossDomainMessenger: {
3818
- readonly address: "0x4200000000000000000000000000000000000007";
3819
- };
3820
- readonly l2Erc721Bridge: {
3821
- readonly address: "0x4200000000000000000000000000000000000014";
3822
- };
3823
- readonly l2StandardBridge: {
3824
- readonly address: "0x4200000000000000000000000000000000000010";
3825
- };
3826
- readonly l2ToL1MessagePasser: {
3827
- readonly address: "0x4200000000000000000000000000000000000016";
3828
- };
3829
- };
5107
+ contracts?: {
5108
+ [x: string]: import("viem").ChainContract | {
5109
+ [sourceId: number]: import("viem").ChainContract | undefined;
5110
+ } | undefined;
5111
+ ensRegistry?: import("viem").ChainContract | undefined;
5112
+ ensUniversalResolver?: import("viem").ChainContract | undefined;
5113
+ multicall3?: import("viem").ChainContract | undefined;
5114
+ erc6492Verifier?: import("viem").ChainContract | undefined;
5115
+ } | undefined;
3830
5116
  ensTlds?: readonly string[] | undefined;
3831
- id: 130;
3832
- name: "Unichain";
5117
+ id: 4217;
5118
+ name: "Tempo Mainnet";
3833
5119
  nativeCurrency: {
3834
- readonly name: "Ether";
3835
- readonly symbol: "ETH";
3836
- readonly decimals: 18;
5120
+ readonly name: "USD";
5121
+ readonly symbol: "USD";
5122
+ readonly decimals: 6;
3837
5123
  };
3838
5124
  experimental_preconfirmationTime?: number | undefined | undefined;
3839
5125
  rpcUrls: {
3840
5126
  readonly default: {
3841
- readonly http: readonly ["https://mainnet.unichain.org/"];
5127
+ readonly http: readonly ["https://rpc.presto.tempo.xyz"];
5128
+ readonly webSocket: readonly ["wss://rpc.presto.tempo.xyz"];
3842
5129
  };
3843
5130
  };
3844
- sourceId: 1;
5131
+ sourceId?: number | undefined | undefined;
3845
5132
  testnet?: boolean | undefined | undefined;
3846
5133
  custom?: Record<string, unknown> | undefined;
3847
- extendSchema?: Record<string, unknown> | undefined;
5134
+ extendSchema: {
5135
+ feeToken?: import("ox/tempo/TokenId").TokenIdOrAddress | undefined;
5136
+ };
3848
5137
  fees?: import("viem").ChainFees<undefined> | undefined;
3849
5138
  formatters: {
3850
- readonly block: {
3851
- exclude: [] | undefined;
3852
- format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
3853
- baseFeePerGas: bigint | null;
3854
- blobGasUsed: bigint;
3855
- difficulty: bigint;
3856
- excessBlobGas: bigint;
3857
- extraData: import("viem").Hex;
3858
- gasLimit: bigint;
3859
- gasUsed: bigint;
3860
- hash: `0x${string}` | null;
3861
- logsBloom: `0x${string}` | null;
3862
- miner: import("abitype").Address;
3863
- mixHash: import("viem").Hash;
3864
- nonce: `0x${string}` | null;
3865
- number: bigint | null;
3866
- parentBeaconBlockRoot?: `0x${string}` | undefined;
3867
- parentHash: import("viem").Hash;
3868
- receiptsRoot: import("viem").Hex;
3869
- sealFields: import("viem").Hex[];
3870
- sha3Uncles: import("viem").Hash;
3871
- size: bigint;
3872
- stateRoot: import("viem").Hash;
3873
- timestamp: bigint;
3874
- totalDifficulty: bigint | null;
3875
- transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
3876
- transactionsRoot: import("viem").Hash;
3877
- uncles: import("viem").Hash[];
3878
- withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
3879
- withdrawalsRoot?: `0x${string}` | undefined;
3880
- } & {};
3881
- type: "block";
3882
- };
3883
5139
  readonly transaction: {
3884
- exclude: [] | undefined;
3885
- format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
3886
- blockHash: `0x${string}` | null;
3887
- blockNumber: bigint | null;
3888
- from: import("abitype").Address;
3889
- gas: bigint;
3890
- hash: import("viem").Hash;
3891
- input: import("viem").Hex;
3892
- nonce: number;
3893
- r: import("viem").Hex;
3894
- s: import("viem").Hex;
3895
- to: import("abitype").Address | null;
3896
- transactionIndex: number | null;
3897
- typeHex: import("viem").Hex | null;
3898
- v: bigint;
3899
- value: bigint;
3900
- yParity: number;
3901
- gasPrice?: undefined | undefined;
3902
- maxFeePerBlobGas?: undefined | undefined;
3903
- maxFeePerGas: bigint;
3904
- maxPriorityFeePerGas: bigint;
3905
- isSystemTx?: boolean;
3906
- mint?: bigint | undefined | undefined;
3907
- sourceHash: import("viem").Hex;
3908
- type: "deposit";
3909
- } | {
5140
+ exclude: never[] | undefined;
5141
+ format: (args: import("viem/_types/tempo/Transaction").TransactionRpc, action?: string | undefined) => ({
3910
5142
  r: import("viem").Hex;
3911
5143
  s: import("viem").Hex;
3912
5144
  v: bigint;
@@ -3931,9 +5163,14 @@ declare const chains: ({
3931
5163
  maxFeePerBlobGas?: undefined | undefined;
3932
5164
  maxFeePerGas?: undefined | undefined;
3933
5165
  maxPriorityFeePerGas?: undefined | undefined;
3934
- isSystemTx?: undefined | undefined;
3935
- mint?: undefined | undefined;
3936
- sourceHash?: undefined | undefined;
5166
+ signature?: undefined;
5167
+ calls?: undefined;
5168
+ nonceKey?: undefined;
5169
+ validAfter?: undefined;
5170
+ feeToken?: undefined;
5171
+ feePayerSignature?: undefined;
5172
+ keyAuthorization?: undefined;
5173
+ validBefore?: undefined;
3937
5174
  } | {
3938
5175
  blockHash: `0x${string}` | null;
3939
5176
  blockNumber: bigint | null;
@@ -3959,9 +5196,14 @@ declare const chains: ({
3959
5196
  maxFeePerBlobGas?: undefined | undefined;
3960
5197
  maxFeePerGas?: undefined | undefined;
3961
5198
  maxPriorityFeePerGas?: undefined | undefined;
3962
- isSystemTx?: undefined | undefined;
3963
- mint?: undefined | undefined;
3964
- sourceHash?: undefined | undefined;
5199
+ signature?: undefined;
5200
+ calls?: undefined;
5201
+ nonceKey?: undefined;
5202
+ validAfter?: undefined;
5203
+ feeToken?: undefined;
5204
+ feePayerSignature?: undefined;
5205
+ keyAuthorization?: undefined;
5206
+ validBefore?: undefined;
3965
5207
  } | {
3966
5208
  blockHash: `0x${string}` | null;
3967
5209
  blockNumber: bigint | null;
@@ -3987,9 +5229,14 @@ declare const chains: ({
3987
5229
  maxFeePerBlobGas?: undefined | undefined;
3988
5230
  maxFeePerGas: bigint;
3989
5231
  maxPriorityFeePerGas: bigint;
3990
- isSystemTx?: undefined | undefined;
3991
- mint?: undefined | undefined;
3992
- sourceHash?: undefined | undefined;
5232
+ signature?: undefined;
5233
+ calls?: undefined;
5234
+ nonceKey?: undefined;
5235
+ validAfter?: undefined;
5236
+ feeToken?: undefined;
5237
+ feePayerSignature?: undefined;
5238
+ keyAuthorization?: undefined;
5239
+ validBefore?: undefined;
3993
5240
  } | {
3994
5241
  blockHash: `0x${string}` | null;
3995
5242
  blockNumber: bigint | null;
@@ -4015,9 +5262,14 @@ declare const chains: ({
4015
5262
  maxFeePerBlobGas: bigint;
4016
5263
  maxFeePerGas: bigint;
4017
5264
  maxPriorityFeePerGas: bigint;
4018
- isSystemTx?: undefined | undefined;
4019
- mint?: undefined | undefined;
4020
- sourceHash?: undefined | undefined;
5265
+ signature?: undefined;
5266
+ calls?: undefined;
5267
+ nonceKey?: undefined;
5268
+ validAfter?: undefined;
5269
+ feeToken?: undefined;
5270
+ feePayerSignature?: undefined;
5271
+ keyAuthorization?: undefined;
5272
+ validBefore?: undefined;
4021
5273
  } | {
4022
5274
  blockHash: `0x${string}` | null;
4023
5275
  blockNumber: bigint | null;
@@ -4043,15 +5295,58 @@ declare const chains: ({
4043
5295
  maxFeePerBlobGas?: undefined | undefined;
4044
5296
  maxFeePerGas: bigint;
4045
5297
  maxPriorityFeePerGas: bigint;
4046
- isSystemTx?: undefined | undefined;
4047
- mint?: undefined | undefined;
4048
- sourceHash?: undefined | undefined;
5298
+ signature?: undefined;
5299
+ calls?: undefined;
5300
+ nonceKey?: undefined;
5301
+ validAfter?: undefined;
5302
+ feeToken?: undefined;
5303
+ feePayerSignature?: undefined;
5304
+ keyAuthorization?: undefined;
5305
+ validBefore?: undefined;
5306
+ } | {
5307
+ from: import("abitype").Address;
5308
+ gas: bigint;
5309
+ nonce: number;
5310
+ blockHash: `0x${string}` | null;
5311
+ blockNumber: bigint | null;
5312
+ hash: import("viem").Hash;
5313
+ transactionIndex: number | null;
5314
+ typeHex: import("viem").Hex | null;
5315
+ r?: `0x${string}` | undefined;
5316
+ s?: `0x${string}` | undefined;
5317
+ v?: bigint | undefined;
5318
+ yParity?: number | undefined;
5319
+ accessList: import("viem").AccessList;
5320
+ authorizationList?: readonly {
5321
+ address: import("ox/_types/core/Address").Address;
5322
+ chainId: number;
5323
+ nonce: bigint;
5324
+ signature: import("ox/tempo/SignatureEnvelope").SignatureEnvelope<bigint, number>;
5325
+ }[] | undefined;
5326
+ calls: readonly import("ox/tempo/TxEnvelopeTempo").Call<bigint>[];
5327
+ chainId: number;
5328
+ feeToken?: `0x${string}` | undefined;
5329
+ feePayerSignature?: import("viem").Signature | undefined;
5330
+ keyAuthorization?: import("ox/tempo/KeyAuthorization").Signed<bigint, number> | null | undefined;
5331
+ nonceKey?: bigint | undefined;
5332
+ signature: import("ox/tempo/SignatureEnvelope").SignatureEnvelope;
5333
+ type: "tempo";
5334
+ validBefore?: number | undefined;
5335
+ validAfter?: number | undefined;
5336
+ gasPrice?: undefined | undefined;
5337
+ maxFeePerBlobGas?: undefined | undefined;
5338
+ maxFeePerGas: bigint;
5339
+ maxPriorityFeePerGas: bigint;
5340
+ to?: undefined;
5341
+ value?: undefined;
5342
+ blobVersionedHashes?: undefined;
5343
+ input?: undefined;
4049
5344
  }) & {};
4050
5345
  type: "transaction";
4051
5346
  };
4052
5347
  readonly transactionReceipt: {
4053
5348
  exclude: [] | undefined;
4054
- format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
5349
+ format: (args: import("viem/_types/tempo/Transaction").TransactionReceiptRpc, action?: string | undefined) => {
4055
5350
  blobGasPrice?: bigint | undefined;
4056
5351
  blobGasUsed?: bigint | undefined;
4057
5352
  blockHash: import("viem").Hash;
@@ -4068,26 +5363,653 @@ declare const chains: ({
4068
5363
  to: import("abitype").Address | null;
4069
5364
  transactionHash: import("viem").Hash;
4070
5365
  transactionIndex: number;
4071
- type: import("viem").TransactionType;
4072
- l1GasPrice: bigint | null;
4073
- l1GasUsed: bigint | null;
4074
- l1Fee: bigint | null;
4075
- l1FeeScalar: number | null;
5366
+ type: import("viem/_types/tempo/Transaction").TransactionType;
5367
+ feePayer?: `0x${string}` | undefined;
5368
+ feeToken?: `0x${string}` | undefined;
4076
5369
  } & {};
4077
5370
  type: "transactionReceipt";
4078
5371
  };
5372
+ readonly transactionRequest: {
5373
+ exclude: [] | undefined;
5374
+ format: (args: import("viem/_types/tempo/Transaction").TransactionRequest, action?: string | undefined) => ({
5375
+ data?: `0x${string}` | undefined;
5376
+ from?: `0x${string}` | undefined;
5377
+ gas?: `0x${string}` | undefined;
5378
+ nonce?: `0x${string}` | undefined;
5379
+ to?: `0x${string}` | null | undefined;
5380
+ type?: "0x0" | undefined;
5381
+ value?: `0x${string}` | undefined;
5382
+ gasPrice?: `0x${string}` | undefined;
5383
+ maxFeePerBlobGas?: undefined | undefined;
5384
+ maxFeePerGas?: undefined | undefined;
5385
+ maxPriorityFeePerGas?: undefined | undefined;
5386
+ blobs?: undefined;
5387
+ blobVersionedHashes?: undefined;
5388
+ kzg?: undefined;
5389
+ accessList?: undefined;
5390
+ sidecars?: undefined;
5391
+ authorizationList?: undefined;
5392
+ calls?: undefined;
5393
+ nonceKey?: undefined;
5394
+ validAfter?: undefined;
5395
+ feeToken?: undefined;
5396
+ keyAuthorization?: undefined;
5397
+ validBefore?: undefined;
5398
+ feePayer?: undefined;
5399
+ } | {
5400
+ data?: `0x${string}` | undefined;
5401
+ from?: `0x${string}` | undefined;
5402
+ gas?: `0x${string}` | undefined;
5403
+ nonce?: `0x${string}` | undefined;
5404
+ to?: `0x${string}` | null | undefined;
5405
+ type?: "0x1" | undefined;
5406
+ value?: `0x${string}` | undefined;
5407
+ gasPrice?: `0x${string}` | undefined;
5408
+ maxFeePerBlobGas?: undefined | undefined;
5409
+ maxFeePerGas?: undefined | undefined;
5410
+ maxPriorityFeePerGas?: undefined | undefined;
5411
+ accessList?: import("viem").AccessList | undefined;
5412
+ blobs?: undefined;
5413
+ blobVersionedHashes?: undefined;
5414
+ kzg?: undefined;
5415
+ sidecars?: undefined;
5416
+ authorizationList?: undefined;
5417
+ calls?: undefined;
5418
+ nonceKey?: undefined;
5419
+ validAfter?: undefined;
5420
+ feeToken?: undefined;
5421
+ keyAuthorization?: undefined;
5422
+ validBefore?: undefined;
5423
+ feePayer?: undefined;
5424
+ } | {
5425
+ data?: `0x${string}` | undefined;
5426
+ from?: `0x${string}` | undefined;
5427
+ gas?: `0x${string}` | undefined;
5428
+ nonce?: `0x${string}` | undefined;
5429
+ to?: `0x${string}` | null | undefined;
5430
+ type?: "0x2" | undefined;
5431
+ value?: `0x${string}` | undefined;
5432
+ gasPrice?: undefined | undefined;
5433
+ maxFeePerBlobGas?: undefined | undefined;
5434
+ maxFeePerGas?: `0x${string}` | undefined;
5435
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5436
+ accessList?: import("viem").AccessList | undefined;
5437
+ blobs?: undefined;
5438
+ blobVersionedHashes?: undefined;
5439
+ kzg?: undefined;
5440
+ sidecars?: undefined;
5441
+ authorizationList?: undefined;
5442
+ calls?: undefined;
5443
+ nonceKey?: undefined;
5444
+ validAfter?: undefined;
5445
+ feeToken?: undefined;
5446
+ keyAuthorization?: undefined;
5447
+ validBefore?: undefined;
5448
+ feePayer?: undefined;
5449
+ } | {
5450
+ type?: "0x3" | undefined;
5451
+ data?: `0x${string}` | undefined;
5452
+ from?: `0x${string}` | undefined;
5453
+ gas?: `0x${string}` | undefined;
5454
+ nonce?: `0x${string}` | undefined;
5455
+ value?: `0x${string}` | undefined;
5456
+ to: `0x${string}` | null;
5457
+ gasPrice?: undefined | undefined;
5458
+ maxFeePerBlobGas?: `0x${string}` | undefined;
5459
+ maxFeePerGas?: `0x${string}` | undefined;
5460
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5461
+ accessList?: import("viem").AccessList | undefined;
5462
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
5463
+ blobs?: readonly `0x${string}`[] | readonly import("viem").ByteArray[] | undefined;
5464
+ blobVersionedHashes: readonly import("viem").Hex[];
5465
+ kzg?: undefined;
5466
+ authorizationList?: undefined;
5467
+ calls?: undefined;
5468
+ nonceKey?: undefined;
5469
+ validAfter?: undefined;
5470
+ feeToken?: undefined;
5471
+ keyAuthorization?: undefined;
5472
+ validBefore?: undefined;
5473
+ feePayer?: undefined;
5474
+ } | {
5475
+ type?: "0x3" | undefined;
5476
+ data?: `0x${string}` | undefined;
5477
+ from?: `0x${string}` | undefined;
5478
+ gas?: `0x${string}` | undefined;
5479
+ nonce?: `0x${string}` | undefined;
5480
+ value?: `0x${string}` | undefined;
5481
+ to: `0x${string}` | null;
5482
+ gasPrice?: undefined | undefined;
5483
+ maxFeePerBlobGas?: `0x${string}` | undefined;
5484
+ maxFeePerGas?: `0x${string}` | undefined;
5485
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5486
+ accessList?: import("viem").AccessList | undefined;
5487
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
5488
+ blobs: readonly import("viem").Hex[] | readonly import("viem").ByteArray[];
5489
+ blobVersionedHashes?: readonly `0x${string}`[] | undefined;
5490
+ kzg?: import("viem").Kzg | undefined;
5491
+ authorizationList?: undefined;
5492
+ calls?: undefined;
5493
+ nonceKey?: undefined;
5494
+ validAfter?: undefined;
5495
+ feeToken?: undefined;
5496
+ keyAuthorization?: undefined;
5497
+ validBefore?: undefined;
5498
+ feePayer?: undefined;
5499
+ } | {
5500
+ type?: "0x4" | undefined;
5501
+ gasPrice?: undefined | undefined;
5502
+ maxFeePerBlobGas?: undefined | undefined;
5503
+ maxFeePerGas?: `0x${string}` | undefined;
5504
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5505
+ to?: `0x${string}` | null | undefined;
5506
+ data?: `0x${string}` | undefined;
5507
+ from?: `0x${string}` | undefined;
5508
+ gas?: `0x${string}` | undefined;
5509
+ nonce?: `0x${string}` | undefined;
5510
+ value?: `0x${string}` | undefined;
5511
+ accessList?: import("viem").AccessList | undefined;
5512
+ authorizationList?: import("viem").RpcAuthorizationList | undefined;
5513
+ blobs?: undefined;
5514
+ blobVersionedHashes?: undefined;
5515
+ kzg?: undefined;
5516
+ sidecars?: undefined;
5517
+ calls?: undefined;
5518
+ nonceKey?: undefined;
5519
+ validAfter?: undefined;
5520
+ feeToken?: undefined;
5521
+ keyAuthorization?: undefined;
5522
+ validBefore?: undefined;
5523
+ feePayer?: undefined;
5524
+ } | {
5525
+ data?: `0x${string}` | undefined;
5526
+ from?: `0x${string}` | undefined;
5527
+ gas?: `0x${string}` | undefined;
5528
+ nonce?: `0x${string}` | undefined;
5529
+ to?: `0x${string}` | null | undefined;
5530
+ type?: "0x76" | undefined;
5531
+ value?: `0x${string}` | undefined;
5532
+ gasPrice?: undefined | undefined;
5533
+ maxFeePerBlobGas?: undefined | undefined;
5534
+ maxFeePerGas?: `0x${string}` | undefined;
5535
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5536
+ accessList?: import("viem").AccessList | undefined;
5537
+ keyAuthorization?: import("ox/tempo/KeyAuthorization").Signed<`0x${string}`, `0x${string}`> | undefined;
5538
+ calls?: readonly import("ox/tempo/TxEnvelopeTempo").Call<`0x${string}`>[] | undefined;
5539
+ feePayer?: true | import("viem").Account | undefined;
5540
+ feeToken?: bigint | `0x${string}` | undefined;
5541
+ nonceKey?: `0x${string}` | "expiring" | undefined;
5542
+ validBefore?: `0x${string}` | undefined;
5543
+ validAfter?: `0x${string}` | undefined;
5544
+ blobs?: undefined;
5545
+ blobVersionedHashes?: undefined;
5546
+ kzg?: undefined;
5547
+ sidecars?: undefined;
5548
+ authorizationList?: undefined;
5549
+ }) & {};
5550
+ type: "transactionRequest";
5551
+ };
4079
5552
  };
4080
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4081
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4082
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
5553
+ prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { phase }: {
4083
5554
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4084
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4085
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4086
- }] | undefined;
5555
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
5556
+ readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
5557
+ }];
4087
5558
  serializers: {
4088
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
4089
- };
4090
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
5559
+ readonly transaction: import("viem").SerializeTransactionFn;
5560
+ };
5561
+ verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
5562
+ extend: <const extended_1 extends {
5563
+ feeToken?: import("ox/tempo/TokenId").TokenIdOrAddress | undefined;
5564
+ }>(extended: extended_1) => import("viem/chains").Assign<import("viem/chains").Assign<import("viem/chains").Chain<undefined>, {
5565
+ readonly id: 4217;
5566
+ readonly blockExplorers: {
5567
+ readonly default: {
5568
+ readonly name: "Tempo Explorer";
5569
+ readonly url: "https://explore.mainnet.tempo.xyz";
5570
+ };
5571
+ };
5572
+ readonly name: "Tempo Mainnet";
5573
+ readonly nativeCurrency: {
5574
+ readonly name: "USD";
5575
+ readonly symbol: "USD";
5576
+ readonly decimals: 6;
5577
+ };
5578
+ readonly rpcUrls: {
5579
+ readonly default: {
5580
+ readonly http: readonly ["https://rpc.presto.tempo.xyz"];
5581
+ readonly webSocket: readonly ["wss://rpc.presto.tempo.xyz"];
5582
+ };
5583
+ };
5584
+ readonly blockTime: 1000;
5585
+ readonly extendSchema: {
5586
+ feeToken?: import("ox/tempo/TokenId").TokenIdOrAddress | undefined;
5587
+ };
5588
+ readonly formatters: {
5589
+ readonly transaction: {
5590
+ exclude: never[] | undefined;
5591
+ format: (args: import("viem/_types/tempo/Transaction").TransactionRpc, action?: string | undefined) => ({
5592
+ r: import("viem").Hex;
5593
+ s: import("viem").Hex;
5594
+ v: bigint;
5595
+ to: import("abitype").Address | null;
5596
+ from: import("abitype").Address;
5597
+ gas: bigint;
5598
+ nonce: number;
5599
+ value: bigint;
5600
+ blockHash: `0x${string}` | null;
5601
+ blockNumber: bigint | null;
5602
+ hash: import("viem").Hash;
5603
+ input: import("viem").Hex;
5604
+ transactionIndex: number | null;
5605
+ typeHex: import("viem").Hex | null;
5606
+ accessList?: undefined | undefined;
5607
+ authorizationList?: undefined | undefined;
5608
+ blobVersionedHashes?: undefined | undefined;
5609
+ chainId?: number | undefined;
5610
+ yParity?: undefined | undefined;
5611
+ type: "legacy";
5612
+ gasPrice: bigint;
5613
+ maxFeePerBlobGas?: undefined | undefined;
5614
+ maxFeePerGas?: undefined | undefined;
5615
+ maxPriorityFeePerGas?: undefined | undefined;
5616
+ signature?: undefined;
5617
+ calls?: undefined;
5618
+ nonceKey?: undefined;
5619
+ validAfter?: undefined;
5620
+ feeToken?: undefined;
5621
+ feePayerSignature?: undefined;
5622
+ keyAuthorization?: undefined;
5623
+ validBefore?: undefined;
5624
+ } | {
5625
+ blockHash: `0x${string}` | null;
5626
+ blockNumber: bigint | null;
5627
+ from: import("abitype").Address;
5628
+ gas: bigint;
5629
+ hash: import("viem").Hash;
5630
+ input: import("viem").Hex;
5631
+ nonce: number;
5632
+ r: import("viem").Hex;
5633
+ s: import("viem").Hex;
5634
+ to: import("abitype").Address | null;
5635
+ transactionIndex: number | null;
5636
+ typeHex: import("viem").Hex | null;
5637
+ v: bigint;
5638
+ value: bigint;
5639
+ yParity: number;
5640
+ accessList: import("viem").AccessList;
5641
+ authorizationList?: undefined | undefined;
5642
+ blobVersionedHashes?: undefined | undefined;
5643
+ chainId: number;
5644
+ type: "eip2930";
5645
+ gasPrice: bigint;
5646
+ maxFeePerBlobGas?: undefined | undefined;
5647
+ maxFeePerGas?: undefined | undefined;
5648
+ maxPriorityFeePerGas?: undefined | undefined;
5649
+ signature?: undefined;
5650
+ calls?: undefined;
5651
+ nonceKey?: undefined;
5652
+ validAfter?: undefined;
5653
+ feeToken?: undefined;
5654
+ feePayerSignature?: undefined;
5655
+ keyAuthorization?: undefined;
5656
+ validBefore?: undefined;
5657
+ } | {
5658
+ blockHash: `0x${string}` | null;
5659
+ blockNumber: bigint | null;
5660
+ from: import("abitype").Address;
5661
+ gas: bigint;
5662
+ hash: import("viem").Hash;
5663
+ input: import("viem").Hex;
5664
+ nonce: number;
5665
+ r: import("viem").Hex;
5666
+ s: import("viem").Hex;
5667
+ to: import("abitype").Address | null;
5668
+ transactionIndex: number | null;
5669
+ typeHex: import("viem").Hex | null;
5670
+ v: bigint;
5671
+ value: bigint;
5672
+ yParity: number;
5673
+ accessList: import("viem").AccessList;
5674
+ authorizationList?: undefined | undefined;
5675
+ blobVersionedHashes?: undefined | undefined;
5676
+ chainId: number;
5677
+ type: "eip1559";
5678
+ gasPrice?: undefined | undefined;
5679
+ maxFeePerBlobGas?: undefined | undefined;
5680
+ maxFeePerGas: bigint;
5681
+ maxPriorityFeePerGas: bigint;
5682
+ signature?: undefined;
5683
+ calls?: undefined;
5684
+ nonceKey?: undefined;
5685
+ validAfter?: undefined;
5686
+ feeToken?: undefined;
5687
+ feePayerSignature?: undefined;
5688
+ keyAuthorization?: undefined;
5689
+ validBefore?: undefined;
5690
+ } | {
5691
+ blockHash: `0x${string}` | null;
5692
+ blockNumber: bigint | null;
5693
+ from: import("abitype").Address;
5694
+ gas: bigint;
5695
+ hash: import("viem").Hash;
5696
+ input: import("viem").Hex;
5697
+ nonce: number;
5698
+ r: import("viem").Hex;
5699
+ s: import("viem").Hex;
5700
+ to: import("abitype").Address | null;
5701
+ transactionIndex: number | null;
5702
+ typeHex: import("viem").Hex | null;
5703
+ v: bigint;
5704
+ value: bigint;
5705
+ yParity: number;
5706
+ accessList: import("viem").AccessList;
5707
+ authorizationList?: undefined | undefined;
5708
+ blobVersionedHashes: readonly import("viem").Hex[];
5709
+ chainId: number;
5710
+ type: "eip4844";
5711
+ gasPrice?: undefined | undefined;
5712
+ maxFeePerBlobGas: bigint;
5713
+ maxFeePerGas: bigint;
5714
+ maxPriorityFeePerGas: bigint;
5715
+ signature?: undefined;
5716
+ calls?: undefined;
5717
+ nonceKey?: undefined;
5718
+ validAfter?: undefined;
5719
+ feeToken?: undefined;
5720
+ feePayerSignature?: undefined;
5721
+ keyAuthorization?: undefined;
5722
+ validBefore?: undefined;
5723
+ } | {
5724
+ blockHash: `0x${string}` | null;
5725
+ blockNumber: bigint | null;
5726
+ from: import("abitype").Address;
5727
+ gas: bigint;
5728
+ hash: import("viem").Hash;
5729
+ input: import("viem").Hex;
5730
+ nonce: number;
5731
+ r: import("viem").Hex;
5732
+ s: import("viem").Hex;
5733
+ to: import("abitype").Address | null;
5734
+ transactionIndex: number | null;
5735
+ typeHex: import("viem").Hex | null;
5736
+ v: bigint;
5737
+ value: bigint;
5738
+ yParity: number;
5739
+ accessList: import("viem").AccessList;
5740
+ authorizationList: import("viem").SignedAuthorizationList;
5741
+ blobVersionedHashes?: undefined | undefined;
5742
+ chainId: number;
5743
+ type: "eip7702";
5744
+ gasPrice?: undefined | undefined;
5745
+ maxFeePerBlobGas?: undefined | undefined;
5746
+ maxFeePerGas: bigint;
5747
+ maxPriorityFeePerGas: bigint;
5748
+ signature?: undefined;
5749
+ calls?: undefined;
5750
+ nonceKey?: undefined;
5751
+ validAfter?: undefined;
5752
+ feeToken?: undefined;
5753
+ feePayerSignature?: undefined;
5754
+ keyAuthorization?: undefined;
5755
+ validBefore?: undefined;
5756
+ } | {
5757
+ from: import("abitype").Address;
5758
+ gas: bigint;
5759
+ nonce: number;
5760
+ blockHash: `0x${string}` | null;
5761
+ blockNumber: bigint | null;
5762
+ hash: import("viem").Hash;
5763
+ transactionIndex: number | null;
5764
+ typeHex: import("viem").Hex | null;
5765
+ r?: `0x${string}` | undefined;
5766
+ s?: `0x${string}` | undefined;
5767
+ v?: bigint | undefined;
5768
+ yParity?: number | undefined;
5769
+ accessList: import("viem").AccessList;
5770
+ authorizationList?: readonly {
5771
+ address: import("ox/_types/core/Address").Address;
5772
+ chainId: number;
5773
+ nonce: bigint;
5774
+ signature: import("ox/tempo/SignatureEnvelope").SignatureEnvelope<bigint, number>;
5775
+ }[] | undefined;
5776
+ calls: readonly import("ox/tempo/TxEnvelopeTempo").Call<bigint>[];
5777
+ chainId: number;
5778
+ feeToken?: `0x${string}` | undefined;
5779
+ feePayerSignature?: import("viem").Signature | undefined;
5780
+ keyAuthorization?: import("ox/tempo/KeyAuthorization").Signed<bigint, number> | null | undefined;
5781
+ nonceKey?: bigint | undefined;
5782
+ signature: import("ox/tempo/SignatureEnvelope").SignatureEnvelope;
5783
+ type: "tempo";
5784
+ validBefore?: number | undefined;
5785
+ validAfter?: number | undefined;
5786
+ gasPrice?: undefined | undefined;
5787
+ maxFeePerBlobGas?: undefined | undefined;
5788
+ maxFeePerGas: bigint;
5789
+ maxPriorityFeePerGas: bigint;
5790
+ to?: undefined;
5791
+ value?: undefined;
5792
+ blobVersionedHashes?: undefined;
5793
+ input?: undefined;
5794
+ }) & {};
5795
+ type: "transaction";
5796
+ };
5797
+ readonly transactionReceipt: {
5798
+ exclude: [] | undefined;
5799
+ format: (args: import("viem/_types/tempo/Transaction").TransactionReceiptRpc, action?: string | undefined) => {
5800
+ blobGasPrice?: bigint | undefined;
5801
+ blobGasUsed?: bigint | undefined;
5802
+ blockHash: import("viem").Hash;
5803
+ blockNumber: bigint;
5804
+ contractAddress: import("abitype").Address | null | undefined;
5805
+ cumulativeGasUsed: bigint;
5806
+ effectiveGasPrice: bigint;
5807
+ from: import("abitype").Address;
5808
+ gasUsed: bigint;
5809
+ logs: import("viem").Log<bigint, number, false>[];
5810
+ logsBloom: import("viem").Hex;
5811
+ root?: `0x${string}` | undefined;
5812
+ status: "success" | "reverted";
5813
+ to: import("abitype").Address | null;
5814
+ transactionHash: import("viem").Hash;
5815
+ transactionIndex: number;
5816
+ type: import("viem/_types/tempo/Transaction").TransactionType;
5817
+ feePayer?: `0x${string}` | undefined;
5818
+ feeToken?: `0x${string}` | undefined;
5819
+ } & {};
5820
+ type: "transactionReceipt";
5821
+ };
5822
+ readonly transactionRequest: {
5823
+ exclude: [] | undefined;
5824
+ format: (args: import("viem/_types/tempo/Transaction").TransactionRequest, action?: string | undefined) => ({
5825
+ data?: `0x${string}` | undefined;
5826
+ from?: `0x${string}` | undefined;
5827
+ gas?: `0x${string}` | undefined;
5828
+ nonce?: `0x${string}` | undefined;
5829
+ to?: `0x${string}` | null | undefined;
5830
+ type?: "0x0" | undefined;
5831
+ value?: `0x${string}` | undefined;
5832
+ gasPrice?: `0x${string}` | undefined;
5833
+ maxFeePerBlobGas?: undefined | undefined;
5834
+ maxFeePerGas?: undefined | undefined;
5835
+ maxPriorityFeePerGas?: undefined | undefined;
5836
+ blobs?: undefined;
5837
+ blobVersionedHashes?: undefined;
5838
+ kzg?: undefined;
5839
+ accessList?: undefined;
5840
+ sidecars?: undefined;
5841
+ authorizationList?: undefined;
5842
+ calls?: undefined;
5843
+ nonceKey?: undefined;
5844
+ validAfter?: undefined;
5845
+ feeToken?: undefined;
5846
+ keyAuthorization?: undefined;
5847
+ validBefore?: undefined;
5848
+ feePayer?: undefined;
5849
+ } | {
5850
+ data?: `0x${string}` | undefined;
5851
+ from?: `0x${string}` | undefined;
5852
+ gas?: `0x${string}` | undefined;
5853
+ nonce?: `0x${string}` | undefined;
5854
+ to?: `0x${string}` | null | undefined;
5855
+ type?: "0x1" | undefined;
5856
+ value?: `0x${string}` | undefined;
5857
+ gasPrice?: `0x${string}` | undefined;
5858
+ maxFeePerBlobGas?: undefined | undefined;
5859
+ maxFeePerGas?: undefined | undefined;
5860
+ maxPriorityFeePerGas?: undefined | undefined;
5861
+ accessList?: import("viem").AccessList | undefined;
5862
+ blobs?: undefined;
5863
+ blobVersionedHashes?: undefined;
5864
+ kzg?: undefined;
5865
+ sidecars?: undefined;
5866
+ authorizationList?: undefined;
5867
+ calls?: undefined;
5868
+ nonceKey?: undefined;
5869
+ validAfter?: undefined;
5870
+ feeToken?: undefined;
5871
+ keyAuthorization?: undefined;
5872
+ validBefore?: undefined;
5873
+ feePayer?: undefined;
5874
+ } | {
5875
+ data?: `0x${string}` | undefined;
5876
+ from?: `0x${string}` | undefined;
5877
+ gas?: `0x${string}` | undefined;
5878
+ nonce?: `0x${string}` | undefined;
5879
+ to?: `0x${string}` | null | undefined;
5880
+ type?: "0x2" | undefined;
5881
+ value?: `0x${string}` | undefined;
5882
+ gasPrice?: undefined | undefined;
5883
+ maxFeePerBlobGas?: undefined | undefined;
5884
+ maxFeePerGas?: `0x${string}` | undefined;
5885
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5886
+ accessList?: import("viem").AccessList | undefined;
5887
+ blobs?: undefined;
5888
+ blobVersionedHashes?: undefined;
5889
+ kzg?: undefined;
5890
+ sidecars?: undefined;
5891
+ authorizationList?: undefined;
5892
+ calls?: undefined;
5893
+ nonceKey?: undefined;
5894
+ validAfter?: undefined;
5895
+ feeToken?: undefined;
5896
+ keyAuthorization?: undefined;
5897
+ validBefore?: undefined;
5898
+ feePayer?: undefined;
5899
+ } | {
5900
+ type?: "0x3" | undefined;
5901
+ data?: `0x${string}` | undefined;
5902
+ from?: `0x${string}` | undefined;
5903
+ gas?: `0x${string}` | undefined;
5904
+ nonce?: `0x${string}` | undefined;
5905
+ value?: `0x${string}` | undefined;
5906
+ to: `0x${string}` | null;
5907
+ gasPrice?: undefined | undefined;
5908
+ maxFeePerBlobGas?: `0x${string}` | undefined;
5909
+ maxFeePerGas?: `0x${string}` | undefined;
5910
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5911
+ accessList?: import("viem").AccessList | undefined;
5912
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
5913
+ blobs?: readonly `0x${string}`[] | readonly import("viem").ByteArray[] | undefined;
5914
+ blobVersionedHashes: readonly import("viem").Hex[];
5915
+ kzg?: undefined;
5916
+ authorizationList?: undefined;
5917
+ calls?: undefined;
5918
+ nonceKey?: undefined;
5919
+ validAfter?: undefined;
5920
+ feeToken?: undefined;
5921
+ keyAuthorization?: undefined;
5922
+ validBefore?: undefined;
5923
+ feePayer?: undefined;
5924
+ } | {
5925
+ type?: "0x3" | undefined;
5926
+ data?: `0x${string}` | undefined;
5927
+ from?: `0x${string}` | undefined;
5928
+ gas?: `0x${string}` | undefined;
5929
+ nonce?: `0x${string}` | undefined;
5930
+ value?: `0x${string}` | undefined;
5931
+ to: `0x${string}` | null;
5932
+ gasPrice?: undefined | undefined;
5933
+ maxFeePerBlobGas?: `0x${string}` | undefined;
5934
+ maxFeePerGas?: `0x${string}` | undefined;
5935
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5936
+ accessList?: import("viem").AccessList | undefined;
5937
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
5938
+ blobs: readonly import("viem").Hex[] | readonly import("viem").ByteArray[];
5939
+ blobVersionedHashes?: readonly `0x${string}`[] | undefined;
5940
+ kzg?: import("viem").Kzg | undefined;
5941
+ authorizationList?: undefined;
5942
+ calls?: undefined;
5943
+ nonceKey?: undefined;
5944
+ validAfter?: undefined;
5945
+ feeToken?: undefined;
5946
+ keyAuthorization?: undefined;
5947
+ validBefore?: undefined;
5948
+ feePayer?: undefined;
5949
+ } | {
5950
+ type?: "0x4" | undefined;
5951
+ gasPrice?: undefined | undefined;
5952
+ maxFeePerBlobGas?: undefined | undefined;
5953
+ maxFeePerGas?: `0x${string}` | undefined;
5954
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5955
+ to?: `0x${string}` | null | undefined;
5956
+ data?: `0x${string}` | undefined;
5957
+ from?: `0x${string}` | undefined;
5958
+ gas?: `0x${string}` | undefined;
5959
+ nonce?: `0x${string}` | undefined;
5960
+ value?: `0x${string}` | undefined;
5961
+ accessList?: import("viem").AccessList | undefined;
5962
+ authorizationList?: import("viem").RpcAuthorizationList | undefined;
5963
+ blobs?: undefined;
5964
+ blobVersionedHashes?: undefined;
5965
+ kzg?: undefined;
5966
+ sidecars?: undefined;
5967
+ calls?: undefined;
5968
+ nonceKey?: undefined;
5969
+ validAfter?: undefined;
5970
+ feeToken?: undefined;
5971
+ keyAuthorization?: undefined;
5972
+ validBefore?: undefined;
5973
+ feePayer?: undefined;
5974
+ } | {
5975
+ data?: `0x${string}` | undefined;
5976
+ from?: `0x${string}` | undefined;
5977
+ gas?: `0x${string}` | undefined;
5978
+ nonce?: `0x${string}` | undefined;
5979
+ to?: `0x${string}` | null | undefined;
5980
+ type?: "0x76" | undefined;
5981
+ value?: `0x${string}` | undefined;
5982
+ gasPrice?: undefined | undefined;
5983
+ maxFeePerBlobGas?: undefined | undefined;
5984
+ maxFeePerGas?: `0x${string}` | undefined;
5985
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5986
+ accessList?: import("viem").AccessList | undefined;
5987
+ keyAuthorization?: import("ox/tempo/KeyAuthorization").Signed<`0x${string}`, `0x${string}`> | undefined;
5988
+ calls?: readonly import("ox/tempo/TxEnvelopeTempo").Call<`0x${string}`>[] | undefined;
5989
+ feePayer?: true | import("viem").Account | undefined;
5990
+ feeToken?: bigint | `0x${string}` | undefined;
5991
+ nonceKey?: `0x${string}` | "expiring" | undefined;
5992
+ validBefore?: `0x${string}` | undefined;
5993
+ validAfter?: `0x${string}` | undefined;
5994
+ blobs?: undefined;
5995
+ blobVersionedHashes?: undefined;
5996
+ kzg?: undefined;
5997
+ sidecars?: undefined;
5998
+ authorizationList?: undefined;
5999
+ }) & {};
6000
+ type: "transactionRequest";
6001
+ };
6002
+ };
6003
+ readonly prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { phase }: {
6004
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
6005
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
6006
+ readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
6007
+ }];
6008
+ readonly serializers: {
6009
+ readonly transaction: import("viem").SerializeTransactionFn;
6010
+ };
6011
+ readonly verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
6012
+ }>, extended_1>;
4091
6013
  } | {
4092
6014
  blockExplorers: {
4093
6015
  readonly default: {
@@ -4870,7 +6792,9 @@ declare enum MainnetNetwork {
4870
6792
  MONAD,
4871
6793
  UNICHAIN,
4872
6794
  SOLANA = 792703809,
4873
- TRON = 728126428
6795
+ TRON = 728126428,
6796
+ KATANA,
6797
+ TEMPO
4874
6798
  }
4875
6799
  declare enum TestnetNetwork {
4876
6800
  ETHEREUM_SEPOLIA,