@1delta/providers 0.0.41 → 0.0.43

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 (20) hide show
  1. package/dist/{_esm-NMEXBKYZ.mjs → _esm-BLSSJTMS.mjs} +33 -33
  2. package/dist/{ccip-3Y4YD27I.mjs → ccip-P6QKYDYG.mjs} +1 -1
  3. package/dist/{chunk-7BYOX3YW.mjs → chunk-GGVKF6RL.mjs} +175 -129
  4. package/dist/index.d.mts +582 -160
  5. package/dist/index.d.ts +582 -160
  6. package/dist/index.js +1424 -1193
  7. package/dist/index.mjs +815 -640
  8. package/package.json +5 -6
  9. package/src/chains/chainMapping.ts +314 -0
  10. package/src/chains/customChains.ts +202 -0
  11. package/src/client/client.ts +110 -0
  12. package/src/evm.ts +7 -1067
  13. package/src/multicall/multicall.ts +250 -0
  14. package/src/rpc/rpcOverrides.ts +248 -0
  15. package/src/transport/transport.ts +17 -0
  16. package/src/utils/utils.ts +55 -0
  17. package/test/contract.ts +204 -0
  18. package/test/multicallRetry.test.ts +808 -0
  19. package/test/multicallRetry.testUtils.ts +181 -0
  20. package/vitest.config.ts +8 -0
package/dist/index.d.ts CHANGED
@@ -1,7 +1,7 @@
1
- import * as viem_zksync from 'viem/zksync';
2
- import * as viem_chains from 'viem/chains';
3
1
  import * as viem from 'viem';
4
2
  import { PublicClient } from 'viem';
3
+ import * as viem_zksync from 'viem/zksync';
4
+ import * as viem_chains from 'viem/chains';
5
5
 
6
6
  declare const katana: {
7
7
  blockExplorers: {
@@ -35,6 +35,7 @@ declare const katana: {
35
35
  sourceId?: number | undefined | undefined;
36
36
  testnet?: boolean | undefined | undefined;
37
37
  custom?: Record<string, unknown> | undefined;
38
+ extendSchema?: Record<string, unknown> | undefined;
38
39
  fees?: viem.ChainFees<undefined> | undefined;
39
40
  formatters?: undefined;
40
41
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -45,6 +46,7 @@ declare const katana: {
45
46
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
46
47
  }] | undefined;
47
48
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
49
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
48
50
  };
49
51
  declare const plasma: {
50
52
  blockExplorers: {
@@ -77,6 +79,7 @@ declare const plasma: {
77
79
  sourceId?: number | undefined | undefined;
78
80
  testnet?: boolean | undefined | undefined;
79
81
  custom?: Record<string, unknown> | undefined;
82
+ extendSchema?: Record<string, unknown> | undefined;
80
83
  fees?: viem.ChainFees<undefined> | undefined;
81
84
  formatters?: undefined;
82
85
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -87,7 +90,282 @@ declare const plasma: {
87
90
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
88
91
  }] | undefined;
89
92
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
93
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
94
+ };
95
+ declare const customChains: {
96
+ readonly artela: {
97
+ blockExplorers: {
98
+ readonly default: {
99
+ readonly name: "Explorer";
100
+ readonly url: "https://artscan.artela.network";
101
+ };
102
+ };
103
+ blockTime?: number | undefined | undefined;
104
+ contracts: {
105
+ readonly multicall3: {
106
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
107
+ readonly blockCreated: 1;
108
+ };
109
+ };
110
+ ensTlds?: readonly string[] | undefined;
111
+ id: 11820;
112
+ name: "Artela Mainnet";
113
+ nativeCurrency: {
114
+ readonly decimals: 18;
115
+ readonly name: "ART";
116
+ readonly symbol: "ART";
117
+ };
118
+ experimental_preconfirmationTime?: number | undefined | undefined;
119
+ rpcUrls: {
120
+ readonly default: {
121
+ readonly http: readonly ["https://node-euro.artela.network/rpc"];
122
+ };
123
+ };
124
+ sourceId?: number | undefined | undefined;
125
+ testnet?: boolean | undefined | undefined;
126
+ custom?: Record<string, unknown> | undefined;
127
+ extendSchema?: Record<string, unknown> | undefined;
128
+ fees?: viem.ChainFees<undefined> | undefined;
129
+ formatters?: undefined;
130
+ prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
131
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
132
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
133
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
134
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
135
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
136
+ }] | undefined;
137
+ serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
138
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
139
+ };
140
+ readonly botanix: {
141
+ blockExplorers: {
142
+ readonly default: {
143
+ readonly name: "Explorer";
144
+ readonly url: "https://botanixscan.io/";
145
+ };
146
+ };
147
+ blockTime?: number | undefined | undefined;
148
+ contracts: {
149
+ readonly multicall3: {
150
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
151
+ readonly blockCreated: 1;
152
+ };
153
+ };
154
+ ensTlds?: readonly string[] | undefined;
155
+ id: 3637;
156
+ name: "Botanix";
157
+ nativeCurrency: {
158
+ readonly decimals: 18;
159
+ readonly name: "BTC";
160
+ readonly symbol: "BTC";
161
+ };
162
+ experimental_preconfirmationTime?: number | undefined | undefined;
163
+ rpcUrls: {
164
+ readonly default: {
165
+ readonly http: readonly ["https://rpc.ankr.com/botanix_mainnet", "https://rpc.botanixlabs.com"];
166
+ };
167
+ };
168
+ sourceId?: number | undefined | undefined;
169
+ testnet?: boolean | undefined | undefined;
170
+ custom?: Record<string, unknown> | undefined;
171
+ extendSchema?: Record<string, unknown> | undefined;
172
+ fees?: viem.ChainFees<undefined> | undefined;
173
+ formatters?: undefined;
174
+ prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
175
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
176
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
177
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
178
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
179
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
180
+ }] | undefined;
181
+ serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
182
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
183
+ };
184
+ readonly crossfi: {
185
+ blockExplorers: {
186
+ readonly default: {
187
+ readonly name: "Explorer";
188
+ readonly url: "https://xfiscan.com/";
189
+ };
190
+ };
191
+ blockTime?: number | undefined | undefined;
192
+ contracts?: {
193
+ [x: string]: viem.ChainContract | {
194
+ [sourceId: number]: viem.ChainContract | undefined;
195
+ } | undefined;
196
+ ensRegistry?: viem.ChainContract | undefined;
197
+ ensUniversalResolver?: viem.ChainContract | undefined;
198
+ multicall3?: viem.ChainContract | undefined;
199
+ erc6492Verifier?: viem.ChainContract | undefined;
200
+ } | undefined;
201
+ ensTlds?: readonly string[] | undefined;
202
+ id: 4158;
203
+ name: "CrossFi Mainet";
204
+ nativeCurrency: {
205
+ readonly decimals: 18;
206
+ readonly name: "XFI";
207
+ readonly symbol: "XFI";
208
+ };
209
+ experimental_preconfirmationTime?: number | undefined | undefined;
210
+ rpcUrls: {
211
+ readonly default: {
212
+ readonly http: readonly ["https://rpc.mainnet.ms/"];
213
+ };
214
+ };
215
+ sourceId?: number | undefined | undefined;
216
+ testnet?: boolean | undefined | undefined;
217
+ custom?: Record<string, unknown> | undefined;
218
+ extendSchema?: Record<string, unknown> | undefined;
219
+ fees?: viem.ChainFees<undefined> | undefined;
220
+ formatters?: undefined;
221
+ prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
222
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
223
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
224
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
225
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
226
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
227
+ }] | undefined;
228
+ serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
229
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
230
+ };
231
+ readonly GraphLinq: {
232
+ blockExplorers: {
233
+ readonly default: {
234
+ readonly name: "Explorer";
235
+ readonly url: "https://explorer.graphlinq.io";
236
+ };
237
+ };
238
+ blockTime?: number | undefined | undefined;
239
+ contracts?: {
240
+ [x: string]: viem.ChainContract | {
241
+ [sourceId: number]: viem.ChainContract | undefined;
242
+ } | undefined;
243
+ ensRegistry?: viem.ChainContract | undefined;
244
+ ensUniversalResolver?: viem.ChainContract | undefined;
245
+ multicall3?: viem.ChainContract | undefined;
246
+ erc6492Verifier?: viem.ChainContract | undefined;
247
+ } | undefined;
248
+ ensTlds?: readonly string[] | undefined;
249
+ id: 614;
250
+ name: "GraphLinq Chain";
251
+ nativeCurrency: {
252
+ readonly decimals: 18;
253
+ readonly name: "GLQ";
254
+ readonly symbol: "GLQ";
255
+ };
256
+ experimental_preconfirmationTime?: number | undefined | undefined;
257
+ rpcUrls: {
258
+ readonly default: {
259
+ readonly http: readonly ["https://glq-dataseed.graphlinq.io"];
260
+ };
261
+ };
262
+ sourceId?: number | undefined | undefined;
263
+ testnet?: boolean | undefined | undefined;
264
+ custom?: Record<string, unknown> | undefined;
265
+ extendSchema?: Record<string, unknown> | undefined;
266
+ fees?: viem.ChainFees<undefined> | undefined;
267
+ formatters?: undefined;
268
+ prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
269
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
270
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
271
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
272
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
273
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
274
+ }] | undefined;
275
+ serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
276
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
277
+ };
278
+ readonly hyperEvm: {
279
+ blockExplorers: {
280
+ readonly default: {
281
+ readonly name: "Explorer";
282
+ readonly url: "https://hypurrscan.io/";
283
+ };
284
+ };
285
+ blockTime?: number | undefined | undefined;
286
+ contracts: {
287
+ readonly multicall3: {
288
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
289
+ readonly blockCreated: 1;
290
+ };
291
+ };
292
+ ensTlds?: readonly string[] | undefined;
293
+ id: 999;
294
+ name: "Hyper EVM";
295
+ nativeCurrency: {
296
+ readonly decimals: 18;
297
+ readonly name: "HYPE";
298
+ readonly symbol: "HYPE";
299
+ };
300
+ experimental_preconfirmationTime?: number | undefined | undefined;
301
+ rpcUrls: {
302
+ readonly default: {
303
+ readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
304
+ };
305
+ };
306
+ sourceId?: number | undefined | undefined;
307
+ testnet?: boolean | undefined | undefined;
308
+ custom?: Record<string, unknown> | undefined;
309
+ extendSchema?: Record<string, unknown> | undefined;
310
+ fees?: viem.ChainFees<undefined> | undefined;
311
+ formatters?: undefined;
312
+ prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
313
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
314
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
315
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
316
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
317
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
318
+ }] | undefined;
319
+ serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
320
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
321
+ };
322
+ readonly monadMainnet: {
323
+ blockExplorers: {
324
+ readonly default: {
325
+ readonly name: "Explorer";
326
+ readonly url: "https://monadvision.com/";
327
+ };
328
+ };
329
+ blockTime?: number | undefined | undefined;
330
+ contracts: {
331
+ readonly multicall3: {
332
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
333
+ readonly blockCreated: 1;
334
+ };
335
+ };
336
+ ensTlds?: readonly string[] | undefined;
337
+ id: 143;
338
+ name: "Monad Mainnet";
339
+ nativeCurrency: {
340
+ readonly name: "Monad";
341
+ readonly symbol: "MON";
342
+ readonly decimals: 18;
343
+ };
344
+ experimental_preconfirmationTime?: number | undefined | undefined;
345
+ rpcUrls: {
346
+ readonly default: {
347
+ readonly http: readonly ["https://rpc-mainnet.monadinfra.com", "https://rpc.monad.xyz", "https://rpc1.monad.xyz", "https://rpc2.monad.xyz", "https://rpc3.monad.xyz", "https://rpc4.monad.xyz"];
348
+ };
349
+ };
350
+ sourceId?: number | undefined | undefined;
351
+ testnet?: boolean | undefined | undefined;
352
+ custom?: Record<string, unknown> | undefined;
353
+ extendSchema?: Record<string, unknown> | undefined;
354
+ fees?: viem.ChainFees<undefined> | undefined;
355
+ formatters?: undefined;
356
+ prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
357
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
358
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
359
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
360
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
361
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
362
+ }] | undefined;
363
+ serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
364
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
365
+ readonly network: "monad";
366
+ };
90
367
  };
368
+
91
369
  declare function getEvmChain(chain: string): {
92
370
  blockExplorers: {
93
371
  readonly default: {
@@ -122,6 +400,7 @@ declare function getEvmChain(chain: string): {
122
400
  sourceId?: number | undefined | undefined;
123
401
  testnet?: boolean | undefined | undefined;
124
402
  custom?: Record<string, unknown> | undefined;
403
+ extendSchema?: Record<string, unknown> | undefined;
125
404
  fees?: viem.ChainFees<undefined> | undefined;
126
405
  formatters?: undefined;
127
406
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -132,6 +411,7 @@ declare function getEvmChain(chain: string): {
132
411
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
133
412
  }] | undefined;
134
413
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
414
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
135
415
  } | {
136
416
  blockExplorers: {
137
417
  readonly default: {
@@ -163,6 +443,7 @@ declare function getEvmChain(chain: string): {
163
443
  sourceId?: number | undefined | undefined;
164
444
  testnet?: boolean | undefined | undefined;
165
445
  custom?: Record<string, unknown> | undefined;
446
+ extendSchema?: Record<string, unknown> | undefined;
166
447
  fees?: viem.ChainFees<undefined> | undefined;
167
448
  formatters?: undefined;
168
449
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -173,6 +454,7 @@ declare function getEvmChain(chain: string): {
173
454
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
174
455
  }] | undefined;
175
456
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
457
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
176
458
  } | {
177
459
  blockExplorers: {
178
460
  readonly default: {
@@ -204,6 +486,7 @@ declare function getEvmChain(chain: string): {
204
486
  sourceId?: number | undefined | undefined;
205
487
  testnet?: boolean | undefined | undefined;
206
488
  custom?: Record<string, unknown> | undefined;
489
+ extendSchema?: Record<string, unknown> | undefined;
207
490
  fees?: viem.ChainFees<undefined> | undefined;
208
491
  formatters?: undefined;
209
492
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -214,6 +497,7 @@ declare function getEvmChain(chain: string): {
214
497
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
215
498
  }] | undefined;
216
499
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
500
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
217
501
  } | {
218
502
  blockExplorers: {
219
503
  readonly default: {
@@ -246,6 +530,7 @@ declare function getEvmChain(chain: string): {
246
530
  sourceId?: number | undefined | undefined;
247
531
  testnet?: boolean | undefined | undefined;
248
532
  custom?: Record<string, unknown> | undefined;
533
+ extendSchema?: Record<string, unknown> | undefined;
249
534
  fees?: viem.ChainFees<undefined> | undefined;
250
535
  formatters?: undefined;
251
536
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -256,6 +541,7 @@ declare function getEvmChain(chain: string): {
256
541
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
257
542
  }] | undefined;
258
543
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
544
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
259
545
  } | {
260
546
  blockExplorers: {
261
547
  readonly default: {
@@ -290,6 +576,7 @@ declare function getEvmChain(chain: string): {
290
576
  sourceId?: number | undefined | undefined;
291
577
  testnet?: boolean | undefined | undefined;
292
578
  custom?: Record<string, unknown> | undefined;
579
+ extendSchema?: Record<string, unknown> | undefined;
293
580
  fees?: viem.ChainFees<undefined> | undefined;
294
581
  formatters?: undefined;
295
582
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -300,6 +587,7 @@ declare function getEvmChain(chain: string): {
300
587
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
301
588
  }] | undefined;
302
589
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
590
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
303
591
  } | {
304
592
  blockExplorers: {
305
593
  readonly default: {
@@ -331,6 +619,7 @@ declare function getEvmChain(chain: string): {
331
619
  sourceId?: number | undefined | undefined;
332
620
  testnet?: boolean | undefined | undefined;
333
621
  custom?: Record<string, unknown> | undefined;
622
+ extendSchema?: Record<string, unknown> | undefined;
334
623
  fees?: viem.ChainFees<undefined> | undefined;
335
624
  formatters?: undefined;
336
625
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -341,6 +630,7 @@ declare function getEvmChain(chain: string): {
341
630
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
342
631
  }] | undefined;
343
632
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
633
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
344
634
  } | {
345
635
  blockExplorers: {
346
636
  readonly default: {
@@ -372,6 +662,7 @@ declare function getEvmChain(chain: string): {
372
662
  sourceId?: number | undefined | undefined;
373
663
  testnet?: boolean | undefined | undefined;
374
664
  custom?: Record<string, unknown> | undefined;
665
+ extendSchema?: Record<string, unknown> | undefined;
375
666
  fees?: viem.ChainFees<undefined> | undefined;
376
667
  formatters?: undefined;
377
668
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -382,6 +673,7 @@ declare function getEvmChain(chain: string): {
382
673
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
383
674
  }] | undefined;
384
675
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
676
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
385
677
  } | {
386
678
  blockExplorers: {
387
679
  readonly default: {
@@ -413,6 +705,7 @@ declare function getEvmChain(chain: string): {
413
705
  sourceId?: number | undefined | undefined;
414
706
  testnet?: boolean | undefined | undefined;
415
707
  custom?: Record<string, unknown> | undefined;
708
+ extendSchema?: Record<string, unknown> | undefined;
416
709
  fees?: viem.ChainFees<undefined> | undefined;
417
710
  formatters?: undefined;
418
711
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -423,6 +716,7 @@ declare function getEvmChain(chain: string): {
423
716
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
424
717
  }] | undefined;
425
718
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
719
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
426
720
  readonly network: "monad";
427
721
  } | {
428
722
  blockExplorers: {
@@ -456,6 +750,7 @@ declare function getEvmChain(chain: string): {
456
750
  sourceId?: number | undefined | undefined;
457
751
  testnet?: boolean | undefined | undefined;
458
752
  custom?: Record<string, unknown> | undefined;
753
+ extendSchema?: Record<string, unknown> | undefined;
459
754
  fees?: viem.ChainFees<undefined> | undefined;
460
755
  formatters?: undefined;
461
756
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -466,6 +761,7 @@ declare function getEvmChain(chain: string): {
466
761
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
467
762
  }] | undefined;
468
763
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
764
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
469
765
  } | {
470
766
  blockExplorers: {
471
767
  readonly default: {
@@ -502,6 +798,7 @@ declare function getEvmChain(chain: string): {
502
798
  sourceId?: number | undefined | undefined;
503
799
  testnet?: boolean | undefined | undefined;
504
800
  custom?: Record<string, unknown> | undefined;
801
+ extendSchema?: Record<string, unknown> | undefined;
505
802
  fees?: viem.ChainFees<undefined> | undefined;
506
803
  formatters?: undefined;
507
804
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -512,6 +809,7 @@ declare function getEvmChain(chain: string): {
512
809
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
513
810
  }] | undefined;
514
811
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
812
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
515
813
  } | {
516
814
  blockExplorers: {
517
815
  readonly default: {
@@ -544,6 +842,7 @@ declare function getEvmChain(chain: string): {
544
842
  sourceId?: number | undefined | undefined;
545
843
  testnet?: boolean | undefined | undefined;
546
844
  custom?: Record<string, unknown> | undefined;
845
+ extendSchema?: Record<string, unknown> | undefined;
547
846
  fees?: viem.ChainFees<undefined> | undefined;
548
847
  formatters?: undefined;
549
848
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -554,6 +853,7 @@ declare function getEvmChain(chain: string): {
554
853
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
555
854
  }] | undefined;
556
855
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
856
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
557
857
  } | {
558
858
  blockExplorers: {
559
859
  readonly default: {
@@ -586,6 +886,7 @@ declare function getEvmChain(chain: string): {
586
886
  sourceId?: number | undefined | undefined;
587
887
  testnet?: boolean | undefined | undefined;
588
888
  custom?: Record<string, unknown> | undefined;
889
+ extendSchema?: Record<string, unknown> | undefined;
589
890
  fees?: viem.ChainFees<undefined> | undefined;
590
891
  formatters?: undefined;
591
892
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -596,6 +897,7 @@ declare function getEvmChain(chain: string): {
596
897
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
597
898
  }] | undefined;
598
899
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
900
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
599
901
  } | {
600
902
  blockExplorers: {
601
903
  readonly default: {
@@ -661,6 +963,7 @@ declare function getEvmChain(chain: string): {
661
963
  sourceId: 56;
662
964
  testnet?: boolean | undefined | undefined;
663
965
  custom?: Record<string, unknown> | undefined;
966
+ extendSchema?: Record<string, unknown> | undefined;
664
967
  fees?: viem.ChainFees<undefined> | undefined;
665
968
  formatters?: undefined;
666
969
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -671,6 +974,7 @@ declare function getEvmChain(chain: string): {
671
974
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
672
975
  }] | undefined;
673
976
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
977
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
674
978
  } | {
675
979
  blockExplorers: {
676
980
  readonly default: {
@@ -703,6 +1007,7 @@ declare function getEvmChain(chain: string): {
703
1007
  sourceId?: number | undefined | undefined;
704
1008
  testnet?: boolean | undefined | undefined;
705
1009
  custom?: Record<string, unknown> | undefined;
1010
+ extendSchema?: Record<string, unknown> | undefined;
706
1011
  fees?: viem.ChainFees<undefined> | undefined;
707
1012
  formatters?: undefined;
708
1013
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -713,6 +1018,7 @@ declare function getEvmChain(chain: string): {
713
1018
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
714
1019
  }] | undefined;
715
1020
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
1021
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
716
1022
  } | {
717
1023
  blockExplorers: {
718
1024
  readonly default: {
@@ -745,6 +1051,7 @@ declare function getEvmChain(chain: string): {
745
1051
  sourceId?: number | undefined | undefined;
746
1052
  testnet?: boolean | undefined | undefined;
747
1053
  custom?: Record<string, unknown> | undefined;
1054
+ extendSchema?: Record<string, unknown> | undefined;
748
1055
  fees?: viem.ChainFees<undefined> | undefined;
749
1056
  formatters?: undefined;
750
1057
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -755,6 +1062,7 @@ declare function getEvmChain(chain: string): {
755
1062
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
756
1063
  }] | undefined;
757
1064
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
1065
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
758
1066
  } | {
759
1067
  blockExplorers: {
760
1068
  readonly default: {
@@ -825,6 +1133,7 @@ declare function getEvmChain(chain: string): {
825
1133
  sourceId: 1;
826
1134
  testnet?: boolean | undefined | undefined;
827
1135
  custom?: Record<string, unknown> | undefined;
1136
+ extendSchema?: Record<string, unknown> | undefined;
828
1137
  fees?: viem.ChainFees<undefined> | undefined;
829
1138
  formatters: {
830
1139
  readonly block: {
@@ -890,16 +1199,16 @@ declare function getEvmChain(chain: string): {
890
1199
  r: viem.Hex;
891
1200
  s: viem.Hex;
892
1201
  v: bigint;
893
- value: bigint;
894
- gas: bigint;
895
1202
  to: viem.Address | null;
896
1203
  from: viem.Address;
1204
+ gas: bigint;
897
1205
  nonce: number;
1206
+ value: bigint;
898
1207
  blockHash: `0x${string}` | null;
899
1208
  blockNumber: bigint | null;
900
- transactionIndex: number | null;
901
1209
  hash: viem.Hash;
902
1210
  input: viem.Hex;
1211
+ transactionIndex: number | null;
903
1212
  typeHex: viem.Hex | null;
904
1213
  accessList?: undefined | undefined;
905
1214
  authorizationList?: undefined | undefined;
@@ -1067,6 +1376,7 @@ declare function getEvmChain(chain: string): {
1067
1376
  serializers: {
1068
1377
  readonly transaction: typeof viem_chains.serializeTransactionOpStack;
1069
1378
  };
1379
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
1070
1380
  } | {
1071
1381
  blockExplorers: {
1072
1382
  readonly default: {
@@ -1100,6 +1410,7 @@ declare function getEvmChain(chain: string): {
1100
1410
  sourceId?: number | undefined | undefined;
1101
1411
  testnet?: boolean | undefined | undefined;
1102
1412
  custom?: Record<string, unknown> | undefined;
1413
+ extendSchema?: Record<string, unknown> | undefined;
1103
1414
  fees?: viem.ChainFees<undefined> | undefined;
1104
1415
  formatters?: undefined;
1105
1416
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -1110,12 +1421,13 @@ declare function getEvmChain(chain: string): {
1110
1421
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1111
1422
  }] | undefined;
1112
1423
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
1424
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
1113
1425
  } | {
1114
1426
  blockExplorers: {
1115
1427
  readonly default: {
1116
1428
  readonly name: "PolygonScan";
1117
1429
  readonly url: "https://polygonscan.com";
1118
- readonly apiUrl: "https://api.polygonscan.com/api";
1430
+ readonly apiUrl: "https://api.etherscan.io/v2/api";
1119
1431
  };
1120
1432
  };
1121
1433
  blockTime: 2000;
@@ -1142,6 +1454,7 @@ declare function getEvmChain(chain: string): {
1142
1454
  sourceId?: number | undefined | undefined;
1143
1455
  testnet?: boolean | undefined | undefined;
1144
1456
  custom?: Record<string, unknown> | undefined;
1457
+ extendSchema?: Record<string, unknown> | undefined;
1145
1458
  fees?: viem.ChainFees<undefined> | undefined;
1146
1459
  formatters?: undefined;
1147
1460
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -1152,14 +1465,10 @@ declare function getEvmChain(chain: string): {
1152
1465
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1153
1466
  }] | undefined;
1154
1467
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
1468
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
1155
1469
  } | {
1156
1470
  blockExplorers: {
1157
1471
  readonly default: {
1158
- readonly name: "Etherscan";
1159
- readonly url: "https://era.zksync.network/";
1160
- readonly apiUrl: "https://api-era.zksync.network/api";
1161
- };
1162
- readonly native: {
1163
1472
  readonly name: "ZKsync Explorer";
1164
1473
  readonly url: "https://explorer.zksync.io/";
1165
1474
  readonly apiUrl: "https://block-explorer-api.mainnet.zksync.io/api";
@@ -1195,6 +1504,7 @@ declare function getEvmChain(chain: string): {
1195
1504
  custom: {
1196
1505
  readonly getEip712Domain: viem_zksync.EIP712DomainFn<viem_chains.ZkSyncTransactionSerializable, viem_chains.ZkSyncEIP712TransactionSignable>;
1197
1506
  };
1507
+ extendSchema?: Record<string, unknown> | undefined;
1198
1508
  fees?: viem.ChainFees<undefined> | undefined;
1199
1509
  formatters: {
1200
1510
  readonly block: {
@@ -1238,16 +1548,16 @@ declare function getEvmChain(chain: string): {
1238
1548
  r: viem.Hex;
1239
1549
  s: viem.Hex;
1240
1550
  v: bigint;
1241
- value: bigint;
1242
- gas: bigint;
1243
1551
  to: viem.Address | null;
1244
1552
  from: viem.Address;
1553
+ gas: bigint;
1245
1554
  nonce: number;
1555
+ value: bigint;
1246
1556
  blockHash: `0x${string}` | null;
1247
1557
  blockNumber: bigint | null;
1248
- transactionIndex: number | null;
1249
1558
  hash: viem.Hash;
1250
1559
  input: viem.Hex;
1560
+ transactionIndex: number | null;
1251
1561
  typeHex: viem.Hex | null;
1252
1562
  accessList?: undefined | undefined;
1253
1563
  authorizationList?: undefined | undefined;
@@ -1421,15 +1731,15 @@ declare function getEvmChain(chain: string): {
1421
1731
  readonly transactionReceipt: {
1422
1732
  exclude: [] | undefined;
1423
1733
  format: (args: viem_chains.ZkSyncRpcTransactionReceipt, action?: string | undefined) => {
1424
- contractAddress: viem.Address | null | undefined;
1425
1734
  type: viem_chains.ZkSyncTransactionType;
1426
- status: "success" | "reverted";
1735
+ contractAddress: viem.Address | null | undefined;
1427
1736
  to: viem.Address | null;
1428
1737
  from: viem.Address;
1429
1738
  blockHash: viem.Hash;
1430
1739
  blockNumber: bigint;
1431
- transactionHash: viem.Hash;
1432
1740
  transactionIndex: number;
1741
+ status: "success" | "reverted";
1742
+ transactionHash: viem.Hash;
1433
1743
  logsBloom: viem.Hex;
1434
1744
  blobGasUsed?: bigint | undefined;
1435
1745
  gasUsed: bigint;
@@ -1506,10 +1816,10 @@ declare function getEvmChain(chain: string): {
1506
1816
  } | {
1507
1817
  type?: "0x3" | undefined;
1508
1818
  data?: `0x${string}` | undefined;
1509
- value?: `0x${string}` | undefined;
1510
- gas?: `0x${string}` | undefined;
1511
1819
  from?: `0x${string}` | undefined;
1820
+ gas?: `0x${string}` | undefined;
1512
1821
  nonce?: `0x${string}` | undefined;
1822
+ value?: `0x${string}` | undefined;
1513
1823
  to: `0x${string}` | null;
1514
1824
  gasPrice?: undefined | undefined;
1515
1825
  maxFeePerBlobGas?: `0x${string}` | undefined;
@@ -1525,10 +1835,10 @@ declare function getEvmChain(chain: string): {
1525
1835
  } | {
1526
1836
  type?: "0x3" | undefined;
1527
1837
  data?: `0x${string}` | undefined;
1528
- value?: `0x${string}` | undefined;
1529
- gas?: `0x${string}` | undefined;
1530
1838
  from?: `0x${string}` | undefined;
1839
+ gas?: `0x${string}` | undefined;
1531
1840
  nonce?: `0x${string}` | undefined;
1841
+ value?: `0x${string}` | undefined;
1532
1842
  to: `0x${string}` | null;
1533
1843
  gasPrice?: undefined | undefined;
1534
1844
  maxFeePerBlobGas?: `0x${string}` | undefined;
@@ -1542,17 +1852,17 @@ declare function getEvmChain(chain: string): {
1542
1852
  authorizationList?: undefined;
1543
1853
  eip712Meta?: undefined | undefined;
1544
1854
  } | {
1855
+ type?: "0x4" | undefined;
1545
1856
  gasPrice?: undefined | undefined;
1546
1857
  maxFeePerBlobGas?: undefined | undefined;
1547
1858
  maxFeePerGas?: `0x${string}` | undefined;
1548
1859
  maxPriorityFeePerGas?: `0x${string}` | undefined;
1549
- type?: "0x4" | undefined;
1550
- data?: `0x${string}` | undefined;
1551
- value?: `0x${string}` | undefined;
1552
- gas?: `0x${string}` | undefined;
1553
1860
  to?: `0x${string}` | null | undefined;
1861
+ data?: `0x${string}` | undefined;
1554
1862
  from?: `0x${string}` | undefined;
1863
+ gas?: `0x${string}` | undefined;
1555
1864
  nonce?: `0x${string}` | undefined;
1865
+ value?: `0x${string}` | undefined;
1556
1866
  accessList?: viem.AccessList | undefined;
1557
1867
  authorizationList?: viem.RpcAuthorizationList | undefined;
1558
1868
  blobs?: undefined;
@@ -1593,6 +1903,7 @@ declare function getEvmChain(chain: string): {
1593
1903
  serializers: {
1594
1904
  readonly transaction: typeof viem_zksync.serializeTransaction;
1595
1905
  };
1906
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
1596
1907
  readonly network: "zksync-era";
1597
1908
  } | {
1598
1909
  blockExplorers: {
@@ -1627,6 +1938,7 @@ declare function getEvmChain(chain: string): {
1627
1938
  sourceId?: number | undefined | undefined;
1628
1939
  testnet: false;
1629
1940
  custom?: Record<string, unknown> | undefined;
1941
+ extendSchema?: Record<string, unknown> | undefined;
1630
1942
  fees?: viem.ChainFees<undefined> | undefined;
1631
1943
  formatters?: undefined;
1632
1944
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -1637,6 +1949,7 @@ declare function getEvmChain(chain: string): {
1637
1949
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1638
1950
  }] | undefined;
1639
1951
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
1952
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
1640
1953
  } | {
1641
1954
  blockExplorers: {
1642
1955
  readonly default: {
@@ -1670,6 +1983,7 @@ declare function getEvmChain(chain: string): {
1670
1983
  sourceId?: number | undefined | undefined;
1671
1984
  testnet?: boolean | undefined | undefined;
1672
1985
  custom?: Record<string, unknown> | undefined;
1986
+ extendSchema?: Record<string, unknown> | undefined;
1673
1987
  fees?: viem.ChainFees<undefined> | undefined;
1674
1988
  formatters?: undefined;
1675
1989
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -1680,6 +1994,7 @@ declare function getEvmChain(chain: string): {
1680
1994
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1681
1995
  }] | undefined;
1682
1996
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
1997
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
1683
1998
  } | {
1684
1999
  blockExplorers: {
1685
2000
  readonly default: {
@@ -1752,6 +2067,7 @@ declare function getEvmChain(chain: string): {
1752
2067
  sourceId: 1;
1753
2068
  testnet?: boolean | undefined | undefined;
1754
2069
  custom?: Record<string, unknown> | undefined;
2070
+ extendSchema?: Record<string, unknown> | undefined;
1755
2071
  fees?: viem.ChainFees<undefined> | undefined;
1756
2072
  formatters: {
1757
2073
  readonly block: {
@@ -1817,16 +2133,16 @@ declare function getEvmChain(chain: string): {
1817
2133
  r: viem.Hex;
1818
2134
  s: viem.Hex;
1819
2135
  v: bigint;
1820
- value: bigint;
1821
- gas: bigint;
1822
2136
  to: viem.Address | null;
1823
2137
  from: viem.Address;
2138
+ gas: bigint;
1824
2139
  nonce: number;
2140
+ value: bigint;
1825
2141
  blockHash: `0x${string}` | null;
1826
2142
  blockNumber: bigint | null;
1827
- transactionIndex: number | null;
1828
2143
  hash: viem.Hash;
1829
2144
  input: viem.Hex;
2145
+ transactionIndex: number | null;
1830
2146
  typeHex: viem.Hex | null;
1831
2147
  accessList?: undefined | undefined;
1832
2148
  authorizationList?: undefined | undefined;
@@ -1994,6 +2310,7 @@ declare function getEvmChain(chain: string): {
1994
2310
  serializers: {
1995
2311
  readonly transaction: typeof viem_chains.serializeTransactionOpStack;
1996
2312
  };
2313
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
1997
2314
  } | {
1998
2315
  blockExplorers: {
1999
2316
  readonly default: {
@@ -2062,6 +2379,7 @@ declare function getEvmChain(chain: string): {
2062
2379
  sourceId: 1;
2063
2380
  testnet?: boolean | undefined | undefined;
2064
2381
  custom?: Record<string, unknown> | undefined;
2382
+ extendSchema?: Record<string, unknown> | undefined;
2065
2383
  fees?: viem.ChainFees<undefined> | undefined;
2066
2384
  formatters: {
2067
2385
  readonly block: {
@@ -2127,16 +2445,16 @@ declare function getEvmChain(chain: string): {
2127
2445
  r: viem.Hex;
2128
2446
  s: viem.Hex;
2129
2447
  v: bigint;
2130
- value: bigint;
2131
- gas: bigint;
2132
2448
  to: viem.Address | null;
2133
2449
  from: viem.Address;
2450
+ gas: bigint;
2134
2451
  nonce: number;
2452
+ value: bigint;
2135
2453
  blockHash: `0x${string}` | null;
2136
2454
  blockNumber: bigint | null;
2137
- transactionIndex: number | null;
2138
2455
  hash: viem.Hash;
2139
2456
  input: viem.Hex;
2457
+ transactionIndex: number | null;
2140
2458
  typeHex: viem.Hex | null;
2141
2459
  accessList?: undefined | undefined;
2142
2460
  authorizationList?: undefined | undefined;
@@ -2304,6 +2622,7 @@ declare function getEvmChain(chain: string): {
2304
2622
  serializers: {
2305
2623
  readonly transaction: typeof viem_chains.serializeTransactionOpStack;
2306
2624
  };
2625
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
2307
2626
  } | {
2308
2627
  blockExplorers: {
2309
2628
  readonly default: {
@@ -2336,6 +2655,7 @@ declare function getEvmChain(chain: string): {
2336
2655
  sourceId?: number | undefined | undefined;
2337
2656
  testnet?: boolean | undefined | undefined;
2338
2657
  custom?: Record<string, unknown> | undefined;
2658
+ extendSchema?: Record<string, unknown> | undefined;
2339
2659
  fees?: viem.ChainFees<undefined> | undefined;
2340
2660
  formatters?: undefined;
2341
2661
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -2346,6 +2666,7 @@ declare function getEvmChain(chain: string): {
2346
2666
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2347
2667
  }] | undefined;
2348
2668
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
2669
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
2349
2670
  } | {
2350
2671
  blockExplorers: {
2351
2672
  readonly default: {
@@ -2378,6 +2699,7 @@ declare function getEvmChain(chain: string): {
2378
2699
  sourceId?: number | undefined | undefined;
2379
2700
  testnet?: boolean | undefined | undefined;
2380
2701
  custom?: Record<string, unknown> | undefined;
2702
+ extendSchema?: Record<string, unknown> | undefined;
2381
2703
  fees?: viem.ChainFees<undefined> | undefined;
2382
2704
  formatters?: undefined;
2383
2705
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -2388,6 +2710,7 @@ declare function getEvmChain(chain: string): {
2388
2710
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2389
2711
  }] | undefined;
2390
2712
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
2713
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
2391
2714
  } | {
2392
2715
  blockExplorers: {
2393
2716
  readonly default: {
@@ -2419,6 +2742,7 @@ declare function getEvmChain(chain: string): {
2419
2742
  sourceId?: number | undefined | undefined;
2420
2743
  testnet: false;
2421
2744
  custom?: Record<string, unknown> | undefined;
2745
+ extendSchema?: Record<string, unknown> | undefined;
2422
2746
  fees?: viem.ChainFees<undefined> | undefined;
2423
2747
  formatters?: undefined;
2424
2748
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -2429,6 +2753,7 @@ declare function getEvmChain(chain: string): {
2429
2753
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2430
2754
  }] | undefined;
2431
2755
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
2756
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
2432
2757
  } | {
2433
2758
  blockExplorers: {
2434
2759
  readonly default: {
@@ -2470,6 +2795,7 @@ declare function getEvmChain(chain: string): {
2470
2795
  sourceId?: number | undefined | undefined;
2471
2796
  testnet: false;
2472
2797
  custom?: Record<string, unknown> | undefined;
2798
+ extendSchema?: Record<string, unknown> | undefined;
2473
2799
  fees: {
2474
2800
  readonly estimateFeesPerGas: ({ client, multiply, request, type, }: Parameters<viem.ChainEstimateFeesPerGasFn>[0]) => ReturnType<viem.ChainEstimateFeesPerGasFn>;
2475
2801
  readonly maxPriorityFeePerGas: ({ block, client, request }: viem.ChainFeesFnParameters<viem.ChainFormatters | undefined>) => Promise<bigint | null>;
@@ -2483,6 +2809,7 @@ declare function getEvmChain(chain: string): {
2483
2809
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2484
2810
  }] | undefined;
2485
2811
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
2812
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
2486
2813
  } | {
2487
2814
  blockExplorers: {
2488
2815
  readonly default: {
@@ -2514,6 +2841,7 @@ declare function getEvmChain(chain: string): {
2514
2841
  sourceId?: number | undefined | undefined;
2515
2842
  testnet: false;
2516
2843
  custom?: Record<string, unknown> | undefined;
2844
+ extendSchema?: Record<string, unknown> | undefined;
2517
2845
  fees?: viem.ChainFees<undefined> | undefined;
2518
2846
  formatters?: undefined;
2519
2847
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -2524,6 +2852,7 @@ declare function getEvmChain(chain: string): {
2524
2852
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2525
2853
  }] | undefined;
2526
2854
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
2855
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
2527
2856
  readonly network: "neonMainnet";
2528
2857
  } | {
2529
2858
  blockExplorers: {
@@ -2557,6 +2886,7 @@ declare function getEvmChain(chain: string): {
2557
2886
  sourceId?: number | undefined | undefined;
2558
2887
  testnet?: boolean | undefined | undefined;
2559
2888
  custom?: Record<string, unknown> | undefined;
2889
+ extendSchema?: Record<string, unknown> | undefined;
2560
2890
  fees?: viem.ChainFees<undefined> | undefined;
2561
2891
  formatters?: undefined;
2562
2892
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -2567,6 +2897,7 @@ declare function getEvmChain(chain: string): {
2567
2897
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2568
2898
  }] | undefined;
2569
2899
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
2900
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
2570
2901
  } | {
2571
2902
  blockExplorers: {
2572
2903
  readonly default: {
@@ -2598,6 +2929,7 @@ declare function getEvmChain(chain: string): {
2598
2929
  sourceId?: number | undefined | undefined;
2599
2930
  testnet: false;
2600
2931
  custom?: Record<string, unknown> | undefined;
2932
+ extendSchema?: Record<string, unknown> | undefined;
2601
2933
  fees?: viem.ChainFees<undefined> | undefined;
2602
2934
  formatters?: undefined;
2603
2935
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -2608,6 +2940,7 @@ declare function getEvmChain(chain: string): {
2608
2940
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2609
2941
  }] | undefined;
2610
2942
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
2943
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
2611
2944
  readonly network: "lightlink-phoenix";
2612
2945
  } | {
2613
2946
  blockExplorers: {
@@ -2642,6 +2975,7 @@ declare function getEvmChain(chain: string): {
2642
2975
  sourceId: 1;
2643
2976
  testnet?: boolean | undefined | undefined;
2644
2977
  custom?: Record<string, unknown> | undefined;
2978
+ extendSchema?: Record<string, unknown> | undefined;
2645
2979
  fees?: viem.ChainFees<undefined> | undefined;
2646
2980
  formatters?: undefined;
2647
2981
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -2652,6 +2986,7 @@ declare function getEvmChain(chain: string): {
2652
2986
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2653
2987
  }] | undefined;
2654
2988
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
2989
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
2655
2990
  } | {
2656
2991
  blockExplorers: {
2657
2992
  readonly default: {
@@ -2694,6 +3029,7 @@ declare function getEvmChain(chain: string): {
2694
3029
  custom: {
2695
3030
  readonly getEip712Domain: viem_zksync.EIP712DomainFn<viem_chains.ZkSyncTransactionSerializable, viem_chains.ZkSyncEIP712TransactionSignable>;
2696
3031
  };
3032
+ extendSchema?: Record<string, unknown> | undefined;
2697
3033
  fees?: viem.ChainFees<undefined> | undefined;
2698
3034
  formatters: {
2699
3035
  readonly block: {
@@ -2737,16 +3073,16 @@ declare function getEvmChain(chain: string): {
2737
3073
  r: viem.Hex;
2738
3074
  s: viem.Hex;
2739
3075
  v: bigint;
2740
- value: bigint;
2741
- gas: bigint;
2742
3076
  to: viem.Address | null;
2743
3077
  from: viem.Address;
3078
+ gas: bigint;
2744
3079
  nonce: number;
3080
+ value: bigint;
2745
3081
  blockHash: `0x${string}` | null;
2746
3082
  blockNumber: bigint | null;
2747
- transactionIndex: number | null;
2748
3083
  hash: viem.Hash;
2749
3084
  input: viem.Hex;
3085
+ transactionIndex: number | null;
2750
3086
  typeHex: viem.Hex | null;
2751
3087
  accessList?: undefined | undefined;
2752
3088
  authorizationList?: undefined | undefined;
@@ -2920,15 +3256,15 @@ declare function getEvmChain(chain: string): {
2920
3256
  readonly transactionReceipt: {
2921
3257
  exclude: [] | undefined;
2922
3258
  format: (args: viem_chains.ZkSyncRpcTransactionReceipt, action?: string | undefined) => {
2923
- contractAddress: viem.Address | null | undefined;
2924
3259
  type: viem_chains.ZkSyncTransactionType;
2925
- status: "success" | "reverted";
3260
+ contractAddress: viem.Address | null | undefined;
2926
3261
  to: viem.Address | null;
2927
3262
  from: viem.Address;
2928
3263
  blockHash: viem.Hash;
2929
3264
  blockNumber: bigint;
2930
- transactionHash: viem.Hash;
2931
3265
  transactionIndex: number;
3266
+ status: "success" | "reverted";
3267
+ transactionHash: viem.Hash;
2932
3268
  logsBloom: viem.Hex;
2933
3269
  blobGasUsed?: bigint | undefined;
2934
3270
  gasUsed: bigint;
@@ -3005,10 +3341,10 @@ declare function getEvmChain(chain: string): {
3005
3341
  } | {
3006
3342
  type?: "0x3" | undefined;
3007
3343
  data?: `0x${string}` | undefined;
3008
- value?: `0x${string}` | undefined;
3009
- gas?: `0x${string}` | undefined;
3010
3344
  from?: `0x${string}` | undefined;
3345
+ gas?: `0x${string}` | undefined;
3011
3346
  nonce?: `0x${string}` | undefined;
3347
+ value?: `0x${string}` | undefined;
3012
3348
  to: `0x${string}` | null;
3013
3349
  gasPrice?: undefined | undefined;
3014
3350
  maxFeePerBlobGas?: `0x${string}` | undefined;
@@ -3024,10 +3360,10 @@ declare function getEvmChain(chain: string): {
3024
3360
  } | {
3025
3361
  type?: "0x3" | undefined;
3026
3362
  data?: `0x${string}` | undefined;
3027
- value?: `0x${string}` | undefined;
3028
- gas?: `0x${string}` | undefined;
3029
3363
  from?: `0x${string}` | undefined;
3364
+ gas?: `0x${string}` | undefined;
3030
3365
  nonce?: `0x${string}` | undefined;
3366
+ value?: `0x${string}` | undefined;
3031
3367
  to: `0x${string}` | null;
3032
3368
  gasPrice?: undefined | undefined;
3033
3369
  maxFeePerBlobGas?: `0x${string}` | undefined;
@@ -3041,17 +3377,17 @@ declare function getEvmChain(chain: string): {
3041
3377
  authorizationList?: undefined;
3042
3378
  eip712Meta?: undefined | undefined;
3043
3379
  } | {
3380
+ type?: "0x4" | undefined;
3044
3381
  gasPrice?: undefined | undefined;
3045
3382
  maxFeePerBlobGas?: undefined | undefined;
3046
3383
  maxFeePerGas?: `0x${string}` | undefined;
3047
3384
  maxPriorityFeePerGas?: `0x${string}` | undefined;
3048
- type?: "0x4" | undefined;
3049
- data?: `0x${string}` | undefined;
3050
- value?: `0x${string}` | undefined;
3051
- gas?: `0x${string}` | undefined;
3052
3385
  to?: `0x${string}` | null | undefined;
3386
+ data?: `0x${string}` | undefined;
3053
3387
  from?: `0x${string}` | undefined;
3388
+ gas?: `0x${string}` | undefined;
3054
3389
  nonce?: `0x${string}` | undefined;
3390
+ value?: `0x${string}` | undefined;
3055
3391
  accessList?: viem.AccessList | undefined;
3056
3392
  authorizationList?: viem.RpcAuthorizationList | undefined;
3057
3393
  blobs?: undefined;
@@ -3092,6 +3428,7 @@ declare function getEvmChain(chain: string): {
3092
3428
  serializers: {
3093
3429
  readonly transaction: typeof viem_zksync.serializeTransaction;
3094
3430
  };
3431
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3095
3432
  } | {
3096
3433
  blockExplorers: {
3097
3434
  readonly default: {
@@ -3124,6 +3461,7 @@ declare function getEvmChain(chain: string): {
3124
3461
  sourceId?: number | undefined | undefined;
3125
3462
  testnet?: boolean | undefined | undefined;
3126
3463
  custom?: Record<string, unknown> | undefined;
3464
+ extendSchema?: Record<string, unknown> | undefined;
3127
3465
  fees?: viem.ChainFees<undefined> | undefined;
3128
3466
  formatters?: undefined;
3129
3467
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3134,6 +3472,7 @@ declare function getEvmChain(chain: string): {
3134
3472
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3135
3473
  }] | undefined;
3136
3474
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
3475
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3137
3476
  } | {
3138
3477
  blockExplorers: {
3139
3478
  readonly default: {
@@ -3165,6 +3504,7 @@ declare function getEvmChain(chain: string): {
3165
3504
  sourceId?: number | undefined | undefined;
3166
3505
  testnet?: boolean | undefined | undefined;
3167
3506
  custom?: Record<string, unknown> | undefined;
3507
+ extendSchema?: Record<string, unknown> | undefined;
3168
3508
  fees?: viem.ChainFees<undefined> | undefined;
3169
3509
  formatters?: undefined;
3170
3510
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3175,6 +3515,7 @@ declare function getEvmChain(chain: string): {
3175
3515
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3176
3516
  }] | undefined;
3177
3517
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
3518
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3178
3519
  } | {
3179
3520
  blockExplorers: {
3180
3521
  readonly default: {
@@ -3247,6 +3588,7 @@ declare function getEvmChain(chain: string): {
3247
3588
  sourceId: 1;
3248
3589
  testnet?: boolean | undefined | undefined;
3249
3590
  custom?: Record<string, unknown> | undefined;
3591
+ extendSchema?: Record<string, unknown> | undefined;
3250
3592
  fees?: viem.ChainFees<undefined> | undefined;
3251
3593
  formatters: {
3252
3594
  readonly block: {
@@ -3312,16 +3654,16 @@ declare function getEvmChain(chain: string): {
3312
3654
  r: viem.Hex;
3313
3655
  s: viem.Hex;
3314
3656
  v: bigint;
3315
- value: bigint;
3316
- gas: bigint;
3317
3657
  to: viem.Address | null;
3318
3658
  from: viem.Address;
3659
+ gas: bigint;
3319
3660
  nonce: number;
3661
+ value: bigint;
3320
3662
  blockHash: `0x${string}` | null;
3321
3663
  blockNumber: bigint | null;
3322
- transactionIndex: number | null;
3323
3664
  hash: viem.Hash;
3324
3665
  input: viem.Hex;
3666
+ transactionIndex: number | null;
3325
3667
  typeHex: viem.Hex | null;
3326
3668
  accessList?: undefined | undefined;
3327
3669
  authorizationList?: undefined | undefined;
@@ -3489,6 +3831,7 @@ declare function getEvmChain(chain: string): {
3489
3831
  serializers: {
3490
3832
  readonly transaction: typeof viem_chains.serializeTransactionOpStack;
3491
3833
  };
3834
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3492
3835
  } | {
3493
3836
  blockExplorers: {
3494
3837
  readonly default: {
@@ -3520,6 +3863,7 @@ declare function getEvmChain(chain: string): {
3520
3863
  sourceId?: number | undefined | undefined;
3521
3864
  testnet?: boolean | undefined | undefined;
3522
3865
  custom?: Record<string, unknown> | undefined;
3866
+ extendSchema?: Record<string, unknown> | undefined;
3523
3867
  fees?: viem.ChainFees<undefined> | undefined;
3524
3868
  formatters?: undefined;
3525
3869
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3530,6 +3874,7 @@ declare function getEvmChain(chain: string): {
3530
3874
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3531
3875
  }] | undefined;
3532
3876
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
3877
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3533
3878
  } | {
3534
3879
  blockExplorers: {
3535
3880
  readonly default: {
@@ -3569,6 +3914,7 @@ declare function getEvmChain(chain: string): {
3569
3914
  sourceId?: number | undefined | undefined;
3570
3915
  testnet: false;
3571
3916
  custom?: Record<string, unknown> | undefined;
3917
+ extendSchema?: Record<string, unknown> | undefined;
3572
3918
  fees?: viem.ChainFees<undefined> | undefined;
3573
3919
  formatters?: undefined;
3574
3920
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3579,6 +3925,7 @@ declare function getEvmChain(chain: string): {
3579
3925
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3580
3926
  }] | undefined;
3581
3927
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
3928
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3582
3929
  } | {
3583
3930
  blockExplorers: {
3584
3931
  readonly default: {
@@ -3610,6 +3957,7 @@ declare function getEvmChain(chain: string): {
3610
3957
  sourceId?: number | undefined | undefined;
3611
3958
  testnet?: boolean | undefined | undefined;
3612
3959
  custom?: Record<string, unknown> | undefined;
3960
+ extendSchema?: Record<string, unknown> | undefined;
3613
3961
  fees?: viem.ChainFees<undefined> | undefined;
3614
3962
  formatters?: undefined;
3615
3963
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3620,6 +3968,7 @@ declare function getEvmChain(chain: string): {
3620
3968
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3621
3969
  }] | undefined;
3622
3970
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
3971
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3623
3972
  readonly network: "rootstock";
3624
3973
  } | {
3625
3974
  blockExplorers: {
@@ -3655,6 +4004,7 @@ declare function getEvmChain(chain: string): {
3655
4004
  sourceId?: number | undefined | undefined;
3656
4005
  testnet: false;
3657
4006
  custom?: Record<string, unknown> | undefined;
4007
+ extendSchema?: Record<string, unknown> | undefined;
3658
4008
  fees?: viem.ChainFees<undefined> | undefined;
3659
4009
  formatters?: undefined;
3660
4010
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3665,6 +4015,7 @@ declare function getEvmChain(chain: string): {
3665
4015
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3666
4016
  }] | undefined;
3667
4017
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4018
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3668
4019
  } | {
3669
4020
  blockExplorers: {
3670
4021
  readonly default: {
@@ -3697,6 +4048,7 @@ declare function getEvmChain(chain: string): {
3697
4048
  sourceId?: number | undefined | undefined;
3698
4049
  testnet?: boolean | undefined | undefined;
3699
4050
  custom?: Record<string, unknown> | undefined;
4051
+ extendSchema?: Record<string, unknown> | undefined;
3700
4052
  fees?: viem.ChainFees<undefined> | undefined;
3701
4053
  formatters?: undefined;
3702
4054
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3707,6 +4059,7 @@ declare function getEvmChain(chain: string): {
3707
4059
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3708
4060
  }] | undefined;
3709
4061
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4062
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3710
4063
  } | {
3711
4064
  blockExplorers: {
3712
4065
  readonly default: {
@@ -3738,6 +4091,7 @@ declare function getEvmChain(chain: string): {
3738
4091
  sourceId?: number | undefined | undefined;
3739
4092
  testnet: false;
3740
4093
  custom?: Record<string, unknown> | undefined;
4094
+ extendSchema?: Record<string, unknown> | undefined;
3741
4095
  fees?: viem.ChainFees<undefined> | undefined;
3742
4096
  formatters?: undefined;
3743
4097
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3748,6 +4102,7 @@ declare function getEvmChain(chain: string): {
3748
4102
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3749
4103
  }] | undefined;
3750
4104
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4105
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3751
4106
  } | {
3752
4107
  blockExplorers: {
3753
4108
  readonly default: {
@@ -3781,6 +4136,7 @@ declare function getEvmChain(chain: string): {
3781
4136
  sourceId: 42161;
3782
4137
  testnet?: boolean | undefined | undefined;
3783
4138
  custom?: Record<string, unknown> | undefined;
4139
+ extendSchema?: Record<string, unknown> | undefined;
3784
4140
  fees?: viem.ChainFees<undefined> | undefined;
3785
4141
  formatters?: undefined;
3786
4142
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3791,6 +4147,7 @@ declare function getEvmChain(chain: string): {
3791
4147
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3792
4148
  }] | undefined;
3793
4149
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4150
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3794
4151
  } | {
3795
4152
  blockExplorers: {
3796
4153
  readonly default: {
@@ -3823,6 +4180,7 @@ declare function getEvmChain(chain: string): {
3823
4180
  sourceId?: number | undefined | undefined;
3824
4181
  testnet?: boolean | undefined | undefined;
3825
4182
  custom?: Record<string, unknown> | undefined;
4183
+ extendSchema?: Record<string, unknown> | undefined;
3826
4184
  fees?: viem.ChainFees<undefined> | undefined;
3827
4185
  formatters?: undefined;
3828
4186
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3833,6 +4191,7 @@ declare function getEvmChain(chain: string): {
3833
4191
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3834
4192
  }] | undefined;
3835
4193
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4194
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3836
4195
  } | {
3837
4196
  blockExplorers: {
3838
4197
  readonly default: {
@@ -3864,6 +4223,7 @@ declare function getEvmChain(chain: string): {
3864
4223
  sourceId?: number | undefined | undefined;
3865
4224
  testnet?: boolean | undefined | undefined;
3866
4225
  custom?: Record<string, unknown> | undefined;
4226
+ extendSchema?: Record<string, unknown> | undefined;
3867
4227
  fees?: viem.ChainFees<undefined> | undefined;
3868
4228
  formatters?: undefined;
3869
4229
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3874,6 +4234,7 @@ declare function getEvmChain(chain: string): {
3874
4234
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3875
4235
  }] | undefined;
3876
4236
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4237
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3877
4238
  } | {
3878
4239
  blockExplorers: {
3879
4240
  readonly default: {
@@ -3906,6 +4267,7 @@ declare function getEvmChain(chain: string): {
3906
4267
  sourceId?: number | undefined | undefined;
3907
4268
  testnet?: boolean | undefined | undefined;
3908
4269
  custom?: Record<string, unknown> | undefined;
4270
+ extendSchema?: Record<string, unknown> | undefined;
3909
4271
  fees?: viem.ChainFees<undefined> | undefined;
3910
4272
  formatters?: undefined;
3911
4273
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3916,6 +4278,7 @@ declare function getEvmChain(chain: string): {
3916
4278
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3917
4279
  }] | undefined;
3918
4280
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4281
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3919
4282
  } | {
3920
4283
  blockExplorers: {
3921
4284
  readonly default: {
@@ -3948,6 +4311,7 @@ declare function getEvmChain(chain: string): {
3948
4311
  sourceId?: number | undefined | undefined;
3949
4312
  testnet?: boolean | undefined | undefined;
3950
4313
  custom?: Record<string, unknown> | undefined;
4314
+ extendSchema?: Record<string, unknown> | undefined;
3951
4315
  fees?: viem.ChainFees<undefined> | undefined;
3952
4316
  formatters?: undefined;
3953
4317
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -3958,6 +4322,7 @@ declare function getEvmChain(chain: string): {
3958
4322
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3959
4323
  }] | undefined;
3960
4324
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4325
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
3961
4326
  } | {
3962
4327
  blockExplorers: {
3963
4328
  readonly default: {
@@ -3990,6 +4355,7 @@ declare function getEvmChain(chain: string): {
3990
4355
  sourceId?: number | undefined | undefined;
3991
4356
  testnet: false;
3992
4357
  custom?: Record<string, unknown> | undefined;
4358
+ extendSchema?: Record<string, unknown> | undefined;
3993
4359
  fees?: viem.ChainFees<undefined> | undefined;
3994
4360
  formatters?: undefined;
3995
4361
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -4000,6 +4366,7 @@ declare function getEvmChain(chain: string): {
4000
4366
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4001
4367
  }] | undefined;
4002
4368
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4369
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
4003
4370
  readonly network: "kava-mainnet";
4004
4371
  } | {
4005
4372
  blockExplorers: {
@@ -4034,6 +4401,7 @@ declare function getEvmChain(chain: string): {
4034
4401
  sourceId?: number | undefined | undefined;
4035
4402
  testnet?: boolean | undefined | undefined;
4036
4403
  custom?: Record<string, unknown> | undefined;
4404
+ extendSchema?: Record<string, unknown> | undefined;
4037
4405
  fees?: viem.ChainFees<undefined> | undefined;
4038
4406
  formatters?: undefined;
4039
4407
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -4044,6 +4412,7 @@ declare function getEvmChain(chain: string): {
4044
4412
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4045
4413
  }] | undefined;
4046
4414
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4415
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
4047
4416
  readonly network: "iotaevm";
4048
4417
  } | {
4049
4418
  blockExplorers: {
@@ -4110,6 +4479,7 @@ declare function getEvmChain(chain: string): {
4110
4479
  sourceId: 1;
4111
4480
  testnet?: boolean | undefined | undefined;
4112
4481
  custom?: Record<string, unknown> | undefined;
4482
+ extendSchema?: Record<string, unknown> | undefined;
4113
4483
  fees?: viem.ChainFees<undefined> | undefined;
4114
4484
  formatters: {
4115
4485
  readonly block: {
@@ -4175,16 +4545,16 @@ declare function getEvmChain(chain: string): {
4175
4545
  r: viem.Hex;
4176
4546
  s: viem.Hex;
4177
4547
  v: bigint;
4178
- value: bigint;
4179
- gas: bigint;
4180
4548
  to: viem.Address | null;
4181
4549
  from: viem.Address;
4550
+ gas: bigint;
4182
4551
  nonce: number;
4552
+ value: bigint;
4183
4553
  blockHash: `0x${string}` | null;
4184
4554
  blockNumber: bigint | null;
4185
- transactionIndex: number | null;
4186
4555
  hash: viem.Hash;
4187
4556
  input: viem.Hex;
4557
+ transactionIndex: number | null;
4188
4558
  typeHex: viem.Hex | null;
4189
4559
  accessList?: undefined | undefined;
4190
4560
  authorizationList?: undefined | undefined;
@@ -4352,6 +4722,7 @@ declare function getEvmChain(chain: string): {
4352
4722
  serializers: {
4353
4723
  readonly transaction: typeof viem_chains.serializeTransactionOpStack;
4354
4724
  };
4725
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
4355
4726
  } | {
4356
4727
  blockExplorers: {
4357
4728
  readonly default: {
@@ -4383,6 +4754,7 @@ declare function getEvmChain(chain: string): {
4383
4754
  sourceId?: number | undefined | undefined;
4384
4755
  testnet: false;
4385
4756
  custom?: Record<string, unknown> | undefined;
4757
+ extendSchema?: Record<string, unknown> | undefined;
4386
4758
  fees?: viem.ChainFees<undefined> | undefined;
4387
4759
  formatters?: undefined;
4388
4760
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -4393,6 +4765,7 @@ declare function getEvmChain(chain: string): {
4393
4765
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4394
4766
  }] | undefined;
4395
4767
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
4768
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
4396
4769
  } | {
4397
4770
  blockExplorers: {
4398
4771
  readonly default: {
@@ -4457,6 +4830,7 @@ declare function getEvmChain(chain: string): {
4457
4830
  sourceId: 1;
4458
4831
  testnet?: boolean | undefined | undefined;
4459
4832
  custom?: Record<string, unknown> | undefined;
4833
+ extendSchema?: Record<string, unknown> | undefined;
4460
4834
  fees?: viem.ChainFees<undefined> | undefined;
4461
4835
  formatters: {
4462
4836
  readonly block: {
@@ -4522,16 +4896,16 @@ declare function getEvmChain(chain: string): {
4522
4896
  r: viem.Hex;
4523
4897
  s: viem.Hex;
4524
4898
  v: bigint;
4525
- value: bigint;
4526
- gas: bigint;
4527
4899
  to: viem.Address | null;
4528
4900
  from: viem.Address;
4901
+ gas: bigint;
4529
4902
  nonce: number;
4903
+ value: bigint;
4530
4904
  blockHash: `0x${string}` | null;
4531
4905
  blockNumber: bigint | null;
4532
- transactionIndex: number | null;
4533
4906
  hash: viem.Hash;
4534
4907
  input: viem.Hex;
4908
+ transactionIndex: number | null;
4535
4909
  typeHex: viem.Hex | null;
4536
4910
  accessList?: undefined | undefined;
4537
4911
  authorizationList?: undefined | undefined;
@@ -4699,6 +5073,7 @@ declare function getEvmChain(chain: string): {
4699
5073
  serializers: {
4700
5074
  readonly transaction: typeof viem_chains.serializeTransactionOpStack;
4701
5075
  };
5076
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
4702
5077
  } | {
4703
5078
  blockExplorers: {
4704
5079
  readonly default: {
@@ -4731,6 +5106,7 @@ declare function getEvmChain(chain: string): {
4731
5106
  sourceId: 1;
4732
5107
  testnet?: boolean | undefined | undefined;
4733
5108
  custom?: Record<string, unknown> | undefined;
5109
+ extendSchema?: Record<string, unknown> | undefined;
4734
5110
  fees?: viem.ChainFees<undefined> | undefined;
4735
5111
  formatters?: undefined;
4736
5112
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -4741,6 +5117,7 @@ declare function getEvmChain(chain: string): {
4741
5117
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4742
5118
  }] | undefined;
4743
5119
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
5120
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
4744
5121
  } | {
4745
5122
  blockExplorers: {
4746
5123
  readonly default: {
@@ -4803,6 +5180,7 @@ declare function getEvmChain(chain: string): {
4803
5180
  sourceId: 1;
4804
5181
  testnet?: boolean | undefined | undefined;
4805
5182
  custom?: Record<string, unknown> | undefined;
5183
+ extendSchema?: Record<string, unknown> | undefined;
4806
5184
  fees?: viem.ChainFees<undefined> | undefined;
4807
5185
  formatters: {
4808
5186
  readonly block: {
@@ -4868,16 +5246,16 @@ declare function getEvmChain(chain: string): {
4868
5246
  r: viem.Hex;
4869
5247
  s: viem.Hex;
4870
5248
  v: bigint;
4871
- value: bigint;
4872
- gas: bigint;
4873
5249
  to: viem.Address | null;
4874
5250
  from: viem.Address;
5251
+ gas: bigint;
4875
5252
  nonce: number;
5253
+ value: bigint;
4876
5254
  blockHash: `0x${string}` | null;
4877
5255
  blockNumber: bigint | null;
4878
- transactionIndex: number | null;
4879
5256
  hash: viem.Hash;
4880
5257
  input: viem.Hex;
5258
+ transactionIndex: number | null;
4881
5259
  typeHex: viem.Hex | null;
4882
5260
  accessList?: undefined | undefined;
4883
5261
  authorizationList?: undefined | undefined;
@@ -5045,6 +5423,7 @@ declare function getEvmChain(chain: string): {
5045
5423
  serializers: {
5046
5424
  readonly transaction: typeof viem_chains.serializeTransactionOpStack;
5047
5425
  };
5426
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5048
5427
  } | {
5049
5428
  blockExplorers: {
5050
5429
  readonly default: {
@@ -5076,6 +5455,7 @@ declare function getEvmChain(chain: string): {
5076
5455
  sourceId?: number | undefined | undefined;
5077
5456
  testnet?: boolean | undefined | undefined;
5078
5457
  custom?: Record<string, unknown> | undefined;
5458
+ extendSchema?: Record<string, unknown> | undefined;
5079
5459
  fees?: viem.ChainFees<undefined> | undefined;
5080
5460
  formatters?: undefined;
5081
5461
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -5086,6 +5466,7 @@ declare function getEvmChain(chain: string): {
5086
5466
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5087
5467
  }] | undefined;
5088
5468
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
5469
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5089
5470
  } | {
5090
5471
  blockExplorers: {
5091
5472
  readonly default: {
@@ -5118,6 +5499,7 @@ declare function getEvmChain(chain: string): {
5118
5499
  sourceId?: number | undefined | undefined;
5119
5500
  testnet?: boolean | undefined | undefined;
5120
5501
  custom?: Record<string, unknown> | undefined;
5502
+ extendSchema?: Record<string, unknown> | undefined;
5121
5503
  fees?: viem.ChainFees<undefined> | undefined;
5122
5504
  formatters?: undefined;
5123
5505
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -5128,6 +5510,7 @@ declare function getEvmChain(chain: string): {
5128
5510
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5129
5511
  }] | undefined;
5130
5512
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
5513
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5131
5514
  readonly network: "manta";
5132
5515
  } | {
5133
5516
  blockExplorers: {
@@ -5174,6 +5557,7 @@ declare function getEvmChain(chain: string): {
5174
5557
  sourceId?: number | undefined | undefined;
5175
5558
  testnet: false;
5176
5559
  custom?: Record<string, unknown> | undefined;
5560
+ extendSchema?: Record<string, unknown> | undefined;
5177
5561
  fees?: viem.ChainFees<undefined> | undefined;
5178
5562
  formatters: {
5179
5563
  readonly block: {
@@ -5239,16 +5623,16 @@ declare function getEvmChain(chain: string): {
5239
5623
  r: viem.Hex;
5240
5624
  s: viem.Hex;
5241
5625
  v: bigint;
5242
- value: bigint;
5243
- gas: bigint;
5244
5626
  to: viem.Address | null;
5245
5627
  from: viem.Address;
5628
+ gas: bigint;
5246
5629
  nonce: number;
5630
+ value: bigint;
5247
5631
  blockHash: `0x${string}` | null;
5248
5632
  blockNumber: bigint | null;
5249
- transactionIndex: number | null;
5250
5633
  hash: viem.Hash;
5251
5634
  input: viem.Hex;
5635
+ transactionIndex: number | null;
5252
5636
  typeHex: viem.Hex | null;
5253
5637
  accessList?: undefined | undefined;
5254
5638
  authorizationList?: undefined | undefined;
@@ -5416,6 +5800,7 @@ declare function getEvmChain(chain: string): {
5416
5800
  serializers: {
5417
5801
  readonly transaction: typeof viem_chains.serializeTransactionOpStack;
5418
5802
  };
5803
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5419
5804
  } | {
5420
5805
  blockExplorers: {
5421
5806
  readonly default: {
@@ -5447,6 +5832,7 @@ declare function getEvmChain(chain: string): {
5447
5832
  sourceId?: number | undefined | undefined;
5448
5833
  testnet: false;
5449
5834
  custom?: Record<string, unknown> | undefined;
5835
+ extendSchema?: Record<string, unknown> | undefined;
5450
5836
  fees?: viem.ChainFees<undefined> | undefined;
5451
5837
  formatters?: undefined;
5452
5838
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -5457,6 +5843,7 @@ declare function getEvmChain(chain: string): {
5457
5843
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5458
5844
  }] | undefined;
5459
5845
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
5846
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5460
5847
  } | {
5461
5848
  blockExplorers: {
5462
5849
  readonly default: {
@@ -5489,6 +5876,7 @@ declare function getEvmChain(chain: string): {
5489
5876
  sourceId?: number | undefined | undefined;
5490
5877
  testnet?: boolean | undefined | undefined;
5491
5878
  custom?: Record<string, unknown> | undefined;
5879
+ extendSchema?: Record<string, unknown> | undefined;
5492
5880
  fees?: viem.ChainFees<undefined> | undefined;
5493
5881
  formatters?: undefined;
5494
5882
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -5499,6 +5887,7 @@ declare function getEvmChain(chain: string): {
5499
5887
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5500
5888
  }] | undefined;
5501
5889
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
5890
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5502
5891
  } | {
5503
5892
  blockExplorers: {
5504
5893
  readonly default: {
@@ -5531,6 +5920,7 @@ declare function getEvmChain(chain: string): {
5531
5920
  sourceId?: number | undefined | undefined;
5532
5921
  testnet?: boolean | undefined | undefined;
5533
5922
  custom?: Record<string, unknown> | undefined;
5923
+ extendSchema?: Record<string, unknown> | undefined;
5534
5924
  fees?: viem.ChainFees<undefined> | undefined;
5535
5925
  formatters?: undefined;
5536
5926
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -5541,6 +5931,7 @@ declare function getEvmChain(chain: string): {
5541
5931
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5542
5932
  }] | undefined;
5543
5933
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
5934
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5544
5935
  } | {
5545
5936
  blockExplorers: {
5546
5937
  readonly default: {
@@ -5572,6 +5963,7 @@ declare function getEvmChain(chain: string): {
5572
5963
  sourceId?: number | undefined | undefined;
5573
5964
  testnet?: boolean | undefined | undefined;
5574
5965
  custom?: Record<string, unknown> | undefined;
5966
+ extendSchema?: Record<string, unknown> | undefined;
5575
5967
  fees?: viem.ChainFees<undefined> | undefined;
5576
5968
  formatters?: undefined;
5577
5969
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -5582,6 +5974,7 @@ declare function getEvmChain(chain: string): {
5582
5974
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5583
5975
  }] | undefined;
5584
5976
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
5977
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5585
5978
  } | {
5586
5979
  blockExplorers: {
5587
5980
  readonly default: {
@@ -5614,6 +6007,7 @@ declare function getEvmChain(chain: string): {
5614
6007
  sourceId?: number | undefined | undefined;
5615
6008
  testnet?: boolean | undefined | undefined;
5616
6009
  custom?: Record<string, unknown> | undefined;
6010
+ extendSchema?: Record<string, unknown> | undefined;
5617
6011
  fees?: viem.ChainFees<undefined> | undefined;
5618
6012
  formatters?: undefined;
5619
6013
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -5624,6 +6018,7 @@ declare function getEvmChain(chain: string): {
5624
6018
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5625
6019
  }] | undefined;
5626
6020
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
6021
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5627
6022
  } | {
5628
6023
  blockExplorers: {
5629
6024
  readonly default: {
@@ -5655,6 +6050,7 @@ declare function getEvmChain(chain: string): {
5655
6050
  sourceId?: number | undefined | undefined;
5656
6051
  testnet?: boolean | undefined | undefined;
5657
6052
  custom?: Record<string, unknown> | undefined;
6053
+ extendSchema?: Record<string, unknown> | undefined;
5658
6054
  fees?: viem.ChainFees<undefined> | undefined;
5659
6055
  formatters?: undefined;
5660
6056
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -5665,6 +6061,7 @@ declare function getEvmChain(chain: string): {
5665
6061
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5666
6062
  }] | undefined;
5667
6063
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
6064
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5668
6065
  } | {
5669
6066
  blockExplorers: {
5670
6067
  readonly default: {
@@ -5697,6 +6094,7 @@ declare function getEvmChain(chain: string): {
5697
6094
  sourceId?: number | undefined | undefined;
5698
6095
  testnet?: boolean | undefined | undefined;
5699
6096
  custom?: Record<string, unknown> | undefined;
6097
+ extendSchema?: Record<string, unknown> | undefined;
5700
6098
  fees?: viem.ChainFees<undefined> | undefined;
5701
6099
  formatters?: undefined;
5702
6100
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -5707,6 +6105,7 @@ declare function getEvmChain(chain: string): {
5707
6105
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5708
6106
  }] | undefined;
5709
6107
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
6108
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5710
6109
  } | {
5711
6110
  blockExplorers: {
5712
6111
  readonly default: {
@@ -5739,6 +6138,7 @@ declare function getEvmChain(chain: string): {
5739
6138
  sourceId?: number | undefined | undefined;
5740
6139
  testnet?: boolean | undefined | undefined;
5741
6140
  custom?: Record<string, unknown> | undefined;
6141
+ extendSchema?: Record<string, unknown> | undefined;
5742
6142
  fees?: viem.ChainFees<undefined> | undefined;
5743
6143
  formatters?: undefined;
5744
6144
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -5749,6 +6149,7 @@ declare function getEvmChain(chain: string): {
5749
6149
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5750
6150
  }] | undefined;
5751
6151
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
6152
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
5752
6153
  } | {
5753
6154
  blockExplorers: {
5754
6155
  readonly default: {
@@ -5781,6 +6182,7 @@ declare function getEvmChain(chain: string): {
5781
6182
  sourceId?: number | undefined | undefined;
5782
6183
  testnet: false;
5783
6184
  custom?: Record<string, unknown> | undefined;
6185
+ extendSchema?: Record<string, unknown> | undefined;
5784
6186
  fees: viem.ChainFees<{
5785
6187
  readonly block: {
5786
6188
  exclude: [] | undefined;
@@ -5821,16 +6223,16 @@ declare function getEvmChain(chain: string): {
5821
6223
  r: viem.Hex;
5822
6224
  s: viem.Hex;
5823
6225
  v: bigint;
5824
- value: bigint;
5825
- gas: bigint;
5826
6226
  to: viem.Address | null;
5827
6227
  from: viem.Address;
6228
+ gas: bigint;
5828
6229
  nonce: number;
6230
+ value: bigint;
5829
6231
  blockHash: `0x${string}` | null;
5830
6232
  blockNumber: bigint | null;
5831
- transactionIndex: number | null;
5832
6233
  hash: viem.Hash;
5833
6234
  input: viem.Hex;
6235
+ transactionIndex: number | null;
5834
6236
  typeHex: viem.Hex | null;
5835
6237
  accessList?: undefined | undefined;
5836
6238
  authorizationList?: undefined | undefined;
@@ -6130,10 +6532,10 @@ declare function getEvmChain(chain: string): {
6130
6532
  } | {
6131
6533
  type?: "0x3" | undefined;
6132
6534
  data?: `0x${string}` | undefined;
6133
- value?: `0x${string}` | undefined;
6134
- gas?: `0x${string}` | undefined;
6135
6535
  from?: `0x${string}` | undefined;
6536
+ gas?: `0x${string}` | undefined;
6136
6537
  nonce?: `0x${string}` | undefined;
6538
+ value?: `0x${string}` | undefined;
6137
6539
  to: `0x${string}` | null;
6138
6540
  gasPrice?: undefined | undefined;
6139
6541
  maxFeePerBlobGas?: `0x${string}` | undefined;
@@ -6149,10 +6551,10 @@ declare function getEvmChain(chain: string): {
6149
6551
  } | {
6150
6552
  type?: "0x3" | undefined;
6151
6553
  data?: `0x${string}` | undefined;
6152
- value?: `0x${string}` | undefined;
6153
- gas?: `0x${string}` | undefined;
6154
6554
  from?: `0x${string}` | undefined;
6555
+ gas?: `0x${string}` | undefined;
6155
6556
  nonce?: `0x${string}` | undefined;
6557
+ value?: `0x${string}` | undefined;
6156
6558
  to: `0x${string}` | null;
6157
6559
  gasPrice?: undefined | undefined;
6158
6560
  maxFeePerBlobGas?: `0x${string}` | undefined;
@@ -6166,17 +6568,17 @@ declare function getEvmChain(chain: string): {
6166
6568
  authorizationList?: undefined;
6167
6569
  feeCurrency?: `0x${string}` | undefined;
6168
6570
  } | {
6571
+ type?: "0x4" | undefined;
6169
6572
  gasPrice?: undefined | undefined;
6170
6573
  maxFeePerBlobGas?: undefined | undefined;
6171
6574
  maxFeePerGas?: `0x${string}` | undefined;
6172
6575
  maxPriorityFeePerGas?: `0x${string}` | undefined;
6173
- type?: "0x4" | undefined;
6174
- data?: `0x${string}` | undefined;
6175
- value?: `0x${string}` | undefined;
6176
- gas?: `0x${string}` | undefined;
6177
6576
  to?: `0x${string}` | null | undefined;
6577
+ data?: `0x${string}` | undefined;
6178
6578
  from?: `0x${string}` | undefined;
6579
+ gas?: `0x${string}` | undefined;
6179
6580
  nonce?: `0x${string}` | undefined;
6581
+ value?: `0x${string}` | undefined;
6180
6582
  accessList?: viem.AccessList | undefined;
6181
6583
  authorizationList?: viem.RpcAuthorizationList | undefined;
6182
6584
  blobs?: undefined;
@@ -6247,16 +6649,16 @@ declare function getEvmChain(chain: string): {
6247
6649
  r: viem.Hex;
6248
6650
  s: viem.Hex;
6249
6651
  v: bigint;
6250
- value: bigint;
6251
- gas: bigint;
6252
6652
  to: viem.Address | null;
6253
6653
  from: viem.Address;
6654
+ gas: bigint;
6254
6655
  nonce: number;
6656
+ value: bigint;
6255
6657
  blockHash: `0x${string}` | null;
6256
6658
  blockNumber: bigint | null;
6257
- transactionIndex: number | null;
6258
6659
  hash: viem.Hash;
6259
6660
  input: viem.Hex;
6661
+ transactionIndex: number | null;
6260
6662
  typeHex: viem.Hex | null;
6261
6663
  accessList?: undefined | undefined;
6262
6664
  authorizationList?: undefined | undefined;
@@ -6556,10 +6958,10 @@ declare function getEvmChain(chain: string): {
6556
6958
  } | {
6557
6959
  type?: "0x3" | undefined;
6558
6960
  data?: `0x${string}` | undefined;
6559
- value?: `0x${string}` | undefined;
6560
- gas?: `0x${string}` | undefined;
6561
6961
  from?: `0x${string}` | undefined;
6962
+ gas?: `0x${string}` | undefined;
6562
6963
  nonce?: `0x${string}` | undefined;
6964
+ value?: `0x${string}` | undefined;
6563
6965
  to: `0x${string}` | null;
6564
6966
  gasPrice?: undefined | undefined;
6565
6967
  maxFeePerBlobGas?: `0x${string}` | undefined;
@@ -6575,10 +6977,10 @@ declare function getEvmChain(chain: string): {
6575
6977
  } | {
6576
6978
  type?: "0x3" | undefined;
6577
6979
  data?: `0x${string}` | undefined;
6578
- value?: `0x${string}` | undefined;
6579
- gas?: `0x${string}` | undefined;
6580
6980
  from?: `0x${string}` | undefined;
6981
+ gas?: `0x${string}` | undefined;
6581
6982
  nonce?: `0x${string}` | undefined;
6983
+ value?: `0x${string}` | undefined;
6582
6984
  to: `0x${string}` | null;
6583
6985
  gasPrice?: undefined | undefined;
6584
6986
  maxFeePerBlobGas?: `0x${string}` | undefined;
@@ -6592,17 +6994,17 @@ declare function getEvmChain(chain: string): {
6592
6994
  authorizationList?: undefined;
6593
6995
  feeCurrency?: `0x${string}` | undefined;
6594
6996
  } | {
6997
+ type?: "0x4" | undefined;
6595
6998
  gasPrice?: undefined | undefined;
6596
6999
  maxFeePerBlobGas?: undefined | undefined;
6597
7000
  maxFeePerGas?: `0x${string}` | undefined;
6598
7001
  maxPriorityFeePerGas?: `0x${string}` | undefined;
6599
- type?: "0x4" | undefined;
6600
- data?: `0x${string}` | undefined;
6601
- value?: `0x${string}` | undefined;
6602
- gas?: `0x${string}` | undefined;
6603
7002
  to?: `0x${string}` | null | undefined;
7003
+ data?: `0x${string}` | undefined;
6604
7004
  from?: `0x${string}` | undefined;
7005
+ gas?: `0x${string}` | undefined;
6605
7006
  nonce?: `0x${string}` | undefined;
7007
+ value?: `0x${string}` | undefined;
6606
7008
  accessList?: viem.AccessList | undefined;
6607
7009
  authorizationList?: viem.RpcAuthorizationList | undefined;
6608
7010
  blobs?: undefined;
@@ -6643,6 +7045,7 @@ declare function getEvmChain(chain: string): {
6643
7045
  serializers: {
6644
7046
  readonly transaction: typeof viem_chains.serializeTransactionCelo;
6645
7047
  };
7048
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
6646
7049
  } | {
6647
7050
  blockExplorers: {
6648
7051
  readonly default: {
@@ -6674,6 +7077,7 @@ declare function getEvmChain(chain: string): {
6674
7077
  sourceId?: number | undefined | undefined;
6675
7078
  testnet?: boolean | undefined | undefined;
6676
7079
  custom?: Record<string, unknown> | undefined;
7080
+ extendSchema?: Record<string, unknown> | undefined;
6677
7081
  fees?: viem.ChainFees<undefined> | undefined;
6678
7082
  formatters?: undefined;
6679
7083
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -6684,50 +7088,7 @@ declare function getEvmChain(chain: string): {
6684
7088
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
6685
7089
  }] | undefined;
6686
7090
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
6687
- } | {
6688
- blockExplorers: {
6689
- readonly default: {
6690
- readonly name: "Taraxa Explorer";
6691
- readonly url: "https://explorer.mainnet.taraxa.io";
6692
- };
6693
- };
6694
- blockTime?: number | undefined | undefined;
6695
- contracts?: {
6696
- [x: string]: viem.ChainContract | {
6697
- [sourceId: number]: viem.ChainContract | undefined;
6698
- } | undefined;
6699
- ensRegistry?: viem.ChainContract | undefined;
6700
- ensUniversalResolver?: viem.ChainContract | undefined;
6701
- multicall3?: viem.ChainContract | undefined;
6702
- erc6492Verifier?: viem.ChainContract | undefined;
6703
- } | undefined;
6704
- ensTlds?: readonly string[] | undefined;
6705
- id: 841;
6706
- name: "Taraxa Mainnet";
6707
- nativeCurrency: {
6708
- readonly name: "Tara";
6709
- readonly symbol: "TARA";
6710
- readonly decimals: 18;
6711
- };
6712
- experimental_preconfirmationTime?: number | undefined | undefined;
6713
- rpcUrls: {
6714
- readonly default: {
6715
- readonly http: readonly ["https://rpc.mainnet.taraxa.io"];
6716
- };
6717
- };
6718
- sourceId?: number | undefined | undefined;
6719
- testnet?: boolean | undefined | undefined;
6720
- custom?: Record<string, unknown> | undefined;
6721
- fees?: viem.ChainFees<undefined> | undefined;
6722
- formatters?: undefined;
6723
- prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
6724
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
6725
- }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
6726
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
6727
- }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
6728
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
6729
- }] | undefined;
6730
- serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7091
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
6731
7092
  } | {
6732
7093
  blockExplorers: {
6733
7094
  readonly default: {
@@ -6760,6 +7121,7 @@ declare function getEvmChain(chain: string): {
6760
7121
  sourceId?: number | undefined | undefined;
6761
7122
  testnet: false;
6762
7123
  custom?: Record<string, unknown> | undefined;
7124
+ extendSchema?: Record<string, unknown> | undefined;
6763
7125
  fees?: viem.ChainFees<undefined> | undefined;
6764
7126
  formatters?: undefined;
6765
7127
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -6770,6 +7132,7 @@ declare function getEvmChain(chain: string): {
6770
7132
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
6771
7133
  }] | undefined;
6772
7134
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7135
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
6773
7136
  } | {
6774
7137
  blockExplorers: {
6775
7138
  readonly default: {
@@ -6802,6 +7165,7 @@ declare function getEvmChain(chain: string): {
6802
7165
  sourceId?: number | undefined | undefined;
6803
7166
  testnet?: boolean | undefined | undefined;
6804
7167
  custom?: Record<string, unknown> | undefined;
7168
+ extendSchema?: Record<string, unknown> | undefined;
6805
7169
  fees?: viem.ChainFees<undefined> | undefined;
6806
7170
  formatters?: undefined;
6807
7171
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -6812,6 +7176,7 @@ declare function getEvmChain(chain: string): {
6812
7176
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
6813
7177
  }] | undefined;
6814
7178
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7179
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
6815
7180
  } | {
6816
7181
  blockExplorers: {
6817
7182
  readonly default: {
@@ -6848,6 +7213,7 @@ declare function getEvmChain(chain: string): {
6848
7213
  sourceId?: number | undefined | undefined;
6849
7214
  testnet: false;
6850
7215
  custom?: Record<string, unknown> | undefined;
7216
+ extendSchema?: Record<string, unknown> | undefined;
6851
7217
  fees?: viem.ChainFees<undefined> | undefined;
6852
7218
  formatters?: undefined;
6853
7219
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -6858,6 +7224,7 @@ declare function getEvmChain(chain: string): {
6858
7224
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
6859
7225
  }] | undefined;
6860
7226
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7227
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
6861
7228
  } | {
6862
7229
  blockExplorers: {
6863
7230
  readonly default: {
@@ -6884,13 +7251,14 @@ declare function getEvmChain(chain: string): {
6884
7251
  experimental_preconfirmationTime?: number | undefined | undefined;
6885
7252
  rpcUrls: {
6886
7253
  readonly default: {
6887
- readonly http: readonly ["https://moonbeam.public.blastapi.io"];
6888
- readonly webSocket: readonly ["wss://moonbeam.public.blastapi.io"];
7254
+ readonly http: readonly ["https://rpc.api.moonbeam.network"];
7255
+ readonly webSocket: readonly ["wss://wss.api.moonbeam.network"];
6889
7256
  };
6890
7257
  };
6891
7258
  sourceId?: number | undefined | undefined;
6892
7259
  testnet: false;
6893
7260
  custom?: Record<string, unknown> | undefined;
7261
+ extendSchema?: Record<string, unknown> | undefined;
6894
7262
  fees?: viem.ChainFees<undefined> | undefined;
6895
7263
  formatters?: undefined;
6896
7264
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -6901,6 +7269,7 @@ declare function getEvmChain(chain: string): {
6901
7269
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
6902
7270
  }] | undefined;
6903
7271
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7272
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
6904
7273
  } | {
6905
7274
  contracts: {
6906
7275
  multicall3: {
@@ -6932,6 +7301,7 @@ declare function getEvmChain(chain: string): {
6932
7301
  sourceId?: number | undefined | undefined;
6933
7302
  testnet: false;
6934
7303
  custom?: Record<string, unknown> | undefined;
7304
+ extendSchema?: Record<string, unknown> | undefined;
6935
7305
  fees?: viem.ChainFees<undefined> | undefined;
6936
7306
  formatters?: undefined;
6937
7307
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -6942,6 +7312,7 @@ declare function getEvmChain(chain: string): {
6942
7312
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
6943
7313
  }] | undefined;
6944
7314
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7315
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
6945
7316
  network: "Hemi";
6946
7317
  } | {
6947
7318
  contracts: {
@@ -6976,6 +7347,7 @@ declare function getEvmChain(chain: string): {
6976
7347
  sourceId?: number | undefined | undefined;
6977
7348
  testnet?: boolean | undefined | undefined;
6978
7349
  custom?: Record<string, unknown> | undefined;
7350
+ extendSchema?: Record<string, unknown> | undefined;
6979
7351
  fees?: viem.ChainFees<undefined> | undefined;
6980
7352
  formatters?: undefined;
6981
7353
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -6986,6 +7358,7 @@ declare function getEvmChain(chain: string): {
6986
7358
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
6987
7359
  }] | undefined;
6988
7360
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7361
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
6989
7362
  } | {
6990
7363
  contracts: {
6991
7364
  multicall3: {
@@ -7019,6 +7392,7 @@ declare function getEvmChain(chain: string): {
7019
7392
  sourceId: 1;
7020
7393
  testnet: false;
7021
7394
  custom?: Record<string, unknown> | undefined;
7395
+ extendSchema?: Record<string, unknown> | undefined;
7022
7396
  fees?: viem.ChainFees<undefined> | undefined;
7023
7397
  formatters: {
7024
7398
  readonly block: {
@@ -7084,16 +7458,16 @@ declare function getEvmChain(chain: string): {
7084
7458
  r: viem.Hex;
7085
7459
  s: viem.Hex;
7086
7460
  v: bigint;
7087
- value: bigint;
7088
- gas: bigint;
7089
7461
  to: viem.Address | null;
7090
7462
  from: viem.Address;
7463
+ gas: bigint;
7091
7464
  nonce: number;
7465
+ value: bigint;
7092
7466
  blockHash: `0x${string}` | null;
7093
7467
  blockNumber: bigint | null;
7094
- transactionIndex: number | null;
7095
7468
  hash: viem.Hash;
7096
7469
  input: viem.Hex;
7470
+ transactionIndex: number | null;
7097
7471
  typeHex: viem.Hex | null;
7098
7472
  accessList?: undefined | undefined;
7099
7473
  authorizationList?: undefined | undefined;
@@ -7261,6 +7635,7 @@ declare function getEvmChain(chain: string): {
7261
7635
  serializers: {
7262
7636
  readonly transaction: typeof viem_chains.serializeTransactionOpStack;
7263
7637
  };
7638
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
7264
7639
  } | {
7265
7640
  contracts: {
7266
7641
  multicall3: {
@@ -7293,6 +7668,7 @@ declare function getEvmChain(chain: string): {
7293
7668
  sourceId?: number | undefined | undefined;
7294
7669
  testnet: false;
7295
7670
  custom?: Record<string, unknown> | undefined;
7671
+ extendSchema?: Record<string, unknown> | undefined;
7296
7672
  fees?: viem.ChainFees<undefined> | undefined;
7297
7673
  formatters?: undefined;
7298
7674
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -7303,6 +7679,7 @@ declare function getEvmChain(chain: string): {
7303
7679
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
7304
7680
  }] | undefined;
7305
7681
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7682
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
7306
7683
  } | {
7307
7684
  contracts: {
7308
7685
  multicall3: {
@@ -7334,6 +7711,7 @@ declare function getEvmChain(chain: string): {
7334
7711
  sourceId?: number | undefined | undefined;
7335
7712
  testnet?: boolean | undefined | undefined;
7336
7713
  custom?: Record<string, unknown> | undefined;
7714
+ extendSchema?: Record<string, unknown> | undefined;
7337
7715
  fees?: viem.ChainFees<undefined> | undefined;
7338
7716
  formatters?: undefined;
7339
7717
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -7344,6 +7722,7 @@ declare function getEvmChain(chain: string): {
7344
7722
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
7345
7723
  }] | undefined;
7346
7724
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7725
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
7347
7726
  } | {
7348
7727
  contracts: {
7349
7728
  multicall3: {
@@ -7376,6 +7755,7 @@ declare function getEvmChain(chain: string): {
7376
7755
  sourceId?: number | undefined | undefined;
7377
7756
  testnet?: boolean | undefined | undefined;
7378
7757
  custom?: Record<string, unknown> | undefined;
7758
+ extendSchema?: Record<string, unknown> | undefined;
7379
7759
  fees?: viem.ChainFees<undefined> | undefined;
7380
7760
  formatters?: undefined;
7381
7761
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -7386,6 +7766,50 @@ declare function getEvmChain(chain: string): {
7386
7766
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
7387
7767
  }] | undefined;
7388
7768
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7769
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
7770
+ } | {
7771
+ contracts: {
7772
+ multicall3: {
7773
+ address: string;
7774
+ blockCreated: number;
7775
+ };
7776
+ };
7777
+ blockExplorers: {
7778
+ readonly default: {
7779
+ readonly name: "Taraxa Explorer";
7780
+ readonly url: "https://explorer.mainnet.taraxa.io";
7781
+ };
7782
+ };
7783
+ blockTime?: number | undefined | undefined;
7784
+ ensTlds?: readonly string[] | undefined;
7785
+ id: 841;
7786
+ name: "Taraxa Mainnet";
7787
+ nativeCurrency: {
7788
+ readonly name: "Tara";
7789
+ readonly symbol: "TARA";
7790
+ readonly decimals: 18;
7791
+ };
7792
+ experimental_preconfirmationTime?: number | undefined | undefined;
7793
+ rpcUrls: {
7794
+ readonly default: {
7795
+ readonly http: readonly ["https://rpc.mainnet.taraxa.io"];
7796
+ };
7797
+ };
7798
+ sourceId?: number | undefined | undefined;
7799
+ testnet?: boolean | undefined | undefined;
7800
+ custom?: Record<string, unknown> | undefined;
7801
+ extendSchema?: Record<string, unknown> | undefined;
7802
+ fees?: viem.ChainFees<undefined> | undefined;
7803
+ formatters?: undefined;
7804
+ prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
7805
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
7806
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
7807
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
7808
+ }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
7809
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
7810
+ }] | undefined;
7811
+ serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7812
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
7389
7813
  } | {
7390
7814
  contracts: {
7391
7815
  multicall3: {
@@ -7417,6 +7841,7 @@ declare function getEvmChain(chain: string): {
7417
7841
  sourceId?: number | undefined | undefined;
7418
7842
  testnet?: boolean | undefined | undefined;
7419
7843
  custom?: Record<string, unknown> | undefined;
7844
+ extendSchema?: Record<string, unknown> | undefined;
7420
7845
  fees?: viem.ChainFees<undefined> | undefined;
7421
7846
  formatters?: undefined;
7422
7847
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -7427,6 +7852,7 @@ declare function getEvmChain(chain: string): {
7427
7852
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
7428
7853
  }] | undefined;
7429
7854
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7855
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
7430
7856
  } | {
7431
7857
  contracts: {
7432
7858
  multicall3: {
@@ -7458,6 +7884,7 @@ declare function getEvmChain(chain: string): {
7458
7884
  sourceId?: number | undefined | undefined;
7459
7885
  testnet?: boolean | undefined | undefined;
7460
7886
  custom?: Record<string, unknown> | undefined;
7887
+ extendSchema?: Record<string, unknown> | undefined;
7461
7888
  fees?: viem.ChainFees<undefined> | undefined;
7462
7889
  formatters?: undefined;
7463
7890
  prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
@@ -7468,45 +7895,36 @@ declare function getEvmChain(chain: string): {
7468
7895
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
7469
7896
  }] | undefined;
7470
7897
  serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
7898
+ verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
7471
7899
  };
7472
- /**
7473
- * Get correct transport according to the input url with optional config
7474
- */
7900
+
7901
+ declare const LIST_OVERRIDES: Record<string, string[]>;
7902
+
7475
7903
  declare function createTransport(url: string, config?: any): viem.WebSocketTransport | viem.HttpTransport<undefined, false>;
7476
- /**
7477
- * Get correct transport according to the input url
7478
- */
7479
7904
  declare function getTransport(url: string): viem.WebSocketTransport | viem.HttpTransport<undefined, false>;
7480
- /**
7481
- * @deprecated Use getEvmClientUniversal instead
7482
- */
7905
+
7906
+ declare const DEFAULT_BATCH_SIZE = 4096;
7907
+ declare function trimTrailingSlash(url?: string): string | undefined;
7908
+ declare function deepCompare(a: any, b: any): boolean;
7909
+ declare function uniq<T>(array: T[]): T[];
7910
+ declare function isArray(value: any): boolean;
7911
+
7483
7912
  declare function getEvmClient(chain: string, rpcId?: number): PublicClient;
7484
7913
  declare function getEvmClientUniversal({ chain, rpcId, }: {
7485
7914
  chain: string;
7486
7915
  rpcId: number;
7487
7916
  }): PublicClient;
7488
- declare function createMulticallRetry(customRpcs?: {
7489
- [chainId: string]: string[];
7490
- }): (chain: string, calls: any[], abi: any, batchSize?: number, maxRetries?: number, providerId?: number, allowFailure?: boolean, logErrors?: boolean) => Promise<any[]>;
7491
7917
  /**
7492
- * @deprecated Use getEvmClientWithCustomRpcsUniversal instead
7918
+ * @deprecated use getEvmClientWithCustomRpcsUniversal instead
7919
+ * @see getEvmClientWithCustomRpcsUniversal
7493
7920
  */
7494
- declare function getEvmClientWithCustomRpcs(chain: string, rpcId?: number, customRpcs?: {
7495
- [chainId: string]: string[];
7496
- }): PublicClient;
7921
+ declare function getEvmClientWithCustomRpcs(chain: string, rpcId?: number, customRpcs?: Record<string, string[]>): PublicClient;
7497
7922
  declare function getEvmClientWithCustomRpcsUniversal({ chain, rpcId, customRpcs, }: {
7498
7923
  chain: string;
7499
7924
  rpcId: number;
7500
- customRpcs: {
7501
- [chainId: string]: string[];
7502
- };
7925
+ customRpcs: Record<string, string[]>;
7503
7926
  }): PublicClient;
7504
- /**
7505
- * @deprecated Use multicallRetryUniversal instead
7506
- */
7507
- declare function multicallRetry(chain: string, calls: any[], abi: any, batchSize?: number, maxRetries?: number, providerId?: number, allowFailure?: boolean, overrdies?: {
7508
- [chainId: string]: string[];
7509
- }, logErrors?: boolean): Promise<any[]>;
7927
+
7510
7928
  interface MulticallRetryParams {
7511
7929
  chain: string;
7512
7930
  calls: any[];
@@ -7515,11 +7933,15 @@ interface MulticallRetryParams {
7515
7933
  maxRetries?: number;
7516
7934
  providerId?: number;
7517
7935
  allowFailure?: boolean;
7518
- overrdies?: {
7519
- [chainId: string]: string[];
7520
- };
7936
+ overrdies?: Record<string, string[]>;
7521
7937
  logErrors?: boolean;
7522
7938
  }
7939
+ declare function createMulticallRetry(customRpcs?: Record<string, string[]>): (chain: string, calls: any[], abi: any, batchSize?: number, maxRetries?: number, providerId?: number, allowFailure?: boolean, logErrors?: boolean, revertedIndices?: Set<number>) => Promise<any[]>;
7940
+ /**
7941
+ * @deprecated use multicallRetryUniversal instead
7942
+ * @see multicallRetryUniversal
7943
+ */
7944
+ declare function multicallRetry(chain: string, calls: any[], abi: any, batchSize?: number, maxRetries?: number, providerId?: number, allowFailure?: boolean, overrdies?: Record<string, string[]>, logErrors?: boolean): Promise<any[]>;
7523
7945
  declare function multicallRetryUniversal({ chain, calls, abi, batchSize, maxRetries, providerId, allowFailure, overrdies, logErrors, }: MulticallRetryParams): Promise<any[]>;
7524
7946
 
7525
- export { type MulticallRetryParams, createMulticallRetry, createTransport, getEvmChain, getEvmClient, getEvmClientUniversal, getEvmClientWithCustomRpcs, getEvmClientWithCustomRpcsUniversal, getTransport, katana, multicallRetry, multicallRetryUniversal, plasma };
7947
+ export { DEFAULT_BATCH_SIZE, LIST_OVERRIDES, type MulticallRetryParams, createMulticallRetry, createTransport, customChains, deepCompare, getEvmChain, getEvmClient, getEvmClientUniversal, getEvmClientWithCustomRpcs, getEvmClientWithCustomRpcsUniversal, getTransport, isArray, katana, multicallRetry, multicallRetryUniversal, plasma, trimTrailingSlash, uniq };