@lifi/compose-spec 0.15.1 → 0.15.2
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/index.d.cts +242 -242
- package/dist/index.d.ts +242 -242
- package/package.json +11 -15
package/dist/index.d.cts
CHANGED
|
@@ -29,19 +29,19 @@ export declare const ResourceSchema: Schema.transform<Schema.Union<[Schema.Struc
|
|
|
29
29
|
token: Schema.refine<string, typeof Schema.String>;
|
|
30
30
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
31
31
|
}>]>, Schema.SchemaClass<{
|
|
32
|
-
readonly chainId: number;
|
|
33
32
|
readonly kind: "native";
|
|
33
|
+
readonly chainId: number;
|
|
34
34
|
} | {
|
|
35
|
+
readonly kind: "erc20";
|
|
35
36
|
readonly token: string;
|
|
36
37
|
readonly chainId: number;
|
|
37
|
-
readonly kind: "erc20";
|
|
38
38
|
}, {
|
|
39
|
-
readonly chainId: number;
|
|
40
39
|
readonly kind: "native";
|
|
40
|
+
readonly chainId: number;
|
|
41
41
|
} | {
|
|
42
|
+
readonly kind: "erc20";
|
|
42
43
|
readonly token: string;
|
|
43
44
|
readonly chainId: number;
|
|
44
|
-
readonly kind: "erc20";
|
|
45
45
|
}, never>>;
|
|
46
46
|
export declare const ResourceInputSchema: Schema.Struct<{
|
|
47
47
|
name: typeof Schema.String;
|
|
@@ -53,19 +53,19 @@ export declare const ResourceInputSchema: Schema.Struct<{
|
|
|
53
53
|
token: Schema.refine<string, typeof Schema.String>;
|
|
54
54
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
55
55
|
}>]>, Schema.SchemaClass<{
|
|
56
|
-
readonly chainId: number;
|
|
57
56
|
readonly kind: "native";
|
|
57
|
+
readonly chainId: number;
|
|
58
58
|
} | {
|
|
59
|
+
readonly kind: "erc20";
|
|
59
60
|
readonly token: string;
|
|
60
61
|
readonly chainId: number;
|
|
61
|
-
readonly kind: "erc20";
|
|
62
62
|
}, {
|
|
63
|
-
readonly chainId: number;
|
|
64
63
|
readonly kind: "native";
|
|
64
|
+
readonly chainId: number;
|
|
65
65
|
} | {
|
|
66
|
+
readonly kind: "erc20";
|
|
66
67
|
readonly token: string;
|
|
67
68
|
readonly chainId: number;
|
|
68
|
-
readonly kind: "erc20";
|
|
69
69
|
}, never>>;
|
|
70
70
|
}>;
|
|
71
71
|
export declare const HandleInputSchema: Schema.Struct<{
|
|
@@ -82,19 +82,19 @@ export declare const FlowInputSchema: Schema.Union<[Schema.Struct<{
|
|
|
82
82
|
token: Schema.refine<string, typeof Schema.String>;
|
|
83
83
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
84
84
|
}>]>, Schema.SchemaClass<{
|
|
85
|
-
readonly chainId: number;
|
|
86
85
|
readonly kind: "native";
|
|
86
|
+
readonly chainId: number;
|
|
87
87
|
} | {
|
|
88
|
+
readonly kind: "erc20";
|
|
88
89
|
readonly token: string;
|
|
89
90
|
readonly chainId: number;
|
|
90
|
-
readonly kind: "erc20";
|
|
91
91
|
}, {
|
|
92
|
-
readonly chainId: number;
|
|
93
92
|
readonly kind: "native";
|
|
93
|
+
readonly chainId: number;
|
|
94
94
|
} | {
|
|
95
|
+
readonly kind: "erc20";
|
|
95
96
|
readonly token: string;
|
|
96
97
|
readonly chainId: number;
|
|
97
|
-
readonly kind: "erc20";
|
|
98
98
|
}, never>>;
|
|
99
99
|
}>, Schema.Struct<{
|
|
100
100
|
name: typeof Schema.String;
|
|
@@ -157,19 +157,19 @@ export declare const EpilogueForwardSchema: Schema.Struct<{
|
|
|
157
157
|
token: Schema.refine<string, typeof Schema.String>;
|
|
158
158
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
159
159
|
}>]>, Schema.SchemaClass<{
|
|
160
|
-
readonly chainId: number;
|
|
161
160
|
readonly kind: "native";
|
|
161
|
+
readonly chainId: number;
|
|
162
162
|
} | {
|
|
163
|
+
readonly kind: "erc20";
|
|
163
164
|
readonly token: string;
|
|
164
165
|
readonly chainId: number;
|
|
165
|
-
readonly kind: "erc20";
|
|
166
166
|
}, {
|
|
167
|
-
readonly chainId: number;
|
|
168
167
|
readonly kind: "native";
|
|
168
|
+
readonly chainId: number;
|
|
169
169
|
} | {
|
|
170
|
+
readonly kind: "erc20";
|
|
170
171
|
readonly token: string;
|
|
171
172
|
readonly chainId: number;
|
|
172
|
-
readonly kind: "erc20";
|
|
173
173
|
}, never>>;
|
|
174
174
|
to: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Struct<{
|
|
175
175
|
$ref: Schema.filter<typeof Schema.String>;
|
|
@@ -185,19 +185,19 @@ export declare const EpilogueSchema: Schema.filter<Schema.Struct<{
|
|
|
185
185
|
token: Schema.refine<string, typeof Schema.String>;
|
|
186
186
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
187
187
|
}>]>, Schema.SchemaClass<{
|
|
188
|
-
readonly chainId: number;
|
|
189
188
|
readonly kind: "native";
|
|
189
|
+
readonly chainId: number;
|
|
190
190
|
} | {
|
|
191
|
+
readonly kind: "erc20";
|
|
191
192
|
readonly token: string;
|
|
192
193
|
readonly chainId: number;
|
|
193
|
-
readonly kind: "erc20";
|
|
194
194
|
}, {
|
|
195
|
-
readonly chainId: number;
|
|
196
195
|
readonly kind: "native";
|
|
196
|
+
readonly chainId: number;
|
|
197
197
|
} | {
|
|
198
|
+
readonly kind: "erc20";
|
|
198
199
|
readonly token: string;
|
|
199
200
|
readonly chainId: number;
|
|
200
|
-
readonly kind: "erc20";
|
|
201
201
|
}, never>>;
|
|
202
202
|
to: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Struct<{
|
|
203
203
|
$ref: Schema.filter<typeof Schema.String>;
|
|
@@ -221,19 +221,19 @@ export declare const FlowSchema: Schema.Struct<{
|
|
|
221
221
|
token: Schema.refine<string, typeof Schema.String>;
|
|
222
222
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
223
223
|
}>]>, Schema.SchemaClass<{
|
|
224
|
-
readonly chainId: number;
|
|
225
224
|
readonly kind: "native";
|
|
225
|
+
readonly chainId: number;
|
|
226
226
|
} | {
|
|
227
|
+
readonly kind: "erc20";
|
|
227
228
|
readonly token: string;
|
|
228
229
|
readonly chainId: number;
|
|
229
|
-
readonly kind: "erc20";
|
|
230
230
|
}, {
|
|
231
|
-
readonly chainId: number;
|
|
232
231
|
readonly kind: "native";
|
|
232
|
+
readonly chainId: number;
|
|
233
233
|
} | {
|
|
234
|
+
readonly kind: "erc20";
|
|
234
235
|
readonly token: string;
|
|
235
236
|
readonly chainId: number;
|
|
236
|
-
readonly kind: "erc20";
|
|
237
237
|
}, never>>;
|
|
238
238
|
}>, Schema.Struct<{
|
|
239
239
|
name: typeof Schema.String;
|
|
@@ -274,19 +274,19 @@ export declare const FlowSchema: Schema.Struct<{
|
|
|
274
274
|
token: Schema.refine<string, typeof Schema.String>;
|
|
275
275
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
276
276
|
}>]>, Schema.SchemaClass<{
|
|
277
|
-
readonly chainId: number;
|
|
278
277
|
readonly kind: "native";
|
|
278
|
+
readonly chainId: number;
|
|
279
279
|
} | {
|
|
280
|
+
readonly kind: "erc20";
|
|
280
281
|
readonly token: string;
|
|
281
282
|
readonly chainId: number;
|
|
282
|
-
readonly kind: "erc20";
|
|
283
283
|
}, {
|
|
284
|
-
readonly chainId: number;
|
|
285
284
|
readonly kind: "native";
|
|
285
|
+
readonly chainId: number;
|
|
286
286
|
} | {
|
|
287
|
+
readonly kind: "erc20";
|
|
287
288
|
readonly token: string;
|
|
288
289
|
readonly chainId: number;
|
|
289
|
-
readonly kind: "erc20";
|
|
290
290
|
}, never>>;
|
|
291
291
|
to: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Struct<{
|
|
292
292
|
$ref: Schema.filter<typeof Schema.String>;
|
|
@@ -320,10 +320,10 @@ export declare const ContinuationOutcomeSchema: Schema.transform<Schema.Schema<{
|
|
|
320
320
|
readonly destination: string;
|
|
321
321
|
readonly chainId: number;
|
|
322
322
|
}, {
|
|
323
|
-
readonly token: string;
|
|
324
|
-
readonly destination: string;
|
|
325
323
|
readonly chainId: number;
|
|
324
|
+
readonly destination: string;
|
|
326
325
|
readonly minAmount?: string | undefined;
|
|
326
|
+
readonly token: string;
|
|
327
327
|
}, never>, Schema.SchemaClass<{
|
|
328
328
|
readonly token: string;
|
|
329
329
|
readonly minAmount?: string | undefined;
|
|
@@ -341,10 +341,10 @@ export declare const CommittedOutcomeSchema: Schema.transform<Schema.Schema<{
|
|
|
341
341
|
readonly destination: string;
|
|
342
342
|
readonly chainId: number;
|
|
343
343
|
}, {
|
|
344
|
-
readonly token: string;
|
|
345
|
-
readonly minAmount: string;
|
|
346
|
-
readonly destination: string;
|
|
347
344
|
readonly chainId: number;
|
|
345
|
+
readonly destination: string;
|
|
346
|
+
readonly minAmount: string;
|
|
347
|
+
readonly token: string;
|
|
348
348
|
}, never>, Schema.SchemaClass<{
|
|
349
349
|
readonly token: string;
|
|
350
350
|
readonly minAmount: string;
|
|
@@ -363,10 +363,10 @@ export declare const ContinuationIntentSchema: Schema.Struct<{
|
|
|
363
363
|
readonly destination: string;
|
|
364
364
|
readonly chainId: number;
|
|
365
365
|
}, {
|
|
366
|
-
readonly token: string;
|
|
367
|
-
readonly destination: string;
|
|
368
366
|
readonly chainId: number;
|
|
367
|
+
readonly destination: string;
|
|
369
368
|
readonly minAmount?: string | undefined;
|
|
369
|
+
readonly token: string;
|
|
370
370
|
}, never>, Schema.SchemaClass<{
|
|
371
371
|
readonly token: string;
|
|
372
372
|
readonly minAmount?: string | undefined;
|
|
@@ -392,19 +392,19 @@ export declare const ContinuationIntentSchema: Schema.Struct<{
|
|
|
392
392
|
token: Schema.refine<string, typeof Schema.String>;
|
|
393
393
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
394
394
|
}>]>, Schema.SchemaClass<{
|
|
395
|
-
readonly chainId: number;
|
|
396
395
|
readonly kind: "native";
|
|
396
|
+
readonly chainId: number;
|
|
397
397
|
} | {
|
|
398
|
+
readonly kind: "erc20";
|
|
398
399
|
readonly token: string;
|
|
399
400
|
readonly chainId: number;
|
|
400
|
-
readonly kind: "erc20";
|
|
401
401
|
}, {
|
|
402
|
-
readonly chainId: number;
|
|
403
402
|
readonly kind: "native";
|
|
403
|
+
readonly chainId: number;
|
|
404
404
|
} | {
|
|
405
|
+
readonly kind: "erc20";
|
|
405
406
|
readonly token: string;
|
|
406
407
|
readonly chainId: number;
|
|
407
|
-
readonly kind: "erc20";
|
|
408
408
|
}, never>>;
|
|
409
409
|
}>, Schema.Struct<{
|
|
410
410
|
name: typeof Schema.String;
|
|
@@ -445,19 +445,19 @@ export declare const ContinuationIntentSchema: Schema.Struct<{
|
|
|
445
445
|
token: Schema.refine<string, typeof Schema.String>;
|
|
446
446
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
447
447
|
}>]>, Schema.SchemaClass<{
|
|
448
|
-
readonly chainId: number;
|
|
449
448
|
readonly kind: "native";
|
|
449
|
+
readonly chainId: number;
|
|
450
450
|
} | {
|
|
451
|
+
readonly kind: "erc20";
|
|
451
452
|
readonly token: string;
|
|
452
453
|
readonly chainId: number;
|
|
453
|
-
readonly kind: "erc20";
|
|
454
454
|
}, {
|
|
455
|
-
readonly chainId: number;
|
|
456
455
|
readonly kind: "native";
|
|
456
|
+
readonly chainId: number;
|
|
457
457
|
} | {
|
|
458
|
+
readonly kind: "erc20";
|
|
458
459
|
readonly token: string;
|
|
459
460
|
readonly chainId: number;
|
|
460
|
-
readonly kind: "erc20";
|
|
461
461
|
}, never>>;
|
|
462
462
|
to: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Struct<{
|
|
463
463
|
$ref: Schema.filter<typeof Schema.String>;
|
|
@@ -565,7 +565,7 @@ type AssertionSpec = typeof AssertionSpecSchema.Type;
|
|
|
565
565
|
type CallCheckSpec = typeof CallCheckSpecSchema.Type;
|
|
566
566
|
export declare const settledOutcome: <I extends {
|
|
567
567
|
readonly outcomes: readonly unknown[];
|
|
568
|
-
}>(intent: I) => I[
|
|
568
|
+
}>(intent: I) => I['outcomes'][number] | undefined;
|
|
569
569
|
//#endregion
|
|
570
570
|
//#region src/descriptor.d.ts
|
|
571
571
|
export declare const Bytes32HexSchema: Schema.filter<typeof Schema.String>;
|
|
@@ -589,42 +589,42 @@ export declare const AssertedPredicateSchema: Schema.transformOrFail<Schema.Unio
|
|
|
589
589
|
comparator: Schema.Literal<["gte", "eq", "lte"]>;
|
|
590
590
|
threshold: Schema.filter<typeof Schema.String>;
|
|
591
591
|
}>]>, Schema.SchemaClass<{
|
|
592
|
-
readonly
|
|
592
|
+
readonly kind: "erc20BalanceGte";
|
|
593
593
|
readonly chainId: number;
|
|
594
|
-
readonly kind: "nativeBalanceGte";
|
|
595
|
-
readonly owner: string;
|
|
596
|
-
} | {
|
|
597
594
|
readonly token: string;
|
|
595
|
+
readonly owner: string;
|
|
598
596
|
readonly minAmount: string;
|
|
597
|
+
} | {
|
|
598
|
+
readonly kind: "nativeBalanceGte";
|
|
599
599
|
readonly chainId: number;
|
|
600
|
-
readonly kind: "erc20BalanceGte";
|
|
601
600
|
readonly owner: string;
|
|
601
|
+
readonly minAmount: string;
|
|
602
602
|
} | {
|
|
603
|
-
readonly chainId: number;
|
|
604
603
|
readonly kind: "call";
|
|
604
|
+
readonly chainId: number;
|
|
605
605
|
readonly to: string;
|
|
606
606
|
readonly signature: string;
|
|
607
607
|
readonly args: readonly string[];
|
|
608
|
-
readonly comparator: "
|
|
608
|
+
readonly comparator: "eq" | "gte" | "lte";
|
|
609
609
|
readonly threshold: string;
|
|
610
610
|
}, {
|
|
611
|
-
readonly
|
|
611
|
+
readonly kind: "erc20BalanceGte";
|
|
612
612
|
readonly chainId: number;
|
|
613
|
-
readonly kind: "nativeBalanceGte";
|
|
614
|
-
readonly owner: string;
|
|
615
|
-
} | {
|
|
616
613
|
readonly token: string;
|
|
614
|
+
readonly owner: string;
|
|
617
615
|
readonly minAmount: string;
|
|
616
|
+
} | {
|
|
617
|
+
readonly kind: "nativeBalanceGte";
|
|
618
618
|
readonly chainId: number;
|
|
619
|
-
readonly kind: "erc20BalanceGte";
|
|
620
619
|
readonly owner: string;
|
|
620
|
+
readonly minAmount: string;
|
|
621
621
|
} | {
|
|
622
|
-
readonly chainId: number;
|
|
623
622
|
readonly kind: "call";
|
|
623
|
+
readonly chainId: number;
|
|
624
624
|
readonly to: string;
|
|
625
625
|
readonly signature: string;
|
|
626
626
|
readonly args: readonly string[];
|
|
627
|
-
readonly comparator: "
|
|
627
|
+
readonly comparator: "eq" | "gte" | "lte";
|
|
628
628
|
readonly threshold: string;
|
|
629
629
|
}, never>, never>;
|
|
630
630
|
export declare const VerificationDescriptorSchema: Schema.Struct<{
|
|
@@ -650,42 +650,42 @@ export declare const VerificationDescriptorSchema: Schema.Struct<{
|
|
|
650
650
|
comparator: Schema.Literal<["gte", "eq", "lte"]>;
|
|
651
651
|
threshold: Schema.filter<typeof Schema.String>;
|
|
652
652
|
}>]>, Schema.SchemaClass<{
|
|
653
|
-
readonly
|
|
653
|
+
readonly kind: "erc20BalanceGte";
|
|
654
654
|
readonly chainId: number;
|
|
655
|
-
readonly kind: "nativeBalanceGte";
|
|
656
|
-
readonly owner: string;
|
|
657
|
-
} | {
|
|
658
655
|
readonly token: string;
|
|
656
|
+
readonly owner: string;
|
|
659
657
|
readonly minAmount: string;
|
|
658
|
+
} | {
|
|
659
|
+
readonly kind: "nativeBalanceGte";
|
|
660
660
|
readonly chainId: number;
|
|
661
|
-
readonly kind: "erc20BalanceGte";
|
|
662
661
|
readonly owner: string;
|
|
662
|
+
readonly minAmount: string;
|
|
663
663
|
} | {
|
|
664
|
-
readonly chainId: number;
|
|
665
664
|
readonly kind: "call";
|
|
665
|
+
readonly chainId: number;
|
|
666
666
|
readonly to: string;
|
|
667
667
|
readonly signature: string;
|
|
668
668
|
readonly args: readonly string[];
|
|
669
|
-
readonly comparator: "
|
|
669
|
+
readonly comparator: "eq" | "gte" | "lte";
|
|
670
670
|
readonly threshold: string;
|
|
671
671
|
}, {
|
|
672
|
-
readonly
|
|
672
|
+
readonly kind: "erc20BalanceGte";
|
|
673
673
|
readonly chainId: number;
|
|
674
|
-
readonly kind: "nativeBalanceGte";
|
|
675
|
-
readonly owner: string;
|
|
676
|
-
} | {
|
|
677
674
|
readonly token: string;
|
|
675
|
+
readonly owner: string;
|
|
678
676
|
readonly minAmount: string;
|
|
677
|
+
} | {
|
|
678
|
+
readonly kind: "nativeBalanceGte";
|
|
679
679
|
readonly chainId: number;
|
|
680
|
-
readonly kind: "erc20BalanceGte";
|
|
681
680
|
readonly owner: string;
|
|
681
|
+
readonly minAmount: string;
|
|
682
682
|
} | {
|
|
683
|
-
readonly chainId: number;
|
|
684
683
|
readonly kind: "call";
|
|
684
|
+
readonly chainId: number;
|
|
685
685
|
readonly to: string;
|
|
686
686
|
readonly signature: string;
|
|
687
687
|
readonly args: readonly string[];
|
|
688
|
-
readonly comparator: "
|
|
688
|
+
readonly comparator: "eq" | "gte" | "lte";
|
|
689
689
|
readonly threshold: string;
|
|
690
690
|
}, never>, never>>;
|
|
691
691
|
}>;
|
|
@@ -766,67 +766,67 @@ export declare const ResourcePortZod: z.ZodObject<{
|
|
|
766
766
|
kind: z.ZodLiteral<"resource">;
|
|
767
767
|
name: z.ZodString;
|
|
768
768
|
accepts: z.ZodEnum<{
|
|
769
|
-
native: "native";
|
|
770
|
-
erc20: "erc20";
|
|
771
769
|
any: "any";
|
|
770
|
+
erc20: "erc20";
|
|
771
|
+
native: "native";
|
|
772
772
|
}>;
|
|
773
773
|
mode: z.ZodEnum<{
|
|
774
|
-
linear: "linear";
|
|
775
774
|
copy: "copy";
|
|
775
|
+
linear: "linear";
|
|
776
776
|
}>;
|
|
777
777
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
778
778
|
}, z.core.$strip>;
|
|
779
|
-
export declare const HANDLE_UNITS: readonly [
|
|
780
|
-
export declare const STATIC_SOL_TYPES: readonly [
|
|
779
|
+
export declare const HANDLE_UNITS: readonly ['raw', 'wad', 'ray', 'bps', 'token-decimals'];
|
|
780
|
+
export declare const STATIC_SOL_TYPES: readonly ['uint256', 'uint128', 'uint64', 'uint32', 'uint16', 'uint8', 'address', 'bool', 'bytes32'];
|
|
781
781
|
export declare const HandleUnitsZod: z.ZodEnum<{
|
|
782
|
+
bps: "bps";
|
|
782
783
|
raw: "raw";
|
|
783
|
-
wad: "wad";
|
|
784
784
|
ray: "ray";
|
|
785
|
-
bps: "bps";
|
|
786
785
|
"token-decimals": "token-decimals";
|
|
786
|
+
wad: "wad";
|
|
787
787
|
}>;
|
|
788
788
|
export declare const StaticSolTypeZod: z.ZodEnum<{
|
|
789
|
-
uint8: "uint8";
|
|
790
|
-
uint16: "uint16";
|
|
791
|
-
uint32: "uint32";
|
|
792
|
-
uint64: "uint64";
|
|
793
|
-
uint128: "uint128";
|
|
794
|
-
uint256: "uint256";
|
|
795
789
|
address: "address";
|
|
796
790
|
bool: "bool";
|
|
797
791
|
bytes32: "bytes32";
|
|
792
|
+
uint128: "uint128";
|
|
793
|
+
uint16: "uint16";
|
|
794
|
+
uint256: "uint256";
|
|
795
|
+
uint32: "uint32";
|
|
796
|
+
uint64: "uint64";
|
|
797
|
+
uint8: "uint8";
|
|
798
798
|
}>;
|
|
799
799
|
export declare const isStaticSolType: (value: string) => value is StaticSolType;
|
|
800
800
|
export declare const HandlePortZod: z.ZodObject<{
|
|
801
801
|
kind: z.ZodLiteral<"handle">;
|
|
802
802
|
name: z.ZodString;
|
|
803
803
|
type: z.ZodEnum<{
|
|
804
|
-
string: "string";
|
|
805
|
-
uint8: "uint8";
|
|
806
|
-
uint16: "uint16";
|
|
807
|
-
uint32: "uint32";
|
|
808
|
-
uint64: "uint64";
|
|
809
|
-
uint128: "uint128";
|
|
810
|
-
uint256: "uint256";
|
|
811
|
-
int128: "int128";
|
|
812
|
-
int256: "int256";
|
|
813
804
|
address: "address";
|
|
814
805
|
bool: "bool";
|
|
815
806
|
bytes: "bytes";
|
|
816
|
-
bytes4: "bytes4";
|
|
817
807
|
bytes32: "bytes32";
|
|
808
|
+
bytes4: "bytes4";
|
|
809
|
+
int128: "int128";
|
|
810
|
+
int256: "int256";
|
|
811
|
+
string: "string";
|
|
812
|
+
uint128: "uint128";
|
|
813
|
+
uint16: "uint16";
|
|
814
|
+
uint256: "uint256";
|
|
815
|
+
uint32: "uint32";
|
|
816
|
+
uint64: "uint64";
|
|
817
|
+
uint8: "uint8";
|
|
818
818
|
}>;
|
|
819
819
|
mode: z.ZodEnum<{
|
|
820
|
-
linear: "linear";
|
|
821
820
|
copy: "copy";
|
|
821
|
+
linear: "linear";
|
|
822
822
|
}>;
|
|
823
823
|
expose: z.ZodOptional<z.ZodBoolean>;
|
|
824
824
|
units: z.ZodOptional<z.ZodEnum<{
|
|
825
|
+
bps: "bps";
|
|
825
826
|
raw: "raw";
|
|
826
|
-
wad: "wad";
|
|
827
827
|
ray: "ray";
|
|
828
|
-
bps: "bps";
|
|
829
828
|
"token-decimals": "token-decimals";
|
|
829
|
+
wad: "wad";
|
|
830
830
|
}>>;
|
|
831
831
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
832
832
|
}, z.core.$strip>;
|
|
@@ -834,45 +834,45 @@ export declare const InputPortZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
834
834
|
kind: z.ZodLiteral<"resource">;
|
|
835
835
|
name: z.ZodString;
|
|
836
836
|
accepts: z.ZodEnum<{
|
|
837
|
-
native: "native";
|
|
838
|
-
erc20: "erc20";
|
|
839
837
|
any: "any";
|
|
838
|
+
erc20: "erc20";
|
|
839
|
+
native: "native";
|
|
840
840
|
}>;
|
|
841
841
|
mode: z.ZodEnum<{
|
|
842
|
-
linear: "linear";
|
|
843
842
|
copy: "copy";
|
|
843
|
+
linear: "linear";
|
|
844
844
|
}>;
|
|
845
845
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
846
846
|
}, z.core.$strip>, z.ZodObject<{
|
|
847
847
|
kind: z.ZodLiteral<"handle">;
|
|
848
848
|
name: z.ZodString;
|
|
849
849
|
type: z.ZodEnum<{
|
|
850
|
-
string: "string";
|
|
851
|
-
uint8: "uint8";
|
|
852
|
-
uint16: "uint16";
|
|
853
|
-
uint32: "uint32";
|
|
854
|
-
uint64: "uint64";
|
|
855
|
-
uint128: "uint128";
|
|
856
|
-
uint256: "uint256";
|
|
857
|
-
int128: "int128";
|
|
858
|
-
int256: "int256";
|
|
859
850
|
address: "address";
|
|
860
851
|
bool: "bool";
|
|
861
852
|
bytes: "bytes";
|
|
862
|
-
bytes4: "bytes4";
|
|
863
853
|
bytes32: "bytes32";
|
|
854
|
+
bytes4: "bytes4";
|
|
855
|
+
int128: "int128";
|
|
856
|
+
int256: "int256";
|
|
857
|
+
string: "string";
|
|
858
|
+
uint128: "uint128";
|
|
859
|
+
uint16: "uint16";
|
|
860
|
+
uint256: "uint256";
|
|
861
|
+
uint32: "uint32";
|
|
862
|
+
uint64: "uint64";
|
|
863
|
+
uint8: "uint8";
|
|
864
864
|
}>;
|
|
865
865
|
mode: z.ZodEnum<{
|
|
866
|
-
linear: "linear";
|
|
867
866
|
copy: "copy";
|
|
867
|
+
linear: "linear";
|
|
868
868
|
}>;
|
|
869
869
|
expose: z.ZodOptional<z.ZodBoolean>;
|
|
870
870
|
units: z.ZodOptional<z.ZodEnum<{
|
|
871
|
+
bps: "bps";
|
|
871
872
|
raw: "raw";
|
|
872
|
-
wad: "wad";
|
|
873
873
|
ray: "ray";
|
|
874
|
-
bps: "bps";
|
|
875
874
|
"token-decimals": "token-decimals";
|
|
875
|
+
wad: "wad";
|
|
876
876
|
}>>;
|
|
877
877
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
878
878
|
}, z.core.$strip>], "kind">;
|
|
@@ -880,12 +880,12 @@ export declare const ResourceOutputPortZod: z.ZodObject<{
|
|
|
880
880
|
kind: z.ZodLiteral<"resource_output">;
|
|
881
881
|
name: z.ZodString;
|
|
882
882
|
mode: z.ZodEnum<{
|
|
883
|
-
linear: "linear";
|
|
884
883
|
copy: "copy";
|
|
884
|
+
linear: "linear";
|
|
885
885
|
}>;
|
|
886
886
|
availability: z.ZodOptional<z.ZodEnum<{
|
|
887
|
-
now: "now";
|
|
888
887
|
future: "future";
|
|
888
|
+
now: "now";
|
|
889
889
|
}>>;
|
|
890
890
|
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
891
891
|
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
@@ -896,12 +896,12 @@ export declare const OutputPortZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
896
896
|
kind: z.ZodLiteral<"resource_output">;
|
|
897
897
|
name: z.ZodString;
|
|
898
898
|
mode: z.ZodEnum<{
|
|
899
|
-
linear: "linear";
|
|
900
899
|
copy: "copy";
|
|
900
|
+
linear: "linear";
|
|
901
901
|
}>;
|
|
902
902
|
availability: z.ZodOptional<z.ZodEnum<{
|
|
903
|
-
now: "now";
|
|
904
903
|
future: "future";
|
|
904
|
+
now: "now";
|
|
905
905
|
}>>;
|
|
906
906
|
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
907
907
|
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
@@ -911,32 +911,32 @@ export declare const OutputPortZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
911
911
|
kind: z.ZodLiteral<"handle">;
|
|
912
912
|
name: z.ZodString;
|
|
913
913
|
type: z.ZodEnum<{
|
|
914
|
-
string: "string";
|
|
915
|
-
uint8: "uint8";
|
|
916
|
-
uint16: "uint16";
|
|
917
|
-
uint32: "uint32";
|
|
918
|
-
uint64: "uint64";
|
|
919
|
-
uint128: "uint128";
|
|
920
|
-
uint256: "uint256";
|
|
921
|
-
int128: "int128";
|
|
922
|
-
int256: "int256";
|
|
923
914
|
address: "address";
|
|
924
915
|
bool: "bool";
|
|
925
916
|
bytes: "bytes";
|
|
926
|
-
bytes4: "bytes4";
|
|
927
917
|
bytes32: "bytes32";
|
|
918
|
+
bytes4: "bytes4";
|
|
919
|
+
int128: "int128";
|
|
920
|
+
int256: "int256";
|
|
921
|
+
string: "string";
|
|
922
|
+
uint128: "uint128";
|
|
923
|
+
uint16: "uint16";
|
|
924
|
+
uint256: "uint256";
|
|
925
|
+
uint32: "uint32";
|
|
926
|
+
uint64: "uint64";
|
|
927
|
+
uint8: "uint8";
|
|
928
928
|
}>;
|
|
929
929
|
mode: z.ZodEnum<{
|
|
930
|
-
linear: "linear";
|
|
931
930
|
copy: "copy";
|
|
931
|
+
linear: "linear";
|
|
932
932
|
}>;
|
|
933
933
|
expose: z.ZodOptional<z.ZodBoolean>;
|
|
934
934
|
units: z.ZodOptional<z.ZodEnum<{
|
|
935
|
+
bps: "bps";
|
|
935
936
|
raw: "raw";
|
|
936
|
-
wad: "wad";
|
|
937
937
|
ray: "ray";
|
|
938
|
-
bps: "bps";
|
|
939
938
|
"token-decimals": "token-decimals";
|
|
939
|
+
wad: "wad";
|
|
940
940
|
}>>;
|
|
941
941
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
942
942
|
}, z.core.$strip>], "kind">;
|
|
@@ -947,45 +947,45 @@ export declare const ManifestOperationZod: z.ZodObject<{
|
|
|
947
947
|
kind: z.ZodLiteral<"resource">;
|
|
948
948
|
name: z.ZodString;
|
|
949
949
|
accepts: z.ZodEnum<{
|
|
950
|
-
native: "native";
|
|
951
|
-
erc20: "erc20";
|
|
952
950
|
any: "any";
|
|
951
|
+
erc20: "erc20";
|
|
952
|
+
native: "native";
|
|
953
953
|
}>;
|
|
954
954
|
mode: z.ZodEnum<{
|
|
955
|
-
linear: "linear";
|
|
956
955
|
copy: "copy";
|
|
956
|
+
linear: "linear";
|
|
957
957
|
}>;
|
|
958
958
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
959
959
|
}, z.core.$strip>, z.ZodObject<{
|
|
960
960
|
kind: z.ZodLiteral<"handle">;
|
|
961
961
|
name: z.ZodString;
|
|
962
962
|
type: z.ZodEnum<{
|
|
963
|
-
string: "string";
|
|
964
|
-
uint8: "uint8";
|
|
965
|
-
uint16: "uint16";
|
|
966
|
-
uint32: "uint32";
|
|
967
|
-
uint64: "uint64";
|
|
968
|
-
uint128: "uint128";
|
|
969
|
-
uint256: "uint256";
|
|
970
|
-
int128: "int128";
|
|
971
|
-
int256: "int256";
|
|
972
963
|
address: "address";
|
|
973
964
|
bool: "bool";
|
|
974
965
|
bytes: "bytes";
|
|
975
|
-
bytes4: "bytes4";
|
|
976
966
|
bytes32: "bytes32";
|
|
967
|
+
bytes4: "bytes4";
|
|
968
|
+
int128: "int128";
|
|
969
|
+
int256: "int256";
|
|
970
|
+
string: "string";
|
|
971
|
+
uint128: "uint128";
|
|
972
|
+
uint16: "uint16";
|
|
973
|
+
uint256: "uint256";
|
|
974
|
+
uint32: "uint32";
|
|
975
|
+
uint64: "uint64";
|
|
976
|
+
uint8: "uint8";
|
|
977
977
|
}>;
|
|
978
978
|
mode: z.ZodEnum<{
|
|
979
|
-
linear: "linear";
|
|
980
979
|
copy: "copy";
|
|
980
|
+
linear: "linear";
|
|
981
981
|
}>;
|
|
982
982
|
expose: z.ZodOptional<z.ZodBoolean>;
|
|
983
983
|
units: z.ZodOptional<z.ZodEnum<{
|
|
984
|
+
bps: "bps";
|
|
984
985
|
raw: "raw";
|
|
985
|
-
wad: "wad";
|
|
986
986
|
ray: "ray";
|
|
987
|
-
bps: "bps";
|
|
988
987
|
"token-decimals": "token-decimals";
|
|
988
|
+
wad: "wad";
|
|
989
989
|
}>>;
|
|
990
990
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
991
991
|
}, z.core.$strip>], "kind">>;
|
|
@@ -993,12 +993,12 @@ export declare const ManifestOperationZod: z.ZodObject<{
|
|
|
993
993
|
kind: z.ZodLiteral<"resource_output">;
|
|
994
994
|
name: z.ZodString;
|
|
995
995
|
mode: z.ZodEnum<{
|
|
996
|
-
linear: "linear";
|
|
997
996
|
copy: "copy";
|
|
997
|
+
linear: "linear";
|
|
998
998
|
}>;
|
|
999
999
|
availability: z.ZodOptional<z.ZodEnum<{
|
|
1000
|
-
now: "now";
|
|
1001
1000
|
future: "future";
|
|
1001
|
+
now: "now";
|
|
1002
1002
|
}>>;
|
|
1003
1003
|
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
1004
1004
|
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
@@ -1008,32 +1008,32 @@ export declare const ManifestOperationZod: z.ZodObject<{
|
|
|
1008
1008
|
kind: z.ZodLiteral<"handle">;
|
|
1009
1009
|
name: z.ZodString;
|
|
1010
1010
|
type: z.ZodEnum<{
|
|
1011
|
-
string: "string";
|
|
1012
|
-
uint8: "uint8";
|
|
1013
|
-
uint16: "uint16";
|
|
1014
|
-
uint32: "uint32";
|
|
1015
|
-
uint64: "uint64";
|
|
1016
|
-
uint128: "uint128";
|
|
1017
|
-
uint256: "uint256";
|
|
1018
|
-
int128: "int128";
|
|
1019
|
-
int256: "int256";
|
|
1020
1011
|
address: "address";
|
|
1021
1012
|
bool: "bool";
|
|
1022
1013
|
bytes: "bytes";
|
|
1023
|
-
bytes4: "bytes4";
|
|
1024
1014
|
bytes32: "bytes32";
|
|
1015
|
+
bytes4: "bytes4";
|
|
1016
|
+
int128: "int128";
|
|
1017
|
+
int256: "int256";
|
|
1018
|
+
string: "string";
|
|
1019
|
+
uint128: "uint128";
|
|
1020
|
+
uint16: "uint16";
|
|
1021
|
+
uint256: "uint256";
|
|
1022
|
+
uint32: "uint32";
|
|
1023
|
+
uint64: "uint64";
|
|
1024
|
+
uint8: "uint8";
|
|
1025
1025
|
}>;
|
|
1026
1026
|
mode: z.ZodEnum<{
|
|
1027
|
-
linear: "linear";
|
|
1028
1027
|
copy: "copy";
|
|
1028
|
+
linear: "linear";
|
|
1029
1029
|
}>;
|
|
1030
1030
|
expose: z.ZodOptional<z.ZodBoolean>;
|
|
1031
1031
|
units: z.ZodOptional<z.ZodEnum<{
|
|
1032
|
+
bps: "bps";
|
|
1032
1033
|
raw: "raw";
|
|
1033
|
-
wad: "wad";
|
|
1034
1034
|
ray: "ray";
|
|
1035
|
-
bps: "bps";
|
|
1036
1035
|
"token-decimals": "token-decimals";
|
|
1036
|
+
wad: "wad";
|
|
1037
1037
|
}>>;
|
|
1038
1038
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
1039
1039
|
}, z.core.$strip>], "kind">>;
|
|
@@ -1047,30 +1047,30 @@ export declare const GuardSelectorZod: z.ZodObject<{
|
|
|
1047
1047
|
}>;
|
|
1048
1048
|
match: z.ZodObject<{
|
|
1049
1049
|
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
1050
|
+
handle: "handle";
|
|
1050
1051
|
resource: "resource";
|
|
1051
1052
|
resource_output: "resource_output";
|
|
1052
|
-
handle: "handle";
|
|
1053
1053
|
}>, z.ZodArray<z.ZodEnum<{
|
|
1054
|
+
handle: "handle";
|
|
1054
1055
|
resource: "resource";
|
|
1055
1056
|
resource_output: "resource_output";
|
|
1056
|
-
handle: "handle";
|
|
1057
1057
|
}>>]>;
|
|
1058
1058
|
mode: z.ZodOptional<z.ZodEnum<{
|
|
1059
|
-
linear: "linear";
|
|
1060
1059
|
copy: "copy";
|
|
1060
|
+
linear: "linear";
|
|
1061
1061
|
}>>;
|
|
1062
1062
|
type: z.ZodOptional<z.ZodEnum<{
|
|
1063
|
-
native: "native";
|
|
1064
|
-
erc20: "erc20";
|
|
1065
1063
|
any: "any";
|
|
1064
|
+
erc20: "erc20";
|
|
1065
|
+
native: "native";
|
|
1066
1066
|
}>>;
|
|
1067
1067
|
}, z.core.$strip>;
|
|
1068
1068
|
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1069
1069
|
kind: z.ZodLiteral<"config">;
|
|
1070
1070
|
configKey: z.ZodString;
|
|
1071
1071
|
cardinality: z.ZodEnum<{
|
|
1072
|
-
one: "one";
|
|
1073
1072
|
many: "many";
|
|
1073
|
+
one: "one";
|
|
1074
1074
|
}>;
|
|
1075
1075
|
}, z.core.$strip>, z.ZodObject<{
|
|
1076
1076
|
kind: z.ZodLiteral<"all_matching">;
|
|
@@ -1085,30 +1085,30 @@ export declare const GuardCompatibilityZod: z.ZodObject<{
|
|
|
1085
1085
|
}>;
|
|
1086
1086
|
match: z.ZodObject<{
|
|
1087
1087
|
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
1088
|
+
handle: "handle";
|
|
1088
1089
|
resource: "resource";
|
|
1089
1090
|
resource_output: "resource_output";
|
|
1090
|
-
handle: "handle";
|
|
1091
1091
|
}>, z.ZodArray<z.ZodEnum<{
|
|
1092
|
+
handle: "handle";
|
|
1092
1093
|
resource: "resource";
|
|
1093
1094
|
resource_output: "resource_output";
|
|
1094
|
-
handle: "handle";
|
|
1095
1095
|
}>>]>;
|
|
1096
1096
|
mode: z.ZodOptional<z.ZodEnum<{
|
|
1097
|
-
linear: "linear";
|
|
1098
1097
|
copy: "copy";
|
|
1098
|
+
linear: "linear";
|
|
1099
1099
|
}>>;
|
|
1100
1100
|
type: z.ZodOptional<z.ZodEnum<{
|
|
1101
|
-
native: "native";
|
|
1102
|
-
erc20: "erc20";
|
|
1103
1101
|
any: "any";
|
|
1102
|
+
erc20: "erc20";
|
|
1103
|
+
native: "native";
|
|
1104
1104
|
}>>;
|
|
1105
1105
|
}, z.core.$strip>;
|
|
1106
1106
|
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1107
1107
|
kind: z.ZodLiteral<"config">;
|
|
1108
1108
|
configKey: z.ZodString;
|
|
1109
1109
|
cardinality: z.ZodEnum<{
|
|
1110
|
-
one: "one";
|
|
1111
1110
|
many: "many";
|
|
1111
|
+
one: "one";
|
|
1112
1112
|
}>;
|
|
1113
1113
|
}, z.core.$strip>, z.ZodObject<{
|
|
1114
1114
|
kind: z.ZodLiteral<"all_matching">;
|
|
@@ -1128,30 +1128,30 @@ export declare const ManifestGuardZod: z.ZodObject<{
|
|
|
1128
1128
|
}>;
|
|
1129
1129
|
match: z.ZodObject<{
|
|
1130
1130
|
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
1131
|
+
handle: "handle";
|
|
1131
1132
|
resource: "resource";
|
|
1132
1133
|
resource_output: "resource_output";
|
|
1133
|
-
handle: "handle";
|
|
1134
1134
|
}>, z.ZodArray<z.ZodEnum<{
|
|
1135
|
+
handle: "handle";
|
|
1135
1136
|
resource: "resource";
|
|
1136
1137
|
resource_output: "resource_output";
|
|
1137
|
-
handle: "handle";
|
|
1138
1138
|
}>>]>;
|
|
1139
1139
|
mode: z.ZodOptional<z.ZodEnum<{
|
|
1140
|
-
linear: "linear";
|
|
1141
1140
|
copy: "copy";
|
|
1141
|
+
linear: "linear";
|
|
1142
1142
|
}>>;
|
|
1143
1143
|
type: z.ZodOptional<z.ZodEnum<{
|
|
1144
|
-
native: "native";
|
|
1145
|
-
erc20: "erc20";
|
|
1146
1144
|
any: "any";
|
|
1145
|
+
erc20: "erc20";
|
|
1146
|
+
native: "native";
|
|
1147
1147
|
}>>;
|
|
1148
1148
|
}, z.core.$strip>;
|
|
1149
1149
|
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1150
1150
|
kind: z.ZodLiteral<"config">;
|
|
1151
1151
|
configKey: z.ZodString;
|
|
1152
1152
|
cardinality: z.ZodEnum<{
|
|
1153
|
-
one: "one";
|
|
1154
1153
|
many: "many";
|
|
1154
|
+
one: "one";
|
|
1155
1155
|
}>;
|
|
1156
1156
|
}, z.core.$strip>, z.ZodObject<{
|
|
1157
1157
|
kind: z.ZodLiteral<"all_matching">;
|
|
@@ -1163,9 +1163,9 @@ export declare const ManifestMaterialiserZod: z.ZodObject<{
|
|
|
1163
1163
|
kind: z.ZodString;
|
|
1164
1164
|
description: z.ZodOptional<z.ZodString>;
|
|
1165
1165
|
accepts: z.ZodEnum<{
|
|
1166
|
-
resource: "resource";
|
|
1167
|
-
handle: "handle";
|
|
1168
1166
|
any: "any";
|
|
1167
|
+
handle: "handle";
|
|
1168
|
+
resource: "resource";
|
|
1169
1169
|
}>;
|
|
1170
1170
|
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1171
1171
|
}, z.core.$strip>;
|
|
@@ -1177,8 +1177,8 @@ export declare const ManifestPreconditionZod: z.ZodObject<{
|
|
|
1177
1177
|
export declare const ManifestRoutingZod: z.ZodObject<{
|
|
1178
1178
|
maxRouteHops: z.ZodNumber;
|
|
1179
1179
|
swapHops: z.ZodEnum<{
|
|
1180
|
-
none: "none";
|
|
1181
1180
|
head: "head";
|
|
1181
|
+
none: "none";
|
|
1182
1182
|
}>;
|
|
1183
1183
|
}, z.core.$strip>;
|
|
1184
1184
|
export declare const ComposeManifestZod: z.ZodObject<{
|
|
@@ -1192,45 +1192,45 @@ export declare const ComposeManifestZod: z.ZodObject<{
|
|
|
1192
1192
|
kind: z.ZodLiteral<"resource">;
|
|
1193
1193
|
name: z.ZodString;
|
|
1194
1194
|
accepts: z.ZodEnum<{
|
|
1195
|
-
native: "native";
|
|
1196
|
-
erc20: "erc20";
|
|
1197
1195
|
any: "any";
|
|
1196
|
+
erc20: "erc20";
|
|
1197
|
+
native: "native";
|
|
1198
1198
|
}>;
|
|
1199
1199
|
mode: z.ZodEnum<{
|
|
1200
|
-
linear: "linear";
|
|
1201
1200
|
copy: "copy";
|
|
1201
|
+
linear: "linear";
|
|
1202
1202
|
}>;
|
|
1203
1203
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
1204
1204
|
}, z.core.$strip>, z.ZodObject<{
|
|
1205
1205
|
kind: z.ZodLiteral<"handle">;
|
|
1206
1206
|
name: z.ZodString;
|
|
1207
1207
|
type: z.ZodEnum<{
|
|
1208
|
-
string: "string";
|
|
1209
|
-
uint8: "uint8";
|
|
1210
|
-
uint16: "uint16";
|
|
1211
|
-
uint32: "uint32";
|
|
1212
|
-
uint64: "uint64";
|
|
1213
|
-
uint128: "uint128";
|
|
1214
|
-
uint256: "uint256";
|
|
1215
|
-
int128: "int128";
|
|
1216
|
-
int256: "int256";
|
|
1217
1208
|
address: "address";
|
|
1218
1209
|
bool: "bool";
|
|
1219
1210
|
bytes: "bytes";
|
|
1220
|
-
bytes4: "bytes4";
|
|
1221
1211
|
bytes32: "bytes32";
|
|
1212
|
+
bytes4: "bytes4";
|
|
1213
|
+
int128: "int128";
|
|
1214
|
+
int256: "int256";
|
|
1215
|
+
string: "string";
|
|
1216
|
+
uint128: "uint128";
|
|
1217
|
+
uint16: "uint16";
|
|
1218
|
+
uint256: "uint256";
|
|
1219
|
+
uint32: "uint32";
|
|
1220
|
+
uint64: "uint64";
|
|
1221
|
+
uint8: "uint8";
|
|
1222
1222
|
}>;
|
|
1223
1223
|
mode: z.ZodEnum<{
|
|
1224
|
-
linear: "linear";
|
|
1225
1224
|
copy: "copy";
|
|
1225
|
+
linear: "linear";
|
|
1226
1226
|
}>;
|
|
1227
1227
|
expose: z.ZodOptional<z.ZodBoolean>;
|
|
1228
1228
|
units: z.ZodOptional<z.ZodEnum<{
|
|
1229
|
+
bps: "bps";
|
|
1229
1230
|
raw: "raw";
|
|
1230
|
-
wad: "wad";
|
|
1231
1231
|
ray: "ray";
|
|
1232
|
-
bps: "bps";
|
|
1233
1232
|
"token-decimals": "token-decimals";
|
|
1233
|
+
wad: "wad";
|
|
1234
1234
|
}>>;
|
|
1235
1235
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
1236
1236
|
}, z.core.$strip>], "kind">>;
|
|
@@ -1238,12 +1238,12 @@ export declare const ComposeManifestZod: z.ZodObject<{
|
|
|
1238
1238
|
kind: z.ZodLiteral<"resource_output">;
|
|
1239
1239
|
name: z.ZodString;
|
|
1240
1240
|
mode: z.ZodEnum<{
|
|
1241
|
-
linear: "linear";
|
|
1242
1241
|
copy: "copy";
|
|
1242
|
+
linear: "linear";
|
|
1243
1243
|
}>;
|
|
1244
1244
|
availability: z.ZodOptional<z.ZodEnum<{
|
|
1245
|
-
now: "now";
|
|
1246
1245
|
future: "future";
|
|
1246
|
+
now: "now";
|
|
1247
1247
|
}>>;
|
|
1248
1248
|
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
1249
1249
|
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
@@ -1253,32 +1253,32 @@ export declare const ComposeManifestZod: z.ZodObject<{
|
|
|
1253
1253
|
kind: z.ZodLiteral<"handle">;
|
|
1254
1254
|
name: z.ZodString;
|
|
1255
1255
|
type: z.ZodEnum<{
|
|
1256
|
-
string: "string";
|
|
1257
|
-
uint8: "uint8";
|
|
1258
|
-
uint16: "uint16";
|
|
1259
|
-
uint32: "uint32";
|
|
1260
|
-
uint64: "uint64";
|
|
1261
|
-
uint128: "uint128";
|
|
1262
|
-
uint256: "uint256";
|
|
1263
|
-
int128: "int128";
|
|
1264
|
-
int256: "int256";
|
|
1265
1256
|
address: "address";
|
|
1266
1257
|
bool: "bool";
|
|
1267
1258
|
bytes: "bytes";
|
|
1268
|
-
bytes4: "bytes4";
|
|
1269
1259
|
bytes32: "bytes32";
|
|
1260
|
+
bytes4: "bytes4";
|
|
1261
|
+
int128: "int128";
|
|
1262
|
+
int256: "int256";
|
|
1263
|
+
string: "string";
|
|
1264
|
+
uint128: "uint128";
|
|
1265
|
+
uint16: "uint16";
|
|
1266
|
+
uint256: "uint256";
|
|
1267
|
+
uint32: "uint32";
|
|
1268
|
+
uint64: "uint64";
|
|
1269
|
+
uint8: "uint8";
|
|
1270
1270
|
}>;
|
|
1271
1271
|
mode: z.ZodEnum<{
|
|
1272
|
-
linear: "linear";
|
|
1273
1272
|
copy: "copy";
|
|
1273
|
+
linear: "linear";
|
|
1274
1274
|
}>;
|
|
1275
1275
|
expose: z.ZodOptional<z.ZodBoolean>;
|
|
1276
1276
|
units: z.ZodOptional<z.ZodEnum<{
|
|
1277
|
+
bps: "bps";
|
|
1277
1278
|
raw: "raw";
|
|
1278
|
-
wad: "wad";
|
|
1279
1279
|
ray: "ray";
|
|
1280
|
-
bps: "bps";
|
|
1281
1280
|
"token-decimals": "token-decimals";
|
|
1281
|
+
wad: "wad";
|
|
1282
1282
|
}>>;
|
|
1283
1283
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
1284
1284
|
}, z.core.$strip>], "kind">>;
|
|
@@ -1297,30 +1297,30 @@ export declare const ComposeManifestZod: z.ZodObject<{
|
|
|
1297
1297
|
}>;
|
|
1298
1298
|
match: z.ZodObject<{
|
|
1299
1299
|
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
1300
|
+
handle: "handle";
|
|
1300
1301
|
resource: "resource";
|
|
1301
1302
|
resource_output: "resource_output";
|
|
1302
|
-
handle: "handle";
|
|
1303
1303
|
}>, z.ZodArray<z.ZodEnum<{
|
|
1304
|
+
handle: "handle";
|
|
1304
1305
|
resource: "resource";
|
|
1305
1306
|
resource_output: "resource_output";
|
|
1306
|
-
handle: "handle";
|
|
1307
1307
|
}>>]>;
|
|
1308
1308
|
mode: z.ZodOptional<z.ZodEnum<{
|
|
1309
|
-
linear: "linear";
|
|
1310
1309
|
copy: "copy";
|
|
1310
|
+
linear: "linear";
|
|
1311
1311
|
}>>;
|
|
1312
1312
|
type: z.ZodOptional<z.ZodEnum<{
|
|
1313
|
-
native: "native";
|
|
1314
|
-
erc20: "erc20";
|
|
1315
1313
|
any: "any";
|
|
1314
|
+
erc20: "erc20";
|
|
1315
|
+
native: "native";
|
|
1316
1316
|
}>>;
|
|
1317
1317
|
}, z.core.$strip>;
|
|
1318
1318
|
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1319
1319
|
kind: z.ZodLiteral<"config">;
|
|
1320
1320
|
configKey: z.ZodString;
|
|
1321
1321
|
cardinality: z.ZodEnum<{
|
|
1322
|
-
one: "one";
|
|
1323
1322
|
many: "many";
|
|
1323
|
+
one: "one";
|
|
1324
1324
|
}>;
|
|
1325
1325
|
}, z.core.$strip>, z.ZodObject<{
|
|
1326
1326
|
kind: z.ZodLiteral<"all_matching">;
|
|
@@ -1332,9 +1332,9 @@ export declare const ComposeManifestZod: z.ZodObject<{
|
|
|
1332
1332
|
kind: z.ZodString;
|
|
1333
1333
|
description: z.ZodOptional<z.ZodString>;
|
|
1334
1334
|
accepts: z.ZodEnum<{
|
|
1335
|
-
resource: "resource";
|
|
1336
|
-
handle: "handle";
|
|
1337
1335
|
any: "any";
|
|
1336
|
+
handle: "handle";
|
|
1337
|
+
resource: "resource";
|
|
1338
1338
|
}>;
|
|
1339
1339
|
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1340
1340
|
}, z.core.$strip>>;
|
|
@@ -1346,8 +1346,8 @@ export declare const ComposeManifestZod: z.ZodObject<{
|
|
|
1346
1346
|
routing: z.ZodOptional<z.ZodObject<{
|
|
1347
1347
|
maxRouteHops: z.ZodNumber;
|
|
1348
1348
|
swapHops: z.ZodEnum<{
|
|
1349
|
-
none: "none";
|
|
1350
1349
|
head: "head";
|
|
1350
|
+
none: "none";
|
|
1351
1351
|
}>;
|
|
1352
1352
|
}, z.core.$strip>>;
|
|
1353
1353
|
}, z.core.$strip>;
|
|
@@ -1377,16 +1377,16 @@ export declare const AssertionSpecZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
1377
1377
|
chainId: z.ZodNumber;
|
|
1378
1378
|
token: z.ZodString;
|
|
1379
1379
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1380
|
-
escrow: "escrow";
|
|
1381
1380
|
delivery: "delivery";
|
|
1381
|
+
escrow: "escrow";
|
|
1382
1382
|
}>]>;
|
|
1383
1383
|
minAmount: z.ZodString;
|
|
1384
1384
|
}, z.core.$strip>, z.ZodObject<{
|
|
1385
1385
|
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1386
1386
|
chainId: z.ZodNumber;
|
|
1387
1387
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1388
|
-
escrow: "escrow";
|
|
1389
1388
|
delivery: "delivery";
|
|
1389
|
+
escrow: "escrow";
|
|
1390
1390
|
}>]>;
|
|
1391
1391
|
minAmount: z.ZodString;
|
|
1392
1392
|
}, z.core.$strip>, z.ZodObject<{
|
|
@@ -1396,8 +1396,8 @@ export declare const AssertionSpecZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
1396
1396
|
signature: z.ZodString;
|
|
1397
1397
|
args: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
1398
1398
|
comparator: z.ZodEnum<{
|
|
1399
|
-
gte: "gte";
|
|
1400
1399
|
eq: "eq";
|
|
1400
|
+
gte: "gte";
|
|
1401
1401
|
lte: "lte";
|
|
1402
1402
|
}>;
|
|
1403
1403
|
threshold: z.ZodString;
|
|
@@ -1411,16 +1411,16 @@ export declare const VerificationDescriptorZod: z.ZodObject<{
|
|
|
1411
1411
|
chainId: z.ZodNumber;
|
|
1412
1412
|
token: z.ZodString;
|
|
1413
1413
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1414
|
-
escrow: "escrow";
|
|
1415
1414
|
delivery: "delivery";
|
|
1415
|
+
escrow: "escrow";
|
|
1416
1416
|
}>]>;
|
|
1417
1417
|
minAmount: z.ZodString;
|
|
1418
1418
|
}, z.core.$strip>, z.ZodObject<{
|
|
1419
1419
|
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1420
1420
|
chainId: z.ZodNumber;
|
|
1421
1421
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1422
|
-
escrow: "escrow";
|
|
1423
1422
|
delivery: "delivery";
|
|
1423
|
+
escrow: "escrow";
|
|
1424
1424
|
}>]>;
|
|
1425
1425
|
minAmount: z.ZodString;
|
|
1426
1426
|
}, z.core.$strip>, z.ZodObject<{
|
|
@@ -1430,8 +1430,8 @@ export declare const VerificationDescriptorZod: z.ZodObject<{
|
|
|
1430
1430
|
signature: z.ZodString;
|
|
1431
1431
|
args: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
1432
1432
|
comparator: z.ZodEnum<{
|
|
1433
|
-
gte: "gte";
|
|
1434
1433
|
eq: "eq";
|
|
1434
|
+
gte: "gte";
|
|
1435
1435
|
lte: "lte";
|
|
1436
1436
|
}>;
|
|
1437
1437
|
threshold: z.ZodString;
|
|
@@ -1638,7 +1638,7 @@ interface Port {
|
|
|
1638
1638
|
}
|
|
1639
1639
|
export declare const isResourceInput: (input: FlowInput) => input is ResourceInput;
|
|
1640
1640
|
export declare const flowInputType: (input: FlowInput) => SolType;
|
|
1641
|
-
export declare const flowInputMode: (input: FlowInput) =>
|
|
1641
|
+
export declare const flowInputMode: (input: FlowInput) => 'linear' | 'copy';
|
|
1642
1642
|
export declare const flowInputResource: (input: FlowInput) => Resource | undefined;
|
|
1643
1643
|
export declare const isResourcePort: (port: OpInputPort) => port is ResourcePort;
|
|
1644
1644
|
export declare const isHandlePort: (port: OpInputPort | OpOutputPort) => port is HandlePort;
|
|
@@ -1723,7 +1723,7 @@ export declare const PROVIDER_KIND: {
|
|
|
1723
1723
|
readonly BALANCER_V2: 2;
|
|
1724
1724
|
readonly MORPHO_BLUE: 3;
|
|
1725
1725
|
};
|
|
1726
|
-
export declare const providerKindNames: readonly [
|
|
1726
|
+
export declare const providerKindNames: readonly ['aave-v3', 'erc3156', 'balancer-v2', 'morpho-blue'];
|
|
1727
1727
|
type ProviderKindName = (typeof providerKindNames)[number];
|
|
1728
1728
|
export declare const providerKindByName: Record<ProviderKindName, number>;
|
|
1729
1729
|
interface FlashloanMaterialiserInput {
|
|
@@ -1741,12 +1741,12 @@ interface OpHandleOptions<Opt extends boolean = boolean> {
|
|
|
1741
1741
|
export declare const linear: <N extends string, T extends SolType>(name: N, type: T) => Port & {
|
|
1742
1742
|
readonly name: N;
|
|
1743
1743
|
readonly type: T;
|
|
1744
|
-
readonly mode:
|
|
1744
|
+
readonly mode: 'linear';
|
|
1745
1745
|
};
|
|
1746
1746
|
export declare const copy: <N extends string, T extends SolType>(name: N, type: T) => Port & {
|
|
1747
1747
|
readonly name: N;
|
|
1748
1748
|
readonly type: T;
|
|
1749
|
-
readonly mode:
|
|
1749
|
+
readonly mode: 'copy';
|
|
1750
1750
|
};
|
|
1751
1751
|
export declare const handle: <N extends string, T extends SolType>(name: N, type: T) => HandleInput & {
|
|
1752
1752
|
readonly name: N;
|
|
@@ -1758,15 +1758,15 @@ export declare const native: <N extends string>(name: N, chainId: number) => Res
|
|
|
1758
1758
|
export declare const erc20: <N extends string>(name: N, token: string, chainId: number) => ResourceInput & {
|
|
1759
1759
|
readonly name: N;
|
|
1760
1760
|
};
|
|
1761
|
-
export declare const resource: <N extends string, Opt extends boolean = false>(name: N, accepts:
|
|
1761
|
+
export declare const resource: <N extends string, Opt extends boolean = false>(name: N, accepts: 'erc20' | 'native' | 'any', options?: {
|
|
1762
1762
|
readonly optional?: Opt;
|
|
1763
1763
|
}) => ResourcePort & {
|
|
1764
1764
|
readonly name: N;
|
|
1765
1765
|
readonly optional: NoInfer<Opt>;
|
|
1766
1766
|
};
|
|
1767
|
-
export declare const readResource: <N extends string>(name: N, accepts:
|
|
1767
|
+
export declare const readResource: <N extends string>(name: N, accepts: 'erc20' | 'native' | 'any') => ResourcePort & {
|
|
1768
1768
|
readonly name: N;
|
|
1769
|
-
readonly mode:
|
|
1769
|
+
readonly mode: 'copy';
|
|
1770
1770
|
};
|
|
1771
1771
|
export declare const opHandle: <N extends string, T extends SolType, Opt extends boolean = false>(name: N, type: T, options?: OpHandleOptions<Opt>) => HandlePort & {
|
|
1772
1772
|
readonly name: N;
|
|
@@ -1788,7 +1788,7 @@ type OutputCountFrom<O> = O extends {
|
|
|
1788
1788
|
type OutputAvailability<O> = [O] extends ['future'] ? 'future' : [O] extends ['now'] ? 'now' : [O] extends [string] ? Availability : O extends {
|
|
1789
1789
|
readonly availability: infer A;
|
|
1790
1790
|
} ? [A] extends ['future'] ? 'future' : [A] extends ['now'] ? 'now' : Availability : 'now';
|
|
1791
|
-
export declare const resourceOutput: <N extends string, const O extends ResourceOutputOptions =
|
|
1791
|
+
export declare const resourceOutput: <N extends string, const O extends ResourceOutputOptions = 'now'>(name: N, options?: O) => ResourceOutputPort & {
|
|
1792
1792
|
readonly name: N;
|
|
1793
1793
|
readonly availability: OutputAvailability<O>;
|
|
1794
1794
|
} & OutputCountFrom<O>;
|
|
@@ -1799,8 +1799,8 @@ type OutputFamilyPort = ResourceOutputPort & {
|
|
|
1799
1799
|
};
|
|
1800
1800
|
export declare const isOutputFamily: (port: OpOutputPort) => port is OutputFamilyPort;
|
|
1801
1801
|
export declare const instancePortName: (family: string, index: number) => string;
|
|
1802
|
-
export declare const familySize: (family: Pick<OutputFamilyPort,
|
|
1803
|
-
export declare const expandOutputPorts: (declared: readonly OpOutputPort[], config: Call[
|
|
1802
|
+
export declare const familySize: (family: Pick<OutputFamilyPort, 'name' | 'countFrom'>, config: Call['config']) => number;
|
|
1803
|
+
export declare const expandOutputPorts: (declared: readonly OpOutputPort[], config: Call['config']) => readonly OpOutputPort[];
|
|
1804
1804
|
//#endregion
|
|
1805
1805
|
//#region src/ref.d.ts
|
|
1806
1806
|
type ParsedRef = {
|
|
@@ -2198,9 +2198,9 @@ type Erc20AllowancePrecondition = {
|
|
|
2198
2198
|
readonly token: string;
|
|
2199
2199
|
readonly allowance: bigint | string;
|
|
2200
2200
|
};
|
|
2201
|
-
export declare const erc20Balance: (config: Omit<Erc20BalancePrecondition,
|
|
2202
|
-
export declare const nativeBalance: (config: Omit<NativeBalancePrecondition,
|
|
2203
|
-
export declare const erc20Allowance: (config: Omit<Erc20AllowancePrecondition,
|
|
2201
|
+
export declare const erc20Balance: (config: Omit<Erc20BalancePrecondition, 'type'>) => Erc20BalancePrecondition;
|
|
2202
|
+
export declare const nativeBalance: (config: Omit<NativeBalancePrecondition, 'type'>) => NativeBalancePrecondition;
|
|
2203
|
+
export declare const erc20Allowance: (config: Omit<Erc20AllowancePrecondition, 'type'>) => Erc20AllowancePrecondition;
|
|
2204
2204
|
export declare const isErc20BalancePrecondition: (p: Precondition) => p is Erc20BalancePrecondition;
|
|
2205
2205
|
export declare const isErc20AllowancePrecondition: (p: Precondition) => p is Erc20AllowancePrecondition;
|
|
2206
2206
|
export declare const isNativeBalancePrecondition: (p: Precondition) => p is NativeBalancePrecondition;
|