@rhinestone/shared-configs 1.6.5 → 1.6.6

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 (13) hide show
  1. package/dist/configs/chains.json +69 -3
  2. package/dist/configs/mainnets.json +6 -0
  3. package/dist/configs/providers.json +3 -0
  4. package/dist/src/chains.d.ts.map +1 -1
  5. package/dist/src/chains.js +73 -3
  6. package/dist/src/generated/contracts.d.ts.map +1 -1
  7. package/dist/src/generated/contracts.dev.d.ts.map +1 -1
  8. package/dist/src/generated/contracts.dev.js +8 -0
  9. package/dist/src/generated/contracts.js +8 -0
  10. package/dist/src/generated/networks.d.ts +1607 -722
  11. package/dist/src/generated/networks.d.ts.map +1 -1
  12. package/dist/src/generated/networks.js +2 -1
  13. package/package.json +1 -1
package/dist/src/generated/networks.d.ts CHANGED
@@ -1706,6 +1706,448 @@ declare const mainnetChains: ({
1706
1706
  serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1707
1707
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1708
1708
  readonly network: "katana";
1709
+ } | {
1710
+ blockExplorers: {
1711
+ readonly default: {
1712
+ readonly name: "Etherscan";
1713
+ readonly url: "https://abscan.org";
1714
+ };
1715
+ readonly native: {
1716
+ readonly name: "Abstract Explorer";
1717
+ readonly url: "https://explorer.mainnet.abs.xyz";
1718
+ };
1719
+ };
1720
+ blockTime: 200;
1721
+ contracts: {
1722
+ readonly multicall3: {
1723
+ readonly address: "0xAa4De41dba0Ca5dCBb288b7cC6b708F3aaC759E7";
1724
+ readonly blockCreated: 5288;
1725
+ };
1726
+ readonly erc6492Verifier: {
1727
+ readonly address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C";
1728
+ readonly blockCreated: 5263;
1729
+ };
1730
+ };
1731
+ ensTlds?: readonly string[] | undefined;
1732
+ id: 2741;
1733
+ name: "Abstract";
1734
+ nativeCurrency: {
1735
+ readonly decimals: 18;
1736
+ readonly name: "ETH";
1737
+ readonly symbol: "ETH";
1738
+ };
1739
+ experimental_preconfirmationTime?: number | undefined | undefined;
1740
+ rpcUrls: {
1741
+ readonly default: {
1742
+ readonly http: readonly ["https://api.mainnet.abs.xyz"];
1743
+ readonly webSocket: readonly ["wss://api.mainnet.abs.xyz/ws"];
1744
+ };
1745
+ };
1746
+ sourceId?: number | undefined | undefined;
1747
+ testnet?: boolean | undefined | undefined;
1748
+ custom: {
1749
+ readonly getEip712Domain: import("viem/zksync").EIP712DomainFn<import("viem/chains").ZkSyncTransactionSerializable, import("viem/chains").ZkSyncEIP712TransactionSignable>;
1750
+ };
1751
+ extendSchema?: Record<string, unknown> | undefined;
1752
+ fees?: import("viem").ChainFees<undefined> | undefined;
1753
+ formatters: {
1754
+ readonly block: {
1755
+ exclude: [] | undefined;
1756
+ format: (args: import("viem/chains").ZkSyncRpcBlock, action?: string | undefined) => {
1757
+ baseFeePerGas: bigint | null;
1758
+ blobGasUsed: bigint;
1759
+ difficulty: bigint;
1760
+ excessBlobGas: bigint;
1761
+ extraData: import("viem").Hex;
1762
+ gasLimit: bigint;
1763
+ gasUsed: bigint;
1764
+ hash: `0x${string}` | null;
1765
+ logsBloom: `0x${string}` | null;
1766
+ miner: import("abitype").Address;
1767
+ mixHash: import("viem").Hash;
1768
+ nonce: `0x${string}` | null;
1769
+ number: bigint | null;
1770
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
1771
+ parentHash: import("viem").Hash;
1772
+ receiptsRoot: import("viem").Hex;
1773
+ sealFields: import("viem").Hex[];
1774
+ sha3Uncles: import("viem").Hash;
1775
+ size: bigint;
1776
+ stateRoot: import("viem").Hash;
1777
+ timestamp: bigint;
1778
+ totalDifficulty: bigint | null;
1779
+ transactions: `0x${string}`[] | import("viem/chains").ZkSyncTransaction<boolean>[];
1780
+ transactionsRoot: import("viem").Hash;
1781
+ uncles: import("viem").Hash[];
1782
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
1783
+ withdrawalsRoot?: `0x${string}` | undefined;
1784
+ l1BatchNumber: bigint | null;
1785
+ l1BatchTimestamp: bigint | null;
1786
+ } & {};
1787
+ type: "block";
1788
+ };
1789
+ readonly transaction: {
1790
+ exclude: [] | undefined;
1791
+ format: (args: import("viem/chains").ZkSyncRpcTransaction, action?: string | undefined) => ({
1792
+ r: import("viem").Hex;
1793
+ s: import("viem").Hex;
1794
+ v: bigint;
1795
+ to: import("abitype").Address | null;
1796
+ from: import("abitype").Address;
1797
+ gas: bigint;
1798
+ nonce: number;
1799
+ value: bigint;
1800
+ blockHash: `0x${string}` | null;
1801
+ blockNumber: bigint | null;
1802
+ hash: import("viem").Hash;
1803
+ input: import("viem").Hex;
1804
+ transactionIndex: number | null;
1805
+ typeHex: import("viem").Hex | null;
1806
+ accessList?: undefined | undefined;
1807
+ authorizationList?: undefined | undefined;
1808
+ blobVersionedHashes?: undefined | undefined;
1809
+ chainId?: number | undefined;
1810
+ yParity?: undefined | undefined;
1811
+ type: "legacy";
1812
+ gasPrice: bigint;
1813
+ maxFeePerBlobGas?: undefined | undefined;
1814
+ maxFeePerGas?: undefined | undefined;
1815
+ maxPriorityFeePerGas?: undefined | undefined;
1816
+ l1BatchNumber: bigint | null;
1817
+ l1BatchTxIndex: bigint | null;
1818
+ } | {
1819
+ blockHash: `0x${string}` | null;
1820
+ blockNumber: bigint | null;
1821
+ from: import("abitype").Address;
1822
+ gas: bigint;
1823
+ hash: import("viem").Hash;
1824
+ input: import("viem").Hex;
1825
+ nonce: number;
1826
+ r: import("viem").Hex;
1827
+ s: import("viem").Hex;
1828
+ to: import("abitype").Address | null;
1829
+ transactionIndex: number | null;
1830
+ typeHex: import("viem").Hex | null;
1831
+ v: bigint;
1832
+ value: bigint;
1833
+ yParity: number;
1834
+ accessList: import("viem").AccessList;
1835
+ authorizationList?: undefined | undefined;
1836
+ blobVersionedHashes?: undefined | undefined;
1837
+ chainId: number;
1838
+ type: "eip2930";
1839
+ gasPrice: bigint;
1840
+ maxFeePerBlobGas?: undefined | undefined;
1841
+ maxFeePerGas?: undefined | undefined;
1842
+ maxPriorityFeePerGas?: undefined | undefined;
1843
+ l1BatchNumber: bigint | null;
1844
+ l1BatchTxIndex: bigint | null;
1845
+ } | {
1846
+ blockHash: `0x${string}` | null;
1847
+ blockNumber: bigint | null;
1848
+ from: import("abitype").Address;
1849
+ gas: bigint;
1850
+ hash: import("viem").Hash;
1851
+ input: import("viem").Hex;
1852
+ nonce: number;
1853
+ r: import("viem").Hex;
1854
+ s: import("viem").Hex;
1855
+ to: import("abitype").Address | null;
1856
+ transactionIndex: number | null;
1857
+ typeHex: import("viem").Hex | null;
1858
+ v: bigint;
1859
+ value: bigint;
1860
+ yParity: number;
1861
+ accessList: import("viem").AccessList;
1862
+ authorizationList?: undefined | undefined;
1863
+ blobVersionedHashes?: undefined | undefined;
1864
+ chainId: number;
1865
+ type: "eip1559";
1866
+ gasPrice?: undefined | undefined;
1867
+ maxFeePerBlobGas?: undefined | undefined;
1868
+ maxFeePerGas: bigint;
1869
+ maxPriorityFeePerGas: bigint;
1870
+ l1BatchNumber: bigint | null;
1871
+ l1BatchTxIndex: bigint | null;
1872
+ } | {
1873
+ blockHash: `0x${string}` | null;
1874
+ blockNumber: bigint | null;
1875
+ from: import("abitype").Address;
1876
+ gas: bigint;
1877
+ hash: import("viem").Hash;
1878
+ input: import("viem").Hex;
1879
+ nonce: number;
1880
+ r: import("viem").Hex;
1881
+ s: import("viem").Hex;
1882
+ to: import("abitype").Address | null;
1883
+ transactionIndex: number | null;
1884
+ typeHex: import("viem").Hex | null;
1885
+ v: bigint;
1886
+ value: bigint;
1887
+ yParity: number;
1888
+ accessList: import("viem").AccessList;
1889
+ authorizationList?: undefined | undefined;
1890
+ blobVersionedHashes: readonly import("viem").Hex[];
1891
+ chainId: number;
1892
+ type: "eip4844";
1893
+ gasPrice?: undefined | undefined;
1894
+ maxFeePerBlobGas: bigint;
1895
+ maxFeePerGas: bigint;
1896
+ maxPriorityFeePerGas: bigint;
1897
+ l1BatchNumber: bigint | null;
1898
+ l1BatchTxIndex: bigint | null;
1899
+ } | {
1900
+ blockHash: `0x${string}` | null;
1901
+ blockNumber: bigint | null;
1902
+ from: import("abitype").Address;
1903
+ gas: bigint;
1904
+ hash: import("viem").Hash;
1905
+ input: import("viem").Hex;
1906
+ nonce: number;
1907
+ r: import("viem").Hex;
1908
+ s: import("viem").Hex;
1909
+ to: import("abitype").Address | null;
1910
+ transactionIndex: number | null;
1911
+ typeHex: import("viem").Hex | null;
1912
+ v: bigint;
1913
+ value: bigint;
1914
+ yParity: number;
1915
+ accessList: import("viem").AccessList;
1916
+ authorizationList: import("viem").SignedAuthorizationList;
1917
+ blobVersionedHashes?: undefined | undefined;
1918
+ chainId: number;
1919
+ type: "eip7702";
1920
+ gasPrice?: undefined | undefined;
1921
+ maxFeePerBlobGas?: undefined | undefined;
1922
+ maxFeePerGas: bigint;
1923
+ maxPriorityFeePerGas: bigint;
1924
+ l1BatchNumber: bigint | null;
1925
+ l1BatchTxIndex: bigint | null;
1926
+ } | {
1927
+ blockHash: `0x${string}` | null;
1928
+ blockNumber: bigint | null;
1929
+ from: import("abitype").Address;
1930
+ gas: bigint;
1931
+ hash: import("viem").Hash;
1932
+ input: import("viem").Hex;
1933
+ nonce: number;
1934
+ r: import("viem").Hex;
1935
+ s: import("viem").Hex;
1936
+ to: import("abitype").Address | null;
1937
+ transactionIndex: number | null;
1938
+ typeHex: import("viem").Hex | null;
1939
+ v: bigint;
1940
+ value: bigint;
1941
+ yParity: number;
1942
+ l1BatchNumber: bigint | null;
1943
+ l1BatchTxIndex: bigint | null;
1944
+ gasPrice?: undefined | undefined;
1945
+ maxFeePerBlobGas?: undefined | undefined;
1946
+ maxFeePerGas: bigint;
1947
+ maxPriorityFeePerGas: bigint;
1948
+ type: "priority";
1949
+ } | {
1950
+ blockHash: `0x${string}` | null;
1951
+ blockNumber: bigint | null;
1952
+ from: import("abitype").Address;
1953
+ gas: bigint;
1954
+ hash: import("viem").Hash;
1955
+ input: import("viem").Hex;
1956
+ nonce: number;
1957
+ r: import("viem").Hex;
1958
+ s: import("viem").Hex;
1959
+ to: import("abitype").Address | null;
1960
+ transactionIndex: number | null;
1961
+ typeHex: import("viem").Hex | null;
1962
+ v: bigint;
1963
+ value: bigint;
1964
+ yParity: number;
1965
+ l1BatchNumber: bigint | null;
1966
+ l1BatchTxIndex: bigint | null;
1967
+ gasPrice?: undefined | undefined;
1968
+ maxFeePerBlobGas?: undefined | undefined;
1969
+ maxFeePerGas: bigint;
1970
+ maxPriorityFeePerGas: bigint;
1971
+ type: "eip712" | "priority";
1972
+ }) & {};
1973
+ type: "transaction";
1974
+ };
1975
+ readonly transactionReceipt: {
1976
+ exclude: [] | undefined;
1977
+ format: (args: import("viem/chains").ZkSyncRpcTransactionReceipt, action?: string | undefined) => {
1978
+ type: import("viem/chains").ZkSyncTransactionType;
1979
+ contractAddress: import("abitype").Address | null | undefined;
1980
+ to: import("abitype").Address | null;
1981
+ from: import("abitype").Address;
1982
+ blockHash: import("viem").Hash;
1983
+ blockNumber: bigint;
1984
+ transactionIndex: number;
1985
+ status: "success" | "reverted";
1986
+ transactionHash: import("viem").Hash;
1987
+ logsBloom: import("viem").Hex;
1988
+ blobGasUsed?: bigint | undefined;
1989
+ gasUsed: bigint;
1990
+ blobGasPrice?: bigint | undefined;
1991
+ cumulativeGasUsed: bigint;
1992
+ effectiveGasPrice: bigint;
1993
+ root?: `0x${string}` | undefined;
1994
+ l1BatchNumber: bigint | null;
1995
+ l1BatchTxIndex: bigint | null;
1996
+ logs: import("viem/chains").ZkSyncLog[];
1997
+ l2ToL1Logs: import("viem/chains").ZkSyncL2ToL1Log[];
1998
+ } & {};
1999
+ type: "transactionReceipt";
2000
+ };
2001
+ readonly transactionRequest: {
2002
+ exclude: ("paymaster" | "gasPerPubdata" | "factoryDeps" | "paymasterInput" | "customSignature")[] | undefined;
2003
+ format: (args: import("viem/chains").ZkSyncTransactionRequest, action?: string | undefined) => ({
2004
+ data?: `0x${string}` | undefined;
2005
+ from?: `0x${string}` | undefined;
2006
+ gas?: `0x${string}` | undefined;
2007
+ nonce?: `0x${string}` | undefined;
2008
+ to?: `0x${string}` | null | undefined;
2009
+ type?: "0x0" | undefined;
2010
+ value?: `0x${string}` | undefined;
2011
+ gasPrice?: `0x${string}` | undefined;
2012
+ maxFeePerBlobGas?: undefined | undefined;
2013
+ maxFeePerGas?: undefined | undefined;
2014
+ maxPriorityFeePerGas?: undefined | undefined;
2015
+ blobs?: undefined;
2016
+ blobVersionedHashes?: undefined;
2017
+ kzg?: undefined;
2018
+ accessList?: undefined;
2019
+ sidecars?: undefined;
2020
+ authorizationList?: undefined;
2021
+ eip712Meta?: undefined | undefined;
2022
+ } | {
2023
+ data?: `0x${string}` | undefined;
2024
+ from?: `0x${string}` | undefined;
2025
+ gas?: `0x${string}` | undefined;
2026
+ nonce?: `0x${string}` | undefined;
2027
+ to?: `0x${string}` | null | undefined;
2028
+ type?: "0x1" | undefined;
2029
+ value?: `0x${string}` | undefined;
2030
+ gasPrice?: `0x${string}` | undefined;
2031
+ maxFeePerBlobGas?: undefined | undefined;
2032
+ maxFeePerGas?: undefined | undefined;
2033
+ maxPriorityFeePerGas?: undefined | undefined;
2034
+ accessList?: import("viem").AccessList | undefined;
2035
+ blobs?: undefined;
2036
+ blobVersionedHashes?: undefined;
2037
+ kzg?: undefined;
2038
+ sidecars?: undefined;
2039
+ authorizationList?: undefined;
2040
+ eip712Meta?: undefined | undefined;
2041
+ } | {
2042
+ data?: `0x${string}` | undefined;
2043
+ from?: `0x${string}` | undefined;
2044
+ gas?: `0x${string}` | undefined;
2045
+ nonce?: `0x${string}` | undefined;
2046
+ to?: `0x${string}` | null | undefined;
2047
+ type?: "0x2" | undefined;
2048
+ value?: `0x${string}` | undefined;
2049
+ gasPrice?: undefined | undefined;
2050
+ maxFeePerBlobGas?: undefined | undefined;
2051
+ maxFeePerGas?: `0x${string}` | undefined;
2052
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2053
+ accessList?: import("viem").AccessList | undefined;
2054
+ blobs?: undefined;
2055
+ blobVersionedHashes?: undefined;
2056
+ kzg?: undefined;
2057
+ sidecars?: undefined;
2058
+ authorizationList?: undefined;
2059
+ eip712Meta?: undefined | undefined;
2060
+ } | {
2061
+ type?: "0x3" | undefined;
2062
+ data?: `0x${string}` | undefined;
2063
+ from?: `0x${string}` | undefined;
2064
+ gas?: `0x${string}` | undefined;
2065
+ nonce?: `0x${string}` | undefined;
2066
+ value?: `0x${string}` | undefined;
2067
+ to: `0x${string}` | null;
2068
+ gasPrice?: undefined | undefined;
2069
+ maxFeePerBlobGas?: `0x${string}` | undefined;
2070
+ maxFeePerGas?: `0x${string}` | undefined;
2071
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2072
+ accessList?: import("viem").AccessList | undefined;
2073
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
2074
+ blobs?: readonly `0x${string}`[] | readonly import("viem").ByteArray[] | undefined;
2075
+ blobVersionedHashes: readonly import("viem").Hex[];
2076
+ kzg?: undefined;
2077
+ authorizationList?: undefined;
2078
+ eip712Meta?: undefined | undefined;
2079
+ } | {
2080
+ type?: "0x3" | undefined;
2081
+ data?: `0x${string}` | undefined;
2082
+ from?: `0x${string}` | undefined;
2083
+ gas?: `0x${string}` | undefined;
2084
+ nonce?: `0x${string}` | undefined;
2085
+ value?: `0x${string}` | undefined;
2086
+ to: `0x${string}` | null;
2087
+ gasPrice?: undefined | undefined;
2088
+ maxFeePerBlobGas?: `0x${string}` | undefined;
2089
+ maxFeePerGas?: `0x${string}` | undefined;
2090
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2091
+ accessList?: import("viem").AccessList | undefined;
2092
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
2093
+ blobs: readonly import("viem").Hex[] | readonly import("viem").ByteArray[];
2094
+ blobVersionedHashes?: readonly `0x${string}`[] | undefined;
2095
+ kzg?: import("viem").Kzg | undefined;
2096
+ authorizationList?: undefined;
2097
+ eip712Meta?: undefined | undefined;
2098
+ } | {
2099
+ type?: "0x4" | undefined;
2100
+ gasPrice?: undefined | undefined;
2101
+ maxFeePerBlobGas?: undefined | undefined;
2102
+ maxFeePerGas?: `0x${string}` | undefined;
2103
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2104
+ to?: `0x${string}` | null | undefined;
2105
+ data?: `0x${string}` | undefined;
2106
+ from?: `0x${string}` | undefined;
2107
+ gas?: `0x${string}` | undefined;
2108
+ nonce?: `0x${string}` | undefined;
2109
+ value?: `0x${string}` | undefined;
2110
+ accessList?: import("viem").AccessList | undefined;
2111
+ authorizationList?: import("viem").RpcAuthorizationList | undefined;
2112
+ blobs?: undefined;
2113
+ blobVersionedHashes?: undefined;
2114
+ kzg?: undefined;
2115
+ sidecars?: undefined;
2116
+ eip712Meta?: undefined | undefined;
2117
+ } | {
2118
+ data?: `0x${string}` | undefined;
2119
+ from?: `0x${string}` | undefined;
2120
+ gas?: `0x${string}` | undefined;
2121
+ nonce?: `0x${string}` | undefined;
2122
+ to?: `0x${string}` | null | undefined;
2123
+ type: "0xff" | "0x71";
2124
+ value?: `0x${string}` | undefined;
2125
+ gasPrice?: undefined | undefined;
2126
+ maxFeePerBlobGas?: undefined | undefined;
2127
+ maxFeePerGas?: `0x${string}` | undefined;
2128
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
2129
+ eip712Meta: import("viem/chains").ZkSyncEip712Meta;
2130
+ }) & {
2131
+ paymaster: never;
2132
+ gasPerPubdata: never;
2133
+ factoryDeps: never;
2134
+ paymasterInput: never;
2135
+ customSignature: never;
2136
+ };
2137
+ type: "transactionRequest";
2138
+ };
2139
+ };
2140
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2141
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2142
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2143
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2144
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2145
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2146
+ }] | undefined;
2147
+ serializers: {
2148
+ readonly transaction: typeof import("viem/zksync").serializeTransaction;
2149
+ };
2150
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1709
2151
  })[];
1710
2152
  declare const testnetChains: ({
1711
2153
  blockExplorers: {
@@ -1725,27 +2167,339 @@ declare const testnetChains: ({
1725
2167
  readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
1726
2168
  readonly blockCreated: 8928790;
1727
2169
  };
1728
- };
1729
- ensTlds?: readonly string[] | undefined;
1730
- id: 11155111;
1731
- name: "Sepolia";
1732
- nativeCurrency: {
1733
- readonly name: "Sepolia Ether";
1734
- readonly symbol: "ETH";
1735
- readonly decimals: 18;
1736
- };
1737
- experimental_preconfirmationTime?: number | undefined | undefined;
1738
- rpcUrls: {
1739
- readonly default: {
1740
- readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
2170
+ };
2171
+ ensTlds?: readonly string[] | undefined;
2172
+ id: 11155111;
2173
+ name: "Sepolia";
2174
+ nativeCurrency: {
2175
+ readonly name: "Sepolia Ether";
2176
+ readonly symbol: "ETH";
2177
+ readonly decimals: 18;
2178
+ };
2179
+ experimental_preconfirmationTime?: number | undefined | undefined;
2180
+ rpcUrls: {
2181
+ readonly default: {
2182
+ readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
2183
+ };
2184
+ };
2185
+ sourceId?: number | undefined | undefined;
2186
+ testnet: true;
2187
+ custom?: Record<string, unknown> | undefined;
2188
+ extendSchema?: Record<string, unknown> | undefined;
2189
+ fees?: import("viem").ChainFees<undefined> | undefined;
2190
+ formatters?: undefined;
2191
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2192
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2193
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2194
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2195
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2196
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2197
+ }] | undefined;
2198
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2199
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2200
+ } | {
2201
+ blockExplorers: {
2202
+ readonly default: {
2203
+ readonly name: "Blockscout";
2204
+ readonly url: "https://optimism-sepolia.blockscout.com";
2205
+ readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
2206
+ };
2207
+ };
2208
+ blockTime: 2000;
2209
+ contracts: {
2210
+ readonly disputeGameFactory: {
2211
+ readonly 11155111: {
2212
+ readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
2213
+ };
2214
+ };
2215
+ readonly l2OutputOracle: {
2216
+ readonly 11155111: {
2217
+ readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
2218
+ };
2219
+ };
2220
+ readonly multicall3: {
2221
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2222
+ readonly blockCreated: 1620204;
2223
+ };
2224
+ readonly portal: {
2225
+ readonly 11155111: {
2226
+ readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
2227
+ };
2228
+ };
2229
+ readonly l1StandardBridge: {
2230
+ readonly 11155111: {
2231
+ readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
2232
+ };
2233
+ };
2234
+ readonly gasPriceOracle: {
2235
+ readonly address: "0x420000000000000000000000000000000000000F";
2236
+ };
2237
+ readonly l1Block: {
2238
+ readonly address: "0x4200000000000000000000000000000000000015";
2239
+ };
2240
+ readonly l2CrossDomainMessenger: {
2241
+ readonly address: "0x4200000000000000000000000000000000000007";
2242
+ };
2243
+ readonly l2Erc721Bridge: {
2244
+ readonly address: "0x4200000000000000000000000000000000000014";
2245
+ };
2246
+ readonly l2StandardBridge: {
2247
+ readonly address: "0x4200000000000000000000000000000000000010";
2248
+ };
2249
+ readonly l2ToL1MessagePasser: {
2250
+ readonly address: "0x4200000000000000000000000000000000000016";
2251
+ };
2252
+ };
2253
+ ensTlds?: readonly string[] | undefined;
2254
+ id: 11155420;
2255
+ name: "OP Sepolia";
2256
+ nativeCurrency: {
2257
+ readonly name: "Sepolia Ether";
2258
+ readonly symbol: "ETH";
2259
+ readonly decimals: 18;
2260
+ };
2261
+ experimental_preconfirmationTime?: number | undefined | undefined;
2262
+ rpcUrls: {
2263
+ readonly default: {
2264
+ readonly http: readonly ["https://sepolia.optimism.io"];
2265
+ };
2266
+ };
2267
+ sourceId: 11155111;
2268
+ testnet: true;
2269
+ custom?: Record<string, unknown> | undefined;
2270
+ extendSchema?: Record<string, unknown> | undefined;
2271
+ fees?: import("viem").ChainFees<undefined> | undefined;
2272
+ formatters: {
2273
+ readonly block: {
2274
+ exclude: [] | undefined;
2275
+ format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
2276
+ baseFeePerGas: bigint | null;
2277
+ blobGasUsed: bigint;
2278
+ difficulty: bigint;
2279
+ excessBlobGas: bigint;
2280
+ extraData: import("viem").Hex;
2281
+ gasLimit: bigint;
2282
+ gasUsed: bigint;
2283
+ hash: `0x${string}` | null;
2284
+ logsBloom: `0x${string}` | null;
2285
+ miner: import("abitype").Address;
2286
+ mixHash: import("viem").Hash;
2287
+ nonce: `0x${string}` | null;
2288
+ number: bigint | null;
2289
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
2290
+ parentHash: import("viem").Hash;
2291
+ receiptsRoot: import("viem").Hex;
2292
+ sealFields: import("viem").Hex[];
2293
+ sha3Uncles: import("viem").Hash;
2294
+ size: bigint;
2295
+ stateRoot: import("viem").Hash;
2296
+ timestamp: bigint;
2297
+ totalDifficulty: bigint | null;
2298
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
2299
+ transactionsRoot: import("viem").Hash;
2300
+ uncles: import("viem").Hash[];
2301
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
2302
+ withdrawalsRoot?: `0x${string}` | undefined;
2303
+ } & {};
2304
+ type: "block";
2305
+ };
2306
+ readonly transaction: {
2307
+ exclude: [] | undefined;
2308
+ format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
2309
+ blockHash: `0x${string}` | null;
2310
+ blockNumber: bigint | null;
2311
+ from: import("abitype").Address;
2312
+ gas: bigint;
2313
+ hash: import("viem").Hash;
2314
+ input: import("viem").Hex;
2315
+ nonce: number;
2316
+ r: import("viem").Hex;
2317
+ s: import("viem").Hex;
2318
+ to: import("abitype").Address | null;
2319
+ transactionIndex: number | null;
2320
+ typeHex: import("viem").Hex | null;
2321
+ v: bigint;
2322
+ value: bigint;
2323
+ yParity: number;
2324
+ gasPrice?: undefined | undefined;
2325
+ maxFeePerBlobGas?: undefined | undefined;
2326
+ maxFeePerGas: bigint;
2327
+ maxPriorityFeePerGas: bigint;
2328
+ isSystemTx?: boolean;
2329
+ mint?: bigint | undefined | undefined;
2330
+ sourceHash: import("viem").Hex;
2331
+ type: "deposit";
2332
+ } | {
2333
+ r: import("viem").Hex;
2334
+ s: import("viem").Hex;
2335
+ v: bigint;
2336
+ to: import("abitype").Address | null;
2337
+ from: import("abitype").Address;
2338
+ gas: bigint;
2339
+ nonce: number;
2340
+ value: bigint;
2341
+ blockHash: `0x${string}` | null;
2342
+ blockNumber: bigint | null;
2343
+ hash: import("viem").Hash;
2344
+ input: import("viem").Hex;
2345
+ transactionIndex: number | null;
2346
+ typeHex: import("viem").Hex | null;
2347
+ accessList?: undefined | undefined;
2348
+ authorizationList?: undefined | undefined;
2349
+ blobVersionedHashes?: undefined | undefined;
2350
+ chainId?: number | undefined;
2351
+ yParity?: undefined | undefined;
2352
+ type: "legacy";
2353
+ gasPrice: bigint;
2354
+ maxFeePerBlobGas?: undefined | undefined;
2355
+ maxFeePerGas?: undefined | undefined;
2356
+ maxPriorityFeePerGas?: undefined | undefined;
2357
+ isSystemTx?: undefined | undefined;
2358
+ mint?: undefined | undefined;
2359
+ sourceHash?: undefined | undefined;
2360
+ } | {
2361
+ blockHash: `0x${string}` | null;
2362
+ blockNumber: bigint | null;
2363
+ from: import("abitype").Address;
2364
+ gas: bigint;
2365
+ hash: import("viem").Hash;
2366
+ input: import("viem").Hex;
2367
+ nonce: number;
2368
+ r: import("viem").Hex;
2369
+ s: import("viem").Hex;
2370
+ to: import("abitype").Address | null;
2371
+ transactionIndex: number | null;
2372
+ typeHex: import("viem").Hex | null;
2373
+ v: bigint;
2374
+ value: bigint;
2375
+ yParity: number;
2376
+ accessList: import("viem").AccessList;
2377
+ authorizationList?: undefined | undefined;
2378
+ blobVersionedHashes?: undefined | undefined;
2379
+ chainId: number;
2380
+ type: "eip2930";
2381
+ gasPrice: bigint;
2382
+ maxFeePerBlobGas?: undefined | undefined;
2383
+ maxFeePerGas?: undefined | undefined;
2384
+ maxPriorityFeePerGas?: undefined | undefined;
2385
+ isSystemTx?: undefined | undefined;
2386
+ mint?: undefined | undefined;
2387
+ sourceHash?: undefined | undefined;
2388
+ } | {
2389
+ blockHash: `0x${string}` | null;
2390
+ blockNumber: bigint | null;
2391
+ from: import("abitype").Address;
2392
+ gas: bigint;
2393
+ hash: import("viem").Hash;
2394
+ input: import("viem").Hex;
2395
+ nonce: number;
2396
+ r: import("viem").Hex;
2397
+ s: import("viem").Hex;
2398
+ to: import("abitype").Address | null;
2399
+ transactionIndex: number | null;
2400
+ typeHex: import("viem").Hex | null;
2401
+ v: bigint;
2402
+ value: bigint;
2403
+ yParity: number;
2404
+ accessList: import("viem").AccessList;
2405
+ authorizationList?: undefined | undefined;
2406
+ blobVersionedHashes?: undefined | undefined;
2407
+ chainId: number;
2408
+ type: "eip1559";
2409
+ gasPrice?: undefined | undefined;
2410
+ maxFeePerBlobGas?: undefined | undefined;
2411
+ maxFeePerGas: bigint;
2412
+ maxPriorityFeePerGas: bigint;
2413
+ isSystemTx?: undefined | undefined;
2414
+ mint?: undefined | undefined;
2415
+ sourceHash?: undefined | undefined;
2416
+ } | {
2417
+ blockHash: `0x${string}` | null;
2418
+ blockNumber: bigint | null;
2419
+ from: import("abitype").Address;
2420
+ gas: bigint;
2421
+ hash: import("viem").Hash;
2422
+ input: import("viem").Hex;
2423
+ nonce: number;
2424
+ r: import("viem").Hex;
2425
+ s: import("viem").Hex;
2426
+ to: import("abitype").Address | null;
2427
+ transactionIndex: number | null;
2428
+ typeHex: import("viem").Hex | null;
2429
+ v: bigint;
2430
+ value: bigint;
2431
+ yParity: number;
2432
+ accessList: import("viem").AccessList;
2433
+ authorizationList?: undefined | undefined;
2434
+ blobVersionedHashes: readonly import("viem").Hex[];
2435
+ chainId: number;
2436
+ type: "eip4844";
2437
+ gasPrice?: undefined | undefined;
2438
+ maxFeePerBlobGas: bigint;
2439
+ maxFeePerGas: bigint;
2440
+ maxPriorityFeePerGas: bigint;
2441
+ isSystemTx?: undefined | undefined;
2442
+ mint?: undefined | undefined;
2443
+ sourceHash?: undefined | undefined;
2444
+ } | {
2445
+ blockHash: `0x${string}` | null;
2446
+ blockNumber: bigint | null;
2447
+ from: import("abitype").Address;
2448
+ gas: bigint;
2449
+ hash: import("viem").Hash;
2450
+ input: import("viem").Hex;
2451
+ nonce: number;
2452
+ r: import("viem").Hex;
2453
+ s: import("viem").Hex;
2454
+ to: import("abitype").Address | null;
2455
+ transactionIndex: number | null;
2456
+ typeHex: import("viem").Hex | null;
2457
+ v: bigint;
2458
+ value: bigint;
2459
+ yParity: number;
2460
+ accessList: import("viem").AccessList;
2461
+ authorizationList: import("viem").SignedAuthorizationList;
2462
+ blobVersionedHashes?: undefined | undefined;
2463
+ chainId: number;
2464
+ type: "eip7702";
2465
+ gasPrice?: undefined | undefined;
2466
+ maxFeePerBlobGas?: undefined | undefined;
2467
+ maxFeePerGas: bigint;
2468
+ maxPriorityFeePerGas: bigint;
2469
+ isSystemTx?: undefined | undefined;
2470
+ mint?: undefined | undefined;
2471
+ sourceHash?: undefined | undefined;
2472
+ }) & {};
2473
+ type: "transaction";
2474
+ };
2475
+ readonly transactionReceipt: {
2476
+ exclude: [] | undefined;
2477
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
2478
+ blobGasPrice?: bigint | undefined;
2479
+ blobGasUsed?: bigint | undefined;
2480
+ blockHash: import("viem").Hash;
2481
+ blockNumber: bigint;
2482
+ contractAddress: import("abitype").Address | null | undefined;
2483
+ cumulativeGasUsed: bigint;
2484
+ effectiveGasPrice: bigint;
2485
+ from: import("abitype").Address;
2486
+ gasUsed: bigint;
2487
+ logs: import("viem").Log<bigint, number, false>[];
2488
+ logsBloom: import("viem").Hex;
2489
+ root?: `0x${string}` | undefined;
2490
+ status: "success" | "reverted";
2491
+ to: import("abitype").Address | null;
2492
+ transactionHash: import("viem").Hash;
2493
+ transactionIndex: number;
2494
+ type: import("viem").TransactionType;
2495
+ l1GasPrice: bigint | null;
2496
+ l1GasUsed: bigint | null;
2497
+ l1Fee: bigint | null;
2498
+ l1FeeScalar: number | null;
2499
+ } & {};
2500
+ type: "transactionReceipt";
1741
2501
  };
1742
2502
  };
1743
- sourceId?: number | undefined | undefined;
1744
- testnet: true;
1745
- custom?: Record<string, unknown> | undefined;
1746
- extendSchema?: Record<string, unknown> | undefined;
1747
- fees?: import("viem").ChainFees<undefined> | undefined;
1748
- formatters?: undefined;
1749
2503
  prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1750
2504
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1751
2505
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
@@ -1753,42 +2507,46 @@ declare const testnetChains: ({
1753
2507
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1754
2508
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1755
2509
  }] | undefined;
1756
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2510
+ serializers: {
2511
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2512
+ };
1757
2513
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1758
2514
  } | {
1759
2515
  blockExplorers: {
1760
2516
  readonly default: {
1761
- readonly name: "Blockscout";
1762
- readonly url: "https://optimism-sepolia.blockscout.com";
1763
- readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
2517
+ readonly name: "Basescan";
2518
+ readonly url: "https://sepolia.basescan.org";
2519
+ readonly apiUrl: "https://api-sepolia.basescan.org/api";
1764
2520
  };
1765
2521
  };
1766
2522
  blockTime: 2000;
1767
2523
  contracts: {
1768
2524
  readonly disputeGameFactory: {
1769
2525
  readonly 11155111: {
1770
- readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
2526
+ readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
1771
2527
  };
1772
2528
  };
1773
2529
  readonly l2OutputOracle: {
1774
2530
  readonly 11155111: {
1775
- readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
2531
+ readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
1776
2532
  };
1777
2533
  };
1778
- readonly multicall3: {
1779
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1780
- readonly blockCreated: 1620204;
1781
- };
1782
2534
  readonly portal: {
1783
2535
  readonly 11155111: {
1784
- readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
2536
+ readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
2537
+ readonly blockCreated: 4446677;
1785
2538
  };
1786
2539
  };
1787
2540
  readonly l1StandardBridge: {
1788
2541
  readonly 11155111: {
1789
- readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
2542
+ readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
2543
+ readonly blockCreated: 4446677;
1790
2544
  };
1791
2545
  };
2546
+ readonly multicall3: {
2547
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2548
+ readonly blockCreated: 1059647;
2549
+ };
1792
2550
  readonly gasPriceOracle: {
1793
2551
  readonly address: "0x420000000000000000000000000000000000000F";
1794
2552
  };
@@ -1809,8 +2567,8 @@ declare const testnetChains: ({
1809
2567
  };
1810
2568
  };
1811
2569
  ensTlds?: readonly string[] | undefined;
1812
- id: 11155420;
1813
- name: "OP Sepolia";
2570
+ id: 84532;
2571
+ name: "Base Sepolia";
1814
2572
  nativeCurrency: {
1815
2573
  readonly name: "Sepolia Ether";
1816
2574
  readonly symbol: "ETH";
@@ -1819,7 +2577,7 @@ declare const testnetChains: ({
1819
2577
  experimental_preconfirmationTime?: number | undefined | undefined;
1820
2578
  rpcUrls: {
1821
2579
  readonly default: {
1822
- readonly http: readonly ["https://sepolia.optimism.io"];
2580
+ readonly http: readonly ["https://sepolia.base.org"];
1823
2581
  };
1824
2582
  };
1825
2583
  sourceId: 11155111;
@@ -2065,46 +2823,181 @@ declare const testnetChains: ({
2065
2823
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2066
2824
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2067
2825
  }] | undefined;
2068
- serializers: {
2069
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2826
+ serializers: {
2827
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2828
+ };
2829
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2830
+ readonly network: "base-sepolia";
2831
+ } | {
2832
+ blockExplorers: {
2833
+ readonly default: {
2834
+ readonly name: "Arbiscan";
2835
+ readonly url: "https://sepolia.arbiscan.io";
2836
+ readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
2837
+ };
2838
+ };
2839
+ blockTime: 250;
2840
+ contracts: {
2841
+ readonly multicall3: {
2842
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2843
+ readonly blockCreated: 81930;
2844
+ };
2845
+ };
2846
+ ensTlds?: readonly string[] | undefined;
2847
+ id: 421614;
2848
+ name: "Arbitrum Sepolia";
2849
+ nativeCurrency: {
2850
+ readonly name: "Arbitrum Sepolia Ether";
2851
+ readonly symbol: "ETH";
2852
+ readonly decimals: 18;
2853
+ };
2854
+ experimental_preconfirmationTime?: number | undefined | undefined;
2855
+ rpcUrls: {
2856
+ readonly default: {
2857
+ readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
2858
+ };
2859
+ };
2860
+ sourceId?: number | undefined | undefined;
2861
+ testnet: true;
2862
+ custom?: Record<string, unknown> | undefined;
2863
+ extendSchema?: Record<string, unknown> | undefined;
2864
+ fees?: import("viem").ChainFees<undefined> | undefined;
2865
+ formatters?: undefined;
2866
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2867
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2868
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2869
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2870
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2871
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2872
+ }] | undefined;
2873
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2874
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2875
+ } | {
2876
+ blockExplorers: {
2877
+ readonly default: {
2878
+ readonly name: "RouteScan";
2879
+ readonly url: "https://testnet.plasmascan.to";
2880
+ };
2881
+ };
2882
+ blockTime?: number | undefined | undefined;
2883
+ contracts: {
2884
+ readonly multicall3: {
2885
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
2886
+ readonly blockCreated: 0;
2887
+ };
2888
+ };
2889
+ ensTlds?: readonly string[] | undefined;
2890
+ id: 9746;
2891
+ name: "Plasma Testnet";
2892
+ nativeCurrency: {
2893
+ readonly name: "Testnet Plasma";
2894
+ readonly symbol: "XPL";
2895
+ readonly decimals: 18;
2896
+ };
2897
+ experimental_preconfirmationTime?: number | undefined | undefined;
2898
+ rpcUrls: {
2899
+ readonly default: {
2900
+ readonly http: readonly ["https://testnet-rpc.plasma.to"];
2901
+ };
2902
+ };
2903
+ sourceId?: number | undefined | undefined;
2904
+ testnet: true;
2905
+ custom?: Record<string, unknown> | undefined;
2906
+ extendSchema?: Record<string, unknown> | undefined;
2907
+ fees?: import("viem").ChainFees<undefined> | undefined;
2908
+ formatters?: undefined;
2909
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2910
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2911
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2912
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2913
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2914
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2915
+ }] | undefined;
2916
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2917
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2918
+ })[];
2919
+ declare const chains: ({
2920
+ blockExplorers: {
2921
+ readonly default: {
2922
+ readonly name: "Etherscan";
2923
+ readonly url: "https://etherscan.io";
2924
+ readonly apiUrl: "https://api.etherscan.io/api";
2925
+ };
2926
+ };
2927
+ blockTime: 12000;
2928
+ contracts: {
2929
+ readonly ensUniversalResolver: {
2930
+ readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
2931
+ readonly blockCreated: 23085558;
2932
+ };
2933
+ readonly multicall3: {
2934
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2935
+ readonly blockCreated: 14353601;
2936
+ };
2937
+ };
2938
+ ensTlds?: readonly string[] | undefined;
2939
+ id: 1;
2940
+ name: "Ethereum";
2941
+ nativeCurrency: {
2942
+ readonly name: "Ether";
2943
+ readonly symbol: "ETH";
2944
+ readonly decimals: 18;
2945
+ };
2946
+ experimental_preconfirmationTime?: number | undefined | undefined;
2947
+ rpcUrls: {
2948
+ readonly default: {
2949
+ readonly http: readonly ["https://eth.merkle.io"];
2950
+ };
2070
2951
  };
2952
+ sourceId?: number | undefined | undefined;
2953
+ testnet?: boolean | undefined | undefined;
2954
+ custom?: Record<string, unknown> | undefined;
2955
+ extendSchema?: Record<string, unknown> | undefined;
2956
+ fees?: import("viem").ChainFees<undefined> | undefined;
2957
+ formatters?: undefined;
2958
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2959
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2960
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2961
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2962
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2963
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2964
+ }] | undefined;
2965
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2071
2966
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2072
2967
  } | {
2073
2968
  blockExplorers: {
2074
2969
  readonly default: {
2075
- readonly name: "Basescan";
2076
- readonly url: "https://sepolia.basescan.org";
2077
- readonly apiUrl: "https://api-sepolia.basescan.org/api";
2970
+ readonly name: "Optimism Explorer";
2971
+ readonly url: "https://optimistic.etherscan.io";
2972
+ readonly apiUrl: "https://api-optimistic.etherscan.io/api";
2078
2973
  };
2079
2974
  };
2080
2975
  blockTime: 2000;
2081
2976
  contracts: {
2082
2977
  readonly disputeGameFactory: {
2083
- readonly 11155111: {
2084
- readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
2978
+ readonly 1: {
2979
+ readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
2085
2980
  };
2086
2981
  };
2087
2982
  readonly l2OutputOracle: {
2088
- readonly 11155111: {
2089
- readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
2983
+ readonly 1: {
2984
+ readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
2090
2985
  };
2091
2986
  };
2987
+ readonly multicall3: {
2988
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2989
+ readonly blockCreated: 4286263;
2990
+ };
2092
2991
  readonly portal: {
2093
- readonly 11155111: {
2094
- readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
2095
- readonly blockCreated: 4446677;
2992
+ readonly 1: {
2993
+ readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
2096
2994
  };
2097
2995
  };
2098
2996
  readonly l1StandardBridge: {
2099
- readonly 11155111: {
2100
- readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
2101
- readonly blockCreated: 4446677;
2997
+ readonly 1: {
2998
+ readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
2102
2999
  };
2103
3000
  };
2104
- readonly multicall3: {
2105
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2106
- readonly blockCreated: 1059647;
2107
- };
2108
3001
  readonly gasPriceOracle: {
2109
3002
  readonly address: "0x420000000000000000000000000000000000000F";
2110
3003
  };
@@ -2125,21 +3018,21 @@ declare const testnetChains: ({
2125
3018
  };
2126
3019
  };
2127
3020
  ensTlds?: readonly string[] | undefined;
2128
- id: 84532;
2129
- name: "Base Sepolia";
3021
+ id: 10;
3022
+ name: "OP Mainnet";
2130
3023
  nativeCurrency: {
2131
- readonly name: "Sepolia Ether";
3024
+ readonly name: "Ether";
2132
3025
  readonly symbol: "ETH";
2133
3026
  readonly decimals: 18;
2134
3027
  };
2135
3028
  experimental_preconfirmationTime?: number | undefined | undefined;
2136
3029
  rpcUrls: {
2137
3030
  readonly default: {
2138
- readonly http: readonly ["https://sepolia.base.org"];
3031
+ readonly http: readonly ["https://mainnet.optimism.io"];
2139
3032
  };
2140
3033
  };
2141
- sourceId: 11155111;
2142
- testnet: true;
3034
+ sourceId: 1;
3035
+ testnet?: boolean | undefined | undefined;
2143
3036
  custom?: Record<string, unknown> | undefined;
2144
3037
  extendSchema?: Record<string, unknown> | undefined;
2145
3038
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -2311,159 +3204,69 @@ declare const testnetChains: ({
2311
3204
  gasPrice?: undefined | undefined;
2312
3205
  maxFeePerBlobGas: bigint;
2313
3206
  maxFeePerGas: bigint;
2314
- maxPriorityFeePerGas: bigint;
2315
- isSystemTx?: undefined | undefined;
2316
- mint?: undefined | undefined;
2317
- sourceHash?: undefined | undefined;
2318
- } | {
2319
- blockHash: `0x${string}` | null;
2320
- blockNumber: bigint | null;
2321
- from: import("abitype").Address;
2322
- gas: bigint;
2323
- hash: import("viem").Hash;
2324
- input: import("viem").Hex;
2325
- nonce: number;
2326
- r: import("viem").Hex;
2327
- s: import("viem").Hex;
2328
- to: import("abitype").Address | null;
2329
- transactionIndex: number | null;
2330
- typeHex: import("viem").Hex | null;
2331
- v: bigint;
2332
- value: bigint;
2333
- yParity: number;
2334
- accessList: import("viem").AccessList;
2335
- authorizationList: import("viem").SignedAuthorizationList;
2336
- blobVersionedHashes?: undefined | undefined;
2337
- chainId: number;
2338
- type: "eip7702";
2339
- gasPrice?: undefined | undefined;
2340
- maxFeePerBlobGas?: undefined | undefined;
2341
- maxFeePerGas: bigint;
2342
- maxPriorityFeePerGas: bigint;
2343
- isSystemTx?: undefined | undefined;
2344
- mint?: undefined | undefined;
2345
- sourceHash?: undefined | undefined;
2346
- }) & {};
2347
- type: "transaction";
2348
- };
2349
- readonly transactionReceipt: {
2350
- exclude: [] | undefined;
2351
- format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
2352
- blobGasPrice?: bigint | undefined;
2353
- blobGasUsed?: bigint | undefined;
2354
- blockHash: import("viem").Hash;
2355
- blockNumber: bigint;
2356
- contractAddress: import("abitype").Address | null | undefined;
2357
- cumulativeGasUsed: bigint;
2358
- effectiveGasPrice: bigint;
2359
- from: import("abitype").Address;
2360
- gasUsed: bigint;
2361
- logs: import("viem").Log<bigint, number, false>[];
2362
- logsBloom: import("viem").Hex;
2363
- root?: `0x${string}` | undefined;
2364
- status: "success" | "reverted";
2365
- to: import("abitype").Address | null;
2366
- transactionHash: import("viem").Hash;
2367
- transactionIndex: number;
2368
- type: import("viem").TransactionType;
2369
- l1GasPrice: bigint | null;
2370
- l1GasUsed: bigint | null;
2371
- l1Fee: bigint | null;
2372
- l1FeeScalar: number | null;
2373
- } & {};
2374
- type: "transactionReceipt";
2375
- };
2376
- };
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: {
2385
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2386
- };
2387
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2388
- readonly network: "base-sepolia";
2389
- } | {
2390
- blockExplorers: {
2391
- readonly default: {
2392
- readonly name: "Arbiscan";
2393
- readonly url: "https://sepolia.arbiscan.io";
2394
- readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
2395
- };
2396
- };
2397
- blockTime: 250;
2398
- contracts: {
2399
- readonly multicall3: {
2400
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2401
- readonly blockCreated: 81930;
2402
- };
2403
- };
2404
- ensTlds?: readonly string[] | undefined;
2405
- id: 421614;
2406
- name: "Arbitrum Sepolia";
2407
- nativeCurrency: {
2408
- readonly name: "Arbitrum Sepolia Ether";
2409
- readonly symbol: "ETH";
2410
- readonly decimals: 18;
2411
- };
2412
- experimental_preconfirmationTime?: number | undefined | undefined;
2413
- rpcUrls: {
2414
- readonly default: {
2415
- readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
2416
- };
2417
- };
2418
- sourceId?: number | undefined | undefined;
2419
- testnet: true;
2420
- custom?: Record<string, unknown> | undefined;
2421
- extendSchema?: Record<string, unknown> | undefined;
2422
- fees?: import("viem").ChainFees<undefined> | undefined;
2423
- formatters?: undefined;
2424
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2425
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2426
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2427
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2428
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2429
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2430
- }] | undefined;
2431
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2432
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2433
- } | {
2434
- blockExplorers: {
2435
- readonly default: {
2436
- readonly name: "RouteScan";
2437
- readonly url: "https://testnet.plasmascan.to";
2438
- };
2439
- };
2440
- blockTime?: number | undefined | undefined;
2441
- contracts: {
2442
- readonly multicall3: {
2443
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
2444
- readonly blockCreated: 0;
3207
+ maxPriorityFeePerGas: bigint;
3208
+ isSystemTx?: undefined | undefined;
3209
+ mint?: undefined | undefined;
3210
+ sourceHash?: undefined | undefined;
3211
+ } | {
3212
+ blockHash: `0x${string}` | null;
3213
+ blockNumber: bigint | null;
3214
+ from: import("abitype").Address;
3215
+ gas: bigint;
3216
+ hash: import("viem").Hash;
3217
+ input: import("viem").Hex;
3218
+ nonce: number;
3219
+ r: import("viem").Hex;
3220
+ s: import("viem").Hex;
3221
+ to: import("abitype").Address | null;
3222
+ transactionIndex: number | null;
3223
+ typeHex: import("viem").Hex | null;
3224
+ v: bigint;
3225
+ value: bigint;
3226
+ yParity: number;
3227
+ accessList: import("viem").AccessList;
3228
+ authorizationList: import("viem").SignedAuthorizationList;
3229
+ blobVersionedHashes?: undefined | undefined;
3230
+ chainId: number;
3231
+ type: "eip7702";
3232
+ gasPrice?: undefined | undefined;
3233
+ maxFeePerBlobGas?: undefined | undefined;
3234
+ maxFeePerGas: bigint;
3235
+ maxPriorityFeePerGas: bigint;
3236
+ isSystemTx?: undefined | undefined;
3237
+ mint?: undefined | undefined;
3238
+ sourceHash?: undefined | undefined;
3239
+ }) & {};
3240
+ type: "transaction";
2445
3241
  };
2446
- };
2447
- ensTlds?: readonly string[] | undefined;
2448
- id: 9746;
2449
- name: "Plasma Testnet";
2450
- nativeCurrency: {
2451
- readonly name: "Testnet Plasma";
2452
- readonly symbol: "XPL";
2453
- readonly decimals: 18;
2454
- };
2455
- experimental_preconfirmationTime?: number | undefined | undefined;
2456
- rpcUrls: {
2457
- readonly default: {
2458
- readonly http: readonly ["https://testnet-rpc.plasma.to"];
3242
+ readonly transactionReceipt: {
3243
+ exclude: [] | undefined;
3244
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
3245
+ blobGasPrice?: bigint | undefined;
3246
+ blobGasUsed?: bigint | undefined;
3247
+ blockHash: import("viem").Hash;
3248
+ blockNumber: bigint;
3249
+ contractAddress: import("abitype").Address | null | undefined;
3250
+ cumulativeGasUsed: bigint;
3251
+ effectiveGasPrice: bigint;
3252
+ from: import("abitype").Address;
3253
+ gasUsed: bigint;
3254
+ logs: import("viem").Log<bigint, number, false>[];
3255
+ logsBloom: import("viem").Hex;
3256
+ root?: `0x${string}` | undefined;
3257
+ status: "success" | "reverted";
3258
+ to: import("abitype").Address | null;
3259
+ transactionHash: import("viem").Hash;
3260
+ transactionIndex: number;
3261
+ type: import("viem").TransactionType;
3262
+ l1GasPrice: bigint | null;
3263
+ l1GasUsed: bigint | null;
3264
+ l1Fee: bigint | null;
3265
+ l1FeeScalar: number | null;
3266
+ } & {};
3267
+ type: "transactionReceipt";
2459
3268
  };
2460
3269
  };
2461
- sourceId?: number | undefined | undefined;
2462
- testnet: true;
2463
- custom?: Record<string, unknown> | undefined;
2464
- extendSchema?: Record<string, unknown> | undefined;
2465
- fees?: import("viem").ChainFees<undefined> | undefined;
2466
- formatters?: undefined;
2467
3270
  prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2468
3271
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2469
3272
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
@@ -2471,89 +3274,44 @@ declare const testnetChains: ({
2471
3274
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2472
3275
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2473
3276
  }] | undefined;
2474
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2475
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2476
- })[];
2477
- declare const chains: ({
2478
- blockExplorers: {
2479
- readonly default: {
2480
- readonly name: "Etherscan";
2481
- readonly url: "https://etherscan.io";
2482
- readonly apiUrl: "https://api.etherscan.io/api";
2483
- };
2484
- };
2485
- blockTime: 12000;
2486
- contracts: {
2487
- readonly ensUniversalResolver: {
2488
- readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
2489
- readonly blockCreated: 23085558;
2490
- };
2491
- readonly multicall3: {
2492
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2493
- readonly blockCreated: 14353601;
2494
- };
2495
- };
2496
- ensTlds?: readonly string[] | undefined;
2497
- id: 1;
2498
- name: "Ethereum";
2499
- nativeCurrency: {
2500
- readonly name: "Ether";
2501
- readonly symbol: "ETH";
2502
- readonly decimals: 18;
2503
- };
2504
- experimental_preconfirmationTime?: number | undefined | undefined;
2505
- rpcUrls: {
2506
- readonly default: {
2507
- readonly http: readonly ["https://eth.merkle.io"];
2508
- };
3277
+ serializers: {
3278
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2509
3279
  };
2510
- sourceId?: number | undefined | undefined;
2511
- testnet?: boolean | undefined | undefined;
2512
- custom?: Record<string, unknown> | undefined;
2513
- extendSchema?: Record<string, unknown> | undefined;
2514
- fees?: import("viem").ChainFees<undefined> | undefined;
2515
- formatters?: undefined;
2516
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2517
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2518
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2519
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2520
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2521
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2522
- }] | undefined;
2523
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2524
3280
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2525
3281
  } | {
2526
3282
  blockExplorers: {
2527
3283
  readonly default: {
2528
- readonly name: "Optimism Explorer";
2529
- readonly url: "https://optimistic.etherscan.io";
2530
- readonly apiUrl: "https://api-optimistic.etherscan.io/api";
3284
+ readonly name: "Basescan";
3285
+ readonly url: "https://basescan.org";
3286
+ readonly apiUrl: "https://api.basescan.org/api";
2531
3287
  };
2532
3288
  };
2533
3289
  blockTime: 2000;
2534
3290
  contracts: {
2535
3291
  readonly disputeGameFactory: {
2536
3292
  readonly 1: {
2537
- readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
3293
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
2538
3294
  };
2539
3295
  };
2540
3296
  readonly l2OutputOracle: {
2541
3297
  readonly 1: {
2542
- readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
3298
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
2543
3299
  };
2544
3300
  };
2545
3301
  readonly multicall3: {
2546
3302
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2547
- readonly blockCreated: 4286263;
3303
+ readonly blockCreated: 5022;
2548
3304
  };
2549
3305
  readonly portal: {
2550
3306
  readonly 1: {
2551
- readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
3307
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
3308
+ readonly blockCreated: 17482143;
2552
3309
  };
2553
3310
  };
2554
3311
  readonly l1StandardBridge: {
2555
3312
  readonly 1: {
2556
- readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
3313
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
3314
+ readonly blockCreated: 17482143;
2557
3315
  };
2558
3316
  };
2559
3317
  readonly gasPriceOracle: {
@@ -2576,8 +3334,8 @@ declare const chains: ({
2576
3334
  };
2577
3335
  };
2578
3336
  ensTlds?: readonly string[] | undefined;
2579
- id: 10;
2580
- name: "OP Mainnet";
3337
+ id: 8453;
3338
+ name: "Base";
2581
3339
  nativeCurrency: {
2582
3340
  readonly name: "Ether";
2583
3341
  readonly symbol: "ETH";
@@ -2586,7 +3344,7 @@ declare const chains: ({
2586
3344
  experimental_preconfirmationTime?: number | undefined | undefined;
2587
3345
  rpcUrls: {
2588
3346
  readonly default: {
2589
- readonly http: readonly ["https://mainnet.optimism.io"];
3347
+ readonly http: readonly ["https://mainnet.base.org"];
2590
3348
  };
2591
3349
  };
2592
3350
  sourceId: 1;
@@ -2839,39 +3597,127 @@ declare const chains: ({
2839
3597
  } | {
2840
3598
  blockExplorers: {
2841
3599
  readonly default: {
2842
- readonly name: "Basescan";
2843
- readonly url: "https://basescan.org";
2844
- readonly apiUrl: "https://api.basescan.org/api";
3600
+ readonly name: "Arbiscan";
3601
+ readonly url: "https://arbiscan.io";
3602
+ readonly apiUrl: "https://api.arbiscan.io/api";
3603
+ };
3604
+ };
3605
+ blockTime: 250;
3606
+ contracts: {
3607
+ readonly multicall3: {
3608
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3609
+ readonly blockCreated: 7654707;
3610
+ };
3611
+ };
3612
+ ensTlds?: readonly string[] | undefined;
3613
+ id: 42161;
3614
+ name: "Arbitrum One";
3615
+ nativeCurrency: {
3616
+ readonly name: "Ether";
3617
+ readonly symbol: "ETH";
3618
+ readonly decimals: 18;
3619
+ };
3620
+ experimental_preconfirmationTime?: number | undefined | undefined;
3621
+ rpcUrls: {
3622
+ readonly default: {
3623
+ readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
3624
+ };
3625
+ };
3626
+ sourceId?: number | undefined | undefined;
3627
+ testnet?: boolean | undefined | undefined;
3628
+ custom?: Record<string, unknown> | undefined;
3629
+ extendSchema?: Record<string, unknown> | undefined;
3630
+ fees?: import("viem").ChainFees<undefined> | undefined;
3631
+ formatters?: undefined;
3632
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3633
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3634
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3635
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3636
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3637
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3638
+ }] | undefined;
3639
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3640
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3641
+ } | {
3642
+ blockExplorers: {
3643
+ readonly default: {
3644
+ readonly name: "PolygonScan";
3645
+ readonly url: "https://polygonscan.com";
3646
+ readonly apiUrl: "https://api.etherscan.io/v2/api";
3647
+ };
3648
+ };
3649
+ blockTime: 2000;
3650
+ contracts: {
3651
+ readonly multicall3: {
3652
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3653
+ readonly blockCreated: 25770160;
3654
+ };
3655
+ };
3656
+ ensTlds?: readonly string[] | undefined;
3657
+ id: 137;
3658
+ name: "Polygon";
3659
+ nativeCurrency: {
3660
+ readonly name: "POL";
3661
+ readonly symbol: "POL";
3662
+ readonly decimals: 18;
3663
+ };
3664
+ experimental_preconfirmationTime?: number | undefined | undefined;
3665
+ rpcUrls: {
3666
+ readonly default: {
3667
+ readonly http: readonly ["https://polygon-rpc.com"];
3668
+ };
3669
+ };
3670
+ sourceId?: number | undefined | undefined;
3671
+ testnet?: boolean | undefined | undefined;
3672
+ custom?: Record<string, unknown> | undefined;
3673
+ extendSchema?: Record<string, unknown> | undefined;
3674
+ fees?: import("viem").ChainFees<undefined> | undefined;
3675
+ formatters?: undefined;
3676
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3677
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3678
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3679
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3680
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3681
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3682
+ }] | undefined;
3683
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3684
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3685
+ } | {
3686
+ blockExplorers: {
3687
+ readonly default: {
3688
+ readonly name: "Blockscout";
3689
+ readonly url: "https://soneium.blockscout.com";
3690
+ readonly apiUrl: "https://soneium.blockscout.com/api";
2845
3691
  };
2846
3692
  };
2847
3693
  blockTime: 2000;
2848
3694
  contracts: {
2849
3695
  readonly disputeGameFactory: {
2850
3696
  readonly 1: {
2851
- readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
3697
+ readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
2852
3698
  };
2853
3699
  };
2854
3700
  readonly l2OutputOracle: {
2855
3701
  readonly 1: {
2856
- readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
3702
+ readonly address: "0x0000000000000000000000000000000000000000";
2857
3703
  };
2858
3704
  };
2859
- readonly multicall3: {
2860
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2861
- readonly blockCreated: 5022;
2862
- };
2863
3705
  readonly portal: {
2864
3706
  readonly 1: {
2865
- readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
2866
- readonly blockCreated: 17482143;
3707
+ readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
3708
+ readonly blockCreated: 7061266;
2867
3709
  };
2868
3710
  };
2869
3711
  readonly l1StandardBridge: {
2870
3712
  readonly 1: {
2871
- readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
2872
- readonly blockCreated: 17482143;
3713
+ readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
3714
+ readonly blockCreated: 7061266;
2873
3715
  };
2874
3716
  };
3717
+ readonly multicall3: {
3718
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3719
+ readonly blockCreated: 1;
3720
+ };
2875
3721
  readonly gasPriceOracle: {
2876
3722
  readonly address: "0x420000000000000000000000000000000000000F";
2877
3723
  };
@@ -2892,8 +3738,8 @@ declare const chains: ({
2892
3738
  };
2893
3739
  };
2894
3740
  ensTlds?: readonly string[] | undefined;
2895
- id: 8453;
2896
- name: "Base";
3741
+ id: 1868;
3742
+ name: "Soneium Mainnet";
2897
3743
  nativeCurrency: {
2898
3744
  readonly name: "Ether";
2899
3745
  readonly symbol: "ETH";
@@ -2902,7 +3748,7 @@ declare const chains: ({
2902
3748
  experimental_preconfirmationTime?: number | undefined | undefined;
2903
3749
  rpcUrls: {
2904
3750
  readonly default: {
2905
- readonly http: readonly ["https://mainnet.base.org"];
3751
+ readonly http: readonly ["https://rpc.soneium.org"];
2906
3752
  };
2907
3753
  };
2908
3754
  sourceId: 1;
@@ -3155,30 +4001,72 @@ declare const chains: ({
3155
4001
  } | {
3156
4002
  blockExplorers: {
3157
4003
  readonly default: {
3158
- readonly name: "Arbiscan";
3159
- readonly url: "https://arbiscan.io";
3160
- readonly apiUrl: "https://api.arbiscan.io/api";
4004
+ readonly name: "Sonic Explorer";
4005
+ readonly url: "https://sonicscan.org";
3161
4006
  };
3162
4007
  };
3163
- blockTime: 250;
4008
+ blockTime: 630;
3164
4009
  contracts: {
3165
4010
  readonly multicall3: {
3166
4011
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3167
- readonly blockCreated: 7654707;
4012
+ readonly blockCreated: 60;
3168
4013
  };
3169
4014
  };
3170
4015
  ensTlds?: readonly string[] | undefined;
3171
- id: 42161;
3172
- name: "Arbitrum One";
4016
+ id: 146;
4017
+ name: "Sonic";
3173
4018
  nativeCurrency: {
3174
- readonly name: "Ether";
3175
- readonly symbol: "ETH";
3176
4019
  readonly decimals: 18;
4020
+ readonly name: "Sonic";
4021
+ readonly symbol: "S";
3177
4022
  };
3178
4023
  experimental_preconfirmationTime?: number | undefined | undefined;
3179
4024
  rpcUrls: {
3180
4025
  readonly default: {
3181
- readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
4026
+ readonly http: readonly ["https://rpc.soniclabs.com"];
4027
+ };
4028
+ };
4029
+ sourceId?: number | undefined | undefined;
4030
+ testnet: false;
4031
+ custom?: Record<string, unknown> | undefined;
4032
+ extendSchema?: Record<string, unknown> | undefined;
4033
+ fees?: import("viem").ChainFees<undefined> | undefined;
4034
+ formatters?: undefined;
4035
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4036
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4037
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4038
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4039
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4040
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4041
+ }] | undefined;
4042
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4043
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4044
+ } | {
4045
+ blockExplorers: {
4046
+ readonly default: {
4047
+ readonly name: "PlasmaScan";
4048
+ readonly url: "https://plasmascan.to";
4049
+ };
4050
+ };
4051
+ blockTime: 1000;
4052
+ contracts: {
4053
+ readonly multicall3: {
4054
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4055
+ readonly blockCreated: 0;
4056
+ };
4057
+ };
4058
+ ensTlds?: readonly string[] | undefined;
4059
+ id: 9745;
4060
+ name: "Plasma";
4061
+ nativeCurrency: {
4062
+ readonly name: "Plasma";
4063
+ readonly symbol: "XPL";
4064
+ readonly decimals: 18;
4065
+ };
4066
+ experimental_preconfirmationTime?: number | undefined | undefined;
4067
+ rpcUrls: {
4068
+ readonly default: {
4069
+ readonly http: readonly ["https://rpc.plasma.to"];
3182
4070
  };
3183
4071
  };
3184
4072
  sourceId?: number | undefined | undefined;
@@ -3199,30 +4087,31 @@ declare const chains: ({
3199
4087
  } | {
3200
4088
  blockExplorers: {
3201
4089
  readonly default: {
3202
- readonly name: "PolygonScan";
3203
- readonly url: "https://polygonscan.com";
3204
- readonly apiUrl: "https://api.etherscan.io/v2/api";
4090
+ readonly name: "Gnosisscan";
4091
+ readonly url: "https://gnosisscan.io";
4092
+ readonly apiUrl: "https://api.gnosisscan.io/api";
3205
4093
  };
3206
4094
  };
3207
- blockTime: 2000;
4095
+ blockTime: 5000;
3208
4096
  contracts: {
3209
4097
  readonly multicall3: {
3210
4098
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3211
- readonly blockCreated: 25770160;
4099
+ readonly blockCreated: 21022491;
3212
4100
  };
3213
4101
  };
3214
4102
  ensTlds?: readonly string[] | undefined;
3215
- id: 137;
3216
- name: "Polygon";
4103
+ id: 100;
4104
+ name: "Gnosis";
3217
4105
  nativeCurrency: {
3218
- readonly name: "POL";
3219
- readonly symbol: "POL";
3220
4106
  readonly decimals: 18;
4107
+ readonly name: "xDAI";
4108
+ readonly symbol: "XDAI";
3221
4109
  };
3222
4110
  experimental_preconfirmationTime?: number | undefined | undefined;
3223
4111
  rpcUrls: {
3224
4112
  readonly default: {
3225
- readonly http: readonly ["https://polygon-rpc.com"];
4113
+ readonly http: readonly ["https://rpc.gnosischain.com"];
4114
+ readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
3226
4115
  };
3227
4116
  };
3228
4117
  sourceId?: number | undefined | undefined;
@@ -3243,39 +4132,171 @@ declare const chains: ({
3243
4132
  } | {
3244
4133
  blockExplorers: {
3245
4134
  readonly default: {
3246
- readonly name: "Blockscout";
3247
- readonly url: "https://soneium.blockscout.com";
3248
- readonly apiUrl: "https://soneium.blockscout.com/api";
4135
+ readonly name: "BscScan";
4136
+ readonly url: "https://bscscan.com";
4137
+ readonly apiUrl: "https://api.bscscan.com/api";
3249
4138
  };
3250
4139
  };
3251
- blockTime: 2000;
4140
+ blockTime: 750;
3252
4141
  contracts: {
3253
- readonly disputeGameFactory: {
3254
- readonly 1: {
3255
- readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
3256
- };
4142
+ readonly multicall3: {
4143
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4144
+ readonly blockCreated: 15921452;
3257
4145
  };
3258
- readonly l2OutputOracle: {
4146
+ };
4147
+ ensTlds?: readonly string[] | undefined;
4148
+ id: 56;
4149
+ name: "BNB Smart Chain";
4150
+ nativeCurrency: {
4151
+ readonly decimals: 18;
4152
+ readonly name: "BNB";
4153
+ readonly symbol: "BNB";
4154
+ };
4155
+ experimental_preconfirmationTime?: number | undefined | undefined;
4156
+ rpcUrls: {
4157
+ readonly default: {
4158
+ readonly http: readonly ["https://56.rpc.thirdweb.com"];
4159
+ };
4160
+ };
4161
+ sourceId?: number | undefined | undefined;
4162
+ testnet?: boolean | undefined | undefined;
4163
+ custom?: Record<string, unknown> | undefined;
4164
+ extendSchema?: Record<string, unknown> | undefined;
4165
+ fees?: import("viem").ChainFees<undefined> | undefined;
4166
+ formatters?: undefined;
4167
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4168
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4169
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4170
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4171
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4172
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4173
+ }] | undefined;
4174
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4175
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4176
+ } | {
4177
+ blockExplorers: {
4178
+ readonly default: {
4179
+ readonly name: "HyperEVMScan";
4180
+ readonly url: "https://hyperevmscan.io";
4181
+ };
4182
+ };
4183
+ blockTime?: number | undefined | undefined;
4184
+ contracts?: {
4185
+ [x: string]: import("viem").ChainContract | {
4186
+ [sourceId: number]: import("viem").ChainContract | undefined;
4187
+ } | undefined;
4188
+ ensRegistry?: import("viem").ChainContract | undefined;
4189
+ ensUniversalResolver?: import("viem").ChainContract | undefined;
4190
+ multicall3?: import("viem").ChainContract | undefined;
4191
+ erc6492Verifier?: import("viem").ChainContract | undefined;
4192
+ } | undefined;
4193
+ ensTlds?: readonly string[] | undefined;
4194
+ id: 999;
4195
+ name: "HyperEVM";
4196
+ nativeCurrency: {
4197
+ readonly name: "HYPE";
4198
+ readonly symbol: "HYPE";
4199
+ readonly decimals: 18;
4200
+ };
4201
+ experimental_preconfirmationTime?: number | undefined | undefined;
4202
+ rpcUrls: {
4203
+ readonly default: {
4204
+ readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
4205
+ };
4206
+ };
4207
+ sourceId?: number | undefined | undefined;
4208
+ testnet: false;
4209
+ custom?: Record<string, unknown> | undefined;
4210
+ extendSchema?: Record<string, unknown> | undefined;
4211
+ fees?: import("viem").ChainFees<undefined> | undefined;
4212
+ formatters?: undefined;
4213
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4214
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4215
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4216
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4217
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4218
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4219
+ }] | undefined;
4220
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4221
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4222
+ } | {
4223
+ blockExplorers: {
4224
+ readonly default: {
4225
+ readonly name: "MonadVision";
4226
+ readonly url: "https://monadvision.com";
4227
+ };
4228
+ readonly monadscan: {
4229
+ readonly name: "Monadscan";
4230
+ readonly url: "https://monadscan.com";
4231
+ readonly apiUrl: "https://api.monadscan.com/api";
4232
+ };
4233
+ };
4234
+ blockTime: 400;
4235
+ contracts: {
4236
+ readonly multicall3: {
4237
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4238
+ readonly blockCreated: 9248132;
4239
+ };
4240
+ };
4241
+ ensTlds?: readonly string[] | undefined;
4242
+ id: 143;
4243
+ name: "Monad";
4244
+ nativeCurrency: {
4245
+ readonly name: "Monad";
4246
+ readonly symbol: "MON";
4247
+ readonly decimals: 18;
4248
+ };
4249
+ experimental_preconfirmationTime?: number | undefined | undefined;
4250
+ rpcUrls: {
4251
+ readonly default: {
4252
+ readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
4253
+ readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
4254
+ };
4255
+ };
4256
+ sourceId?: number | undefined | undefined;
4257
+ testnet: false;
4258
+ custom?: Record<string, unknown> | undefined;
4259
+ extendSchema?: Record<string, unknown> | undefined;
4260
+ fees?: import("viem").ChainFees<undefined> | undefined;
4261
+ formatters?: undefined;
4262
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4263
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4264
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4265
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4266
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4267
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4268
+ }] | undefined;
4269
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4270
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4271
+ } | {
4272
+ blockExplorers: {
4273
+ readonly default: {
4274
+ readonly name: "Uniscan";
4275
+ readonly url: "https://uniscan.xyz";
4276
+ readonly apiUrl: "https://api.uniscan.xyz/api";
4277
+ };
4278
+ };
4279
+ blockTime: 1000;
4280
+ contracts: {
4281
+ readonly multicall3: {
4282
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4283
+ readonly blockCreated: 0;
4284
+ };
4285
+ readonly disputeGameFactory: {
3259
4286
  readonly 1: {
3260
- readonly address: "0x0000000000000000000000000000000000000000";
4287
+ readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
3261
4288
  };
3262
4289
  };
3263
4290
  readonly portal: {
3264
4291
  readonly 1: {
3265
- readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
3266
- readonly blockCreated: 7061266;
4292
+ readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
3267
4293
  };
3268
4294
  };
3269
4295
  readonly l1StandardBridge: {
3270
4296
  readonly 1: {
3271
- readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
3272
- readonly blockCreated: 7061266;
4297
+ readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
3273
4298
  };
3274
4299
  };
3275
- readonly multicall3: {
3276
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3277
- readonly blockCreated: 1;
3278
- };
3279
4300
  readonly gasPriceOracle: {
3280
4301
  readonly address: "0x420000000000000000000000000000000000000F";
3281
4302
  };
@@ -3296,8 +4317,8 @@ declare const chains: ({
3296
4317
  };
3297
4318
  };
3298
4319
  ensTlds?: readonly string[] | undefined;
3299
- id: 1868;
3300
- name: "Soneium Mainnet";
4320
+ id: 130;
4321
+ name: "Unichain";
3301
4322
  nativeCurrency: {
3302
4323
  readonly name: "Ether";
3303
4324
  readonly symbol: "ETH";
@@ -3306,7 +4327,7 @@ declare const chains: ({
3306
4327
  experimental_preconfirmationTime?: number | undefined | undefined;
3307
4328
  rpcUrls: {
3308
4329
  readonly default: {
3309
- readonly http: readonly ["https://rpc.soneium.org"];
4330
+ readonly http: readonly ["https://mainnet.unichain.org/"];
3310
4331
  };
3311
4332
  };
3312
4333
  sourceId: 1;
@@ -3557,258 +4578,34 @@ declare const chains: ({
3557
4578
  };
3558
4579
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3559
4580
  } | {
3560
- blockExplorers: {
3561
- readonly default: {
3562
- readonly name: "Sonic Explorer";
3563
- readonly url: "https://sonicscan.org";
3564
- };
3565
- };
3566
- blockTime: 630;
3567
- contracts: {
3568
- readonly multicall3: {
3569
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3570
- readonly blockCreated: 60;
3571
- };
3572
- };
3573
- ensTlds?: readonly string[] | undefined;
3574
- id: 146;
3575
- name: "Sonic";
3576
- nativeCurrency: {
3577
- readonly decimals: 18;
3578
- readonly name: "Sonic";
3579
- readonly symbol: "S";
3580
- };
3581
- experimental_preconfirmationTime?: number | undefined | undefined;
3582
- rpcUrls: {
3583
- readonly default: {
3584
- readonly http: readonly ["https://rpc.soniclabs.com"];
3585
- };
3586
- };
3587
- sourceId?: number | undefined | undefined;
3588
- testnet: false;
3589
- custom?: Record<string, unknown> | undefined;
3590
- extendSchema?: Record<string, unknown> | undefined;
3591
- fees?: import("viem").ChainFees<undefined> | undefined;
3592
- formatters?: undefined;
3593
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3594
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3595
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3596
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3597
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3598
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3599
- }] | undefined;
3600
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3601
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3602
- } | {
3603
- blockExplorers: {
3604
- readonly default: {
3605
- readonly name: "PlasmaScan";
3606
- readonly url: "https://plasmascan.to";
3607
- };
3608
- };
3609
- blockTime: 1000;
3610
- contracts: {
3611
- readonly multicall3: {
3612
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3613
- readonly blockCreated: 0;
3614
- };
3615
- };
3616
- ensTlds?: readonly string[] | undefined;
3617
- id: 9745;
3618
- name: "Plasma";
3619
- nativeCurrency: {
3620
- readonly name: "Plasma";
3621
- readonly symbol: "XPL";
3622
- readonly decimals: 18;
3623
- };
3624
- experimental_preconfirmationTime?: number | undefined | undefined;
3625
- rpcUrls: {
3626
- readonly default: {
3627
- readonly http: readonly ["https://rpc.plasma.to"];
3628
- };
3629
- };
3630
- sourceId?: number | undefined | undefined;
3631
- testnet?: boolean | undefined | undefined;
3632
- custom?: Record<string, unknown> | undefined;
3633
- extendSchema?: Record<string, unknown> | undefined;
3634
- fees?: import("viem").ChainFees<undefined> | undefined;
3635
- formatters?: undefined;
3636
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3637
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3638
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3639
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3640
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3641
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3642
- }] | undefined;
3643
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3644
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3645
- } | {
3646
- blockExplorers: {
3647
- readonly default: {
3648
- readonly name: "Gnosisscan";
3649
- readonly url: "https://gnosisscan.io";
3650
- readonly apiUrl: "https://api.gnosisscan.io/api";
3651
- };
3652
- };
3653
- blockTime: 5000;
3654
- contracts: {
3655
- readonly multicall3: {
3656
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3657
- readonly blockCreated: 21022491;
3658
- };
3659
- };
3660
- ensTlds?: readonly string[] | undefined;
3661
- id: 100;
3662
- name: "Gnosis";
3663
- nativeCurrency: {
3664
- readonly decimals: 18;
3665
- readonly name: "xDAI";
3666
- readonly symbol: "XDAI";
3667
- };
3668
- experimental_preconfirmationTime?: number | undefined | undefined;
3669
- rpcUrls: {
3670
- readonly default: {
3671
- readonly http: readonly ["https://rpc.gnosischain.com"];
3672
- readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
3673
- };
3674
- };
3675
- sourceId?: number | undefined | undefined;
3676
- testnet?: boolean | undefined | undefined;
3677
- custom?: Record<string, unknown> | undefined;
3678
- extendSchema?: Record<string, unknown> | undefined;
3679
- fees?: import("viem").ChainFees<undefined> | undefined;
3680
- formatters?: undefined;
3681
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3682
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3683
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3684
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3685
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3686
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3687
- }] | undefined;
3688
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3689
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3690
- } | {
3691
- blockExplorers: {
3692
- readonly default: {
3693
- readonly name: "BscScan";
3694
- readonly url: "https://bscscan.com";
3695
- readonly apiUrl: "https://api.bscscan.com/api";
3696
- };
3697
- };
3698
- blockTime: 750;
3699
- contracts: {
3700
- readonly multicall3: {
3701
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3702
- readonly blockCreated: 15921452;
3703
- };
3704
- };
3705
- ensTlds?: readonly string[] | undefined;
3706
- id: 56;
3707
- name: "BNB Smart Chain";
3708
- nativeCurrency: {
3709
- readonly decimals: 18;
3710
- readonly name: "BNB";
3711
- readonly symbol: "BNB";
3712
- };
3713
- experimental_preconfirmationTime?: number | undefined | undefined;
3714
- rpcUrls: {
3715
- readonly default: {
3716
- readonly http: readonly ["https://56.rpc.thirdweb.com"];
3717
- };
3718
- };
3719
- sourceId?: number | undefined | undefined;
3720
- testnet?: boolean | undefined | undefined;
3721
- custom?: Record<string, unknown> | undefined;
3722
- extendSchema?: Record<string, unknown> | undefined;
3723
- fees?: import("viem").ChainFees<undefined> | undefined;
3724
- formatters?: undefined;
3725
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3726
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3727
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3728
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3729
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3730
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3731
- }] | undefined;
3732
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3733
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3734
- } | {
3735
- blockExplorers: {
3736
- readonly default: {
3737
- readonly name: "HyperEVMScan";
3738
- readonly url: "https://hyperevmscan.io";
3739
- };
3740
- };
3741
- blockTime?: number | undefined | undefined;
3742
- contracts?: {
3743
- [x: string]: import("viem").ChainContract | {
3744
- [sourceId: number]: import("viem").ChainContract | undefined;
3745
- } | undefined;
3746
- ensRegistry?: import("viem").ChainContract | undefined;
3747
- ensUniversalResolver?: import("viem").ChainContract | undefined;
3748
- multicall3?: import("viem").ChainContract | undefined;
3749
- erc6492Verifier?: import("viem").ChainContract | undefined;
3750
- } | undefined;
3751
- ensTlds?: readonly string[] | undefined;
3752
- id: 999;
3753
- name: "HyperEVM";
3754
- nativeCurrency: {
3755
- readonly name: "HYPE";
3756
- readonly symbol: "HYPE";
3757
- readonly decimals: 18;
3758
- };
3759
- experimental_preconfirmationTime?: number | undefined | undefined;
3760
- rpcUrls: {
3761
- readonly default: {
3762
- readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
3763
- };
3764
- };
3765
- sourceId?: number | undefined | undefined;
3766
- testnet: false;
3767
- custom?: Record<string, unknown> | undefined;
3768
- extendSchema?: Record<string, unknown> | undefined;
3769
- fees?: import("viem").ChainFees<undefined> | undefined;
3770
- formatters?: undefined;
3771
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3772
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3773
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3774
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3775
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3776
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3777
- }] | undefined;
3778
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3779
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3780
- } | {
3781
- blockExplorers: {
3782
- readonly default: {
3783
- readonly name: "MonadVision";
3784
- readonly url: "https://monadvision.com";
3785
- };
3786
- readonly monadscan: {
3787
- readonly name: "Monadscan";
3788
- readonly url: "https://monadscan.com";
3789
- readonly apiUrl: "https://api.monadscan.com/api";
3790
- };
3791
- };
3792
- blockTime: 400;
3793
- contracts: {
3794
- readonly multicall3: {
3795
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3796
- readonly blockCreated: 9248132;
4581
+ blockExplorers: {
4582
+ readonly default: {
4583
+ readonly name: "katana explorer";
4584
+ readonly url: "https://katanascan.com";
3797
4585
  };
3798
4586
  };
4587
+ blockTime?: number | undefined | undefined;
4588
+ contracts?: {
4589
+ [x: string]: import("viem").ChainContract | {
4590
+ [sourceId: number]: import("viem").ChainContract | undefined;
4591
+ } | undefined;
4592
+ ensRegistry?: import("viem").ChainContract | undefined;
4593
+ ensUniversalResolver?: import("viem").ChainContract | undefined;
4594
+ multicall3?: import("viem").ChainContract | undefined;
4595
+ erc6492Verifier?: import("viem").ChainContract | undefined;
4596
+ } | undefined;
3799
4597
  ensTlds?: readonly string[] | undefined;
3800
- id: 143;
3801
- name: "Monad";
4598
+ id: 747474;
4599
+ name: "Katana";
3802
4600
  nativeCurrency: {
3803
- readonly name: "Monad";
3804
- readonly symbol: "MON";
4601
+ readonly name: "Ether";
4602
+ readonly symbol: "ETH";
3805
4603
  readonly decimals: 18;
3806
4604
  };
3807
4605
  experimental_preconfirmationTime?: number | undefined | undefined;
3808
4606
  rpcUrls: {
3809
4607
  readonly default: {
3810
- readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
3811
- readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
4608
+ readonly http: readonly ["https://rpc.katana.network"];
3812
4609
  };
3813
4610
  };
3814
4611
  sourceId?: number | undefined | undefined;
@@ -3826,77 +4623,55 @@ declare const chains: ({
3826
4623
  }] | undefined;
3827
4624
  serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3828
4625
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4626
+ readonly network: "katana";
3829
4627
  } | {
3830
4628
  blockExplorers: {
3831
4629
  readonly default: {
3832
- readonly name: "Uniscan";
3833
- readonly url: "https://uniscan.xyz";
3834
- readonly apiUrl: "https://api.uniscan.xyz/api";
4630
+ readonly name: "Etherscan";
4631
+ readonly url: "https://abscan.org";
4632
+ };
4633
+ readonly native: {
4634
+ readonly name: "Abstract Explorer";
4635
+ readonly url: "https://explorer.mainnet.abs.xyz";
3835
4636
  };
3836
4637
  };
3837
- blockTime: 1000;
4638
+ blockTime: 200;
3838
4639
  contracts: {
3839
4640
  readonly multicall3: {
3840
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3841
- readonly blockCreated: 0;
3842
- };
3843
- readonly disputeGameFactory: {
3844
- readonly 1: {
3845
- readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
3846
- };
3847
- };
3848
- readonly portal: {
3849
- readonly 1: {
3850
- readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
3851
- };
3852
- };
3853
- readonly l1StandardBridge: {
3854
- readonly 1: {
3855
- readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
3856
- };
3857
- };
3858
- readonly gasPriceOracle: {
3859
- readonly address: "0x420000000000000000000000000000000000000F";
3860
- };
3861
- readonly l1Block: {
3862
- readonly address: "0x4200000000000000000000000000000000000015";
3863
- };
3864
- readonly l2CrossDomainMessenger: {
3865
- readonly address: "0x4200000000000000000000000000000000000007";
3866
- };
3867
- readonly l2Erc721Bridge: {
3868
- readonly address: "0x4200000000000000000000000000000000000014";
3869
- };
3870
- readonly l2StandardBridge: {
3871
- readonly address: "0x4200000000000000000000000000000000000010";
4641
+ readonly address: "0xAa4De41dba0Ca5dCBb288b7cC6b708F3aaC759E7";
4642
+ readonly blockCreated: 5288;
3872
4643
  };
3873
- readonly l2ToL1MessagePasser: {
3874
- readonly address: "0x4200000000000000000000000000000000000016";
4644
+ readonly erc6492Verifier: {
4645
+ readonly address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C";
4646
+ readonly blockCreated: 5263;
3875
4647
  };
3876
4648
  };
3877
4649
  ensTlds?: readonly string[] | undefined;
3878
- id: 130;
3879
- name: "Unichain";
4650
+ id: 2741;
4651
+ name: "Abstract";
3880
4652
  nativeCurrency: {
3881
- readonly name: "Ether";
3882
- readonly symbol: "ETH";
3883
4653
  readonly decimals: 18;
4654
+ readonly name: "ETH";
4655
+ readonly symbol: "ETH";
3884
4656
  };
3885
4657
  experimental_preconfirmationTime?: number | undefined | undefined;
3886
4658
  rpcUrls: {
3887
4659
  readonly default: {
3888
- readonly http: readonly ["https://mainnet.unichain.org/"];
4660
+ readonly http: readonly ["https://api.mainnet.abs.xyz"];
4661
+ readonly webSocket: readonly ["wss://api.mainnet.abs.xyz/ws"];
3889
4662
  };
3890
4663
  };
3891
- sourceId: 1;
4664
+ sourceId?: number | undefined | undefined;
3892
4665
  testnet?: boolean | undefined | undefined;
3893
- custom?: Record<string, unknown> | undefined;
4666
+ custom: {
4667
+ readonly getEip712Domain: import("viem/zksync").EIP712DomainFn<import("viem/chains").ZkSyncTransactionSerializable, import("viem/chains").ZkSyncEIP712TransactionSignable>;
4668
+ };
3894
4669
  extendSchema?: Record<string, unknown> | undefined;
3895
4670
  fees?: import("viem").ChainFees<undefined> | undefined;
3896
4671
  formatters: {
3897
4672
  readonly block: {
3898
4673
  exclude: [] | undefined;
3899
- format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
4674
+ format: (args: import("viem/chains").ZkSyncRpcBlock, action?: string | undefined) => {
3900
4675
  baseFeePerGas: bigint | null;
3901
4676
  blobGasUsed: bigint;
3902
4677
  difficulty: bigint;
@@ -3919,41 +4694,19 @@ declare const chains: ({
3919
4694
  stateRoot: import("viem").Hash;
3920
4695
  timestamp: bigint;
3921
4696
  totalDifficulty: bigint | null;
3922
- transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
4697
+ transactions: `0x${string}`[] | import("viem/chains").ZkSyncTransaction<boolean>[];
3923
4698
  transactionsRoot: import("viem").Hash;
3924
4699
  uncles: import("viem").Hash[];
3925
4700
  withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
3926
4701
  withdrawalsRoot?: `0x${string}` | undefined;
4702
+ l1BatchNumber: bigint | null;
4703
+ l1BatchTimestamp: bigint | null;
3927
4704
  } & {};
3928
4705
  type: "block";
3929
4706
  };
3930
4707
  readonly transaction: {
3931
4708
  exclude: [] | undefined;
3932
- format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
3933
- blockHash: `0x${string}` | null;
3934
- blockNumber: bigint | null;
3935
- from: import("abitype").Address;
3936
- gas: bigint;
3937
- hash: import("viem").Hash;
3938
- input: import("viem").Hex;
3939
- nonce: number;
3940
- r: import("viem").Hex;
3941
- s: import("viem").Hex;
3942
- to: import("abitype").Address | null;
3943
- transactionIndex: number | null;
3944
- typeHex: import("viem").Hex | null;
3945
- v: bigint;
3946
- value: bigint;
3947
- yParity: number;
3948
- gasPrice?: undefined | undefined;
3949
- maxFeePerBlobGas?: undefined | undefined;
3950
- maxFeePerGas: bigint;
3951
- maxPriorityFeePerGas: bigint;
3952
- isSystemTx?: boolean;
3953
- mint?: bigint | undefined | undefined;
3954
- sourceHash: import("viem").Hex;
3955
- type: "deposit";
3956
- } | {
4709
+ format: (args: import("viem/chains").ZkSyncRpcTransaction, action?: string | undefined) => ({
3957
4710
  r: import("viem").Hex;
3958
4711
  s: import("viem").Hex;
3959
4712
  v: bigint;
@@ -3978,9 +4731,8 @@ declare const chains: ({
3978
4731
  maxFeePerBlobGas?: undefined | undefined;
3979
4732
  maxFeePerGas?: undefined | undefined;
3980
4733
  maxPriorityFeePerGas?: undefined | undefined;
3981
- isSystemTx?: undefined | undefined;
3982
- mint?: undefined | undefined;
3983
- sourceHash?: undefined | undefined;
4734
+ l1BatchNumber: bigint | null;
4735
+ l1BatchTxIndex: bigint | null;
3984
4736
  } | {
3985
4737
  blockHash: `0x${string}` | null;
3986
4738
  blockNumber: bigint | null;
@@ -4006,9 +4758,8 @@ declare const chains: ({
4006
4758
  maxFeePerBlobGas?: undefined | undefined;
4007
4759
  maxFeePerGas?: undefined | undefined;
4008
4760
  maxPriorityFeePerGas?: undefined | undefined;
4009
- isSystemTx?: undefined | undefined;
4010
- mint?: undefined | undefined;
4011
- sourceHash?: undefined | undefined;
4761
+ l1BatchNumber: bigint | null;
4762
+ l1BatchTxIndex: bigint | null;
4012
4763
  } | {
4013
4764
  blockHash: `0x${string}` | null;
4014
4765
  blockNumber: bigint | null;
@@ -4034,9 +4785,8 @@ declare const chains: ({
4034
4785
  maxFeePerBlobGas?: undefined | undefined;
4035
4786
  maxFeePerGas: bigint;
4036
4787
  maxPriorityFeePerGas: bigint;
4037
- isSystemTx?: undefined | undefined;
4038
- mint?: undefined | undefined;
4039
- sourceHash?: undefined | undefined;
4788
+ l1BatchNumber: bigint | null;
4789
+ l1BatchTxIndex: bigint | null;
4040
4790
  } | {
4041
4791
  blockHash: `0x${string}` | null;
4042
4792
  blockNumber: bigint | null;
@@ -4062,9 +4812,8 @@ declare const chains: ({
4062
4812
  maxFeePerBlobGas: bigint;
4063
4813
  maxFeePerGas: bigint;
4064
4814
  maxPriorityFeePerGas: bigint;
4065
- isSystemTx?: undefined | undefined;
4066
- mint?: undefined | undefined;
4067
- sourceHash?: undefined | undefined;
4815
+ l1BatchNumber: bigint | null;
4816
+ l1BatchTxIndex: bigint | null;
4068
4817
  } | {
4069
4818
  blockHash: `0x${string}` | null;
4070
4819
  blockNumber: bigint | null;
@@ -4090,39 +4839,221 @@ declare const chains: ({
4090
4839
  maxFeePerBlobGas?: undefined | undefined;
4091
4840
  maxFeePerGas: bigint;
4092
4841
  maxPriorityFeePerGas: bigint;
4093
- isSystemTx?: undefined | undefined;
4094
- mint?: undefined | undefined;
4095
- sourceHash?: undefined | undefined;
4842
+ l1BatchNumber: bigint | null;
4843
+ l1BatchTxIndex: bigint | null;
4844
+ } | {
4845
+ blockHash: `0x${string}` | null;
4846
+ blockNumber: bigint | null;
4847
+ from: import("abitype").Address;
4848
+ gas: bigint;
4849
+ hash: import("viem").Hash;
4850
+ input: import("viem").Hex;
4851
+ nonce: number;
4852
+ r: import("viem").Hex;
4853
+ s: import("viem").Hex;
4854
+ to: import("abitype").Address | null;
4855
+ transactionIndex: number | null;
4856
+ typeHex: import("viem").Hex | null;
4857
+ v: bigint;
4858
+ value: bigint;
4859
+ yParity: number;
4860
+ l1BatchNumber: bigint | null;
4861
+ l1BatchTxIndex: bigint | null;
4862
+ gasPrice?: undefined | undefined;
4863
+ maxFeePerBlobGas?: undefined | undefined;
4864
+ maxFeePerGas: bigint;
4865
+ maxPriorityFeePerGas: bigint;
4866
+ type: "priority";
4867
+ } | {
4868
+ blockHash: `0x${string}` | null;
4869
+ blockNumber: bigint | null;
4870
+ from: import("abitype").Address;
4871
+ gas: bigint;
4872
+ hash: import("viem").Hash;
4873
+ input: import("viem").Hex;
4874
+ nonce: number;
4875
+ r: import("viem").Hex;
4876
+ s: import("viem").Hex;
4877
+ to: import("abitype").Address | null;
4878
+ transactionIndex: number | null;
4879
+ typeHex: import("viem").Hex | null;
4880
+ v: bigint;
4881
+ value: bigint;
4882
+ yParity: number;
4883
+ l1BatchNumber: bigint | null;
4884
+ l1BatchTxIndex: bigint | null;
4885
+ gasPrice?: undefined | undefined;
4886
+ maxFeePerBlobGas?: undefined | undefined;
4887
+ maxFeePerGas: bigint;
4888
+ maxPriorityFeePerGas: bigint;
4889
+ type: "eip712" | "priority";
4096
4890
  }) & {};
4097
4891
  type: "transaction";
4098
4892
  };
4099
4893
  readonly transactionReceipt: {
4100
4894
  exclude: [] | undefined;
4101
- format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
4102
- blobGasPrice?: bigint | undefined;
4103
- blobGasUsed?: bigint | undefined;
4895
+ format: (args: import("viem/chains").ZkSyncRpcTransactionReceipt, action?: string | undefined) => {
4896
+ type: import("viem/chains").ZkSyncTransactionType;
4897
+ contractAddress: import("abitype").Address | null | undefined;
4898
+ to: import("abitype").Address | null;
4899
+ from: import("abitype").Address;
4104
4900
  blockHash: import("viem").Hash;
4105
4901
  blockNumber: bigint;
4106
- contractAddress: import("abitype").Address | null | undefined;
4902
+ transactionIndex: number;
4903
+ status: "success" | "reverted";
4904
+ transactionHash: import("viem").Hash;
4905
+ logsBloom: import("viem").Hex;
4906
+ blobGasUsed?: bigint | undefined;
4907
+ gasUsed: bigint;
4908
+ blobGasPrice?: bigint | undefined;
4107
4909
  cumulativeGasUsed: bigint;
4108
4910
  effectiveGasPrice: bigint;
4109
- from: import("abitype").Address;
4110
- gasUsed: bigint;
4111
- logs: import("viem").Log<bigint, number, false>[];
4112
- logsBloom: import("viem").Hex;
4113
4911
  root?: `0x${string}` | undefined;
4114
- status: "success" | "reverted";
4115
- to: import("abitype").Address | null;
4116
- transactionHash: import("viem").Hash;
4117
- transactionIndex: number;
4118
- type: import("viem").TransactionType;
4119
- l1GasPrice: bigint | null;
4120
- l1GasUsed: bigint | null;
4121
- l1Fee: bigint | null;
4122
- l1FeeScalar: number | null;
4912
+ l1BatchNumber: bigint | null;
4913
+ l1BatchTxIndex: bigint | null;
4914
+ logs: import("viem/chains").ZkSyncLog[];
4915
+ l2ToL1Logs: import("viem/chains").ZkSyncL2ToL1Log[];
4123
4916
  } & {};
4124
4917
  type: "transactionReceipt";
4125
4918
  };
4919
+ readonly transactionRequest: {
4920
+ exclude: ("paymaster" | "gasPerPubdata" | "factoryDeps" | "paymasterInput" | "customSignature")[] | undefined;
4921
+ format: (args: import("viem/chains").ZkSyncTransactionRequest, action?: string | undefined) => ({
4922
+ data?: `0x${string}` | undefined;
4923
+ from?: `0x${string}` | undefined;
4924
+ gas?: `0x${string}` | undefined;
4925
+ nonce?: `0x${string}` | undefined;
4926
+ to?: `0x${string}` | null | undefined;
4927
+ type?: "0x0" | undefined;
4928
+ value?: `0x${string}` | undefined;
4929
+ gasPrice?: `0x${string}` | undefined;
4930
+ maxFeePerBlobGas?: undefined | undefined;
4931
+ maxFeePerGas?: undefined | undefined;
4932
+ maxPriorityFeePerGas?: undefined | undefined;
4933
+ blobs?: undefined;
4934
+ blobVersionedHashes?: undefined;
4935
+ kzg?: undefined;
4936
+ accessList?: undefined;
4937
+ sidecars?: undefined;
4938
+ authorizationList?: undefined;
4939
+ eip712Meta?: undefined | undefined;
4940
+ } | {
4941
+ data?: `0x${string}` | undefined;
4942
+ from?: `0x${string}` | undefined;
4943
+ gas?: `0x${string}` | undefined;
4944
+ nonce?: `0x${string}` | undefined;
4945
+ to?: `0x${string}` | null | undefined;
4946
+ type?: "0x1" | undefined;
4947
+ value?: `0x${string}` | undefined;
4948
+ gasPrice?: `0x${string}` | undefined;
4949
+ maxFeePerBlobGas?: undefined | undefined;
4950
+ maxFeePerGas?: undefined | undefined;
4951
+ maxPriorityFeePerGas?: undefined | undefined;
4952
+ accessList?: import("viem").AccessList | undefined;
4953
+ blobs?: undefined;
4954
+ blobVersionedHashes?: undefined;
4955
+ kzg?: undefined;
4956
+ sidecars?: undefined;
4957
+ authorizationList?: undefined;
4958
+ eip712Meta?: undefined | undefined;
4959
+ } | {
4960
+ data?: `0x${string}` | undefined;
4961
+ from?: `0x${string}` | undefined;
4962
+ gas?: `0x${string}` | undefined;
4963
+ nonce?: `0x${string}` | undefined;
4964
+ to?: `0x${string}` | null | undefined;
4965
+ type?: "0x2" | undefined;
4966
+ value?: `0x${string}` | undefined;
4967
+ gasPrice?: undefined | undefined;
4968
+ maxFeePerBlobGas?: undefined | undefined;
4969
+ maxFeePerGas?: `0x${string}` | undefined;
4970
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
4971
+ accessList?: import("viem").AccessList | undefined;
4972
+ blobs?: undefined;
4973
+ blobVersionedHashes?: undefined;
4974
+ kzg?: undefined;
4975
+ sidecars?: undefined;
4976
+ authorizationList?: undefined;
4977
+ eip712Meta?: undefined | undefined;
4978
+ } | {
4979
+ type?: "0x3" | undefined;
4980
+ data?: `0x${string}` | undefined;
4981
+ from?: `0x${string}` | undefined;
4982
+ gas?: `0x${string}` | undefined;
4983
+ nonce?: `0x${string}` | undefined;
4984
+ value?: `0x${string}` | undefined;
4985
+ to: `0x${string}` | null;
4986
+ gasPrice?: undefined | undefined;
4987
+ maxFeePerBlobGas?: `0x${string}` | undefined;
4988
+ maxFeePerGas?: `0x${string}` | undefined;
4989
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
4990
+ accessList?: import("viem").AccessList | undefined;
4991
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
4992
+ blobs?: readonly `0x${string}`[] | readonly import("viem").ByteArray[] | undefined;
4993
+ blobVersionedHashes: readonly import("viem").Hex[];
4994
+ kzg?: undefined;
4995
+ authorizationList?: undefined;
4996
+ eip712Meta?: undefined | undefined;
4997
+ } | {
4998
+ type?: "0x3" | undefined;
4999
+ data?: `0x${string}` | undefined;
5000
+ from?: `0x${string}` | undefined;
5001
+ gas?: `0x${string}` | undefined;
5002
+ nonce?: `0x${string}` | undefined;
5003
+ value?: `0x${string}` | undefined;
5004
+ to: `0x${string}` | null;
5005
+ gasPrice?: undefined | undefined;
5006
+ maxFeePerBlobGas?: `0x${string}` | undefined;
5007
+ maxFeePerGas?: `0x${string}` | undefined;
5008
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5009
+ accessList?: import("viem").AccessList | undefined;
5010
+ sidecars?: readonly import("viem").BlobSidecar<`0x${string}`>[] | undefined;
5011
+ blobs: readonly import("viem").Hex[] | readonly import("viem").ByteArray[];
5012
+ blobVersionedHashes?: readonly `0x${string}`[] | undefined;
5013
+ kzg?: import("viem").Kzg | undefined;
5014
+ authorizationList?: undefined;
5015
+ eip712Meta?: undefined | undefined;
5016
+ } | {
5017
+ type?: "0x4" | undefined;
5018
+ gasPrice?: undefined | undefined;
5019
+ maxFeePerBlobGas?: undefined | undefined;
5020
+ maxFeePerGas?: `0x${string}` | undefined;
5021
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5022
+ to?: `0x${string}` | null | undefined;
5023
+ data?: `0x${string}` | undefined;
5024
+ from?: `0x${string}` | undefined;
5025
+ gas?: `0x${string}` | undefined;
5026
+ nonce?: `0x${string}` | undefined;
5027
+ value?: `0x${string}` | undefined;
5028
+ accessList?: import("viem").AccessList | undefined;
5029
+ authorizationList?: import("viem").RpcAuthorizationList | undefined;
5030
+ blobs?: undefined;
5031
+ blobVersionedHashes?: undefined;
5032
+ kzg?: undefined;
5033
+ sidecars?: undefined;
5034
+ eip712Meta?: undefined | undefined;
5035
+ } | {
5036
+ data?: `0x${string}` | undefined;
5037
+ from?: `0x${string}` | undefined;
5038
+ gas?: `0x${string}` | undefined;
5039
+ nonce?: `0x${string}` | undefined;
5040
+ to?: `0x${string}` | null | undefined;
5041
+ type: "0xff" | "0x71";
5042
+ value?: `0x${string}` | undefined;
5043
+ gasPrice?: undefined | undefined;
5044
+ maxFeePerBlobGas?: undefined | undefined;
5045
+ maxFeePerGas?: `0x${string}` | undefined;
5046
+ maxPriorityFeePerGas?: `0x${string}` | undefined;
5047
+ eip712Meta: import("viem/chains").ZkSyncEip712Meta;
5048
+ }) & {
5049
+ paymaster: never;
5050
+ gasPerPubdata: never;
5051
+ factoryDeps: never;
5052
+ paymasterInput: never;
5053
+ customSignature: never;
5054
+ };
5055
+ type: "transactionRequest";
5056
+ };
4126
5057
  };
4127
5058
  prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4128
5059
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
@@ -4132,56 +5063,9 @@ declare const chains: ({
4132
5063
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4133
5064
  }] | undefined;
4134
5065
  serializers: {
4135
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
4136
- };
4137
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4138
- } | {
4139
- blockExplorers: {
4140
- readonly default: {
4141
- readonly name: "katana explorer";
4142
- readonly url: "https://katanascan.com";
4143
- };
4144
- };
4145
- blockTime?: number | undefined | undefined;
4146
- contracts?: {
4147
- [x: string]: import("viem").ChainContract | {
4148
- [sourceId: number]: import("viem").ChainContract | undefined;
4149
- } | undefined;
4150
- ensRegistry?: import("viem").ChainContract | undefined;
4151
- ensUniversalResolver?: import("viem").ChainContract | undefined;
4152
- multicall3?: import("viem").ChainContract | undefined;
4153
- erc6492Verifier?: import("viem").ChainContract | undefined;
4154
- } | undefined;
4155
- ensTlds?: readonly string[] | undefined;
4156
- id: 747474;
4157
- name: "Katana";
4158
- nativeCurrency: {
4159
- readonly name: "Ether";
4160
- readonly symbol: "ETH";
4161
- readonly decimals: 18;
4162
- };
4163
- experimental_preconfirmationTime?: number | undefined | undefined;
4164
- rpcUrls: {
4165
- readonly default: {
4166
- readonly http: readonly ["https://rpc.katana.network"];
4167
- };
5066
+ readonly transaction: typeof import("viem/zksync").serializeTransaction;
4168
5067
  };
4169
- sourceId?: number | undefined | undefined;
4170
- testnet: false;
4171
- custom?: Record<string, unknown> | undefined;
4172
- extendSchema?: Record<string, unknown> | undefined;
4173
- fees?: import("viem").ChainFees<undefined> | undefined;
4174
- formatters?: undefined;
4175
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4176
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4177
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4178
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4179
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4180
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4181
- }] | undefined;
4182
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4183
5068
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4184
- readonly network: "katana";
4185
5069
  } | {
4186
5070
  blockExplorers: {
4187
5071
  readonly default: {
@@ -4965,7 +5849,8 @@ declare enum MainnetNetwork {
4965
5849
  UNICHAIN,
4966
5850
  SOLANA = 792703809,
4967
5851
  TRON = 728126428,
4968
- KATANA
5852
+ KATANA,
5853
+ ABSTRACT
4969
5854
  }
4970
5855
  declare enum TestnetNetwork {
4971
5856
  ETHEREUM_SEPOLIA,