@pendle/sdk-boros 0.0.7 → 0.0.8

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 (27) hide show
  1. package/dist/common/index.d.ts +2 -0
  2. package/dist/common/index.js +9 -0
  3. package/dist/common/index.js.map +1 -0
  4. package/dist/constants.d.ts +0 -3
  5. package/dist/constants.js +1 -4
  6. package/dist/constants.js.map +1 -1
  7. package/dist/entities/agent/agent.d.ts +17 -0
  8. package/dist/entities/agent/agent.js +73 -0
  9. package/dist/entities/agent/agent.js.map +1 -0
  10. package/dist/entities/agent/index.d.ts +1 -0
  11. package/dist/entities/agent/index.js +18 -0
  12. package/dist/entities/agent/index.js.map +1 -0
  13. package/dist/entities/index.d.ts +1 -0
  14. package/dist/entities/index.js +18 -0
  15. package/dist/entities/index.js.map +1 -0
  16. package/dist/entities/router.d.ts +4692 -0
  17. package/dist/entities/router.js +17 -0
  18. package/dist/entities/router.js.map +1 -0
  19. package/dist/utils/index.d.ts +1 -0
  20. package/dist/utils/index.js +11 -0
  21. package/dist/utils/index.js.map +1 -1
  22. package/dist/utils/signing/agent.js +5 -8
  23. package/dist/utils/signing/agent.js.map +1 -1
  24. package/dist/utils/signing/common.d.ts +1 -0
  25. package/dist/utils/signing/common.js +4 -0
  26. package/dist/utils/signing/common.js.map +1 -1
  27. package/package.json +1 -1
package/dist/entities/router.d.ts ADDED
@@ -0,0 +1,4692 @@
1
+ export declare const router: {
2
+ read: {
3
+ viewCall: (args: readonly [`0x${string}`], options?: import("viem").Prettify<import("viem").UnionOmit<import("viem").ReadContractParameters<readonly [{
4
+ readonly inputs: readonly [{
5
+ readonly components: readonly [{
6
+ readonly internalType: "Account";
7
+ readonly name: "account";
8
+ readonly type: "bytes21";
9
+ }, {
10
+ readonly internalType: "address";
11
+ readonly name: "target";
12
+ readonly type: "address";
13
+ }, {
14
+ readonly internalType: "bytes";
15
+ readonly name: "data";
16
+ readonly type: "bytes";
17
+ }];
18
+ readonly internalType: "struct IRouter.SimulateData[]";
19
+ readonly name: "calls";
20
+ readonly type: "tuple[]";
21
+ }];
22
+ readonly name: "batchSimulate";
23
+ readonly outputs: readonly [{
24
+ readonly internalType: "bytes[]";
25
+ readonly name: "";
26
+ readonly type: "bytes[]";
27
+ }];
28
+ readonly stateMutability: "nonpayable";
29
+ readonly type: "function";
30
+ }, {
31
+ readonly inputs: readonly [{
32
+ readonly components: readonly [{
33
+ readonly internalType: "uint8";
34
+ readonly name: "accountId";
35
+ readonly type: "uint8";
36
+ }, {
37
+ readonly internalType: "bytes";
38
+ readonly name: "data";
39
+ readonly type: "bytes";
40
+ }];
41
+ readonly internalType: "struct IRouter.DirectCall[]";
42
+ readonly name: "data";
43
+ readonly type: "tuple[]";
44
+ }, {
45
+ readonly internalType: "bool";
46
+ readonly name: "requireMarginCheckCall";
47
+ readonly type: "bool";
48
+ }];
49
+ readonly name: "directCall";
50
+ readonly outputs: readonly [{
51
+ readonly internalType: "bytes[]";
52
+ readonly name: "";
53
+ readonly type: "bytes[]";
54
+ }];
55
+ readonly stateMutability: "nonpayable";
56
+ readonly type: "function";
57
+ }, {
58
+ readonly inputs: readonly [{
59
+ readonly internalType: "bytes";
60
+ readonly name: "data";
61
+ readonly type: "bytes";
62
+ }];
63
+ readonly name: "viewCall";
64
+ readonly outputs: readonly [{
65
+ readonly internalType: "bytes";
66
+ readonly name: "";
67
+ readonly type: "bytes";
68
+ }];
69
+ readonly stateMutability: "view";
70
+ readonly type: "function";
71
+ }], "viewCall", readonly [`0x${string}`]>, "address" | "args" | "abi" | "functionName">> | undefined) => Promise<`0x${string}`>;
72
+ };
73
+ estimateGas: {
74
+ batchSimulate: (args: readonly [readonly {
75
+ account: `0x${string}`;
76
+ target: `0x${string}`;
77
+ data: `0x${string}`;
78
+ }[]], options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<readonly [{
79
+ readonly inputs: readonly [{
80
+ readonly components: readonly [{
81
+ readonly internalType: "Account";
82
+ readonly name: "account";
83
+ readonly type: "bytes21";
84
+ }, {
85
+ readonly internalType: "address";
86
+ readonly name: "target";
87
+ readonly type: "address";
88
+ }, {
89
+ readonly internalType: "bytes";
90
+ readonly name: "data";
91
+ readonly type: "bytes";
92
+ }];
93
+ readonly internalType: "struct IRouter.SimulateData[]";
94
+ readonly name: "calls";
95
+ readonly type: "tuple[]";
96
+ }];
97
+ readonly name: "batchSimulate";
98
+ readonly outputs: readonly [{
99
+ readonly internalType: "bytes[]";
100
+ readonly name: "";
101
+ readonly type: "bytes[]";
102
+ }];
103
+ readonly stateMutability: "nonpayable";
104
+ readonly type: "function";
105
+ }, {
106
+ readonly inputs: readonly [{
107
+ readonly components: readonly [{
108
+ readonly internalType: "uint8";
109
+ readonly name: "accountId";
110
+ readonly type: "uint8";
111
+ }, {
112
+ readonly internalType: "bytes";
113
+ readonly name: "data";
114
+ readonly type: "bytes";
115
+ }];
116
+ readonly internalType: "struct IRouter.DirectCall[]";
117
+ readonly name: "data";
118
+ readonly type: "tuple[]";
119
+ }, {
120
+ readonly internalType: "bool";
121
+ readonly name: "requireMarginCheckCall";
122
+ readonly type: "bool";
123
+ }];
124
+ readonly name: "directCall";
125
+ readonly outputs: readonly [{
126
+ readonly internalType: "bytes[]";
127
+ readonly name: "";
128
+ readonly type: "bytes[]";
129
+ }];
130
+ readonly stateMutability: "nonpayable";
131
+ readonly type: "function";
132
+ }, {
133
+ readonly inputs: readonly [{
134
+ readonly internalType: "bytes";
135
+ readonly name: "data";
136
+ readonly type: "bytes";
137
+ }];
138
+ readonly name: "viewCall";
139
+ readonly outputs: readonly [{
140
+ readonly internalType: "bytes";
141
+ readonly name: "";
142
+ readonly type: "bytes";
143
+ }];
144
+ readonly stateMutability: "view";
145
+ readonly type: "function";
146
+ }], "batchSimulate", readonly [readonly {
147
+ account: `0x${string}`;
148
+ target: `0x${string}`;
149
+ data: `0x${string}`;
150
+ }[]], {
151
+ blockExplorers: {
152
+ readonly default: {
153
+ readonly name: "Basescan";
154
+ readonly url: "https://basescan.org";
155
+ readonly apiUrl: "https://api.basescan.org/api";
156
+ };
157
+ };
158
+ contracts: {
159
+ readonly disputeGameFactory: {
160
+ readonly 1: {
161
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
162
+ };
163
+ };
164
+ readonly l2OutputOracle: {
165
+ readonly 1: {
166
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
167
+ };
168
+ };
169
+ readonly multicall3: {
170
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
171
+ readonly blockCreated: 5022;
172
+ };
173
+ readonly portal: {
174
+ readonly 1: {
175
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
176
+ readonly blockCreated: 17482143;
177
+ };
178
+ };
179
+ readonly l1StandardBridge: {
180
+ readonly 1: {
181
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
182
+ readonly blockCreated: 17482143;
183
+ };
184
+ };
185
+ readonly gasPriceOracle: {
186
+ readonly address: "0x420000000000000000000000000000000000000F";
187
+ };
188
+ readonly l1Block: {
189
+ readonly address: "0x4200000000000000000000000000000000000015";
190
+ };
191
+ readonly l2CrossDomainMessenger: {
192
+ readonly address: "0x4200000000000000000000000000000000000007";
193
+ };
194
+ readonly l2Erc721Bridge: {
195
+ readonly address: "0x4200000000000000000000000000000000000014";
196
+ };
197
+ readonly l2StandardBridge: {
198
+ readonly address: "0x4200000000000000000000000000000000000010";
199
+ };
200
+ readonly l2ToL1MessagePasser: {
201
+ readonly address: "0x4200000000000000000000000000000000000016";
202
+ };
203
+ };
204
+ id: 8453;
205
+ name: "Base";
206
+ nativeCurrency: {
207
+ readonly name: "Ether";
208
+ readonly symbol: "ETH";
209
+ readonly decimals: 18;
210
+ };
211
+ rpcUrls: {
212
+ readonly default: {
213
+ readonly http: readonly ["https://mainnet.base.org"];
214
+ };
215
+ };
216
+ sourceId: 1;
217
+ testnet?: boolean | undefined;
218
+ custom?: Record<string, unknown> | undefined;
219
+ fees?: import("viem").ChainFees<undefined> | undefined;
220
+ formatters: {
221
+ readonly block: {
222
+ exclude: [] | undefined;
223
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
224
+ baseFeePerGas: bigint | null;
225
+ blobGasUsed: bigint;
226
+ difficulty: bigint;
227
+ excessBlobGas: bigint;
228
+ extraData: import("viem").Hex;
229
+ gasLimit: bigint;
230
+ gasUsed: bigint;
231
+ hash: `0x${string}` | null;
232
+ logsBloom: `0x${string}` | null;
233
+ miner: import("viem").Address;
234
+ mixHash: import("viem").Hash;
235
+ nonce: `0x${string}` | null;
236
+ number: bigint | null;
237
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
238
+ parentHash: import("viem").Hash;
239
+ receiptsRoot: import("viem").Hex;
240
+ sealFields: import("viem").Hex[];
241
+ sha3Uncles: import("viem").Hash;
242
+ size: bigint;
243
+ stateRoot: import("viem").Hash;
244
+ timestamp: bigint;
245
+ totalDifficulty: bigint | null;
246
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
247
+ transactionsRoot: import("viem").Hash;
248
+ uncles: import("viem").Hash[];
249
+ withdrawals?: import("viem").Withdrawal[] | undefined;
250
+ withdrawalsRoot?: import("viem").Hex | undefined;
251
+ } & {};
252
+ type: "block";
253
+ };
254
+ readonly transaction: {
255
+ exclude: [] | undefined;
256
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
257
+ blockHash: `0x${string}` | null;
258
+ blockNumber: bigint | null;
259
+ from: import("viem").Address;
260
+ gas: bigint;
261
+ hash: import("viem").Hash;
262
+ input: import("viem").Hex;
263
+ nonce: number;
264
+ r: import("viem").Hex;
265
+ s: import("viem").Hex;
266
+ to: import("viem").Address | null;
267
+ transactionIndex: number | null;
268
+ typeHex: import("viem").Hex | null;
269
+ v: bigint;
270
+ value: bigint;
271
+ yParity: number;
272
+ gasPrice?: undefined;
273
+ maxFeePerBlobGas?: undefined;
274
+ maxFeePerGas: bigint;
275
+ maxPriorityFeePerGas: bigint;
276
+ isSystemTx?: boolean;
277
+ mint?: bigint | undefined;
278
+ sourceHash: import("viem").Hex;
279
+ type: "deposit";
280
+ } | {
281
+ r: import("viem").Hex;
282
+ s: import("viem").Hex;
283
+ v: bigint;
284
+ to: import("viem").Address | null;
285
+ from: import("viem").Address;
286
+ gas: bigint;
287
+ nonce: number;
288
+ value: bigint;
289
+ blockHash: `0x${string}` | null;
290
+ blockNumber: bigint | null;
291
+ hash: import("viem").Hash;
292
+ input: import("viem").Hex;
293
+ transactionIndex: number | null;
294
+ typeHex: import("viem").Hex | null;
295
+ accessList?: undefined;
296
+ authorizationList?: undefined;
297
+ blobVersionedHashes?: undefined;
298
+ chainId?: number | undefined;
299
+ yParity?: undefined;
300
+ type: "legacy";
301
+ gasPrice: bigint;
302
+ maxFeePerBlobGas?: undefined;
303
+ maxFeePerGas?: undefined;
304
+ maxPriorityFeePerGas?: undefined;
305
+ isSystemTx?: undefined;
306
+ mint?: undefined;
307
+ sourceHash?: undefined;
308
+ } | {
309
+ blockHash: `0x${string}` | null;
310
+ blockNumber: bigint | null;
311
+ from: import("viem").Address;
312
+ gas: bigint;
313
+ hash: import("viem").Hash;
314
+ input: import("viem").Hex;
315
+ nonce: number;
316
+ r: import("viem").Hex;
317
+ s: import("viem").Hex;
318
+ to: import("viem").Address | null;
319
+ transactionIndex: number | null;
320
+ typeHex: import("viem").Hex | null;
321
+ v: bigint;
322
+ value: bigint;
323
+ yParity: number;
324
+ accessList: import("viem").AccessList;
325
+ authorizationList?: undefined;
326
+ blobVersionedHashes?: undefined;
327
+ chainId: number;
328
+ type: "eip2930";
329
+ gasPrice: bigint;
330
+ maxFeePerBlobGas?: undefined;
331
+ maxFeePerGas?: undefined;
332
+ maxPriorityFeePerGas?: undefined;
333
+ isSystemTx?: undefined;
334
+ mint?: undefined;
335
+ sourceHash?: undefined;
336
+ } | {
337
+ blockHash: `0x${string}` | null;
338
+ blockNumber: bigint | null;
339
+ from: import("viem").Address;
340
+ gas: bigint;
341
+ hash: import("viem").Hash;
342
+ input: import("viem").Hex;
343
+ nonce: number;
344
+ r: import("viem").Hex;
345
+ s: import("viem").Hex;
346
+ to: import("viem").Address | null;
347
+ transactionIndex: number | null;
348
+ typeHex: import("viem").Hex | null;
349
+ v: bigint;
350
+ value: bigint;
351
+ yParity: number;
352
+ accessList: import("viem").AccessList;
353
+ authorizationList?: undefined;
354
+ blobVersionedHashes?: undefined;
355
+ chainId: number;
356
+ type: "eip1559";
357
+ gasPrice?: undefined;
358
+ maxFeePerBlobGas?: undefined;
359
+ maxFeePerGas: bigint;
360
+ maxPriorityFeePerGas: bigint;
361
+ isSystemTx?: undefined;
362
+ mint?: undefined;
363
+ sourceHash?: undefined;
364
+ } | {
365
+ blockHash: `0x${string}` | null;
366
+ blockNumber: bigint | null;
367
+ from: import("viem").Address;
368
+ gas: bigint;
369
+ hash: import("viem").Hash;
370
+ input: import("viem").Hex;
371
+ nonce: number;
372
+ r: import("viem").Hex;
373
+ s: import("viem").Hex;
374
+ to: import("viem").Address | null;
375
+ transactionIndex: number | null;
376
+ typeHex: import("viem").Hex | null;
377
+ v: bigint;
378
+ value: bigint;
379
+ yParity: number;
380
+ accessList: import("viem").AccessList;
381
+ authorizationList?: undefined;
382
+ blobVersionedHashes: readonly import("viem").Hex[];
383
+ chainId: number;
384
+ type: "eip4844";
385
+ gasPrice?: undefined;
386
+ maxFeePerBlobGas: bigint;
387
+ maxFeePerGas: bigint;
388
+ maxPriorityFeePerGas: bigint;
389
+ isSystemTx?: undefined;
390
+ mint?: undefined;
391
+ sourceHash?: undefined;
392
+ } | {
393
+ blockHash: `0x${string}` | null;
394
+ blockNumber: bigint | null;
395
+ from: import("viem").Address;
396
+ gas: bigint;
397
+ hash: import("viem").Hash;
398
+ input: import("viem").Hex;
399
+ nonce: number;
400
+ r: import("viem").Hex;
401
+ s: import("viem").Hex;
402
+ to: import("viem").Address | null;
403
+ transactionIndex: number | null;
404
+ typeHex: import("viem").Hex | null;
405
+ v: bigint;
406
+ value: bigint;
407
+ yParity: number;
408
+ accessList: import("viem").AccessList;
409
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
410
+ blobVersionedHashes?: undefined;
411
+ chainId: number;
412
+ type: "eip7702";
413
+ gasPrice?: undefined;
414
+ maxFeePerBlobGas?: undefined;
415
+ maxFeePerGas: bigint;
416
+ maxPriorityFeePerGas: bigint;
417
+ isSystemTx?: undefined;
418
+ mint?: undefined;
419
+ sourceHash?: undefined;
420
+ }) & {};
421
+ type: "transaction";
422
+ };
423
+ readonly transactionReceipt: {
424
+ exclude: [] | undefined;
425
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
426
+ blobGasPrice?: bigint | undefined;
427
+ blobGasUsed?: bigint | undefined;
428
+ blockHash: import("viem").Hash;
429
+ blockNumber: bigint;
430
+ contractAddress: import("viem").Address | null | undefined;
431
+ cumulativeGasUsed: bigint;
432
+ effectiveGasPrice: bigint;
433
+ from: import("viem").Address;
434
+ gasUsed: bigint;
435
+ logs: import("viem").Log<bigint, number, false>[];
436
+ logsBloom: import("viem").Hex;
437
+ root?: import("viem").Hash | undefined;
438
+ status: "success" | "reverted";
439
+ to: import("viem").Address | null;
440
+ transactionHash: import("viem").Hash;
441
+ transactionIndex: number;
442
+ type: import("viem").TransactionType;
443
+ l1GasPrice: bigint | null;
444
+ l1GasUsed: bigint | null;
445
+ l1Fee: bigint | null;
446
+ l1FeeScalar: number | null;
447
+ } & {};
448
+ type: "transactionReceipt";
449
+ };
450
+ };
451
+ serializers: {
452
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
453
+ };
454
+ }>, "address" | "args" | "abi" | "functionName">>) => Promise<import("viem").EstimateContractGasReturnType>;
455
+ directCall: (args: readonly [readonly {
456
+ accountId: number;
457
+ data: `0x${string}`;
458
+ }[], boolean], options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<readonly [{
459
+ readonly inputs: readonly [{
460
+ readonly components: readonly [{
461
+ readonly internalType: "Account";
462
+ readonly name: "account";
463
+ readonly type: "bytes21";
464
+ }, {
465
+ readonly internalType: "address";
466
+ readonly name: "target";
467
+ readonly type: "address";
468
+ }, {
469
+ readonly internalType: "bytes";
470
+ readonly name: "data";
471
+ readonly type: "bytes";
472
+ }];
473
+ readonly internalType: "struct IRouter.SimulateData[]";
474
+ readonly name: "calls";
475
+ readonly type: "tuple[]";
476
+ }];
477
+ readonly name: "batchSimulate";
478
+ readonly outputs: readonly [{
479
+ readonly internalType: "bytes[]";
480
+ readonly name: "";
481
+ readonly type: "bytes[]";
482
+ }];
483
+ readonly stateMutability: "nonpayable";
484
+ readonly type: "function";
485
+ }, {
486
+ readonly inputs: readonly [{
487
+ readonly components: readonly [{
488
+ readonly internalType: "uint8";
489
+ readonly name: "accountId";
490
+ readonly type: "uint8";
491
+ }, {
492
+ readonly internalType: "bytes";
493
+ readonly name: "data";
494
+ readonly type: "bytes";
495
+ }];
496
+ readonly internalType: "struct IRouter.DirectCall[]";
497
+ readonly name: "data";
498
+ readonly type: "tuple[]";
499
+ }, {
500
+ readonly internalType: "bool";
501
+ readonly name: "requireMarginCheckCall";
502
+ readonly type: "bool";
503
+ }];
504
+ readonly name: "directCall";
505
+ readonly outputs: readonly [{
506
+ readonly internalType: "bytes[]";
507
+ readonly name: "";
508
+ readonly type: "bytes[]";
509
+ }];
510
+ readonly stateMutability: "nonpayable";
511
+ readonly type: "function";
512
+ }, {
513
+ readonly inputs: readonly [{
514
+ readonly internalType: "bytes";
515
+ readonly name: "data";
516
+ readonly type: "bytes";
517
+ }];
518
+ readonly name: "viewCall";
519
+ readonly outputs: readonly [{
520
+ readonly internalType: "bytes";
521
+ readonly name: "";
522
+ readonly type: "bytes";
523
+ }];
524
+ readonly stateMutability: "view";
525
+ readonly type: "function";
526
+ }], "directCall", readonly [readonly {
527
+ accountId: number;
528
+ data: `0x${string}`;
529
+ }[], boolean], {
530
+ blockExplorers: {
531
+ readonly default: {
532
+ readonly name: "Basescan";
533
+ readonly url: "https://basescan.org";
534
+ readonly apiUrl: "https://api.basescan.org/api";
535
+ };
536
+ };
537
+ contracts: {
538
+ readonly disputeGameFactory: {
539
+ readonly 1: {
540
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
541
+ };
542
+ };
543
+ readonly l2OutputOracle: {
544
+ readonly 1: {
545
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
546
+ };
547
+ };
548
+ readonly multicall3: {
549
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
550
+ readonly blockCreated: 5022;
551
+ };
552
+ readonly portal: {
553
+ readonly 1: {
554
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
555
+ readonly blockCreated: 17482143;
556
+ };
557
+ };
558
+ readonly l1StandardBridge: {
559
+ readonly 1: {
560
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
561
+ readonly blockCreated: 17482143;
562
+ };
563
+ };
564
+ readonly gasPriceOracle: {
565
+ readonly address: "0x420000000000000000000000000000000000000F";
566
+ };
567
+ readonly l1Block: {
568
+ readonly address: "0x4200000000000000000000000000000000000015";
569
+ };
570
+ readonly l2CrossDomainMessenger: {
571
+ readonly address: "0x4200000000000000000000000000000000000007";
572
+ };
573
+ readonly l2Erc721Bridge: {
574
+ readonly address: "0x4200000000000000000000000000000000000014";
575
+ };
576
+ readonly l2StandardBridge: {
577
+ readonly address: "0x4200000000000000000000000000000000000010";
578
+ };
579
+ readonly l2ToL1MessagePasser: {
580
+ readonly address: "0x4200000000000000000000000000000000000016";
581
+ };
582
+ };
583
+ id: 8453;
584
+ name: "Base";
585
+ nativeCurrency: {
586
+ readonly name: "Ether";
587
+ readonly symbol: "ETH";
588
+ readonly decimals: 18;
589
+ };
590
+ rpcUrls: {
591
+ readonly default: {
592
+ readonly http: readonly ["https://mainnet.base.org"];
593
+ };
594
+ };
595
+ sourceId: 1;
596
+ testnet?: boolean | undefined;
597
+ custom?: Record<string, unknown> | undefined;
598
+ fees?: import("viem").ChainFees<undefined> | undefined;
599
+ formatters: {
600
+ readonly block: {
601
+ exclude: [] | undefined;
602
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
603
+ baseFeePerGas: bigint | null;
604
+ blobGasUsed: bigint;
605
+ difficulty: bigint;
606
+ excessBlobGas: bigint;
607
+ extraData: import("viem").Hex;
608
+ gasLimit: bigint;
609
+ gasUsed: bigint;
610
+ hash: `0x${string}` | null;
611
+ logsBloom: `0x${string}` | null;
612
+ miner: import("viem").Address;
613
+ mixHash: import("viem").Hash;
614
+ nonce: `0x${string}` | null;
615
+ number: bigint | null;
616
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
617
+ parentHash: import("viem").Hash;
618
+ receiptsRoot: import("viem").Hex;
619
+ sealFields: import("viem").Hex[];
620
+ sha3Uncles: import("viem").Hash;
621
+ size: bigint;
622
+ stateRoot: import("viem").Hash;
623
+ timestamp: bigint;
624
+ totalDifficulty: bigint | null;
625
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
626
+ transactionsRoot: import("viem").Hash;
627
+ uncles: import("viem").Hash[];
628
+ withdrawals?: import("viem").Withdrawal[] | undefined;
629
+ withdrawalsRoot?: import("viem").Hex | undefined;
630
+ } & {};
631
+ type: "block";
632
+ };
633
+ readonly transaction: {
634
+ exclude: [] | undefined;
635
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
636
+ blockHash: `0x${string}` | null;
637
+ blockNumber: bigint | null;
638
+ from: import("viem").Address;
639
+ gas: bigint;
640
+ hash: import("viem").Hash;
641
+ input: import("viem").Hex;
642
+ nonce: number;
643
+ r: import("viem").Hex;
644
+ s: import("viem").Hex;
645
+ to: import("viem").Address | null;
646
+ transactionIndex: number | null;
647
+ typeHex: import("viem").Hex | null;
648
+ v: bigint;
649
+ value: bigint;
650
+ yParity: number;
651
+ gasPrice?: undefined;
652
+ maxFeePerBlobGas?: undefined;
653
+ maxFeePerGas: bigint;
654
+ maxPriorityFeePerGas: bigint;
655
+ isSystemTx?: boolean;
656
+ mint?: bigint | undefined;
657
+ sourceHash: import("viem").Hex;
658
+ type: "deposit";
659
+ } | {
660
+ r: import("viem").Hex;
661
+ s: import("viem").Hex;
662
+ v: bigint;
663
+ to: import("viem").Address | null;
664
+ from: import("viem").Address;
665
+ gas: bigint;
666
+ nonce: number;
667
+ value: bigint;
668
+ blockHash: `0x${string}` | null;
669
+ blockNumber: bigint | null;
670
+ hash: import("viem").Hash;
671
+ input: import("viem").Hex;
672
+ transactionIndex: number | null;
673
+ typeHex: import("viem").Hex | null;
674
+ accessList?: undefined;
675
+ authorizationList?: undefined;
676
+ blobVersionedHashes?: undefined;
677
+ chainId?: number | undefined;
678
+ yParity?: undefined;
679
+ type: "legacy";
680
+ gasPrice: bigint;
681
+ maxFeePerBlobGas?: undefined;
682
+ maxFeePerGas?: undefined;
683
+ maxPriorityFeePerGas?: undefined;
684
+ isSystemTx?: undefined;
685
+ mint?: undefined;
686
+ sourceHash?: undefined;
687
+ } | {
688
+ blockHash: `0x${string}` | null;
689
+ blockNumber: bigint | null;
690
+ from: import("viem").Address;
691
+ gas: bigint;
692
+ hash: import("viem").Hash;
693
+ input: import("viem").Hex;
694
+ nonce: number;
695
+ r: import("viem").Hex;
696
+ s: import("viem").Hex;
697
+ to: import("viem").Address | null;
698
+ transactionIndex: number | null;
699
+ typeHex: import("viem").Hex | null;
700
+ v: bigint;
701
+ value: bigint;
702
+ yParity: number;
703
+ accessList: import("viem").AccessList;
704
+ authorizationList?: undefined;
705
+ blobVersionedHashes?: undefined;
706
+ chainId: number;
707
+ type: "eip2930";
708
+ gasPrice: bigint;
709
+ maxFeePerBlobGas?: undefined;
710
+ maxFeePerGas?: undefined;
711
+ maxPriorityFeePerGas?: undefined;
712
+ isSystemTx?: undefined;
713
+ mint?: undefined;
714
+ sourceHash?: undefined;
715
+ } | {
716
+ blockHash: `0x${string}` | null;
717
+ blockNumber: bigint | null;
718
+ from: import("viem").Address;
719
+ gas: bigint;
720
+ hash: import("viem").Hash;
721
+ input: import("viem").Hex;
722
+ nonce: number;
723
+ r: import("viem").Hex;
724
+ s: import("viem").Hex;
725
+ to: import("viem").Address | null;
726
+ transactionIndex: number | null;
727
+ typeHex: import("viem").Hex | null;
728
+ v: bigint;
729
+ value: bigint;
730
+ yParity: number;
731
+ accessList: import("viem").AccessList;
732
+ authorizationList?: undefined;
733
+ blobVersionedHashes?: undefined;
734
+ chainId: number;
735
+ type: "eip1559";
736
+ gasPrice?: undefined;
737
+ maxFeePerBlobGas?: undefined;
738
+ maxFeePerGas: bigint;
739
+ maxPriorityFeePerGas: bigint;
740
+ isSystemTx?: undefined;
741
+ mint?: undefined;
742
+ sourceHash?: undefined;
743
+ } | {
744
+ blockHash: `0x${string}` | null;
745
+ blockNumber: bigint | null;
746
+ from: import("viem").Address;
747
+ gas: bigint;
748
+ hash: import("viem").Hash;
749
+ input: import("viem").Hex;
750
+ nonce: number;
751
+ r: import("viem").Hex;
752
+ s: import("viem").Hex;
753
+ to: import("viem").Address | null;
754
+ transactionIndex: number | null;
755
+ typeHex: import("viem").Hex | null;
756
+ v: bigint;
757
+ value: bigint;
758
+ yParity: number;
759
+ accessList: import("viem").AccessList;
760
+ authorizationList?: undefined;
761
+ blobVersionedHashes: readonly import("viem").Hex[];
762
+ chainId: number;
763
+ type: "eip4844";
764
+ gasPrice?: undefined;
765
+ maxFeePerBlobGas: bigint;
766
+ maxFeePerGas: bigint;
767
+ maxPriorityFeePerGas: bigint;
768
+ isSystemTx?: undefined;
769
+ mint?: undefined;
770
+ sourceHash?: undefined;
771
+ } | {
772
+ blockHash: `0x${string}` | null;
773
+ blockNumber: bigint | null;
774
+ from: import("viem").Address;
775
+ gas: bigint;
776
+ hash: import("viem").Hash;
777
+ input: import("viem").Hex;
778
+ nonce: number;
779
+ r: import("viem").Hex;
780
+ s: import("viem").Hex;
781
+ to: import("viem").Address | null;
782
+ transactionIndex: number | null;
783
+ typeHex: import("viem").Hex | null;
784
+ v: bigint;
785
+ value: bigint;
786
+ yParity: number;
787
+ accessList: import("viem").AccessList;
788
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
789
+ blobVersionedHashes?: undefined;
790
+ chainId: number;
791
+ type: "eip7702";
792
+ gasPrice?: undefined;
793
+ maxFeePerBlobGas?: undefined;
794
+ maxFeePerGas: bigint;
795
+ maxPriorityFeePerGas: bigint;
796
+ isSystemTx?: undefined;
797
+ mint?: undefined;
798
+ sourceHash?: undefined;
799
+ }) & {};
800
+ type: "transaction";
801
+ };
802
+ readonly transactionReceipt: {
803
+ exclude: [] | undefined;
804
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
805
+ blobGasPrice?: bigint | undefined;
806
+ blobGasUsed?: bigint | undefined;
807
+ blockHash: import("viem").Hash;
808
+ blockNumber: bigint;
809
+ contractAddress: import("viem").Address | null | undefined;
810
+ cumulativeGasUsed: bigint;
811
+ effectiveGasPrice: bigint;
812
+ from: import("viem").Address;
813
+ gasUsed: bigint;
814
+ logs: import("viem").Log<bigint, number, false>[];
815
+ logsBloom: import("viem").Hex;
816
+ root?: import("viem").Hash | undefined;
817
+ status: "success" | "reverted";
818
+ to: import("viem").Address | null;
819
+ transactionHash: import("viem").Hash;
820
+ transactionIndex: number;
821
+ type: import("viem").TransactionType;
822
+ l1GasPrice: bigint | null;
823
+ l1GasUsed: bigint | null;
824
+ l1Fee: bigint | null;
825
+ l1FeeScalar: number | null;
826
+ } & {};
827
+ type: "transactionReceipt";
828
+ };
829
+ };
830
+ serializers: {
831
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
832
+ };
833
+ }>, "address" | "args" | "abi" | "functionName">>) => Promise<import("viem").EstimateContractGasReturnType>;
834
+ } & {
835
+ batchSimulate: (args: readonly [readonly {
836
+ account: `0x${string}`;
837
+ target: `0x${string}`;
838
+ data: `0x${string}`;
839
+ }[]], options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<readonly [{
840
+ readonly inputs: readonly [{
841
+ readonly components: readonly [{
842
+ readonly internalType: "Account";
843
+ readonly name: "account";
844
+ readonly type: "bytes21";
845
+ }, {
846
+ readonly internalType: "address";
847
+ readonly name: "target";
848
+ readonly type: "address";
849
+ }, {
850
+ readonly internalType: "bytes";
851
+ readonly name: "data";
852
+ readonly type: "bytes";
853
+ }];
854
+ readonly internalType: "struct IRouter.SimulateData[]";
855
+ readonly name: "calls";
856
+ readonly type: "tuple[]";
857
+ }];
858
+ readonly name: "batchSimulate";
859
+ readonly outputs: readonly [{
860
+ readonly internalType: "bytes[]";
861
+ readonly name: "";
862
+ readonly type: "bytes[]";
863
+ }];
864
+ readonly stateMutability: "nonpayable";
865
+ readonly type: "function";
866
+ }, {
867
+ readonly inputs: readonly [{
868
+ readonly components: readonly [{
869
+ readonly internalType: "uint8";
870
+ readonly name: "accountId";
871
+ readonly type: "uint8";
872
+ }, {
873
+ readonly internalType: "bytes";
874
+ readonly name: "data";
875
+ readonly type: "bytes";
876
+ }];
877
+ readonly internalType: "struct IRouter.DirectCall[]";
878
+ readonly name: "data";
879
+ readonly type: "tuple[]";
880
+ }, {
881
+ readonly internalType: "bool";
882
+ readonly name: "requireMarginCheckCall";
883
+ readonly type: "bool";
884
+ }];
885
+ readonly name: "directCall";
886
+ readonly outputs: readonly [{
887
+ readonly internalType: "bytes[]";
888
+ readonly name: "";
889
+ readonly type: "bytes[]";
890
+ }];
891
+ readonly stateMutability: "nonpayable";
892
+ readonly type: "function";
893
+ }, {
894
+ readonly inputs: readonly [{
895
+ readonly internalType: "bytes";
896
+ readonly name: "data";
897
+ readonly type: "bytes";
898
+ }];
899
+ readonly name: "viewCall";
900
+ readonly outputs: readonly [{
901
+ readonly internalType: "bytes";
902
+ readonly name: "";
903
+ readonly type: "bytes";
904
+ }];
905
+ readonly stateMutability: "view";
906
+ readonly type: "function";
907
+ }], "batchSimulate", readonly [readonly {
908
+ account: `0x${string}`;
909
+ target: `0x${string}`;
910
+ data: `0x${string}`;
911
+ }[]], {
912
+ blockExplorers: {
913
+ readonly default: {
914
+ readonly name: "Basescan";
915
+ readonly url: "https://basescan.org";
916
+ readonly apiUrl: "https://api.basescan.org/api";
917
+ };
918
+ };
919
+ contracts: {
920
+ readonly disputeGameFactory: {
921
+ readonly 1: {
922
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
923
+ };
924
+ };
925
+ readonly l2OutputOracle: {
926
+ readonly 1: {
927
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
928
+ };
929
+ };
930
+ readonly multicall3: {
931
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
932
+ readonly blockCreated: 5022;
933
+ };
934
+ readonly portal: {
935
+ readonly 1: {
936
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
937
+ readonly blockCreated: 17482143;
938
+ };
939
+ };
940
+ readonly l1StandardBridge: {
941
+ readonly 1: {
942
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
943
+ readonly blockCreated: 17482143;
944
+ };
945
+ };
946
+ readonly gasPriceOracle: {
947
+ readonly address: "0x420000000000000000000000000000000000000F";
948
+ };
949
+ readonly l1Block: {
950
+ readonly address: "0x4200000000000000000000000000000000000015";
951
+ };
952
+ readonly l2CrossDomainMessenger: {
953
+ readonly address: "0x4200000000000000000000000000000000000007";
954
+ };
955
+ readonly l2Erc721Bridge: {
956
+ readonly address: "0x4200000000000000000000000000000000000014";
957
+ };
958
+ readonly l2StandardBridge: {
959
+ readonly address: "0x4200000000000000000000000000000000000010";
960
+ };
961
+ readonly l2ToL1MessagePasser: {
962
+ readonly address: "0x4200000000000000000000000000000000000016";
963
+ };
964
+ };
965
+ id: 8453;
966
+ name: "Base";
967
+ nativeCurrency: {
968
+ readonly name: "Ether";
969
+ readonly symbol: "ETH";
970
+ readonly decimals: 18;
971
+ };
972
+ rpcUrls: {
973
+ readonly default: {
974
+ readonly http: readonly ["https://mainnet.base.org"];
975
+ };
976
+ };
977
+ sourceId: 1;
978
+ testnet?: boolean | undefined;
979
+ custom?: Record<string, unknown> | undefined;
980
+ fees?: import("viem").ChainFees<undefined> | undefined;
981
+ formatters: {
982
+ readonly block: {
983
+ exclude: [] | undefined;
984
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
985
+ baseFeePerGas: bigint | null;
986
+ blobGasUsed: bigint;
987
+ difficulty: bigint;
988
+ excessBlobGas: bigint;
989
+ extraData: import("viem").Hex;
990
+ gasLimit: bigint;
991
+ gasUsed: bigint;
992
+ hash: `0x${string}` | null;
993
+ logsBloom: `0x${string}` | null;
994
+ miner: import("viem").Address;
995
+ mixHash: import("viem").Hash;
996
+ nonce: `0x${string}` | null;
997
+ number: bigint | null;
998
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
999
+ parentHash: import("viem").Hash;
1000
+ receiptsRoot: import("viem").Hex;
1001
+ sealFields: import("viem").Hex[];
1002
+ sha3Uncles: import("viem").Hash;
1003
+ size: bigint;
1004
+ stateRoot: import("viem").Hash;
1005
+ timestamp: bigint;
1006
+ totalDifficulty: bigint | null;
1007
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
1008
+ transactionsRoot: import("viem").Hash;
1009
+ uncles: import("viem").Hash[];
1010
+ withdrawals?: import("viem").Withdrawal[] | undefined;
1011
+ withdrawalsRoot?: import("viem").Hex | undefined;
1012
+ } & {};
1013
+ type: "block";
1014
+ };
1015
+ readonly transaction: {
1016
+ exclude: [] | undefined;
1017
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
1018
+ blockHash: `0x${string}` | null;
1019
+ blockNumber: bigint | null;
1020
+ from: import("viem").Address;
1021
+ gas: bigint;
1022
+ hash: import("viem").Hash;
1023
+ input: import("viem").Hex;
1024
+ nonce: number;
1025
+ r: import("viem").Hex;
1026
+ s: import("viem").Hex;
1027
+ to: import("viem").Address | null;
1028
+ transactionIndex: number | null;
1029
+ typeHex: import("viem").Hex | null;
1030
+ v: bigint;
1031
+ value: bigint;
1032
+ yParity: number;
1033
+ gasPrice?: undefined;
1034
+ maxFeePerBlobGas?: undefined;
1035
+ maxFeePerGas: bigint;
1036
+ maxPriorityFeePerGas: bigint;
1037
+ isSystemTx?: boolean;
1038
+ mint?: bigint | undefined;
1039
+ sourceHash: import("viem").Hex;
1040
+ type: "deposit";
1041
+ } | {
1042
+ r: import("viem").Hex;
1043
+ s: import("viem").Hex;
1044
+ v: bigint;
1045
+ to: import("viem").Address | null;
1046
+ from: import("viem").Address;
1047
+ gas: bigint;
1048
+ nonce: number;
1049
+ value: bigint;
1050
+ blockHash: `0x${string}` | null;
1051
+ blockNumber: bigint | null;
1052
+ hash: import("viem").Hash;
1053
+ input: import("viem").Hex;
1054
+ transactionIndex: number | null;
1055
+ typeHex: import("viem").Hex | null;
1056
+ accessList?: undefined;
1057
+ authorizationList?: undefined;
1058
+ blobVersionedHashes?: undefined;
1059
+ chainId?: number | undefined;
1060
+ yParity?: undefined;
1061
+ type: "legacy";
1062
+ gasPrice: bigint;
1063
+ maxFeePerBlobGas?: undefined;
1064
+ maxFeePerGas?: undefined;
1065
+ maxPriorityFeePerGas?: undefined;
1066
+ isSystemTx?: undefined;
1067
+ mint?: undefined;
1068
+ sourceHash?: undefined;
1069
+ } | {
1070
+ blockHash: `0x${string}` | null;
1071
+ blockNumber: bigint | null;
1072
+ from: import("viem").Address;
1073
+ gas: bigint;
1074
+ hash: import("viem").Hash;
1075
+ input: import("viem").Hex;
1076
+ nonce: number;
1077
+ r: import("viem").Hex;
1078
+ s: import("viem").Hex;
1079
+ to: import("viem").Address | null;
1080
+ transactionIndex: number | null;
1081
+ typeHex: import("viem").Hex | null;
1082
+ v: bigint;
1083
+ value: bigint;
1084
+ yParity: number;
1085
+ accessList: import("viem").AccessList;
1086
+ authorizationList?: undefined;
1087
+ blobVersionedHashes?: undefined;
1088
+ chainId: number;
1089
+ type: "eip2930";
1090
+ gasPrice: bigint;
1091
+ maxFeePerBlobGas?: undefined;
1092
+ maxFeePerGas?: undefined;
1093
+ maxPriorityFeePerGas?: undefined;
1094
+ isSystemTx?: undefined;
1095
+ mint?: undefined;
1096
+ sourceHash?: undefined;
1097
+ } | {
1098
+ blockHash: `0x${string}` | null;
1099
+ blockNumber: bigint | null;
1100
+ from: import("viem").Address;
1101
+ gas: bigint;
1102
+ hash: import("viem").Hash;
1103
+ input: import("viem").Hex;
1104
+ nonce: number;
1105
+ r: import("viem").Hex;
1106
+ s: import("viem").Hex;
1107
+ to: import("viem").Address | null;
1108
+ transactionIndex: number | null;
1109
+ typeHex: import("viem").Hex | null;
1110
+ v: bigint;
1111
+ value: bigint;
1112
+ yParity: number;
1113
+ accessList: import("viem").AccessList;
1114
+ authorizationList?: undefined;
1115
+ blobVersionedHashes?: undefined;
1116
+ chainId: number;
1117
+ type: "eip1559";
1118
+ gasPrice?: undefined;
1119
+ maxFeePerBlobGas?: undefined;
1120
+ maxFeePerGas: bigint;
1121
+ maxPriorityFeePerGas: bigint;
1122
+ isSystemTx?: undefined;
1123
+ mint?: undefined;
1124
+ sourceHash?: undefined;
1125
+ } | {
1126
+ blockHash: `0x${string}` | null;
1127
+ blockNumber: bigint | null;
1128
+ from: import("viem").Address;
1129
+ gas: bigint;
1130
+ hash: import("viem").Hash;
1131
+ input: import("viem").Hex;
1132
+ nonce: number;
1133
+ r: import("viem").Hex;
1134
+ s: import("viem").Hex;
1135
+ to: import("viem").Address | null;
1136
+ transactionIndex: number | null;
1137
+ typeHex: import("viem").Hex | null;
1138
+ v: bigint;
1139
+ value: bigint;
1140
+ yParity: number;
1141
+ accessList: import("viem").AccessList;
1142
+ authorizationList?: undefined;
1143
+ blobVersionedHashes: readonly import("viem").Hex[];
1144
+ chainId: number;
1145
+ type: "eip4844";
1146
+ gasPrice?: undefined;
1147
+ maxFeePerBlobGas: bigint;
1148
+ maxFeePerGas: bigint;
1149
+ maxPriorityFeePerGas: bigint;
1150
+ isSystemTx?: undefined;
1151
+ mint?: undefined;
1152
+ sourceHash?: undefined;
1153
+ } | {
1154
+ blockHash: `0x${string}` | null;
1155
+ blockNumber: bigint | null;
1156
+ from: import("viem").Address;
1157
+ gas: bigint;
1158
+ hash: import("viem").Hash;
1159
+ input: import("viem").Hex;
1160
+ nonce: number;
1161
+ r: import("viem").Hex;
1162
+ s: import("viem").Hex;
1163
+ to: import("viem").Address | null;
1164
+ transactionIndex: number | null;
1165
+ typeHex: import("viem").Hex | null;
1166
+ v: bigint;
1167
+ value: bigint;
1168
+ yParity: number;
1169
+ accessList: import("viem").AccessList;
1170
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
1171
+ blobVersionedHashes?: undefined;
1172
+ chainId: number;
1173
+ type: "eip7702";
1174
+ gasPrice?: undefined;
1175
+ maxFeePerBlobGas?: undefined;
1176
+ maxFeePerGas: bigint;
1177
+ maxPriorityFeePerGas: bigint;
1178
+ isSystemTx?: undefined;
1179
+ mint?: undefined;
1180
+ sourceHash?: undefined;
1181
+ }) & {};
1182
+ type: "transaction";
1183
+ };
1184
+ readonly transactionReceipt: {
1185
+ exclude: [] | undefined;
1186
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
1187
+ blobGasPrice?: bigint | undefined;
1188
+ blobGasUsed?: bigint | undefined;
1189
+ blockHash: import("viem").Hash;
1190
+ blockNumber: bigint;
1191
+ contractAddress: import("viem").Address | null | undefined;
1192
+ cumulativeGasUsed: bigint;
1193
+ effectiveGasPrice: bigint;
1194
+ from: import("viem").Address;
1195
+ gasUsed: bigint;
1196
+ logs: import("viem").Log<bigint, number, false>[];
1197
+ logsBloom: import("viem").Hex;
1198
+ root?: import("viem").Hash | undefined;
1199
+ status: "success" | "reverted";
1200
+ to: import("viem").Address | null;
1201
+ transactionHash: import("viem").Hash;
1202
+ transactionIndex: number;
1203
+ type: import("viem").TransactionType;
1204
+ l1GasPrice: bigint | null;
1205
+ l1GasUsed: bigint | null;
1206
+ l1Fee: bigint | null;
1207
+ l1FeeScalar: number | null;
1208
+ } & {};
1209
+ type: "transactionReceipt";
1210
+ };
1211
+ };
1212
+ serializers: {
1213
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
1214
+ };
1215
+ }>, "address" | "args" | "abi" | "functionName">>) => Promise<import("viem").EstimateContractGasReturnType>;
1216
+ directCall: (args: readonly [readonly {
1217
+ accountId: number;
1218
+ data: `0x${string}`;
1219
+ }[], boolean], options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<readonly [{
1220
+ readonly inputs: readonly [{
1221
+ readonly components: readonly [{
1222
+ readonly internalType: "Account";
1223
+ readonly name: "account";
1224
+ readonly type: "bytes21";
1225
+ }, {
1226
+ readonly internalType: "address";
1227
+ readonly name: "target";
1228
+ readonly type: "address";
1229
+ }, {
1230
+ readonly internalType: "bytes";
1231
+ readonly name: "data";
1232
+ readonly type: "bytes";
1233
+ }];
1234
+ readonly internalType: "struct IRouter.SimulateData[]";
1235
+ readonly name: "calls";
1236
+ readonly type: "tuple[]";
1237
+ }];
1238
+ readonly name: "batchSimulate";
1239
+ readonly outputs: readonly [{
1240
+ readonly internalType: "bytes[]";
1241
+ readonly name: "";
1242
+ readonly type: "bytes[]";
1243
+ }];
1244
+ readonly stateMutability: "nonpayable";
1245
+ readonly type: "function";
1246
+ }, {
1247
+ readonly inputs: readonly [{
1248
+ readonly components: readonly [{
1249
+ readonly internalType: "uint8";
1250
+ readonly name: "accountId";
1251
+ readonly type: "uint8";
1252
+ }, {
1253
+ readonly internalType: "bytes";
1254
+ readonly name: "data";
1255
+ readonly type: "bytes";
1256
+ }];
1257
+ readonly internalType: "struct IRouter.DirectCall[]";
1258
+ readonly name: "data";
1259
+ readonly type: "tuple[]";
1260
+ }, {
1261
+ readonly internalType: "bool";
1262
+ readonly name: "requireMarginCheckCall";
1263
+ readonly type: "bool";
1264
+ }];
1265
+ readonly name: "directCall";
1266
+ readonly outputs: readonly [{
1267
+ readonly internalType: "bytes[]";
1268
+ readonly name: "";
1269
+ readonly type: "bytes[]";
1270
+ }];
1271
+ readonly stateMutability: "nonpayable";
1272
+ readonly type: "function";
1273
+ }, {
1274
+ readonly inputs: readonly [{
1275
+ readonly internalType: "bytes";
1276
+ readonly name: "data";
1277
+ readonly type: "bytes";
1278
+ }];
1279
+ readonly name: "viewCall";
1280
+ readonly outputs: readonly [{
1281
+ readonly internalType: "bytes";
1282
+ readonly name: "";
1283
+ readonly type: "bytes";
1284
+ }];
1285
+ readonly stateMutability: "view";
1286
+ readonly type: "function";
1287
+ }], "directCall", readonly [readonly {
1288
+ accountId: number;
1289
+ data: `0x${string}`;
1290
+ }[], boolean], {
1291
+ blockExplorers: {
1292
+ readonly default: {
1293
+ readonly name: "Basescan";
1294
+ readonly url: "https://basescan.org";
1295
+ readonly apiUrl: "https://api.basescan.org/api";
1296
+ };
1297
+ };
1298
+ contracts: {
1299
+ readonly disputeGameFactory: {
1300
+ readonly 1: {
1301
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
1302
+ };
1303
+ };
1304
+ readonly l2OutputOracle: {
1305
+ readonly 1: {
1306
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
1307
+ };
1308
+ };
1309
+ readonly multicall3: {
1310
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1311
+ readonly blockCreated: 5022;
1312
+ };
1313
+ readonly portal: {
1314
+ readonly 1: {
1315
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
1316
+ readonly blockCreated: 17482143;
1317
+ };
1318
+ };
1319
+ readonly l1StandardBridge: {
1320
+ readonly 1: {
1321
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
1322
+ readonly blockCreated: 17482143;
1323
+ };
1324
+ };
1325
+ readonly gasPriceOracle: {
1326
+ readonly address: "0x420000000000000000000000000000000000000F";
1327
+ };
1328
+ readonly l1Block: {
1329
+ readonly address: "0x4200000000000000000000000000000000000015";
1330
+ };
1331
+ readonly l2CrossDomainMessenger: {
1332
+ readonly address: "0x4200000000000000000000000000000000000007";
1333
+ };
1334
+ readonly l2Erc721Bridge: {
1335
+ readonly address: "0x4200000000000000000000000000000000000014";
1336
+ };
1337
+ readonly l2StandardBridge: {
1338
+ readonly address: "0x4200000000000000000000000000000000000010";
1339
+ };
1340
+ readonly l2ToL1MessagePasser: {
1341
+ readonly address: "0x4200000000000000000000000000000000000016";
1342
+ };
1343
+ };
1344
+ id: 8453;
1345
+ name: "Base";
1346
+ nativeCurrency: {
1347
+ readonly name: "Ether";
1348
+ readonly symbol: "ETH";
1349
+ readonly decimals: 18;
1350
+ };
1351
+ rpcUrls: {
1352
+ readonly default: {
1353
+ readonly http: readonly ["https://mainnet.base.org"];
1354
+ };
1355
+ };
1356
+ sourceId: 1;
1357
+ testnet?: boolean | undefined;
1358
+ custom?: Record<string, unknown> | undefined;
1359
+ fees?: import("viem").ChainFees<undefined> | undefined;
1360
+ formatters: {
1361
+ readonly block: {
1362
+ exclude: [] | undefined;
1363
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
1364
+ baseFeePerGas: bigint | null;
1365
+ blobGasUsed: bigint;
1366
+ difficulty: bigint;
1367
+ excessBlobGas: bigint;
1368
+ extraData: import("viem").Hex;
1369
+ gasLimit: bigint;
1370
+ gasUsed: bigint;
1371
+ hash: `0x${string}` | null;
1372
+ logsBloom: `0x${string}` | null;
1373
+ miner: import("viem").Address;
1374
+ mixHash: import("viem").Hash;
1375
+ nonce: `0x${string}` | null;
1376
+ number: bigint | null;
1377
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
1378
+ parentHash: import("viem").Hash;
1379
+ receiptsRoot: import("viem").Hex;
1380
+ sealFields: import("viem").Hex[];
1381
+ sha3Uncles: import("viem").Hash;
1382
+ size: bigint;
1383
+ stateRoot: import("viem").Hash;
1384
+ timestamp: bigint;
1385
+ totalDifficulty: bigint | null;
1386
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
1387
+ transactionsRoot: import("viem").Hash;
1388
+ uncles: import("viem").Hash[];
1389
+ withdrawals?: import("viem").Withdrawal[] | undefined;
1390
+ withdrawalsRoot?: import("viem").Hex | undefined;
1391
+ } & {};
1392
+ type: "block";
1393
+ };
1394
+ readonly transaction: {
1395
+ exclude: [] | undefined;
1396
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
1397
+ blockHash: `0x${string}` | null;
1398
+ blockNumber: bigint | null;
1399
+ from: import("viem").Address;
1400
+ gas: bigint;
1401
+ hash: import("viem").Hash;
1402
+ input: import("viem").Hex;
1403
+ nonce: number;
1404
+ r: import("viem").Hex;
1405
+ s: import("viem").Hex;
1406
+ to: import("viem").Address | null;
1407
+ transactionIndex: number | null;
1408
+ typeHex: import("viem").Hex | null;
1409
+ v: bigint;
1410
+ value: bigint;
1411
+ yParity: number;
1412
+ gasPrice?: undefined;
1413
+ maxFeePerBlobGas?: undefined;
1414
+ maxFeePerGas: bigint;
1415
+ maxPriorityFeePerGas: bigint;
1416
+ isSystemTx?: boolean;
1417
+ mint?: bigint | undefined;
1418
+ sourceHash: import("viem").Hex;
1419
+ type: "deposit";
1420
+ } | {
1421
+ r: import("viem").Hex;
1422
+ s: import("viem").Hex;
1423
+ v: bigint;
1424
+ to: import("viem").Address | null;
1425
+ from: import("viem").Address;
1426
+ gas: bigint;
1427
+ nonce: number;
1428
+ value: bigint;
1429
+ blockHash: `0x${string}` | null;
1430
+ blockNumber: bigint | null;
1431
+ hash: import("viem").Hash;
1432
+ input: import("viem").Hex;
1433
+ transactionIndex: number | null;
1434
+ typeHex: import("viem").Hex | null;
1435
+ accessList?: undefined;
1436
+ authorizationList?: undefined;
1437
+ blobVersionedHashes?: undefined;
1438
+ chainId?: number | undefined;
1439
+ yParity?: undefined;
1440
+ type: "legacy";
1441
+ gasPrice: bigint;
1442
+ maxFeePerBlobGas?: undefined;
1443
+ maxFeePerGas?: undefined;
1444
+ maxPriorityFeePerGas?: undefined;
1445
+ isSystemTx?: undefined;
1446
+ mint?: undefined;
1447
+ sourceHash?: undefined;
1448
+ } | {
1449
+ blockHash: `0x${string}` | null;
1450
+ blockNumber: bigint | null;
1451
+ from: import("viem").Address;
1452
+ gas: bigint;
1453
+ hash: import("viem").Hash;
1454
+ input: import("viem").Hex;
1455
+ nonce: number;
1456
+ r: import("viem").Hex;
1457
+ s: import("viem").Hex;
1458
+ to: import("viem").Address | null;
1459
+ transactionIndex: number | null;
1460
+ typeHex: import("viem").Hex | null;
1461
+ v: bigint;
1462
+ value: bigint;
1463
+ yParity: number;
1464
+ accessList: import("viem").AccessList;
1465
+ authorizationList?: undefined;
1466
+ blobVersionedHashes?: undefined;
1467
+ chainId: number;
1468
+ type: "eip2930";
1469
+ gasPrice: bigint;
1470
+ maxFeePerBlobGas?: undefined;
1471
+ maxFeePerGas?: undefined;
1472
+ maxPriorityFeePerGas?: undefined;
1473
+ isSystemTx?: undefined;
1474
+ mint?: undefined;
1475
+ sourceHash?: undefined;
1476
+ } | {
1477
+ blockHash: `0x${string}` | null;
1478
+ blockNumber: bigint | null;
1479
+ from: import("viem").Address;
1480
+ gas: bigint;
1481
+ hash: import("viem").Hash;
1482
+ input: import("viem").Hex;
1483
+ nonce: number;
1484
+ r: import("viem").Hex;
1485
+ s: import("viem").Hex;
1486
+ to: import("viem").Address | null;
1487
+ transactionIndex: number | null;
1488
+ typeHex: import("viem").Hex | null;
1489
+ v: bigint;
1490
+ value: bigint;
1491
+ yParity: number;
1492
+ accessList: import("viem").AccessList;
1493
+ authorizationList?: undefined;
1494
+ blobVersionedHashes?: undefined;
1495
+ chainId: number;
1496
+ type: "eip1559";
1497
+ gasPrice?: undefined;
1498
+ maxFeePerBlobGas?: undefined;
1499
+ maxFeePerGas: bigint;
1500
+ maxPriorityFeePerGas: bigint;
1501
+ isSystemTx?: undefined;
1502
+ mint?: undefined;
1503
+ sourceHash?: undefined;
1504
+ } | {
1505
+ blockHash: `0x${string}` | null;
1506
+ blockNumber: bigint | null;
1507
+ from: import("viem").Address;
1508
+ gas: bigint;
1509
+ hash: import("viem").Hash;
1510
+ input: import("viem").Hex;
1511
+ nonce: number;
1512
+ r: import("viem").Hex;
1513
+ s: import("viem").Hex;
1514
+ to: import("viem").Address | null;
1515
+ transactionIndex: number | null;
1516
+ typeHex: import("viem").Hex | null;
1517
+ v: bigint;
1518
+ value: bigint;
1519
+ yParity: number;
1520
+ accessList: import("viem").AccessList;
1521
+ authorizationList?: undefined;
1522
+ blobVersionedHashes: readonly import("viem").Hex[];
1523
+ chainId: number;
1524
+ type: "eip4844";
1525
+ gasPrice?: undefined;
1526
+ maxFeePerBlobGas: bigint;
1527
+ maxFeePerGas: bigint;
1528
+ maxPriorityFeePerGas: bigint;
1529
+ isSystemTx?: undefined;
1530
+ mint?: undefined;
1531
+ sourceHash?: undefined;
1532
+ } | {
1533
+ blockHash: `0x${string}` | null;
1534
+ blockNumber: bigint | null;
1535
+ from: import("viem").Address;
1536
+ gas: bigint;
1537
+ hash: import("viem").Hash;
1538
+ input: import("viem").Hex;
1539
+ nonce: number;
1540
+ r: import("viem").Hex;
1541
+ s: import("viem").Hex;
1542
+ to: import("viem").Address | null;
1543
+ transactionIndex: number | null;
1544
+ typeHex: import("viem").Hex | null;
1545
+ v: bigint;
1546
+ value: bigint;
1547
+ yParity: number;
1548
+ accessList: import("viem").AccessList;
1549
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
1550
+ blobVersionedHashes?: undefined;
1551
+ chainId: number;
1552
+ type: "eip7702";
1553
+ gasPrice?: undefined;
1554
+ maxFeePerBlobGas?: undefined;
1555
+ maxFeePerGas: bigint;
1556
+ maxPriorityFeePerGas: bigint;
1557
+ isSystemTx?: undefined;
1558
+ mint?: undefined;
1559
+ sourceHash?: undefined;
1560
+ }) & {};
1561
+ type: "transaction";
1562
+ };
1563
+ readonly transactionReceipt: {
1564
+ exclude: [] | undefined;
1565
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
1566
+ blobGasPrice?: bigint | undefined;
1567
+ blobGasUsed?: bigint | undefined;
1568
+ blockHash: import("viem").Hash;
1569
+ blockNumber: bigint;
1570
+ contractAddress: import("viem").Address | null | undefined;
1571
+ cumulativeGasUsed: bigint;
1572
+ effectiveGasPrice: bigint;
1573
+ from: import("viem").Address;
1574
+ gasUsed: bigint;
1575
+ logs: import("viem").Log<bigint, number, false>[];
1576
+ logsBloom: import("viem").Hex;
1577
+ root?: import("viem").Hash | undefined;
1578
+ status: "success" | "reverted";
1579
+ to: import("viem").Address | null;
1580
+ transactionHash: import("viem").Hash;
1581
+ transactionIndex: number;
1582
+ type: import("viem").TransactionType;
1583
+ l1GasPrice: bigint | null;
1584
+ l1GasUsed: bigint | null;
1585
+ l1Fee: bigint | null;
1586
+ l1FeeScalar: number | null;
1587
+ } & {};
1588
+ type: "transactionReceipt";
1589
+ };
1590
+ };
1591
+ serializers: {
1592
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
1593
+ };
1594
+ }>, "address" | "args" | "abi" | "functionName">>) => Promise<import("viem").EstimateContractGasReturnType>;
1595
+ };
1596
+ simulate: {
1597
+ batchSimulate: <chainOverride extends import("viem").Chain | undefined = undefined, accountOverride extends import("viem").Account | import("viem").Address | undefined = undefined>(args: readonly [readonly {
1598
+ account: `0x${string}`;
1599
+ target: `0x${string}`;
1600
+ data: `0x${string}`;
1601
+ }[]], options?: Omit<import("viem").SimulateContractParameters<readonly [{
1602
+ readonly inputs: readonly [{
1603
+ readonly components: readonly [{
1604
+ readonly internalType: "Account";
1605
+ readonly name: "account";
1606
+ readonly type: "bytes21";
1607
+ }, {
1608
+ readonly internalType: "address";
1609
+ readonly name: "target";
1610
+ readonly type: "address";
1611
+ }, {
1612
+ readonly internalType: "bytes";
1613
+ readonly name: "data";
1614
+ readonly type: "bytes";
1615
+ }];
1616
+ readonly internalType: "struct IRouter.SimulateData[]";
1617
+ readonly name: "calls";
1618
+ readonly type: "tuple[]";
1619
+ }];
1620
+ readonly name: "batchSimulate";
1621
+ readonly outputs: readonly [{
1622
+ readonly internalType: "bytes[]";
1623
+ readonly name: "";
1624
+ readonly type: "bytes[]";
1625
+ }];
1626
+ readonly stateMutability: "nonpayable";
1627
+ readonly type: "function";
1628
+ }, {
1629
+ readonly inputs: readonly [{
1630
+ readonly components: readonly [{
1631
+ readonly internalType: "uint8";
1632
+ readonly name: "accountId";
1633
+ readonly type: "uint8";
1634
+ }, {
1635
+ readonly internalType: "bytes";
1636
+ readonly name: "data";
1637
+ readonly type: "bytes";
1638
+ }];
1639
+ readonly internalType: "struct IRouter.DirectCall[]";
1640
+ readonly name: "data";
1641
+ readonly type: "tuple[]";
1642
+ }, {
1643
+ readonly internalType: "bool";
1644
+ readonly name: "requireMarginCheckCall";
1645
+ readonly type: "bool";
1646
+ }];
1647
+ readonly name: "directCall";
1648
+ readonly outputs: readonly [{
1649
+ readonly internalType: "bytes[]";
1650
+ readonly name: "";
1651
+ readonly type: "bytes[]";
1652
+ }];
1653
+ readonly stateMutability: "nonpayable";
1654
+ readonly type: "function";
1655
+ }, {
1656
+ readonly inputs: readonly [{
1657
+ readonly internalType: "bytes";
1658
+ readonly name: "data";
1659
+ readonly type: "bytes";
1660
+ }];
1661
+ readonly name: "viewCall";
1662
+ readonly outputs: readonly [{
1663
+ readonly internalType: "bytes";
1664
+ readonly name: "";
1665
+ readonly type: "bytes";
1666
+ }];
1667
+ readonly stateMutability: "view";
1668
+ readonly type: "function";
1669
+ }], "batchSimulate", readonly [readonly {
1670
+ account: `0x${string}`;
1671
+ target: `0x${string}`;
1672
+ data: `0x${string}`;
1673
+ }[]], {
1674
+ blockExplorers: {
1675
+ readonly default: {
1676
+ readonly name: "Basescan";
1677
+ readonly url: "https://basescan.org";
1678
+ readonly apiUrl: "https://api.basescan.org/api";
1679
+ };
1680
+ };
1681
+ contracts: {
1682
+ readonly disputeGameFactory: {
1683
+ readonly 1: {
1684
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
1685
+ };
1686
+ };
1687
+ readonly l2OutputOracle: {
1688
+ readonly 1: {
1689
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
1690
+ };
1691
+ };
1692
+ readonly multicall3: {
1693
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1694
+ readonly blockCreated: 5022;
1695
+ };
1696
+ readonly portal: {
1697
+ readonly 1: {
1698
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
1699
+ readonly blockCreated: 17482143;
1700
+ };
1701
+ };
1702
+ readonly l1StandardBridge: {
1703
+ readonly 1: {
1704
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
1705
+ readonly blockCreated: 17482143;
1706
+ };
1707
+ };
1708
+ readonly gasPriceOracle: {
1709
+ readonly address: "0x420000000000000000000000000000000000000F";
1710
+ };
1711
+ readonly l1Block: {
1712
+ readonly address: "0x4200000000000000000000000000000000000015";
1713
+ };
1714
+ readonly l2CrossDomainMessenger: {
1715
+ readonly address: "0x4200000000000000000000000000000000000007";
1716
+ };
1717
+ readonly l2Erc721Bridge: {
1718
+ readonly address: "0x4200000000000000000000000000000000000014";
1719
+ };
1720
+ readonly l2StandardBridge: {
1721
+ readonly address: "0x4200000000000000000000000000000000000010";
1722
+ };
1723
+ readonly l2ToL1MessagePasser: {
1724
+ readonly address: "0x4200000000000000000000000000000000000016";
1725
+ };
1726
+ };
1727
+ id: 8453;
1728
+ name: "Base";
1729
+ nativeCurrency: {
1730
+ readonly name: "Ether";
1731
+ readonly symbol: "ETH";
1732
+ readonly decimals: 18;
1733
+ };
1734
+ rpcUrls: {
1735
+ readonly default: {
1736
+ readonly http: readonly ["https://mainnet.base.org"];
1737
+ };
1738
+ };
1739
+ sourceId: 1;
1740
+ testnet?: boolean | undefined;
1741
+ custom?: Record<string, unknown> | undefined;
1742
+ fees?: import("viem").ChainFees<undefined> | undefined;
1743
+ formatters: {
1744
+ readonly block: {
1745
+ exclude: [] | undefined;
1746
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
1747
+ baseFeePerGas: bigint | null;
1748
+ blobGasUsed: bigint;
1749
+ difficulty: bigint;
1750
+ excessBlobGas: bigint;
1751
+ extraData: import("viem").Hex;
1752
+ gasLimit: bigint;
1753
+ gasUsed: bigint;
1754
+ hash: `0x${string}` | null;
1755
+ logsBloom: `0x${string}` | null;
1756
+ miner: import("viem").Address;
1757
+ mixHash: import("viem").Hash;
1758
+ nonce: `0x${string}` | null;
1759
+ number: bigint | null;
1760
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
1761
+ parentHash: import("viem").Hash;
1762
+ receiptsRoot: import("viem").Hex;
1763
+ sealFields: import("viem").Hex[];
1764
+ sha3Uncles: import("viem").Hash;
1765
+ size: bigint;
1766
+ stateRoot: import("viem").Hash;
1767
+ timestamp: bigint;
1768
+ totalDifficulty: bigint | null;
1769
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
1770
+ transactionsRoot: import("viem").Hash;
1771
+ uncles: import("viem").Hash[];
1772
+ withdrawals?: import("viem").Withdrawal[] | undefined;
1773
+ withdrawalsRoot?: import("viem").Hex | undefined;
1774
+ } & {};
1775
+ type: "block";
1776
+ };
1777
+ readonly transaction: {
1778
+ exclude: [] | undefined;
1779
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
1780
+ blockHash: `0x${string}` | null;
1781
+ blockNumber: bigint | null;
1782
+ from: import("viem").Address;
1783
+ gas: bigint;
1784
+ hash: import("viem").Hash;
1785
+ input: import("viem").Hex;
1786
+ nonce: number;
1787
+ r: import("viem").Hex;
1788
+ s: import("viem").Hex;
1789
+ to: import("viem").Address | null;
1790
+ transactionIndex: number | null;
1791
+ typeHex: import("viem").Hex | null;
1792
+ v: bigint;
1793
+ value: bigint;
1794
+ yParity: number;
1795
+ gasPrice?: undefined;
1796
+ maxFeePerBlobGas?: undefined;
1797
+ maxFeePerGas: bigint;
1798
+ maxPriorityFeePerGas: bigint;
1799
+ isSystemTx?: boolean;
1800
+ mint?: bigint | undefined;
1801
+ sourceHash: import("viem").Hex;
1802
+ type: "deposit";
1803
+ } | {
1804
+ r: import("viem").Hex;
1805
+ s: import("viem").Hex;
1806
+ v: bigint;
1807
+ to: import("viem").Address | null;
1808
+ from: import("viem").Address;
1809
+ gas: bigint;
1810
+ nonce: number;
1811
+ value: bigint;
1812
+ blockHash: `0x${string}` | null;
1813
+ blockNumber: bigint | null;
1814
+ hash: import("viem").Hash;
1815
+ input: import("viem").Hex;
1816
+ transactionIndex: number | null;
1817
+ typeHex: import("viem").Hex | null;
1818
+ accessList?: undefined;
1819
+ authorizationList?: undefined;
1820
+ blobVersionedHashes?: undefined;
1821
+ chainId?: number | undefined;
1822
+ yParity?: undefined;
1823
+ type: "legacy";
1824
+ gasPrice: bigint;
1825
+ maxFeePerBlobGas?: undefined;
1826
+ maxFeePerGas?: undefined;
1827
+ maxPriorityFeePerGas?: undefined;
1828
+ isSystemTx?: undefined;
1829
+ mint?: undefined;
1830
+ sourceHash?: undefined;
1831
+ } | {
1832
+ blockHash: `0x${string}` | null;
1833
+ blockNumber: bigint | null;
1834
+ from: import("viem").Address;
1835
+ gas: bigint;
1836
+ hash: import("viem").Hash;
1837
+ input: import("viem").Hex;
1838
+ nonce: number;
1839
+ r: import("viem").Hex;
1840
+ s: import("viem").Hex;
1841
+ to: import("viem").Address | null;
1842
+ transactionIndex: number | null;
1843
+ typeHex: import("viem").Hex | null;
1844
+ v: bigint;
1845
+ value: bigint;
1846
+ yParity: number;
1847
+ accessList: import("viem").AccessList;
1848
+ authorizationList?: undefined;
1849
+ blobVersionedHashes?: undefined;
1850
+ chainId: number;
1851
+ type: "eip2930";
1852
+ gasPrice: bigint;
1853
+ maxFeePerBlobGas?: undefined;
1854
+ maxFeePerGas?: undefined;
1855
+ maxPriorityFeePerGas?: undefined;
1856
+ isSystemTx?: undefined;
1857
+ mint?: undefined;
1858
+ sourceHash?: undefined;
1859
+ } | {
1860
+ blockHash: `0x${string}` | null;
1861
+ blockNumber: bigint | null;
1862
+ from: import("viem").Address;
1863
+ gas: bigint;
1864
+ hash: import("viem").Hash;
1865
+ input: import("viem").Hex;
1866
+ nonce: number;
1867
+ r: import("viem").Hex;
1868
+ s: import("viem").Hex;
1869
+ to: import("viem").Address | null;
1870
+ transactionIndex: number | null;
1871
+ typeHex: import("viem").Hex | null;
1872
+ v: bigint;
1873
+ value: bigint;
1874
+ yParity: number;
1875
+ accessList: import("viem").AccessList;
1876
+ authorizationList?: undefined;
1877
+ blobVersionedHashes?: undefined;
1878
+ chainId: number;
1879
+ type: "eip1559";
1880
+ gasPrice?: undefined;
1881
+ maxFeePerBlobGas?: undefined;
1882
+ maxFeePerGas: bigint;
1883
+ maxPriorityFeePerGas: bigint;
1884
+ isSystemTx?: undefined;
1885
+ mint?: undefined;
1886
+ sourceHash?: undefined;
1887
+ } | {
1888
+ blockHash: `0x${string}` | null;
1889
+ blockNumber: bigint | null;
1890
+ from: import("viem").Address;
1891
+ gas: bigint;
1892
+ hash: import("viem").Hash;
1893
+ input: import("viem").Hex;
1894
+ nonce: number;
1895
+ r: import("viem").Hex;
1896
+ s: import("viem").Hex;
1897
+ to: import("viem").Address | null;
1898
+ transactionIndex: number | null;
1899
+ typeHex: import("viem").Hex | null;
1900
+ v: bigint;
1901
+ value: bigint;
1902
+ yParity: number;
1903
+ accessList: import("viem").AccessList;
1904
+ authorizationList?: undefined;
1905
+ blobVersionedHashes: readonly import("viem").Hex[];
1906
+ chainId: number;
1907
+ type: "eip4844";
1908
+ gasPrice?: undefined;
1909
+ maxFeePerBlobGas: bigint;
1910
+ maxFeePerGas: bigint;
1911
+ maxPriorityFeePerGas: bigint;
1912
+ isSystemTx?: undefined;
1913
+ mint?: undefined;
1914
+ sourceHash?: undefined;
1915
+ } | {
1916
+ blockHash: `0x${string}` | null;
1917
+ blockNumber: bigint | null;
1918
+ from: import("viem").Address;
1919
+ gas: bigint;
1920
+ hash: import("viem").Hash;
1921
+ input: import("viem").Hex;
1922
+ nonce: number;
1923
+ r: import("viem").Hex;
1924
+ s: import("viem").Hex;
1925
+ to: import("viem").Address | null;
1926
+ transactionIndex: number | null;
1927
+ typeHex: import("viem").Hex | null;
1928
+ v: bigint;
1929
+ value: bigint;
1930
+ yParity: number;
1931
+ accessList: import("viem").AccessList;
1932
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
1933
+ blobVersionedHashes?: undefined;
1934
+ chainId: number;
1935
+ type: "eip7702";
1936
+ gasPrice?: undefined;
1937
+ maxFeePerBlobGas?: undefined;
1938
+ maxFeePerGas: bigint;
1939
+ maxPriorityFeePerGas: bigint;
1940
+ isSystemTx?: undefined;
1941
+ mint?: undefined;
1942
+ sourceHash?: undefined;
1943
+ }) & {};
1944
+ type: "transaction";
1945
+ };
1946
+ readonly transactionReceipt: {
1947
+ exclude: [] | undefined;
1948
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
1949
+ blobGasPrice?: bigint | undefined;
1950
+ blobGasUsed?: bigint | undefined;
1951
+ blockHash: import("viem").Hash;
1952
+ blockNumber: bigint;
1953
+ contractAddress: import("viem").Address | null | undefined;
1954
+ cumulativeGasUsed: bigint;
1955
+ effectiveGasPrice: bigint;
1956
+ from: import("viem").Address;
1957
+ gasUsed: bigint;
1958
+ logs: import("viem").Log<bigint, number, false>[];
1959
+ logsBloom: import("viem").Hex;
1960
+ root?: import("viem").Hash | undefined;
1961
+ status: "success" | "reverted";
1962
+ to: import("viem").Address | null;
1963
+ transactionHash: import("viem").Hash;
1964
+ transactionIndex: number;
1965
+ type: import("viem").TransactionType;
1966
+ l1GasPrice: bigint | null;
1967
+ l1GasUsed: bigint | null;
1968
+ l1Fee: bigint | null;
1969
+ l1FeeScalar: number | null;
1970
+ } & {};
1971
+ type: "transactionReceipt";
1972
+ };
1973
+ };
1974
+ serializers: {
1975
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
1976
+ };
1977
+ }, chainOverride, accountOverride>, "address" | "args" | "abi" | "functionName"> | undefined) => Promise<import("viem").SimulateContractReturnType<readonly [{
1978
+ readonly inputs: readonly [{
1979
+ readonly components: readonly [{
1980
+ readonly internalType: "Account";
1981
+ readonly name: "account";
1982
+ readonly type: "bytes21";
1983
+ }, {
1984
+ readonly internalType: "address";
1985
+ readonly name: "target";
1986
+ readonly type: "address";
1987
+ }, {
1988
+ readonly internalType: "bytes";
1989
+ readonly name: "data";
1990
+ readonly type: "bytes";
1991
+ }];
1992
+ readonly internalType: "struct IRouter.SimulateData[]";
1993
+ readonly name: "calls";
1994
+ readonly type: "tuple[]";
1995
+ }];
1996
+ readonly name: "batchSimulate";
1997
+ readonly outputs: readonly [{
1998
+ readonly internalType: "bytes[]";
1999
+ readonly name: "";
2000
+ readonly type: "bytes[]";
2001
+ }];
2002
+ readonly stateMutability: "nonpayable";
2003
+ readonly type: "function";
2004
+ }, {
2005
+ readonly inputs: readonly [{
2006
+ readonly components: readonly [{
2007
+ readonly internalType: "uint8";
2008
+ readonly name: "accountId";
2009
+ readonly type: "uint8";
2010
+ }, {
2011
+ readonly internalType: "bytes";
2012
+ readonly name: "data";
2013
+ readonly type: "bytes";
2014
+ }];
2015
+ readonly internalType: "struct IRouter.DirectCall[]";
2016
+ readonly name: "data";
2017
+ readonly type: "tuple[]";
2018
+ }, {
2019
+ readonly internalType: "bool";
2020
+ readonly name: "requireMarginCheckCall";
2021
+ readonly type: "bool";
2022
+ }];
2023
+ readonly name: "directCall";
2024
+ readonly outputs: readonly [{
2025
+ readonly internalType: "bytes[]";
2026
+ readonly name: "";
2027
+ readonly type: "bytes[]";
2028
+ }];
2029
+ readonly stateMutability: "nonpayable";
2030
+ readonly type: "function";
2031
+ }, {
2032
+ readonly inputs: readonly [{
2033
+ readonly internalType: "bytes";
2034
+ readonly name: "data";
2035
+ readonly type: "bytes";
2036
+ }];
2037
+ readonly name: "viewCall";
2038
+ readonly outputs: readonly [{
2039
+ readonly internalType: "bytes";
2040
+ readonly name: "";
2041
+ readonly type: "bytes";
2042
+ }];
2043
+ readonly stateMutability: "view";
2044
+ readonly type: "function";
2045
+ }], "batchSimulate", readonly [readonly {
2046
+ account: `0x${string}`;
2047
+ target: `0x${string}`;
2048
+ data: `0x${string}`;
2049
+ }[]], {
2050
+ blockExplorers: {
2051
+ readonly default: {
2052
+ readonly name: "Basescan";
2053
+ readonly url: "https://basescan.org";
2054
+ readonly apiUrl: "https://api.basescan.org/api";
2055
+ };
2056
+ };
2057
+ contracts: {
2058
+ readonly disputeGameFactory: {
2059
+ readonly 1: {
2060
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
2061
+ };
2062
+ };
2063
+ readonly l2OutputOracle: {
2064
+ readonly 1: {
2065
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
2066
+ };
2067
+ };
2068
+ readonly multicall3: {
2069
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2070
+ readonly blockCreated: 5022;
2071
+ };
2072
+ readonly portal: {
2073
+ readonly 1: {
2074
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
2075
+ readonly blockCreated: 17482143;
2076
+ };
2077
+ };
2078
+ readonly l1StandardBridge: {
2079
+ readonly 1: {
2080
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
2081
+ readonly blockCreated: 17482143;
2082
+ };
2083
+ };
2084
+ readonly gasPriceOracle: {
2085
+ readonly address: "0x420000000000000000000000000000000000000F";
2086
+ };
2087
+ readonly l1Block: {
2088
+ readonly address: "0x4200000000000000000000000000000000000015";
2089
+ };
2090
+ readonly l2CrossDomainMessenger: {
2091
+ readonly address: "0x4200000000000000000000000000000000000007";
2092
+ };
2093
+ readonly l2Erc721Bridge: {
2094
+ readonly address: "0x4200000000000000000000000000000000000014";
2095
+ };
2096
+ readonly l2StandardBridge: {
2097
+ readonly address: "0x4200000000000000000000000000000000000010";
2098
+ };
2099
+ readonly l2ToL1MessagePasser: {
2100
+ readonly address: "0x4200000000000000000000000000000000000016";
2101
+ };
2102
+ };
2103
+ id: 8453;
2104
+ name: "Base";
2105
+ nativeCurrency: {
2106
+ readonly name: "Ether";
2107
+ readonly symbol: "ETH";
2108
+ readonly decimals: 18;
2109
+ };
2110
+ rpcUrls: {
2111
+ readonly default: {
2112
+ readonly http: readonly ["https://mainnet.base.org"];
2113
+ };
2114
+ };
2115
+ sourceId: 1;
2116
+ testnet?: boolean | undefined;
2117
+ custom?: Record<string, unknown> | undefined;
2118
+ fees?: import("viem").ChainFees<undefined> | undefined;
2119
+ formatters: {
2120
+ readonly block: {
2121
+ exclude: [] | undefined;
2122
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
2123
+ baseFeePerGas: bigint | null;
2124
+ blobGasUsed: bigint;
2125
+ difficulty: bigint;
2126
+ excessBlobGas: bigint;
2127
+ extraData: import("viem").Hex;
2128
+ gasLimit: bigint;
2129
+ gasUsed: bigint;
2130
+ hash: `0x${string}` | null;
2131
+ logsBloom: `0x${string}` | null;
2132
+ miner: import("viem").Address;
2133
+ mixHash: import("viem").Hash;
2134
+ nonce: `0x${string}` | null;
2135
+ number: bigint | null;
2136
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
2137
+ parentHash: import("viem").Hash;
2138
+ receiptsRoot: import("viem").Hex;
2139
+ sealFields: import("viem").Hex[];
2140
+ sha3Uncles: import("viem").Hash;
2141
+ size: bigint;
2142
+ stateRoot: import("viem").Hash;
2143
+ timestamp: bigint;
2144
+ totalDifficulty: bigint | null;
2145
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
2146
+ transactionsRoot: import("viem").Hash;
2147
+ uncles: import("viem").Hash[];
2148
+ withdrawals?: import("viem").Withdrawal[] | undefined;
2149
+ withdrawalsRoot?: import("viem").Hex | undefined;
2150
+ } & {};
2151
+ type: "block";
2152
+ };
2153
+ readonly transaction: {
2154
+ exclude: [] | undefined;
2155
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
2156
+ blockHash: `0x${string}` | null;
2157
+ blockNumber: bigint | null;
2158
+ from: import("viem").Address;
2159
+ gas: bigint;
2160
+ hash: import("viem").Hash;
2161
+ input: import("viem").Hex;
2162
+ nonce: number;
2163
+ r: import("viem").Hex;
2164
+ s: import("viem").Hex;
2165
+ to: import("viem").Address | null;
2166
+ transactionIndex: number | null;
2167
+ typeHex: import("viem").Hex | null;
2168
+ v: bigint;
2169
+ value: bigint;
2170
+ yParity: number;
2171
+ gasPrice?: undefined;
2172
+ maxFeePerBlobGas?: undefined;
2173
+ maxFeePerGas: bigint;
2174
+ maxPriorityFeePerGas: bigint;
2175
+ isSystemTx?: boolean;
2176
+ mint?: bigint | undefined;
2177
+ sourceHash: import("viem").Hex;
2178
+ type: "deposit";
2179
+ } | {
2180
+ r: import("viem").Hex;
2181
+ s: import("viem").Hex;
2182
+ v: bigint;
2183
+ to: import("viem").Address | null;
2184
+ from: import("viem").Address;
2185
+ gas: bigint;
2186
+ nonce: number;
2187
+ value: bigint;
2188
+ blockHash: `0x${string}` | null;
2189
+ blockNumber: bigint | null;
2190
+ hash: import("viem").Hash;
2191
+ input: import("viem").Hex;
2192
+ transactionIndex: number | null;
2193
+ typeHex: import("viem").Hex | null;
2194
+ accessList?: undefined;
2195
+ authorizationList?: undefined;
2196
+ blobVersionedHashes?: undefined;
2197
+ chainId?: number | undefined;
2198
+ yParity?: undefined;
2199
+ type: "legacy";
2200
+ gasPrice: bigint;
2201
+ maxFeePerBlobGas?: undefined;
2202
+ maxFeePerGas?: undefined;
2203
+ maxPriorityFeePerGas?: undefined;
2204
+ isSystemTx?: undefined;
2205
+ mint?: undefined;
2206
+ sourceHash?: undefined;
2207
+ } | {
2208
+ blockHash: `0x${string}` | null;
2209
+ blockNumber: bigint | null;
2210
+ from: import("viem").Address;
2211
+ gas: bigint;
2212
+ hash: import("viem").Hash;
2213
+ input: import("viem").Hex;
2214
+ nonce: number;
2215
+ r: import("viem").Hex;
2216
+ s: import("viem").Hex;
2217
+ to: import("viem").Address | null;
2218
+ transactionIndex: number | null;
2219
+ typeHex: import("viem").Hex | null;
2220
+ v: bigint;
2221
+ value: bigint;
2222
+ yParity: number;
2223
+ accessList: import("viem").AccessList;
2224
+ authorizationList?: undefined;
2225
+ blobVersionedHashes?: undefined;
2226
+ chainId: number;
2227
+ type: "eip2930";
2228
+ gasPrice: bigint;
2229
+ maxFeePerBlobGas?: undefined;
2230
+ maxFeePerGas?: undefined;
2231
+ maxPriorityFeePerGas?: undefined;
2232
+ isSystemTx?: undefined;
2233
+ mint?: undefined;
2234
+ sourceHash?: undefined;
2235
+ } | {
2236
+ blockHash: `0x${string}` | null;
2237
+ blockNumber: bigint | null;
2238
+ from: import("viem").Address;
2239
+ gas: bigint;
2240
+ hash: import("viem").Hash;
2241
+ input: import("viem").Hex;
2242
+ nonce: number;
2243
+ r: import("viem").Hex;
2244
+ s: import("viem").Hex;
2245
+ to: import("viem").Address | null;
2246
+ transactionIndex: number | null;
2247
+ typeHex: import("viem").Hex | null;
2248
+ v: bigint;
2249
+ value: bigint;
2250
+ yParity: number;
2251
+ accessList: import("viem").AccessList;
2252
+ authorizationList?: undefined;
2253
+ blobVersionedHashes?: undefined;
2254
+ chainId: number;
2255
+ type: "eip1559";
2256
+ gasPrice?: undefined;
2257
+ maxFeePerBlobGas?: undefined;
2258
+ maxFeePerGas: bigint;
2259
+ maxPriorityFeePerGas: bigint;
2260
+ isSystemTx?: undefined;
2261
+ mint?: undefined;
2262
+ sourceHash?: undefined;
2263
+ } | {
2264
+ blockHash: `0x${string}` | null;
2265
+ blockNumber: bigint | null;
2266
+ from: import("viem").Address;
2267
+ gas: bigint;
2268
+ hash: import("viem").Hash;
2269
+ input: import("viem").Hex;
2270
+ nonce: number;
2271
+ r: import("viem").Hex;
2272
+ s: import("viem").Hex;
2273
+ to: import("viem").Address | null;
2274
+ transactionIndex: number | null;
2275
+ typeHex: import("viem").Hex | null;
2276
+ v: bigint;
2277
+ value: bigint;
2278
+ yParity: number;
2279
+ accessList: import("viem").AccessList;
2280
+ authorizationList?: undefined;
2281
+ blobVersionedHashes: readonly import("viem").Hex[];
2282
+ chainId: number;
2283
+ type: "eip4844";
2284
+ gasPrice?: undefined;
2285
+ maxFeePerBlobGas: bigint;
2286
+ maxFeePerGas: bigint;
2287
+ maxPriorityFeePerGas: bigint;
2288
+ isSystemTx?: undefined;
2289
+ mint?: undefined;
2290
+ sourceHash?: undefined;
2291
+ } | {
2292
+ blockHash: `0x${string}` | null;
2293
+ blockNumber: bigint | null;
2294
+ from: import("viem").Address;
2295
+ gas: bigint;
2296
+ hash: import("viem").Hash;
2297
+ input: import("viem").Hex;
2298
+ nonce: number;
2299
+ r: import("viem").Hex;
2300
+ s: import("viem").Hex;
2301
+ to: import("viem").Address | null;
2302
+ transactionIndex: number | null;
2303
+ typeHex: import("viem").Hex | null;
2304
+ v: bigint;
2305
+ value: bigint;
2306
+ yParity: number;
2307
+ accessList: import("viem").AccessList;
2308
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
2309
+ blobVersionedHashes?: undefined;
2310
+ chainId: number;
2311
+ type: "eip7702";
2312
+ gasPrice?: undefined;
2313
+ maxFeePerBlobGas?: undefined;
2314
+ maxFeePerGas: bigint;
2315
+ maxPriorityFeePerGas: bigint;
2316
+ isSystemTx?: undefined;
2317
+ mint?: undefined;
2318
+ sourceHash?: undefined;
2319
+ }) & {};
2320
+ type: "transaction";
2321
+ };
2322
+ readonly transactionReceipt: {
2323
+ exclude: [] | undefined;
2324
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
2325
+ blobGasPrice?: bigint | undefined;
2326
+ blobGasUsed?: bigint | undefined;
2327
+ blockHash: import("viem").Hash;
2328
+ blockNumber: bigint;
2329
+ contractAddress: import("viem").Address | null | undefined;
2330
+ cumulativeGasUsed: bigint;
2331
+ effectiveGasPrice: bigint;
2332
+ from: import("viem").Address;
2333
+ gasUsed: bigint;
2334
+ logs: import("viem").Log<bigint, number, false>[];
2335
+ logsBloom: import("viem").Hex;
2336
+ root?: import("viem").Hash | undefined;
2337
+ status: "success" | "reverted";
2338
+ to: import("viem").Address | null;
2339
+ transactionHash: import("viem").Hash;
2340
+ transactionIndex: number;
2341
+ type: import("viem").TransactionType;
2342
+ l1GasPrice: bigint | null;
2343
+ l1GasUsed: bigint | null;
2344
+ l1Fee: bigint | null;
2345
+ l1FeeScalar: number | null;
2346
+ } & {};
2347
+ type: "transactionReceipt";
2348
+ };
2349
+ };
2350
+ serializers: {
2351
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2352
+ };
2353
+ }, undefined, chainOverride, accountOverride>>;
2354
+ directCall: <chainOverride extends import("viem").Chain | undefined = undefined, accountOverride extends import("viem").Account | import("viem").Address | undefined = undefined>(args: readonly [readonly {
2355
+ accountId: number;
2356
+ data: `0x${string}`;
2357
+ }[], boolean], options?: Omit<import("viem").SimulateContractParameters<readonly [{
2358
+ readonly inputs: readonly [{
2359
+ readonly components: readonly [{
2360
+ readonly internalType: "Account";
2361
+ readonly name: "account";
2362
+ readonly type: "bytes21";
2363
+ }, {
2364
+ readonly internalType: "address";
2365
+ readonly name: "target";
2366
+ readonly type: "address";
2367
+ }, {
2368
+ readonly internalType: "bytes";
2369
+ readonly name: "data";
2370
+ readonly type: "bytes";
2371
+ }];
2372
+ readonly internalType: "struct IRouter.SimulateData[]";
2373
+ readonly name: "calls";
2374
+ readonly type: "tuple[]";
2375
+ }];
2376
+ readonly name: "batchSimulate";
2377
+ readonly outputs: readonly [{
2378
+ readonly internalType: "bytes[]";
2379
+ readonly name: "";
2380
+ readonly type: "bytes[]";
2381
+ }];
2382
+ readonly stateMutability: "nonpayable";
2383
+ readonly type: "function";
2384
+ }, {
2385
+ readonly inputs: readonly [{
2386
+ readonly components: readonly [{
2387
+ readonly internalType: "uint8";
2388
+ readonly name: "accountId";
2389
+ readonly type: "uint8";
2390
+ }, {
2391
+ readonly internalType: "bytes";
2392
+ readonly name: "data";
2393
+ readonly type: "bytes";
2394
+ }];
2395
+ readonly internalType: "struct IRouter.DirectCall[]";
2396
+ readonly name: "data";
2397
+ readonly type: "tuple[]";
2398
+ }, {
2399
+ readonly internalType: "bool";
2400
+ readonly name: "requireMarginCheckCall";
2401
+ readonly type: "bool";
2402
+ }];
2403
+ readonly name: "directCall";
2404
+ readonly outputs: readonly [{
2405
+ readonly internalType: "bytes[]";
2406
+ readonly name: "";
2407
+ readonly type: "bytes[]";
2408
+ }];
2409
+ readonly stateMutability: "nonpayable";
2410
+ readonly type: "function";
2411
+ }, {
2412
+ readonly inputs: readonly [{
2413
+ readonly internalType: "bytes";
2414
+ readonly name: "data";
2415
+ readonly type: "bytes";
2416
+ }];
2417
+ readonly name: "viewCall";
2418
+ readonly outputs: readonly [{
2419
+ readonly internalType: "bytes";
2420
+ readonly name: "";
2421
+ readonly type: "bytes";
2422
+ }];
2423
+ readonly stateMutability: "view";
2424
+ readonly type: "function";
2425
+ }], "directCall", readonly [readonly {
2426
+ accountId: number;
2427
+ data: `0x${string}`;
2428
+ }[], boolean], {
2429
+ blockExplorers: {
2430
+ readonly default: {
2431
+ readonly name: "Basescan";
2432
+ readonly url: "https://basescan.org";
2433
+ readonly apiUrl: "https://api.basescan.org/api";
2434
+ };
2435
+ };
2436
+ contracts: {
2437
+ readonly disputeGameFactory: {
2438
+ readonly 1: {
2439
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
2440
+ };
2441
+ };
2442
+ readonly l2OutputOracle: {
2443
+ readonly 1: {
2444
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
2445
+ };
2446
+ };
2447
+ readonly multicall3: {
2448
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2449
+ readonly blockCreated: 5022;
2450
+ };
2451
+ readonly portal: {
2452
+ readonly 1: {
2453
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
2454
+ readonly blockCreated: 17482143;
2455
+ };
2456
+ };
2457
+ readonly l1StandardBridge: {
2458
+ readonly 1: {
2459
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
2460
+ readonly blockCreated: 17482143;
2461
+ };
2462
+ };
2463
+ readonly gasPriceOracle: {
2464
+ readonly address: "0x420000000000000000000000000000000000000F";
2465
+ };
2466
+ readonly l1Block: {
2467
+ readonly address: "0x4200000000000000000000000000000000000015";
2468
+ };
2469
+ readonly l2CrossDomainMessenger: {
2470
+ readonly address: "0x4200000000000000000000000000000000000007";
2471
+ };
2472
+ readonly l2Erc721Bridge: {
2473
+ readonly address: "0x4200000000000000000000000000000000000014";
2474
+ };
2475
+ readonly l2StandardBridge: {
2476
+ readonly address: "0x4200000000000000000000000000000000000010";
2477
+ };
2478
+ readonly l2ToL1MessagePasser: {
2479
+ readonly address: "0x4200000000000000000000000000000000000016";
2480
+ };
2481
+ };
2482
+ id: 8453;
2483
+ name: "Base";
2484
+ nativeCurrency: {
2485
+ readonly name: "Ether";
2486
+ readonly symbol: "ETH";
2487
+ readonly decimals: 18;
2488
+ };
2489
+ rpcUrls: {
2490
+ readonly default: {
2491
+ readonly http: readonly ["https://mainnet.base.org"];
2492
+ };
2493
+ };
2494
+ sourceId: 1;
2495
+ testnet?: boolean | undefined;
2496
+ custom?: Record<string, unknown> | undefined;
2497
+ fees?: import("viem").ChainFees<undefined> | undefined;
2498
+ formatters: {
2499
+ readonly block: {
2500
+ exclude: [] | undefined;
2501
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
2502
+ baseFeePerGas: bigint | null;
2503
+ blobGasUsed: bigint;
2504
+ difficulty: bigint;
2505
+ excessBlobGas: bigint;
2506
+ extraData: import("viem").Hex;
2507
+ gasLimit: bigint;
2508
+ gasUsed: bigint;
2509
+ hash: `0x${string}` | null;
2510
+ logsBloom: `0x${string}` | null;
2511
+ miner: import("viem").Address;
2512
+ mixHash: import("viem").Hash;
2513
+ nonce: `0x${string}` | null;
2514
+ number: bigint | null;
2515
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
2516
+ parentHash: import("viem").Hash;
2517
+ receiptsRoot: import("viem").Hex;
2518
+ sealFields: import("viem").Hex[];
2519
+ sha3Uncles: import("viem").Hash;
2520
+ size: bigint;
2521
+ stateRoot: import("viem").Hash;
2522
+ timestamp: bigint;
2523
+ totalDifficulty: bigint | null;
2524
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
2525
+ transactionsRoot: import("viem").Hash;
2526
+ uncles: import("viem").Hash[];
2527
+ withdrawals?: import("viem").Withdrawal[] | undefined;
2528
+ withdrawalsRoot?: import("viem").Hex | undefined;
2529
+ } & {};
2530
+ type: "block";
2531
+ };
2532
+ readonly transaction: {
2533
+ exclude: [] | undefined;
2534
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
2535
+ blockHash: `0x${string}` | null;
2536
+ blockNumber: bigint | null;
2537
+ from: import("viem").Address;
2538
+ gas: bigint;
2539
+ hash: import("viem").Hash;
2540
+ input: import("viem").Hex;
2541
+ nonce: number;
2542
+ r: import("viem").Hex;
2543
+ s: import("viem").Hex;
2544
+ to: import("viem").Address | null;
2545
+ transactionIndex: number | null;
2546
+ typeHex: import("viem").Hex | null;
2547
+ v: bigint;
2548
+ value: bigint;
2549
+ yParity: number;
2550
+ gasPrice?: undefined;
2551
+ maxFeePerBlobGas?: undefined;
2552
+ maxFeePerGas: bigint;
2553
+ maxPriorityFeePerGas: bigint;
2554
+ isSystemTx?: boolean;
2555
+ mint?: bigint | undefined;
2556
+ sourceHash: import("viem").Hex;
2557
+ type: "deposit";
2558
+ } | {
2559
+ r: import("viem").Hex;
2560
+ s: import("viem").Hex;
2561
+ v: bigint;
2562
+ to: import("viem").Address | null;
2563
+ from: import("viem").Address;
2564
+ gas: bigint;
2565
+ nonce: number;
2566
+ value: bigint;
2567
+ blockHash: `0x${string}` | null;
2568
+ blockNumber: bigint | null;
2569
+ hash: import("viem").Hash;
2570
+ input: import("viem").Hex;
2571
+ transactionIndex: number | null;
2572
+ typeHex: import("viem").Hex | null;
2573
+ accessList?: undefined;
2574
+ authorizationList?: undefined;
2575
+ blobVersionedHashes?: undefined;
2576
+ chainId?: number | undefined;
2577
+ yParity?: undefined;
2578
+ type: "legacy";
2579
+ gasPrice: bigint;
2580
+ maxFeePerBlobGas?: undefined;
2581
+ maxFeePerGas?: undefined;
2582
+ maxPriorityFeePerGas?: undefined;
2583
+ isSystemTx?: undefined;
2584
+ mint?: undefined;
2585
+ sourceHash?: undefined;
2586
+ } | {
2587
+ blockHash: `0x${string}` | null;
2588
+ blockNumber: bigint | null;
2589
+ from: import("viem").Address;
2590
+ gas: bigint;
2591
+ hash: import("viem").Hash;
2592
+ input: import("viem").Hex;
2593
+ nonce: number;
2594
+ r: import("viem").Hex;
2595
+ s: import("viem").Hex;
2596
+ to: import("viem").Address | null;
2597
+ transactionIndex: number | null;
2598
+ typeHex: import("viem").Hex | null;
2599
+ v: bigint;
2600
+ value: bigint;
2601
+ yParity: number;
2602
+ accessList: import("viem").AccessList;
2603
+ authorizationList?: undefined;
2604
+ blobVersionedHashes?: undefined;
2605
+ chainId: number;
2606
+ type: "eip2930";
2607
+ gasPrice: bigint;
2608
+ maxFeePerBlobGas?: undefined;
2609
+ maxFeePerGas?: undefined;
2610
+ maxPriorityFeePerGas?: undefined;
2611
+ isSystemTx?: undefined;
2612
+ mint?: undefined;
2613
+ sourceHash?: undefined;
2614
+ } | {
2615
+ blockHash: `0x${string}` | null;
2616
+ blockNumber: bigint | null;
2617
+ from: import("viem").Address;
2618
+ gas: bigint;
2619
+ hash: import("viem").Hash;
2620
+ input: import("viem").Hex;
2621
+ nonce: number;
2622
+ r: import("viem").Hex;
2623
+ s: import("viem").Hex;
2624
+ to: import("viem").Address | null;
2625
+ transactionIndex: number | null;
2626
+ typeHex: import("viem").Hex | null;
2627
+ v: bigint;
2628
+ value: bigint;
2629
+ yParity: number;
2630
+ accessList: import("viem").AccessList;
2631
+ authorizationList?: undefined;
2632
+ blobVersionedHashes?: undefined;
2633
+ chainId: number;
2634
+ type: "eip1559";
2635
+ gasPrice?: undefined;
2636
+ maxFeePerBlobGas?: undefined;
2637
+ maxFeePerGas: bigint;
2638
+ maxPriorityFeePerGas: bigint;
2639
+ isSystemTx?: undefined;
2640
+ mint?: undefined;
2641
+ sourceHash?: undefined;
2642
+ } | {
2643
+ blockHash: `0x${string}` | null;
2644
+ blockNumber: bigint | null;
2645
+ from: import("viem").Address;
2646
+ gas: bigint;
2647
+ hash: import("viem").Hash;
2648
+ input: import("viem").Hex;
2649
+ nonce: number;
2650
+ r: import("viem").Hex;
2651
+ s: import("viem").Hex;
2652
+ to: import("viem").Address | null;
2653
+ transactionIndex: number | null;
2654
+ typeHex: import("viem").Hex | null;
2655
+ v: bigint;
2656
+ value: bigint;
2657
+ yParity: number;
2658
+ accessList: import("viem").AccessList;
2659
+ authorizationList?: undefined;
2660
+ blobVersionedHashes: readonly import("viem").Hex[];
2661
+ chainId: number;
2662
+ type: "eip4844";
2663
+ gasPrice?: undefined;
2664
+ maxFeePerBlobGas: bigint;
2665
+ maxFeePerGas: bigint;
2666
+ maxPriorityFeePerGas: bigint;
2667
+ isSystemTx?: undefined;
2668
+ mint?: undefined;
2669
+ sourceHash?: undefined;
2670
+ } | {
2671
+ blockHash: `0x${string}` | null;
2672
+ blockNumber: bigint | null;
2673
+ from: import("viem").Address;
2674
+ gas: bigint;
2675
+ hash: import("viem").Hash;
2676
+ input: import("viem").Hex;
2677
+ nonce: number;
2678
+ r: import("viem").Hex;
2679
+ s: import("viem").Hex;
2680
+ to: import("viem").Address | null;
2681
+ transactionIndex: number | null;
2682
+ typeHex: import("viem").Hex | null;
2683
+ v: bigint;
2684
+ value: bigint;
2685
+ yParity: number;
2686
+ accessList: import("viem").AccessList;
2687
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
2688
+ blobVersionedHashes?: undefined;
2689
+ chainId: number;
2690
+ type: "eip7702";
2691
+ gasPrice?: undefined;
2692
+ maxFeePerBlobGas?: undefined;
2693
+ maxFeePerGas: bigint;
2694
+ maxPriorityFeePerGas: bigint;
2695
+ isSystemTx?: undefined;
2696
+ mint?: undefined;
2697
+ sourceHash?: undefined;
2698
+ }) & {};
2699
+ type: "transaction";
2700
+ };
2701
+ readonly transactionReceipt: {
2702
+ exclude: [] | undefined;
2703
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
2704
+ blobGasPrice?: bigint | undefined;
2705
+ blobGasUsed?: bigint | undefined;
2706
+ blockHash: import("viem").Hash;
2707
+ blockNumber: bigint;
2708
+ contractAddress: import("viem").Address | null | undefined;
2709
+ cumulativeGasUsed: bigint;
2710
+ effectiveGasPrice: bigint;
2711
+ from: import("viem").Address;
2712
+ gasUsed: bigint;
2713
+ logs: import("viem").Log<bigint, number, false>[];
2714
+ logsBloom: import("viem").Hex;
2715
+ root?: import("viem").Hash | undefined;
2716
+ status: "success" | "reverted";
2717
+ to: import("viem").Address | null;
2718
+ transactionHash: import("viem").Hash;
2719
+ transactionIndex: number;
2720
+ type: import("viem").TransactionType;
2721
+ l1GasPrice: bigint | null;
2722
+ l1GasUsed: bigint | null;
2723
+ l1Fee: bigint | null;
2724
+ l1FeeScalar: number | null;
2725
+ } & {};
2726
+ type: "transactionReceipt";
2727
+ };
2728
+ };
2729
+ serializers: {
2730
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2731
+ };
2732
+ }, chainOverride, accountOverride>, "address" | "args" | "abi" | "functionName"> | undefined) => Promise<import("viem").SimulateContractReturnType<readonly [{
2733
+ readonly inputs: readonly [{
2734
+ readonly components: readonly [{
2735
+ readonly internalType: "Account";
2736
+ readonly name: "account";
2737
+ readonly type: "bytes21";
2738
+ }, {
2739
+ readonly internalType: "address";
2740
+ readonly name: "target";
2741
+ readonly type: "address";
2742
+ }, {
2743
+ readonly internalType: "bytes";
2744
+ readonly name: "data";
2745
+ readonly type: "bytes";
2746
+ }];
2747
+ readonly internalType: "struct IRouter.SimulateData[]";
2748
+ readonly name: "calls";
2749
+ readonly type: "tuple[]";
2750
+ }];
2751
+ readonly name: "batchSimulate";
2752
+ readonly outputs: readonly [{
2753
+ readonly internalType: "bytes[]";
2754
+ readonly name: "";
2755
+ readonly type: "bytes[]";
2756
+ }];
2757
+ readonly stateMutability: "nonpayable";
2758
+ readonly type: "function";
2759
+ }, {
2760
+ readonly inputs: readonly [{
2761
+ readonly components: readonly [{
2762
+ readonly internalType: "uint8";
2763
+ readonly name: "accountId";
2764
+ readonly type: "uint8";
2765
+ }, {
2766
+ readonly internalType: "bytes";
2767
+ readonly name: "data";
2768
+ readonly type: "bytes";
2769
+ }];
2770
+ readonly internalType: "struct IRouter.DirectCall[]";
2771
+ readonly name: "data";
2772
+ readonly type: "tuple[]";
2773
+ }, {
2774
+ readonly internalType: "bool";
2775
+ readonly name: "requireMarginCheckCall";
2776
+ readonly type: "bool";
2777
+ }];
2778
+ readonly name: "directCall";
2779
+ readonly outputs: readonly [{
2780
+ readonly internalType: "bytes[]";
2781
+ readonly name: "";
2782
+ readonly type: "bytes[]";
2783
+ }];
2784
+ readonly stateMutability: "nonpayable";
2785
+ readonly type: "function";
2786
+ }, {
2787
+ readonly inputs: readonly [{
2788
+ readonly internalType: "bytes";
2789
+ readonly name: "data";
2790
+ readonly type: "bytes";
2791
+ }];
2792
+ readonly name: "viewCall";
2793
+ readonly outputs: readonly [{
2794
+ readonly internalType: "bytes";
2795
+ readonly name: "";
2796
+ readonly type: "bytes";
2797
+ }];
2798
+ readonly stateMutability: "view";
2799
+ readonly type: "function";
2800
+ }], "directCall", readonly [readonly {
2801
+ accountId: number;
2802
+ data: `0x${string}`;
2803
+ }[], boolean], {
2804
+ blockExplorers: {
2805
+ readonly default: {
2806
+ readonly name: "Basescan";
2807
+ readonly url: "https://basescan.org";
2808
+ readonly apiUrl: "https://api.basescan.org/api";
2809
+ };
2810
+ };
2811
+ contracts: {
2812
+ readonly disputeGameFactory: {
2813
+ readonly 1: {
2814
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
2815
+ };
2816
+ };
2817
+ readonly l2OutputOracle: {
2818
+ readonly 1: {
2819
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
2820
+ };
2821
+ };
2822
+ readonly multicall3: {
2823
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2824
+ readonly blockCreated: 5022;
2825
+ };
2826
+ readonly portal: {
2827
+ readonly 1: {
2828
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
2829
+ readonly blockCreated: 17482143;
2830
+ };
2831
+ };
2832
+ readonly l1StandardBridge: {
2833
+ readonly 1: {
2834
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
2835
+ readonly blockCreated: 17482143;
2836
+ };
2837
+ };
2838
+ readonly gasPriceOracle: {
2839
+ readonly address: "0x420000000000000000000000000000000000000F";
2840
+ };
2841
+ readonly l1Block: {
2842
+ readonly address: "0x4200000000000000000000000000000000000015";
2843
+ };
2844
+ readonly l2CrossDomainMessenger: {
2845
+ readonly address: "0x4200000000000000000000000000000000000007";
2846
+ };
2847
+ readonly l2Erc721Bridge: {
2848
+ readonly address: "0x4200000000000000000000000000000000000014";
2849
+ };
2850
+ readonly l2StandardBridge: {
2851
+ readonly address: "0x4200000000000000000000000000000000000010";
2852
+ };
2853
+ readonly l2ToL1MessagePasser: {
2854
+ readonly address: "0x4200000000000000000000000000000000000016";
2855
+ };
2856
+ };
2857
+ id: 8453;
2858
+ name: "Base";
2859
+ nativeCurrency: {
2860
+ readonly name: "Ether";
2861
+ readonly symbol: "ETH";
2862
+ readonly decimals: 18;
2863
+ };
2864
+ rpcUrls: {
2865
+ readonly default: {
2866
+ readonly http: readonly ["https://mainnet.base.org"];
2867
+ };
2868
+ };
2869
+ sourceId: 1;
2870
+ testnet?: boolean | undefined;
2871
+ custom?: Record<string, unknown> | undefined;
2872
+ fees?: import("viem").ChainFees<undefined> | undefined;
2873
+ formatters: {
2874
+ readonly block: {
2875
+ exclude: [] | undefined;
2876
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
2877
+ baseFeePerGas: bigint | null;
2878
+ blobGasUsed: bigint;
2879
+ difficulty: bigint;
2880
+ excessBlobGas: bigint;
2881
+ extraData: import("viem").Hex;
2882
+ gasLimit: bigint;
2883
+ gasUsed: bigint;
2884
+ hash: `0x${string}` | null;
2885
+ logsBloom: `0x${string}` | null;
2886
+ miner: import("viem").Address;
2887
+ mixHash: import("viem").Hash;
2888
+ nonce: `0x${string}` | null;
2889
+ number: bigint | null;
2890
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
2891
+ parentHash: import("viem").Hash;
2892
+ receiptsRoot: import("viem").Hex;
2893
+ sealFields: import("viem").Hex[];
2894
+ sha3Uncles: import("viem").Hash;
2895
+ size: bigint;
2896
+ stateRoot: import("viem").Hash;
2897
+ timestamp: bigint;
2898
+ totalDifficulty: bigint | null;
2899
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
2900
+ transactionsRoot: import("viem").Hash;
2901
+ uncles: import("viem").Hash[];
2902
+ withdrawals?: import("viem").Withdrawal[] | undefined;
2903
+ withdrawalsRoot?: import("viem").Hex | undefined;
2904
+ } & {};
2905
+ type: "block";
2906
+ };
2907
+ readonly transaction: {
2908
+ exclude: [] | undefined;
2909
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
2910
+ blockHash: `0x${string}` | null;
2911
+ blockNumber: bigint | null;
2912
+ from: import("viem").Address;
2913
+ gas: bigint;
2914
+ hash: import("viem").Hash;
2915
+ input: import("viem").Hex;
2916
+ nonce: number;
2917
+ r: import("viem").Hex;
2918
+ s: import("viem").Hex;
2919
+ to: import("viem").Address | null;
2920
+ transactionIndex: number | null;
2921
+ typeHex: import("viem").Hex | null;
2922
+ v: bigint;
2923
+ value: bigint;
2924
+ yParity: number;
2925
+ gasPrice?: undefined;
2926
+ maxFeePerBlobGas?: undefined;
2927
+ maxFeePerGas: bigint;
2928
+ maxPriorityFeePerGas: bigint;
2929
+ isSystemTx?: boolean;
2930
+ mint?: bigint | undefined;
2931
+ sourceHash: import("viem").Hex;
2932
+ type: "deposit";
2933
+ } | {
2934
+ r: import("viem").Hex;
2935
+ s: import("viem").Hex;
2936
+ v: bigint;
2937
+ to: import("viem").Address | null;
2938
+ from: import("viem").Address;
2939
+ gas: bigint;
2940
+ nonce: number;
2941
+ value: bigint;
2942
+ blockHash: `0x${string}` | null;
2943
+ blockNumber: bigint | null;
2944
+ hash: import("viem").Hash;
2945
+ input: import("viem").Hex;
2946
+ transactionIndex: number | null;
2947
+ typeHex: import("viem").Hex | null;
2948
+ accessList?: undefined;
2949
+ authorizationList?: undefined;
2950
+ blobVersionedHashes?: undefined;
2951
+ chainId?: number | undefined;
2952
+ yParity?: undefined;
2953
+ type: "legacy";
2954
+ gasPrice: bigint;
2955
+ maxFeePerBlobGas?: undefined;
2956
+ maxFeePerGas?: undefined;
2957
+ maxPriorityFeePerGas?: undefined;
2958
+ isSystemTx?: undefined;
2959
+ mint?: undefined;
2960
+ sourceHash?: undefined;
2961
+ } | {
2962
+ blockHash: `0x${string}` | null;
2963
+ blockNumber: bigint | null;
2964
+ from: import("viem").Address;
2965
+ gas: bigint;
2966
+ hash: import("viem").Hash;
2967
+ input: import("viem").Hex;
2968
+ nonce: number;
2969
+ r: import("viem").Hex;
2970
+ s: import("viem").Hex;
2971
+ to: import("viem").Address | null;
2972
+ transactionIndex: number | null;
2973
+ typeHex: import("viem").Hex | null;
2974
+ v: bigint;
2975
+ value: bigint;
2976
+ yParity: number;
2977
+ accessList: import("viem").AccessList;
2978
+ authorizationList?: undefined;
2979
+ blobVersionedHashes?: undefined;
2980
+ chainId: number;
2981
+ type: "eip2930";
2982
+ gasPrice: bigint;
2983
+ maxFeePerBlobGas?: undefined;
2984
+ maxFeePerGas?: undefined;
2985
+ maxPriorityFeePerGas?: undefined;
2986
+ isSystemTx?: undefined;
2987
+ mint?: undefined;
2988
+ sourceHash?: undefined;
2989
+ } | {
2990
+ blockHash: `0x${string}` | null;
2991
+ blockNumber: bigint | null;
2992
+ from: import("viem").Address;
2993
+ gas: bigint;
2994
+ hash: import("viem").Hash;
2995
+ input: import("viem").Hex;
2996
+ nonce: number;
2997
+ r: import("viem").Hex;
2998
+ s: import("viem").Hex;
2999
+ to: import("viem").Address | null;
3000
+ transactionIndex: number | null;
3001
+ typeHex: import("viem").Hex | null;
3002
+ v: bigint;
3003
+ value: bigint;
3004
+ yParity: number;
3005
+ accessList: import("viem").AccessList;
3006
+ authorizationList?: undefined;
3007
+ blobVersionedHashes?: undefined;
3008
+ chainId: number;
3009
+ type: "eip1559";
3010
+ gasPrice?: undefined;
3011
+ maxFeePerBlobGas?: undefined;
3012
+ maxFeePerGas: bigint;
3013
+ maxPriorityFeePerGas: bigint;
3014
+ isSystemTx?: undefined;
3015
+ mint?: undefined;
3016
+ sourceHash?: undefined;
3017
+ } | {
3018
+ blockHash: `0x${string}` | null;
3019
+ blockNumber: bigint | null;
3020
+ from: import("viem").Address;
3021
+ gas: bigint;
3022
+ hash: import("viem").Hash;
3023
+ input: import("viem").Hex;
3024
+ nonce: number;
3025
+ r: import("viem").Hex;
3026
+ s: import("viem").Hex;
3027
+ to: import("viem").Address | null;
3028
+ transactionIndex: number | null;
3029
+ typeHex: import("viem").Hex | null;
3030
+ v: bigint;
3031
+ value: bigint;
3032
+ yParity: number;
3033
+ accessList: import("viem").AccessList;
3034
+ authorizationList?: undefined;
3035
+ blobVersionedHashes: readonly import("viem").Hex[];
3036
+ chainId: number;
3037
+ type: "eip4844";
3038
+ gasPrice?: undefined;
3039
+ maxFeePerBlobGas: bigint;
3040
+ maxFeePerGas: bigint;
3041
+ maxPriorityFeePerGas: bigint;
3042
+ isSystemTx?: undefined;
3043
+ mint?: undefined;
3044
+ sourceHash?: undefined;
3045
+ } | {
3046
+ blockHash: `0x${string}` | null;
3047
+ blockNumber: bigint | null;
3048
+ from: import("viem").Address;
3049
+ gas: bigint;
3050
+ hash: import("viem").Hash;
3051
+ input: import("viem").Hex;
3052
+ nonce: number;
3053
+ r: import("viem").Hex;
3054
+ s: import("viem").Hex;
3055
+ to: import("viem").Address | null;
3056
+ transactionIndex: number | null;
3057
+ typeHex: import("viem").Hex | null;
3058
+ v: bigint;
3059
+ value: bigint;
3060
+ yParity: number;
3061
+ accessList: import("viem").AccessList;
3062
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
3063
+ blobVersionedHashes?: undefined;
3064
+ chainId: number;
3065
+ type: "eip7702";
3066
+ gasPrice?: undefined;
3067
+ maxFeePerBlobGas?: undefined;
3068
+ maxFeePerGas: bigint;
3069
+ maxPriorityFeePerGas: bigint;
3070
+ isSystemTx?: undefined;
3071
+ mint?: undefined;
3072
+ sourceHash?: undefined;
3073
+ }) & {};
3074
+ type: "transaction";
3075
+ };
3076
+ readonly transactionReceipt: {
3077
+ exclude: [] | undefined;
3078
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
3079
+ blobGasPrice?: bigint | undefined;
3080
+ blobGasUsed?: bigint | undefined;
3081
+ blockHash: import("viem").Hash;
3082
+ blockNumber: bigint;
3083
+ contractAddress: import("viem").Address | null | undefined;
3084
+ cumulativeGasUsed: bigint;
3085
+ effectiveGasPrice: bigint;
3086
+ from: import("viem").Address;
3087
+ gasUsed: bigint;
3088
+ logs: import("viem").Log<bigint, number, false>[];
3089
+ logsBloom: import("viem").Hex;
3090
+ root?: import("viem").Hash | undefined;
3091
+ status: "success" | "reverted";
3092
+ to: import("viem").Address | null;
3093
+ transactionHash: import("viem").Hash;
3094
+ transactionIndex: number;
3095
+ type: import("viem").TransactionType;
3096
+ l1GasPrice: bigint | null;
3097
+ l1GasUsed: bigint | null;
3098
+ l1Fee: bigint | null;
3099
+ l1FeeScalar: number | null;
3100
+ } & {};
3101
+ type: "transactionReceipt";
3102
+ };
3103
+ };
3104
+ serializers: {
3105
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3106
+ };
3107
+ }, undefined, chainOverride, accountOverride>>;
3108
+ };
3109
+ write: {
3110
+ batchSimulate: <chainOverride extends import("viem").Chain | undefined, options extends import("viem").UnionOmit<import("viem").WriteContractParameters<readonly [{
3111
+ readonly inputs: readonly [{
3112
+ readonly components: readonly [{
3113
+ readonly internalType: "Account";
3114
+ readonly name: "account";
3115
+ readonly type: "bytes21";
3116
+ }, {
3117
+ readonly internalType: "address";
3118
+ readonly name: "target";
3119
+ readonly type: "address";
3120
+ }, {
3121
+ readonly internalType: "bytes";
3122
+ readonly name: "data";
3123
+ readonly type: "bytes";
3124
+ }];
3125
+ readonly internalType: "struct IRouter.SimulateData[]";
3126
+ readonly name: "calls";
3127
+ readonly type: "tuple[]";
3128
+ }];
3129
+ readonly name: "batchSimulate";
3130
+ readonly outputs: readonly [{
3131
+ readonly internalType: "bytes[]";
3132
+ readonly name: "";
3133
+ readonly type: "bytes[]";
3134
+ }];
3135
+ readonly stateMutability: "nonpayable";
3136
+ readonly type: "function";
3137
+ }, {
3138
+ readonly inputs: readonly [{
3139
+ readonly components: readonly [{
3140
+ readonly internalType: "uint8";
3141
+ readonly name: "accountId";
3142
+ readonly type: "uint8";
3143
+ }, {
3144
+ readonly internalType: "bytes";
3145
+ readonly name: "data";
3146
+ readonly type: "bytes";
3147
+ }];
3148
+ readonly internalType: "struct IRouter.DirectCall[]";
3149
+ readonly name: "data";
3150
+ readonly type: "tuple[]";
3151
+ }, {
3152
+ readonly internalType: "bool";
3153
+ readonly name: "requireMarginCheckCall";
3154
+ readonly type: "bool";
3155
+ }];
3156
+ readonly name: "directCall";
3157
+ readonly outputs: readonly [{
3158
+ readonly internalType: "bytes[]";
3159
+ readonly name: "";
3160
+ readonly type: "bytes[]";
3161
+ }];
3162
+ readonly stateMutability: "nonpayable";
3163
+ readonly type: "function";
3164
+ }, {
3165
+ readonly inputs: readonly [{
3166
+ readonly internalType: "bytes";
3167
+ readonly name: "data";
3168
+ readonly type: "bytes";
3169
+ }];
3170
+ readonly name: "viewCall";
3171
+ readonly outputs: readonly [{
3172
+ readonly internalType: "bytes";
3173
+ readonly name: "";
3174
+ readonly type: "bytes";
3175
+ }];
3176
+ readonly stateMutability: "view";
3177
+ readonly type: "function";
3178
+ }], "batchSimulate", readonly [readonly {
3179
+ account: `0x${string}`;
3180
+ target: `0x${string}`;
3181
+ data: `0x${string}`;
3182
+ }[]], {
3183
+ blockExplorers: {
3184
+ readonly default: {
3185
+ readonly name: "Basescan";
3186
+ readonly url: "https://basescan.org";
3187
+ readonly apiUrl: "https://api.basescan.org/api";
3188
+ };
3189
+ };
3190
+ contracts: {
3191
+ readonly disputeGameFactory: {
3192
+ readonly 1: {
3193
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
3194
+ };
3195
+ };
3196
+ readonly l2OutputOracle: {
3197
+ readonly 1: {
3198
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
3199
+ };
3200
+ };
3201
+ readonly multicall3: {
3202
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3203
+ readonly blockCreated: 5022;
3204
+ };
3205
+ readonly portal: {
3206
+ readonly 1: {
3207
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
3208
+ readonly blockCreated: 17482143;
3209
+ };
3210
+ };
3211
+ readonly l1StandardBridge: {
3212
+ readonly 1: {
3213
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
3214
+ readonly blockCreated: 17482143;
3215
+ };
3216
+ };
3217
+ readonly gasPriceOracle: {
3218
+ readonly address: "0x420000000000000000000000000000000000000F";
3219
+ };
3220
+ readonly l1Block: {
3221
+ readonly address: "0x4200000000000000000000000000000000000015";
3222
+ };
3223
+ readonly l2CrossDomainMessenger: {
3224
+ readonly address: "0x4200000000000000000000000000000000000007";
3225
+ };
3226
+ readonly l2Erc721Bridge: {
3227
+ readonly address: "0x4200000000000000000000000000000000000014";
3228
+ };
3229
+ readonly l2StandardBridge: {
3230
+ readonly address: "0x4200000000000000000000000000000000000010";
3231
+ };
3232
+ readonly l2ToL1MessagePasser: {
3233
+ readonly address: "0x4200000000000000000000000000000000000016";
3234
+ };
3235
+ };
3236
+ id: 8453;
3237
+ name: "Base";
3238
+ nativeCurrency: {
3239
+ readonly name: "Ether";
3240
+ readonly symbol: "ETH";
3241
+ readonly decimals: 18;
3242
+ };
3243
+ rpcUrls: {
3244
+ readonly default: {
3245
+ readonly http: readonly ["https://mainnet.base.org"];
3246
+ };
3247
+ };
3248
+ sourceId: 1;
3249
+ testnet?: boolean | undefined;
3250
+ custom?: Record<string, unknown> | undefined;
3251
+ fees?: import("viem").ChainFees<undefined> | undefined;
3252
+ formatters: {
3253
+ readonly block: {
3254
+ exclude: [] | undefined;
3255
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
3256
+ baseFeePerGas: bigint | null;
3257
+ blobGasUsed: bigint;
3258
+ difficulty: bigint;
3259
+ excessBlobGas: bigint;
3260
+ extraData: import("viem").Hex;
3261
+ gasLimit: bigint;
3262
+ gasUsed: bigint;
3263
+ hash: `0x${string}` | null;
3264
+ logsBloom: `0x${string}` | null;
3265
+ miner: import("viem").Address;
3266
+ mixHash: import("viem").Hash;
3267
+ nonce: `0x${string}` | null;
3268
+ number: bigint | null;
3269
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
3270
+ parentHash: import("viem").Hash;
3271
+ receiptsRoot: import("viem").Hex;
3272
+ sealFields: import("viem").Hex[];
3273
+ sha3Uncles: import("viem").Hash;
3274
+ size: bigint;
3275
+ stateRoot: import("viem").Hash;
3276
+ timestamp: bigint;
3277
+ totalDifficulty: bigint | null;
3278
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
3279
+ transactionsRoot: import("viem").Hash;
3280
+ uncles: import("viem").Hash[];
3281
+ withdrawals?: import("viem").Withdrawal[] | undefined;
3282
+ withdrawalsRoot?: import("viem").Hex | undefined;
3283
+ } & {};
3284
+ type: "block";
3285
+ };
3286
+ readonly transaction: {
3287
+ exclude: [] | undefined;
3288
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
3289
+ blockHash: `0x${string}` | null;
3290
+ blockNumber: bigint | null;
3291
+ from: import("viem").Address;
3292
+ gas: bigint;
3293
+ hash: import("viem").Hash;
3294
+ input: import("viem").Hex;
3295
+ nonce: number;
3296
+ r: import("viem").Hex;
3297
+ s: import("viem").Hex;
3298
+ to: import("viem").Address | null;
3299
+ transactionIndex: number | null;
3300
+ typeHex: import("viem").Hex | null;
3301
+ v: bigint;
3302
+ value: bigint;
3303
+ yParity: number;
3304
+ gasPrice?: undefined;
3305
+ maxFeePerBlobGas?: undefined;
3306
+ maxFeePerGas: bigint;
3307
+ maxPriorityFeePerGas: bigint;
3308
+ isSystemTx?: boolean;
3309
+ mint?: bigint | undefined;
3310
+ sourceHash: import("viem").Hex;
3311
+ type: "deposit";
3312
+ } | {
3313
+ r: import("viem").Hex;
3314
+ s: import("viem").Hex;
3315
+ v: bigint;
3316
+ to: import("viem").Address | null;
3317
+ from: import("viem").Address;
3318
+ gas: bigint;
3319
+ nonce: number;
3320
+ value: bigint;
3321
+ blockHash: `0x${string}` | null;
3322
+ blockNumber: bigint | null;
3323
+ hash: import("viem").Hash;
3324
+ input: import("viem").Hex;
3325
+ transactionIndex: number | null;
3326
+ typeHex: import("viem").Hex | null;
3327
+ accessList?: undefined;
3328
+ authorizationList?: undefined;
3329
+ blobVersionedHashes?: undefined;
3330
+ chainId?: number | undefined;
3331
+ yParity?: undefined;
3332
+ type: "legacy";
3333
+ gasPrice: bigint;
3334
+ maxFeePerBlobGas?: undefined;
3335
+ maxFeePerGas?: undefined;
3336
+ maxPriorityFeePerGas?: undefined;
3337
+ isSystemTx?: undefined;
3338
+ mint?: undefined;
3339
+ sourceHash?: undefined;
3340
+ } | {
3341
+ blockHash: `0x${string}` | null;
3342
+ blockNumber: bigint | null;
3343
+ from: import("viem").Address;
3344
+ gas: bigint;
3345
+ hash: import("viem").Hash;
3346
+ input: import("viem").Hex;
3347
+ nonce: number;
3348
+ r: import("viem").Hex;
3349
+ s: import("viem").Hex;
3350
+ to: import("viem").Address | null;
3351
+ transactionIndex: number | null;
3352
+ typeHex: import("viem").Hex | null;
3353
+ v: bigint;
3354
+ value: bigint;
3355
+ yParity: number;
3356
+ accessList: import("viem").AccessList;
3357
+ authorizationList?: undefined;
3358
+ blobVersionedHashes?: undefined;
3359
+ chainId: number;
3360
+ type: "eip2930";
3361
+ gasPrice: bigint;
3362
+ maxFeePerBlobGas?: undefined;
3363
+ maxFeePerGas?: undefined;
3364
+ maxPriorityFeePerGas?: undefined;
3365
+ isSystemTx?: undefined;
3366
+ mint?: undefined;
3367
+ sourceHash?: undefined;
3368
+ } | {
3369
+ blockHash: `0x${string}` | null;
3370
+ blockNumber: bigint | null;
3371
+ from: import("viem").Address;
3372
+ gas: bigint;
3373
+ hash: import("viem").Hash;
3374
+ input: import("viem").Hex;
3375
+ nonce: number;
3376
+ r: import("viem").Hex;
3377
+ s: import("viem").Hex;
3378
+ to: import("viem").Address | null;
3379
+ transactionIndex: number | null;
3380
+ typeHex: import("viem").Hex | null;
3381
+ v: bigint;
3382
+ value: bigint;
3383
+ yParity: number;
3384
+ accessList: import("viem").AccessList;
3385
+ authorizationList?: undefined;
3386
+ blobVersionedHashes?: undefined;
3387
+ chainId: number;
3388
+ type: "eip1559";
3389
+ gasPrice?: undefined;
3390
+ maxFeePerBlobGas?: undefined;
3391
+ maxFeePerGas: bigint;
3392
+ maxPriorityFeePerGas: bigint;
3393
+ isSystemTx?: undefined;
3394
+ mint?: undefined;
3395
+ sourceHash?: undefined;
3396
+ } | {
3397
+ blockHash: `0x${string}` | null;
3398
+ blockNumber: bigint | null;
3399
+ from: import("viem").Address;
3400
+ gas: bigint;
3401
+ hash: import("viem").Hash;
3402
+ input: import("viem").Hex;
3403
+ nonce: number;
3404
+ r: import("viem").Hex;
3405
+ s: import("viem").Hex;
3406
+ to: import("viem").Address | null;
3407
+ transactionIndex: number | null;
3408
+ typeHex: import("viem").Hex | null;
3409
+ v: bigint;
3410
+ value: bigint;
3411
+ yParity: number;
3412
+ accessList: import("viem").AccessList;
3413
+ authorizationList?: undefined;
3414
+ blobVersionedHashes: readonly import("viem").Hex[];
3415
+ chainId: number;
3416
+ type: "eip4844";
3417
+ gasPrice?: undefined;
3418
+ maxFeePerBlobGas: bigint;
3419
+ maxFeePerGas: bigint;
3420
+ maxPriorityFeePerGas: bigint;
3421
+ isSystemTx?: undefined;
3422
+ mint?: undefined;
3423
+ sourceHash?: undefined;
3424
+ } | {
3425
+ blockHash: `0x${string}` | null;
3426
+ blockNumber: bigint | null;
3427
+ from: import("viem").Address;
3428
+ gas: bigint;
3429
+ hash: import("viem").Hash;
3430
+ input: import("viem").Hex;
3431
+ nonce: number;
3432
+ r: import("viem").Hex;
3433
+ s: import("viem").Hex;
3434
+ to: import("viem").Address | null;
3435
+ transactionIndex: number | null;
3436
+ typeHex: import("viem").Hex | null;
3437
+ v: bigint;
3438
+ value: bigint;
3439
+ yParity: number;
3440
+ accessList: import("viem").AccessList;
3441
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
3442
+ blobVersionedHashes?: undefined;
3443
+ chainId: number;
3444
+ type: "eip7702";
3445
+ gasPrice?: undefined;
3446
+ maxFeePerBlobGas?: undefined;
3447
+ maxFeePerGas: bigint;
3448
+ maxPriorityFeePerGas: bigint;
3449
+ isSystemTx?: undefined;
3450
+ mint?: undefined;
3451
+ sourceHash?: undefined;
3452
+ }) & {};
3453
+ type: "transaction";
3454
+ };
3455
+ readonly transactionReceipt: {
3456
+ exclude: [] | undefined;
3457
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
3458
+ blobGasPrice?: bigint | undefined;
3459
+ blobGasUsed?: bigint | undefined;
3460
+ blockHash: import("viem").Hash;
3461
+ blockNumber: bigint;
3462
+ contractAddress: import("viem").Address | null | undefined;
3463
+ cumulativeGasUsed: bigint;
3464
+ effectiveGasPrice: bigint;
3465
+ from: import("viem").Address;
3466
+ gasUsed: bigint;
3467
+ logs: import("viem").Log<bigint, number, false>[];
3468
+ logsBloom: import("viem").Hex;
3469
+ root?: import("viem").Hash | undefined;
3470
+ status: "success" | "reverted";
3471
+ to: import("viem").Address | null;
3472
+ transactionHash: import("viem").Hash;
3473
+ transactionIndex: number;
3474
+ type: import("viem").TransactionType;
3475
+ l1GasPrice: bigint | null;
3476
+ l1GasUsed: bigint | null;
3477
+ l1Fee: bigint | null;
3478
+ l1FeeScalar: number | null;
3479
+ } & {};
3480
+ type: "transactionReceipt";
3481
+ };
3482
+ };
3483
+ serializers: {
3484
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3485
+ };
3486
+ }, undefined, chainOverride>, "address" | "args" | "abi" | "functionName"> extends infer T ? { [K in keyof T]: import("viem").UnionOmit<import("viem").WriteContractParameters<readonly [{
3487
+ readonly inputs: readonly [{
3488
+ readonly components: readonly [{
3489
+ readonly internalType: "Account";
3490
+ readonly name: "account";
3491
+ readonly type: "bytes21";
3492
+ }, {
3493
+ readonly internalType: "address";
3494
+ readonly name: "target";
3495
+ readonly type: "address";
3496
+ }, {
3497
+ readonly internalType: "bytes";
3498
+ readonly name: "data";
3499
+ readonly type: "bytes";
3500
+ }];
3501
+ readonly internalType: "struct IRouter.SimulateData[]";
3502
+ readonly name: "calls";
3503
+ readonly type: "tuple[]";
3504
+ }];
3505
+ readonly name: "batchSimulate";
3506
+ readonly outputs: readonly [{
3507
+ readonly internalType: "bytes[]";
3508
+ readonly name: "";
3509
+ readonly type: "bytes[]";
3510
+ }];
3511
+ readonly stateMutability: "nonpayable";
3512
+ readonly type: "function";
3513
+ }, {
3514
+ readonly inputs: readonly [{
3515
+ readonly components: readonly [{
3516
+ readonly internalType: "uint8";
3517
+ readonly name: "accountId";
3518
+ readonly type: "uint8";
3519
+ }, {
3520
+ readonly internalType: "bytes";
3521
+ readonly name: "data";
3522
+ readonly type: "bytes";
3523
+ }];
3524
+ readonly internalType: "struct IRouter.DirectCall[]";
3525
+ readonly name: "data";
3526
+ readonly type: "tuple[]";
3527
+ }, {
3528
+ readonly internalType: "bool";
3529
+ readonly name: "requireMarginCheckCall";
3530
+ readonly type: "bool";
3531
+ }];
3532
+ readonly name: "directCall";
3533
+ readonly outputs: readonly [{
3534
+ readonly internalType: "bytes[]";
3535
+ readonly name: "";
3536
+ readonly type: "bytes[]";
3537
+ }];
3538
+ readonly stateMutability: "nonpayable";
3539
+ readonly type: "function";
3540
+ }, {
3541
+ readonly inputs: readonly [{
3542
+ readonly internalType: "bytes";
3543
+ readonly name: "data";
3544
+ readonly type: "bytes";
3545
+ }];
3546
+ readonly name: "viewCall";
3547
+ readonly outputs: readonly [{
3548
+ readonly internalType: "bytes";
3549
+ readonly name: "";
3550
+ readonly type: "bytes";
3551
+ }];
3552
+ readonly stateMutability: "view";
3553
+ readonly type: "function";
3554
+ }], "batchSimulate", readonly [readonly {
3555
+ account: `0x${string}`;
3556
+ target: `0x${string}`;
3557
+ data: `0x${string}`;
3558
+ }[]], {
3559
+ blockExplorers: {
3560
+ readonly default: {
3561
+ readonly name: "Basescan";
3562
+ readonly url: "https://basescan.org";
3563
+ readonly apiUrl: "https://api.basescan.org/api";
3564
+ };
3565
+ };
3566
+ contracts: {
3567
+ readonly disputeGameFactory: {
3568
+ readonly 1: {
3569
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
3570
+ };
3571
+ };
3572
+ readonly l2OutputOracle: {
3573
+ readonly 1: {
3574
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
3575
+ };
3576
+ };
3577
+ readonly multicall3: {
3578
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3579
+ readonly blockCreated: 5022;
3580
+ };
3581
+ readonly portal: {
3582
+ readonly 1: {
3583
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
3584
+ readonly blockCreated: 17482143;
3585
+ };
3586
+ };
3587
+ readonly l1StandardBridge: {
3588
+ readonly 1: {
3589
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
3590
+ readonly blockCreated: 17482143;
3591
+ };
3592
+ };
3593
+ readonly gasPriceOracle: {
3594
+ readonly address: "0x420000000000000000000000000000000000000F";
3595
+ };
3596
+ readonly l1Block: {
3597
+ readonly address: "0x4200000000000000000000000000000000000015";
3598
+ };
3599
+ readonly l2CrossDomainMessenger: {
3600
+ readonly address: "0x4200000000000000000000000000000000000007";
3601
+ };
3602
+ readonly l2Erc721Bridge: {
3603
+ readonly address: "0x4200000000000000000000000000000000000014";
3604
+ };
3605
+ readonly l2StandardBridge: {
3606
+ readonly address: "0x4200000000000000000000000000000000000010";
3607
+ };
3608
+ readonly l2ToL1MessagePasser: {
3609
+ readonly address: "0x4200000000000000000000000000000000000016";
3610
+ };
3611
+ };
3612
+ id: 8453;
3613
+ name: "Base";
3614
+ nativeCurrency: {
3615
+ readonly name: "Ether";
3616
+ readonly symbol: "ETH";
3617
+ readonly decimals: 18;
3618
+ };
3619
+ rpcUrls: {
3620
+ readonly default: {
3621
+ readonly http: readonly ["https://mainnet.base.org"];
3622
+ };
3623
+ };
3624
+ sourceId: 1;
3625
+ testnet?: boolean | undefined;
3626
+ custom?: Record<string, unknown> | undefined;
3627
+ fees?: import("viem").ChainFees<undefined> | undefined;
3628
+ formatters: {
3629
+ readonly block: {
3630
+ exclude: [] | undefined;
3631
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
3632
+ baseFeePerGas: bigint | null;
3633
+ blobGasUsed: bigint;
3634
+ difficulty: bigint;
3635
+ excessBlobGas: bigint;
3636
+ extraData: import("viem").Hex;
3637
+ gasLimit: bigint;
3638
+ gasUsed: bigint;
3639
+ hash: `0x${string}` | null;
3640
+ logsBloom: `0x${string}` | null;
3641
+ miner: import("viem").Address;
3642
+ mixHash: import("viem").Hash;
3643
+ nonce: `0x${string}` | null;
3644
+ number: bigint | null;
3645
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
3646
+ parentHash: import("viem").Hash;
3647
+ receiptsRoot: import("viem").Hex;
3648
+ sealFields: import("viem").Hex[];
3649
+ sha3Uncles: import("viem").Hash;
3650
+ size: bigint;
3651
+ stateRoot: import("viem").Hash;
3652
+ timestamp: bigint;
3653
+ totalDifficulty: bigint | null;
3654
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
3655
+ transactionsRoot: import("viem").Hash;
3656
+ uncles: import("viem").Hash[];
3657
+ withdrawals?: import("viem").Withdrawal[] | undefined;
3658
+ withdrawalsRoot?: import("viem").Hex | undefined;
3659
+ } & {};
3660
+ type: "block";
3661
+ };
3662
+ readonly transaction: {
3663
+ exclude: [] | undefined;
3664
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
3665
+ blockHash: `0x${string}` | null;
3666
+ blockNumber: bigint | null;
3667
+ from: import("viem").Address;
3668
+ gas: bigint;
3669
+ hash: import("viem").Hash;
3670
+ input: import("viem").Hex;
3671
+ nonce: number;
3672
+ r: import("viem").Hex;
3673
+ s: import("viem").Hex;
3674
+ to: import("viem").Address | null;
3675
+ transactionIndex: number | null;
3676
+ typeHex: import("viem").Hex | null;
3677
+ v: bigint;
3678
+ value: bigint;
3679
+ yParity: number;
3680
+ gasPrice?: undefined;
3681
+ maxFeePerBlobGas?: undefined;
3682
+ maxFeePerGas: bigint;
3683
+ maxPriorityFeePerGas: bigint;
3684
+ isSystemTx?: boolean;
3685
+ mint?: bigint | undefined;
3686
+ sourceHash: import("viem").Hex;
3687
+ type: "deposit";
3688
+ } | {
3689
+ r: import("viem").Hex;
3690
+ s: import("viem").Hex;
3691
+ v: bigint;
3692
+ to: import("viem").Address | null;
3693
+ from: import("viem").Address;
3694
+ gas: bigint;
3695
+ nonce: number;
3696
+ value: bigint;
3697
+ blockHash: `0x${string}` | null;
3698
+ blockNumber: bigint | null;
3699
+ hash: import("viem").Hash;
3700
+ input: import("viem").Hex;
3701
+ transactionIndex: number | null;
3702
+ typeHex: import("viem").Hex | null;
3703
+ accessList?: undefined;
3704
+ authorizationList?: undefined;
3705
+ blobVersionedHashes?: undefined;
3706
+ chainId?: number | undefined;
3707
+ yParity?: undefined;
3708
+ type: "legacy";
3709
+ gasPrice: bigint;
3710
+ maxFeePerBlobGas?: undefined;
3711
+ maxFeePerGas?: undefined;
3712
+ maxPriorityFeePerGas?: undefined;
3713
+ isSystemTx?: undefined;
3714
+ mint?: undefined;
3715
+ sourceHash?: undefined;
3716
+ } | {
3717
+ blockHash: `0x${string}` | null;
3718
+ blockNumber: bigint | null;
3719
+ from: import("viem").Address;
3720
+ gas: bigint;
3721
+ hash: import("viem").Hash;
3722
+ input: import("viem").Hex;
3723
+ nonce: number;
3724
+ r: import("viem").Hex;
3725
+ s: import("viem").Hex;
3726
+ to: import("viem").Address | null;
3727
+ transactionIndex: number | null;
3728
+ typeHex: import("viem").Hex | null;
3729
+ v: bigint;
3730
+ value: bigint;
3731
+ yParity: number;
3732
+ accessList: import("viem").AccessList;
3733
+ authorizationList?: undefined;
3734
+ blobVersionedHashes?: undefined;
3735
+ chainId: number;
3736
+ type: "eip2930";
3737
+ gasPrice: bigint;
3738
+ maxFeePerBlobGas?: undefined;
3739
+ maxFeePerGas?: undefined;
3740
+ maxPriorityFeePerGas?: undefined;
3741
+ isSystemTx?: undefined;
3742
+ mint?: undefined;
3743
+ sourceHash?: undefined;
3744
+ } | {
3745
+ blockHash: `0x${string}` | null;
3746
+ blockNumber: bigint | null;
3747
+ from: import("viem").Address;
3748
+ gas: bigint;
3749
+ hash: import("viem").Hash;
3750
+ input: import("viem").Hex;
3751
+ nonce: number;
3752
+ r: import("viem").Hex;
3753
+ s: import("viem").Hex;
3754
+ to: import("viem").Address | null;
3755
+ transactionIndex: number | null;
3756
+ typeHex: import("viem").Hex | null;
3757
+ v: bigint;
3758
+ value: bigint;
3759
+ yParity: number;
3760
+ accessList: import("viem").AccessList;
3761
+ authorizationList?: undefined;
3762
+ blobVersionedHashes?: undefined;
3763
+ chainId: number;
3764
+ type: "eip1559";
3765
+ gasPrice?: undefined;
3766
+ maxFeePerBlobGas?: undefined;
3767
+ maxFeePerGas: bigint;
3768
+ maxPriorityFeePerGas: bigint;
3769
+ isSystemTx?: undefined;
3770
+ mint?: undefined;
3771
+ sourceHash?: undefined;
3772
+ } | {
3773
+ blockHash: `0x${string}` | null;
3774
+ blockNumber: bigint | null;
3775
+ from: import("viem").Address;
3776
+ gas: bigint;
3777
+ hash: import("viem").Hash;
3778
+ input: import("viem").Hex;
3779
+ nonce: number;
3780
+ r: import("viem").Hex;
3781
+ s: import("viem").Hex;
3782
+ to: import("viem").Address | null;
3783
+ transactionIndex: number | null;
3784
+ typeHex: import("viem").Hex | null;
3785
+ v: bigint;
3786
+ value: bigint;
3787
+ yParity: number;
3788
+ accessList: import("viem").AccessList;
3789
+ authorizationList?: undefined;
3790
+ blobVersionedHashes: readonly import("viem").Hex[];
3791
+ chainId: number;
3792
+ type: "eip4844";
3793
+ gasPrice?: undefined;
3794
+ maxFeePerBlobGas: bigint;
3795
+ maxFeePerGas: bigint;
3796
+ maxPriorityFeePerGas: bigint;
3797
+ isSystemTx?: undefined;
3798
+ mint?: undefined;
3799
+ sourceHash?: undefined;
3800
+ } | {
3801
+ blockHash: `0x${string}` | null;
3802
+ blockNumber: bigint | null;
3803
+ from: import("viem").Address;
3804
+ gas: bigint;
3805
+ hash: import("viem").Hash;
3806
+ input: import("viem").Hex;
3807
+ nonce: number;
3808
+ r: import("viem").Hex;
3809
+ s: import("viem").Hex;
3810
+ to: import("viem").Address | null;
3811
+ transactionIndex: number | null;
3812
+ typeHex: import("viem").Hex | null;
3813
+ v: bigint;
3814
+ value: bigint;
3815
+ yParity: number;
3816
+ accessList: import("viem").AccessList;
3817
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
3818
+ blobVersionedHashes?: undefined;
3819
+ chainId: number;
3820
+ type: "eip7702";
3821
+ gasPrice?: undefined;
3822
+ maxFeePerBlobGas?: undefined;
3823
+ maxFeePerGas: bigint;
3824
+ maxPriorityFeePerGas: bigint;
3825
+ isSystemTx?: undefined;
3826
+ mint?: undefined;
3827
+ sourceHash?: undefined;
3828
+ }) & {};
3829
+ type: "transaction";
3830
+ };
3831
+ readonly transactionReceipt: {
3832
+ exclude: [] | undefined;
3833
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
3834
+ blobGasPrice?: bigint | undefined;
3835
+ blobGasUsed?: bigint | undefined;
3836
+ blockHash: import("viem").Hash;
3837
+ blockNumber: bigint;
3838
+ contractAddress: import("viem").Address | null | undefined;
3839
+ cumulativeGasUsed: bigint;
3840
+ effectiveGasPrice: bigint;
3841
+ from: import("viem").Address;
3842
+ gasUsed: bigint;
3843
+ logs: import("viem").Log<bigint, number, false>[];
3844
+ logsBloom: import("viem").Hex;
3845
+ root?: import("viem").Hash | undefined;
3846
+ status: "success" | "reverted";
3847
+ to: import("viem").Address | null;
3848
+ transactionHash: import("viem").Hash;
3849
+ transactionIndex: number;
3850
+ type: import("viem").TransactionType;
3851
+ l1GasPrice: bigint | null;
3852
+ l1GasUsed: bigint | null;
3853
+ l1Fee: bigint | null;
3854
+ l1FeeScalar: number | null;
3855
+ } & {};
3856
+ type: "transactionReceipt";
3857
+ };
3858
+ };
3859
+ serializers: {
3860
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3861
+ };
3862
+ }, undefined, chainOverride>, "address" | "args" | "abi" | "functionName">[K]; } : never>(args: readonly [readonly {
3863
+ account: `0x${string}`;
3864
+ target: `0x${string}`;
3865
+ data: `0x${string}`;
3866
+ }[]], options: options) => Promise<import("viem").WriteContractReturnType>;
3867
+ directCall: <chainOverride extends import("viem").Chain | undefined, options extends import("viem").UnionOmit<import("viem").WriteContractParameters<readonly [{
3868
+ readonly inputs: readonly [{
3869
+ readonly components: readonly [{
3870
+ readonly internalType: "Account";
3871
+ readonly name: "account";
3872
+ readonly type: "bytes21";
3873
+ }, {
3874
+ readonly internalType: "address";
3875
+ readonly name: "target";
3876
+ readonly type: "address";
3877
+ }, {
3878
+ readonly internalType: "bytes";
3879
+ readonly name: "data";
3880
+ readonly type: "bytes";
3881
+ }];
3882
+ readonly internalType: "struct IRouter.SimulateData[]";
3883
+ readonly name: "calls";
3884
+ readonly type: "tuple[]";
3885
+ }];
3886
+ readonly name: "batchSimulate";
3887
+ readonly outputs: readonly [{
3888
+ readonly internalType: "bytes[]";
3889
+ readonly name: "";
3890
+ readonly type: "bytes[]";
3891
+ }];
3892
+ readonly stateMutability: "nonpayable";
3893
+ readonly type: "function";
3894
+ }, {
3895
+ readonly inputs: readonly [{
3896
+ readonly components: readonly [{
3897
+ readonly internalType: "uint8";
3898
+ readonly name: "accountId";
3899
+ readonly type: "uint8";
3900
+ }, {
3901
+ readonly internalType: "bytes";
3902
+ readonly name: "data";
3903
+ readonly type: "bytes";
3904
+ }];
3905
+ readonly internalType: "struct IRouter.DirectCall[]";
3906
+ readonly name: "data";
3907
+ readonly type: "tuple[]";
3908
+ }, {
3909
+ readonly internalType: "bool";
3910
+ readonly name: "requireMarginCheckCall";
3911
+ readonly type: "bool";
3912
+ }];
3913
+ readonly name: "directCall";
3914
+ readonly outputs: readonly [{
3915
+ readonly internalType: "bytes[]";
3916
+ readonly name: "";
3917
+ readonly type: "bytes[]";
3918
+ }];
3919
+ readonly stateMutability: "nonpayable";
3920
+ readonly type: "function";
3921
+ }, {
3922
+ readonly inputs: readonly [{
3923
+ readonly internalType: "bytes";
3924
+ readonly name: "data";
3925
+ readonly type: "bytes";
3926
+ }];
3927
+ readonly name: "viewCall";
3928
+ readonly outputs: readonly [{
3929
+ readonly internalType: "bytes";
3930
+ readonly name: "";
3931
+ readonly type: "bytes";
3932
+ }];
3933
+ readonly stateMutability: "view";
3934
+ readonly type: "function";
3935
+ }], "directCall", readonly [readonly {
3936
+ accountId: number;
3937
+ data: `0x${string}`;
3938
+ }[], boolean], {
3939
+ blockExplorers: {
3940
+ readonly default: {
3941
+ readonly name: "Basescan";
3942
+ readonly url: "https://basescan.org";
3943
+ readonly apiUrl: "https://api.basescan.org/api";
3944
+ };
3945
+ };
3946
+ contracts: {
3947
+ readonly disputeGameFactory: {
3948
+ readonly 1: {
3949
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
3950
+ };
3951
+ };
3952
+ readonly l2OutputOracle: {
3953
+ readonly 1: {
3954
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
3955
+ };
3956
+ };
3957
+ readonly multicall3: {
3958
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3959
+ readonly blockCreated: 5022;
3960
+ };
3961
+ readonly portal: {
3962
+ readonly 1: {
3963
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
3964
+ readonly blockCreated: 17482143;
3965
+ };
3966
+ };
3967
+ readonly l1StandardBridge: {
3968
+ readonly 1: {
3969
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
3970
+ readonly blockCreated: 17482143;
3971
+ };
3972
+ };
3973
+ readonly gasPriceOracle: {
3974
+ readonly address: "0x420000000000000000000000000000000000000F";
3975
+ };
3976
+ readonly l1Block: {
3977
+ readonly address: "0x4200000000000000000000000000000000000015";
3978
+ };
3979
+ readonly l2CrossDomainMessenger: {
3980
+ readonly address: "0x4200000000000000000000000000000000000007";
3981
+ };
3982
+ readonly l2Erc721Bridge: {
3983
+ readonly address: "0x4200000000000000000000000000000000000014";
3984
+ };
3985
+ readonly l2StandardBridge: {
3986
+ readonly address: "0x4200000000000000000000000000000000000010";
3987
+ };
3988
+ readonly l2ToL1MessagePasser: {
3989
+ readonly address: "0x4200000000000000000000000000000000000016";
3990
+ };
3991
+ };
3992
+ id: 8453;
3993
+ name: "Base";
3994
+ nativeCurrency: {
3995
+ readonly name: "Ether";
3996
+ readonly symbol: "ETH";
3997
+ readonly decimals: 18;
3998
+ };
3999
+ rpcUrls: {
4000
+ readonly default: {
4001
+ readonly http: readonly ["https://mainnet.base.org"];
4002
+ };
4003
+ };
4004
+ sourceId: 1;
4005
+ testnet?: boolean | undefined;
4006
+ custom?: Record<string, unknown> | undefined;
4007
+ fees?: import("viem").ChainFees<undefined> | undefined;
4008
+ formatters: {
4009
+ readonly block: {
4010
+ exclude: [] | undefined;
4011
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
4012
+ baseFeePerGas: bigint | null;
4013
+ blobGasUsed: bigint;
4014
+ difficulty: bigint;
4015
+ excessBlobGas: bigint;
4016
+ extraData: import("viem").Hex;
4017
+ gasLimit: bigint;
4018
+ gasUsed: bigint;
4019
+ hash: `0x${string}` | null;
4020
+ logsBloom: `0x${string}` | null;
4021
+ miner: import("viem").Address;
4022
+ mixHash: import("viem").Hash;
4023
+ nonce: `0x${string}` | null;
4024
+ number: bigint | null;
4025
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
4026
+ parentHash: import("viem").Hash;
4027
+ receiptsRoot: import("viem").Hex;
4028
+ sealFields: import("viem").Hex[];
4029
+ sha3Uncles: import("viem").Hash;
4030
+ size: bigint;
4031
+ stateRoot: import("viem").Hash;
4032
+ timestamp: bigint;
4033
+ totalDifficulty: bigint | null;
4034
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
4035
+ transactionsRoot: import("viem").Hash;
4036
+ uncles: import("viem").Hash[];
4037
+ withdrawals?: import("viem").Withdrawal[] | undefined;
4038
+ withdrawalsRoot?: import("viem").Hex | undefined;
4039
+ } & {};
4040
+ type: "block";
4041
+ };
4042
+ readonly transaction: {
4043
+ exclude: [] | undefined;
4044
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
4045
+ blockHash: `0x${string}` | null;
4046
+ blockNumber: bigint | null;
4047
+ from: import("viem").Address;
4048
+ gas: bigint;
4049
+ hash: import("viem").Hash;
4050
+ input: import("viem").Hex;
4051
+ nonce: number;
4052
+ r: import("viem").Hex;
4053
+ s: import("viem").Hex;
4054
+ to: import("viem").Address | null;
4055
+ transactionIndex: number | null;
4056
+ typeHex: import("viem").Hex | null;
4057
+ v: bigint;
4058
+ value: bigint;
4059
+ yParity: number;
4060
+ gasPrice?: undefined;
4061
+ maxFeePerBlobGas?: undefined;
4062
+ maxFeePerGas: bigint;
4063
+ maxPriorityFeePerGas: bigint;
4064
+ isSystemTx?: boolean;
4065
+ mint?: bigint | undefined;
4066
+ sourceHash: import("viem").Hex;
4067
+ type: "deposit";
4068
+ } | {
4069
+ r: import("viem").Hex;
4070
+ s: import("viem").Hex;
4071
+ v: bigint;
4072
+ to: import("viem").Address | null;
4073
+ from: import("viem").Address;
4074
+ gas: bigint;
4075
+ nonce: number;
4076
+ value: bigint;
4077
+ blockHash: `0x${string}` | null;
4078
+ blockNumber: bigint | null;
4079
+ hash: import("viem").Hash;
4080
+ input: import("viem").Hex;
4081
+ transactionIndex: number | null;
4082
+ typeHex: import("viem").Hex | null;
4083
+ accessList?: undefined;
4084
+ authorizationList?: undefined;
4085
+ blobVersionedHashes?: undefined;
4086
+ chainId?: number | undefined;
4087
+ yParity?: undefined;
4088
+ type: "legacy";
4089
+ gasPrice: bigint;
4090
+ maxFeePerBlobGas?: undefined;
4091
+ maxFeePerGas?: undefined;
4092
+ maxPriorityFeePerGas?: undefined;
4093
+ isSystemTx?: undefined;
4094
+ mint?: undefined;
4095
+ sourceHash?: undefined;
4096
+ } | {
4097
+ blockHash: `0x${string}` | null;
4098
+ blockNumber: bigint | null;
4099
+ from: import("viem").Address;
4100
+ gas: bigint;
4101
+ hash: import("viem").Hash;
4102
+ input: import("viem").Hex;
4103
+ nonce: number;
4104
+ r: import("viem").Hex;
4105
+ s: import("viem").Hex;
4106
+ to: import("viem").Address | null;
4107
+ transactionIndex: number | null;
4108
+ typeHex: import("viem").Hex | null;
4109
+ v: bigint;
4110
+ value: bigint;
4111
+ yParity: number;
4112
+ accessList: import("viem").AccessList;
4113
+ authorizationList?: undefined;
4114
+ blobVersionedHashes?: undefined;
4115
+ chainId: number;
4116
+ type: "eip2930";
4117
+ gasPrice: bigint;
4118
+ maxFeePerBlobGas?: undefined;
4119
+ maxFeePerGas?: undefined;
4120
+ maxPriorityFeePerGas?: undefined;
4121
+ isSystemTx?: undefined;
4122
+ mint?: undefined;
4123
+ sourceHash?: undefined;
4124
+ } | {
4125
+ blockHash: `0x${string}` | null;
4126
+ blockNumber: bigint | null;
4127
+ from: import("viem").Address;
4128
+ gas: bigint;
4129
+ hash: import("viem").Hash;
4130
+ input: import("viem").Hex;
4131
+ nonce: number;
4132
+ r: import("viem").Hex;
4133
+ s: import("viem").Hex;
4134
+ to: import("viem").Address | null;
4135
+ transactionIndex: number | null;
4136
+ typeHex: import("viem").Hex | null;
4137
+ v: bigint;
4138
+ value: bigint;
4139
+ yParity: number;
4140
+ accessList: import("viem").AccessList;
4141
+ authorizationList?: undefined;
4142
+ blobVersionedHashes?: undefined;
4143
+ chainId: number;
4144
+ type: "eip1559";
4145
+ gasPrice?: undefined;
4146
+ maxFeePerBlobGas?: undefined;
4147
+ maxFeePerGas: bigint;
4148
+ maxPriorityFeePerGas: bigint;
4149
+ isSystemTx?: undefined;
4150
+ mint?: undefined;
4151
+ sourceHash?: undefined;
4152
+ } | {
4153
+ blockHash: `0x${string}` | null;
4154
+ blockNumber: bigint | null;
4155
+ from: import("viem").Address;
4156
+ gas: bigint;
4157
+ hash: import("viem").Hash;
4158
+ input: import("viem").Hex;
4159
+ nonce: number;
4160
+ r: import("viem").Hex;
4161
+ s: import("viem").Hex;
4162
+ to: import("viem").Address | null;
4163
+ transactionIndex: number | null;
4164
+ typeHex: import("viem").Hex | null;
4165
+ v: bigint;
4166
+ value: bigint;
4167
+ yParity: number;
4168
+ accessList: import("viem").AccessList;
4169
+ authorizationList?: undefined;
4170
+ blobVersionedHashes: readonly import("viem").Hex[];
4171
+ chainId: number;
4172
+ type: "eip4844";
4173
+ gasPrice?: undefined;
4174
+ maxFeePerBlobGas: bigint;
4175
+ maxFeePerGas: bigint;
4176
+ maxPriorityFeePerGas: bigint;
4177
+ isSystemTx?: undefined;
4178
+ mint?: undefined;
4179
+ sourceHash?: undefined;
4180
+ } | {
4181
+ blockHash: `0x${string}` | null;
4182
+ blockNumber: bigint | null;
4183
+ from: import("viem").Address;
4184
+ gas: bigint;
4185
+ hash: import("viem").Hash;
4186
+ input: import("viem").Hex;
4187
+ nonce: number;
4188
+ r: import("viem").Hex;
4189
+ s: import("viem").Hex;
4190
+ to: import("viem").Address | null;
4191
+ transactionIndex: number | null;
4192
+ typeHex: import("viem").Hex | null;
4193
+ v: bigint;
4194
+ value: bigint;
4195
+ yParity: number;
4196
+ accessList: import("viem").AccessList;
4197
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
4198
+ blobVersionedHashes?: undefined;
4199
+ chainId: number;
4200
+ type: "eip7702";
4201
+ gasPrice?: undefined;
4202
+ maxFeePerBlobGas?: undefined;
4203
+ maxFeePerGas: bigint;
4204
+ maxPriorityFeePerGas: bigint;
4205
+ isSystemTx?: undefined;
4206
+ mint?: undefined;
4207
+ sourceHash?: undefined;
4208
+ }) & {};
4209
+ type: "transaction";
4210
+ };
4211
+ readonly transactionReceipt: {
4212
+ exclude: [] | undefined;
4213
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
4214
+ blobGasPrice?: bigint | undefined;
4215
+ blobGasUsed?: bigint | undefined;
4216
+ blockHash: import("viem").Hash;
4217
+ blockNumber: bigint;
4218
+ contractAddress: import("viem").Address | null | undefined;
4219
+ cumulativeGasUsed: bigint;
4220
+ effectiveGasPrice: bigint;
4221
+ from: import("viem").Address;
4222
+ gasUsed: bigint;
4223
+ logs: import("viem").Log<bigint, number, false>[];
4224
+ logsBloom: import("viem").Hex;
4225
+ root?: import("viem").Hash | undefined;
4226
+ status: "success" | "reverted";
4227
+ to: import("viem").Address | null;
4228
+ transactionHash: import("viem").Hash;
4229
+ transactionIndex: number;
4230
+ type: import("viem").TransactionType;
4231
+ l1GasPrice: bigint | null;
4232
+ l1GasUsed: bigint | null;
4233
+ l1Fee: bigint | null;
4234
+ l1FeeScalar: number | null;
4235
+ } & {};
4236
+ type: "transactionReceipt";
4237
+ };
4238
+ };
4239
+ serializers: {
4240
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
4241
+ };
4242
+ }, undefined, chainOverride>, "address" | "args" | "abi" | "functionName"> extends infer T ? { [K in keyof T]: import("viem").UnionOmit<import("viem").WriteContractParameters<readonly [{
4243
+ readonly inputs: readonly [{
4244
+ readonly components: readonly [{
4245
+ readonly internalType: "Account";
4246
+ readonly name: "account";
4247
+ readonly type: "bytes21";
4248
+ }, {
4249
+ readonly internalType: "address";
4250
+ readonly name: "target";
4251
+ readonly type: "address";
4252
+ }, {
4253
+ readonly internalType: "bytes";
4254
+ readonly name: "data";
4255
+ readonly type: "bytes";
4256
+ }];
4257
+ readonly internalType: "struct IRouter.SimulateData[]";
4258
+ readonly name: "calls";
4259
+ readonly type: "tuple[]";
4260
+ }];
4261
+ readonly name: "batchSimulate";
4262
+ readonly outputs: readonly [{
4263
+ readonly internalType: "bytes[]";
4264
+ readonly name: "";
4265
+ readonly type: "bytes[]";
4266
+ }];
4267
+ readonly stateMutability: "nonpayable";
4268
+ readonly type: "function";
4269
+ }, {
4270
+ readonly inputs: readonly [{
4271
+ readonly components: readonly [{
4272
+ readonly internalType: "uint8";
4273
+ readonly name: "accountId";
4274
+ readonly type: "uint8";
4275
+ }, {
4276
+ readonly internalType: "bytes";
4277
+ readonly name: "data";
4278
+ readonly type: "bytes";
4279
+ }];
4280
+ readonly internalType: "struct IRouter.DirectCall[]";
4281
+ readonly name: "data";
4282
+ readonly type: "tuple[]";
4283
+ }, {
4284
+ readonly internalType: "bool";
4285
+ readonly name: "requireMarginCheckCall";
4286
+ readonly type: "bool";
4287
+ }];
4288
+ readonly name: "directCall";
4289
+ readonly outputs: readonly [{
4290
+ readonly internalType: "bytes[]";
4291
+ readonly name: "";
4292
+ readonly type: "bytes[]";
4293
+ }];
4294
+ readonly stateMutability: "nonpayable";
4295
+ readonly type: "function";
4296
+ }, {
4297
+ readonly inputs: readonly [{
4298
+ readonly internalType: "bytes";
4299
+ readonly name: "data";
4300
+ readonly type: "bytes";
4301
+ }];
4302
+ readonly name: "viewCall";
4303
+ readonly outputs: readonly [{
4304
+ readonly internalType: "bytes";
4305
+ readonly name: "";
4306
+ readonly type: "bytes";
4307
+ }];
4308
+ readonly stateMutability: "view";
4309
+ readonly type: "function";
4310
+ }], "directCall", readonly [readonly {
4311
+ accountId: number;
4312
+ data: `0x${string}`;
4313
+ }[], boolean], {
4314
+ blockExplorers: {
4315
+ readonly default: {
4316
+ readonly name: "Basescan";
4317
+ readonly url: "https://basescan.org";
4318
+ readonly apiUrl: "https://api.basescan.org/api";
4319
+ };
4320
+ };
4321
+ contracts: {
4322
+ readonly disputeGameFactory: {
4323
+ readonly 1: {
4324
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
4325
+ };
4326
+ };
4327
+ readonly l2OutputOracle: {
4328
+ readonly 1: {
4329
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
4330
+ };
4331
+ };
4332
+ readonly multicall3: {
4333
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4334
+ readonly blockCreated: 5022;
4335
+ };
4336
+ readonly portal: {
4337
+ readonly 1: {
4338
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
4339
+ readonly blockCreated: 17482143;
4340
+ };
4341
+ };
4342
+ readonly l1StandardBridge: {
4343
+ readonly 1: {
4344
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
4345
+ readonly blockCreated: 17482143;
4346
+ };
4347
+ };
4348
+ readonly gasPriceOracle: {
4349
+ readonly address: "0x420000000000000000000000000000000000000F";
4350
+ };
4351
+ readonly l1Block: {
4352
+ readonly address: "0x4200000000000000000000000000000000000015";
4353
+ };
4354
+ readonly l2CrossDomainMessenger: {
4355
+ readonly address: "0x4200000000000000000000000000000000000007";
4356
+ };
4357
+ readonly l2Erc721Bridge: {
4358
+ readonly address: "0x4200000000000000000000000000000000000014";
4359
+ };
4360
+ readonly l2StandardBridge: {
4361
+ readonly address: "0x4200000000000000000000000000000000000010";
4362
+ };
4363
+ readonly l2ToL1MessagePasser: {
4364
+ readonly address: "0x4200000000000000000000000000000000000016";
4365
+ };
4366
+ };
4367
+ id: 8453;
4368
+ name: "Base";
4369
+ nativeCurrency: {
4370
+ readonly name: "Ether";
4371
+ readonly symbol: "ETH";
4372
+ readonly decimals: 18;
4373
+ };
4374
+ rpcUrls: {
4375
+ readonly default: {
4376
+ readonly http: readonly ["https://mainnet.base.org"];
4377
+ };
4378
+ };
4379
+ sourceId: 1;
4380
+ testnet?: boolean | undefined;
4381
+ custom?: Record<string, unknown> | undefined;
4382
+ fees?: import("viem").ChainFees<undefined> | undefined;
4383
+ formatters: {
4384
+ readonly block: {
4385
+ exclude: [] | undefined;
4386
+ format: (args: import("viem/chains").OpStackRpcBlock) => {
4387
+ baseFeePerGas: bigint | null;
4388
+ blobGasUsed: bigint;
4389
+ difficulty: bigint;
4390
+ excessBlobGas: bigint;
4391
+ extraData: import("viem").Hex;
4392
+ gasLimit: bigint;
4393
+ gasUsed: bigint;
4394
+ hash: `0x${string}` | null;
4395
+ logsBloom: `0x${string}` | null;
4396
+ miner: import("viem").Address;
4397
+ mixHash: import("viem").Hash;
4398
+ nonce: `0x${string}` | null;
4399
+ number: bigint | null;
4400
+ parentBeaconBlockRoot?: import("viem").Hex | undefined;
4401
+ parentHash: import("viem").Hash;
4402
+ receiptsRoot: import("viem").Hex;
4403
+ sealFields: import("viem").Hex[];
4404
+ sha3Uncles: import("viem").Hash;
4405
+ size: bigint;
4406
+ stateRoot: import("viem").Hash;
4407
+ timestamp: bigint;
4408
+ totalDifficulty: bigint | null;
4409
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
4410
+ transactionsRoot: import("viem").Hash;
4411
+ uncles: import("viem").Hash[];
4412
+ withdrawals?: import("viem").Withdrawal[] | undefined;
4413
+ withdrawalsRoot?: import("viem").Hex | undefined;
4414
+ } & {};
4415
+ type: "block";
4416
+ };
4417
+ readonly transaction: {
4418
+ exclude: [] | undefined;
4419
+ format: (args: import("viem/chains").OpStackRpcTransaction) => ({
4420
+ blockHash: `0x${string}` | null;
4421
+ blockNumber: bigint | null;
4422
+ from: import("viem").Address;
4423
+ gas: bigint;
4424
+ hash: import("viem").Hash;
4425
+ input: import("viem").Hex;
4426
+ nonce: number;
4427
+ r: import("viem").Hex;
4428
+ s: import("viem").Hex;
4429
+ to: import("viem").Address | null;
4430
+ transactionIndex: number | null;
4431
+ typeHex: import("viem").Hex | null;
4432
+ v: bigint;
4433
+ value: bigint;
4434
+ yParity: number;
4435
+ gasPrice?: undefined;
4436
+ maxFeePerBlobGas?: undefined;
4437
+ maxFeePerGas: bigint;
4438
+ maxPriorityFeePerGas: bigint;
4439
+ isSystemTx?: boolean;
4440
+ mint?: bigint | undefined;
4441
+ sourceHash: import("viem").Hex;
4442
+ type: "deposit";
4443
+ } | {
4444
+ r: import("viem").Hex;
4445
+ s: import("viem").Hex;
4446
+ v: bigint;
4447
+ to: import("viem").Address | null;
4448
+ from: import("viem").Address;
4449
+ gas: bigint;
4450
+ nonce: number;
4451
+ value: bigint;
4452
+ blockHash: `0x${string}` | null;
4453
+ blockNumber: bigint | null;
4454
+ hash: import("viem").Hash;
4455
+ input: import("viem").Hex;
4456
+ transactionIndex: number | null;
4457
+ typeHex: import("viem").Hex | null;
4458
+ accessList?: undefined;
4459
+ authorizationList?: undefined;
4460
+ blobVersionedHashes?: undefined;
4461
+ chainId?: number | undefined;
4462
+ yParity?: undefined;
4463
+ type: "legacy";
4464
+ gasPrice: bigint;
4465
+ maxFeePerBlobGas?: undefined;
4466
+ maxFeePerGas?: undefined;
4467
+ maxPriorityFeePerGas?: undefined;
4468
+ isSystemTx?: undefined;
4469
+ mint?: undefined;
4470
+ sourceHash?: undefined;
4471
+ } | {
4472
+ blockHash: `0x${string}` | null;
4473
+ blockNumber: bigint | null;
4474
+ from: import("viem").Address;
4475
+ gas: bigint;
4476
+ hash: import("viem").Hash;
4477
+ input: import("viem").Hex;
4478
+ nonce: number;
4479
+ r: import("viem").Hex;
4480
+ s: import("viem").Hex;
4481
+ to: import("viem").Address | null;
4482
+ transactionIndex: number | null;
4483
+ typeHex: import("viem").Hex | null;
4484
+ v: bigint;
4485
+ value: bigint;
4486
+ yParity: number;
4487
+ accessList: import("viem").AccessList;
4488
+ authorizationList?: undefined;
4489
+ blobVersionedHashes?: undefined;
4490
+ chainId: number;
4491
+ type: "eip2930";
4492
+ gasPrice: bigint;
4493
+ maxFeePerBlobGas?: undefined;
4494
+ maxFeePerGas?: undefined;
4495
+ maxPriorityFeePerGas?: undefined;
4496
+ isSystemTx?: undefined;
4497
+ mint?: undefined;
4498
+ sourceHash?: undefined;
4499
+ } | {
4500
+ blockHash: `0x${string}` | null;
4501
+ blockNumber: bigint | null;
4502
+ from: import("viem").Address;
4503
+ gas: bigint;
4504
+ hash: import("viem").Hash;
4505
+ input: import("viem").Hex;
4506
+ nonce: number;
4507
+ r: import("viem").Hex;
4508
+ s: import("viem").Hex;
4509
+ to: import("viem").Address | null;
4510
+ transactionIndex: number | null;
4511
+ typeHex: import("viem").Hex | null;
4512
+ v: bigint;
4513
+ value: bigint;
4514
+ yParity: number;
4515
+ accessList: import("viem").AccessList;
4516
+ authorizationList?: undefined;
4517
+ blobVersionedHashes?: undefined;
4518
+ chainId: number;
4519
+ type: "eip1559";
4520
+ gasPrice?: undefined;
4521
+ maxFeePerBlobGas?: undefined;
4522
+ maxFeePerGas: bigint;
4523
+ maxPriorityFeePerGas: bigint;
4524
+ isSystemTx?: undefined;
4525
+ mint?: undefined;
4526
+ sourceHash?: undefined;
4527
+ } | {
4528
+ blockHash: `0x${string}` | null;
4529
+ blockNumber: bigint | null;
4530
+ from: import("viem").Address;
4531
+ gas: bigint;
4532
+ hash: import("viem").Hash;
4533
+ input: import("viem").Hex;
4534
+ nonce: number;
4535
+ r: import("viem").Hex;
4536
+ s: import("viem").Hex;
4537
+ to: import("viem").Address | null;
4538
+ transactionIndex: number | null;
4539
+ typeHex: import("viem").Hex | null;
4540
+ v: bigint;
4541
+ value: bigint;
4542
+ yParity: number;
4543
+ accessList: import("viem").AccessList;
4544
+ authorizationList?: undefined;
4545
+ blobVersionedHashes: readonly import("viem").Hex[];
4546
+ chainId: number;
4547
+ type: "eip4844";
4548
+ gasPrice?: undefined;
4549
+ maxFeePerBlobGas: bigint;
4550
+ maxFeePerGas: bigint;
4551
+ maxPriorityFeePerGas: bigint;
4552
+ isSystemTx?: undefined;
4553
+ mint?: undefined;
4554
+ sourceHash?: undefined;
4555
+ } | {
4556
+ blockHash: `0x${string}` | null;
4557
+ blockNumber: bigint | null;
4558
+ from: import("viem").Address;
4559
+ gas: bigint;
4560
+ hash: import("viem").Hash;
4561
+ input: import("viem").Hex;
4562
+ nonce: number;
4563
+ r: import("viem").Hex;
4564
+ s: import("viem").Hex;
4565
+ to: import("viem").Address | null;
4566
+ transactionIndex: number | null;
4567
+ typeHex: import("viem").Hex | null;
4568
+ v: bigint;
4569
+ value: bigint;
4570
+ yParity: number;
4571
+ accessList: import("viem").AccessList;
4572
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
4573
+ blobVersionedHashes?: undefined;
4574
+ chainId: number;
4575
+ type: "eip7702";
4576
+ gasPrice?: undefined;
4577
+ maxFeePerBlobGas?: undefined;
4578
+ maxFeePerGas: bigint;
4579
+ maxPriorityFeePerGas: bigint;
4580
+ isSystemTx?: undefined;
4581
+ mint?: undefined;
4582
+ sourceHash?: undefined;
4583
+ }) & {};
4584
+ type: "transaction";
4585
+ };
4586
+ readonly transactionReceipt: {
4587
+ exclude: [] | undefined;
4588
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
4589
+ blobGasPrice?: bigint | undefined;
4590
+ blobGasUsed?: bigint | undefined;
4591
+ blockHash: import("viem").Hash;
4592
+ blockNumber: bigint;
4593
+ contractAddress: import("viem").Address | null | undefined;
4594
+ cumulativeGasUsed: bigint;
4595
+ effectiveGasPrice: bigint;
4596
+ from: import("viem").Address;
4597
+ gasUsed: bigint;
4598
+ logs: import("viem").Log<bigint, number, false>[];
4599
+ logsBloom: import("viem").Hex;
4600
+ root?: import("viem").Hash | undefined;
4601
+ status: "success" | "reverted";
4602
+ to: import("viem").Address | null;
4603
+ transactionHash: import("viem").Hash;
4604
+ transactionIndex: number;
4605
+ type: import("viem").TransactionType;
4606
+ l1GasPrice: bigint | null;
4607
+ l1GasUsed: bigint | null;
4608
+ l1Fee: bigint | null;
4609
+ l1FeeScalar: number | null;
4610
+ } & {};
4611
+ type: "transactionReceipt";
4612
+ };
4613
+ };
4614
+ serializers: {
4615
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
4616
+ };
4617
+ }, undefined, chainOverride>, "address" | "args" | "abi" | "functionName">[K]; } : never>(args: readonly [readonly {
4618
+ accountId: number;
4619
+ data: `0x${string}`;
4620
+ }[], boolean], options: options) => Promise<import("viem").WriteContractReturnType>;
4621
+ };
4622
+ address: "0xb18F37F4B37b6B4F56E15f2e9F3Fe78cf5c6FE9E";
4623
+ abi: readonly [{
4624
+ readonly inputs: readonly [{
4625
+ readonly components: readonly [{
4626
+ readonly internalType: "Account";
4627
+ readonly name: "account";
4628
+ readonly type: "bytes21";
4629
+ }, {
4630
+ readonly internalType: "address";
4631
+ readonly name: "target";
4632
+ readonly type: "address";
4633
+ }, {
4634
+ readonly internalType: "bytes";
4635
+ readonly name: "data";
4636
+ readonly type: "bytes";
4637
+ }];
4638
+ readonly internalType: "struct IRouter.SimulateData[]";
4639
+ readonly name: "calls";
4640
+ readonly type: "tuple[]";
4641
+ }];
4642
+ readonly name: "batchSimulate";
4643
+ readonly outputs: readonly [{
4644
+ readonly internalType: "bytes[]";
4645
+ readonly name: "";
4646
+ readonly type: "bytes[]";
4647
+ }];
4648
+ readonly stateMutability: "nonpayable";
4649
+ readonly type: "function";
4650
+ }, {
4651
+ readonly inputs: readonly [{
4652
+ readonly components: readonly [{
4653
+ readonly internalType: "uint8";
4654
+ readonly name: "accountId";
4655
+ readonly type: "uint8";
4656
+ }, {
4657
+ readonly internalType: "bytes";
4658
+ readonly name: "data";
4659
+ readonly type: "bytes";
4660
+ }];
4661
+ readonly internalType: "struct IRouter.DirectCall[]";
4662
+ readonly name: "data";
4663
+ readonly type: "tuple[]";
4664
+ }, {
4665
+ readonly internalType: "bool";
4666
+ readonly name: "requireMarginCheckCall";
4667
+ readonly type: "bool";
4668
+ }];
4669
+ readonly name: "directCall";
4670
+ readonly outputs: readonly [{
4671
+ readonly internalType: "bytes[]";
4672
+ readonly name: "";
4673
+ readonly type: "bytes[]";
4674
+ }];
4675
+ readonly stateMutability: "nonpayable";
4676
+ readonly type: "function";
4677
+ }, {
4678
+ readonly inputs: readonly [{
4679
+ readonly internalType: "bytes";
4680
+ readonly name: "data";
4681
+ readonly type: "bytes";
4682
+ }];
4683
+ readonly name: "viewCall";
4684
+ readonly outputs: readonly [{
4685
+ readonly internalType: "bytes";
4686
+ readonly name: "";
4687
+ readonly type: "bytes";
4688
+ }];
4689
+ readonly stateMutability: "view";
4690
+ readonly type: "function";
4691
+ }];
4692
+ };