@steerprotocol/liquidity-meter 1.0.0

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 (24) hide show
  1. package/README.md +207 -0
  2. package/dist/adapters/onchain.d.ts +51 -0
  3. package/dist/adapters/onchain.js +158 -0
  4. package/dist/adapters/uniswapv3-subgraph.d.ts +44 -0
  5. package/dist/adapters/uniswapv3-subgraph.js +105 -0
  6. package/dist/adapters/withdraw.d.ts +14 -0
  7. package/dist/adapters/withdraw.js +150 -0
  8. package/dist/api.d.ts +72 -0
  9. package/dist/api.js +180 -0
  10. package/dist/cli/liquidity-depth.d.ts +2 -0
  11. package/dist/cli/liquidity-depth.js +1160 -0
  12. package/dist/core/depth.d.ts +48 -0
  13. package/dist/core/depth.js +314 -0
  14. package/dist/handlers/cron.d.ts +27 -0
  15. package/dist/handlers/cron.js +68 -0
  16. package/dist/index.d.ts +7 -0
  17. package/dist/index.js +7 -0
  18. package/dist/prices.d.ts +15 -0
  19. package/dist/prices.js +205 -0
  20. package/dist/wagmi/config.d.ts +2106 -0
  21. package/dist/wagmi/config.js +24 -0
  22. package/dist/wagmi/generated.d.ts +2019 -0
  23. package/dist/wagmi/generated.js +346 -0
  24. package/package.json +47 -0
package/dist/wagmi/config.d.ts ADDED
@@ -0,0 +1,2106 @@
1
+ import { getClient, getConnectorClient } from '@wagmi/core';
2
+ export declare const defaultConfig: import("@wagmi/core").Config<readonly [{
3
+ blockExplorers: {
4
+ readonly default: {
5
+ readonly name: "Etherscan";
6
+ readonly url: "https://etherscan.io";
7
+ readonly apiUrl: "https://api.etherscan.io/api";
8
+ };
9
+ };
10
+ blockTime: 12000;
11
+ contracts: {
12
+ readonly ensRegistry: {
13
+ readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
14
+ };
15
+ readonly ensUniversalResolver: {
16
+ readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
17
+ readonly blockCreated: 19258213;
18
+ };
19
+ readonly multicall3: {
20
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
21
+ readonly blockCreated: 14353601;
22
+ };
23
+ };
24
+ ensTlds?: readonly string[] | undefined;
25
+ id: 1;
26
+ name: "Ethereum";
27
+ nativeCurrency: {
28
+ readonly name: "Ether";
29
+ readonly symbol: "ETH";
30
+ readonly decimals: 18;
31
+ };
32
+ experimental_preconfirmationTime?: number | undefined | undefined;
33
+ rpcUrls: {
34
+ readonly default: {
35
+ readonly http: readonly ["https://eth.merkle.io"];
36
+ };
37
+ };
38
+ sourceId?: number | undefined | undefined;
39
+ testnet?: boolean | undefined | undefined;
40
+ custom?: Record<string, unknown> | undefined;
41
+ fees?: import("viem").ChainFees<undefined> | undefined;
42
+ formatters?: undefined;
43
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
44
+ }, {
45
+ blockExplorers: {
46
+ readonly default: {
47
+ readonly name: "Basescan";
48
+ readonly url: "https://basescan.org";
49
+ readonly apiUrl: "https://api.basescan.org/api";
50
+ };
51
+ };
52
+ blockTime: 2000;
53
+ contracts: {
54
+ readonly disputeGameFactory: {
55
+ readonly 1: {
56
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
57
+ };
58
+ };
59
+ readonly l2OutputOracle: {
60
+ readonly 1: {
61
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
62
+ };
63
+ };
64
+ readonly multicall3: {
65
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
66
+ readonly blockCreated: 5022;
67
+ };
68
+ readonly portal: {
69
+ readonly 1: {
70
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
71
+ readonly blockCreated: 17482143;
72
+ };
73
+ };
74
+ readonly l1StandardBridge: {
75
+ readonly 1: {
76
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
77
+ readonly blockCreated: 17482143;
78
+ };
79
+ };
80
+ readonly gasPriceOracle: {
81
+ readonly address: "0x420000000000000000000000000000000000000F";
82
+ };
83
+ readonly l1Block: {
84
+ readonly address: "0x4200000000000000000000000000000000000015";
85
+ };
86
+ readonly l2CrossDomainMessenger: {
87
+ readonly address: "0x4200000000000000000000000000000000000007";
88
+ };
89
+ readonly l2Erc721Bridge: {
90
+ readonly address: "0x4200000000000000000000000000000000000014";
91
+ };
92
+ readonly l2StandardBridge: {
93
+ readonly address: "0x4200000000000000000000000000000000000010";
94
+ };
95
+ readonly l2ToL1MessagePasser: {
96
+ readonly address: "0x4200000000000000000000000000000000000016";
97
+ };
98
+ };
99
+ ensTlds?: readonly string[] | undefined;
100
+ id: 8453;
101
+ name: "Base";
102
+ nativeCurrency: {
103
+ readonly name: "Ether";
104
+ readonly symbol: "ETH";
105
+ readonly decimals: 18;
106
+ };
107
+ experimental_preconfirmationTime?: number | undefined | undefined;
108
+ rpcUrls: {
109
+ readonly default: {
110
+ readonly http: readonly ["https://mainnet.base.org"];
111
+ };
112
+ };
113
+ sourceId: 1;
114
+ testnet?: boolean | undefined | undefined;
115
+ custom?: Record<string, unknown> | undefined;
116
+ fees?: import("viem").ChainFees<undefined> | undefined;
117
+ formatters: {
118
+ readonly block: {
119
+ exclude: [] | undefined;
120
+ format: (args: import("@wagmi/core/chains").OpStackRpcBlock) => {
121
+ baseFeePerGas: bigint | null;
122
+ blobGasUsed: bigint;
123
+ difficulty: bigint;
124
+ excessBlobGas: bigint;
125
+ extraData: import("viem").Hex;
126
+ gasLimit: bigint;
127
+ gasUsed: bigint;
128
+ hash: `0x${string}` | null;
129
+ logsBloom: `0x${string}` | null;
130
+ miner: import("viem").Address;
131
+ mixHash: import("viem").Hash;
132
+ nonce: `0x${string}` | null;
133
+ number: bigint | null;
134
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
135
+ parentHash: import("viem").Hash;
136
+ receiptsRoot: import("viem").Hex;
137
+ sealFields: import("viem").Hex[];
138
+ sha3Uncles: import("viem").Hash;
139
+ size: bigint;
140
+ stateRoot: import("viem").Hash;
141
+ timestamp: bigint;
142
+ totalDifficulty: bigint | null;
143
+ transactions: `0x${string}`[] | import("@wagmi/core/chains").OpStackTransaction<boolean>[];
144
+ transactionsRoot: import("viem").Hash;
145
+ uncles: import("viem").Hash[];
146
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
147
+ withdrawalsRoot?: `0x${string}` | undefined;
148
+ } & {};
149
+ type: "block";
150
+ };
151
+ readonly transaction: {
152
+ exclude: [] | undefined;
153
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransaction) => ({
154
+ blockHash: `0x${string}` | null;
155
+ blockNumber: bigint | null;
156
+ from: import("viem").Address;
157
+ gas: bigint;
158
+ hash: import("viem").Hash;
159
+ input: import("viem").Hex;
160
+ nonce: number;
161
+ r: import("viem").Hex;
162
+ s: import("viem").Hex;
163
+ to: import("viem").Address | null;
164
+ transactionIndex: number | null;
165
+ typeHex: import("viem").Hex | null;
166
+ v: bigint;
167
+ value: bigint;
168
+ yParity: number;
169
+ gasPrice?: undefined | undefined;
170
+ maxFeePerBlobGas?: undefined | undefined;
171
+ maxFeePerGas: bigint;
172
+ maxPriorityFeePerGas: bigint;
173
+ isSystemTx?: boolean;
174
+ mint?: bigint | undefined | undefined;
175
+ sourceHash: import("viem").Hex;
176
+ type: "deposit";
177
+ } | {
178
+ r: import("viem").Hex;
179
+ s: import("viem").Hex;
180
+ v: bigint;
181
+ to: import("viem").Address | null;
182
+ from: import("viem").Address;
183
+ gas: bigint;
184
+ nonce: number;
185
+ value: bigint;
186
+ blockHash: `0x${string}` | null;
187
+ blockNumber: bigint | null;
188
+ hash: import("viem").Hash;
189
+ input: import("viem").Hex;
190
+ transactionIndex: number | null;
191
+ typeHex: import("viem").Hex | null;
192
+ accessList?: undefined | undefined;
193
+ authorizationList?: undefined | undefined;
194
+ blobVersionedHashes?: undefined | undefined;
195
+ chainId?: number | undefined;
196
+ yParity?: undefined | undefined;
197
+ type: "legacy";
198
+ gasPrice: bigint;
199
+ maxFeePerBlobGas?: undefined | undefined;
200
+ maxFeePerGas?: undefined | undefined;
201
+ maxPriorityFeePerGas?: undefined | undefined;
202
+ isSystemTx?: undefined | undefined;
203
+ mint?: undefined | undefined;
204
+ sourceHash?: undefined | undefined;
205
+ } | {
206
+ blockHash: `0x${string}` | null;
207
+ blockNumber: bigint | null;
208
+ from: import("viem").Address;
209
+ gas: bigint;
210
+ hash: import("viem").Hash;
211
+ input: import("viem").Hex;
212
+ nonce: number;
213
+ r: import("viem").Hex;
214
+ s: import("viem").Hex;
215
+ to: import("viem").Address | null;
216
+ transactionIndex: number | null;
217
+ typeHex: import("viem").Hex | null;
218
+ v: bigint;
219
+ value: bigint;
220
+ yParity: number;
221
+ accessList: import("viem").AccessList;
222
+ authorizationList?: undefined | undefined;
223
+ blobVersionedHashes?: undefined | undefined;
224
+ chainId: number;
225
+ type: "eip2930";
226
+ gasPrice: bigint;
227
+ maxFeePerBlobGas?: undefined | undefined;
228
+ maxFeePerGas?: undefined | undefined;
229
+ maxPriorityFeePerGas?: undefined | undefined;
230
+ isSystemTx?: undefined | undefined;
231
+ mint?: undefined | undefined;
232
+ sourceHash?: undefined | undefined;
233
+ } | {
234
+ blockHash: `0x${string}` | null;
235
+ blockNumber: bigint | null;
236
+ from: import("viem").Address;
237
+ gas: bigint;
238
+ hash: import("viem").Hash;
239
+ input: import("viem").Hex;
240
+ nonce: number;
241
+ r: import("viem").Hex;
242
+ s: import("viem").Hex;
243
+ to: import("viem").Address | null;
244
+ transactionIndex: number | null;
245
+ typeHex: import("viem").Hex | null;
246
+ v: bigint;
247
+ value: bigint;
248
+ yParity: number;
249
+ accessList: import("viem").AccessList;
250
+ authorizationList?: undefined | undefined;
251
+ blobVersionedHashes?: undefined | undefined;
252
+ chainId: number;
253
+ type: "eip1559";
254
+ gasPrice?: undefined | undefined;
255
+ maxFeePerBlobGas?: undefined | undefined;
256
+ maxFeePerGas: bigint;
257
+ maxPriorityFeePerGas: bigint;
258
+ isSystemTx?: undefined | undefined;
259
+ mint?: undefined | undefined;
260
+ sourceHash?: undefined | undefined;
261
+ } | {
262
+ blockHash: `0x${string}` | null;
263
+ blockNumber: bigint | null;
264
+ from: import("viem").Address;
265
+ gas: bigint;
266
+ hash: import("viem").Hash;
267
+ input: import("viem").Hex;
268
+ nonce: number;
269
+ r: import("viem").Hex;
270
+ s: import("viem").Hex;
271
+ to: import("viem").Address | null;
272
+ transactionIndex: number | null;
273
+ typeHex: import("viem").Hex | null;
274
+ v: bigint;
275
+ value: bigint;
276
+ yParity: number;
277
+ accessList: import("viem").AccessList;
278
+ authorizationList?: undefined | undefined;
279
+ blobVersionedHashes: readonly import("viem").Hex[];
280
+ chainId: number;
281
+ type: "eip4844";
282
+ gasPrice?: undefined | undefined;
283
+ maxFeePerBlobGas: bigint;
284
+ maxFeePerGas: bigint;
285
+ maxPriorityFeePerGas: bigint;
286
+ isSystemTx?: undefined | undefined;
287
+ mint?: undefined | undefined;
288
+ sourceHash?: undefined | undefined;
289
+ } | {
290
+ blockHash: `0x${string}` | null;
291
+ blockNumber: bigint | null;
292
+ from: import("viem").Address;
293
+ gas: bigint;
294
+ hash: import("viem").Hash;
295
+ input: import("viem").Hex;
296
+ nonce: number;
297
+ r: import("viem").Hex;
298
+ s: import("viem").Hex;
299
+ to: import("viem").Address | null;
300
+ transactionIndex: number | null;
301
+ typeHex: import("viem").Hex | null;
302
+ v: bigint;
303
+ value: bigint;
304
+ yParity: number;
305
+ accessList: import("viem").AccessList;
306
+ authorizationList: import("viem").SignedAuthorizationList;
307
+ blobVersionedHashes?: undefined | undefined;
308
+ chainId: number;
309
+ type: "eip7702";
310
+ gasPrice?: undefined | undefined;
311
+ maxFeePerBlobGas?: undefined | undefined;
312
+ maxFeePerGas: bigint;
313
+ maxPriorityFeePerGas: bigint;
314
+ isSystemTx?: undefined | undefined;
315
+ mint?: undefined | undefined;
316
+ sourceHash?: undefined | undefined;
317
+ }) & {};
318
+ type: "transaction";
319
+ };
320
+ readonly transactionReceipt: {
321
+ exclude: [] | undefined;
322
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransactionReceipt) => {
323
+ blobGasPrice?: bigint | undefined;
324
+ blobGasUsed?: bigint | undefined;
325
+ blockHash: import("viem").Hash;
326
+ blockNumber: bigint;
327
+ contractAddress: import("viem").Address | null | undefined;
328
+ cumulativeGasUsed: bigint;
329
+ effectiveGasPrice: bigint;
330
+ from: import("viem").Address;
331
+ gasUsed: bigint;
332
+ logs: import("viem").Log<bigint, number, false>[];
333
+ logsBloom: import("viem").Hex;
334
+ root?: `0x${string}` | undefined;
335
+ status: "success" | "reverted";
336
+ to: import("viem").Address | null;
337
+ transactionHash: import("viem").Hash;
338
+ transactionIndex: number;
339
+ type: import("viem").TransactionType;
340
+ l1GasPrice: bigint | null;
341
+ l1GasUsed: bigint | null;
342
+ l1Fee: bigint | null;
343
+ l1FeeScalar: number | null;
344
+ } & {};
345
+ type: "transactionReceipt";
346
+ };
347
+ };
348
+ serializers: {
349
+ readonly transaction: typeof import("@wagmi/core/chains").serializeTransactionOpStack;
350
+ };
351
+ }, {
352
+ blockExplorers: {
353
+ readonly default: {
354
+ readonly name: "Optimism Explorer";
355
+ readonly url: "https://optimistic.etherscan.io";
356
+ readonly apiUrl: "https://api-optimistic.etherscan.io/api";
357
+ };
358
+ };
359
+ blockTime: 2000;
360
+ contracts: {
361
+ readonly disputeGameFactory: {
362
+ readonly 1: {
363
+ readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
364
+ };
365
+ };
366
+ readonly l2OutputOracle: {
367
+ readonly 1: {
368
+ readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
369
+ };
370
+ };
371
+ readonly multicall3: {
372
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
373
+ readonly blockCreated: 4286263;
374
+ };
375
+ readonly portal: {
376
+ readonly 1: {
377
+ readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
378
+ };
379
+ };
380
+ readonly l1StandardBridge: {
381
+ readonly 1: {
382
+ readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
383
+ };
384
+ };
385
+ readonly gasPriceOracle: {
386
+ readonly address: "0x420000000000000000000000000000000000000F";
387
+ };
388
+ readonly l1Block: {
389
+ readonly address: "0x4200000000000000000000000000000000000015";
390
+ };
391
+ readonly l2CrossDomainMessenger: {
392
+ readonly address: "0x4200000000000000000000000000000000000007";
393
+ };
394
+ readonly l2Erc721Bridge: {
395
+ readonly address: "0x4200000000000000000000000000000000000014";
396
+ };
397
+ readonly l2StandardBridge: {
398
+ readonly address: "0x4200000000000000000000000000000000000010";
399
+ };
400
+ readonly l2ToL1MessagePasser: {
401
+ readonly address: "0x4200000000000000000000000000000000000016";
402
+ };
403
+ };
404
+ ensTlds?: readonly string[] | undefined;
405
+ id: 10;
406
+ name: "OP Mainnet";
407
+ nativeCurrency: {
408
+ readonly name: "Ether";
409
+ readonly symbol: "ETH";
410
+ readonly decimals: 18;
411
+ };
412
+ experimental_preconfirmationTime?: number | undefined | undefined;
413
+ rpcUrls: {
414
+ readonly default: {
415
+ readonly http: readonly ["https://mainnet.optimism.io"];
416
+ };
417
+ };
418
+ sourceId: 1;
419
+ testnet?: boolean | undefined | undefined;
420
+ custom?: Record<string, unknown> | undefined;
421
+ fees?: import("viem").ChainFees<undefined> | undefined;
422
+ formatters: {
423
+ readonly block: {
424
+ exclude: [] | undefined;
425
+ format: (args: import("@wagmi/core/chains").OpStackRpcBlock) => {
426
+ baseFeePerGas: bigint | null;
427
+ blobGasUsed: bigint;
428
+ difficulty: bigint;
429
+ excessBlobGas: bigint;
430
+ extraData: import("viem").Hex;
431
+ gasLimit: bigint;
432
+ gasUsed: bigint;
433
+ hash: `0x${string}` | null;
434
+ logsBloom: `0x${string}` | null;
435
+ miner: import("viem").Address;
436
+ mixHash: import("viem").Hash;
437
+ nonce: `0x${string}` | null;
438
+ number: bigint | null;
439
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
440
+ parentHash: import("viem").Hash;
441
+ receiptsRoot: import("viem").Hex;
442
+ sealFields: import("viem").Hex[];
443
+ sha3Uncles: import("viem").Hash;
444
+ size: bigint;
445
+ stateRoot: import("viem").Hash;
446
+ timestamp: bigint;
447
+ totalDifficulty: bigint | null;
448
+ transactions: `0x${string}`[] | import("@wagmi/core/chains").OpStackTransaction<boolean>[];
449
+ transactionsRoot: import("viem").Hash;
450
+ uncles: import("viem").Hash[];
451
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
452
+ withdrawalsRoot?: `0x${string}` | undefined;
453
+ } & {};
454
+ type: "block";
455
+ };
456
+ readonly transaction: {
457
+ exclude: [] | undefined;
458
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransaction) => ({
459
+ blockHash: `0x${string}` | null;
460
+ blockNumber: bigint | null;
461
+ from: import("viem").Address;
462
+ gas: bigint;
463
+ hash: import("viem").Hash;
464
+ input: import("viem").Hex;
465
+ nonce: number;
466
+ r: import("viem").Hex;
467
+ s: import("viem").Hex;
468
+ to: import("viem").Address | null;
469
+ transactionIndex: number | null;
470
+ typeHex: import("viem").Hex | null;
471
+ v: bigint;
472
+ value: bigint;
473
+ yParity: number;
474
+ gasPrice?: undefined | undefined;
475
+ maxFeePerBlobGas?: undefined | undefined;
476
+ maxFeePerGas: bigint;
477
+ maxPriorityFeePerGas: bigint;
478
+ isSystemTx?: boolean;
479
+ mint?: bigint | undefined | undefined;
480
+ sourceHash: import("viem").Hex;
481
+ type: "deposit";
482
+ } | {
483
+ r: import("viem").Hex;
484
+ s: import("viem").Hex;
485
+ v: bigint;
486
+ to: import("viem").Address | null;
487
+ from: import("viem").Address;
488
+ gas: bigint;
489
+ nonce: number;
490
+ value: bigint;
491
+ blockHash: `0x${string}` | null;
492
+ blockNumber: bigint | null;
493
+ hash: import("viem").Hash;
494
+ input: import("viem").Hex;
495
+ transactionIndex: number | null;
496
+ typeHex: import("viem").Hex | null;
497
+ accessList?: undefined | undefined;
498
+ authorizationList?: undefined | undefined;
499
+ blobVersionedHashes?: undefined | undefined;
500
+ chainId?: number | undefined;
501
+ yParity?: undefined | undefined;
502
+ type: "legacy";
503
+ gasPrice: bigint;
504
+ maxFeePerBlobGas?: undefined | undefined;
505
+ maxFeePerGas?: undefined | undefined;
506
+ maxPriorityFeePerGas?: undefined | undefined;
507
+ isSystemTx?: undefined | undefined;
508
+ mint?: undefined | undefined;
509
+ sourceHash?: undefined | undefined;
510
+ } | {
511
+ blockHash: `0x${string}` | null;
512
+ blockNumber: bigint | null;
513
+ from: import("viem").Address;
514
+ gas: bigint;
515
+ hash: import("viem").Hash;
516
+ input: import("viem").Hex;
517
+ nonce: number;
518
+ r: import("viem").Hex;
519
+ s: import("viem").Hex;
520
+ to: import("viem").Address | null;
521
+ transactionIndex: number | null;
522
+ typeHex: import("viem").Hex | null;
523
+ v: bigint;
524
+ value: bigint;
525
+ yParity: number;
526
+ accessList: import("viem").AccessList;
527
+ authorizationList?: undefined | undefined;
528
+ blobVersionedHashes?: undefined | undefined;
529
+ chainId: number;
530
+ type: "eip2930";
531
+ gasPrice: bigint;
532
+ maxFeePerBlobGas?: undefined | undefined;
533
+ maxFeePerGas?: undefined | undefined;
534
+ maxPriorityFeePerGas?: undefined | undefined;
535
+ isSystemTx?: undefined | undefined;
536
+ mint?: undefined | undefined;
537
+ sourceHash?: undefined | undefined;
538
+ } | {
539
+ blockHash: `0x${string}` | null;
540
+ blockNumber: bigint | null;
541
+ from: import("viem").Address;
542
+ gas: bigint;
543
+ hash: import("viem").Hash;
544
+ input: import("viem").Hex;
545
+ nonce: number;
546
+ r: import("viem").Hex;
547
+ s: import("viem").Hex;
548
+ to: import("viem").Address | null;
549
+ transactionIndex: number | null;
550
+ typeHex: import("viem").Hex | null;
551
+ v: bigint;
552
+ value: bigint;
553
+ yParity: number;
554
+ accessList: import("viem").AccessList;
555
+ authorizationList?: undefined | undefined;
556
+ blobVersionedHashes?: undefined | undefined;
557
+ chainId: number;
558
+ type: "eip1559";
559
+ gasPrice?: undefined | undefined;
560
+ maxFeePerBlobGas?: undefined | undefined;
561
+ maxFeePerGas: bigint;
562
+ maxPriorityFeePerGas: bigint;
563
+ isSystemTx?: undefined | undefined;
564
+ mint?: undefined | undefined;
565
+ sourceHash?: undefined | undefined;
566
+ } | {
567
+ blockHash: `0x${string}` | null;
568
+ blockNumber: bigint | null;
569
+ from: import("viem").Address;
570
+ gas: bigint;
571
+ hash: import("viem").Hash;
572
+ input: import("viem").Hex;
573
+ nonce: number;
574
+ r: import("viem").Hex;
575
+ s: import("viem").Hex;
576
+ to: import("viem").Address | null;
577
+ transactionIndex: number | null;
578
+ typeHex: import("viem").Hex | null;
579
+ v: bigint;
580
+ value: bigint;
581
+ yParity: number;
582
+ accessList: import("viem").AccessList;
583
+ authorizationList?: undefined | undefined;
584
+ blobVersionedHashes: readonly import("viem").Hex[];
585
+ chainId: number;
586
+ type: "eip4844";
587
+ gasPrice?: undefined | undefined;
588
+ maxFeePerBlobGas: bigint;
589
+ maxFeePerGas: bigint;
590
+ maxPriorityFeePerGas: bigint;
591
+ isSystemTx?: undefined | undefined;
592
+ mint?: undefined | undefined;
593
+ sourceHash?: undefined | undefined;
594
+ } | {
595
+ blockHash: `0x${string}` | null;
596
+ blockNumber: bigint | null;
597
+ from: import("viem").Address;
598
+ gas: bigint;
599
+ hash: import("viem").Hash;
600
+ input: import("viem").Hex;
601
+ nonce: number;
602
+ r: import("viem").Hex;
603
+ s: import("viem").Hex;
604
+ to: import("viem").Address | null;
605
+ transactionIndex: number | null;
606
+ typeHex: import("viem").Hex | null;
607
+ v: bigint;
608
+ value: bigint;
609
+ yParity: number;
610
+ accessList: import("viem").AccessList;
611
+ authorizationList: import("viem").SignedAuthorizationList;
612
+ blobVersionedHashes?: undefined | undefined;
613
+ chainId: number;
614
+ type: "eip7702";
615
+ gasPrice?: undefined | undefined;
616
+ maxFeePerBlobGas?: undefined | undefined;
617
+ maxFeePerGas: bigint;
618
+ maxPriorityFeePerGas: bigint;
619
+ isSystemTx?: undefined | undefined;
620
+ mint?: undefined | undefined;
621
+ sourceHash?: undefined | undefined;
622
+ }) & {};
623
+ type: "transaction";
624
+ };
625
+ readonly transactionReceipt: {
626
+ exclude: [] | undefined;
627
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransactionReceipt) => {
628
+ blobGasPrice?: bigint | undefined;
629
+ blobGasUsed?: bigint | undefined;
630
+ blockHash: import("viem").Hash;
631
+ blockNumber: bigint;
632
+ contractAddress: import("viem").Address | null | undefined;
633
+ cumulativeGasUsed: bigint;
634
+ effectiveGasPrice: bigint;
635
+ from: import("viem").Address;
636
+ gasUsed: bigint;
637
+ logs: import("viem").Log<bigint, number, false>[];
638
+ logsBloom: import("viem").Hex;
639
+ root?: `0x${string}` | undefined;
640
+ status: "success" | "reverted";
641
+ to: import("viem").Address | null;
642
+ transactionHash: import("viem").Hash;
643
+ transactionIndex: number;
644
+ type: import("viem").TransactionType;
645
+ l1GasPrice: bigint | null;
646
+ l1GasUsed: bigint | null;
647
+ l1Fee: bigint | null;
648
+ l1FeeScalar: number | null;
649
+ } & {};
650
+ type: "transactionReceipt";
651
+ };
652
+ };
653
+ serializers: {
654
+ readonly transaction: typeof import("@wagmi/core/chains").serializeTransactionOpStack;
655
+ };
656
+ }, {
657
+ blockExplorers: {
658
+ readonly default: {
659
+ readonly name: "Arbiscan";
660
+ readonly url: "https://arbiscan.io";
661
+ readonly apiUrl: "https://api.arbiscan.io/api";
662
+ };
663
+ };
664
+ blockTime: 250;
665
+ contracts: {
666
+ readonly multicall3: {
667
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
668
+ readonly blockCreated: 7654707;
669
+ };
670
+ };
671
+ ensTlds?: readonly string[] | undefined;
672
+ id: 42161;
673
+ name: "Arbitrum One";
674
+ nativeCurrency: {
675
+ readonly name: "Ether";
676
+ readonly symbol: "ETH";
677
+ readonly decimals: 18;
678
+ };
679
+ experimental_preconfirmationTime?: number | undefined | undefined;
680
+ rpcUrls: {
681
+ readonly default: {
682
+ readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
683
+ };
684
+ };
685
+ sourceId?: number | undefined | undefined;
686
+ testnet?: boolean | undefined | undefined;
687
+ custom?: Record<string, unknown> | undefined;
688
+ fees?: import("viem").ChainFees<undefined> | undefined;
689
+ formatters?: undefined;
690
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
691
+ }, {
692
+ blockExplorers: {
693
+ readonly default: {
694
+ readonly name: "PolygonScan";
695
+ readonly url: "https://polygonscan.com";
696
+ readonly apiUrl: "https://api.polygonscan.com/api";
697
+ };
698
+ };
699
+ blockTime?: number | undefined | undefined;
700
+ contracts: {
701
+ readonly multicall3: {
702
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
703
+ readonly blockCreated: 25770160;
704
+ };
705
+ };
706
+ ensTlds?: readonly string[] | undefined;
707
+ id: 137;
708
+ name: "Polygon";
709
+ nativeCurrency: {
710
+ readonly name: "POL";
711
+ readonly symbol: "POL";
712
+ readonly decimals: 18;
713
+ };
714
+ experimental_preconfirmationTime?: number | undefined | undefined;
715
+ rpcUrls: {
716
+ readonly default: {
717
+ readonly http: readonly ["https://polygon-rpc.com"];
718
+ };
719
+ };
720
+ sourceId?: number | undefined | undefined;
721
+ testnet?: boolean | undefined | undefined;
722
+ custom?: Record<string, unknown> | undefined;
723
+ fees?: import("viem").ChainFees<undefined> | undefined;
724
+ formatters?: undefined;
725
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
726
+ }, {
727
+ blockExplorers: {
728
+ readonly default: {
729
+ readonly name: "Explorer";
730
+ readonly url: "https://explorer.zora.energy";
731
+ readonly apiUrl: "https://explorer.zora.energy/api";
732
+ };
733
+ };
734
+ blockTime: 2000;
735
+ contracts: {
736
+ readonly l2OutputOracle: {
737
+ readonly 1: {
738
+ readonly address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c";
739
+ };
740
+ };
741
+ readonly multicall3: {
742
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
743
+ readonly blockCreated: 5882;
744
+ };
745
+ readonly portal: {
746
+ readonly 1: {
747
+ readonly address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054";
748
+ };
749
+ };
750
+ readonly l1StandardBridge: {
751
+ readonly 1: {
752
+ readonly address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631";
753
+ };
754
+ };
755
+ readonly gasPriceOracle: {
756
+ readonly address: "0x420000000000000000000000000000000000000F";
757
+ };
758
+ readonly l1Block: {
759
+ readonly address: "0x4200000000000000000000000000000000000015";
760
+ };
761
+ readonly l2CrossDomainMessenger: {
762
+ readonly address: "0x4200000000000000000000000000000000000007";
763
+ };
764
+ readonly l2Erc721Bridge: {
765
+ readonly address: "0x4200000000000000000000000000000000000014";
766
+ };
767
+ readonly l2StandardBridge: {
768
+ readonly address: "0x4200000000000000000000000000000000000010";
769
+ };
770
+ readonly l2ToL1MessagePasser: {
771
+ readonly address: "0x4200000000000000000000000000000000000016";
772
+ };
773
+ };
774
+ ensTlds?: readonly string[] | undefined;
775
+ id: 7777777;
776
+ name: "Zora";
777
+ nativeCurrency: {
778
+ readonly decimals: 18;
779
+ readonly name: "Ether";
780
+ readonly symbol: "ETH";
781
+ };
782
+ experimental_preconfirmationTime?: number | undefined | undefined;
783
+ rpcUrls: {
784
+ readonly default: {
785
+ readonly http: readonly ["https://rpc.zora.energy"];
786
+ readonly webSocket: readonly ["wss://rpc.zora.energy"];
787
+ };
788
+ };
789
+ sourceId: 1;
790
+ testnet?: boolean | undefined | undefined;
791
+ custom?: Record<string, unknown> | undefined;
792
+ fees?: import("viem").ChainFees<undefined> | undefined;
793
+ formatters: {
794
+ readonly block: {
795
+ exclude: [] | undefined;
796
+ format: (args: import("@wagmi/core/chains").OpStackRpcBlock) => {
797
+ baseFeePerGas: bigint | null;
798
+ blobGasUsed: bigint;
799
+ difficulty: bigint;
800
+ excessBlobGas: bigint;
801
+ extraData: import("viem").Hex;
802
+ gasLimit: bigint;
803
+ gasUsed: bigint;
804
+ hash: `0x${string}` | null;
805
+ logsBloom: `0x${string}` | null;
806
+ miner: import("viem").Address;
807
+ mixHash: import("viem").Hash;
808
+ nonce: `0x${string}` | null;
809
+ number: bigint | null;
810
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
811
+ parentHash: import("viem").Hash;
812
+ receiptsRoot: import("viem").Hex;
813
+ sealFields: import("viem").Hex[];
814
+ sha3Uncles: import("viem").Hash;
815
+ size: bigint;
816
+ stateRoot: import("viem").Hash;
817
+ timestamp: bigint;
818
+ totalDifficulty: bigint | null;
819
+ transactions: `0x${string}`[] | import("@wagmi/core/chains").OpStackTransaction<boolean>[];
820
+ transactionsRoot: import("viem").Hash;
821
+ uncles: import("viem").Hash[];
822
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
823
+ withdrawalsRoot?: `0x${string}` | undefined;
824
+ } & {};
825
+ type: "block";
826
+ };
827
+ readonly transaction: {
828
+ exclude: [] | undefined;
829
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransaction) => ({
830
+ blockHash: `0x${string}` | null;
831
+ blockNumber: bigint | null;
832
+ from: import("viem").Address;
833
+ gas: bigint;
834
+ hash: import("viem").Hash;
835
+ input: import("viem").Hex;
836
+ nonce: number;
837
+ r: import("viem").Hex;
838
+ s: import("viem").Hex;
839
+ to: import("viem").Address | null;
840
+ transactionIndex: number | null;
841
+ typeHex: import("viem").Hex | null;
842
+ v: bigint;
843
+ value: bigint;
844
+ yParity: number;
845
+ gasPrice?: undefined | undefined;
846
+ maxFeePerBlobGas?: undefined | undefined;
847
+ maxFeePerGas: bigint;
848
+ maxPriorityFeePerGas: bigint;
849
+ isSystemTx?: boolean;
850
+ mint?: bigint | undefined | undefined;
851
+ sourceHash: import("viem").Hex;
852
+ type: "deposit";
853
+ } | {
854
+ r: import("viem").Hex;
855
+ s: import("viem").Hex;
856
+ v: bigint;
857
+ to: import("viem").Address | null;
858
+ from: import("viem").Address;
859
+ gas: bigint;
860
+ nonce: number;
861
+ value: bigint;
862
+ blockHash: `0x${string}` | null;
863
+ blockNumber: bigint | null;
864
+ hash: import("viem").Hash;
865
+ input: import("viem").Hex;
866
+ transactionIndex: number | null;
867
+ typeHex: import("viem").Hex | null;
868
+ accessList?: undefined | undefined;
869
+ authorizationList?: undefined | undefined;
870
+ blobVersionedHashes?: undefined | undefined;
871
+ chainId?: number | undefined;
872
+ yParity?: undefined | undefined;
873
+ type: "legacy";
874
+ gasPrice: bigint;
875
+ maxFeePerBlobGas?: undefined | undefined;
876
+ maxFeePerGas?: undefined | undefined;
877
+ maxPriorityFeePerGas?: undefined | undefined;
878
+ isSystemTx?: undefined | undefined;
879
+ mint?: undefined | undefined;
880
+ sourceHash?: undefined | undefined;
881
+ } | {
882
+ blockHash: `0x${string}` | null;
883
+ blockNumber: bigint | null;
884
+ from: import("viem").Address;
885
+ gas: bigint;
886
+ hash: import("viem").Hash;
887
+ input: import("viem").Hex;
888
+ nonce: number;
889
+ r: import("viem").Hex;
890
+ s: import("viem").Hex;
891
+ to: import("viem").Address | null;
892
+ transactionIndex: number | null;
893
+ typeHex: import("viem").Hex | null;
894
+ v: bigint;
895
+ value: bigint;
896
+ yParity: number;
897
+ accessList: import("viem").AccessList;
898
+ authorizationList?: undefined | undefined;
899
+ blobVersionedHashes?: undefined | undefined;
900
+ chainId: number;
901
+ type: "eip2930";
902
+ gasPrice: bigint;
903
+ maxFeePerBlobGas?: undefined | undefined;
904
+ maxFeePerGas?: undefined | undefined;
905
+ maxPriorityFeePerGas?: undefined | undefined;
906
+ isSystemTx?: undefined | undefined;
907
+ mint?: undefined | undefined;
908
+ sourceHash?: undefined | undefined;
909
+ } | {
910
+ blockHash: `0x${string}` | null;
911
+ blockNumber: bigint | null;
912
+ from: import("viem").Address;
913
+ gas: bigint;
914
+ hash: import("viem").Hash;
915
+ input: import("viem").Hex;
916
+ nonce: number;
917
+ r: import("viem").Hex;
918
+ s: import("viem").Hex;
919
+ to: import("viem").Address | null;
920
+ transactionIndex: number | null;
921
+ typeHex: import("viem").Hex | null;
922
+ v: bigint;
923
+ value: bigint;
924
+ yParity: number;
925
+ accessList: import("viem").AccessList;
926
+ authorizationList?: undefined | undefined;
927
+ blobVersionedHashes?: undefined | undefined;
928
+ chainId: number;
929
+ type: "eip1559";
930
+ gasPrice?: undefined | undefined;
931
+ maxFeePerBlobGas?: undefined | undefined;
932
+ maxFeePerGas: bigint;
933
+ maxPriorityFeePerGas: bigint;
934
+ isSystemTx?: undefined | undefined;
935
+ mint?: undefined | undefined;
936
+ sourceHash?: undefined | undefined;
937
+ } | {
938
+ blockHash: `0x${string}` | null;
939
+ blockNumber: bigint | null;
940
+ from: import("viem").Address;
941
+ gas: bigint;
942
+ hash: import("viem").Hash;
943
+ input: import("viem").Hex;
944
+ nonce: number;
945
+ r: import("viem").Hex;
946
+ s: import("viem").Hex;
947
+ to: import("viem").Address | null;
948
+ transactionIndex: number | null;
949
+ typeHex: import("viem").Hex | null;
950
+ v: bigint;
951
+ value: bigint;
952
+ yParity: number;
953
+ accessList: import("viem").AccessList;
954
+ authorizationList?: undefined | undefined;
955
+ blobVersionedHashes: readonly import("viem").Hex[];
956
+ chainId: number;
957
+ type: "eip4844";
958
+ gasPrice?: undefined | undefined;
959
+ maxFeePerBlobGas: bigint;
960
+ maxFeePerGas: bigint;
961
+ maxPriorityFeePerGas: bigint;
962
+ isSystemTx?: undefined | undefined;
963
+ mint?: undefined | undefined;
964
+ sourceHash?: undefined | undefined;
965
+ } | {
966
+ blockHash: `0x${string}` | null;
967
+ blockNumber: bigint | null;
968
+ from: import("viem").Address;
969
+ gas: bigint;
970
+ hash: import("viem").Hash;
971
+ input: import("viem").Hex;
972
+ nonce: number;
973
+ r: import("viem").Hex;
974
+ s: import("viem").Hex;
975
+ to: import("viem").Address | null;
976
+ transactionIndex: number | null;
977
+ typeHex: import("viem").Hex | null;
978
+ v: bigint;
979
+ value: bigint;
980
+ yParity: number;
981
+ accessList: import("viem").AccessList;
982
+ authorizationList: import("viem").SignedAuthorizationList;
983
+ blobVersionedHashes?: undefined | undefined;
984
+ chainId: number;
985
+ type: "eip7702";
986
+ gasPrice?: undefined | undefined;
987
+ maxFeePerBlobGas?: undefined | undefined;
988
+ maxFeePerGas: bigint;
989
+ maxPriorityFeePerGas: bigint;
990
+ isSystemTx?: undefined | undefined;
991
+ mint?: undefined | undefined;
992
+ sourceHash?: undefined | undefined;
993
+ }) & {};
994
+ type: "transaction";
995
+ };
996
+ readonly transactionReceipt: {
997
+ exclude: [] | undefined;
998
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransactionReceipt) => {
999
+ blobGasPrice?: bigint | undefined;
1000
+ blobGasUsed?: bigint | undefined;
1001
+ blockHash: import("viem").Hash;
1002
+ blockNumber: bigint;
1003
+ contractAddress: import("viem").Address | null | undefined;
1004
+ cumulativeGasUsed: bigint;
1005
+ effectiveGasPrice: bigint;
1006
+ from: import("viem").Address;
1007
+ gasUsed: bigint;
1008
+ logs: import("viem").Log<bigint, number, false>[];
1009
+ logsBloom: import("viem").Hex;
1010
+ root?: `0x${string}` | undefined;
1011
+ status: "success" | "reverted";
1012
+ to: import("viem").Address | null;
1013
+ transactionHash: import("viem").Hash;
1014
+ transactionIndex: number;
1015
+ type: import("viem").TransactionType;
1016
+ l1GasPrice: bigint | null;
1017
+ l1GasUsed: bigint | null;
1018
+ l1Fee: bigint | null;
1019
+ l1FeeScalar: number | null;
1020
+ } & {};
1021
+ type: "transactionReceipt";
1022
+ };
1023
+ };
1024
+ serializers: {
1025
+ readonly transaction: typeof import("@wagmi/core/chains").serializeTransactionOpStack;
1026
+ };
1027
+ }], {
1028
+ 1: import("viem").HttpTransport<undefined, false>;
1029
+ 8453: import("viem").HttpTransport<undefined, false>;
1030
+ 10: import("viem").HttpTransport<undefined, false>;
1031
+ 42161: import("viem").HttpTransport<undefined, false>;
1032
+ 137: import("viem").HttpTransport<undefined, false>;
1033
+ 7777777: import("viem").HttpTransport<undefined, false>;
1034
+ }, readonly import("@wagmi/core").CreateConnectorFn[]>;
1035
+ export declare function configFromRpc(rpcUrl: string): Promise<import("@wagmi/core").Config<readonly [{
1036
+ blockExplorers: {
1037
+ readonly default: {
1038
+ readonly name: "Etherscan";
1039
+ readonly url: "https://etherscan.io";
1040
+ readonly apiUrl: "https://api.etherscan.io/api";
1041
+ };
1042
+ };
1043
+ blockTime: 12000;
1044
+ contracts: {
1045
+ readonly ensRegistry: {
1046
+ readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
1047
+ };
1048
+ readonly ensUniversalResolver: {
1049
+ readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
1050
+ readonly blockCreated: 19258213;
1051
+ };
1052
+ readonly multicall3: {
1053
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1054
+ readonly blockCreated: 14353601;
1055
+ };
1056
+ };
1057
+ ensTlds?: readonly string[] | undefined;
1058
+ id: 1;
1059
+ name: "Ethereum";
1060
+ nativeCurrency: {
1061
+ readonly name: "Ether";
1062
+ readonly symbol: "ETH";
1063
+ readonly decimals: 18;
1064
+ };
1065
+ experimental_preconfirmationTime?: number | undefined | undefined;
1066
+ rpcUrls: {
1067
+ readonly default: {
1068
+ readonly http: readonly ["https://eth.merkle.io"];
1069
+ };
1070
+ };
1071
+ sourceId?: number | undefined | undefined;
1072
+ testnet?: boolean | undefined | undefined;
1073
+ custom?: Record<string, unknown> | undefined;
1074
+ fees?: import("viem").ChainFees<undefined> | undefined;
1075
+ formatters?: undefined;
1076
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1077
+ } | {
1078
+ blockExplorers: {
1079
+ readonly default: {
1080
+ readonly name: "Basescan";
1081
+ readonly url: "https://basescan.org";
1082
+ readonly apiUrl: "https://api.basescan.org/api";
1083
+ };
1084
+ };
1085
+ blockTime: 2000;
1086
+ contracts: {
1087
+ readonly disputeGameFactory: {
1088
+ readonly 1: {
1089
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
1090
+ };
1091
+ };
1092
+ readonly l2OutputOracle: {
1093
+ readonly 1: {
1094
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
1095
+ };
1096
+ };
1097
+ readonly multicall3: {
1098
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1099
+ readonly blockCreated: 5022;
1100
+ };
1101
+ readonly portal: {
1102
+ readonly 1: {
1103
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
1104
+ readonly blockCreated: 17482143;
1105
+ };
1106
+ };
1107
+ readonly l1StandardBridge: {
1108
+ readonly 1: {
1109
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
1110
+ readonly blockCreated: 17482143;
1111
+ };
1112
+ };
1113
+ readonly gasPriceOracle: {
1114
+ readonly address: "0x420000000000000000000000000000000000000F";
1115
+ };
1116
+ readonly l1Block: {
1117
+ readonly address: "0x4200000000000000000000000000000000000015";
1118
+ };
1119
+ readonly l2CrossDomainMessenger: {
1120
+ readonly address: "0x4200000000000000000000000000000000000007";
1121
+ };
1122
+ readonly l2Erc721Bridge: {
1123
+ readonly address: "0x4200000000000000000000000000000000000014";
1124
+ };
1125
+ readonly l2StandardBridge: {
1126
+ readonly address: "0x4200000000000000000000000000000000000010";
1127
+ };
1128
+ readonly l2ToL1MessagePasser: {
1129
+ readonly address: "0x4200000000000000000000000000000000000016";
1130
+ };
1131
+ };
1132
+ ensTlds?: readonly string[] | undefined;
1133
+ id: 8453;
1134
+ name: "Base";
1135
+ nativeCurrency: {
1136
+ readonly name: "Ether";
1137
+ readonly symbol: "ETH";
1138
+ readonly decimals: 18;
1139
+ };
1140
+ experimental_preconfirmationTime?: number | undefined | undefined;
1141
+ rpcUrls: {
1142
+ readonly default: {
1143
+ readonly http: readonly ["https://mainnet.base.org"];
1144
+ };
1145
+ };
1146
+ sourceId: 1;
1147
+ testnet?: boolean | undefined | undefined;
1148
+ custom?: Record<string, unknown> | undefined;
1149
+ fees?: import("viem").ChainFees<undefined> | undefined;
1150
+ formatters: {
1151
+ readonly block: {
1152
+ exclude: [] | undefined;
1153
+ format: (args: import("@wagmi/core/chains").OpStackRpcBlock) => {
1154
+ baseFeePerGas: bigint | null;
1155
+ blobGasUsed: bigint;
1156
+ difficulty: bigint;
1157
+ excessBlobGas: bigint;
1158
+ extraData: import("viem").Hex;
1159
+ gasLimit: bigint;
1160
+ gasUsed: bigint;
1161
+ hash: `0x${string}` | null;
1162
+ logsBloom: `0x${string}` | null;
1163
+ miner: import("viem").Address;
1164
+ mixHash: import("viem").Hash;
1165
+ nonce: `0x${string}` | null;
1166
+ number: bigint | null;
1167
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
1168
+ parentHash: import("viem").Hash;
1169
+ receiptsRoot: import("viem").Hex;
1170
+ sealFields: import("viem").Hex[];
1171
+ sha3Uncles: import("viem").Hash;
1172
+ size: bigint;
1173
+ stateRoot: import("viem").Hash;
1174
+ timestamp: bigint;
1175
+ totalDifficulty: bigint | null;
1176
+ transactions: `0x${string}`[] | import("@wagmi/core/chains").OpStackTransaction<boolean>[];
1177
+ transactionsRoot: import("viem").Hash;
1178
+ uncles: import("viem").Hash[];
1179
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
1180
+ withdrawalsRoot?: `0x${string}` | undefined;
1181
+ } & {};
1182
+ type: "block";
1183
+ };
1184
+ readonly transaction: {
1185
+ exclude: [] | undefined;
1186
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransaction) => ({
1187
+ blockHash: `0x${string}` | null;
1188
+ blockNumber: bigint | null;
1189
+ from: import("viem").Address;
1190
+ gas: bigint;
1191
+ hash: import("viem").Hash;
1192
+ input: import("viem").Hex;
1193
+ nonce: number;
1194
+ r: import("viem").Hex;
1195
+ s: import("viem").Hex;
1196
+ to: import("viem").Address | null;
1197
+ transactionIndex: number | null;
1198
+ typeHex: import("viem").Hex | null;
1199
+ v: bigint;
1200
+ value: bigint;
1201
+ yParity: number;
1202
+ gasPrice?: undefined | undefined;
1203
+ maxFeePerBlobGas?: undefined | undefined;
1204
+ maxFeePerGas: bigint;
1205
+ maxPriorityFeePerGas: bigint;
1206
+ isSystemTx?: boolean;
1207
+ mint?: bigint | undefined | undefined;
1208
+ sourceHash: import("viem").Hex;
1209
+ type: "deposit";
1210
+ } | {
1211
+ r: import("viem").Hex;
1212
+ s: import("viem").Hex;
1213
+ v: bigint;
1214
+ to: import("viem").Address | null;
1215
+ from: import("viem").Address;
1216
+ gas: bigint;
1217
+ nonce: number;
1218
+ value: bigint;
1219
+ blockHash: `0x${string}` | null;
1220
+ blockNumber: bigint | null;
1221
+ hash: import("viem").Hash;
1222
+ input: import("viem").Hex;
1223
+ transactionIndex: number | null;
1224
+ typeHex: import("viem").Hex | null;
1225
+ accessList?: undefined | undefined;
1226
+ authorizationList?: undefined | undefined;
1227
+ blobVersionedHashes?: undefined | undefined;
1228
+ chainId?: number | undefined;
1229
+ yParity?: undefined | undefined;
1230
+ type: "legacy";
1231
+ gasPrice: bigint;
1232
+ maxFeePerBlobGas?: undefined | undefined;
1233
+ maxFeePerGas?: undefined | undefined;
1234
+ maxPriorityFeePerGas?: undefined | undefined;
1235
+ isSystemTx?: undefined | undefined;
1236
+ mint?: undefined | undefined;
1237
+ sourceHash?: undefined | undefined;
1238
+ } | {
1239
+ blockHash: `0x${string}` | null;
1240
+ blockNumber: bigint | null;
1241
+ from: import("viem").Address;
1242
+ gas: bigint;
1243
+ hash: import("viem").Hash;
1244
+ input: import("viem").Hex;
1245
+ nonce: number;
1246
+ r: import("viem").Hex;
1247
+ s: import("viem").Hex;
1248
+ to: import("viem").Address | null;
1249
+ transactionIndex: number | null;
1250
+ typeHex: import("viem").Hex | null;
1251
+ v: bigint;
1252
+ value: bigint;
1253
+ yParity: number;
1254
+ accessList: import("viem").AccessList;
1255
+ authorizationList?: undefined | undefined;
1256
+ blobVersionedHashes?: undefined | undefined;
1257
+ chainId: number;
1258
+ type: "eip2930";
1259
+ gasPrice: bigint;
1260
+ maxFeePerBlobGas?: undefined | undefined;
1261
+ maxFeePerGas?: undefined | undefined;
1262
+ maxPriorityFeePerGas?: undefined | undefined;
1263
+ isSystemTx?: undefined | undefined;
1264
+ mint?: undefined | undefined;
1265
+ sourceHash?: undefined | undefined;
1266
+ } | {
1267
+ blockHash: `0x${string}` | null;
1268
+ blockNumber: bigint | null;
1269
+ from: import("viem").Address;
1270
+ gas: bigint;
1271
+ hash: import("viem").Hash;
1272
+ input: import("viem").Hex;
1273
+ nonce: number;
1274
+ r: import("viem").Hex;
1275
+ s: import("viem").Hex;
1276
+ to: import("viem").Address | null;
1277
+ transactionIndex: number | null;
1278
+ typeHex: import("viem").Hex | null;
1279
+ v: bigint;
1280
+ value: bigint;
1281
+ yParity: number;
1282
+ accessList: import("viem").AccessList;
1283
+ authorizationList?: undefined | undefined;
1284
+ blobVersionedHashes?: undefined | undefined;
1285
+ chainId: number;
1286
+ type: "eip1559";
1287
+ gasPrice?: undefined | undefined;
1288
+ maxFeePerBlobGas?: undefined | undefined;
1289
+ maxFeePerGas: bigint;
1290
+ maxPriorityFeePerGas: bigint;
1291
+ isSystemTx?: undefined | undefined;
1292
+ mint?: undefined | undefined;
1293
+ sourceHash?: undefined | undefined;
1294
+ } | {
1295
+ blockHash: `0x${string}` | null;
1296
+ blockNumber: bigint | null;
1297
+ from: import("viem").Address;
1298
+ gas: bigint;
1299
+ hash: import("viem").Hash;
1300
+ input: import("viem").Hex;
1301
+ nonce: number;
1302
+ r: import("viem").Hex;
1303
+ s: import("viem").Hex;
1304
+ to: import("viem").Address | null;
1305
+ transactionIndex: number | null;
1306
+ typeHex: import("viem").Hex | null;
1307
+ v: bigint;
1308
+ value: bigint;
1309
+ yParity: number;
1310
+ accessList: import("viem").AccessList;
1311
+ authorizationList?: undefined | undefined;
1312
+ blobVersionedHashes: readonly import("viem").Hex[];
1313
+ chainId: number;
1314
+ type: "eip4844";
1315
+ gasPrice?: undefined | undefined;
1316
+ maxFeePerBlobGas: bigint;
1317
+ maxFeePerGas: bigint;
1318
+ maxPriorityFeePerGas: bigint;
1319
+ isSystemTx?: undefined | undefined;
1320
+ mint?: undefined | undefined;
1321
+ sourceHash?: undefined | undefined;
1322
+ } | {
1323
+ blockHash: `0x${string}` | null;
1324
+ blockNumber: bigint | null;
1325
+ from: import("viem").Address;
1326
+ gas: bigint;
1327
+ hash: import("viem").Hash;
1328
+ input: import("viem").Hex;
1329
+ nonce: number;
1330
+ r: import("viem").Hex;
1331
+ s: import("viem").Hex;
1332
+ to: import("viem").Address | null;
1333
+ transactionIndex: number | null;
1334
+ typeHex: import("viem").Hex | null;
1335
+ v: bigint;
1336
+ value: bigint;
1337
+ yParity: number;
1338
+ accessList: import("viem").AccessList;
1339
+ authorizationList: import("viem").SignedAuthorizationList;
1340
+ blobVersionedHashes?: undefined | undefined;
1341
+ chainId: number;
1342
+ type: "eip7702";
1343
+ gasPrice?: undefined | undefined;
1344
+ maxFeePerBlobGas?: undefined | undefined;
1345
+ maxFeePerGas: bigint;
1346
+ maxPriorityFeePerGas: bigint;
1347
+ isSystemTx?: undefined | undefined;
1348
+ mint?: undefined | undefined;
1349
+ sourceHash?: undefined | undefined;
1350
+ }) & {};
1351
+ type: "transaction";
1352
+ };
1353
+ readonly transactionReceipt: {
1354
+ exclude: [] | undefined;
1355
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransactionReceipt) => {
1356
+ blobGasPrice?: bigint | undefined;
1357
+ blobGasUsed?: bigint | undefined;
1358
+ blockHash: import("viem").Hash;
1359
+ blockNumber: bigint;
1360
+ contractAddress: import("viem").Address | null | undefined;
1361
+ cumulativeGasUsed: bigint;
1362
+ effectiveGasPrice: bigint;
1363
+ from: import("viem").Address;
1364
+ gasUsed: bigint;
1365
+ logs: import("viem").Log<bigint, number, false>[];
1366
+ logsBloom: import("viem").Hex;
1367
+ root?: `0x${string}` | undefined;
1368
+ status: "success" | "reverted";
1369
+ to: import("viem").Address | null;
1370
+ transactionHash: import("viem").Hash;
1371
+ transactionIndex: number;
1372
+ type: import("viem").TransactionType;
1373
+ l1GasPrice: bigint | null;
1374
+ l1GasUsed: bigint | null;
1375
+ l1Fee: bigint | null;
1376
+ l1FeeScalar: number | null;
1377
+ } & {};
1378
+ type: "transactionReceipt";
1379
+ };
1380
+ };
1381
+ serializers: {
1382
+ readonly transaction: typeof import("@wagmi/core/chains").serializeTransactionOpStack;
1383
+ };
1384
+ } | {
1385
+ blockExplorers: {
1386
+ readonly default: {
1387
+ readonly name: "Optimism Explorer";
1388
+ readonly url: "https://optimistic.etherscan.io";
1389
+ readonly apiUrl: "https://api-optimistic.etherscan.io/api";
1390
+ };
1391
+ };
1392
+ blockTime: 2000;
1393
+ contracts: {
1394
+ readonly disputeGameFactory: {
1395
+ readonly 1: {
1396
+ readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
1397
+ };
1398
+ };
1399
+ readonly l2OutputOracle: {
1400
+ readonly 1: {
1401
+ readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
1402
+ };
1403
+ };
1404
+ readonly multicall3: {
1405
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1406
+ readonly blockCreated: 4286263;
1407
+ };
1408
+ readonly portal: {
1409
+ readonly 1: {
1410
+ readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
1411
+ };
1412
+ };
1413
+ readonly l1StandardBridge: {
1414
+ readonly 1: {
1415
+ readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
1416
+ };
1417
+ };
1418
+ readonly gasPriceOracle: {
1419
+ readonly address: "0x420000000000000000000000000000000000000F";
1420
+ };
1421
+ readonly l1Block: {
1422
+ readonly address: "0x4200000000000000000000000000000000000015";
1423
+ };
1424
+ readonly l2CrossDomainMessenger: {
1425
+ readonly address: "0x4200000000000000000000000000000000000007";
1426
+ };
1427
+ readonly l2Erc721Bridge: {
1428
+ readonly address: "0x4200000000000000000000000000000000000014";
1429
+ };
1430
+ readonly l2StandardBridge: {
1431
+ readonly address: "0x4200000000000000000000000000000000000010";
1432
+ };
1433
+ readonly l2ToL1MessagePasser: {
1434
+ readonly address: "0x4200000000000000000000000000000000000016";
1435
+ };
1436
+ };
1437
+ ensTlds?: readonly string[] | undefined;
1438
+ id: 10;
1439
+ name: "OP Mainnet";
1440
+ nativeCurrency: {
1441
+ readonly name: "Ether";
1442
+ readonly symbol: "ETH";
1443
+ readonly decimals: 18;
1444
+ };
1445
+ experimental_preconfirmationTime?: number | undefined | undefined;
1446
+ rpcUrls: {
1447
+ readonly default: {
1448
+ readonly http: readonly ["https://mainnet.optimism.io"];
1449
+ };
1450
+ };
1451
+ sourceId: 1;
1452
+ testnet?: boolean | undefined | undefined;
1453
+ custom?: Record<string, unknown> | undefined;
1454
+ fees?: import("viem").ChainFees<undefined> | undefined;
1455
+ formatters: {
1456
+ readonly block: {
1457
+ exclude: [] | undefined;
1458
+ format: (args: import("@wagmi/core/chains").OpStackRpcBlock) => {
1459
+ baseFeePerGas: bigint | null;
1460
+ blobGasUsed: bigint;
1461
+ difficulty: bigint;
1462
+ excessBlobGas: bigint;
1463
+ extraData: import("viem").Hex;
1464
+ gasLimit: bigint;
1465
+ gasUsed: bigint;
1466
+ hash: `0x${string}` | null;
1467
+ logsBloom: `0x${string}` | null;
1468
+ miner: import("viem").Address;
1469
+ mixHash: import("viem").Hash;
1470
+ nonce: `0x${string}` | null;
1471
+ number: bigint | null;
1472
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
1473
+ parentHash: import("viem").Hash;
1474
+ receiptsRoot: import("viem").Hex;
1475
+ sealFields: import("viem").Hex[];
1476
+ sha3Uncles: import("viem").Hash;
1477
+ size: bigint;
1478
+ stateRoot: import("viem").Hash;
1479
+ timestamp: bigint;
1480
+ totalDifficulty: bigint | null;
1481
+ transactions: `0x${string}`[] | import("@wagmi/core/chains").OpStackTransaction<boolean>[];
1482
+ transactionsRoot: import("viem").Hash;
1483
+ uncles: import("viem").Hash[];
1484
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
1485
+ withdrawalsRoot?: `0x${string}` | undefined;
1486
+ } & {};
1487
+ type: "block";
1488
+ };
1489
+ readonly transaction: {
1490
+ exclude: [] | undefined;
1491
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransaction) => ({
1492
+ blockHash: `0x${string}` | null;
1493
+ blockNumber: bigint | null;
1494
+ from: import("viem").Address;
1495
+ gas: bigint;
1496
+ hash: import("viem").Hash;
1497
+ input: import("viem").Hex;
1498
+ nonce: number;
1499
+ r: import("viem").Hex;
1500
+ s: import("viem").Hex;
1501
+ to: import("viem").Address | null;
1502
+ transactionIndex: number | null;
1503
+ typeHex: import("viem").Hex | null;
1504
+ v: bigint;
1505
+ value: bigint;
1506
+ yParity: number;
1507
+ gasPrice?: undefined | undefined;
1508
+ maxFeePerBlobGas?: undefined | undefined;
1509
+ maxFeePerGas: bigint;
1510
+ maxPriorityFeePerGas: bigint;
1511
+ isSystemTx?: boolean;
1512
+ mint?: bigint | undefined | undefined;
1513
+ sourceHash: import("viem").Hex;
1514
+ type: "deposit";
1515
+ } | {
1516
+ r: import("viem").Hex;
1517
+ s: import("viem").Hex;
1518
+ v: bigint;
1519
+ to: import("viem").Address | null;
1520
+ from: import("viem").Address;
1521
+ gas: bigint;
1522
+ nonce: number;
1523
+ value: bigint;
1524
+ blockHash: `0x${string}` | null;
1525
+ blockNumber: bigint | null;
1526
+ hash: import("viem").Hash;
1527
+ input: import("viem").Hex;
1528
+ transactionIndex: number | null;
1529
+ typeHex: import("viem").Hex | null;
1530
+ accessList?: undefined | undefined;
1531
+ authorizationList?: undefined | undefined;
1532
+ blobVersionedHashes?: undefined | undefined;
1533
+ chainId?: number | undefined;
1534
+ yParity?: undefined | undefined;
1535
+ type: "legacy";
1536
+ gasPrice: bigint;
1537
+ maxFeePerBlobGas?: undefined | undefined;
1538
+ maxFeePerGas?: undefined | undefined;
1539
+ maxPriorityFeePerGas?: undefined | undefined;
1540
+ isSystemTx?: undefined | undefined;
1541
+ mint?: undefined | undefined;
1542
+ sourceHash?: undefined | undefined;
1543
+ } | {
1544
+ blockHash: `0x${string}` | null;
1545
+ blockNumber: bigint | null;
1546
+ from: import("viem").Address;
1547
+ gas: bigint;
1548
+ hash: import("viem").Hash;
1549
+ input: import("viem").Hex;
1550
+ nonce: number;
1551
+ r: import("viem").Hex;
1552
+ s: import("viem").Hex;
1553
+ to: import("viem").Address | null;
1554
+ transactionIndex: number | null;
1555
+ typeHex: import("viem").Hex | null;
1556
+ v: bigint;
1557
+ value: bigint;
1558
+ yParity: number;
1559
+ accessList: import("viem").AccessList;
1560
+ authorizationList?: undefined | undefined;
1561
+ blobVersionedHashes?: undefined | undefined;
1562
+ chainId: number;
1563
+ type: "eip2930";
1564
+ gasPrice: bigint;
1565
+ maxFeePerBlobGas?: undefined | undefined;
1566
+ maxFeePerGas?: undefined | undefined;
1567
+ maxPriorityFeePerGas?: undefined | undefined;
1568
+ isSystemTx?: undefined | undefined;
1569
+ mint?: undefined | undefined;
1570
+ sourceHash?: undefined | undefined;
1571
+ } | {
1572
+ blockHash: `0x${string}` | null;
1573
+ blockNumber: bigint | null;
1574
+ from: import("viem").Address;
1575
+ gas: bigint;
1576
+ hash: import("viem").Hash;
1577
+ input: import("viem").Hex;
1578
+ nonce: number;
1579
+ r: import("viem").Hex;
1580
+ s: import("viem").Hex;
1581
+ to: import("viem").Address | null;
1582
+ transactionIndex: number | null;
1583
+ typeHex: import("viem").Hex | null;
1584
+ v: bigint;
1585
+ value: bigint;
1586
+ yParity: number;
1587
+ accessList: import("viem").AccessList;
1588
+ authorizationList?: undefined | undefined;
1589
+ blobVersionedHashes?: undefined | undefined;
1590
+ chainId: number;
1591
+ type: "eip1559";
1592
+ gasPrice?: undefined | undefined;
1593
+ maxFeePerBlobGas?: undefined | undefined;
1594
+ maxFeePerGas: bigint;
1595
+ maxPriorityFeePerGas: bigint;
1596
+ isSystemTx?: undefined | undefined;
1597
+ mint?: undefined | undefined;
1598
+ sourceHash?: undefined | undefined;
1599
+ } | {
1600
+ blockHash: `0x${string}` | null;
1601
+ blockNumber: bigint | null;
1602
+ from: import("viem").Address;
1603
+ gas: bigint;
1604
+ hash: import("viem").Hash;
1605
+ input: import("viem").Hex;
1606
+ nonce: number;
1607
+ r: import("viem").Hex;
1608
+ s: import("viem").Hex;
1609
+ to: import("viem").Address | null;
1610
+ transactionIndex: number | null;
1611
+ typeHex: import("viem").Hex | null;
1612
+ v: bigint;
1613
+ value: bigint;
1614
+ yParity: number;
1615
+ accessList: import("viem").AccessList;
1616
+ authorizationList?: undefined | undefined;
1617
+ blobVersionedHashes: readonly import("viem").Hex[];
1618
+ chainId: number;
1619
+ type: "eip4844";
1620
+ gasPrice?: undefined | undefined;
1621
+ maxFeePerBlobGas: bigint;
1622
+ maxFeePerGas: bigint;
1623
+ maxPriorityFeePerGas: bigint;
1624
+ isSystemTx?: undefined | undefined;
1625
+ mint?: undefined | undefined;
1626
+ sourceHash?: undefined | undefined;
1627
+ } | {
1628
+ blockHash: `0x${string}` | null;
1629
+ blockNumber: bigint | null;
1630
+ from: import("viem").Address;
1631
+ gas: bigint;
1632
+ hash: import("viem").Hash;
1633
+ input: import("viem").Hex;
1634
+ nonce: number;
1635
+ r: import("viem").Hex;
1636
+ s: import("viem").Hex;
1637
+ to: import("viem").Address | null;
1638
+ transactionIndex: number | null;
1639
+ typeHex: import("viem").Hex | null;
1640
+ v: bigint;
1641
+ value: bigint;
1642
+ yParity: number;
1643
+ accessList: import("viem").AccessList;
1644
+ authorizationList: import("viem").SignedAuthorizationList;
1645
+ blobVersionedHashes?: undefined | undefined;
1646
+ chainId: number;
1647
+ type: "eip7702";
1648
+ gasPrice?: undefined | undefined;
1649
+ maxFeePerBlobGas?: undefined | undefined;
1650
+ maxFeePerGas: bigint;
1651
+ maxPriorityFeePerGas: bigint;
1652
+ isSystemTx?: undefined | undefined;
1653
+ mint?: undefined | undefined;
1654
+ sourceHash?: undefined | undefined;
1655
+ }) & {};
1656
+ type: "transaction";
1657
+ };
1658
+ readonly transactionReceipt: {
1659
+ exclude: [] | undefined;
1660
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransactionReceipt) => {
1661
+ blobGasPrice?: bigint | undefined;
1662
+ blobGasUsed?: bigint | undefined;
1663
+ blockHash: import("viem").Hash;
1664
+ blockNumber: bigint;
1665
+ contractAddress: import("viem").Address | null | undefined;
1666
+ cumulativeGasUsed: bigint;
1667
+ effectiveGasPrice: bigint;
1668
+ from: import("viem").Address;
1669
+ gasUsed: bigint;
1670
+ logs: import("viem").Log<bigint, number, false>[];
1671
+ logsBloom: import("viem").Hex;
1672
+ root?: `0x${string}` | undefined;
1673
+ status: "success" | "reverted";
1674
+ to: import("viem").Address | null;
1675
+ transactionHash: import("viem").Hash;
1676
+ transactionIndex: number;
1677
+ type: import("viem").TransactionType;
1678
+ l1GasPrice: bigint | null;
1679
+ l1GasUsed: bigint | null;
1680
+ l1Fee: bigint | null;
1681
+ l1FeeScalar: number | null;
1682
+ } & {};
1683
+ type: "transactionReceipt";
1684
+ };
1685
+ };
1686
+ serializers: {
1687
+ readonly transaction: typeof import("@wagmi/core/chains").serializeTransactionOpStack;
1688
+ };
1689
+ } | {
1690
+ blockExplorers: {
1691
+ readonly default: {
1692
+ readonly name: "Arbiscan";
1693
+ readonly url: "https://arbiscan.io";
1694
+ readonly apiUrl: "https://api.arbiscan.io/api";
1695
+ };
1696
+ };
1697
+ blockTime: 250;
1698
+ contracts: {
1699
+ readonly multicall3: {
1700
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1701
+ readonly blockCreated: 7654707;
1702
+ };
1703
+ };
1704
+ ensTlds?: readonly string[] | undefined;
1705
+ id: 42161;
1706
+ name: "Arbitrum One";
1707
+ nativeCurrency: {
1708
+ readonly name: "Ether";
1709
+ readonly symbol: "ETH";
1710
+ readonly decimals: 18;
1711
+ };
1712
+ experimental_preconfirmationTime?: number | undefined | undefined;
1713
+ rpcUrls: {
1714
+ readonly default: {
1715
+ readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
1716
+ };
1717
+ };
1718
+ sourceId?: number | undefined | undefined;
1719
+ testnet?: boolean | undefined | undefined;
1720
+ custom?: Record<string, unknown> | undefined;
1721
+ fees?: import("viem").ChainFees<undefined> | undefined;
1722
+ formatters?: undefined;
1723
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1724
+ } | {
1725
+ blockExplorers: {
1726
+ readonly default: {
1727
+ readonly name: "PolygonScan";
1728
+ readonly url: "https://polygonscan.com";
1729
+ readonly apiUrl: "https://api.polygonscan.com/api";
1730
+ };
1731
+ };
1732
+ blockTime?: number | undefined | undefined;
1733
+ contracts: {
1734
+ readonly multicall3: {
1735
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1736
+ readonly blockCreated: 25770160;
1737
+ };
1738
+ };
1739
+ ensTlds?: readonly string[] | undefined;
1740
+ id: 137;
1741
+ name: "Polygon";
1742
+ nativeCurrency: {
1743
+ readonly name: "POL";
1744
+ readonly symbol: "POL";
1745
+ readonly decimals: 18;
1746
+ };
1747
+ experimental_preconfirmationTime?: number | undefined | undefined;
1748
+ rpcUrls: {
1749
+ readonly default: {
1750
+ readonly http: readonly ["https://polygon-rpc.com"];
1751
+ };
1752
+ };
1753
+ sourceId?: number | undefined | undefined;
1754
+ testnet?: boolean | undefined | undefined;
1755
+ custom?: Record<string, unknown> | undefined;
1756
+ fees?: import("viem").ChainFees<undefined> | undefined;
1757
+ formatters?: undefined;
1758
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1759
+ } | {
1760
+ blockExplorers: {
1761
+ readonly default: {
1762
+ readonly name: "Explorer";
1763
+ readonly url: "https://explorer.zora.energy";
1764
+ readonly apiUrl: "https://explorer.zora.energy/api";
1765
+ };
1766
+ };
1767
+ blockTime: 2000;
1768
+ contracts: {
1769
+ readonly l2OutputOracle: {
1770
+ readonly 1: {
1771
+ readonly address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c";
1772
+ };
1773
+ };
1774
+ readonly multicall3: {
1775
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1776
+ readonly blockCreated: 5882;
1777
+ };
1778
+ readonly portal: {
1779
+ readonly 1: {
1780
+ readonly address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054";
1781
+ };
1782
+ };
1783
+ readonly l1StandardBridge: {
1784
+ readonly 1: {
1785
+ readonly address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631";
1786
+ };
1787
+ };
1788
+ readonly gasPriceOracle: {
1789
+ readonly address: "0x420000000000000000000000000000000000000F";
1790
+ };
1791
+ readonly l1Block: {
1792
+ readonly address: "0x4200000000000000000000000000000000000015";
1793
+ };
1794
+ readonly l2CrossDomainMessenger: {
1795
+ readonly address: "0x4200000000000000000000000000000000000007";
1796
+ };
1797
+ readonly l2Erc721Bridge: {
1798
+ readonly address: "0x4200000000000000000000000000000000000014";
1799
+ };
1800
+ readonly l2StandardBridge: {
1801
+ readonly address: "0x4200000000000000000000000000000000000010";
1802
+ };
1803
+ readonly l2ToL1MessagePasser: {
1804
+ readonly address: "0x4200000000000000000000000000000000000016";
1805
+ };
1806
+ };
1807
+ ensTlds?: readonly string[] | undefined;
1808
+ id: 7777777;
1809
+ name: "Zora";
1810
+ nativeCurrency: {
1811
+ readonly decimals: 18;
1812
+ readonly name: "Ether";
1813
+ readonly symbol: "ETH";
1814
+ };
1815
+ experimental_preconfirmationTime?: number | undefined | undefined;
1816
+ rpcUrls: {
1817
+ readonly default: {
1818
+ readonly http: readonly ["https://rpc.zora.energy"];
1819
+ readonly webSocket: readonly ["wss://rpc.zora.energy"];
1820
+ };
1821
+ };
1822
+ sourceId: 1;
1823
+ testnet?: boolean | undefined | undefined;
1824
+ custom?: Record<string, unknown> | undefined;
1825
+ fees?: import("viem").ChainFees<undefined> | undefined;
1826
+ formatters: {
1827
+ readonly block: {
1828
+ exclude: [] | undefined;
1829
+ format: (args: import("@wagmi/core/chains").OpStackRpcBlock) => {
1830
+ baseFeePerGas: bigint | null;
1831
+ blobGasUsed: bigint;
1832
+ difficulty: bigint;
1833
+ excessBlobGas: bigint;
1834
+ extraData: import("viem").Hex;
1835
+ gasLimit: bigint;
1836
+ gasUsed: bigint;
1837
+ hash: `0x${string}` | null;
1838
+ logsBloom: `0x${string}` | null;
1839
+ miner: import("viem").Address;
1840
+ mixHash: import("viem").Hash;
1841
+ nonce: `0x${string}` | null;
1842
+ number: bigint | null;
1843
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
1844
+ parentHash: import("viem").Hash;
1845
+ receiptsRoot: import("viem").Hex;
1846
+ sealFields: import("viem").Hex[];
1847
+ sha3Uncles: import("viem").Hash;
1848
+ size: bigint;
1849
+ stateRoot: import("viem").Hash;
1850
+ timestamp: bigint;
1851
+ totalDifficulty: bigint | null;
1852
+ transactions: `0x${string}`[] | import("@wagmi/core/chains").OpStackTransaction<boolean>[];
1853
+ transactionsRoot: import("viem").Hash;
1854
+ uncles: import("viem").Hash[];
1855
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
1856
+ withdrawalsRoot?: `0x${string}` | undefined;
1857
+ } & {};
1858
+ type: "block";
1859
+ };
1860
+ readonly transaction: {
1861
+ exclude: [] | undefined;
1862
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransaction) => ({
1863
+ blockHash: `0x${string}` | null;
1864
+ blockNumber: bigint | null;
1865
+ from: import("viem").Address;
1866
+ gas: bigint;
1867
+ hash: import("viem").Hash;
1868
+ input: import("viem").Hex;
1869
+ nonce: number;
1870
+ r: import("viem").Hex;
1871
+ s: import("viem").Hex;
1872
+ to: import("viem").Address | null;
1873
+ transactionIndex: number | null;
1874
+ typeHex: import("viem").Hex | null;
1875
+ v: bigint;
1876
+ value: bigint;
1877
+ yParity: number;
1878
+ gasPrice?: undefined | undefined;
1879
+ maxFeePerBlobGas?: undefined | undefined;
1880
+ maxFeePerGas: bigint;
1881
+ maxPriorityFeePerGas: bigint;
1882
+ isSystemTx?: boolean;
1883
+ mint?: bigint | undefined | undefined;
1884
+ sourceHash: import("viem").Hex;
1885
+ type: "deposit";
1886
+ } | {
1887
+ r: import("viem").Hex;
1888
+ s: import("viem").Hex;
1889
+ v: bigint;
1890
+ to: import("viem").Address | null;
1891
+ from: import("viem").Address;
1892
+ gas: bigint;
1893
+ nonce: number;
1894
+ value: bigint;
1895
+ blockHash: `0x${string}` | null;
1896
+ blockNumber: bigint | null;
1897
+ hash: import("viem").Hash;
1898
+ input: import("viem").Hex;
1899
+ transactionIndex: number | null;
1900
+ typeHex: import("viem").Hex | null;
1901
+ accessList?: undefined | undefined;
1902
+ authorizationList?: undefined | undefined;
1903
+ blobVersionedHashes?: undefined | undefined;
1904
+ chainId?: number | undefined;
1905
+ yParity?: undefined | undefined;
1906
+ type: "legacy";
1907
+ gasPrice: bigint;
1908
+ maxFeePerBlobGas?: undefined | undefined;
1909
+ maxFeePerGas?: undefined | undefined;
1910
+ maxPriorityFeePerGas?: undefined | undefined;
1911
+ isSystemTx?: undefined | undefined;
1912
+ mint?: undefined | undefined;
1913
+ sourceHash?: undefined | undefined;
1914
+ } | {
1915
+ blockHash: `0x${string}` | null;
1916
+ blockNumber: bigint | null;
1917
+ from: import("viem").Address;
1918
+ gas: bigint;
1919
+ hash: import("viem").Hash;
1920
+ input: import("viem").Hex;
1921
+ nonce: number;
1922
+ r: import("viem").Hex;
1923
+ s: import("viem").Hex;
1924
+ to: import("viem").Address | null;
1925
+ transactionIndex: number | null;
1926
+ typeHex: import("viem").Hex | null;
1927
+ v: bigint;
1928
+ value: bigint;
1929
+ yParity: number;
1930
+ accessList: import("viem").AccessList;
1931
+ authorizationList?: undefined | undefined;
1932
+ blobVersionedHashes?: undefined | undefined;
1933
+ chainId: number;
1934
+ type: "eip2930";
1935
+ gasPrice: bigint;
1936
+ maxFeePerBlobGas?: undefined | undefined;
1937
+ maxFeePerGas?: undefined | undefined;
1938
+ maxPriorityFeePerGas?: undefined | undefined;
1939
+ isSystemTx?: undefined | undefined;
1940
+ mint?: undefined | undefined;
1941
+ sourceHash?: undefined | undefined;
1942
+ } | {
1943
+ blockHash: `0x${string}` | null;
1944
+ blockNumber: bigint | null;
1945
+ from: import("viem").Address;
1946
+ gas: bigint;
1947
+ hash: import("viem").Hash;
1948
+ input: import("viem").Hex;
1949
+ nonce: number;
1950
+ r: import("viem").Hex;
1951
+ s: import("viem").Hex;
1952
+ to: import("viem").Address | null;
1953
+ transactionIndex: number | null;
1954
+ typeHex: import("viem").Hex | null;
1955
+ v: bigint;
1956
+ value: bigint;
1957
+ yParity: number;
1958
+ accessList: import("viem").AccessList;
1959
+ authorizationList?: undefined | undefined;
1960
+ blobVersionedHashes?: undefined | undefined;
1961
+ chainId: number;
1962
+ type: "eip1559";
1963
+ gasPrice?: undefined | undefined;
1964
+ maxFeePerBlobGas?: undefined | undefined;
1965
+ maxFeePerGas: bigint;
1966
+ maxPriorityFeePerGas: bigint;
1967
+ isSystemTx?: undefined | undefined;
1968
+ mint?: undefined | undefined;
1969
+ sourceHash?: undefined | undefined;
1970
+ } | {
1971
+ blockHash: `0x${string}` | null;
1972
+ blockNumber: bigint | null;
1973
+ from: import("viem").Address;
1974
+ gas: bigint;
1975
+ hash: import("viem").Hash;
1976
+ input: import("viem").Hex;
1977
+ nonce: number;
1978
+ r: import("viem").Hex;
1979
+ s: import("viem").Hex;
1980
+ to: import("viem").Address | null;
1981
+ transactionIndex: number | null;
1982
+ typeHex: import("viem").Hex | null;
1983
+ v: bigint;
1984
+ value: bigint;
1985
+ yParity: number;
1986
+ accessList: import("viem").AccessList;
1987
+ authorizationList?: undefined | undefined;
1988
+ blobVersionedHashes: readonly import("viem").Hex[];
1989
+ chainId: number;
1990
+ type: "eip4844";
1991
+ gasPrice?: undefined | undefined;
1992
+ maxFeePerBlobGas: bigint;
1993
+ maxFeePerGas: bigint;
1994
+ maxPriorityFeePerGas: bigint;
1995
+ isSystemTx?: undefined | undefined;
1996
+ mint?: undefined | undefined;
1997
+ sourceHash?: undefined | undefined;
1998
+ } | {
1999
+ blockHash: `0x${string}` | null;
2000
+ blockNumber: bigint | null;
2001
+ from: import("viem").Address;
2002
+ gas: bigint;
2003
+ hash: import("viem").Hash;
2004
+ input: import("viem").Hex;
2005
+ nonce: number;
2006
+ r: import("viem").Hex;
2007
+ s: import("viem").Hex;
2008
+ to: import("viem").Address | null;
2009
+ transactionIndex: number | null;
2010
+ typeHex: import("viem").Hex | null;
2011
+ v: bigint;
2012
+ value: bigint;
2013
+ yParity: number;
2014
+ accessList: import("viem").AccessList;
2015
+ authorizationList: import("viem").SignedAuthorizationList;
2016
+ blobVersionedHashes?: undefined | undefined;
2017
+ chainId: number;
2018
+ type: "eip7702";
2019
+ gasPrice?: undefined | undefined;
2020
+ maxFeePerBlobGas?: undefined | undefined;
2021
+ maxFeePerGas: bigint;
2022
+ maxPriorityFeePerGas: bigint;
2023
+ isSystemTx?: undefined | undefined;
2024
+ mint?: undefined | undefined;
2025
+ sourceHash?: undefined | undefined;
2026
+ }) & {};
2027
+ type: "transaction";
2028
+ };
2029
+ readonly transactionReceipt: {
2030
+ exclude: [] | undefined;
2031
+ format: (args: import("@wagmi/core/chains").OpStackRpcTransactionReceipt) => {
2032
+ blobGasPrice?: bigint | undefined;
2033
+ blobGasUsed?: bigint | undefined;
2034
+ blockHash: import("viem").Hash;
2035
+ blockNumber: bigint;
2036
+ contractAddress: import("viem").Address | null | undefined;
2037
+ cumulativeGasUsed: bigint;
2038
+ effectiveGasPrice: bigint;
2039
+ from: import("viem").Address;
2040
+ gasUsed: bigint;
2041
+ logs: import("viem").Log<bigint, number, false>[];
2042
+ logsBloom: import("viem").Hex;
2043
+ root?: `0x${string}` | undefined;
2044
+ status: "success" | "reverted";
2045
+ to: import("viem").Address | null;
2046
+ transactionHash: import("viem").Hash;
2047
+ transactionIndex: number;
2048
+ type: import("viem").TransactionType;
2049
+ l1GasPrice: bigint | null;
2050
+ l1GasUsed: bigint | null;
2051
+ l1Fee: bigint | null;
2052
+ l1FeeScalar: number | null;
2053
+ } & {};
2054
+ type: "transactionReceipt";
2055
+ };
2056
+ };
2057
+ serializers: {
2058
+ readonly transaction: typeof import("@wagmi/core/chains").serializeTransactionOpStack;
2059
+ };
2060
+ } | {
2061
+ blockExplorers?: {
2062
+ [key: string]: {
2063
+ name: string;
2064
+ url: string;
2065
+ apiUrl?: string | undefined;
2066
+ };
2067
+ default: {
2068
+ name: string;
2069
+ url: string;
2070
+ apiUrl?: string | undefined;
2071
+ };
2072
+ } | undefined | undefined;
2073
+ blockTime?: number | undefined | undefined;
2074
+ contracts?: {
2075
+ [x: string]: import("viem").ChainContract | {
2076
+ [sourceId: number]: import("viem").ChainContract | undefined;
2077
+ } | undefined;
2078
+ ensRegistry?: import("viem").ChainContract | undefined;
2079
+ ensUniversalResolver?: import("viem").ChainContract | undefined;
2080
+ multicall3?: import("viem").ChainContract | undefined;
2081
+ universalSignatureVerifier?: import("viem").ChainContract | undefined;
2082
+ } | undefined;
2083
+ ensTlds?: readonly string[] | undefined;
2084
+ id: number;
2085
+ name: `chain-${number}`;
2086
+ nativeCurrency: {
2087
+ readonly name: "Ether";
2088
+ readonly symbol: "ETH";
2089
+ readonly decimals: 18;
2090
+ };
2091
+ experimental_preconfirmationTime?: number | undefined | undefined;
2092
+ rpcUrls: {
2093
+ readonly default: {
2094
+ readonly http: readonly [string];
2095
+ };
2096
+ };
2097
+ sourceId?: number | undefined | undefined;
2098
+ testnet?: boolean | undefined | undefined;
2099
+ custom?: Record<string, unknown> | undefined;
2100
+ fees?: import("viem").ChainFees<undefined> | undefined;
2101
+ formatters?: undefined;
2102
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2103
+ }], {
2104
+ [x: number]: import("viem").HttpTransport<undefined, false>;
2105
+ }, readonly import("@wagmi/core").CreateConnectorFn[]>>;
2106
+ export { getClient, getConnectorClient };