@hyperlane-xyz/sdk 16.1.1 → 16.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/consts/multisigIsm.d.ts.map +1 -1
- package/dist/consts/multisigIsm.js +26 -176
- package/dist/consts/multisigIsm.js.map +1 -1
- package/dist/index.d.ts +3 -3
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +3 -3
- package/dist/index.js.map +1 -1
- package/dist/token/EvmERC20WarpRouteReader.d.ts.map +1 -1
- package/dist/token/EvmERC20WarpRouteReader.js +3 -1
- package/dist/token/EvmERC20WarpRouteReader.js.map +1 -1
- package/dist/token/TokenStandard.d.ts +1 -0
- package/dist/token/TokenStandard.d.ts.map +1 -1
- package/dist/token/TokenStandard.js +4 -0
- package/dist/token/TokenStandard.js.map +1 -1
- package/dist/token/adapters/EvmTokenAdapter.d.ts +15 -2
- package/dist/token/adapters/EvmTokenAdapter.d.ts.map +1 -1
- package/dist/token/adapters/EvmTokenAdapter.js +24 -0
- package/dist/token/adapters/EvmTokenAdapter.js.map +1 -1
- package/dist/token/adapters/ITokenAdapter.d.ts +8 -0
- package/dist/token/adapters/ITokenAdapter.d.ts.map +1 -1
- package/dist/token/checker.d.ts.map +1 -1
- package/dist/token/checker.js +2 -1
- package/dist/token/checker.js.map +1 -1
- package/dist/token/types.d.ts +769 -33
- package/dist/token/types.d.ts.map +1 -1
- package/dist/token/types.js +19 -3
- package/dist/token/types.js.map +1 -1
- package/dist/token/xerc20.d.ts.map +1 -1
- package/dist/token/xerc20.js +2 -0
- package/dist/token/xerc20.js.map +1 -1
- package/dist/warp/WarpCore.d.ts.map +1 -1
- package/dist/warp/WarpCore.js +2 -3
- package/dist/warp/WarpCore.js.map +1 -1
- package/package.json +5 -5
package/dist/token/types.d.ts
CHANGED
|
@@ -9,7 +9,7 @@ export declare const WarpRouteDeployConfigSchemaErrors: {
|
|
|
9
9
|
NO_SYNTHETIC_ONLY: string;
|
|
10
10
|
};
|
|
11
11
|
export declare const contractVersionMatchesDependency: (version: string) => boolean;
|
|
12
|
-
export declare const VERSION_ERROR_MESSAGE = "Contract version must match the @hyperlane-xyz/core dependency version (9.0.
|
|
12
|
+
export declare const VERSION_ERROR_MESSAGE = "Contract version must match the @hyperlane-xyz/core dependency version (9.0.5)";
|
|
13
13
|
export declare const TokenMetadataSchema: z.ZodObject<{
|
|
14
14
|
name: z.ZodString;
|
|
15
15
|
symbol: z.ZodString;
|
|
@@ -334,129 +334,255 @@ export declare const isCollateralTokenConfig: (config: unknown) => config is {
|
|
|
334
334
|
}[]> | undefined;
|
|
335
335
|
allowedRebalancers?: string[] | undefined;
|
|
336
336
|
};
|
|
337
|
-
declare
|
|
337
|
+
export declare enum XERC20Type {
|
|
338
|
+
Velo = "velo",
|
|
339
|
+
Standard = "standard"
|
|
340
|
+
}
|
|
341
|
+
declare const XERC20VSLimitConfigSchema: z.ZodObject<{
|
|
342
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
338
343
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
339
344
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
340
345
|
}, "strip", z.ZodTypeAny, {
|
|
346
|
+
type: XERC20Type.Velo;
|
|
341
347
|
bufferCap?: string | undefined;
|
|
342
348
|
rateLimitPerSecond?: string | undefined;
|
|
343
349
|
}, {
|
|
350
|
+
type: XERC20Type.Velo;
|
|
344
351
|
bufferCap?: string | undefined;
|
|
345
352
|
rateLimitPerSecond?: string | undefined;
|
|
346
353
|
}>;
|
|
347
|
-
export type
|
|
354
|
+
export type XERC20VSLimitConfig = z.infer<typeof XERC20VSLimitConfigSchema>;
|
|
355
|
+
declare const XERC20StandardLimitConfigSchema: z.ZodObject<{
|
|
356
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
357
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
358
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
359
|
+
}, "strip", z.ZodTypeAny, {
|
|
360
|
+
type: XERC20Type.Standard;
|
|
361
|
+
mint?: string | undefined;
|
|
362
|
+
burn?: string | undefined;
|
|
363
|
+
}, {
|
|
364
|
+
type: XERC20Type.Standard;
|
|
365
|
+
mint?: string | undefined;
|
|
366
|
+
burn?: string | undefined;
|
|
367
|
+
}>;
|
|
368
|
+
export type XERC20StandardLimitConfig = z.infer<typeof XERC20StandardLimitConfigSchema>;
|
|
348
369
|
declare const xERC20ExtraBridgesLimitConfigsSchema: z.ZodObject<{
|
|
349
370
|
lockbox: z.ZodString;
|
|
350
|
-
limits: z.ZodObject<{
|
|
371
|
+
limits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
372
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
351
373
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
352
374
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
353
375
|
}, "strip", z.ZodTypeAny, {
|
|
376
|
+
type: XERC20Type.Velo;
|
|
354
377
|
bufferCap?: string | undefined;
|
|
355
378
|
rateLimitPerSecond?: string | undefined;
|
|
356
379
|
}, {
|
|
380
|
+
type: XERC20Type.Velo;
|
|
357
381
|
bufferCap?: string | undefined;
|
|
358
382
|
rateLimitPerSecond?: string | undefined;
|
|
359
|
-
}
|
|
383
|
+
}>, z.ZodObject<{
|
|
384
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
385
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
386
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
387
|
+
}, "strip", z.ZodTypeAny, {
|
|
388
|
+
type: XERC20Type.Standard;
|
|
389
|
+
mint?: string | undefined;
|
|
390
|
+
burn?: string | undefined;
|
|
391
|
+
}, {
|
|
392
|
+
type: XERC20Type.Standard;
|
|
393
|
+
mint?: string | undefined;
|
|
394
|
+
burn?: string | undefined;
|
|
395
|
+
}>]>;
|
|
360
396
|
}, "strip", z.ZodTypeAny, {
|
|
361
397
|
lockbox: string;
|
|
362
398
|
limits: {
|
|
399
|
+
type: XERC20Type.Velo;
|
|
363
400
|
bufferCap?: string | undefined;
|
|
364
401
|
rateLimitPerSecond?: string | undefined;
|
|
402
|
+
} | {
|
|
403
|
+
type: XERC20Type.Standard;
|
|
404
|
+
mint?: string | undefined;
|
|
405
|
+
burn?: string | undefined;
|
|
365
406
|
};
|
|
366
407
|
}, {
|
|
367
408
|
lockbox: string;
|
|
368
409
|
limits: {
|
|
410
|
+
type: XERC20Type.Velo;
|
|
369
411
|
bufferCap?: string | undefined;
|
|
370
412
|
rateLimitPerSecond?: string | undefined;
|
|
413
|
+
} | {
|
|
414
|
+
type: XERC20Type.Standard;
|
|
415
|
+
mint?: string | undefined;
|
|
416
|
+
burn?: string | undefined;
|
|
371
417
|
};
|
|
372
418
|
}>;
|
|
373
419
|
declare const xERC20TokenMetadataSchema: z.ZodObject<{
|
|
374
420
|
xERC20: z.ZodOptional<z.ZodObject<{
|
|
375
421
|
extraBridges: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
376
422
|
lockbox: z.ZodString;
|
|
377
|
-
limits: z.ZodObject<{
|
|
423
|
+
limits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
424
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
378
425
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
379
426
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
380
427
|
}, "strip", z.ZodTypeAny, {
|
|
428
|
+
type: XERC20Type.Velo;
|
|
381
429
|
bufferCap?: string | undefined;
|
|
382
430
|
rateLimitPerSecond?: string | undefined;
|
|
383
431
|
}, {
|
|
432
|
+
type: XERC20Type.Velo;
|
|
384
433
|
bufferCap?: string | undefined;
|
|
385
434
|
rateLimitPerSecond?: string | undefined;
|
|
386
|
-
}
|
|
435
|
+
}>, z.ZodObject<{
|
|
436
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
437
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
438
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
439
|
+
}, "strip", z.ZodTypeAny, {
|
|
440
|
+
type: XERC20Type.Standard;
|
|
441
|
+
mint?: string | undefined;
|
|
442
|
+
burn?: string | undefined;
|
|
443
|
+
}, {
|
|
444
|
+
type: XERC20Type.Standard;
|
|
445
|
+
mint?: string | undefined;
|
|
446
|
+
burn?: string | undefined;
|
|
447
|
+
}>]>;
|
|
387
448
|
}, "strip", z.ZodTypeAny, {
|
|
388
449
|
lockbox: string;
|
|
389
450
|
limits: {
|
|
451
|
+
type: XERC20Type.Velo;
|
|
390
452
|
bufferCap?: string | undefined;
|
|
391
453
|
rateLimitPerSecond?: string | undefined;
|
|
454
|
+
} | {
|
|
455
|
+
type: XERC20Type.Standard;
|
|
456
|
+
mint?: string | undefined;
|
|
457
|
+
burn?: string | undefined;
|
|
392
458
|
};
|
|
393
459
|
}, {
|
|
394
460
|
lockbox: string;
|
|
395
461
|
limits: {
|
|
462
|
+
type: XERC20Type.Velo;
|
|
396
463
|
bufferCap?: string | undefined;
|
|
397
464
|
rateLimitPerSecond?: string | undefined;
|
|
465
|
+
} | {
|
|
466
|
+
type: XERC20Type.Standard;
|
|
467
|
+
mint?: string | undefined;
|
|
468
|
+
burn?: string | undefined;
|
|
398
469
|
};
|
|
399
470
|
}>, "many">>;
|
|
400
|
-
warpRouteLimits: z.ZodObject<{
|
|
471
|
+
warpRouteLimits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
472
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
401
473
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
402
474
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
403
475
|
}, "strip", z.ZodTypeAny, {
|
|
476
|
+
type: XERC20Type.Velo;
|
|
404
477
|
bufferCap?: string | undefined;
|
|
405
478
|
rateLimitPerSecond?: string | undefined;
|
|
406
479
|
}, {
|
|
480
|
+
type: XERC20Type.Velo;
|
|
407
481
|
bufferCap?: string | undefined;
|
|
408
482
|
rateLimitPerSecond?: string | undefined;
|
|
409
|
-
}
|
|
483
|
+
}>, z.ZodObject<{
|
|
484
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
485
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
486
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
487
|
+
}, "strip", z.ZodTypeAny, {
|
|
488
|
+
type: XERC20Type.Standard;
|
|
489
|
+
mint?: string | undefined;
|
|
490
|
+
burn?: string | undefined;
|
|
491
|
+
}, {
|
|
492
|
+
type: XERC20Type.Standard;
|
|
493
|
+
mint?: string | undefined;
|
|
494
|
+
burn?: string | undefined;
|
|
495
|
+
}>]>;
|
|
410
496
|
}, "strip", z.ZodTypeAny, {
|
|
411
497
|
warpRouteLimits: {
|
|
498
|
+
type: XERC20Type.Velo;
|
|
412
499
|
bufferCap?: string | undefined;
|
|
413
500
|
rateLimitPerSecond?: string | undefined;
|
|
501
|
+
} | {
|
|
502
|
+
type: XERC20Type.Standard;
|
|
503
|
+
mint?: string | undefined;
|
|
504
|
+
burn?: string | undefined;
|
|
414
505
|
};
|
|
415
506
|
extraBridges?: {
|
|
416
507
|
lockbox: string;
|
|
417
508
|
limits: {
|
|
509
|
+
type: XERC20Type.Velo;
|
|
418
510
|
bufferCap?: string | undefined;
|
|
419
511
|
rateLimitPerSecond?: string | undefined;
|
|
512
|
+
} | {
|
|
513
|
+
type: XERC20Type.Standard;
|
|
514
|
+
mint?: string | undefined;
|
|
515
|
+
burn?: string | undefined;
|
|
420
516
|
};
|
|
421
517
|
}[] | undefined;
|
|
422
518
|
}, {
|
|
423
519
|
warpRouteLimits: {
|
|
520
|
+
type: XERC20Type.Velo;
|
|
424
521
|
bufferCap?: string | undefined;
|
|
425
522
|
rateLimitPerSecond?: string | undefined;
|
|
523
|
+
} | {
|
|
524
|
+
type: XERC20Type.Standard;
|
|
525
|
+
mint?: string | undefined;
|
|
526
|
+
burn?: string | undefined;
|
|
426
527
|
};
|
|
427
528
|
extraBridges?: {
|
|
428
529
|
lockbox: string;
|
|
429
530
|
limits: {
|
|
531
|
+
type: XERC20Type.Velo;
|
|
430
532
|
bufferCap?: string | undefined;
|
|
431
533
|
rateLimitPerSecond?: string | undefined;
|
|
534
|
+
} | {
|
|
535
|
+
type: XERC20Type.Standard;
|
|
536
|
+
mint?: string | undefined;
|
|
537
|
+
burn?: string | undefined;
|
|
432
538
|
};
|
|
433
539
|
}[] | undefined;
|
|
434
540
|
}>>;
|
|
435
541
|
}, "strip", z.ZodTypeAny, {
|
|
436
542
|
xERC20?: {
|
|
437
543
|
warpRouteLimits: {
|
|
544
|
+
type: XERC20Type.Velo;
|
|
438
545
|
bufferCap?: string | undefined;
|
|
439
546
|
rateLimitPerSecond?: string | undefined;
|
|
547
|
+
} | {
|
|
548
|
+
type: XERC20Type.Standard;
|
|
549
|
+
mint?: string | undefined;
|
|
550
|
+
burn?: string | undefined;
|
|
440
551
|
};
|
|
441
552
|
extraBridges?: {
|
|
442
553
|
lockbox: string;
|
|
443
554
|
limits: {
|
|
555
|
+
type: XERC20Type.Velo;
|
|
444
556
|
bufferCap?: string | undefined;
|
|
445
557
|
rateLimitPerSecond?: string | undefined;
|
|
558
|
+
} | {
|
|
559
|
+
type: XERC20Type.Standard;
|
|
560
|
+
mint?: string | undefined;
|
|
561
|
+
burn?: string | undefined;
|
|
446
562
|
};
|
|
447
563
|
}[] | undefined;
|
|
448
564
|
} | undefined;
|
|
449
565
|
}, {
|
|
450
566
|
xERC20?: {
|
|
451
567
|
warpRouteLimits: {
|
|
568
|
+
type: XERC20Type.Velo;
|
|
452
569
|
bufferCap?: string | undefined;
|
|
453
570
|
rateLimitPerSecond?: string | undefined;
|
|
571
|
+
} | {
|
|
572
|
+
type: XERC20Type.Standard;
|
|
573
|
+
mint?: string | undefined;
|
|
574
|
+
burn?: string | undefined;
|
|
454
575
|
};
|
|
455
576
|
extraBridges?: {
|
|
456
577
|
lockbox: string;
|
|
457
578
|
limits: {
|
|
579
|
+
type: XERC20Type.Velo;
|
|
458
580
|
bufferCap?: string | undefined;
|
|
459
581
|
rateLimitPerSecond?: string | undefined;
|
|
582
|
+
} | {
|
|
583
|
+
type: XERC20Type.Standard;
|
|
584
|
+
mint?: string | undefined;
|
|
585
|
+
burn?: string | undefined;
|
|
460
586
|
};
|
|
461
587
|
}[] | undefined;
|
|
462
588
|
} | undefined;
|
|
@@ -486,61 +612,121 @@ export declare const XERC20TokenConfigSchema: z.ZodObject<{
|
|
|
486
612
|
xERC20: z.ZodOptional<z.ZodObject<{
|
|
487
613
|
extraBridges: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
488
614
|
lockbox: z.ZodString;
|
|
489
|
-
limits: z.ZodObject<{
|
|
615
|
+
limits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
616
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
490
617
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
491
618
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
492
619
|
}, "strip", z.ZodTypeAny, {
|
|
620
|
+
type: XERC20Type.Velo;
|
|
493
621
|
bufferCap?: string | undefined;
|
|
494
622
|
rateLimitPerSecond?: string | undefined;
|
|
495
623
|
}, {
|
|
624
|
+
type: XERC20Type.Velo;
|
|
496
625
|
bufferCap?: string | undefined;
|
|
497
626
|
rateLimitPerSecond?: string | undefined;
|
|
498
|
-
}
|
|
627
|
+
}>, z.ZodObject<{
|
|
628
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
629
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
630
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
631
|
+
}, "strip", z.ZodTypeAny, {
|
|
632
|
+
type: XERC20Type.Standard;
|
|
633
|
+
mint?: string | undefined;
|
|
634
|
+
burn?: string | undefined;
|
|
635
|
+
}, {
|
|
636
|
+
type: XERC20Type.Standard;
|
|
637
|
+
mint?: string | undefined;
|
|
638
|
+
burn?: string | undefined;
|
|
639
|
+
}>]>;
|
|
499
640
|
}, "strip", z.ZodTypeAny, {
|
|
500
641
|
lockbox: string;
|
|
501
642
|
limits: {
|
|
643
|
+
type: XERC20Type.Velo;
|
|
502
644
|
bufferCap?: string | undefined;
|
|
503
645
|
rateLimitPerSecond?: string | undefined;
|
|
646
|
+
} | {
|
|
647
|
+
type: XERC20Type.Standard;
|
|
648
|
+
mint?: string | undefined;
|
|
649
|
+
burn?: string | undefined;
|
|
504
650
|
};
|
|
505
651
|
}, {
|
|
506
652
|
lockbox: string;
|
|
507
653
|
limits: {
|
|
654
|
+
type: XERC20Type.Velo;
|
|
508
655
|
bufferCap?: string | undefined;
|
|
509
656
|
rateLimitPerSecond?: string | undefined;
|
|
657
|
+
} | {
|
|
658
|
+
type: XERC20Type.Standard;
|
|
659
|
+
mint?: string | undefined;
|
|
660
|
+
burn?: string | undefined;
|
|
510
661
|
};
|
|
511
662
|
}>, "many">>;
|
|
512
|
-
warpRouteLimits: z.ZodObject<{
|
|
663
|
+
warpRouteLimits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
664
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
513
665
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
514
666
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
515
667
|
}, "strip", z.ZodTypeAny, {
|
|
668
|
+
type: XERC20Type.Velo;
|
|
516
669
|
bufferCap?: string | undefined;
|
|
517
670
|
rateLimitPerSecond?: string | undefined;
|
|
518
671
|
}, {
|
|
672
|
+
type: XERC20Type.Velo;
|
|
519
673
|
bufferCap?: string | undefined;
|
|
520
674
|
rateLimitPerSecond?: string | undefined;
|
|
521
|
-
}
|
|
675
|
+
}>, z.ZodObject<{
|
|
676
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
677
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
678
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
679
|
+
}, "strip", z.ZodTypeAny, {
|
|
680
|
+
type: XERC20Type.Standard;
|
|
681
|
+
mint?: string | undefined;
|
|
682
|
+
burn?: string | undefined;
|
|
683
|
+
}, {
|
|
684
|
+
type: XERC20Type.Standard;
|
|
685
|
+
mint?: string | undefined;
|
|
686
|
+
burn?: string | undefined;
|
|
687
|
+
}>]>;
|
|
522
688
|
}, "strip", z.ZodTypeAny, {
|
|
523
689
|
warpRouteLimits: {
|
|
690
|
+
type: XERC20Type.Velo;
|
|
524
691
|
bufferCap?: string | undefined;
|
|
525
692
|
rateLimitPerSecond?: string | undefined;
|
|
693
|
+
} | {
|
|
694
|
+
type: XERC20Type.Standard;
|
|
695
|
+
mint?: string | undefined;
|
|
696
|
+
burn?: string | undefined;
|
|
526
697
|
};
|
|
527
698
|
extraBridges?: {
|
|
528
699
|
lockbox: string;
|
|
529
700
|
limits: {
|
|
701
|
+
type: XERC20Type.Velo;
|
|
530
702
|
bufferCap?: string | undefined;
|
|
531
703
|
rateLimitPerSecond?: string | undefined;
|
|
704
|
+
} | {
|
|
705
|
+
type: XERC20Type.Standard;
|
|
706
|
+
mint?: string | undefined;
|
|
707
|
+
burn?: string | undefined;
|
|
532
708
|
};
|
|
533
709
|
}[] | undefined;
|
|
534
710
|
}, {
|
|
535
711
|
warpRouteLimits: {
|
|
712
|
+
type: XERC20Type.Velo;
|
|
536
713
|
bufferCap?: string | undefined;
|
|
537
714
|
rateLimitPerSecond?: string | undefined;
|
|
715
|
+
} | {
|
|
716
|
+
type: XERC20Type.Standard;
|
|
717
|
+
mint?: string | undefined;
|
|
718
|
+
burn?: string | undefined;
|
|
538
719
|
};
|
|
539
720
|
extraBridges?: {
|
|
540
721
|
lockbox: string;
|
|
541
722
|
limits: {
|
|
723
|
+
type: XERC20Type.Velo;
|
|
542
724
|
bufferCap?: string | undefined;
|
|
543
725
|
rateLimitPerSecond?: string | undefined;
|
|
726
|
+
} | {
|
|
727
|
+
type: XERC20Type.Standard;
|
|
728
|
+
mint?: string | undefined;
|
|
729
|
+
burn?: string | undefined;
|
|
544
730
|
};
|
|
545
731
|
}[] | undefined;
|
|
546
732
|
}>>;
|
|
@@ -560,14 +746,24 @@ export declare const XERC20TokenConfigSchema: z.ZodObject<{
|
|
|
560
746
|
allowedRebalancers?: string[] | undefined;
|
|
561
747
|
xERC20?: {
|
|
562
748
|
warpRouteLimits: {
|
|
749
|
+
type: XERC20Type.Velo;
|
|
563
750
|
bufferCap?: string | undefined;
|
|
564
751
|
rateLimitPerSecond?: string | undefined;
|
|
752
|
+
} | {
|
|
753
|
+
type: XERC20Type.Standard;
|
|
754
|
+
mint?: string | undefined;
|
|
755
|
+
burn?: string | undefined;
|
|
565
756
|
};
|
|
566
757
|
extraBridges?: {
|
|
567
758
|
lockbox: string;
|
|
568
759
|
limits: {
|
|
760
|
+
type: XERC20Type.Velo;
|
|
569
761
|
bufferCap?: string | undefined;
|
|
570
762
|
rateLimitPerSecond?: string | undefined;
|
|
763
|
+
} | {
|
|
764
|
+
type: XERC20Type.Standard;
|
|
765
|
+
mint?: string | undefined;
|
|
766
|
+
burn?: string | undefined;
|
|
571
767
|
};
|
|
572
768
|
}[] | undefined;
|
|
573
769
|
} | undefined;
|
|
@@ -587,14 +783,24 @@ export declare const XERC20TokenConfigSchema: z.ZodObject<{
|
|
|
587
783
|
allowedRebalancers?: string[] | undefined;
|
|
588
784
|
xERC20?: {
|
|
589
785
|
warpRouteLimits: {
|
|
786
|
+
type: XERC20Type.Velo;
|
|
590
787
|
bufferCap?: string | undefined;
|
|
591
788
|
rateLimitPerSecond?: string | undefined;
|
|
789
|
+
} | {
|
|
790
|
+
type: XERC20Type.Standard;
|
|
791
|
+
mint?: string | undefined;
|
|
792
|
+
burn?: string | undefined;
|
|
592
793
|
};
|
|
593
794
|
extraBridges?: {
|
|
594
795
|
lockbox: string;
|
|
595
796
|
limits: {
|
|
797
|
+
type: XERC20Type.Velo;
|
|
596
798
|
bufferCap?: string | undefined;
|
|
597
799
|
rateLimitPerSecond?: string | undefined;
|
|
800
|
+
} | {
|
|
801
|
+
type: XERC20Type.Standard;
|
|
802
|
+
mint?: string | undefined;
|
|
803
|
+
burn?: string | undefined;
|
|
598
804
|
};
|
|
599
805
|
}[] | undefined;
|
|
600
806
|
} | undefined;
|
|
@@ -616,14 +822,24 @@ export declare const isXERC20TokenConfig: (config: unknown) => config is {
|
|
|
616
822
|
allowedRebalancers?: string[] | undefined;
|
|
617
823
|
xERC20?: {
|
|
618
824
|
warpRouteLimits: {
|
|
825
|
+
type: XERC20Type.Velo;
|
|
619
826
|
bufferCap?: string | undefined;
|
|
620
827
|
rateLimitPerSecond?: string | undefined;
|
|
828
|
+
} | {
|
|
829
|
+
type: XERC20Type.Standard;
|
|
830
|
+
mint?: string | undefined;
|
|
831
|
+
burn?: string | undefined;
|
|
621
832
|
};
|
|
622
833
|
extraBridges?: {
|
|
623
834
|
lockbox: string;
|
|
624
835
|
limits: {
|
|
836
|
+
type: XERC20Type.Velo;
|
|
625
837
|
bufferCap?: string | undefined;
|
|
626
838
|
rateLimitPerSecond?: string | undefined;
|
|
839
|
+
} | {
|
|
840
|
+
type: XERC20Type.Standard;
|
|
841
|
+
mint?: string | undefined;
|
|
842
|
+
burn?: string | undefined;
|
|
627
843
|
};
|
|
628
844
|
}[] | undefined;
|
|
629
845
|
} | undefined;
|
|
@@ -1071,61 +1287,121 @@ export declare const HypTokenConfigSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
|
|
|
1071
1287
|
xERC20: z.ZodOptional<z.ZodObject<{
|
|
1072
1288
|
extraBridges: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1073
1289
|
lockbox: z.ZodString;
|
|
1074
|
-
limits: z.ZodObject<{
|
|
1290
|
+
limits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
1291
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
1075
1292
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
1076
1293
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
1077
1294
|
}, "strip", z.ZodTypeAny, {
|
|
1295
|
+
type: XERC20Type.Velo;
|
|
1078
1296
|
bufferCap?: string | undefined;
|
|
1079
1297
|
rateLimitPerSecond?: string | undefined;
|
|
1080
1298
|
}, {
|
|
1299
|
+
type: XERC20Type.Velo;
|
|
1081
1300
|
bufferCap?: string | undefined;
|
|
1082
1301
|
rateLimitPerSecond?: string | undefined;
|
|
1083
|
-
}
|
|
1302
|
+
}>, z.ZodObject<{
|
|
1303
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
1304
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
1305
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
1306
|
+
}, "strip", z.ZodTypeAny, {
|
|
1307
|
+
type: XERC20Type.Standard;
|
|
1308
|
+
mint?: string | undefined;
|
|
1309
|
+
burn?: string | undefined;
|
|
1310
|
+
}, {
|
|
1311
|
+
type: XERC20Type.Standard;
|
|
1312
|
+
mint?: string | undefined;
|
|
1313
|
+
burn?: string | undefined;
|
|
1314
|
+
}>]>;
|
|
1084
1315
|
}, "strip", z.ZodTypeAny, {
|
|
1085
1316
|
lockbox: string;
|
|
1086
1317
|
limits: {
|
|
1318
|
+
type: XERC20Type.Velo;
|
|
1087
1319
|
bufferCap?: string | undefined;
|
|
1088
1320
|
rateLimitPerSecond?: string | undefined;
|
|
1321
|
+
} | {
|
|
1322
|
+
type: XERC20Type.Standard;
|
|
1323
|
+
mint?: string | undefined;
|
|
1324
|
+
burn?: string | undefined;
|
|
1089
1325
|
};
|
|
1090
1326
|
}, {
|
|
1091
1327
|
lockbox: string;
|
|
1092
1328
|
limits: {
|
|
1329
|
+
type: XERC20Type.Velo;
|
|
1093
1330
|
bufferCap?: string | undefined;
|
|
1094
1331
|
rateLimitPerSecond?: string | undefined;
|
|
1332
|
+
} | {
|
|
1333
|
+
type: XERC20Type.Standard;
|
|
1334
|
+
mint?: string | undefined;
|
|
1335
|
+
burn?: string | undefined;
|
|
1095
1336
|
};
|
|
1096
1337
|
}>, "many">>;
|
|
1097
|
-
warpRouteLimits: z.ZodObject<{
|
|
1338
|
+
warpRouteLimits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
1339
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
1098
1340
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
1099
1341
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
1100
1342
|
}, "strip", z.ZodTypeAny, {
|
|
1343
|
+
type: XERC20Type.Velo;
|
|
1101
1344
|
bufferCap?: string | undefined;
|
|
1102
1345
|
rateLimitPerSecond?: string | undefined;
|
|
1103
1346
|
}, {
|
|
1347
|
+
type: XERC20Type.Velo;
|
|
1104
1348
|
bufferCap?: string | undefined;
|
|
1105
1349
|
rateLimitPerSecond?: string | undefined;
|
|
1106
|
-
}
|
|
1350
|
+
}>, z.ZodObject<{
|
|
1351
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
1352
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
1353
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
1354
|
+
}, "strip", z.ZodTypeAny, {
|
|
1355
|
+
type: XERC20Type.Standard;
|
|
1356
|
+
mint?: string | undefined;
|
|
1357
|
+
burn?: string | undefined;
|
|
1358
|
+
}, {
|
|
1359
|
+
type: XERC20Type.Standard;
|
|
1360
|
+
mint?: string | undefined;
|
|
1361
|
+
burn?: string | undefined;
|
|
1362
|
+
}>]>;
|
|
1107
1363
|
}, "strip", z.ZodTypeAny, {
|
|
1108
1364
|
warpRouteLimits: {
|
|
1365
|
+
type: XERC20Type.Velo;
|
|
1109
1366
|
bufferCap?: string | undefined;
|
|
1110
1367
|
rateLimitPerSecond?: string | undefined;
|
|
1368
|
+
} | {
|
|
1369
|
+
type: XERC20Type.Standard;
|
|
1370
|
+
mint?: string | undefined;
|
|
1371
|
+
burn?: string | undefined;
|
|
1111
1372
|
};
|
|
1112
1373
|
extraBridges?: {
|
|
1113
1374
|
lockbox: string;
|
|
1114
1375
|
limits: {
|
|
1376
|
+
type: XERC20Type.Velo;
|
|
1115
1377
|
bufferCap?: string | undefined;
|
|
1116
1378
|
rateLimitPerSecond?: string | undefined;
|
|
1379
|
+
} | {
|
|
1380
|
+
type: XERC20Type.Standard;
|
|
1381
|
+
mint?: string | undefined;
|
|
1382
|
+
burn?: string | undefined;
|
|
1117
1383
|
};
|
|
1118
1384
|
}[] | undefined;
|
|
1119
1385
|
}, {
|
|
1120
1386
|
warpRouteLimits: {
|
|
1387
|
+
type: XERC20Type.Velo;
|
|
1121
1388
|
bufferCap?: string | undefined;
|
|
1122
1389
|
rateLimitPerSecond?: string | undefined;
|
|
1390
|
+
} | {
|
|
1391
|
+
type: XERC20Type.Standard;
|
|
1392
|
+
mint?: string | undefined;
|
|
1393
|
+
burn?: string | undefined;
|
|
1123
1394
|
};
|
|
1124
1395
|
extraBridges?: {
|
|
1125
1396
|
lockbox: string;
|
|
1126
1397
|
limits: {
|
|
1398
|
+
type: XERC20Type.Velo;
|
|
1127
1399
|
bufferCap?: string | undefined;
|
|
1128
1400
|
rateLimitPerSecond?: string | undefined;
|
|
1401
|
+
} | {
|
|
1402
|
+
type: XERC20Type.Standard;
|
|
1403
|
+
mint?: string | undefined;
|
|
1404
|
+
burn?: string | undefined;
|
|
1129
1405
|
};
|
|
1130
1406
|
}[] | undefined;
|
|
1131
1407
|
}>>;
|
|
@@ -1145,14 +1421,24 @@ export declare const HypTokenConfigSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
|
|
|
1145
1421
|
allowedRebalancers?: string[] | undefined;
|
|
1146
1422
|
xERC20?: {
|
|
1147
1423
|
warpRouteLimits: {
|
|
1424
|
+
type: XERC20Type.Velo;
|
|
1148
1425
|
bufferCap?: string | undefined;
|
|
1149
1426
|
rateLimitPerSecond?: string | undefined;
|
|
1427
|
+
} | {
|
|
1428
|
+
type: XERC20Type.Standard;
|
|
1429
|
+
mint?: string | undefined;
|
|
1430
|
+
burn?: string | undefined;
|
|
1150
1431
|
};
|
|
1151
1432
|
extraBridges?: {
|
|
1152
1433
|
lockbox: string;
|
|
1153
1434
|
limits: {
|
|
1435
|
+
type: XERC20Type.Velo;
|
|
1154
1436
|
bufferCap?: string | undefined;
|
|
1155
1437
|
rateLimitPerSecond?: string | undefined;
|
|
1438
|
+
} | {
|
|
1439
|
+
type: XERC20Type.Standard;
|
|
1440
|
+
mint?: string | undefined;
|
|
1441
|
+
burn?: string | undefined;
|
|
1156
1442
|
};
|
|
1157
1443
|
}[] | undefined;
|
|
1158
1444
|
} | undefined;
|
|
@@ -1172,14 +1458,24 @@ export declare const HypTokenConfigSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
|
|
|
1172
1458
|
allowedRebalancers?: string[] | undefined;
|
|
1173
1459
|
xERC20?: {
|
|
1174
1460
|
warpRouteLimits: {
|
|
1461
|
+
type: XERC20Type.Velo;
|
|
1175
1462
|
bufferCap?: string | undefined;
|
|
1176
1463
|
rateLimitPerSecond?: string | undefined;
|
|
1464
|
+
} | {
|
|
1465
|
+
type: XERC20Type.Standard;
|
|
1466
|
+
mint?: string | undefined;
|
|
1467
|
+
burn?: string | undefined;
|
|
1177
1468
|
};
|
|
1178
1469
|
extraBridges?: {
|
|
1179
1470
|
lockbox: string;
|
|
1180
1471
|
limits: {
|
|
1472
|
+
type: XERC20Type.Velo;
|
|
1181
1473
|
bufferCap?: string | undefined;
|
|
1182
1474
|
rateLimitPerSecond?: string | undefined;
|
|
1475
|
+
} | {
|
|
1476
|
+
type: XERC20Type.Standard;
|
|
1477
|
+
mint?: string | undefined;
|
|
1478
|
+
burn?: string | undefined;
|
|
1183
1479
|
};
|
|
1184
1480
|
}[] | undefined;
|
|
1185
1481
|
} | undefined;
|
|
@@ -1520,61 +1816,121 @@ export declare const HypTokenRouterConfigSchema: z.ZodIntersection<z.ZodIntersec
|
|
|
1520
1816
|
xERC20: z.ZodOptional<z.ZodObject<{
|
|
1521
1817
|
extraBridges: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1522
1818
|
lockbox: z.ZodString;
|
|
1523
|
-
limits: z.ZodObject<{
|
|
1819
|
+
limits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
1820
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
1524
1821
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
1525
1822
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
1526
1823
|
}, "strip", z.ZodTypeAny, {
|
|
1824
|
+
type: XERC20Type.Velo;
|
|
1527
1825
|
bufferCap?: string | undefined;
|
|
1528
1826
|
rateLimitPerSecond?: string | undefined;
|
|
1529
1827
|
}, {
|
|
1828
|
+
type: XERC20Type.Velo;
|
|
1530
1829
|
bufferCap?: string | undefined;
|
|
1531
1830
|
rateLimitPerSecond?: string | undefined;
|
|
1532
|
-
}
|
|
1831
|
+
}>, z.ZodObject<{
|
|
1832
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
1833
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
1834
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
1835
|
+
}, "strip", z.ZodTypeAny, {
|
|
1836
|
+
type: XERC20Type.Standard;
|
|
1837
|
+
mint?: string | undefined;
|
|
1838
|
+
burn?: string | undefined;
|
|
1839
|
+
}, {
|
|
1840
|
+
type: XERC20Type.Standard;
|
|
1841
|
+
mint?: string | undefined;
|
|
1842
|
+
burn?: string | undefined;
|
|
1843
|
+
}>]>;
|
|
1533
1844
|
}, "strip", z.ZodTypeAny, {
|
|
1534
1845
|
lockbox: string;
|
|
1535
1846
|
limits: {
|
|
1847
|
+
type: XERC20Type.Velo;
|
|
1536
1848
|
bufferCap?: string | undefined;
|
|
1537
1849
|
rateLimitPerSecond?: string | undefined;
|
|
1850
|
+
} | {
|
|
1851
|
+
type: XERC20Type.Standard;
|
|
1852
|
+
mint?: string | undefined;
|
|
1853
|
+
burn?: string | undefined;
|
|
1538
1854
|
};
|
|
1539
1855
|
}, {
|
|
1540
1856
|
lockbox: string;
|
|
1541
1857
|
limits: {
|
|
1858
|
+
type: XERC20Type.Velo;
|
|
1542
1859
|
bufferCap?: string | undefined;
|
|
1543
1860
|
rateLimitPerSecond?: string | undefined;
|
|
1861
|
+
} | {
|
|
1862
|
+
type: XERC20Type.Standard;
|
|
1863
|
+
mint?: string | undefined;
|
|
1864
|
+
burn?: string | undefined;
|
|
1544
1865
|
};
|
|
1545
1866
|
}>, "many">>;
|
|
1546
|
-
warpRouteLimits: z.ZodObject<{
|
|
1867
|
+
warpRouteLimits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
1868
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
1547
1869
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
1548
1870
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
1549
1871
|
}, "strip", z.ZodTypeAny, {
|
|
1872
|
+
type: XERC20Type.Velo;
|
|
1550
1873
|
bufferCap?: string | undefined;
|
|
1551
1874
|
rateLimitPerSecond?: string | undefined;
|
|
1552
1875
|
}, {
|
|
1876
|
+
type: XERC20Type.Velo;
|
|
1553
1877
|
bufferCap?: string | undefined;
|
|
1554
1878
|
rateLimitPerSecond?: string | undefined;
|
|
1555
|
-
}
|
|
1879
|
+
}>, z.ZodObject<{
|
|
1880
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
1881
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
1882
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
1883
|
+
}, "strip", z.ZodTypeAny, {
|
|
1884
|
+
type: XERC20Type.Standard;
|
|
1885
|
+
mint?: string | undefined;
|
|
1886
|
+
burn?: string | undefined;
|
|
1887
|
+
}, {
|
|
1888
|
+
type: XERC20Type.Standard;
|
|
1889
|
+
mint?: string | undefined;
|
|
1890
|
+
burn?: string | undefined;
|
|
1891
|
+
}>]>;
|
|
1556
1892
|
}, "strip", z.ZodTypeAny, {
|
|
1557
1893
|
warpRouteLimits: {
|
|
1894
|
+
type: XERC20Type.Velo;
|
|
1558
1895
|
bufferCap?: string | undefined;
|
|
1559
1896
|
rateLimitPerSecond?: string | undefined;
|
|
1897
|
+
} | {
|
|
1898
|
+
type: XERC20Type.Standard;
|
|
1899
|
+
mint?: string | undefined;
|
|
1900
|
+
burn?: string | undefined;
|
|
1560
1901
|
};
|
|
1561
1902
|
extraBridges?: {
|
|
1562
1903
|
lockbox: string;
|
|
1563
1904
|
limits: {
|
|
1905
|
+
type: XERC20Type.Velo;
|
|
1564
1906
|
bufferCap?: string | undefined;
|
|
1565
1907
|
rateLimitPerSecond?: string | undefined;
|
|
1908
|
+
} | {
|
|
1909
|
+
type: XERC20Type.Standard;
|
|
1910
|
+
mint?: string | undefined;
|
|
1911
|
+
burn?: string | undefined;
|
|
1566
1912
|
};
|
|
1567
1913
|
}[] | undefined;
|
|
1568
1914
|
}, {
|
|
1569
1915
|
warpRouteLimits: {
|
|
1916
|
+
type: XERC20Type.Velo;
|
|
1570
1917
|
bufferCap?: string | undefined;
|
|
1571
1918
|
rateLimitPerSecond?: string | undefined;
|
|
1919
|
+
} | {
|
|
1920
|
+
type: XERC20Type.Standard;
|
|
1921
|
+
mint?: string | undefined;
|
|
1922
|
+
burn?: string | undefined;
|
|
1572
1923
|
};
|
|
1573
1924
|
extraBridges?: {
|
|
1574
1925
|
lockbox: string;
|
|
1575
1926
|
limits: {
|
|
1927
|
+
type: XERC20Type.Velo;
|
|
1576
1928
|
bufferCap?: string | undefined;
|
|
1577
1929
|
rateLimitPerSecond?: string | undefined;
|
|
1930
|
+
} | {
|
|
1931
|
+
type: XERC20Type.Standard;
|
|
1932
|
+
mint?: string | undefined;
|
|
1933
|
+
burn?: string | undefined;
|
|
1578
1934
|
};
|
|
1579
1935
|
}[] | undefined;
|
|
1580
1936
|
}>>;
|
|
@@ -1594,14 +1950,24 @@ export declare const HypTokenRouterConfigSchema: z.ZodIntersection<z.ZodIntersec
|
|
|
1594
1950
|
allowedRebalancers?: string[] | undefined;
|
|
1595
1951
|
xERC20?: {
|
|
1596
1952
|
warpRouteLimits: {
|
|
1953
|
+
type: XERC20Type.Velo;
|
|
1597
1954
|
bufferCap?: string | undefined;
|
|
1598
1955
|
rateLimitPerSecond?: string | undefined;
|
|
1956
|
+
} | {
|
|
1957
|
+
type: XERC20Type.Standard;
|
|
1958
|
+
mint?: string | undefined;
|
|
1959
|
+
burn?: string | undefined;
|
|
1599
1960
|
};
|
|
1600
1961
|
extraBridges?: {
|
|
1601
1962
|
lockbox: string;
|
|
1602
1963
|
limits: {
|
|
1964
|
+
type: XERC20Type.Velo;
|
|
1603
1965
|
bufferCap?: string | undefined;
|
|
1604
1966
|
rateLimitPerSecond?: string | undefined;
|
|
1967
|
+
} | {
|
|
1968
|
+
type: XERC20Type.Standard;
|
|
1969
|
+
mint?: string | undefined;
|
|
1970
|
+
burn?: string | undefined;
|
|
1605
1971
|
};
|
|
1606
1972
|
}[] | undefined;
|
|
1607
1973
|
} | undefined;
|
|
@@ -1621,14 +1987,24 @@ export declare const HypTokenRouterConfigSchema: z.ZodIntersection<z.ZodIntersec
|
|
|
1621
1987
|
allowedRebalancers?: string[] | undefined;
|
|
1622
1988
|
xERC20?: {
|
|
1623
1989
|
warpRouteLimits: {
|
|
1990
|
+
type: XERC20Type.Velo;
|
|
1624
1991
|
bufferCap?: string | undefined;
|
|
1625
1992
|
rateLimitPerSecond?: string | undefined;
|
|
1993
|
+
} | {
|
|
1994
|
+
type: XERC20Type.Standard;
|
|
1995
|
+
mint?: string | undefined;
|
|
1996
|
+
burn?: string | undefined;
|
|
1626
1997
|
};
|
|
1627
1998
|
extraBridges?: {
|
|
1628
1999
|
lockbox: string;
|
|
1629
2000
|
limits: {
|
|
2001
|
+
type: XERC20Type.Velo;
|
|
1630
2002
|
bufferCap?: string | undefined;
|
|
1631
2003
|
rateLimitPerSecond?: string | undefined;
|
|
2004
|
+
} | {
|
|
2005
|
+
type: XERC20Type.Standard;
|
|
2006
|
+
mint?: string | undefined;
|
|
2007
|
+
burn?: string | undefined;
|
|
1632
2008
|
};
|
|
1633
2009
|
}[] | undefined;
|
|
1634
2010
|
} | undefined;
|
|
@@ -2532,61 +2908,121 @@ export declare const HypTokenRouterConfigMailboxOptionalSchema: z.ZodIntersectio
|
|
|
2532
2908
|
xERC20: z.ZodOptional<z.ZodObject<{
|
|
2533
2909
|
extraBridges: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
2534
2910
|
lockbox: z.ZodString;
|
|
2535
|
-
limits: z.ZodObject<{
|
|
2911
|
+
limits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
2912
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
2536
2913
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
2537
2914
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
2538
2915
|
}, "strip", z.ZodTypeAny, {
|
|
2916
|
+
type: XERC20Type.Velo;
|
|
2539
2917
|
bufferCap?: string | undefined;
|
|
2540
2918
|
rateLimitPerSecond?: string | undefined;
|
|
2541
2919
|
}, {
|
|
2920
|
+
type: XERC20Type.Velo;
|
|
2542
2921
|
bufferCap?: string | undefined;
|
|
2543
2922
|
rateLimitPerSecond?: string | undefined;
|
|
2544
|
-
}
|
|
2923
|
+
}>, z.ZodObject<{
|
|
2924
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
2925
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
2926
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
2927
|
+
}, "strip", z.ZodTypeAny, {
|
|
2928
|
+
type: XERC20Type.Standard;
|
|
2929
|
+
mint?: string | undefined;
|
|
2930
|
+
burn?: string | undefined;
|
|
2931
|
+
}, {
|
|
2932
|
+
type: XERC20Type.Standard;
|
|
2933
|
+
mint?: string | undefined;
|
|
2934
|
+
burn?: string | undefined;
|
|
2935
|
+
}>]>;
|
|
2545
2936
|
}, "strip", z.ZodTypeAny, {
|
|
2546
2937
|
lockbox: string;
|
|
2547
2938
|
limits: {
|
|
2939
|
+
type: XERC20Type.Velo;
|
|
2548
2940
|
bufferCap?: string | undefined;
|
|
2549
2941
|
rateLimitPerSecond?: string | undefined;
|
|
2942
|
+
} | {
|
|
2943
|
+
type: XERC20Type.Standard;
|
|
2944
|
+
mint?: string | undefined;
|
|
2945
|
+
burn?: string | undefined;
|
|
2550
2946
|
};
|
|
2551
2947
|
}, {
|
|
2552
2948
|
lockbox: string;
|
|
2553
2949
|
limits: {
|
|
2950
|
+
type: XERC20Type.Velo;
|
|
2554
2951
|
bufferCap?: string | undefined;
|
|
2555
2952
|
rateLimitPerSecond?: string | undefined;
|
|
2953
|
+
} | {
|
|
2954
|
+
type: XERC20Type.Standard;
|
|
2955
|
+
mint?: string | undefined;
|
|
2956
|
+
burn?: string | undefined;
|
|
2556
2957
|
};
|
|
2557
2958
|
}>, "many">>;
|
|
2558
|
-
warpRouteLimits: z.ZodObject<{
|
|
2959
|
+
warpRouteLimits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
2960
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
2559
2961
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
2560
2962
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
2561
2963
|
}, "strip", z.ZodTypeAny, {
|
|
2964
|
+
type: XERC20Type.Velo;
|
|
2562
2965
|
bufferCap?: string | undefined;
|
|
2563
2966
|
rateLimitPerSecond?: string | undefined;
|
|
2564
2967
|
}, {
|
|
2968
|
+
type: XERC20Type.Velo;
|
|
2565
2969
|
bufferCap?: string | undefined;
|
|
2566
2970
|
rateLimitPerSecond?: string | undefined;
|
|
2567
|
-
}
|
|
2971
|
+
}>, z.ZodObject<{
|
|
2972
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
2973
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
2974
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
2975
|
+
}, "strip", z.ZodTypeAny, {
|
|
2976
|
+
type: XERC20Type.Standard;
|
|
2977
|
+
mint?: string | undefined;
|
|
2978
|
+
burn?: string | undefined;
|
|
2979
|
+
}, {
|
|
2980
|
+
type: XERC20Type.Standard;
|
|
2981
|
+
mint?: string | undefined;
|
|
2982
|
+
burn?: string | undefined;
|
|
2983
|
+
}>]>;
|
|
2568
2984
|
}, "strip", z.ZodTypeAny, {
|
|
2569
2985
|
warpRouteLimits: {
|
|
2986
|
+
type: XERC20Type.Velo;
|
|
2570
2987
|
bufferCap?: string | undefined;
|
|
2571
2988
|
rateLimitPerSecond?: string | undefined;
|
|
2989
|
+
} | {
|
|
2990
|
+
type: XERC20Type.Standard;
|
|
2991
|
+
mint?: string | undefined;
|
|
2992
|
+
burn?: string | undefined;
|
|
2572
2993
|
};
|
|
2573
2994
|
extraBridges?: {
|
|
2574
2995
|
lockbox: string;
|
|
2575
2996
|
limits: {
|
|
2997
|
+
type: XERC20Type.Velo;
|
|
2576
2998
|
bufferCap?: string | undefined;
|
|
2577
2999
|
rateLimitPerSecond?: string | undefined;
|
|
3000
|
+
} | {
|
|
3001
|
+
type: XERC20Type.Standard;
|
|
3002
|
+
mint?: string | undefined;
|
|
3003
|
+
burn?: string | undefined;
|
|
2578
3004
|
};
|
|
2579
3005
|
}[] | undefined;
|
|
2580
3006
|
}, {
|
|
2581
3007
|
warpRouteLimits: {
|
|
3008
|
+
type: XERC20Type.Velo;
|
|
2582
3009
|
bufferCap?: string | undefined;
|
|
2583
3010
|
rateLimitPerSecond?: string | undefined;
|
|
3011
|
+
} | {
|
|
3012
|
+
type: XERC20Type.Standard;
|
|
3013
|
+
mint?: string | undefined;
|
|
3014
|
+
burn?: string | undefined;
|
|
2584
3015
|
};
|
|
2585
3016
|
extraBridges?: {
|
|
2586
3017
|
lockbox: string;
|
|
2587
3018
|
limits: {
|
|
3019
|
+
type: XERC20Type.Velo;
|
|
2588
3020
|
bufferCap?: string | undefined;
|
|
2589
3021
|
rateLimitPerSecond?: string | undefined;
|
|
3022
|
+
} | {
|
|
3023
|
+
type: XERC20Type.Standard;
|
|
3024
|
+
mint?: string | undefined;
|
|
3025
|
+
burn?: string | undefined;
|
|
2590
3026
|
};
|
|
2591
3027
|
}[] | undefined;
|
|
2592
3028
|
}>>;
|
|
@@ -2606,14 +3042,24 @@ export declare const HypTokenRouterConfigMailboxOptionalSchema: z.ZodIntersectio
|
|
|
2606
3042
|
allowedRebalancers?: string[] | undefined;
|
|
2607
3043
|
xERC20?: {
|
|
2608
3044
|
warpRouteLimits: {
|
|
3045
|
+
type: XERC20Type.Velo;
|
|
2609
3046
|
bufferCap?: string | undefined;
|
|
2610
3047
|
rateLimitPerSecond?: string | undefined;
|
|
3048
|
+
} | {
|
|
3049
|
+
type: XERC20Type.Standard;
|
|
3050
|
+
mint?: string | undefined;
|
|
3051
|
+
burn?: string | undefined;
|
|
2611
3052
|
};
|
|
2612
3053
|
extraBridges?: {
|
|
2613
3054
|
lockbox: string;
|
|
2614
3055
|
limits: {
|
|
3056
|
+
type: XERC20Type.Velo;
|
|
2615
3057
|
bufferCap?: string | undefined;
|
|
2616
3058
|
rateLimitPerSecond?: string | undefined;
|
|
3059
|
+
} | {
|
|
3060
|
+
type: XERC20Type.Standard;
|
|
3061
|
+
mint?: string | undefined;
|
|
3062
|
+
burn?: string | undefined;
|
|
2617
3063
|
};
|
|
2618
3064
|
}[] | undefined;
|
|
2619
3065
|
} | undefined;
|
|
@@ -2633,14 +3079,24 @@ export declare const HypTokenRouterConfigMailboxOptionalSchema: z.ZodIntersectio
|
|
|
2633
3079
|
allowedRebalancers?: string[] | undefined;
|
|
2634
3080
|
xERC20?: {
|
|
2635
3081
|
warpRouteLimits: {
|
|
3082
|
+
type: XERC20Type.Velo;
|
|
2636
3083
|
bufferCap?: string | undefined;
|
|
2637
3084
|
rateLimitPerSecond?: string | undefined;
|
|
3085
|
+
} | {
|
|
3086
|
+
type: XERC20Type.Standard;
|
|
3087
|
+
mint?: string | undefined;
|
|
3088
|
+
burn?: string | undefined;
|
|
2638
3089
|
};
|
|
2639
3090
|
extraBridges?: {
|
|
2640
3091
|
lockbox: string;
|
|
2641
3092
|
limits: {
|
|
3093
|
+
type: XERC20Type.Velo;
|
|
2642
3094
|
bufferCap?: string | undefined;
|
|
2643
3095
|
rateLimitPerSecond?: string | undefined;
|
|
3096
|
+
} | {
|
|
3097
|
+
type: XERC20Type.Standard;
|
|
3098
|
+
mint?: string | undefined;
|
|
3099
|
+
burn?: string | undefined;
|
|
2644
3100
|
};
|
|
2645
3101
|
}[] | undefined;
|
|
2646
3102
|
} | undefined;
|
|
@@ -3540,61 +3996,121 @@ export declare const WarpRouteDeployConfigSchema: z.ZodEffects<z.ZodEffects<z.Zo
|
|
|
3540
3996
|
xERC20: z.ZodOptional<z.ZodObject<{
|
|
3541
3997
|
extraBridges: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
3542
3998
|
lockbox: z.ZodString;
|
|
3543
|
-
limits: z.ZodObject<{
|
|
3999
|
+
limits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
4000
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
3544
4001
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
3545
4002
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
3546
4003
|
}, "strip", z.ZodTypeAny, {
|
|
4004
|
+
type: XERC20Type.Velo;
|
|
3547
4005
|
bufferCap?: string | undefined;
|
|
3548
4006
|
rateLimitPerSecond?: string | undefined;
|
|
3549
4007
|
}, {
|
|
4008
|
+
type: XERC20Type.Velo;
|
|
3550
4009
|
bufferCap?: string | undefined;
|
|
3551
4010
|
rateLimitPerSecond?: string | undefined;
|
|
3552
|
-
}
|
|
4011
|
+
}>, z.ZodObject<{
|
|
4012
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
4013
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
4014
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
4015
|
+
}, "strip", z.ZodTypeAny, {
|
|
4016
|
+
type: XERC20Type.Standard;
|
|
4017
|
+
mint?: string | undefined;
|
|
4018
|
+
burn?: string | undefined;
|
|
4019
|
+
}, {
|
|
4020
|
+
type: XERC20Type.Standard;
|
|
4021
|
+
mint?: string | undefined;
|
|
4022
|
+
burn?: string | undefined;
|
|
4023
|
+
}>]>;
|
|
3553
4024
|
}, "strip", z.ZodTypeAny, {
|
|
3554
4025
|
lockbox: string;
|
|
3555
4026
|
limits: {
|
|
4027
|
+
type: XERC20Type.Velo;
|
|
3556
4028
|
bufferCap?: string | undefined;
|
|
3557
4029
|
rateLimitPerSecond?: string | undefined;
|
|
4030
|
+
} | {
|
|
4031
|
+
type: XERC20Type.Standard;
|
|
4032
|
+
mint?: string | undefined;
|
|
4033
|
+
burn?: string | undefined;
|
|
3558
4034
|
};
|
|
3559
4035
|
}, {
|
|
3560
4036
|
lockbox: string;
|
|
3561
4037
|
limits: {
|
|
4038
|
+
type: XERC20Type.Velo;
|
|
3562
4039
|
bufferCap?: string | undefined;
|
|
3563
4040
|
rateLimitPerSecond?: string | undefined;
|
|
4041
|
+
} | {
|
|
4042
|
+
type: XERC20Type.Standard;
|
|
4043
|
+
mint?: string | undefined;
|
|
4044
|
+
burn?: string | undefined;
|
|
3564
4045
|
};
|
|
3565
4046
|
}>, "many">>;
|
|
3566
|
-
warpRouteLimits: z.ZodObject<{
|
|
4047
|
+
warpRouteLimits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
4048
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
3567
4049
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
3568
4050
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
3569
4051
|
}, "strip", z.ZodTypeAny, {
|
|
4052
|
+
type: XERC20Type.Velo;
|
|
3570
4053
|
bufferCap?: string | undefined;
|
|
3571
4054
|
rateLimitPerSecond?: string | undefined;
|
|
3572
4055
|
}, {
|
|
4056
|
+
type: XERC20Type.Velo;
|
|
3573
4057
|
bufferCap?: string | undefined;
|
|
3574
4058
|
rateLimitPerSecond?: string | undefined;
|
|
3575
|
-
}
|
|
4059
|
+
}>, z.ZodObject<{
|
|
4060
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
4061
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
4062
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
4063
|
+
}, "strip", z.ZodTypeAny, {
|
|
4064
|
+
type: XERC20Type.Standard;
|
|
4065
|
+
mint?: string | undefined;
|
|
4066
|
+
burn?: string | undefined;
|
|
4067
|
+
}, {
|
|
4068
|
+
type: XERC20Type.Standard;
|
|
4069
|
+
mint?: string | undefined;
|
|
4070
|
+
burn?: string | undefined;
|
|
4071
|
+
}>]>;
|
|
3576
4072
|
}, "strip", z.ZodTypeAny, {
|
|
3577
4073
|
warpRouteLimits: {
|
|
4074
|
+
type: XERC20Type.Velo;
|
|
3578
4075
|
bufferCap?: string | undefined;
|
|
3579
4076
|
rateLimitPerSecond?: string | undefined;
|
|
4077
|
+
} | {
|
|
4078
|
+
type: XERC20Type.Standard;
|
|
4079
|
+
mint?: string | undefined;
|
|
4080
|
+
burn?: string | undefined;
|
|
3580
4081
|
};
|
|
3581
4082
|
extraBridges?: {
|
|
3582
4083
|
lockbox: string;
|
|
3583
4084
|
limits: {
|
|
4085
|
+
type: XERC20Type.Velo;
|
|
3584
4086
|
bufferCap?: string | undefined;
|
|
3585
4087
|
rateLimitPerSecond?: string | undefined;
|
|
4088
|
+
} | {
|
|
4089
|
+
type: XERC20Type.Standard;
|
|
4090
|
+
mint?: string | undefined;
|
|
4091
|
+
burn?: string | undefined;
|
|
3586
4092
|
};
|
|
3587
4093
|
}[] | undefined;
|
|
3588
4094
|
}, {
|
|
3589
4095
|
warpRouteLimits: {
|
|
4096
|
+
type: XERC20Type.Velo;
|
|
3590
4097
|
bufferCap?: string | undefined;
|
|
3591
4098
|
rateLimitPerSecond?: string | undefined;
|
|
4099
|
+
} | {
|
|
4100
|
+
type: XERC20Type.Standard;
|
|
4101
|
+
mint?: string | undefined;
|
|
4102
|
+
burn?: string | undefined;
|
|
3592
4103
|
};
|
|
3593
4104
|
extraBridges?: {
|
|
3594
4105
|
lockbox: string;
|
|
3595
4106
|
limits: {
|
|
4107
|
+
type: XERC20Type.Velo;
|
|
3596
4108
|
bufferCap?: string | undefined;
|
|
3597
4109
|
rateLimitPerSecond?: string | undefined;
|
|
4110
|
+
} | {
|
|
4111
|
+
type: XERC20Type.Standard;
|
|
4112
|
+
mint?: string | undefined;
|
|
4113
|
+
burn?: string | undefined;
|
|
3598
4114
|
};
|
|
3599
4115
|
}[] | undefined;
|
|
3600
4116
|
}>>;
|
|
@@ -3614,14 +4130,24 @@ export declare const WarpRouteDeployConfigSchema: z.ZodEffects<z.ZodEffects<z.Zo
|
|
|
3614
4130
|
allowedRebalancers?: string[] | undefined;
|
|
3615
4131
|
xERC20?: {
|
|
3616
4132
|
warpRouteLimits: {
|
|
4133
|
+
type: XERC20Type.Velo;
|
|
3617
4134
|
bufferCap?: string | undefined;
|
|
3618
4135
|
rateLimitPerSecond?: string | undefined;
|
|
4136
|
+
} | {
|
|
4137
|
+
type: XERC20Type.Standard;
|
|
4138
|
+
mint?: string | undefined;
|
|
4139
|
+
burn?: string | undefined;
|
|
3619
4140
|
};
|
|
3620
4141
|
extraBridges?: {
|
|
3621
4142
|
lockbox: string;
|
|
3622
4143
|
limits: {
|
|
4144
|
+
type: XERC20Type.Velo;
|
|
3623
4145
|
bufferCap?: string | undefined;
|
|
3624
4146
|
rateLimitPerSecond?: string | undefined;
|
|
4147
|
+
} | {
|
|
4148
|
+
type: XERC20Type.Standard;
|
|
4149
|
+
mint?: string | undefined;
|
|
4150
|
+
burn?: string | undefined;
|
|
3625
4151
|
};
|
|
3626
4152
|
}[] | undefined;
|
|
3627
4153
|
} | undefined;
|
|
@@ -3641,14 +4167,24 @@ export declare const WarpRouteDeployConfigSchema: z.ZodEffects<z.ZodEffects<z.Zo
|
|
|
3641
4167
|
allowedRebalancers?: string[] | undefined;
|
|
3642
4168
|
xERC20?: {
|
|
3643
4169
|
warpRouteLimits: {
|
|
4170
|
+
type: XERC20Type.Velo;
|
|
3644
4171
|
bufferCap?: string | undefined;
|
|
3645
4172
|
rateLimitPerSecond?: string | undefined;
|
|
4173
|
+
} | {
|
|
4174
|
+
type: XERC20Type.Standard;
|
|
4175
|
+
mint?: string | undefined;
|
|
4176
|
+
burn?: string | undefined;
|
|
3646
4177
|
};
|
|
3647
4178
|
extraBridges?: {
|
|
3648
4179
|
lockbox: string;
|
|
3649
4180
|
limits: {
|
|
4181
|
+
type: XERC20Type.Velo;
|
|
3650
4182
|
bufferCap?: string | undefined;
|
|
3651
4183
|
rateLimitPerSecond?: string | undefined;
|
|
4184
|
+
} | {
|
|
4185
|
+
type: XERC20Type.Standard;
|
|
4186
|
+
mint?: string | undefined;
|
|
4187
|
+
burn?: string | undefined;
|
|
3652
4188
|
};
|
|
3653
4189
|
}[] | undefined;
|
|
3654
4190
|
} | undefined;
|
|
@@ -4399,14 +4935,24 @@ export declare const WarpRouteDeployConfigSchema: z.ZodEffects<z.ZodEffects<z.Zo
|
|
|
4399
4935
|
allowedRebalancers?: string[] | undefined;
|
|
4400
4936
|
xERC20?: {
|
|
4401
4937
|
warpRouteLimits: {
|
|
4938
|
+
type: XERC20Type.Velo;
|
|
4402
4939
|
bufferCap?: string | undefined;
|
|
4403
4940
|
rateLimitPerSecond?: string | undefined;
|
|
4941
|
+
} | {
|
|
4942
|
+
type: XERC20Type.Standard;
|
|
4943
|
+
mint?: string | undefined;
|
|
4944
|
+
burn?: string | undefined;
|
|
4404
4945
|
};
|
|
4405
4946
|
extraBridges?: {
|
|
4406
4947
|
lockbox: string;
|
|
4407
4948
|
limits: {
|
|
4949
|
+
type: XERC20Type.Velo;
|
|
4408
4950
|
bufferCap?: string | undefined;
|
|
4409
4951
|
rateLimitPerSecond?: string | undefined;
|
|
4952
|
+
} | {
|
|
4953
|
+
type: XERC20Type.Standard;
|
|
4954
|
+
mint?: string | undefined;
|
|
4955
|
+
burn?: string | undefined;
|
|
4410
4956
|
};
|
|
4411
4957
|
}[] | undefined;
|
|
4412
4958
|
} | undefined;
|
|
@@ -4627,14 +5173,24 @@ export declare const WarpRouteDeployConfigSchema: z.ZodEffects<z.ZodEffects<z.Zo
|
|
|
4627
5173
|
allowedRebalancers?: string[] | undefined;
|
|
4628
5174
|
xERC20?: {
|
|
4629
5175
|
warpRouteLimits: {
|
|
5176
|
+
type: XERC20Type.Velo;
|
|
4630
5177
|
bufferCap?: string | undefined;
|
|
4631
5178
|
rateLimitPerSecond?: string | undefined;
|
|
5179
|
+
} | {
|
|
5180
|
+
type: XERC20Type.Standard;
|
|
5181
|
+
mint?: string | undefined;
|
|
5182
|
+
burn?: string | undefined;
|
|
4632
5183
|
};
|
|
4633
5184
|
extraBridges?: {
|
|
4634
5185
|
lockbox: string;
|
|
4635
5186
|
limits: {
|
|
5187
|
+
type: XERC20Type.Velo;
|
|
4636
5188
|
bufferCap?: string | undefined;
|
|
4637
5189
|
rateLimitPerSecond?: string | undefined;
|
|
5190
|
+
} | {
|
|
5191
|
+
type: XERC20Type.Standard;
|
|
5192
|
+
mint?: string | undefined;
|
|
5193
|
+
burn?: string | undefined;
|
|
4638
5194
|
};
|
|
4639
5195
|
}[] | undefined;
|
|
4640
5196
|
} | undefined;
|
|
@@ -4860,14 +5416,24 @@ export declare const WarpRouteDeployConfigSchema: z.ZodEffects<z.ZodEffects<z.Zo
|
|
|
4860
5416
|
allowedRebalancers?: string[] | undefined;
|
|
4861
5417
|
xERC20?: {
|
|
4862
5418
|
warpRouteLimits: {
|
|
5419
|
+
type: XERC20Type.Velo;
|
|
4863
5420
|
bufferCap?: string | undefined;
|
|
4864
5421
|
rateLimitPerSecond?: string | undefined;
|
|
5422
|
+
} | {
|
|
5423
|
+
type: XERC20Type.Standard;
|
|
5424
|
+
mint?: string | undefined;
|
|
5425
|
+
burn?: string | undefined;
|
|
4865
5426
|
};
|
|
4866
5427
|
extraBridges?: {
|
|
4867
5428
|
lockbox: string;
|
|
4868
5429
|
limits: {
|
|
5430
|
+
type: XERC20Type.Velo;
|
|
4869
5431
|
bufferCap?: string | undefined;
|
|
4870
5432
|
rateLimitPerSecond?: string | undefined;
|
|
5433
|
+
} | {
|
|
5434
|
+
type: XERC20Type.Standard;
|
|
5435
|
+
mint?: string | undefined;
|
|
5436
|
+
burn?: string | undefined;
|
|
4871
5437
|
};
|
|
4872
5438
|
}[] | undefined;
|
|
4873
5439
|
} | undefined;
|
|
@@ -5088,14 +5654,24 @@ export declare const WarpRouteDeployConfigSchema: z.ZodEffects<z.ZodEffects<z.Zo
|
|
|
5088
5654
|
allowedRebalancers?: string[] | undefined;
|
|
5089
5655
|
xERC20?: {
|
|
5090
5656
|
warpRouteLimits: {
|
|
5657
|
+
type: XERC20Type.Velo;
|
|
5091
5658
|
bufferCap?: string | undefined;
|
|
5092
5659
|
rateLimitPerSecond?: string | undefined;
|
|
5660
|
+
} | {
|
|
5661
|
+
type: XERC20Type.Standard;
|
|
5662
|
+
mint?: string | undefined;
|
|
5663
|
+
burn?: string | undefined;
|
|
5093
5664
|
};
|
|
5094
5665
|
extraBridges?: {
|
|
5095
5666
|
lockbox: string;
|
|
5096
5667
|
limits: {
|
|
5668
|
+
type: XERC20Type.Velo;
|
|
5097
5669
|
bufferCap?: string | undefined;
|
|
5098
5670
|
rateLimitPerSecond?: string | undefined;
|
|
5671
|
+
} | {
|
|
5672
|
+
type: XERC20Type.Standard;
|
|
5673
|
+
mint?: string | undefined;
|
|
5674
|
+
burn?: string | undefined;
|
|
5099
5675
|
};
|
|
5100
5676
|
}[] | undefined;
|
|
5101
5677
|
} | undefined;
|
|
@@ -5321,14 +5897,24 @@ export declare const WarpRouteDeployConfigSchema: z.ZodEffects<z.ZodEffects<z.Zo
|
|
|
5321
5897
|
allowedRebalancers?: string[] | undefined;
|
|
5322
5898
|
xERC20?: {
|
|
5323
5899
|
warpRouteLimits: {
|
|
5900
|
+
type: XERC20Type.Velo;
|
|
5324
5901
|
bufferCap?: string | undefined;
|
|
5325
5902
|
rateLimitPerSecond?: string | undefined;
|
|
5903
|
+
} | {
|
|
5904
|
+
type: XERC20Type.Standard;
|
|
5905
|
+
mint?: string | undefined;
|
|
5906
|
+
burn?: string | undefined;
|
|
5326
5907
|
};
|
|
5327
5908
|
extraBridges?: {
|
|
5328
5909
|
lockbox: string;
|
|
5329
5910
|
limits: {
|
|
5911
|
+
type: XERC20Type.Velo;
|
|
5330
5912
|
bufferCap?: string | undefined;
|
|
5331
5913
|
rateLimitPerSecond?: string | undefined;
|
|
5914
|
+
} | {
|
|
5915
|
+
type: XERC20Type.Standard;
|
|
5916
|
+
mint?: string | undefined;
|
|
5917
|
+
burn?: string | undefined;
|
|
5332
5918
|
};
|
|
5333
5919
|
}[] | undefined;
|
|
5334
5920
|
} | undefined;
|
|
@@ -5549,14 +6135,24 @@ export declare const WarpRouteDeployConfigSchema: z.ZodEffects<z.ZodEffects<z.Zo
|
|
|
5549
6135
|
allowedRebalancers?: string[] | undefined;
|
|
5550
6136
|
xERC20?: {
|
|
5551
6137
|
warpRouteLimits: {
|
|
6138
|
+
type: XERC20Type.Velo;
|
|
5552
6139
|
bufferCap?: string | undefined;
|
|
5553
6140
|
rateLimitPerSecond?: string | undefined;
|
|
6141
|
+
} | {
|
|
6142
|
+
type: XERC20Type.Standard;
|
|
6143
|
+
mint?: string | undefined;
|
|
6144
|
+
burn?: string | undefined;
|
|
5554
6145
|
};
|
|
5555
6146
|
extraBridges?: {
|
|
5556
6147
|
lockbox: string;
|
|
5557
6148
|
limits: {
|
|
6149
|
+
type: XERC20Type.Velo;
|
|
5558
6150
|
bufferCap?: string | undefined;
|
|
5559
6151
|
rateLimitPerSecond?: string | undefined;
|
|
6152
|
+
} | {
|
|
6153
|
+
type: XERC20Type.Standard;
|
|
6154
|
+
mint?: string | undefined;
|
|
6155
|
+
burn?: string | undefined;
|
|
5560
6156
|
};
|
|
5561
6157
|
}[] | undefined;
|
|
5562
6158
|
} | undefined;
|
|
@@ -5931,61 +6527,121 @@ export declare const WarpRouteDeployConfigMailboxRequiredSchema: z.ZodIntersecti
|
|
|
5931
6527
|
xERC20: z.ZodOptional<z.ZodObject<{
|
|
5932
6528
|
extraBridges: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
5933
6529
|
lockbox: z.ZodString;
|
|
5934
|
-
limits: z.ZodObject<{
|
|
6530
|
+
limits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
6531
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
5935
6532
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
5936
6533
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
5937
6534
|
}, "strip", z.ZodTypeAny, {
|
|
6535
|
+
type: XERC20Type.Velo;
|
|
5938
6536
|
bufferCap?: string | undefined;
|
|
5939
6537
|
rateLimitPerSecond?: string | undefined;
|
|
5940
6538
|
}, {
|
|
6539
|
+
type: XERC20Type.Velo;
|
|
5941
6540
|
bufferCap?: string | undefined;
|
|
5942
6541
|
rateLimitPerSecond?: string | undefined;
|
|
5943
|
-
}
|
|
6542
|
+
}>, z.ZodObject<{
|
|
6543
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
6544
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
6545
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
6546
|
+
}, "strip", z.ZodTypeAny, {
|
|
6547
|
+
type: XERC20Type.Standard;
|
|
6548
|
+
mint?: string | undefined;
|
|
6549
|
+
burn?: string | undefined;
|
|
6550
|
+
}, {
|
|
6551
|
+
type: XERC20Type.Standard;
|
|
6552
|
+
mint?: string | undefined;
|
|
6553
|
+
burn?: string | undefined;
|
|
6554
|
+
}>]>;
|
|
5944
6555
|
}, "strip", z.ZodTypeAny, {
|
|
5945
6556
|
lockbox: string;
|
|
5946
6557
|
limits: {
|
|
6558
|
+
type: XERC20Type.Velo;
|
|
5947
6559
|
bufferCap?: string | undefined;
|
|
5948
6560
|
rateLimitPerSecond?: string | undefined;
|
|
6561
|
+
} | {
|
|
6562
|
+
type: XERC20Type.Standard;
|
|
6563
|
+
mint?: string | undefined;
|
|
6564
|
+
burn?: string | undefined;
|
|
5949
6565
|
};
|
|
5950
6566
|
}, {
|
|
5951
6567
|
lockbox: string;
|
|
5952
6568
|
limits: {
|
|
6569
|
+
type: XERC20Type.Velo;
|
|
5953
6570
|
bufferCap?: string | undefined;
|
|
5954
6571
|
rateLimitPerSecond?: string | undefined;
|
|
6572
|
+
} | {
|
|
6573
|
+
type: XERC20Type.Standard;
|
|
6574
|
+
mint?: string | undefined;
|
|
6575
|
+
burn?: string | undefined;
|
|
5955
6576
|
};
|
|
5956
6577
|
}>, "many">>;
|
|
5957
|
-
warpRouteLimits: z.ZodObject<{
|
|
6578
|
+
warpRouteLimits: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
6579
|
+
type: z.ZodLiteral<XERC20Type.Velo>;
|
|
5958
6580
|
bufferCap: z.ZodOptional<z.ZodString>;
|
|
5959
6581
|
rateLimitPerSecond: z.ZodOptional<z.ZodString>;
|
|
5960
6582
|
}, "strip", z.ZodTypeAny, {
|
|
6583
|
+
type: XERC20Type.Velo;
|
|
5961
6584
|
bufferCap?: string | undefined;
|
|
5962
6585
|
rateLimitPerSecond?: string | undefined;
|
|
5963
6586
|
}, {
|
|
6587
|
+
type: XERC20Type.Velo;
|
|
5964
6588
|
bufferCap?: string | undefined;
|
|
5965
6589
|
rateLimitPerSecond?: string | undefined;
|
|
5966
|
-
}
|
|
6590
|
+
}>, z.ZodObject<{
|
|
6591
|
+
type: z.ZodLiteral<XERC20Type.Standard>;
|
|
6592
|
+
mint: z.ZodOptional<z.ZodString>;
|
|
6593
|
+
burn: z.ZodOptional<z.ZodString>;
|
|
6594
|
+
}, "strip", z.ZodTypeAny, {
|
|
6595
|
+
type: XERC20Type.Standard;
|
|
6596
|
+
mint?: string | undefined;
|
|
6597
|
+
burn?: string | undefined;
|
|
6598
|
+
}, {
|
|
6599
|
+
type: XERC20Type.Standard;
|
|
6600
|
+
mint?: string | undefined;
|
|
6601
|
+
burn?: string | undefined;
|
|
6602
|
+
}>]>;
|
|
5967
6603
|
}, "strip", z.ZodTypeAny, {
|
|
5968
6604
|
warpRouteLimits: {
|
|
6605
|
+
type: XERC20Type.Velo;
|
|
5969
6606
|
bufferCap?: string | undefined;
|
|
5970
6607
|
rateLimitPerSecond?: string | undefined;
|
|
6608
|
+
} | {
|
|
6609
|
+
type: XERC20Type.Standard;
|
|
6610
|
+
mint?: string | undefined;
|
|
6611
|
+
burn?: string | undefined;
|
|
5971
6612
|
};
|
|
5972
6613
|
extraBridges?: {
|
|
5973
6614
|
lockbox: string;
|
|
5974
6615
|
limits: {
|
|
6616
|
+
type: XERC20Type.Velo;
|
|
5975
6617
|
bufferCap?: string | undefined;
|
|
5976
6618
|
rateLimitPerSecond?: string | undefined;
|
|
6619
|
+
} | {
|
|
6620
|
+
type: XERC20Type.Standard;
|
|
6621
|
+
mint?: string | undefined;
|
|
6622
|
+
burn?: string | undefined;
|
|
5977
6623
|
};
|
|
5978
6624
|
}[] | undefined;
|
|
5979
6625
|
}, {
|
|
5980
6626
|
warpRouteLimits: {
|
|
6627
|
+
type: XERC20Type.Velo;
|
|
5981
6628
|
bufferCap?: string | undefined;
|
|
5982
6629
|
rateLimitPerSecond?: string | undefined;
|
|
6630
|
+
} | {
|
|
6631
|
+
type: XERC20Type.Standard;
|
|
6632
|
+
mint?: string | undefined;
|
|
6633
|
+
burn?: string | undefined;
|
|
5983
6634
|
};
|
|
5984
6635
|
extraBridges?: {
|
|
5985
6636
|
lockbox: string;
|
|
5986
6637
|
limits: {
|
|
6638
|
+
type: XERC20Type.Velo;
|
|
5987
6639
|
bufferCap?: string | undefined;
|
|
5988
6640
|
rateLimitPerSecond?: string | undefined;
|
|
6641
|
+
} | {
|
|
6642
|
+
type: XERC20Type.Standard;
|
|
6643
|
+
mint?: string | undefined;
|
|
6644
|
+
burn?: string | undefined;
|
|
5989
6645
|
};
|
|
5990
6646
|
}[] | undefined;
|
|
5991
6647
|
}>>;
|
|
@@ -6005,14 +6661,24 @@ export declare const WarpRouteDeployConfigMailboxRequiredSchema: z.ZodIntersecti
|
|
|
6005
6661
|
allowedRebalancers?: string[] | undefined;
|
|
6006
6662
|
xERC20?: {
|
|
6007
6663
|
warpRouteLimits: {
|
|
6664
|
+
type: XERC20Type.Velo;
|
|
6008
6665
|
bufferCap?: string | undefined;
|
|
6009
6666
|
rateLimitPerSecond?: string | undefined;
|
|
6667
|
+
} | {
|
|
6668
|
+
type: XERC20Type.Standard;
|
|
6669
|
+
mint?: string | undefined;
|
|
6670
|
+
burn?: string | undefined;
|
|
6010
6671
|
};
|
|
6011
6672
|
extraBridges?: {
|
|
6012
6673
|
lockbox: string;
|
|
6013
6674
|
limits: {
|
|
6675
|
+
type: XERC20Type.Velo;
|
|
6014
6676
|
bufferCap?: string | undefined;
|
|
6015
6677
|
rateLimitPerSecond?: string | undefined;
|
|
6678
|
+
} | {
|
|
6679
|
+
type: XERC20Type.Standard;
|
|
6680
|
+
mint?: string | undefined;
|
|
6681
|
+
burn?: string | undefined;
|
|
6016
6682
|
};
|
|
6017
6683
|
}[] | undefined;
|
|
6018
6684
|
} | undefined;
|
|
@@ -6032,14 +6698,24 @@ export declare const WarpRouteDeployConfigMailboxRequiredSchema: z.ZodIntersecti
|
|
|
6032
6698
|
allowedRebalancers?: string[] | undefined;
|
|
6033
6699
|
xERC20?: {
|
|
6034
6700
|
warpRouteLimits: {
|
|
6701
|
+
type: XERC20Type.Velo;
|
|
6035
6702
|
bufferCap?: string | undefined;
|
|
6036
6703
|
rateLimitPerSecond?: string | undefined;
|
|
6704
|
+
} | {
|
|
6705
|
+
type: XERC20Type.Standard;
|
|
6706
|
+
mint?: string | undefined;
|
|
6707
|
+
burn?: string | undefined;
|
|
6037
6708
|
};
|
|
6038
6709
|
extraBridges?: {
|
|
6039
6710
|
lockbox: string;
|
|
6040
6711
|
limits: {
|
|
6712
|
+
type: XERC20Type.Velo;
|
|
6041
6713
|
bufferCap?: string | undefined;
|
|
6042
6714
|
rateLimitPerSecond?: string | undefined;
|
|
6715
|
+
} | {
|
|
6716
|
+
type: XERC20Type.Standard;
|
|
6717
|
+
mint?: string | undefined;
|
|
6718
|
+
burn?: string | undefined;
|
|
6043
6719
|
};
|
|
6044
6720
|
}[] | undefined;
|
|
6045
6721
|
} | undefined;
|
|
@@ -6790,14 +7466,24 @@ export declare const WarpRouteDeployConfigMailboxRequiredSchema: z.ZodIntersecti
|
|
|
6790
7466
|
allowedRebalancers?: string[] | undefined;
|
|
6791
7467
|
xERC20?: {
|
|
6792
7468
|
warpRouteLimits: {
|
|
7469
|
+
type: XERC20Type.Velo;
|
|
6793
7470
|
bufferCap?: string | undefined;
|
|
6794
7471
|
rateLimitPerSecond?: string | undefined;
|
|
7472
|
+
} | {
|
|
7473
|
+
type: XERC20Type.Standard;
|
|
7474
|
+
mint?: string | undefined;
|
|
7475
|
+
burn?: string | undefined;
|
|
6795
7476
|
};
|
|
6796
7477
|
extraBridges?: {
|
|
6797
7478
|
lockbox: string;
|
|
6798
7479
|
limits: {
|
|
7480
|
+
type: XERC20Type.Velo;
|
|
6799
7481
|
bufferCap?: string | undefined;
|
|
6800
7482
|
rateLimitPerSecond?: string | undefined;
|
|
7483
|
+
} | {
|
|
7484
|
+
type: XERC20Type.Standard;
|
|
7485
|
+
mint?: string | undefined;
|
|
7486
|
+
burn?: string | undefined;
|
|
6801
7487
|
};
|
|
6802
7488
|
}[] | undefined;
|
|
6803
7489
|
} | undefined;
|
|
@@ -7018,14 +7704,24 @@ export declare const WarpRouteDeployConfigMailboxRequiredSchema: z.ZodIntersecti
|
|
|
7018
7704
|
allowedRebalancers?: string[] | undefined;
|
|
7019
7705
|
xERC20?: {
|
|
7020
7706
|
warpRouteLimits: {
|
|
7707
|
+
type: XERC20Type.Velo;
|
|
7021
7708
|
bufferCap?: string | undefined;
|
|
7022
7709
|
rateLimitPerSecond?: string | undefined;
|
|
7710
|
+
} | {
|
|
7711
|
+
type: XERC20Type.Standard;
|
|
7712
|
+
mint?: string | undefined;
|
|
7713
|
+
burn?: string | undefined;
|
|
7023
7714
|
};
|
|
7024
7715
|
extraBridges?: {
|
|
7025
7716
|
lockbox: string;
|
|
7026
7717
|
limits: {
|
|
7718
|
+
type: XERC20Type.Velo;
|
|
7027
7719
|
bufferCap?: string | undefined;
|
|
7028
7720
|
rateLimitPerSecond?: string | undefined;
|
|
7721
|
+
} | {
|
|
7722
|
+
type: XERC20Type.Standard;
|
|
7723
|
+
mint?: string | undefined;
|
|
7724
|
+
burn?: string | undefined;
|
|
7029
7725
|
};
|
|
7030
7726
|
}[] | undefined;
|
|
7031
7727
|
} | undefined;
|
|
@@ -7251,14 +7947,24 @@ export declare const WarpRouteDeployConfigMailboxRequiredSchema: z.ZodIntersecti
|
|
|
7251
7947
|
allowedRebalancers?: string[] | undefined;
|
|
7252
7948
|
xERC20?: {
|
|
7253
7949
|
warpRouteLimits: {
|
|
7950
|
+
type: XERC20Type.Velo;
|
|
7254
7951
|
bufferCap?: string | undefined;
|
|
7255
7952
|
rateLimitPerSecond?: string | undefined;
|
|
7953
|
+
} | {
|
|
7954
|
+
type: XERC20Type.Standard;
|
|
7955
|
+
mint?: string | undefined;
|
|
7956
|
+
burn?: string | undefined;
|
|
7256
7957
|
};
|
|
7257
7958
|
extraBridges?: {
|
|
7258
7959
|
lockbox: string;
|
|
7259
7960
|
limits: {
|
|
7961
|
+
type: XERC20Type.Velo;
|
|
7260
7962
|
bufferCap?: string | undefined;
|
|
7261
7963
|
rateLimitPerSecond?: string | undefined;
|
|
7964
|
+
} | {
|
|
7965
|
+
type: XERC20Type.Standard;
|
|
7966
|
+
mint?: string | undefined;
|
|
7967
|
+
burn?: string | undefined;
|
|
7262
7968
|
};
|
|
7263
7969
|
}[] | undefined;
|
|
7264
7970
|
} | undefined;
|
|
@@ -7479,14 +8185,24 @@ export declare const WarpRouteDeployConfigMailboxRequiredSchema: z.ZodIntersecti
|
|
|
7479
8185
|
allowedRebalancers?: string[] | undefined;
|
|
7480
8186
|
xERC20?: {
|
|
7481
8187
|
warpRouteLimits: {
|
|
8188
|
+
type: XERC20Type.Velo;
|
|
7482
8189
|
bufferCap?: string | undefined;
|
|
7483
8190
|
rateLimitPerSecond?: string | undefined;
|
|
8191
|
+
} | {
|
|
8192
|
+
type: XERC20Type.Standard;
|
|
8193
|
+
mint?: string | undefined;
|
|
8194
|
+
burn?: string | undefined;
|
|
7484
8195
|
};
|
|
7485
8196
|
extraBridges?: {
|
|
7486
8197
|
lockbox: string;
|
|
7487
8198
|
limits: {
|
|
8199
|
+
type: XERC20Type.Velo;
|
|
7488
8200
|
bufferCap?: string | undefined;
|
|
7489
8201
|
rateLimitPerSecond?: string | undefined;
|
|
8202
|
+
} | {
|
|
8203
|
+
type: XERC20Type.Standard;
|
|
8204
|
+
mint?: string | undefined;
|
|
8205
|
+
burn?: string | undefined;
|
|
7490
8206
|
};
|
|
7491
8207
|
}[] | undefined;
|
|
7492
8208
|
} | undefined;
|
|
@@ -7712,14 +8428,24 @@ export declare const WarpRouteDeployConfigMailboxRequiredSchema: z.ZodIntersecti
|
|
|
7712
8428
|
allowedRebalancers?: string[] | undefined;
|
|
7713
8429
|
xERC20?: {
|
|
7714
8430
|
warpRouteLimits: {
|
|
8431
|
+
type: XERC20Type.Velo;
|
|
7715
8432
|
bufferCap?: string | undefined;
|
|
7716
8433
|
rateLimitPerSecond?: string | undefined;
|
|
8434
|
+
} | {
|
|
8435
|
+
type: XERC20Type.Standard;
|
|
8436
|
+
mint?: string | undefined;
|
|
8437
|
+
burn?: string | undefined;
|
|
7717
8438
|
};
|
|
7718
8439
|
extraBridges?: {
|
|
7719
8440
|
lockbox: string;
|
|
7720
8441
|
limits: {
|
|
8442
|
+
type: XERC20Type.Velo;
|
|
7721
8443
|
bufferCap?: string | undefined;
|
|
7722
8444
|
rateLimitPerSecond?: string | undefined;
|
|
8445
|
+
} | {
|
|
8446
|
+
type: XERC20Type.Standard;
|
|
8447
|
+
mint?: string | undefined;
|
|
8448
|
+
burn?: string | undefined;
|
|
7723
8449
|
};
|
|
7724
8450
|
}[] | undefined;
|
|
7725
8451
|
} | undefined;
|
|
@@ -7940,14 +8666,24 @@ export declare const WarpRouteDeployConfigMailboxRequiredSchema: z.ZodIntersecti
|
|
|
7940
8666
|
allowedRebalancers?: string[] | undefined;
|
|
7941
8667
|
xERC20?: {
|
|
7942
8668
|
warpRouteLimits: {
|
|
8669
|
+
type: XERC20Type.Velo;
|
|
7943
8670
|
bufferCap?: string | undefined;
|
|
7944
8671
|
rateLimitPerSecond?: string | undefined;
|
|
8672
|
+
} | {
|
|
8673
|
+
type: XERC20Type.Standard;
|
|
8674
|
+
mint?: string | undefined;
|
|
8675
|
+
burn?: string | undefined;
|
|
7945
8676
|
};
|
|
7946
8677
|
extraBridges?: {
|
|
7947
8678
|
lockbox: string;
|
|
7948
8679
|
limits: {
|
|
8680
|
+
type: XERC20Type.Velo;
|
|
7949
8681
|
bufferCap?: string | undefined;
|
|
7950
8682
|
rateLimitPerSecond?: string | undefined;
|
|
8683
|
+
} | {
|
|
8684
|
+
type: XERC20Type.Standard;
|
|
8685
|
+
mint?: string | undefined;
|
|
8686
|
+
burn?: string | undefined;
|
|
7951
8687
|
};
|
|
7952
8688
|
}[] | undefined;
|
|
7953
8689
|
} | undefined;
|