@lifi/compose-spec 0.8.1 → 0.10.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/index.cjs +1019 -1095
- package/dist/index.d.cts +1666 -1701
- package/dist/index.d.ts +1666 -1701
- package/dist/index.js +926 -989
- package/package.json +4 -4
- package/src/continuation.ts +4 -3
- package/src/flowSchema.ts +8 -0
- package/src/materialiserMetadata.ts +5 -4
- package/src/output.ts +7 -4
package/dist/index.d.ts
CHANGED
|
@@ -1,9 +1,9 @@
|
|
|
1
|
-
import { Schema } from
|
|
2
|
-
import z from
|
|
3
|
-
|
|
4
|
-
declare const SolTypeSchema: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
5
|
-
declare const EVMAddressString: Schema.refine<string, typeof Schema.String>;
|
|
6
|
-
declare const IntegerString: Schema.filter<typeof Schema.String>;
|
|
1
|
+
import { ParseResult, Schema } from "effect";
|
|
2
|
+
import z from "zod";
|
|
3
|
+
//#region src/flowSchema.d.ts
|
|
4
|
+
export declare const SolTypeSchema: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
5
|
+
export declare const EVMAddressString: Schema.refine<string, typeof Schema.String>;
|
|
6
|
+
export declare const IntegerString: Schema.filter<typeof Schema.String>;
|
|
7
7
|
/**
|
|
8
8
|
* THE chain-capabilities chokepoint.
|
|
9
9
|
*
|
|
@@ -21,187 +21,187 @@ declare const IntegerString: Schema.filter<typeof Schema.String>;
|
|
|
21
21
|
* the published wire format from the encoded (`from`) side, so the manifest
|
|
22
22
|
* keeps advertising the plain union with both arms.
|
|
23
23
|
*/
|
|
24
|
-
declare const ResourceSchema: Schema.transform<Schema.Union<[Schema.Struct<{
|
|
24
|
+
export declare const ResourceSchema: Schema.transform<Schema.Union<[Schema.Struct<{
|
|
25
|
+
kind: Schema.Literal<["native"]>;
|
|
26
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
27
|
+
}>, Schema.Struct<{
|
|
28
|
+
kind: Schema.Literal<["erc20"]>;
|
|
29
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
30
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
31
|
+
}>]>, Schema.SchemaClass<{
|
|
32
|
+
readonly kind: "native";
|
|
33
|
+
readonly chainId: number;
|
|
34
|
+
} | {
|
|
35
|
+
readonly kind: "erc20";
|
|
36
|
+
readonly chainId: number;
|
|
37
|
+
readonly token: string;
|
|
38
|
+
}, {
|
|
39
|
+
readonly kind: "native";
|
|
40
|
+
readonly chainId: number;
|
|
41
|
+
} | {
|
|
42
|
+
readonly kind: "erc20";
|
|
43
|
+
readonly chainId: number;
|
|
44
|
+
readonly token: string;
|
|
45
|
+
}, never>>;
|
|
46
|
+
export declare const ResourceInputSchema: Schema.Struct<{
|
|
47
|
+
name: typeof Schema.String;
|
|
48
|
+
resource: Schema.transform<Schema.Union<[Schema.Struct<{
|
|
25
49
|
kind: Schema.Literal<["native"]>;
|
|
26
50
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
27
|
-
}>, Schema.Struct<{
|
|
51
|
+
}>, Schema.Struct<{
|
|
28
52
|
kind: Schema.Literal<["erc20"]>;
|
|
29
53
|
token: Schema.refine<string, typeof Schema.String>;
|
|
30
54
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
31
|
-
}>]>, Schema.SchemaClass<{
|
|
55
|
+
}>]>, Schema.SchemaClass<{
|
|
32
56
|
readonly kind: "native";
|
|
33
57
|
readonly chainId: number;
|
|
34
|
-
} | {
|
|
58
|
+
} | {
|
|
59
|
+
readonly kind: "erc20";
|
|
60
|
+
readonly chainId: number;
|
|
35
61
|
readonly token: string;
|
|
62
|
+
}, {
|
|
63
|
+
readonly kind: "native";
|
|
64
|
+
readonly chainId: number;
|
|
65
|
+
} | {
|
|
36
66
|
readonly kind: "erc20";
|
|
37
67
|
readonly chainId: number;
|
|
38
|
-
|
|
68
|
+
readonly token: string;
|
|
69
|
+
}, never>>;
|
|
70
|
+
}>;
|
|
71
|
+
export declare const HandleInputSchema: Schema.Struct<{
|
|
72
|
+
name: typeof Schema.String;
|
|
73
|
+
type: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
74
|
+
}>;
|
|
75
|
+
export declare const FlowInputSchema: Schema.Union<[Schema.Struct<{
|
|
76
|
+
name: typeof Schema.String;
|
|
77
|
+
resource: Schema.transform<Schema.Union<[Schema.Struct<{
|
|
78
|
+
kind: Schema.Literal<["native"]>;
|
|
79
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
80
|
+
}>, Schema.Struct<{
|
|
81
|
+
kind: Schema.Literal<["erc20"]>;
|
|
82
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
83
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
84
|
+
}>]>, Schema.SchemaClass<{
|
|
39
85
|
readonly kind: "native";
|
|
40
86
|
readonly chainId: number;
|
|
41
|
-
} | {
|
|
87
|
+
} | {
|
|
88
|
+
readonly kind: "erc20";
|
|
89
|
+
readonly chainId: number;
|
|
42
90
|
readonly token: string;
|
|
91
|
+
}, {
|
|
92
|
+
readonly kind: "native";
|
|
93
|
+
readonly chainId: number;
|
|
94
|
+
} | {
|
|
43
95
|
readonly kind: "erc20";
|
|
44
96
|
readonly chainId: number;
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
token: Schema.refine<string, typeof Schema.String>;
|
|
54
|
-
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
55
|
-
}>]>, Schema.SchemaClass<{
|
|
56
|
-
readonly kind: "native";
|
|
57
|
-
readonly chainId: number;
|
|
58
|
-
} | {
|
|
59
|
-
readonly token: string;
|
|
60
|
-
readonly kind: "erc20";
|
|
61
|
-
readonly chainId: number;
|
|
62
|
-
}, {
|
|
63
|
-
readonly kind: "native";
|
|
64
|
-
readonly chainId: number;
|
|
65
|
-
} | {
|
|
66
|
-
readonly token: string;
|
|
67
|
-
readonly kind: "erc20";
|
|
68
|
-
readonly chainId: number;
|
|
69
|
-
}, never>>;
|
|
97
|
+
readonly token: string;
|
|
98
|
+
}, never>>;
|
|
99
|
+
}>, Schema.Struct<{
|
|
100
|
+
name: typeof Schema.String;
|
|
101
|
+
type: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
102
|
+
}>]>;
|
|
103
|
+
export declare const RefSchema: Schema.Struct<{
|
|
104
|
+
$ref: Schema.filter<typeof Schema.String>;
|
|
70
105
|
}>;
|
|
71
|
-
declare const
|
|
72
|
-
|
|
73
|
-
|
|
106
|
+
export declare const LiteralBindingSchema: Schema.Struct<{
|
|
107
|
+
kind: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
108
|
+
value: typeof Schema.String;
|
|
109
|
+
}>;
|
|
110
|
+
export declare const BindValueSchema: Schema.Union<[Schema.Struct<{
|
|
111
|
+
$ref: Schema.filter<typeof Schema.String>;
|
|
112
|
+
}>, Schema.Struct<{
|
|
113
|
+
kind: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
114
|
+
value: typeof Schema.String;
|
|
115
|
+
}>]>;
|
|
116
|
+
export declare const AppliedGuardSchema: Schema.TypeLiteral<{
|
|
117
|
+
kind: typeof Schema.String;
|
|
118
|
+
}, readonly [{
|
|
119
|
+
readonly key: typeof Schema.String;
|
|
120
|
+
readonly value: typeof Schema.Unknown;
|
|
121
|
+
}]>;
|
|
122
|
+
export declare const CallSchema: Schema.Struct<{
|
|
123
|
+
id: Schema.filter<Schema.filter<typeof Schema.String>>;
|
|
124
|
+
op: typeof Schema.String;
|
|
125
|
+
bind: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
|
|
126
|
+
$ref: Schema.filter<typeof Schema.String>;
|
|
127
|
+
}>, Schema.Struct<{
|
|
128
|
+
kind: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
129
|
+
value: typeof Schema.String;
|
|
130
|
+
}>]>>, {
|
|
131
|
+
default: () => {};
|
|
132
|
+
}>;
|
|
133
|
+
config: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>, {
|
|
134
|
+
default: () => {};
|
|
135
|
+
}>;
|
|
136
|
+
guards: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
|
|
137
|
+
kind: typeof Schema.String;
|
|
138
|
+
}, readonly [{
|
|
139
|
+
readonly key: typeof Schema.String;
|
|
140
|
+
readonly value: typeof Schema.Unknown;
|
|
141
|
+
}]>>>;
|
|
142
|
+
}>;
|
|
143
|
+
export declare const UuidSchema: Schema.filter<typeof Schema.String>;
|
|
144
|
+
export declare const LineageSchema: Schema.Struct<{
|
|
145
|
+
journeyId: Schema.filter<typeof Schema.String>;
|
|
146
|
+
parentRequestId: Schema.filter<typeof Schema.String>;
|
|
74
147
|
}>;
|
|
75
|
-
declare const
|
|
148
|
+
export declare const FlowSchema: Schema.Struct<{
|
|
149
|
+
version: Schema.Literal<[1]>;
|
|
150
|
+
id: typeof Schema.String;
|
|
151
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
152
|
+
inputs: Schema.Array$<Schema.Union<[Schema.Struct<{
|
|
76
153
|
name: typeof Schema.String;
|
|
77
154
|
resource: Schema.transform<Schema.Union<[Schema.Struct<{
|
|
78
|
-
|
|
79
|
-
|
|
155
|
+
kind: Schema.Literal<["native"]>;
|
|
156
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
80
157
|
}>, Schema.Struct<{
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
158
|
+
kind: Schema.Literal<["erc20"]>;
|
|
159
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
160
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
84
161
|
}>]>, Schema.SchemaClass<{
|
|
85
|
-
|
|
86
|
-
|
|
162
|
+
readonly kind: "native";
|
|
163
|
+
readonly chainId: number;
|
|
87
164
|
} | {
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
165
|
+
readonly kind: "erc20";
|
|
166
|
+
readonly chainId: number;
|
|
167
|
+
readonly token: string;
|
|
91
168
|
}, {
|
|
92
|
-
|
|
93
|
-
|
|
169
|
+
readonly kind: "native";
|
|
170
|
+
readonly chainId: number;
|
|
94
171
|
} | {
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
172
|
+
readonly kind: "erc20";
|
|
173
|
+
readonly chainId: number;
|
|
174
|
+
readonly token: string;
|
|
98
175
|
}, never>>;
|
|
99
|
-
}>, Schema.Struct<{
|
|
176
|
+
}>, Schema.Struct<{
|
|
100
177
|
name: typeof Schema.String;
|
|
101
178
|
type: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
102
|
-
}>]
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
}>;
|
|
106
|
-
declare const LiteralBindingSchema: Schema.Struct<{
|
|
107
|
-
kind: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
108
|
-
value: typeof Schema.String;
|
|
109
|
-
}>;
|
|
110
|
-
declare const BindValueSchema: Schema.Union<[Schema.Struct<{
|
|
111
|
-
$ref: Schema.filter<typeof Schema.String>;
|
|
112
|
-
}>, Schema.Struct<{
|
|
113
|
-
kind: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
114
|
-
value: typeof Schema.String;
|
|
115
|
-
}>]>;
|
|
116
|
-
declare const AppliedGuardSchema: Schema.TypeLiteral<{
|
|
117
|
-
kind: typeof Schema.String;
|
|
118
|
-
}, readonly [{
|
|
119
|
-
readonly key: typeof Schema.String;
|
|
120
|
-
readonly value: typeof Schema.Unknown;
|
|
121
|
-
}]>;
|
|
122
|
-
declare const CallSchema: Schema.Struct<{
|
|
123
|
-
id: Schema.filter<typeof Schema.String>;
|
|
179
|
+
}>]>>;
|
|
180
|
+
nodes: Schema.Array$<Schema.Struct<{
|
|
181
|
+
id: Schema.filter<Schema.filter<typeof Schema.String>>;
|
|
124
182
|
op: typeof Schema.String;
|
|
125
183
|
bind: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
|
|
126
|
-
|
|
184
|
+
$ref: Schema.filter<typeof Schema.String>;
|
|
127
185
|
}>, Schema.Struct<{
|
|
128
|
-
|
|
129
|
-
|
|
186
|
+
kind: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
187
|
+
value: typeof Schema.String;
|
|
130
188
|
}>]>>, {
|
|
131
|
-
|
|
189
|
+
default: () => {};
|
|
132
190
|
}>;
|
|
133
191
|
config: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>, {
|
|
134
|
-
|
|
192
|
+
default: () => {};
|
|
135
193
|
}>;
|
|
136
194
|
guards: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
|
|
137
|
-
|
|
195
|
+
kind: typeof Schema.String;
|
|
138
196
|
}, readonly [{
|
|
139
|
-
|
|
140
|
-
|
|
197
|
+
readonly key: typeof Schema.String;
|
|
198
|
+
readonly value: typeof Schema.Unknown;
|
|
141
199
|
}]>>>;
|
|
142
|
-
}
|
|
143
|
-
|
|
144
|
-
declare const LineageSchema: Schema.Struct<{
|
|
200
|
+
}>>;
|
|
201
|
+
lineage: Schema.optional<Schema.Struct<{
|
|
145
202
|
journeyId: Schema.filter<typeof Schema.String>;
|
|
146
203
|
parentRequestId: Schema.filter<typeof Schema.String>;
|
|
147
|
-
}
|
|
148
|
-
declare const FlowSchema: Schema.Struct<{
|
|
149
|
-
version: Schema.Literal<[1]>;
|
|
150
|
-
id: typeof Schema.String;
|
|
151
|
-
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
152
|
-
inputs: Schema.Array$<Schema.Union<[Schema.Struct<{
|
|
153
|
-
name: typeof Schema.String;
|
|
154
|
-
resource: Schema.transform<Schema.Union<[Schema.Struct<{
|
|
155
|
-
kind: Schema.Literal<["native"]>;
|
|
156
|
-
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
157
|
-
}>, Schema.Struct<{
|
|
158
|
-
kind: Schema.Literal<["erc20"]>;
|
|
159
|
-
token: Schema.refine<string, typeof Schema.String>;
|
|
160
|
-
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
161
|
-
}>]>, Schema.SchemaClass<{
|
|
162
|
-
readonly kind: "native";
|
|
163
|
-
readonly chainId: number;
|
|
164
|
-
} | {
|
|
165
|
-
readonly token: string;
|
|
166
|
-
readonly kind: "erc20";
|
|
167
|
-
readonly chainId: number;
|
|
168
|
-
}, {
|
|
169
|
-
readonly kind: "native";
|
|
170
|
-
readonly chainId: number;
|
|
171
|
-
} | {
|
|
172
|
-
readonly token: string;
|
|
173
|
-
readonly kind: "erc20";
|
|
174
|
-
readonly chainId: number;
|
|
175
|
-
}, never>>;
|
|
176
|
-
}>, Schema.Struct<{
|
|
177
|
-
name: typeof Schema.String;
|
|
178
|
-
type: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
179
|
-
}>]>>;
|
|
180
|
-
nodes: Schema.Array$<Schema.Struct<{
|
|
181
|
-
id: Schema.filter<typeof Schema.String>;
|
|
182
|
-
op: typeof Schema.String;
|
|
183
|
-
bind: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
|
|
184
|
-
$ref: Schema.filter<typeof Schema.String>;
|
|
185
|
-
}>, Schema.Struct<{
|
|
186
|
-
kind: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
187
|
-
value: typeof Schema.String;
|
|
188
|
-
}>]>>, {
|
|
189
|
-
default: () => {};
|
|
190
|
-
}>;
|
|
191
|
-
config: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>, {
|
|
192
|
-
default: () => {};
|
|
193
|
-
}>;
|
|
194
|
-
guards: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
|
|
195
|
-
kind: typeof Schema.String;
|
|
196
|
-
}, readonly [{
|
|
197
|
-
readonly key: typeof Schema.String;
|
|
198
|
-
readonly value: typeof Schema.Unknown;
|
|
199
|
-
}]>>>;
|
|
200
|
-
}>>;
|
|
201
|
-
lineage: Schema.optional<Schema.Struct<{
|
|
202
|
-
journeyId: Schema.filter<typeof Schema.String>;
|
|
203
|
-
parentRequestId: Schema.filter<typeof Schema.String>;
|
|
204
|
-
}>>;
|
|
204
|
+
}>>;
|
|
205
205
|
}>;
|
|
206
206
|
type SolType = typeof SolTypeSchema.Type;
|
|
207
207
|
type ResourceInput = typeof ResourceInputSchema.Type;
|
|
@@ -214,1382 +214,1387 @@ type AppliedGuard = typeof AppliedGuardSchema.Type;
|
|
|
214
214
|
type Call = typeof CallSchema.Type;
|
|
215
215
|
type Lineage = typeof LineageSchema.Type;
|
|
216
216
|
type Flow = typeof FlowSchema.Type;
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
declare const
|
|
217
|
+
//#endregion
|
|
218
|
+
//#region src/continuation.d.ts
|
|
219
|
+
export declare const CONTINUATION_COMMITMENT_OP_ID = "continuation.commitment";
|
|
220
|
+
export declare const ContinuationOutcomeSchema: Schema.transform<Schema.Struct<{
|
|
221
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
222
|
+
minAmount: Schema.filter<typeof Schema.String>;
|
|
223
|
+
destination: Schema.refine<string, typeof Schema.String>;
|
|
224
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
225
|
+
}>, Schema.SchemaClass<{
|
|
226
|
+
readonly chainId: number;
|
|
227
|
+
readonly token: string;
|
|
228
|
+
readonly minAmount: string;
|
|
229
|
+
readonly destination: string;
|
|
230
|
+
}, {
|
|
231
|
+
readonly chainId: number;
|
|
232
|
+
readonly token: string;
|
|
233
|
+
readonly minAmount: string;
|
|
234
|
+
readonly destination: string;
|
|
235
|
+
}, never>>;
|
|
236
|
+
export declare const ContinuationIntentSchema: Schema.Struct<{
|
|
237
|
+
outcomes: Schema.NonEmptyArray<Schema.transform<Schema.Struct<{
|
|
220
238
|
token: Schema.refine<string, typeof Schema.String>;
|
|
221
239
|
minAmount: Schema.filter<typeof Schema.String>;
|
|
222
240
|
destination: Schema.refine<string, typeof Schema.String>;
|
|
223
241
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
224
|
-
}>, Schema.SchemaClass<{
|
|
225
|
-
readonly token: string;
|
|
242
|
+
}>, Schema.SchemaClass<{
|
|
226
243
|
readonly chainId: number;
|
|
244
|
+
readonly token: string;
|
|
227
245
|
readonly minAmount: string;
|
|
228
246
|
readonly destination: string;
|
|
229
|
-
}, {
|
|
230
|
-
readonly token: string;
|
|
247
|
+
}, {
|
|
231
248
|
readonly chainId: number;
|
|
249
|
+
readonly token: string;
|
|
232
250
|
readonly minAmount: string;
|
|
233
251
|
readonly destination: string;
|
|
234
|
-
}, never
|
|
235
|
-
|
|
236
|
-
|
|
252
|
+
}, never>>>;
|
|
253
|
+
continuationFlow: Schema.optional<Schema.Struct<{
|
|
254
|
+
version: Schema.Literal<[1]>;
|
|
255
|
+
id: typeof Schema.String;
|
|
256
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
257
|
+
inputs: Schema.Array$<Schema.Union<[Schema.Struct<{
|
|
258
|
+
name: typeof Schema.String;
|
|
259
|
+
resource: Schema.transform<Schema.Union<[Schema.Struct<{
|
|
260
|
+
kind: Schema.Literal<["native"]>;
|
|
261
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
262
|
+
}>, Schema.Struct<{
|
|
263
|
+
kind: Schema.Literal<["erc20"]>;
|
|
237
264
|
token: Schema.refine<string, typeof Schema.String>;
|
|
238
|
-
minAmount: Schema.filter<typeof Schema.String>;
|
|
239
|
-
destination: Schema.refine<string, typeof Schema.String>;
|
|
240
265
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
241
|
-
|
|
242
|
-
readonly
|
|
266
|
+
}>]>, Schema.SchemaClass<{
|
|
267
|
+
readonly kind: "native";
|
|
268
|
+
readonly chainId: number;
|
|
269
|
+
} | {
|
|
270
|
+
readonly kind: "erc20";
|
|
243
271
|
readonly chainId: number;
|
|
244
|
-
readonly minAmount: string;
|
|
245
|
-
readonly destination: string;
|
|
246
|
-
}, {
|
|
247
272
|
readonly token: string;
|
|
273
|
+
}, {
|
|
274
|
+
readonly kind: "native";
|
|
248
275
|
readonly chainId: number;
|
|
249
|
-
|
|
250
|
-
readonly
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
}>]>, Schema.SchemaClass<{
|
|
266
|
-
readonly kind: "native";
|
|
267
|
-
readonly chainId: number;
|
|
268
|
-
} | {
|
|
269
|
-
readonly token: string;
|
|
270
|
-
readonly kind: "erc20";
|
|
271
|
-
readonly chainId: number;
|
|
272
|
-
}, {
|
|
273
|
-
readonly kind: "native";
|
|
274
|
-
readonly chainId: number;
|
|
275
|
-
} | {
|
|
276
|
-
readonly token: string;
|
|
277
|
-
readonly kind: "erc20";
|
|
278
|
-
readonly chainId: number;
|
|
279
|
-
}, never>>;
|
|
280
|
-
}>, Schema.Struct<{
|
|
281
|
-
name: typeof Schema.String;
|
|
282
|
-
type: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
283
|
-
}>]>>;
|
|
284
|
-
nodes: Schema.Array$<Schema.Struct<{
|
|
285
|
-
id: Schema.filter<typeof Schema.String>;
|
|
286
|
-
op: typeof Schema.String;
|
|
287
|
-
bind: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
|
|
288
|
-
$ref: Schema.filter<typeof Schema.String>;
|
|
289
|
-
}>, Schema.Struct<{
|
|
290
|
-
kind: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
291
|
-
value: typeof Schema.String;
|
|
292
|
-
}>]>>, {
|
|
293
|
-
default: () => {};
|
|
294
|
-
}>;
|
|
295
|
-
config: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>, {
|
|
296
|
-
default: () => {};
|
|
297
|
-
}>;
|
|
298
|
-
guards: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
|
|
299
|
-
kind: typeof Schema.String;
|
|
300
|
-
}, readonly [{
|
|
301
|
-
readonly key: typeof Schema.String;
|
|
302
|
-
readonly value: typeof Schema.Unknown;
|
|
303
|
-
}]>>>;
|
|
304
|
-
}>>;
|
|
305
|
-
lineage: Schema.optional<Schema.Struct<{
|
|
306
|
-
journeyId: Schema.filter<typeof Schema.String>;
|
|
307
|
-
parentRequestId: Schema.filter<typeof Schema.String>;
|
|
308
|
-
}>>;
|
|
309
|
-
}>>;
|
|
310
|
-
validity: Schema.Struct<{
|
|
311
|
-
expiresAtMs: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
312
|
-
}>;
|
|
313
|
-
perpetual: Schema.optional<typeof Schema.Boolean>;
|
|
314
|
-
provider: Schema.optional<typeof Schema.String>;
|
|
315
|
-
funding: Schema.optional<Schema.Literal<["inline", "external"]>>;
|
|
316
|
-
}>;
|
|
317
|
-
declare const HexStringSchema: Schema.filter<typeof Schema.String>;
|
|
318
|
-
declare const Phase1ArtifactSchema: Schema.Union<[Schema.Struct<{
|
|
319
|
-
kind: Schema.Literal<["transaction"]>;
|
|
320
|
-
funding: Schema.Literal<["inline", "external"]>;
|
|
321
|
-
transactionRequest: Schema.optional<Schema.Struct<{
|
|
322
|
-
to: typeof Schema.String;
|
|
323
|
-
data: typeof Schema.String;
|
|
276
|
+
} | {
|
|
277
|
+
readonly kind: "erc20";
|
|
278
|
+
readonly chainId: number;
|
|
279
|
+
readonly token: string;
|
|
280
|
+
}, never>>;
|
|
281
|
+
}>, Schema.Struct<{
|
|
282
|
+
name: typeof Schema.String;
|
|
283
|
+
type: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
284
|
+
}>]>>;
|
|
285
|
+
nodes: Schema.Array$<Schema.Struct<{
|
|
286
|
+
id: Schema.filter<Schema.filter<typeof Schema.String>>;
|
|
287
|
+
op: typeof Schema.String;
|
|
288
|
+
bind: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
|
|
289
|
+
$ref: Schema.filter<typeof Schema.String>;
|
|
290
|
+
}>, Schema.Struct<{
|
|
291
|
+
kind: Schema.Literal<["uint8", "uint16", "uint32", "uint64", "uint128", "uint256", "int128", "int256", "address", "bool", "bytes", "bytes4", "bytes32", "string"]>;
|
|
324
292
|
value: typeof Schema.String;
|
|
325
|
-
|
|
293
|
+
}>]>>, {
|
|
294
|
+
default: () => {};
|
|
295
|
+
}>;
|
|
296
|
+
config: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>, {
|
|
297
|
+
default: () => {};
|
|
298
|
+
}>;
|
|
299
|
+
guards: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
|
|
300
|
+
kind: typeof Schema.String;
|
|
301
|
+
}, readonly [{
|
|
302
|
+
readonly key: typeof Schema.String;
|
|
303
|
+
readonly value: typeof Schema.Unknown;
|
|
304
|
+
}]>>>;
|
|
326
305
|
}>>;
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
token: Schema.filter<typeof Schema.String>;
|
|
331
|
-
amount: typeof Schema.String;
|
|
332
|
-
cap: typeof Schema.String;
|
|
333
|
-
owner: Schema.filter<typeof Schema.String>;
|
|
334
|
-
refund: Schema.filter<typeof Schema.String>;
|
|
335
|
-
expiresAtMs: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
306
|
+
lineage: Schema.optional<Schema.Struct<{
|
|
307
|
+
journeyId: Schema.filter<typeof Schema.String>;
|
|
308
|
+
parentRequestId: Schema.filter<typeof Schema.String>;
|
|
336
309
|
}>>;
|
|
310
|
+
}>>;
|
|
311
|
+
validity: Schema.Struct<{
|
|
312
|
+
expiresAtMs: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
313
|
+
}>;
|
|
314
|
+
perpetual: Schema.optional<typeof Schema.Boolean>;
|
|
315
|
+
provider: Schema.optional<typeof Schema.String>;
|
|
316
|
+
funding: Schema.optional<Schema.Literal<["inline", "external"]>>;
|
|
317
|
+
}>;
|
|
318
|
+
export declare const HexStringSchema: Schema.filter<typeof Schema.String>;
|
|
319
|
+
export declare const Phase1ArtifactSchema: Schema.Union<[Schema.Struct<{
|
|
320
|
+
kind: Schema.Literal<["transaction"]>;
|
|
321
|
+
funding: Schema.Literal<["inline", "external"]>;
|
|
322
|
+
transactionRequest: Schema.optional<Schema.Struct<{
|
|
323
|
+
to: typeof Schema.String;
|
|
324
|
+
data: typeof Schema.String;
|
|
325
|
+
value: typeof Schema.String;
|
|
326
|
+
chainId: typeof Schema.Number;
|
|
327
|
+
}>>;
|
|
328
|
+
escrow: Schema.optional<Schema.Struct<{
|
|
329
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
330
|
+
address: Schema.filter<typeof Schema.String>;
|
|
331
|
+
token: Schema.filter<typeof Schema.String>;
|
|
332
|
+
amount: typeof Schema.String;
|
|
333
|
+
cap: typeof Schema.String;
|
|
334
|
+
owner: Schema.filter<typeof Schema.String>;
|
|
335
|
+
refund: Schema.filter<typeof Schema.String>;
|
|
336
|
+
expiresAtMs: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
337
|
+
}>>;
|
|
337
338
|
}>, Schema.Struct<{
|
|
338
|
-
|
|
339
|
-
|
|
339
|
+
kind: Schema.Literal<["signables"]>;
|
|
340
|
+
typedData: Schema.Array$<typeof Schema.Unknown>;
|
|
340
341
|
}>, Schema.Struct<{
|
|
341
|
-
|
|
342
|
+
kind: Schema.Literal<["none"]>;
|
|
342
343
|
}>]>;
|
|
343
|
-
declare const AssertionOwnerSchema: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
344
|
+
export declare const AssertionOwnerSchema: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
344
345
|
type AssertionOwner = typeof AssertionOwnerSchema.Type;
|
|
345
|
-
declare const Erc20BalanceGteSpecSchema: Schema.Struct<{
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
346
|
+
export declare const Erc20BalanceGteSpecSchema: Schema.Struct<{
|
|
347
|
+
kind: Schema.Literal<["erc20BalanceGte"]>;
|
|
348
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
349
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
350
|
+
owner: Schema.refine<string, typeof Schema.String>;
|
|
351
|
+
minAmount: Schema.filter<typeof Schema.String>;
|
|
351
352
|
}>;
|
|
352
|
-
declare const NativeBalanceGteSpecSchema: Schema.Struct<{
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
353
|
+
export declare const NativeBalanceGteSpecSchema: Schema.Struct<{
|
|
354
|
+
kind: Schema.Literal<["nativeBalanceGte"]>;
|
|
355
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
356
|
+
owner: Schema.refine<string, typeof Schema.String>;
|
|
357
|
+
minAmount: Schema.filter<typeof Schema.String>;
|
|
357
358
|
}>;
|
|
358
|
-
declare const CallCheckSpecSchema: Schema.Struct<{
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
359
|
+
export declare const CallCheckSpecSchema: Schema.Struct<{
|
|
360
|
+
kind: Schema.Literal<["call"]>;
|
|
361
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
362
|
+
to: Schema.refine<string, typeof Schema.String>;
|
|
363
|
+
calldata: Schema.refine<string, typeof Schema.String>;
|
|
364
|
+
comparator: Schema.Literal<["gte", "eq", "lte"]>;
|
|
365
|
+
value: Schema.filter<typeof Schema.String>;
|
|
365
366
|
}>;
|
|
366
|
-
declare const Erc20BalanceDeltaGteSpecSchema: Schema.Struct<{
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
367
|
+
export declare const Erc20BalanceDeltaGteSpecSchema: Schema.Struct<{
|
|
368
|
+
kind: Schema.Literal<["erc20BalanceDeltaGte"]>;
|
|
369
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
370
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
371
|
+
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
372
|
+
minDelta: Schema.filter<typeof Schema.String>;
|
|
372
373
|
}>;
|
|
373
|
-
declare const NativeBalanceDeltaGteSpecSchema: Schema.Struct<{
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
374
|
+
export declare const NativeBalanceDeltaGteSpecSchema: Schema.Struct<{
|
|
375
|
+
kind: Schema.Literal<["nativeBalanceDeltaGte"]>;
|
|
376
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
377
|
+
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
378
|
+
minDelta: Schema.filter<typeof Schema.String>;
|
|
378
379
|
}>;
|
|
379
|
-
declare const AssertionSpecSchema: Schema.Union<[Schema.Struct<{
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
380
|
+
export declare const AssertionSpecSchema: Schema.Union<[Schema.Struct<{
|
|
381
|
+
kind: Schema.Literal<["erc20BalanceGte"]>;
|
|
382
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
383
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
384
|
+
owner: Schema.refine<string, typeof Schema.String>;
|
|
385
|
+
minAmount: Schema.filter<typeof Schema.String>;
|
|
385
386
|
}>, Schema.Struct<{
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
387
|
+
kind: Schema.Literal<["nativeBalanceGte"]>;
|
|
388
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
389
|
+
owner: Schema.refine<string, typeof Schema.String>;
|
|
390
|
+
minAmount: Schema.filter<typeof Schema.String>;
|
|
390
391
|
}>, Schema.Struct<{
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
392
|
+
kind: Schema.Literal<["call"]>;
|
|
393
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
394
|
+
to: Schema.refine<string, typeof Schema.String>;
|
|
395
|
+
calldata: Schema.refine<string, typeof Schema.String>;
|
|
396
|
+
comparator: Schema.Literal<["gte", "eq", "lte"]>;
|
|
397
|
+
value: Schema.filter<typeof Schema.String>;
|
|
397
398
|
}>, Schema.Struct<{
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
399
|
+
kind: Schema.Literal<["erc20BalanceDeltaGte"]>;
|
|
400
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
401
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
402
|
+
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
403
|
+
minDelta: Schema.filter<typeof Schema.String>;
|
|
403
404
|
}>, Schema.Struct<{
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
405
|
+
kind: Schema.Literal<["nativeBalanceDeltaGte"]>;
|
|
406
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
407
|
+
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
408
|
+
minDelta: Schema.filter<typeof Schema.String>;
|
|
408
409
|
}>]>;
|
|
409
410
|
type ContinuationOutcome = typeof ContinuationOutcomeSchema.Type;
|
|
410
411
|
type ContinuationIntent = typeof ContinuationIntentSchema.Type;
|
|
411
412
|
type Phase1Artifact = typeof Phase1ArtifactSchema.Type;
|
|
412
413
|
type AssertionSpec = typeof AssertionSpecSchema.Type;
|
|
413
|
-
declare const settledOutcome: (intent: ContinuationIntent) => ContinuationOutcome;
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
declare const
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
414
|
+
export declare const settledOutcome: (intent: ContinuationIntent) => ContinuationOutcome;
|
|
415
|
+
//#endregion
|
|
416
|
+
//#region src/descriptor.d.ts
|
|
417
|
+
export declare const Bytes32HexSchema: Schema.filter<typeof Schema.String>;
|
|
418
|
+
export declare const AssertedErc20BalanceGteSpecSchema: Schema.Struct<{
|
|
419
|
+
kind: Schema.Literal<["erc20BalanceGte"]>;
|
|
420
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
421
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
422
|
+
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
423
|
+
minAmount: Schema.filter<typeof Schema.String>;
|
|
422
424
|
}>;
|
|
423
|
-
declare const AssertedNativeBalanceGteSpecSchema: Schema.Struct<{
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
425
|
+
export declare const AssertedNativeBalanceGteSpecSchema: Schema.Struct<{
|
|
426
|
+
kind: Schema.Literal<["nativeBalanceGte"]>;
|
|
427
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
428
|
+
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
429
|
+
minAmount: Schema.filter<typeof Schema.String>;
|
|
428
430
|
}>;
|
|
429
|
-
declare const AssertedPredicateSchema: Schema.transformOrFail<Schema.Union<[Schema.Struct<{
|
|
431
|
+
export declare const AssertedPredicateSchema: Schema.transformOrFail<Schema.Union<[Schema.Struct<{
|
|
432
|
+
kind: Schema.Literal<["erc20BalanceGte"]>;
|
|
433
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
434
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
435
|
+
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
436
|
+
minAmount: Schema.filter<typeof Schema.String>;
|
|
437
|
+
}>, Schema.Struct<{
|
|
438
|
+
kind: Schema.Literal<["nativeBalanceGte"]>;
|
|
439
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
440
|
+
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
441
|
+
minAmount: Schema.filter<typeof Schema.String>;
|
|
442
|
+
}>, Schema.Struct<{
|
|
443
|
+
kind: Schema.Literal<["call"]>;
|
|
444
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
445
|
+
to: Schema.refine<string, typeof Schema.String>;
|
|
446
|
+
calldata: Schema.refine<string, typeof Schema.String>;
|
|
447
|
+
comparator: Schema.Literal<["gte", "eq", "lte"]>;
|
|
448
|
+
value: Schema.filter<typeof Schema.String>;
|
|
449
|
+
}>, Schema.Struct<{
|
|
450
|
+
kind: Schema.Literal<["erc20BalanceDeltaGte"]>;
|
|
451
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
452
|
+
token: Schema.refine<string, typeof Schema.String>;
|
|
453
|
+
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
454
|
+
minDelta: Schema.filter<typeof Schema.String>;
|
|
455
|
+
}>, Schema.Struct<{
|
|
456
|
+
kind: Schema.Literal<["nativeBalanceDeltaGte"]>;
|
|
457
|
+
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
458
|
+
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
459
|
+
minDelta: Schema.filter<typeof Schema.String>;
|
|
460
|
+
}>]>, Schema.SchemaClass<{
|
|
461
|
+
readonly value: string;
|
|
462
|
+
readonly kind: "call";
|
|
463
|
+
readonly chainId: number;
|
|
464
|
+
readonly to: string;
|
|
465
|
+
readonly calldata: string;
|
|
466
|
+
readonly comparator: "gte" | "eq" | "lte";
|
|
467
|
+
} | {
|
|
468
|
+
readonly kind: "erc20BalanceDeltaGte";
|
|
469
|
+
readonly chainId: number;
|
|
470
|
+
readonly token: string;
|
|
471
|
+
readonly owner: string;
|
|
472
|
+
readonly minDelta: string;
|
|
473
|
+
} | {
|
|
474
|
+
readonly kind: "nativeBalanceDeltaGte";
|
|
475
|
+
readonly chainId: number;
|
|
476
|
+
readonly owner: string;
|
|
477
|
+
readonly minDelta: string;
|
|
478
|
+
} | {
|
|
479
|
+
readonly kind: "erc20BalanceGte";
|
|
480
|
+
readonly chainId: number;
|
|
481
|
+
readonly token: string;
|
|
482
|
+
readonly owner: string;
|
|
483
|
+
readonly minAmount: string;
|
|
484
|
+
} | {
|
|
485
|
+
readonly kind: "nativeBalanceGte";
|
|
486
|
+
readonly chainId: number;
|
|
487
|
+
readonly owner: string;
|
|
488
|
+
readonly minAmount: string;
|
|
489
|
+
}, {
|
|
490
|
+
readonly value: string;
|
|
491
|
+
readonly kind: "call";
|
|
492
|
+
readonly chainId: number;
|
|
493
|
+
readonly to: string;
|
|
494
|
+
readonly calldata: string;
|
|
495
|
+
readonly comparator: "gte" | "eq" | "lte";
|
|
496
|
+
} | {
|
|
497
|
+
readonly kind: "erc20BalanceDeltaGte";
|
|
498
|
+
readonly chainId: number;
|
|
499
|
+
readonly token: string;
|
|
500
|
+
readonly owner: string;
|
|
501
|
+
readonly minDelta: string;
|
|
502
|
+
} | {
|
|
503
|
+
readonly kind: "nativeBalanceDeltaGte";
|
|
504
|
+
readonly chainId: number;
|
|
505
|
+
readonly owner: string;
|
|
506
|
+
readonly minDelta: string;
|
|
507
|
+
} | {
|
|
508
|
+
readonly kind: "erc20BalanceGte";
|
|
509
|
+
readonly chainId: number;
|
|
510
|
+
readonly token: string;
|
|
511
|
+
readonly owner: string;
|
|
512
|
+
readonly minAmount: string;
|
|
513
|
+
} | {
|
|
514
|
+
readonly kind: "nativeBalanceGte";
|
|
515
|
+
readonly chainId: number;
|
|
516
|
+
readonly owner: string;
|
|
517
|
+
readonly minAmount: string;
|
|
518
|
+
}, never>, never>;
|
|
519
|
+
export declare const VerificationDescriptorSchema: Schema.Struct<{
|
|
520
|
+
validationProgramHash: Schema.filter<typeof Schema.String>;
|
|
521
|
+
paramsHash: Schema.filter<typeof Schema.String>;
|
|
522
|
+
assertedPredicate: Schema.Array$<Schema.transformOrFail<Schema.Union<[Schema.Struct<{
|
|
430
523
|
kind: Schema.Literal<["erc20BalanceGte"]>;
|
|
431
524
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
432
525
|
token: Schema.refine<string, typeof Schema.String>;
|
|
433
526
|
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
434
527
|
minAmount: Schema.filter<typeof Schema.String>;
|
|
435
|
-
}>, Schema.Struct<{
|
|
528
|
+
}>, Schema.Struct<{
|
|
436
529
|
kind: Schema.Literal<["nativeBalanceGte"]>;
|
|
437
530
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
438
531
|
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
439
532
|
minAmount: Schema.filter<typeof Schema.String>;
|
|
440
|
-
}>, Schema.Struct<{
|
|
533
|
+
}>, Schema.Struct<{
|
|
441
534
|
kind: Schema.Literal<["call"]>;
|
|
442
535
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
443
536
|
to: Schema.refine<string, typeof Schema.String>;
|
|
444
537
|
calldata: Schema.refine<string, typeof Schema.String>;
|
|
445
538
|
comparator: Schema.Literal<["gte", "eq", "lte"]>;
|
|
446
539
|
value: Schema.filter<typeof Schema.String>;
|
|
447
|
-
}>, Schema.Struct<{
|
|
540
|
+
}>, Schema.Struct<{
|
|
448
541
|
kind: Schema.Literal<["erc20BalanceDeltaGte"]>;
|
|
449
542
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
450
543
|
token: Schema.refine<string, typeof Schema.String>;
|
|
451
544
|
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
452
545
|
minDelta: Schema.filter<typeof Schema.String>;
|
|
453
|
-
}>, Schema.Struct<{
|
|
546
|
+
}>, Schema.Struct<{
|
|
454
547
|
kind: Schema.Literal<["nativeBalanceDeltaGte"]>;
|
|
455
548
|
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
456
549
|
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
457
550
|
minDelta: Schema.filter<typeof Schema.String>;
|
|
458
|
-
}>]>, Schema.SchemaClass<{
|
|
551
|
+
}>]>, Schema.SchemaClass<{
|
|
552
|
+
readonly value: string;
|
|
459
553
|
readonly kind: "call";
|
|
460
554
|
readonly chainId: number;
|
|
461
|
-
readonly value: string;
|
|
462
555
|
readonly to: string;
|
|
463
556
|
readonly calldata: string;
|
|
464
557
|
readonly comparator: "gte" | "eq" | "lte";
|
|
465
|
-
} | {
|
|
466
|
-
readonly token: string;
|
|
558
|
+
} | {
|
|
467
559
|
readonly kind: "erc20BalanceDeltaGte";
|
|
468
560
|
readonly chainId: number;
|
|
561
|
+
readonly token: string;
|
|
469
562
|
readonly owner: string;
|
|
470
563
|
readonly minDelta: string;
|
|
471
|
-
} | {
|
|
564
|
+
} | {
|
|
472
565
|
readonly kind: "nativeBalanceDeltaGte";
|
|
473
566
|
readonly chainId: number;
|
|
474
567
|
readonly owner: string;
|
|
475
568
|
readonly minDelta: string;
|
|
476
|
-
} | {
|
|
477
|
-
readonly token: string;
|
|
569
|
+
} | {
|
|
478
570
|
readonly kind: "erc20BalanceGte";
|
|
479
571
|
readonly chainId: number;
|
|
480
|
-
readonly
|
|
572
|
+
readonly token: string;
|
|
481
573
|
readonly owner: string;
|
|
482
|
-
|
|
574
|
+
readonly minAmount: string;
|
|
575
|
+
} | {
|
|
483
576
|
readonly kind: "nativeBalanceGte";
|
|
484
577
|
readonly chainId: number;
|
|
485
|
-
readonly minAmount: string;
|
|
486
578
|
readonly owner: string;
|
|
487
|
-
|
|
579
|
+
readonly minAmount: string;
|
|
580
|
+
}, {
|
|
581
|
+
readonly value: string;
|
|
488
582
|
readonly kind: "call";
|
|
489
583
|
readonly chainId: number;
|
|
490
|
-
readonly value: string;
|
|
491
584
|
readonly to: string;
|
|
492
585
|
readonly calldata: string;
|
|
493
586
|
readonly comparator: "gte" | "eq" | "lte";
|
|
494
|
-
} | {
|
|
495
|
-
readonly token: string;
|
|
587
|
+
} | {
|
|
496
588
|
readonly kind: "erc20BalanceDeltaGte";
|
|
497
589
|
readonly chainId: number;
|
|
590
|
+
readonly token: string;
|
|
498
591
|
readonly owner: string;
|
|
499
592
|
readonly minDelta: string;
|
|
500
|
-
} | {
|
|
593
|
+
} | {
|
|
501
594
|
readonly kind: "nativeBalanceDeltaGte";
|
|
502
595
|
readonly chainId: number;
|
|
503
596
|
readonly owner: string;
|
|
504
597
|
readonly minDelta: string;
|
|
505
|
-
} | {
|
|
506
|
-
readonly token: string;
|
|
598
|
+
} | {
|
|
507
599
|
readonly kind: "erc20BalanceGte";
|
|
508
600
|
readonly chainId: number;
|
|
509
|
-
readonly
|
|
601
|
+
readonly token: string;
|
|
510
602
|
readonly owner: string;
|
|
511
|
-
|
|
603
|
+
readonly minAmount: string;
|
|
604
|
+
} | {
|
|
512
605
|
readonly kind: "nativeBalanceGte";
|
|
513
606
|
readonly chainId: number;
|
|
514
|
-
readonly minAmount: string;
|
|
515
607
|
readonly owner: string;
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
validationProgramHash: Schema.filter<typeof Schema.String>;
|
|
519
|
-
paramsHash: Schema.filter<typeof Schema.String>;
|
|
520
|
-
assertedPredicate: Schema.Array$<Schema.transformOrFail<Schema.Union<[Schema.Struct<{
|
|
521
|
-
kind: Schema.Literal<["erc20BalanceGte"]>;
|
|
522
|
-
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
523
|
-
token: Schema.refine<string, typeof Schema.String>;
|
|
524
|
-
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
525
|
-
minAmount: Schema.filter<typeof Schema.String>;
|
|
526
|
-
}>, Schema.Struct<{
|
|
527
|
-
kind: Schema.Literal<["nativeBalanceGte"]>;
|
|
528
|
-
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
529
|
-
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
530
|
-
minAmount: Schema.filter<typeof Schema.String>;
|
|
531
|
-
}>, Schema.Struct<{
|
|
532
|
-
kind: Schema.Literal<["call"]>;
|
|
533
|
-
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
534
|
-
to: Schema.refine<string, typeof Schema.String>;
|
|
535
|
-
calldata: Schema.refine<string, typeof Schema.String>;
|
|
536
|
-
comparator: Schema.Literal<["gte", "eq", "lte"]>;
|
|
537
|
-
value: Schema.filter<typeof Schema.String>;
|
|
538
|
-
}>, Schema.Struct<{
|
|
539
|
-
kind: Schema.Literal<["erc20BalanceDeltaGte"]>;
|
|
540
|
-
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
541
|
-
token: Schema.refine<string, typeof Schema.String>;
|
|
542
|
-
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
543
|
-
minDelta: Schema.filter<typeof Schema.String>;
|
|
544
|
-
}>, Schema.Struct<{
|
|
545
|
-
kind: Schema.Literal<["nativeBalanceDeltaGte"]>;
|
|
546
|
-
chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
|
|
547
|
-
owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
|
|
548
|
-
minDelta: Schema.filter<typeof Schema.String>;
|
|
549
|
-
}>]>, Schema.SchemaClass<{
|
|
550
|
-
readonly kind: "call";
|
|
551
|
-
readonly chainId: number;
|
|
552
|
-
readonly value: string;
|
|
553
|
-
readonly to: string;
|
|
554
|
-
readonly calldata: string;
|
|
555
|
-
readonly comparator: "gte" | "eq" | "lte";
|
|
556
|
-
} | {
|
|
557
|
-
readonly token: string;
|
|
558
|
-
readonly kind: "erc20BalanceDeltaGte";
|
|
559
|
-
readonly chainId: number;
|
|
560
|
-
readonly owner: string;
|
|
561
|
-
readonly minDelta: string;
|
|
562
|
-
} | {
|
|
563
|
-
readonly kind: "nativeBalanceDeltaGte";
|
|
564
|
-
readonly chainId: number;
|
|
565
|
-
readonly owner: string;
|
|
566
|
-
readonly minDelta: string;
|
|
567
|
-
} | {
|
|
568
|
-
readonly token: string;
|
|
569
|
-
readonly kind: "erc20BalanceGte";
|
|
570
|
-
readonly chainId: number;
|
|
571
|
-
readonly minAmount: string;
|
|
572
|
-
readonly owner: string;
|
|
573
|
-
} | {
|
|
574
|
-
readonly kind: "nativeBalanceGte";
|
|
575
|
-
readonly chainId: number;
|
|
576
|
-
readonly minAmount: string;
|
|
577
|
-
readonly owner: string;
|
|
578
|
-
}, {
|
|
579
|
-
readonly kind: "call";
|
|
580
|
-
readonly chainId: number;
|
|
581
|
-
readonly value: string;
|
|
582
|
-
readonly to: string;
|
|
583
|
-
readonly calldata: string;
|
|
584
|
-
readonly comparator: "gte" | "eq" | "lte";
|
|
585
|
-
} | {
|
|
586
|
-
readonly token: string;
|
|
587
|
-
readonly kind: "erc20BalanceDeltaGte";
|
|
588
|
-
readonly chainId: number;
|
|
589
|
-
readonly owner: string;
|
|
590
|
-
readonly minDelta: string;
|
|
591
|
-
} | {
|
|
592
|
-
readonly kind: "nativeBalanceDeltaGte";
|
|
593
|
-
readonly chainId: number;
|
|
594
|
-
readonly owner: string;
|
|
595
|
-
readonly minDelta: string;
|
|
596
|
-
} | {
|
|
597
|
-
readonly token: string;
|
|
598
|
-
readonly kind: "erc20BalanceGte";
|
|
599
|
-
readonly chainId: number;
|
|
600
|
-
readonly minAmount: string;
|
|
601
|
-
readonly owner: string;
|
|
602
|
-
} | {
|
|
603
|
-
readonly kind: "nativeBalanceGte";
|
|
604
|
-
readonly chainId: number;
|
|
605
|
-
readonly minAmount: string;
|
|
606
|
-
readonly owner: string;
|
|
607
|
-
}, never>, never>>;
|
|
608
|
+
readonly minAmount: string;
|
|
609
|
+
}, never>, never>>;
|
|
608
610
|
}>;
|
|
609
|
-
declare const canonicalAssertedPredicate: (specs: readonly AssertionSpec[]) => string;
|
|
611
|
+
export declare const canonicalAssertedPredicate: (specs: readonly AssertionSpec[]) => string;
|
|
610
612
|
type VerificationDescriptor = typeof VerificationDescriptorSchema.Type;
|
|
611
613
|
type AssertedPredicate = AssertionSpec;
|
|
612
|
-
|
|
614
|
+
//#endregion
|
|
615
|
+
//#region src/resource.d.ts
|
|
613
616
|
type Availability = 'now' | 'future';
|
|
614
617
|
interface OutputAmount {
|
|
615
|
-
|
|
616
|
-
|
|
618
|
+
readonly expected: bigint;
|
|
619
|
+
readonly min?: bigint;
|
|
617
620
|
}
|
|
618
621
|
type Resource = {
|
|
619
|
-
|
|
620
|
-
|
|
622
|
+
readonly kind: 'native';
|
|
623
|
+
readonly chainId: number;
|
|
621
624
|
} | {
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
+
readonly kind: 'erc20';
|
|
626
|
+
readonly token: string;
|
|
627
|
+
readonly chainId: number;
|
|
625
628
|
};
|
|
626
|
-
declare const erc20Resource: (token: string, chainId: number) => Resource;
|
|
627
|
-
declare const nativeResource: (chainId: number) => Resource;
|
|
628
|
-
declare const isERC20Resource: (r: Resource) => r is Extract<Resource, {
|
|
629
|
-
|
|
629
|
+
export declare const erc20Resource: (token: string, chainId: number) => Resource;
|
|
630
|
+
export declare const nativeResource: (chainId: number) => Resource;
|
|
631
|
+
export declare const isERC20Resource: (r: Resource) => r is Extract<Resource, {
|
|
632
|
+
kind: "erc20";
|
|
630
633
|
}>;
|
|
631
|
-
declare const isNativeResource: (r: Resource) => r is Extract<Resource, {
|
|
632
|
-
|
|
634
|
+
export declare const isNativeResource: (r: Resource) => r is Extract<Resource, {
|
|
635
|
+
kind: "native";
|
|
633
636
|
}>;
|
|
634
|
-
declare const resourcesEqual: (a: Resource, b: Resource) => boolean;
|
|
635
|
-
declare const foldResource: <R>(r: Resource, cases: {
|
|
636
|
-
|
|
637
|
-
|
|
637
|
+
export declare const resourcesEqual: (a: Resource, b: Resource) => boolean;
|
|
638
|
+
export declare const foldResource: <R>(r: Resource, cases: {
|
|
639
|
+
readonly native: (chainId: number) => R;
|
|
640
|
+
readonly erc20: (token: string, chainId: number) => R;
|
|
638
641
|
}) => R;
|
|
639
|
-
declare const resourceToken: (r: Resource) => string;
|
|
640
|
-
declare const resourceKey: (r: Resource) => string;
|
|
641
|
-
declare const erc20Token: (r: Resource) => string;
|
|
642
|
-
|
|
642
|
+
export declare const resourceToken: (r: Resource) => string;
|
|
643
|
+
export declare const resourceKey: (r: Resource) => string;
|
|
644
|
+
export declare const erc20Token: (r: Resource) => string;
|
|
645
|
+
//#endregion
|
|
646
|
+
//#region src/output.d.ts
|
|
643
647
|
type EstimateBasis = 'simulated' | 'quoted';
|
|
644
648
|
type MinimumBasis = 'guard' | 'op' | 'declared';
|
|
645
649
|
interface Estimate {
|
|
646
|
-
|
|
647
|
-
|
|
650
|
+
readonly basis: EstimateBasis;
|
|
651
|
+
readonly value: bigint;
|
|
648
652
|
}
|
|
649
653
|
interface Minimum {
|
|
650
|
-
|
|
651
|
-
|
|
654
|
+
readonly basis: MinimumBasis;
|
|
655
|
+
readonly value: bigint;
|
|
652
656
|
}
|
|
653
657
|
interface Amount {
|
|
654
|
-
|
|
655
|
-
|
|
658
|
+
readonly estimate?: Estimate;
|
|
659
|
+
readonly minimum?: Minimum;
|
|
656
660
|
}
|
|
657
661
|
type Delivery = {
|
|
658
|
-
|
|
662
|
+
readonly when: 'now';
|
|
659
663
|
} | {
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
664
|
+
readonly when: 'future';
|
|
665
|
+
readonly etaSeconds?: number;
|
|
666
|
+
readonly provider?: string;
|
|
663
667
|
};
|
|
664
668
|
interface OutputBase {
|
|
665
|
-
|
|
666
|
-
|
|
669
|
+
readonly resource: Resource;
|
|
670
|
+
readonly amount: Amount;
|
|
667
671
|
}
|
|
668
672
|
interface ConsumedOutput extends OutputBase {
|
|
669
|
-
|
|
670
|
-
|
|
673
|
+
readonly role: 'consumed';
|
|
674
|
+
readonly consumedBy: string;
|
|
671
675
|
}
|
|
672
676
|
interface TerminalOutput extends OutputBase {
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
677
|
+
readonly role: 'terminal';
|
|
678
|
+
readonly owner: string;
|
|
679
|
+
readonly delivery: Delivery;
|
|
676
680
|
}
|
|
677
681
|
type Output = ConsumedOutput | TerminalOutput;
|
|
678
682
|
type Outputs = Record<string, Output>;
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
683
|
+
//#endregion
|
|
684
|
+
//#region src/zodSchemas.d.ts
|
|
685
|
+
export declare const ResourcePortZod: z.ZodObject<{
|
|
686
|
+
kind: z.ZodLiteral<"resource">;
|
|
687
|
+
name: z.ZodString;
|
|
688
|
+
accepts: z.ZodEnum<{
|
|
689
|
+
erc20: "erc20";
|
|
690
|
+
native: "native";
|
|
691
|
+
any: "any";
|
|
692
|
+
}>;
|
|
693
|
+
mode: z.ZodEnum<{
|
|
694
|
+
linear: "linear";
|
|
695
|
+
copy: "copy";
|
|
696
|
+
}>;
|
|
697
|
+
optional: z.ZodOptional<z.ZodBoolean>;
|
|
693
698
|
}, z.core.$strip>;
|
|
694
|
-
declare const HANDLE_UNITS: readonly ["raw", "wad", "ray", "bps", "token-decimals"];
|
|
695
|
-
declare const STATIC_SOL_TYPES: readonly ["uint256", "uint128", "uint64", "uint32", "uint16", "uint8", "address", "bool", "bytes32"];
|
|
696
|
-
declare const HandleUnitsZod: z.ZodEnum<{
|
|
699
|
+
export declare const HANDLE_UNITS: readonly ["raw", "wad", "ray", "bps", "token-decimals"];
|
|
700
|
+
export declare const STATIC_SOL_TYPES: readonly ["uint256", "uint128", "uint64", "uint32", "uint16", "uint8", "address", "bool", "bytes32"];
|
|
701
|
+
export declare const HandleUnitsZod: z.ZodEnum<{
|
|
702
|
+
raw: "raw";
|
|
703
|
+
wad: "wad";
|
|
704
|
+
ray: "ray";
|
|
705
|
+
bps: "bps";
|
|
706
|
+
"token-decimals": "token-decimals";
|
|
707
|
+
}>;
|
|
708
|
+
export declare const StaticSolTypeZod: z.ZodEnum<{
|
|
709
|
+
uint32: "uint32";
|
|
710
|
+
uint256: "uint256";
|
|
711
|
+
uint128: "uint128";
|
|
712
|
+
uint64: "uint64";
|
|
713
|
+
uint16: "uint16";
|
|
714
|
+
uint8: "uint8";
|
|
715
|
+
address: "address";
|
|
716
|
+
bool: "bool";
|
|
717
|
+
bytes32: "bytes32";
|
|
718
|
+
}>;
|
|
719
|
+
export declare const isStaticSolType: (value: string) => value is StaticSolType;
|
|
720
|
+
export declare const HandlePortZod: z.ZodObject<{
|
|
721
|
+
kind: z.ZodLiteral<"handle">;
|
|
722
|
+
name: z.ZodString;
|
|
723
|
+
type: z.ZodEnum<{
|
|
724
|
+
string: "string";
|
|
725
|
+
uint32: "uint32";
|
|
726
|
+
uint256: "uint256";
|
|
727
|
+
uint128: "uint128";
|
|
728
|
+
uint64: "uint64";
|
|
729
|
+
uint16: "uint16";
|
|
730
|
+
uint8: "uint8";
|
|
731
|
+
address: "address";
|
|
732
|
+
bool: "bool";
|
|
733
|
+
bytes32: "bytes32";
|
|
734
|
+
int128: "int128";
|
|
735
|
+
int256: "int256";
|
|
736
|
+
bytes: "bytes";
|
|
737
|
+
bytes4: "bytes4";
|
|
738
|
+
}>;
|
|
739
|
+
mode: z.ZodEnum<{
|
|
740
|
+
linear: "linear";
|
|
741
|
+
copy: "copy";
|
|
742
|
+
}>;
|
|
743
|
+
expose: z.ZodOptional<z.ZodBoolean>;
|
|
744
|
+
units: z.ZodOptional<z.ZodEnum<{
|
|
697
745
|
raw: "raw";
|
|
698
746
|
wad: "wad";
|
|
699
747
|
ray: "ray";
|
|
700
748
|
bps: "bps";
|
|
701
749
|
"token-decimals": "token-decimals";
|
|
702
|
-
}
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
|
|
750
|
+
}>>;
|
|
751
|
+
optional: z.ZodOptional<z.ZodBoolean>;
|
|
752
|
+
}, z.core.$strip>;
|
|
753
|
+
export declare const InputPortZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
754
|
+
kind: z.ZodLiteral<"resource">;
|
|
755
|
+
name: z.ZodString;
|
|
756
|
+
accepts: z.ZodEnum<{
|
|
757
|
+
erc20: "erc20";
|
|
758
|
+
native: "native";
|
|
759
|
+
any: "any";
|
|
760
|
+
}>;
|
|
761
|
+
mode: z.ZodEnum<{
|
|
762
|
+
linear: "linear";
|
|
763
|
+
copy: "copy";
|
|
764
|
+
}>;
|
|
765
|
+
optional: z.ZodOptional<z.ZodBoolean>;
|
|
766
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
767
|
+
kind: z.ZodLiteral<"handle">;
|
|
768
|
+
name: z.ZodString;
|
|
769
|
+
type: z.ZodEnum<{
|
|
770
|
+
string: "string";
|
|
706
771
|
uint32: "uint32";
|
|
707
|
-
|
|
772
|
+
uint256: "uint256";
|
|
708
773
|
uint128: "uint128";
|
|
774
|
+
uint64: "uint64";
|
|
775
|
+
uint16: "uint16";
|
|
776
|
+
uint8: "uint8";
|
|
777
|
+
address: "address";
|
|
778
|
+
bool: "bool";
|
|
779
|
+
bytes32: "bytes32";
|
|
780
|
+
int128: "int128";
|
|
781
|
+
int256: "int256";
|
|
782
|
+
bytes: "bytes";
|
|
783
|
+
bytes4: "bytes4";
|
|
784
|
+
}>;
|
|
785
|
+
mode: z.ZodEnum<{
|
|
786
|
+
linear: "linear";
|
|
787
|
+
copy: "copy";
|
|
788
|
+
}>;
|
|
789
|
+
expose: z.ZodOptional<z.ZodBoolean>;
|
|
790
|
+
units: z.ZodOptional<z.ZodEnum<{
|
|
791
|
+
raw: "raw";
|
|
792
|
+
wad: "wad";
|
|
793
|
+
ray: "ray";
|
|
794
|
+
bps: "bps";
|
|
795
|
+
"token-decimals": "token-decimals";
|
|
796
|
+
}>>;
|
|
797
|
+
optional: z.ZodOptional<z.ZodBoolean>;
|
|
798
|
+
}, z.core.$strip>], "kind">;
|
|
799
|
+
export declare const ResourceOutputPortZod: z.ZodObject<{
|
|
800
|
+
kind: z.ZodLiteral<"resource_output">;
|
|
801
|
+
name: z.ZodString;
|
|
802
|
+
mode: z.ZodEnum<{
|
|
803
|
+
linear: "linear";
|
|
804
|
+
copy: "copy";
|
|
805
|
+
}>;
|
|
806
|
+
availability: z.ZodOptional<z.ZodEnum<{
|
|
807
|
+
now: "now";
|
|
808
|
+
future: "future";
|
|
809
|
+
}>>;
|
|
810
|
+
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
811
|
+
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
812
|
+
deliveryAddressInput: z.ZodOptional<z.ZodString>;
|
|
813
|
+
countFrom: z.ZodOptional<z.ZodString>;
|
|
814
|
+
}, z.core.$strip>;
|
|
815
|
+
export declare const OutputPortZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
816
|
+
kind: z.ZodLiteral<"resource_output">;
|
|
817
|
+
name: z.ZodString;
|
|
818
|
+
mode: z.ZodEnum<{
|
|
819
|
+
linear: "linear";
|
|
820
|
+
copy: "copy";
|
|
821
|
+
}>;
|
|
822
|
+
availability: z.ZodOptional<z.ZodEnum<{
|
|
823
|
+
now: "now";
|
|
824
|
+
future: "future";
|
|
825
|
+
}>>;
|
|
826
|
+
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
827
|
+
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
828
|
+
deliveryAddressInput: z.ZodOptional<z.ZodString>;
|
|
829
|
+
countFrom: z.ZodOptional<z.ZodString>;
|
|
830
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
831
|
+
kind: z.ZodLiteral<"handle">;
|
|
832
|
+
name: z.ZodString;
|
|
833
|
+
type: z.ZodEnum<{
|
|
834
|
+
string: "string";
|
|
835
|
+
uint32: "uint32";
|
|
709
836
|
uint256: "uint256";
|
|
837
|
+
uint128: "uint128";
|
|
838
|
+
uint64: "uint64";
|
|
839
|
+
uint16: "uint16";
|
|
840
|
+
uint8: "uint8";
|
|
710
841
|
address: "address";
|
|
711
842
|
bool: "bool";
|
|
712
843
|
bytes32: "bytes32";
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
844
|
+
int128: "int128";
|
|
845
|
+
int256: "int256";
|
|
846
|
+
bytes: "bytes";
|
|
847
|
+
bytes4: "bytes4";
|
|
848
|
+
}>;
|
|
849
|
+
mode: z.ZodEnum<{
|
|
850
|
+
linear: "linear";
|
|
851
|
+
copy: "copy";
|
|
852
|
+
}>;
|
|
853
|
+
expose: z.ZodOptional<z.ZodBoolean>;
|
|
854
|
+
units: z.ZodOptional<z.ZodEnum<{
|
|
855
|
+
raw: "raw";
|
|
856
|
+
wad: "wad";
|
|
857
|
+
ray: "ray";
|
|
858
|
+
bps: "bps";
|
|
859
|
+
"token-decimals": "token-decimals";
|
|
860
|
+
}>>;
|
|
861
|
+
optional: z.ZodOptional<z.ZodBoolean>;
|
|
862
|
+
}, z.core.$strip>], "kind">;
|
|
863
|
+
export declare const ManifestOperationZod: z.ZodObject<{
|
|
864
|
+
id: z.ZodString;
|
|
865
|
+
description: z.ZodOptional<z.ZodString>;
|
|
866
|
+
inputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
867
|
+
kind: z.ZodLiteral<"resource">;
|
|
868
|
+
name: z.ZodString;
|
|
869
|
+
accepts: z.ZodEnum<{
|
|
870
|
+
erc20: "erc20";
|
|
871
|
+
native: "native";
|
|
872
|
+
any: "any";
|
|
873
|
+
}>;
|
|
874
|
+
mode: z.ZodEnum<{
|
|
875
|
+
linear: "linear";
|
|
876
|
+
copy: "copy";
|
|
877
|
+
}>;
|
|
878
|
+
optional: z.ZodOptional<z.ZodBoolean>;
|
|
879
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
716
880
|
kind: z.ZodLiteral<"handle">;
|
|
717
881
|
name: z.ZodString;
|
|
718
882
|
type: z.ZodEnum<{
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
883
|
+
string: "string";
|
|
884
|
+
uint32: "uint32";
|
|
885
|
+
uint256: "uint256";
|
|
886
|
+
uint128: "uint128";
|
|
887
|
+
uint64: "uint64";
|
|
888
|
+
uint16: "uint16";
|
|
889
|
+
uint8: "uint8";
|
|
890
|
+
address: "address";
|
|
891
|
+
bool: "bool";
|
|
892
|
+
bytes32: "bytes32";
|
|
893
|
+
int128: "int128";
|
|
894
|
+
int256: "int256";
|
|
895
|
+
bytes: "bytes";
|
|
896
|
+
bytes4: "bytes4";
|
|
733
897
|
}>;
|
|
734
898
|
mode: z.ZodEnum<{
|
|
735
|
-
|
|
736
|
-
|
|
899
|
+
linear: "linear";
|
|
900
|
+
copy: "copy";
|
|
737
901
|
}>;
|
|
738
902
|
expose: z.ZodOptional<z.ZodBoolean>;
|
|
739
903
|
units: z.ZodOptional<z.ZodEnum<{
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
904
|
+
raw: "raw";
|
|
905
|
+
wad: "wad";
|
|
906
|
+
ray: "ray";
|
|
907
|
+
bps: "bps";
|
|
908
|
+
"token-decimals": "token-decimals";
|
|
745
909
|
}>>;
|
|
746
910
|
optional: z.ZodOptional<z.ZodBoolean>;
|
|
747
|
-
}, z.core.$strip
|
|
748
|
-
|
|
749
|
-
kind: z.ZodLiteral<"
|
|
911
|
+
}, z.core.$strip>], "kind">>;
|
|
912
|
+
outputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
913
|
+
kind: z.ZodLiteral<"resource_output">;
|
|
750
914
|
name: z.ZodString;
|
|
751
|
-
accepts: z.ZodEnum<{
|
|
752
|
-
native: "native";
|
|
753
|
-
erc20: "erc20";
|
|
754
|
-
any: "any";
|
|
755
|
-
}>;
|
|
756
915
|
mode: z.ZodEnum<{
|
|
757
|
-
|
|
758
|
-
|
|
916
|
+
linear: "linear";
|
|
917
|
+
copy: "copy";
|
|
759
918
|
}>;
|
|
760
|
-
|
|
761
|
-
|
|
919
|
+
availability: z.ZodOptional<z.ZodEnum<{
|
|
920
|
+
now: "now";
|
|
921
|
+
future: "future";
|
|
922
|
+
}>>;
|
|
923
|
+
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
924
|
+
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
925
|
+
deliveryAddressInput: z.ZodOptional<z.ZodString>;
|
|
926
|
+
countFrom: z.ZodOptional<z.ZodString>;
|
|
927
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
762
928
|
kind: z.ZodLiteral<"handle">;
|
|
763
929
|
name: z.ZodString;
|
|
764
930
|
type: z.ZodEnum<{
|
|
931
|
+
string: "string";
|
|
932
|
+
uint32: "uint32";
|
|
933
|
+
uint256: "uint256";
|
|
934
|
+
uint128: "uint128";
|
|
935
|
+
uint64: "uint64";
|
|
936
|
+
uint16: "uint16";
|
|
937
|
+
uint8: "uint8";
|
|
938
|
+
address: "address";
|
|
939
|
+
bool: "bool";
|
|
940
|
+
bytes32: "bytes32";
|
|
941
|
+
int128: "int128";
|
|
942
|
+
int256: "int256";
|
|
943
|
+
bytes: "bytes";
|
|
944
|
+
bytes4: "bytes4";
|
|
945
|
+
}>;
|
|
946
|
+
mode: z.ZodEnum<{
|
|
947
|
+
linear: "linear";
|
|
948
|
+
copy: "copy";
|
|
949
|
+
}>;
|
|
950
|
+
expose: z.ZodOptional<z.ZodBoolean>;
|
|
951
|
+
units: z.ZodOptional<z.ZodEnum<{
|
|
952
|
+
raw: "raw";
|
|
953
|
+
wad: "wad";
|
|
954
|
+
ray: "ray";
|
|
955
|
+
bps: "bps";
|
|
956
|
+
"token-decimals": "token-decimals";
|
|
957
|
+
}>>;
|
|
958
|
+
optional: z.ZodOptional<z.ZodBoolean>;
|
|
959
|
+
}, z.core.$strip>], "kind">>;
|
|
960
|
+
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
961
|
+
}, z.core.$strip>;
|
|
962
|
+
export declare const GuardSelectorZod: z.ZodObject<{
|
|
963
|
+
binding: z.ZodString;
|
|
964
|
+
source: z.ZodEnum<{
|
|
965
|
+
inputs: "inputs";
|
|
966
|
+
outputs: "outputs";
|
|
967
|
+
}>;
|
|
968
|
+
match: z.ZodObject<{
|
|
969
|
+
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
970
|
+
resource: "resource";
|
|
971
|
+
handle: "handle";
|
|
972
|
+
resource_output: "resource_output";
|
|
973
|
+
}>, z.ZodArray<z.ZodEnum<{
|
|
974
|
+
resource: "resource";
|
|
975
|
+
handle: "handle";
|
|
976
|
+
resource_output: "resource_output";
|
|
977
|
+
}>>]>;
|
|
978
|
+
mode: z.ZodOptional<z.ZodEnum<{
|
|
979
|
+
linear: "linear";
|
|
980
|
+
copy: "copy";
|
|
981
|
+
}>>;
|
|
982
|
+
type: z.ZodOptional<z.ZodEnum<{
|
|
983
|
+
erc20: "erc20";
|
|
984
|
+
native: "native";
|
|
985
|
+
any: "any";
|
|
986
|
+
}>>;
|
|
987
|
+
}, z.core.$strip>;
|
|
988
|
+
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
989
|
+
kind: z.ZodLiteral<"config">;
|
|
990
|
+
configKey: z.ZodString;
|
|
991
|
+
cardinality: z.ZodEnum<{
|
|
992
|
+
one: "one";
|
|
993
|
+
many: "many";
|
|
994
|
+
}>;
|
|
995
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
996
|
+
kind: z.ZodLiteral<"all_matching">;
|
|
997
|
+
}, z.core.$strip>], "kind">;
|
|
998
|
+
}, z.core.$strip>;
|
|
999
|
+
export declare const GuardCompatibilityZod: z.ZodObject<{
|
|
1000
|
+
selectors: z.ZodArray<z.ZodObject<{
|
|
1001
|
+
binding: z.ZodString;
|
|
1002
|
+
source: z.ZodEnum<{
|
|
1003
|
+
inputs: "inputs";
|
|
1004
|
+
outputs: "outputs";
|
|
1005
|
+
}>;
|
|
1006
|
+
match: z.ZodObject<{
|
|
1007
|
+
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
1008
|
+
resource: "resource";
|
|
1009
|
+
handle: "handle";
|
|
1010
|
+
resource_output: "resource_output";
|
|
1011
|
+
}>, z.ZodArray<z.ZodEnum<{
|
|
1012
|
+
resource: "resource";
|
|
1013
|
+
handle: "handle";
|
|
1014
|
+
resource_output: "resource_output";
|
|
1015
|
+
}>>]>;
|
|
1016
|
+
mode: z.ZodOptional<z.ZodEnum<{
|
|
1017
|
+
linear: "linear";
|
|
1018
|
+
copy: "copy";
|
|
1019
|
+
}>>;
|
|
1020
|
+
type: z.ZodOptional<z.ZodEnum<{
|
|
1021
|
+
erc20: "erc20";
|
|
1022
|
+
native: "native";
|
|
1023
|
+
any: "any";
|
|
1024
|
+
}>>;
|
|
1025
|
+
}, z.core.$strip>;
|
|
1026
|
+
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1027
|
+
kind: z.ZodLiteral<"config">;
|
|
1028
|
+
configKey: z.ZodString;
|
|
1029
|
+
cardinality: z.ZodEnum<{
|
|
1030
|
+
one: "one";
|
|
1031
|
+
many: "many";
|
|
1032
|
+
}>;
|
|
1033
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1034
|
+
kind: z.ZodLiteral<"all_matching">;
|
|
1035
|
+
}, z.core.$strip>], "kind">;
|
|
1036
|
+
}, z.core.$strip>>;
|
|
1037
|
+
}, z.core.$strip>;
|
|
1038
|
+
export declare const ManifestGuardZod: z.ZodObject<{
|
|
1039
|
+
kind: z.ZodString;
|
|
1040
|
+
description: z.ZodOptional<z.ZodString>;
|
|
1041
|
+
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1042
|
+
compatibility: z.ZodOptional<z.ZodObject<{
|
|
1043
|
+
selectors: z.ZodArray<z.ZodObject<{
|
|
1044
|
+
binding: z.ZodString;
|
|
1045
|
+
source: z.ZodEnum<{
|
|
1046
|
+
inputs: "inputs";
|
|
1047
|
+
outputs: "outputs";
|
|
1048
|
+
}>;
|
|
1049
|
+
match: z.ZodObject<{
|
|
1050
|
+
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
1051
|
+
resource: "resource";
|
|
1052
|
+
handle: "handle";
|
|
1053
|
+
resource_output: "resource_output";
|
|
1054
|
+
}>, z.ZodArray<z.ZodEnum<{
|
|
1055
|
+
resource: "resource";
|
|
1056
|
+
handle: "handle";
|
|
1057
|
+
resource_output: "resource_output";
|
|
1058
|
+
}>>]>;
|
|
1059
|
+
mode: z.ZodOptional<z.ZodEnum<{
|
|
1060
|
+
linear: "linear";
|
|
1061
|
+
copy: "copy";
|
|
1062
|
+
}>>;
|
|
1063
|
+
type: z.ZodOptional<z.ZodEnum<{
|
|
1064
|
+
erc20: "erc20";
|
|
1065
|
+
native: "native";
|
|
1066
|
+
any: "any";
|
|
1067
|
+
}>>;
|
|
1068
|
+
}, z.core.$strip>;
|
|
1069
|
+
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1070
|
+
kind: z.ZodLiteral<"config">;
|
|
1071
|
+
configKey: z.ZodString;
|
|
1072
|
+
cardinality: z.ZodEnum<{
|
|
1073
|
+
one: "one";
|
|
1074
|
+
many: "many";
|
|
1075
|
+
}>;
|
|
1076
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1077
|
+
kind: z.ZodLiteral<"all_matching">;
|
|
1078
|
+
}, z.core.$strip>], "kind">;
|
|
1079
|
+
}, z.core.$strip>>;
|
|
1080
|
+
}, z.core.$strip>>;
|
|
1081
|
+
}, z.core.$strip>;
|
|
1082
|
+
export declare const ManifestMaterialiserZod: z.ZodObject<{
|
|
1083
|
+
kind: z.ZodString;
|
|
1084
|
+
description: z.ZodOptional<z.ZodString>;
|
|
1085
|
+
accepts: z.ZodEnum<{
|
|
1086
|
+
resource: "resource";
|
|
1087
|
+
any: "any";
|
|
1088
|
+
handle: "handle";
|
|
1089
|
+
}>;
|
|
1090
|
+
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1091
|
+
}, z.core.$strip>;
|
|
1092
|
+
export declare const ManifestPreconditionZod: z.ZodObject<{
|
|
1093
|
+
type: z.ZodString;
|
|
1094
|
+
description: z.ZodOptional<z.ZodString>;
|
|
1095
|
+
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1096
|
+
}, z.core.$strip>;
|
|
1097
|
+
export declare const ComposeManifestZod: z.ZodObject<{
|
|
1098
|
+
manifestVersion: z.ZodNumber;
|
|
1099
|
+
manifestHash: z.ZodString;
|
|
1100
|
+
flowSchema: z.ZodObject<{}, z.core.$loose>;
|
|
1101
|
+
operations: z.ZodArray<z.ZodObject<{
|
|
1102
|
+
id: z.ZodString;
|
|
1103
|
+
description: z.ZodOptional<z.ZodString>;
|
|
1104
|
+
inputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1105
|
+
kind: z.ZodLiteral<"resource">;
|
|
1106
|
+
name: z.ZodString;
|
|
1107
|
+
accepts: z.ZodEnum<{
|
|
1108
|
+
erc20: "erc20";
|
|
1109
|
+
native: "native";
|
|
1110
|
+
any: "any";
|
|
1111
|
+
}>;
|
|
1112
|
+
mode: z.ZodEnum<{
|
|
1113
|
+
linear: "linear";
|
|
1114
|
+
copy: "copy";
|
|
1115
|
+
}>;
|
|
1116
|
+
optional: z.ZodOptional<z.ZodBoolean>;
|
|
1117
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1118
|
+
kind: z.ZodLiteral<"handle">;
|
|
1119
|
+
name: z.ZodString;
|
|
1120
|
+
type: z.ZodEnum<{
|
|
765
1121
|
string: "string";
|
|
766
|
-
uint8: "uint8";
|
|
767
|
-
uint16: "uint16";
|
|
768
1122
|
uint32: "uint32";
|
|
769
|
-
uint64: "uint64";
|
|
770
|
-
uint128: "uint128";
|
|
771
1123
|
uint256: "uint256";
|
|
772
|
-
|
|
773
|
-
|
|
1124
|
+
uint128: "uint128";
|
|
1125
|
+
uint64: "uint64";
|
|
1126
|
+
uint16: "uint16";
|
|
1127
|
+
uint8: "uint8";
|
|
774
1128
|
address: "address";
|
|
775
1129
|
bool: "bool";
|
|
1130
|
+
bytes32: "bytes32";
|
|
1131
|
+
int128: "int128";
|
|
1132
|
+
int256: "int256";
|
|
776
1133
|
bytes: "bytes";
|
|
777
1134
|
bytes4: "bytes4";
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
mode: z.ZodEnum<{
|
|
1135
|
+
}>;
|
|
1136
|
+
mode: z.ZodEnum<{
|
|
781
1137
|
linear: "linear";
|
|
782
1138
|
copy: "copy";
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
1139
|
+
}>;
|
|
1140
|
+
expose: z.ZodOptional<z.ZodBoolean>;
|
|
1141
|
+
units: z.ZodOptional<z.ZodEnum<{
|
|
786
1142
|
raw: "raw";
|
|
787
1143
|
wad: "wad";
|
|
788
1144
|
ray: "ray";
|
|
789
1145
|
bps: "bps";
|
|
790
1146
|
"token-decimals": "token-decimals";
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
}, z.core.$strip>], "kind"
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
linear: "linear";
|
|
799
|
-
copy: "copy";
|
|
800
|
-
}>;
|
|
801
|
-
availability: z.ZodOptional<z.ZodEnum<{
|
|
802
|
-
now: "now";
|
|
803
|
-
future: "future";
|
|
804
|
-
}>>;
|
|
805
|
-
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
806
|
-
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
807
|
-
deliveryAddressInput: z.ZodOptional<z.ZodString>;
|
|
808
|
-
countFrom: z.ZodOptional<z.ZodString>;
|
|
809
|
-
}, z.core.$strip>;
|
|
810
|
-
declare const OutputPortZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
811
|
-
kind: z.ZodLiteral<"resource_output">;
|
|
812
|
-
name: z.ZodString;
|
|
813
|
-
mode: z.ZodEnum<{
|
|
1147
|
+
}>>;
|
|
1148
|
+
optional: z.ZodOptional<z.ZodBoolean>;
|
|
1149
|
+
}, z.core.$strip>], "kind">>;
|
|
1150
|
+
outputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1151
|
+
kind: z.ZodLiteral<"resource_output">;
|
|
1152
|
+
name: z.ZodString;
|
|
1153
|
+
mode: z.ZodEnum<{
|
|
814
1154
|
linear: "linear";
|
|
815
1155
|
copy: "copy";
|
|
816
|
-
|
|
817
|
-
|
|
1156
|
+
}>;
|
|
1157
|
+
availability: z.ZodOptional<z.ZodEnum<{
|
|
818
1158
|
now: "now";
|
|
819
1159
|
future: "future";
|
|
820
|
-
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
|
|
824
|
-
|
|
825
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
1160
|
+
}>>;
|
|
1161
|
+
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
1162
|
+
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
1163
|
+
deliveryAddressInput: z.ZodOptional<z.ZodString>;
|
|
1164
|
+
countFrom: z.ZodOptional<z.ZodString>;
|
|
1165
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1166
|
+
kind: z.ZodLiteral<"handle">;
|
|
1167
|
+
name: z.ZodString;
|
|
1168
|
+
type: z.ZodEnum<{
|
|
829
1169
|
string: "string";
|
|
830
|
-
uint8: "uint8";
|
|
831
|
-
uint16: "uint16";
|
|
832
1170
|
uint32: "uint32";
|
|
833
|
-
uint64: "uint64";
|
|
834
|
-
uint128: "uint128";
|
|
835
1171
|
uint256: "uint256";
|
|
836
|
-
|
|
837
|
-
|
|
1172
|
+
uint128: "uint128";
|
|
1173
|
+
uint64: "uint64";
|
|
1174
|
+
uint16: "uint16";
|
|
1175
|
+
uint8: "uint8";
|
|
838
1176
|
address: "address";
|
|
839
1177
|
bool: "bool";
|
|
1178
|
+
bytes32: "bytes32";
|
|
1179
|
+
int128: "int128";
|
|
1180
|
+
int256: "int256";
|
|
840
1181
|
bytes: "bytes";
|
|
841
1182
|
bytes4: "bytes4";
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
mode: z.ZodEnum<{
|
|
1183
|
+
}>;
|
|
1184
|
+
mode: z.ZodEnum<{
|
|
845
1185
|
linear: "linear";
|
|
846
1186
|
copy: "copy";
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
1187
|
+
}>;
|
|
1188
|
+
expose: z.ZodOptional<z.ZodBoolean>;
|
|
1189
|
+
units: z.ZodOptional<z.ZodEnum<{
|
|
850
1190
|
raw: "raw";
|
|
851
1191
|
wad: "wad";
|
|
852
1192
|
ray: "ray";
|
|
853
1193
|
bps: "bps";
|
|
854
1194
|
"token-decimals": "token-decimals";
|
|
855
|
-
|
|
856
|
-
|
|
857
|
-
}, z.core.$strip>], "kind">;
|
|
858
|
-
declare const ManifestOperationZod: z.ZodObject<{
|
|
859
|
-
id: z.ZodString;
|
|
860
|
-
description: z.ZodOptional<z.ZodString>;
|
|
861
|
-
inputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
862
|
-
kind: z.ZodLiteral<"resource">;
|
|
863
|
-
name: z.ZodString;
|
|
864
|
-
accepts: z.ZodEnum<{
|
|
865
|
-
native: "native";
|
|
866
|
-
erc20: "erc20";
|
|
867
|
-
any: "any";
|
|
868
|
-
}>;
|
|
869
|
-
mode: z.ZodEnum<{
|
|
870
|
-
linear: "linear";
|
|
871
|
-
copy: "copy";
|
|
872
|
-
}>;
|
|
873
|
-
optional: z.ZodOptional<z.ZodBoolean>;
|
|
874
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
875
|
-
kind: z.ZodLiteral<"handle">;
|
|
876
|
-
name: z.ZodString;
|
|
877
|
-
type: z.ZodEnum<{
|
|
878
|
-
string: "string";
|
|
879
|
-
uint8: "uint8";
|
|
880
|
-
uint16: "uint16";
|
|
881
|
-
uint32: "uint32";
|
|
882
|
-
uint64: "uint64";
|
|
883
|
-
uint128: "uint128";
|
|
884
|
-
uint256: "uint256";
|
|
885
|
-
int128: "int128";
|
|
886
|
-
int256: "int256";
|
|
887
|
-
address: "address";
|
|
888
|
-
bool: "bool";
|
|
889
|
-
bytes: "bytes";
|
|
890
|
-
bytes4: "bytes4";
|
|
891
|
-
bytes32: "bytes32";
|
|
892
|
-
}>;
|
|
893
|
-
mode: z.ZodEnum<{
|
|
894
|
-
linear: "linear";
|
|
895
|
-
copy: "copy";
|
|
896
|
-
}>;
|
|
897
|
-
expose: z.ZodOptional<z.ZodBoolean>;
|
|
898
|
-
units: z.ZodOptional<z.ZodEnum<{
|
|
899
|
-
raw: "raw";
|
|
900
|
-
wad: "wad";
|
|
901
|
-
ray: "ray";
|
|
902
|
-
bps: "bps";
|
|
903
|
-
"token-decimals": "token-decimals";
|
|
904
|
-
}>>;
|
|
905
|
-
optional: z.ZodOptional<z.ZodBoolean>;
|
|
906
|
-
}, z.core.$strip>], "kind">>;
|
|
907
|
-
outputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
908
|
-
kind: z.ZodLiteral<"resource_output">;
|
|
909
|
-
name: z.ZodString;
|
|
910
|
-
mode: z.ZodEnum<{
|
|
911
|
-
linear: "linear";
|
|
912
|
-
copy: "copy";
|
|
913
|
-
}>;
|
|
914
|
-
availability: z.ZodOptional<z.ZodEnum<{
|
|
915
|
-
now: "now";
|
|
916
|
-
future: "future";
|
|
917
|
-
}>>;
|
|
918
|
-
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
919
|
-
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
920
|
-
deliveryAddressInput: z.ZodOptional<z.ZodString>;
|
|
921
|
-
countFrom: z.ZodOptional<z.ZodString>;
|
|
922
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
923
|
-
kind: z.ZodLiteral<"handle">;
|
|
924
|
-
name: z.ZodString;
|
|
925
|
-
type: z.ZodEnum<{
|
|
926
|
-
string: "string";
|
|
927
|
-
uint8: "uint8";
|
|
928
|
-
uint16: "uint16";
|
|
929
|
-
uint32: "uint32";
|
|
930
|
-
uint64: "uint64";
|
|
931
|
-
uint128: "uint128";
|
|
932
|
-
uint256: "uint256";
|
|
933
|
-
int128: "int128";
|
|
934
|
-
int256: "int256";
|
|
935
|
-
address: "address";
|
|
936
|
-
bool: "bool";
|
|
937
|
-
bytes: "bytes";
|
|
938
|
-
bytes4: "bytes4";
|
|
939
|
-
bytes32: "bytes32";
|
|
940
|
-
}>;
|
|
941
|
-
mode: z.ZodEnum<{
|
|
942
|
-
linear: "linear";
|
|
943
|
-
copy: "copy";
|
|
944
|
-
}>;
|
|
945
|
-
expose: z.ZodOptional<z.ZodBoolean>;
|
|
946
|
-
units: z.ZodOptional<z.ZodEnum<{
|
|
947
|
-
raw: "raw";
|
|
948
|
-
wad: "wad";
|
|
949
|
-
ray: "ray";
|
|
950
|
-
bps: "bps";
|
|
951
|
-
"token-decimals": "token-decimals";
|
|
952
|
-
}>>;
|
|
953
|
-
optional: z.ZodOptional<z.ZodBoolean>;
|
|
1195
|
+
}>>;
|
|
1196
|
+
optional: z.ZodOptional<z.ZodBoolean>;
|
|
954
1197
|
}, z.core.$strip>], "kind">>;
|
|
955
1198
|
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
956
|
-
}, z.core.$strip
|
|
957
|
-
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
1199
|
+
}, z.core.$strip>>;
|
|
1200
|
+
guards: z.ZodArray<z.ZodObject<{
|
|
1201
|
+
kind: z.ZodString;
|
|
1202
|
+
description: z.ZodOptional<z.ZodString>;
|
|
1203
|
+
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1204
|
+
compatibility: z.ZodOptional<z.ZodObject<{
|
|
1205
|
+
selectors: z.ZodArray<z.ZodObject<{
|
|
1206
|
+
binding: z.ZodString;
|
|
1207
|
+
source: z.ZodEnum<{
|
|
1208
|
+
inputs: "inputs";
|
|
1209
|
+
outputs: "outputs";
|
|
1210
|
+
}>;
|
|
1211
|
+
match: z.ZodObject<{
|
|
1212
|
+
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
965
1213
|
resource: "resource";
|
|
966
1214
|
handle: "handle";
|
|
967
1215
|
resource_output: "resource_output";
|
|
968
|
-
|
|
1216
|
+
}>, z.ZodArray<z.ZodEnum<{
|
|
969
1217
|
resource: "resource";
|
|
970
1218
|
handle: "handle";
|
|
971
1219
|
resource_output: "resource_output";
|
|
972
|
-
|
|
973
|
-
|
|
1220
|
+
}>>]>;
|
|
1221
|
+
mode: z.ZodOptional<z.ZodEnum<{
|
|
974
1222
|
linear: "linear";
|
|
975
1223
|
copy: "copy";
|
|
976
|
-
|
|
977
|
-
|
|
978
|
-
native: "native";
|
|
1224
|
+
}>>;
|
|
1225
|
+
type: z.ZodOptional<z.ZodEnum<{
|
|
979
1226
|
erc20: "erc20";
|
|
1227
|
+
native: "native";
|
|
980
1228
|
any: "any";
|
|
981
|
-
|
|
982
|
-
}, z.core.$strip>;
|
|
983
|
-
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
984
|
-
kind: z.ZodLiteral<"config">;
|
|
985
|
-
configKey: z.ZodString;
|
|
986
|
-
cardinality: z.ZodEnum<{
|
|
987
|
-
one: "one";
|
|
988
|
-
many: "many";
|
|
989
|
-
}>;
|
|
990
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
991
|
-
kind: z.ZodLiteral<"all_matching">;
|
|
992
|
-
}, z.core.$strip>], "kind">;
|
|
993
|
-
}, z.core.$strip>;
|
|
994
|
-
declare const GuardCompatibilityZod: z.ZodObject<{
|
|
995
|
-
selectors: z.ZodArray<z.ZodObject<{
|
|
996
|
-
binding: z.ZodString;
|
|
997
|
-
source: z.ZodEnum<{
|
|
998
|
-
inputs: "inputs";
|
|
999
|
-
outputs: "outputs";
|
|
1000
|
-
}>;
|
|
1001
|
-
match: z.ZodObject<{
|
|
1002
|
-
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
1003
|
-
resource: "resource";
|
|
1004
|
-
handle: "handle";
|
|
1005
|
-
resource_output: "resource_output";
|
|
1006
|
-
}>, z.ZodArray<z.ZodEnum<{
|
|
1007
|
-
resource: "resource";
|
|
1008
|
-
handle: "handle";
|
|
1009
|
-
resource_output: "resource_output";
|
|
1010
|
-
}>>]>;
|
|
1011
|
-
mode: z.ZodOptional<z.ZodEnum<{
|
|
1012
|
-
linear: "linear";
|
|
1013
|
-
copy: "copy";
|
|
1014
|
-
}>>;
|
|
1015
|
-
type: z.ZodOptional<z.ZodEnum<{
|
|
1016
|
-
native: "native";
|
|
1017
|
-
erc20: "erc20";
|
|
1018
|
-
any: "any";
|
|
1019
|
-
}>>;
|
|
1229
|
+
}>>;
|
|
1020
1230
|
}, z.core.$strip>;
|
|
1021
1231
|
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
|
|
1027
|
-
|
|
1232
|
+
kind: z.ZodLiteral<"config">;
|
|
1233
|
+
configKey: z.ZodString;
|
|
1234
|
+
cardinality: z.ZodEnum<{
|
|
1235
|
+
one: "one";
|
|
1236
|
+
many: "many";
|
|
1237
|
+
}>;
|
|
1028
1238
|
}, z.core.$strip>, z.ZodObject<{
|
|
1029
|
-
|
|
1239
|
+
kind: z.ZodLiteral<"all_matching">;
|
|
1030
1240
|
}, z.core.$strip>], "kind">;
|
|
1241
|
+
}, z.core.$strip>>;
|
|
1031
1242
|
}, z.core.$strip>>;
|
|
1032
|
-
}, z.core.$strip
|
|
1033
|
-
|
|
1034
|
-
kind: z.ZodString;
|
|
1035
|
-
description: z.ZodOptional<z.ZodString>;
|
|
1036
|
-
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1037
|
-
compatibility: z.ZodOptional<z.ZodObject<{
|
|
1038
|
-
selectors: z.ZodArray<z.ZodObject<{
|
|
1039
|
-
binding: z.ZodString;
|
|
1040
|
-
source: z.ZodEnum<{
|
|
1041
|
-
inputs: "inputs";
|
|
1042
|
-
outputs: "outputs";
|
|
1043
|
-
}>;
|
|
1044
|
-
match: z.ZodObject<{
|
|
1045
|
-
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
1046
|
-
resource: "resource";
|
|
1047
|
-
handle: "handle";
|
|
1048
|
-
resource_output: "resource_output";
|
|
1049
|
-
}>, z.ZodArray<z.ZodEnum<{
|
|
1050
|
-
resource: "resource";
|
|
1051
|
-
handle: "handle";
|
|
1052
|
-
resource_output: "resource_output";
|
|
1053
|
-
}>>]>;
|
|
1054
|
-
mode: z.ZodOptional<z.ZodEnum<{
|
|
1055
|
-
linear: "linear";
|
|
1056
|
-
copy: "copy";
|
|
1057
|
-
}>>;
|
|
1058
|
-
type: z.ZodOptional<z.ZodEnum<{
|
|
1059
|
-
native: "native";
|
|
1060
|
-
erc20: "erc20";
|
|
1061
|
-
any: "any";
|
|
1062
|
-
}>>;
|
|
1063
|
-
}, z.core.$strip>;
|
|
1064
|
-
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1065
|
-
kind: z.ZodLiteral<"config">;
|
|
1066
|
-
configKey: z.ZodString;
|
|
1067
|
-
cardinality: z.ZodEnum<{
|
|
1068
|
-
one: "one";
|
|
1069
|
-
many: "many";
|
|
1070
|
-
}>;
|
|
1071
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1072
|
-
kind: z.ZodLiteral<"all_matching">;
|
|
1073
|
-
}, z.core.$strip>], "kind">;
|
|
1074
|
-
}, z.core.$strip>>;
|
|
1075
|
-
}, z.core.$strip>>;
|
|
1076
|
-
}, z.core.$strip>;
|
|
1077
|
-
declare const ManifestMaterialiserZod: z.ZodObject<{
|
|
1243
|
+
}, z.core.$strip>>;
|
|
1244
|
+
materialisers: z.ZodArray<z.ZodObject<{
|
|
1078
1245
|
kind: z.ZodString;
|
|
1079
1246
|
description: z.ZodOptional<z.ZodString>;
|
|
1080
1247
|
accepts: z.ZodEnum<{
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
|
|
1248
|
+
resource: "resource";
|
|
1249
|
+
any: "any";
|
|
1250
|
+
handle: "handle";
|
|
1084
1251
|
}>;
|
|
1085
1252
|
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1086
|
-
}, z.core.$strip
|
|
1087
|
-
|
|
1253
|
+
}, z.core.$strip>>;
|
|
1254
|
+
preconditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1088
1255
|
type: z.ZodString;
|
|
1089
1256
|
description: z.ZodOptional<z.ZodString>;
|
|
1090
1257
|
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1091
|
-
}, z.core.$strip
|
|
1092
|
-
declare const ComposeManifestZod: z.ZodObject<{
|
|
1093
|
-
manifestVersion: z.ZodNumber;
|
|
1094
|
-
manifestHash: z.ZodString;
|
|
1095
|
-
flowSchema: z.ZodObject<{}, z.core.$loose>;
|
|
1096
|
-
operations: z.ZodArray<z.ZodObject<{
|
|
1097
|
-
id: z.ZodString;
|
|
1098
|
-
description: z.ZodOptional<z.ZodString>;
|
|
1099
|
-
inputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1100
|
-
kind: z.ZodLiteral<"resource">;
|
|
1101
|
-
name: z.ZodString;
|
|
1102
|
-
accepts: z.ZodEnum<{
|
|
1103
|
-
native: "native";
|
|
1104
|
-
erc20: "erc20";
|
|
1105
|
-
any: "any";
|
|
1106
|
-
}>;
|
|
1107
|
-
mode: z.ZodEnum<{
|
|
1108
|
-
linear: "linear";
|
|
1109
|
-
copy: "copy";
|
|
1110
|
-
}>;
|
|
1111
|
-
optional: z.ZodOptional<z.ZodBoolean>;
|
|
1112
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1113
|
-
kind: z.ZodLiteral<"handle">;
|
|
1114
|
-
name: z.ZodString;
|
|
1115
|
-
type: z.ZodEnum<{
|
|
1116
|
-
string: "string";
|
|
1117
|
-
uint8: "uint8";
|
|
1118
|
-
uint16: "uint16";
|
|
1119
|
-
uint32: "uint32";
|
|
1120
|
-
uint64: "uint64";
|
|
1121
|
-
uint128: "uint128";
|
|
1122
|
-
uint256: "uint256";
|
|
1123
|
-
int128: "int128";
|
|
1124
|
-
int256: "int256";
|
|
1125
|
-
address: "address";
|
|
1126
|
-
bool: "bool";
|
|
1127
|
-
bytes: "bytes";
|
|
1128
|
-
bytes4: "bytes4";
|
|
1129
|
-
bytes32: "bytes32";
|
|
1130
|
-
}>;
|
|
1131
|
-
mode: z.ZodEnum<{
|
|
1132
|
-
linear: "linear";
|
|
1133
|
-
copy: "copy";
|
|
1134
|
-
}>;
|
|
1135
|
-
expose: z.ZodOptional<z.ZodBoolean>;
|
|
1136
|
-
units: z.ZodOptional<z.ZodEnum<{
|
|
1137
|
-
raw: "raw";
|
|
1138
|
-
wad: "wad";
|
|
1139
|
-
ray: "ray";
|
|
1140
|
-
bps: "bps";
|
|
1141
|
-
"token-decimals": "token-decimals";
|
|
1142
|
-
}>>;
|
|
1143
|
-
optional: z.ZodOptional<z.ZodBoolean>;
|
|
1144
|
-
}, z.core.$strip>], "kind">>;
|
|
1145
|
-
outputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1146
|
-
kind: z.ZodLiteral<"resource_output">;
|
|
1147
|
-
name: z.ZodString;
|
|
1148
|
-
mode: z.ZodEnum<{
|
|
1149
|
-
linear: "linear";
|
|
1150
|
-
copy: "copy";
|
|
1151
|
-
}>;
|
|
1152
|
-
availability: z.ZodOptional<z.ZodEnum<{
|
|
1153
|
-
now: "now";
|
|
1154
|
-
future: "future";
|
|
1155
|
-
}>>;
|
|
1156
|
-
providesMinimum: z.ZodOptional<z.ZodBoolean>;
|
|
1157
|
-
omitIfZero: z.ZodOptional<z.ZodBoolean>;
|
|
1158
|
-
deliveryAddressInput: z.ZodOptional<z.ZodString>;
|
|
1159
|
-
countFrom: z.ZodOptional<z.ZodString>;
|
|
1160
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1161
|
-
kind: z.ZodLiteral<"handle">;
|
|
1162
|
-
name: z.ZodString;
|
|
1163
|
-
type: z.ZodEnum<{
|
|
1164
|
-
string: "string";
|
|
1165
|
-
uint8: "uint8";
|
|
1166
|
-
uint16: "uint16";
|
|
1167
|
-
uint32: "uint32";
|
|
1168
|
-
uint64: "uint64";
|
|
1169
|
-
uint128: "uint128";
|
|
1170
|
-
uint256: "uint256";
|
|
1171
|
-
int128: "int128";
|
|
1172
|
-
int256: "int256";
|
|
1173
|
-
address: "address";
|
|
1174
|
-
bool: "bool";
|
|
1175
|
-
bytes: "bytes";
|
|
1176
|
-
bytes4: "bytes4";
|
|
1177
|
-
bytes32: "bytes32";
|
|
1178
|
-
}>;
|
|
1179
|
-
mode: z.ZodEnum<{
|
|
1180
|
-
linear: "linear";
|
|
1181
|
-
copy: "copy";
|
|
1182
|
-
}>;
|
|
1183
|
-
expose: z.ZodOptional<z.ZodBoolean>;
|
|
1184
|
-
units: z.ZodOptional<z.ZodEnum<{
|
|
1185
|
-
raw: "raw";
|
|
1186
|
-
wad: "wad";
|
|
1187
|
-
ray: "ray";
|
|
1188
|
-
bps: "bps";
|
|
1189
|
-
"token-decimals": "token-decimals";
|
|
1190
|
-
}>>;
|
|
1191
|
-
optional: z.ZodOptional<z.ZodBoolean>;
|
|
1192
|
-
}, z.core.$strip>], "kind">>;
|
|
1193
|
-
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1194
|
-
}, z.core.$strip>>;
|
|
1195
|
-
guards: z.ZodArray<z.ZodObject<{
|
|
1196
|
-
kind: z.ZodString;
|
|
1197
|
-
description: z.ZodOptional<z.ZodString>;
|
|
1198
|
-
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1199
|
-
compatibility: z.ZodOptional<z.ZodObject<{
|
|
1200
|
-
selectors: z.ZodArray<z.ZodObject<{
|
|
1201
|
-
binding: z.ZodString;
|
|
1202
|
-
source: z.ZodEnum<{
|
|
1203
|
-
inputs: "inputs";
|
|
1204
|
-
outputs: "outputs";
|
|
1205
|
-
}>;
|
|
1206
|
-
match: z.ZodObject<{
|
|
1207
|
-
kind: z.ZodUnion<readonly [z.ZodEnum<{
|
|
1208
|
-
resource: "resource";
|
|
1209
|
-
handle: "handle";
|
|
1210
|
-
resource_output: "resource_output";
|
|
1211
|
-
}>, z.ZodArray<z.ZodEnum<{
|
|
1212
|
-
resource: "resource";
|
|
1213
|
-
handle: "handle";
|
|
1214
|
-
resource_output: "resource_output";
|
|
1215
|
-
}>>]>;
|
|
1216
|
-
mode: z.ZodOptional<z.ZodEnum<{
|
|
1217
|
-
linear: "linear";
|
|
1218
|
-
copy: "copy";
|
|
1219
|
-
}>>;
|
|
1220
|
-
type: z.ZodOptional<z.ZodEnum<{
|
|
1221
|
-
native: "native";
|
|
1222
|
-
erc20: "erc20";
|
|
1223
|
-
any: "any";
|
|
1224
|
-
}>>;
|
|
1225
|
-
}, z.core.$strip>;
|
|
1226
|
-
selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1227
|
-
kind: z.ZodLiteral<"config">;
|
|
1228
|
-
configKey: z.ZodString;
|
|
1229
|
-
cardinality: z.ZodEnum<{
|
|
1230
|
-
one: "one";
|
|
1231
|
-
many: "many";
|
|
1232
|
-
}>;
|
|
1233
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1234
|
-
kind: z.ZodLiteral<"all_matching">;
|
|
1235
|
-
}, z.core.$strip>], "kind">;
|
|
1236
|
-
}, z.core.$strip>>;
|
|
1237
|
-
}, z.core.$strip>>;
|
|
1238
|
-
}, z.core.$strip>>;
|
|
1239
|
-
materialisers: z.ZodArray<z.ZodObject<{
|
|
1240
|
-
kind: z.ZodString;
|
|
1241
|
-
description: z.ZodOptional<z.ZodString>;
|
|
1242
|
-
accepts: z.ZodEnum<{
|
|
1243
|
-
resource: "resource";
|
|
1244
|
-
any: "any";
|
|
1245
|
-
handle: "handle";
|
|
1246
|
-
}>;
|
|
1247
|
-
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1248
|
-
}, z.core.$strip>>;
|
|
1249
|
-
preconditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1250
|
-
type: z.ZodString;
|
|
1251
|
-
description: z.ZodOptional<z.ZodString>;
|
|
1252
|
-
configSchema: z.ZodOptional<z.ZodUnknown>;
|
|
1253
|
-
}, z.core.$strip>>>;
|
|
1258
|
+
}, z.core.$strip>>>;
|
|
1254
1259
|
}, z.core.$strip>;
|
|
1255
1260
|
declare const SettlementEscrowZod: z.ZodObject<{
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1259
|
-
|
|
1260
|
-
|
|
1261
|
-
|
|
1262
|
-
|
|
1263
|
-
|
|
1261
|
+
chainId: z.ZodNumber;
|
|
1262
|
+
address: z.ZodString;
|
|
1263
|
+
token: z.ZodString;
|
|
1264
|
+
amount: z.ZodString;
|
|
1265
|
+
cap: z.ZodString;
|
|
1266
|
+
owner: z.ZodString;
|
|
1267
|
+
refund: z.ZodString;
|
|
1268
|
+
expiresAtMs: z.ZodNumber;
|
|
1264
1269
|
}, z.core.$strip>;
|
|
1265
|
-
declare const AssertionSpecZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1266
|
-
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
|
|
1270
|
+
export declare const AssertionSpecZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1271
|
+
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1272
|
+
chainId: z.ZodNumber;
|
|
1273
|
+
token: z.ZodString;
|
|
1274
|
+
owner: z.ZodString;
|
|
1275
|
+
minAmount: z.ZodString;
|
|
1271
1276
|
}, z.core.$strip>, z.ZodObject<{
|
|
1272
|
-
|
|
1273
|
-
|
|
1274
|
-
|
|
1275
|
-
|
|
1277
|
+
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1278
|
+
chainId: z.ZodNumber;
|
|
1279
|
+
owner: z.ZodString;
|
|
1280
|
+
minAmount: z.ZodString;
|
|
1276
1281
|
}, z.core.$strip>, z.ZodObject<{
|
|
1277
|
-
|
|
1278
|
-
|
|
1279
|
-
|
|
1280
|
-
|
|
1281
|
-
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
|
|
1282
|
+
kind: z.ZodLiteral<"call">;
|
|
1283
|
+
chainId: z.ZodNumber;
|
|
1284
|
+
to: z.ZodString;
|
|
1285
|
+
calldata: z.ZodString;
|
|
1286
|
+
comparator: z.ZodEnum<{
|
|
1287
|
+
gte: "gte";
|
|
1288
|
+
eq: "eq";
|
|
1289
|
+
lte: "lte";
|
|
1290
|
+
}>;
|
|
1291
|
+
value: z.ZodString;
|
|
1287
1292
|
}, z.core.$strip>, z.ZodObject<{
|
|
1288
|
-
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
|
|
1293
|
+
kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
|
|
1294
|
+
chainId: z.ZodNumber;
|
|
1295
|
+
token: z.ZodString;
|
|
1296
|
+
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1297
|
+
escrow: "escrow";
|
|
1298
|
+
delivery: "delivery";
|
|
1299
|
+
}>]>;
|
|
1300
|
+
minDelta: z.ZodString;
|
|
1296
1301
|
}, z.core.$strip>, z.ZodObject<{
|
|
1297
|
-
|
|
1298
|
-
|
|
1299
|
-
|
|
1300
|
-
|
|
1301
|
-
|
|
1302
|
-
|
|
1303
|
-
|
|
1302
|
+
kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
|
|
1303
|
+
chainId: z.ZodNumber;
|
|
1304
|
+
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1305
|
+
escrow: "escrow";
|
|
1306
|
+
delivery: "delivery";
|
|
1307
|
+
}>]>;
|
|
1308
|
+
minDelta: z.ZodString;
|
|
1304
1309
|
}, z.core.$strip>], "kind">;
|
|
1305
1310
|
type AssertionSpecWire = z.infer<typeof AssertionSpecZod>;
|
|
1306
|
-
declare const AssertedPredicateZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1311
|
+
export declare const AssertedPredicateZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1312
|
+
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1313
|
+
chainId: z.ZodNumber;
|
|
1314
|
+
token: z.ZodString;
|
|
1315
|
+
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1316
|
+
escrow: "escrow";
|
|
1317
|
+
delivery: "delivery";
|
|
1318
|
+
}>]>;
|
|
1319
|
+
minAmount: z.ZodString;
|
|
1320
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1321
|
+
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1322
|
+
chainId: z.ZodNumber;
|
|
1323
|
+
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1324
|
+
escrow: "escrow";
|
|
1325
|
+
delivery: "delivery";
|
|
1326
|
+
}>]>;
|
|
1327
|
+
minAmount: z.ZodString;
|
|
1328
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1329
|
+
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1330
|
+
chainId: z.ZodNumber;
|
|
1331
|
+
token: z.ZodString;
|
|
1332
|
+
owner: z.ZodString;
|
|
1333
|
+
minAmount: z.ZodString;
|
|
1334
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1335
|
+
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1336
|
+
chainId: z.ZodNumber;
|
|
1337
|
+
owner: z.ZodString;
|
|
1338
|
+
minAmount: z.ZodString;
|
|
1339
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1340
|
+
kind: z.ZodLiteral<"call">;
|
|
1341
|
+
chainId: z.ZodNumber;
|
|
1342
|
+
to: z.ZodString;
|
|
1343
|
+
calldata: z.ZodString;
|
|
1344
|
+
comparator: z.ZodEnum<{
|
|
1345
|
+
gte: "gte";
|
|
1346
|
+
eq: "eq";
|
|
1347
|
+
lte: "lte";
|
|
1348
|
+
}>;
|
|
1349
|
+
value: z.ZodString;
|
|
1350
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1351
|
+
kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
|
|
1352
|
+
chainId: z.ZodNumber;
|
|
1353
|
+
token: z.ZodString;
|
|
1354
|
+
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1355
|
+
escrow: "escrow";
|
|
1356
|
+
delivery: "delivery";
|
|
1357
|
+
}>]>;
|
|
1358
|
+
minDelta: z.ZodString;
|
|
1359
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1360
|
+
kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
|
|
1361
|
+
chainId: z.ZodNumber;
|
|
1362
|
+
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1363
|
+
escrow: "escrow";
|
|
1364
|
+
delivery: "delivery";
|
|
1365
|
+
}>]>;
|
|
1366
|
+
minDelta: z.ZodString;
|
|
1367
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1368
|
+
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1369
|
+
chainId: z.ZodNumber;
|
|
1370
|
+
token: z.ZodString;
|
|
1371
|
+
owner: z.ZodString;
|
|
1372
|
+
minAmount: z.ZodString;
|
|
1373
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1374
|
+
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1375
|
+
chainId: z.ZodNumber;
|
|
1376
|
+
owner: z.ZodString;
|
|
1377
|
+
minAmount: z.ZodString;
|
|
1378
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1379
|
+
kind: z.ZodLiteral<"call">;
|
|
1380
|
+
chainId: z.ZodNumber;
|
|
1381
|
+
to: z.ZodString;
|
|
1382
|
+
calldata: z.ZodString;
|
|
1383
|
+
comparator: z.ZodEnum<{
|
|
1384
|
+
gte: "gte";
|
|
1385
|
+
eq: "eq";
|
|
1386
|
+
lte: "lte";
|
|
1387
|
+
}>;
|
|
1388
|
+
value: z.ZodString;
|
|
1389
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1390
|
+
kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
|
|
1391
|
+
chainId: z.ZodNumber;
|
|
1392
|
+
token: z.ZodString;
|
|
1393
|
+
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1394
|
+
escrow: "escrow";
|
|
1395
|
+
delivery: "delivery";
|
|
1396
|
+
}>]>;
|
|
1397
|
+
minDelta: z.ZodString;
|
|
1398
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1399
|
+
kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
|
|
1400
|
+
chainId: z.ZodNumber;
|
|
1401
|
+
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1402
|
+
escrow: "escrow";
|
|
1403
|
+
delivery: "delivery";
|
|
1404
|
+
}>]>;
|
|
1405
|
+
minDelta: z.ZodString;
|
|
1406
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1407
|
+
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1408
|
+
chainId: z.ZodNumber;
|
|
1409
|
+
token: z.ZodString;
|
|
1410
|
+
owner: z.ZodString;
|
|
1411
|
+
minAmount: z.ZodString;
|
|
1412
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1413
|
+
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1414
|
+
chainId: z.ZodNumber;
|
|
1415
|
+
owner: z.ZodString;
|
|
1416
|
+
minAmount: z.ZodString;
|
|
1417
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1418
|
+
kind: z.ZodLiteral<"call">;
|
|
1419
|
+
chainId: z.ZodNumber;
|
|
1420
|
+
to: z.ZodString;
|
|
1421
|
+
calldata: z.ZodString;
|
|
1422
|
+
comparator: z.ZodEnum<{
|
|
1423
|
+
gte: "gte";
|
|
1424
|
+
eq: "eq";
|
|
1425
|
+
lte: "lte";
|
|
1426
|
+
}>;
|
|
1427
|
+
value: z.ZodString;
|
|
1428
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1429
|
+
kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
|
|
1430
|
+
chainId: z.ZodNumber;
|
|
1431
|
+
token: z.ZodString;
|
|
1432
|
+
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1433
|
+
escrow: "escrow";
|
|
1434
|
+
delivery: "delivery";
|
|
1435
|
+
}>]>;
|
|
1436
|
+
minDelta: z.ZodString;
|
|
1437
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1438
|
+
kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
|
|
1439
|
+
chainId: z.ZodNumber;
|
|
1440
|
+
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1441
|
+
escrow: "escrow";
|
|
1442
|
+
delivery: "delivery";
|
|
1443
|
+
}>]>;
|
|
1444
|
+
minDelta: z.ZodString;
|
|
1445
|
+
}, z.core.$strip>], "kind">;
|
|
1446
|
+
export declare const VerificationDescriptorZod: z.ZodObject<{
|
|
1447
|
+
validationProgramHash: z.ZodString;
|
|
1448
|
+
paramsHash: z.ZodString;
|
|
1449
|
+
assertedPredicate: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1307
1450
|
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1308
1451
|
chainId: z.ZodNumber;
|
|
1309
1452
|
token: z.ZodString;
|
|
1310
1453
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1311
|
-
|
|
1312
|
-
|
|
1454
|
+
escrow: "escrow";
|
|
1455
|
+
delivery: "delivery";
|
|
1313
1456
|
}>]>;
|
|
1314
1457
|
minAmount: z.ZodString;
|
|
1315
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1458
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1316
1459
|
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1317
1460
|
chainId: z.ZodNumber;
|
|
1318
1461
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1319
|
-
|
|
1320
|
-
|
|
1462
|
+
escrow: "escrow";
|
|
1463
|
+
delivery: "delivery";
|
|
1321
1464
|
}>]>;
|
|
1322
1465
|
minAmount: z.ZodString;
|
|
1323
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1466
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1324
1467
|
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1325
1468
|
chainId: z.ZodNumber;
|
|
1326
1469
|
token: z.ZodString;
|
|
1327
1470
|
owner: z.ZodString;
|
|
1328
1471
|
minAmount: z.ZodString;
|
|
1329
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1472
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1330
1473
|
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1331
1474
|
chainId: z.ZodNumber;
|
|
1332
1475
|
owner: z.ZodString;
|
|
1333
1476
|
minAmount: z.ZodString;
|
|
1334
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1477
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1335
1478
|
kind: z.ZodLiteral<"call">;
|
|
1336
1479
|
chainId: z.ZodNumber;
|
|
1337
1480
|
to: z.ZodString;
|
|
1338
1481
|
calldata: z.ZodString;
|
|
1339
1482
|
comparator: z.ZodEnum<{
|
|
1340
|
-
|
|
1341
|
-
|
|
1342
|
-
|
|
1483
|
+
gte: "gte";
|
|
1484
|
+
eq: "eq";
|
|
1485
|
+
lte: "lte";
|
|
1343
1486
|
}>;
|
|
1344
1487
|
value: z.ZodString;
|
|
1345
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1488
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1346
1489
|
kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
|
|
1347
1490
|
chainId: z.ZodNumber;
|
|
1348
1491
|
token: z.ZodString;
|
|
1349
1492
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1350
|
-
|
|
1351
|
-
|
|
1493
|
+
escrow: "escrow";
|
|
1494
|
+
delivery: "delivery";
|
|
1352
1495
|
}>]>;
|
|
1353
1496
|
minDelta: z.ZodString;
|
|
1354
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1497
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1355
1498
|
kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
|
|
1356
1499
|
chainId: z.ZodNumber;
|
|
1357
1500
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1358
|
-
|
|
1359
|
-
|
|
1501
|
+
escrow: "escrow";
|
|
1502
|
+
delivery: "delivery";
|
|
1360
1503
|
}>]>;
|
|
1361
1504
|
minDelta: z.ZodString;
|
|
1362
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1505
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1363
1506
|
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1364
1507
|
chainId: z.ZodNumber;
|
|
1365
1508
|
token: z.ZodString;
|
|
1366
1509
|
owner: z.ZodString;
|
|
1367
1510
|
minAmount: z.ZodString;
|
|
1368
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1511
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1369
1512
|
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1370
1513
|
chainId: z.ZodNumber;
|
|
1371
1514
|
owner: z.ZodString;
|
|
1372
1515
|
minAmount: z.ZodString;
|
|
1373
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1516
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1374
1517
|
kind: z.ZodLiteral<"call">;
|
|
1375
1518
|
chainId: z.ZodNumber;
|
|
1376
1519
|
to: z.ZodString;
|
|
1377
1520
|
calldata: z.ZodString;
|
|
1378
1521
|
comparator: z.ZodEnum<{
|
|
1379
|
-
|
|
1380
|
-
|
|
1381
|
-
|
|
1522
|
+
gte: "gte";
|
|
1523
|
+
eq: "eq";
|
|
1524
|
+
lte: "lte";
|
|
1382
1525
|
}>;
|
|
1383
1526
|
value: z.ZodString;
|
|
1384
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1527
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1385
1528
|
kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
|
|
1386
1529
|
chainId: z.ZodNumber;
|
|
1387
1530
|
token: z.ZodString;
|
|
1388
1531
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1389
|
-
|
|
1390
|
-
|
|
1532
|
+
escrow: "escrow";
|
|
1533
|
+
delivery: "delivery";
|
|
1391
1534
|
}>]>;
|
|
1392
1535
|
minDelta: z.ZodString;
|
|
1393
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1536
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1394
1537
|
kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
|
|
1395
1538
|
chainId: z.ZodNumber;
|
|
1396
1539
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1397
|
-
|
|
1398
|
-
|
|
1540
|
+
escrow: "escrow";
|
|
1541
|
+
delivery: "delivery";
|
|
1399
1542
|
}>]>;
|
|
1400
1543
|
minDelta: z.ZodString;
|
|
1401
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1544
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1402
1545
|
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1403
1546
|
chainId: z.ZodNumber;
|
|
1404
1547
|
token: z.ZodString;
|
|
1405
1548
|
owner: z.ZodString;
|
|
1406
1549
|
minAmount: z.ZodString;
|
|
1407
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1550
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1408
1551
|
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1409
1552
|
chainId: z.ZodNumber;
|
|
1410
1553
|
owner: z.ZodString;
|
|
1411
1554
|
minAmount: z.ZodString;
|
|
1412
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1555
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1413
1556
|
kind: z.ZodLiteral<"call">;
|
|
1414
1557
|
chainId: z.ZodNumber;
|
|
1415
1558
|
to: z.ZodString;
|
|
1416
1559
|
calldata: z.ZodString;
|
|
1417
1560
|
comparator: z.ZodEnum<{
|
|
1418
|
-
|
|
1419
|
-
|
|
1420
|
-
|
|
1561
|
+
gte: "gte";
|
|
1562
|
+
eq: "eq";
|
|
1563
|
+
lte: "lte";
|
|
1421
1564
|
}>;
|
|
1422
1565
|
value: z.ZodString;
|
|
1423
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1566
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1424
1567
|
kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
|
|
1425
1568
|
chainId: z.ZodNumber;
|
|
1426
1569
|
token: z.ZodString;
|
|
1427
1570
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1428
|
-
|
|
1429
|
-
|
|
1571
|
+
escrow: "escrow";
|
|
1572
|
+
delivery: "delivery";
|
|
1430
1573
|
}>]>;
|
|
1431
1574
|
minDelta: z.ZodString;
|
|
1432
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1575
|
+
}, z.core.$strip> | z.ZodObject<{
|
|
1433
1576
|
kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
|
|
1434
1577
|
chainId: z.ZodNumber;
|
|
1435
1578
|
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1436
|
-
|
|
1437
|
-
|
|
1579
|
+
escrow: "escrow";
|
|
1580
|
+
delivery: "delivery";
|
|
1438
1581
|
}>]>;
|
|
1439
1582
|
minDelta: z.ZodString;
|
|
1440
|
-
}, z.core.$strip>], "kind"
|
|
1441
|
-
declare const VerificationDescriptorZod: z.ZodObject<{
|
|
1442
|
-
validationProgramHash: z.ZodString;
|
|
1443
|
-
paramsHash: z.ZodString;
|
|
1444
|
-
assertedPredicate: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1445
|
-
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1446
|
-
chainId: z.ZodNumber;
|
|
1447
|
-
token: z.ZodString;
|
|
1448
|
-
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1449
|
-
escrow: "escrow";
|
|
1450
|
-
delivery: "delivery";
|
|
1451
|
-
}>]>;
|
|
1452
|
-
minAmount: z.ZodString;
|
|
1453
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1454
|
-
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1455
|
-
chainId: z.ZodNumber;
|
|
1456
|
-
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1457
|
-
escrow: "escrow";
|
|
1458
|
-
delivery: "delivery";
|
|
1459
|
-
}>]>;
|
|
1460
|
-
minAmount: z.ZodString;
|
|
1461
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1462
|
-
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1463
|
-
chainId: z.ZodNumber;
|
|
1464
|
-
token: z.ZodString;
|
|
1465
|
-
owner: z.ZodString;
|
|
1466
|
-
minAmount: z.ZodString;
|
|
1467
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1468
|
-
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1469
|
-
chainId: z.ZodNumber;
|
|
1470
|
-
owner: z.ZodString;
|
|
1471
|
-
minAmount: z.ZodString;
|
|
1472
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1473
|
-
kind: z.ZodLiteral<"call">;
|
|
1474
|
-
chainId: z.ZodNumber;
|
|
1475
|
-
to: z.ZodString;
|
|
1476
|
-
calldata: z.ZodString;
|
|
1477
|
-
comparator: z.ZodEnum<{
|
|
1478
|
-
gte: "gte";
|
|
1479
|
-
eq: "eq";
|
|
1480
|
-
lte: "lte";
|
|
1481
|
-
}>;
|
|
1482
|
-
value: z.ZodString;
|
|
1483
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1484
|
-
kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
|
|
1485
|
-
chainId: z.ZodNumber;
|
|
1486
|
-
token: z.ZodString;
|
|
1487
|
-
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1488
|
-
escrow: "escrow";
|
|
1489
|
-
delivery: "delivery";
|
|
1490
|
-
}>]>;
|
|
1491
|
-
minDelta: z.ZodString;
|
|
1492
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1493
|
-
kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
|
|
1494
|
-
chainId: z.ZodNumber;
|
|
1495
|
-
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1496
|
-
escrow: "escrow";
|
|
1497
|
-
delivery: "delivery";
|
|
1498
|
-
}>]>;
|
|
1499
|
-
minDelta: z.ZodString;
|
|
1500
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1501
|
-
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1502
|
-
chainId: z.ZodNumber;
|
|
1503
|
-
token: z.ZodString;
|
|
1504
|
-
owner: z.ZodString;
|
|
1505
|
-
minAmount: z.ZodString;
|
|
1506
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1507
|
-
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1508
|
-
chainId: z.ZodNumber;
|
|
1509
|
-
owner: z.ZodString;
|
|
1510
|
-
minAmount: z.ZodString;
|
|
1511
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1512
|
-
kind: z.ZodLiteral<"call">;
|
|
1513
|
-
chainId: z.ZodNumber;
|
|
1514
|
-
to: z.ZodString;
|
|
1515
|
-
calldata: z.ZodString;
|
|
1516
|
-
comparator: z.ZodEnum<{
|
|
1517
|
-
gte: "gte";
|
|
1518
|
-
eq: "eq";
|
|
1519
|
-
lte: "lte";
|
|
1520
|
-
}>;
|
|
1521
|
-
value: z.ZodString;
|
|
1522
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1523
|
-
kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
|
|
1524
|
-
chainId: z.ZodNumber;
|
|
1525
|
-
token: z.ZodString;
|
|
1526
|
-
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1527
|
-
escrow: "escrow";
|
|
1528
|
-
delivery: "delivery";
|
|
1529
|
-
}>]>;
|
|
1530
|
-
minDelta: z.ZodString;
|
|
1531
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1532
|
-
kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
|
|
1533
|
-
chainId: z.ZodNumber;
|
|
1534
|
-
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1535
|
-
escrow: "escrow";
|
|
1536
|
-
delivery: "delivery";
|
|
1537
|
-
}>]>;
|
|
1538
|
-
minDelta: z.ZodString;
|
|
1539
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
1540
|
-
kind: z.ZodLiteral<"erc20BalanceGte">;
|
|
1541
|
-
chainId: z.ZodNumber;
|
|
1542
|
-
token: z.ZodString;
|
|
1543
|
-
owner: z.ZodString;
|
|
1544
|
-
minAmount: z.ZodString;
|
|
1545
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1546
|
-
kind: z.ZodLiteral<"nativeBalanceGte">;
|
|
1547
|
-
chainId: z.ZodNumber;
|
|
1548
|
-
owner: z.ZodString;
|
|
1549
|
-
minAmount: z.ZodString;
|
|
1550
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1551
|
-
kind: z.ZodLiteral<"call">;
|
|
1552
|
-
chainId: z.ZodNumber;
|
|
1553
|
-
to: z.ZodString;
|
|
1554
|
-
calldata: z.ZodString;
|
|
1555
|
-
comparator: z.ZodEnum<{
|
|
1556
|
-
gte: "gte";
|
|
1557
|
-
eq: "eq";
|
|
1558
|
-
lte: "lte";
|
|
1559
|
-
}>;
|
|
1560
|
-
value: z.ZodString;
|
|
1561
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1562
|
-
kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
|
|
1563
|
-
chainId: z.ZodNumber;
|
|
1564
|
-
token: z.ZodString;
|
|
1565
|
-
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1566
|
-
escrow: "escrow";
|
|
1567
|
-
delivery: "delivery";
|
|
1568
|
-
}>]>;
|
|
1569
|
-
minDelta: z.ZodString;
|
|
1570
|
-
}, z.core.$strip> | z.ZodObject<{
|
|
1571
|
-
kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
|
|
1572
|
-
chainId: z.ZodNumber;
|
|
1573
|
-
owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
|
|
1574
|
-
escrow: "escrow";
|
|
1575
|
-
delivery: "delivery";
|
|
1576
|
-
}>]>;
|
|
1577
|
-
minDelta: z.ZodString;
|
|
1578
|
-
}, z.core.$strip>], "kind">>;
|
|
1583
|
+
}, z.core.$strip>], "kind">>;
|
|
1579
1584
|
}, z.core.$strip>;
|
|
1580
1585
|
type AssertedPredicateWire = z.infer<typeof AssertedPredicateZod>;
|
|
1581
1586
|
type VerificationDescriptorWire = z.infer<typeof VerificationDescriptorZod>;
|
|
1582
|
-
declare const SettlementZod: z.ZodObject<{
|
|
1583
|
-
|
|
1584
|
-
|
|
1585
|
-
|
|
1586
|
-
|
|
1587
|
-
|
|
1588
|
-
|
|
1589
|
-
|
|
1590
|
-
|
|
1591
|
-
|
|
1592
|
-
|
|
1587
|
+
export declare const SettlementZod: z.ZodObject<{
|
|
1588
|
+
escrow: z.ZodOptional<z.ZodObject<{
|
|
1589
|
+
chainId: z.ZodNumber;
|
|
1590
|
+
address: z.ZodString;
|
|
1591
|
+
token: z.ZodString;
|
|
1592
|
+
amount: z.ZodString;
|
|
1593
|
+
cap: z.ZodString;
|
|
1594
|
+
owner: z.ZodString;
|
|
1595
|
+
refund: z.ZodString;
|
|
1596
|
+
expiresAtMs: z.ZodNumber;
|
|
1597
|
+
}, z.core.$strip>>;
|
|
1593
1598
|
}, z.core.$strip>;
|
|
1594
1599
|
type ResourcePort = z.infer<typeof ResourcePortZod>;
|
|
1595
1600
|
type HandlePort = z.infer<typeof HandlePortZod>;
|
|
@@ -1607,7 +1612,8 @@ type ManifestPrecondition = z.infer<typeof ManifestPreconditionZod>;
|
|
|
1607
1612
|
type ComposeManifest = z.infer<typeof ComposeManifestZod>;
|
|
1608
1613
|
type SettlementEscrowWire = z.infer<typeof SettlementEscrowZod>;
|
|
1609
1614
|
type SettlementWire = z.infer<typeof SettlementZod>;
|
|
1610
|
-
|
|
1615
|
+
//#endregion
|
|
1616
|
+
//#region src/compile.d.ts
|
|
1611
1617
|
type SimulationPolicy = 'strict' | 'allow-revert';
|
|
1612
1618
|
/**
|
|
1613
1619
|
* Destination for sweeping proxy-held terminal resources after execution.
|
|
@@ -1615,156 +1621,157 @@ type SimulationPolicy = 'strict' | 'allow-revert';
|
|
|
1615
1621
|
* (e.g. `{ $ref: "context.sender" }`).
|
|
1616
1622
|
*/
|
|
1617
1623
|
type SweepTo = string | {
|
|
1618
|
-
|
|
1624
|
+
readonly $ref: string;
|
|
1619
1625
|
};
|
|
1620
1626
|
interface ComposeRun {
|
|
1621
|
-
|
|
1622
|
-
|
|
1623
|
-
|
|
1624
|
-
|
|
1625
|
-
|
|
1626
|
-
|
|
1627
|
-
|
|
1628
|
-
|
|
1629
|
-
|
|
1630
|
-
|
|
1631
|
-
|
|
1632
|
-
|
|
1633
|
-
|
|
1634
|
-
|
|
1635
|
-
|
|
1636
|
-
|
|
1627
|
+
readonly inputs: Record<string, InputSpec>;
|
|
1628
|
+
readonly preconditions?: readonly Precondition[];
|
|
1629
|
+
readonly signer: string;
|
|
1630
|
+
readonly assumptions?: Record<string, bigint>;
|
|
1631
|
+
readonly referrer?: string;
|
|
1632
|
+
readonly integratorFeeBps?: number;
|
|
1633
|
+
readonly maxPriceImpactBps?: number;
|
|
1634
|
+
readonly sweepTo?: SweepTo;
|
|
1635
|
+
readonly simulationPolicy?: SimulationPolicy;
|
|
1636
|
+
/**
|
|
1637
|
+
* Also simulate the final user-facing transaction. Defaults to `false`;
|
|
1638
|
+
* reverts honour `simulationPolicy` and a success is echoed back as
|
|
1639
|
+
* `userProgramSimulation`.
|
|
1640
|
+
*/
|
|
1641
|
+
readonly simulateUserProgram?: boolean;
|
|
1642
|
+
readonly checkOnChainAllowances?: boolean;
|
|
1637
1643
|
}
|
|
1638
1644
|
interface ComposeCompileRequest {
|
|
1639
|
-
|
|
1640
|
-
|
|
1645
|
+
readonly flow: Flow;
|
|
1646
|
+
readonly run: ComposeRun;
|
|
1641
1647
|
}
|
|
1642
1648
|
interface PriceImpact {
|
|
1643
|
-
|
|
1644
|
-
|
|
1645
|
-
|
|
1646
|
-
|
|
1647
|
-
|
|
1649
|
+
readonly inputValueUsd: number;
|
|
1650
|
+
readonly outputValueUsd: number;
|
|
1651
|
+
readonly impactBps: number;
|
|
1652
|
+
readonly unpricedInputs: readonly string[];
|
|
1653
|
+
readonly unpricedOutputs: readonly string[];
|
|
1648
1654
|
}
|
|
1649
1655
|
interface ApprovalEntry {
|
|
1650
|
-
|
|
1651
|
-
|
|
1652
|
-
|
|
1653
|
-
|
|
1654
|
-
|
|
1655
|
-
|
|
1656
|
-
|
|
1657
|
-
|
|
1656
|
+
readonly token: string;
|
|
1657
|
+
readonly spender: string;
|
|
1658
|
+
readonly amount: string;
|
|
1659
|
+
readonly transactionRequest: {
|
|
1660
|
+
readonly to: string;
|
|
1661
|
+
readonly data: string;
|
|
1662
|
+
readonly value: '0';
|
|
1663
|
+
};
|
|
1658
1664
|
}
|
|
1659
1665
|
interface SimulationRevert {
|
|
1660
|
-
|
|
1661
|
-
|
|
1662
|
-
|
|
1663
|
-
|
|
1664
|
-
|
|
1665
|
-
|
|
1666
|
-
|
|
1667
|
-
|
|
1668
|
-
|
|
1666
|
+
readonly code: number;
|
|
1667
|
+
readonly rawErrorBytes: string;
|
|
1668
|
+
readonly decodeResult?: {
|
|
1669
|
+
readonly errorCandidates?: readonly {
|
|
1670
|
+
readonly decodedErrorSignature: string;
|
|
1671
|
+
readonly decodedParams: readonly string[];
|
|
1672
|
+
}[];
|
|
1673
|
+
readonly error?: string;
|
|
1674
|
+
};
|
|
1669
1675
|
}
|
|
1670
1676
|
interface ComposeTransactionRequest {
|
|
1671
|
-
|
|
1672
|
-
|
|
1673
|
-
|
|
1674
|
-
|
|
1675
|
-
|
|
1677
|
+
readonly to: string;
|
|
1678
|
+
readonly chainId: number;
|
|
1679
|
+
readonly data: string;
|
|
1680
|
+
readonly value: string;
|
|
1681
|
+
readonly gasLimit?: string;
|
|
1676
1682
|
}
|
|
1677
1683
|
type ComposeAction = {
|
|
1678
|
-
|
|
1679
|
-
|
|
1680
|
-
|
|
1681
|
-
|
|
1684
|
+
readonly kind: 'transaction';
|
|
1685
|
+
readonly purpose: 'approval' | 'execute';
|
|
1686
|
+
readonly submitter: 'signer' | 'anyone';
|
|
1687
|
+
readonly transactionRequest: ComposeTransactionRequest;
|
|
1682
1688
|
} | {
|
|
1683
|
-
|
|
1684
|
-
|
|
1685
|
-
|
|
1686
|
-
|
|
1687
|
-
|
|
1689
|
+
readonly kind: 'transaction';
|
|
1690
|
+
readonly purpose: 'fundEscrow';
|
|
1691
|
+
readonly submitter: 'signer' | 'anyone';
|
|
1692
|
+
readonly transactionRequest: ComposeTransactionRequest;
|
|
1693
|
+
readonly nodeId: string;
|
|
1688
1694
|
} | {
|
|
1689
|
-
|
|
1690
|
-
|
|
1691
|
-
|
|
1692
|
-
|
|
1693
|
-
|
|
1695
|
+
readonly kind: 'typedData';
|
|
1696
|
+
readonly purpose: 'signOrder';
|
|
1697
|
+
readonly submitter: 'signer';
|
|
1698
|
+
readonly nodeId: string;
|
|
1699
|
+
readonly typedData: readonly unknown[];
|
|
1694
1700
|
};
|
|
1695
1701
|
interface ComposeContinuationData {
|
|
1696
|
-
|
|
1702
|
+
readonly settlements?: Record<string, SettlementWire>;
|
|
1697
1703
|
}
|
|
1698
1704
|
interface SpendEntry {
|
|
1699
|
-
|
|
1700
|
-
|
|
1701
|
-
|
|
1702
|
-
|
|
1703
|
-
|
|
1705
|
+
readonly input: string;
|
|
1706
|
+
readonly token: string;
|
|
1707
|
+
readonly chainId: number;
|
|
1708
|
+
readonly amount: string;
|
|
1709
|
+
readonly nodeId?: string;
|
|
1704
1710
|
}
|
|
1705
1711
|
interface ComposeFee {
|
|
1706
|
-
|
|
1707
|
-
|
|
1708
|
-
|
|
1709
|
-
|
|
1710
|
-
|
|
1711
|
-
|
|
1712
|
+
readonly input: string;
|
|
1713
|
+
readonly token: string;
|
|
1714
|
+
readonly recipient: 'lifi' | 'integrator';
|
|
1715
|
+
readonly recipientAddress: string;
|
|
1716
|
+
readonly bps: number;
|
|
1717
|
+
readonly amount?: string;
|
|
1712
1718
|
}
|
|
1713
1719
|
interface ComposeUserProgramSimulation {
|
|
1714
|
-
|
|
1715
|
-
|
|
1720
|
+
readonly status: 'ok';
|
|
1721
|
+
readonly returnData: string;
|
|
1716
1722
|
}
|
|
1717
1723
|
interface ComposeFill {
|
|
1718
|
-
|
|
1719
|
-
|
|
1724
|
+
readonly spends: readonly SpendEntry[];
|
|
1725
|
+
readonly validUntilMs?: number;
|
|
1720
1726
|
}
|
|
1721
1727
|
interface ComposeCompileSuccessData extends ComposeContinuationData {
|
|
1722
|
-
|
|
1723
|
-
|
|
1724
|
-
|
|
1725
|
-
|
|
1726
|
-
|
|
1727
|
-
|
|
1728
|
-
|
|
1729
|
-
|
|
1730
|
-
|
|
1731
|
-
|
|
1728
|
+
readonly outputs: Outputs;
|
|
1729
|
+
readonly transactionRequest?: ComposeTransactionRequest;
|
|
1730
|
+
readonly actions?: readonly ComposeAction[];
|
|
1731
|
+
readonly userProxy: string;
|
|
1732
|
+
readonly priceImpact?: PriceImpact;
|
|
1733
|
+
readonly approvals?: readonly ApprovalEntry[];
|
|
1734
|
+
readonly fees?: readonly ComposeFee[];
|
|
1735
|
+
readonly userProgramSimulation?: ComposeUserProgramSimulation;
|
|
1736
|
+
readonly fill?: ComposeFill;
|
|
1737
|
+
readonly verificationByNode?: Record<string, VerificationDescriptor>;
|
|
1732
1738
|
}
|
|
1733
1739
|
interface ComposeCompilePartialData extends ComposeContinuationData {
|
|
1734
|
-
|
|
1735
|
-
|
|
1736
|
-
|
|
1737
|
-
|
|
1738
|
-
|
|
1739
|
-
|
|
1740
|
-
|
|
1741
|
-
|
|
1740
|
+
readonly outputs: Outputs;
|
|
1741
|
+
readonly transactionRequest: ComposeTransactionRequest;
|
|
1742
|
+
readonly userProxy: string;
|
|
1743
|
+
readonly simulationRevert: SimulationRevert;
|
|
1744
|
+
readonly approvals?: readonly ApprovalEntry[];
|
|
1745
|
+
readonly actions?: readonly ComposeAction[];
|
|
1746
|
+
readonly fees?: readonly ComposeFee[];
|
|
1747
|
+
readonly userProgramSimulation?: ComposeUserProgramSimulation;
|
|
1742
1748
|
}
|
|
1743
1749
|
type ComposeCompileResult = (ComposeCompileSuccessData & {
|
|
1744
|
-
|
|
1750
|
+
readonly status: 'success';
|
|
1745
1751
|
}) | (ComposeCompilePartialData & {
|
|
1746
|
-
|
|
1747
|
-
|
|
1748
|
-
|
|
1749
|
-
|
|
1750
|
-
|
|
1752
|
+
readonly status: 'partial';
|
|
1753
|
+
readonly error: {
|
|
1754
|
+
readonly kind: string;
|
|
1755
|
+
readonly message: string;
|
|
1756
|
+
};
|
|
1751
1757
|
});
|
|
1752
|
-
|
|
1758
|
+
//#endregion
|
|
1759
|
+
//#region src/flow.d.ts
|
|
1753
1760
|
interface Port {
|
|
1754
|
-
|
|
1755
|
-
|
|
1756
|
-
|
|
1757
|
-
|
|
1758
|
-
|
|
1761
|
+
readonly name: string;
|
|
1762
|
+
readonly type: SolType;
|
|
1763
|
+
readonly mode: 'linear' | 'copy';
|
|
1764
|
+
readonly availability?: Availability;
|
|
1765
|
+
readonly resource?: Resource;
|
|
1759
1766
|
}
|
|
1760
|
-
declare const isResourceInput: (input: FlowInput) => input is ResourceInput;
|
|
1761
|
-
declare const flowInputType: (input: FlowInput) => SolType;
|
|
1762
|
-
declare const flowInputMode: (input: FlowInput) => "linear" | "copy";
|
|
1763
|
-
declare const flowInputResource: (input: FlowInput) => Resource | undefined;
|
|
1764
|
-
declare const isResourcePort: (port: OpInputPort) => port is ResourcePort;
|
|
1765
|
-
declare const isHandlePort: (port: OpInputPort | OpOutputPort) => port is HandlePort;
|
|
1766
|
-
declare const isResourceOutputPort: (port: OpInputPort | OpOutputPort) => port is ResourceOutputPort;
|
|
1767
|
-
declare const isFutureResourceOutput: (port: OpInputPort | OpOutputPort) => boolean;
|
|
1767
|
+
export declare const isResourceInput: (input: FlowInput) => input is ResourceInput;
|
|
1768
|
+
export declare const flowInputType: (input: FlowInput) => SolType;
|
|
1769
|
+
export declare const flowInputMode: (input: FlowInput) => "linear" | "copy";
|
|
1770
|
+
export declare const flowInputResource: (input: FlowInput) => Resource | undefined;
|
|
1771
|
+
export declare const isResourcePort: (port: OpInputPort) => port is ResourcePort;
|
|
1772
|
+
export declare const isHandlePort: (port: OpInputPort | OpOutputPort) => port is HandlePort;
|
|
1773
|
+
export declare const isResourceOutputPort: (port: OpInputPort | OpOutputPort) => port is ResourceOutputPort;
|
|
1774
|
+
export declare const isFutureResourceOutput: (port: OpInputPort | OpOutputPort) => boolean;
|
|
1768
1775
|
type ComposeErrorKind = 'decode_error' | 'validation_error' | 'linearity_error' | 'resolve_error' | 'preparation_error' | 'provider_error' | 'no_route_error' | 'resolution_error' | 'resolution_rejected' | 'lowering_error' | 'empty_program' | 'simulation_error' | 'simulation_setup_error' | 'simulation_insufficient_funds' | 'simulation_gas_limit' | 'simulation_rpc_error' | 'simulation_revert' | 'subgraph_simulation_revert' | 'guard_error' | 'continuation_error' | 'compilation_error' | 'verification_error' | 'price_impact_exceeded' | 'fee_resolution_error' | 'fee_resolution_unavailable' | 'flashloan_unauthorized' | 'deadline_exceeded';
|
|
1769
1776
|
/**
|
|
1770
1777
|
* Errors raised by compose routes outside the compile pipeline.
|
|
@@ -1772,155 +1779,159 @@ type ComposeErrorKind = 'decode_error' | 'validation_error' | 'linearity_error'
|
|
|
1772
1779
|
type ComposeRouteErrorKind = 'chain_validation_error' | 'unsupported_token' | 'zero_output' | 'service_unavailable' | 'verification_unavailable' | 'deployment_check_unavailable' | 'manifest_error' | 'sdk_outdated' | 'server_outdated';
|
|
1773
1780
|
type GenericComposeErrorKind = Exclude<ComposeErrorKind, 'preparation_error' | 'simulation_revert'>;
|
|
1774
1781
|
interface FailedPreparedOp {
|
|
1775
|
-
|
|
1776
|
-
|
|
1777
|
-
|
|
1778
|
-
|
|
1779
|
-
|
|
1780
|
-
|
|
1781
|
-
|
|
1782
|
+
readonly callId: string;
|
|
1783
|
+
readonly op: string;
|
|
1784
|
+
readonly kind: GenericComposeErrorKind;
|
|
1785
|
+
readonly message: string;
|
|
1786
|
+
readonly path?: string;
|
|
1787
|
+
readonly port?: string;
|
|
1788
|
+
readonly fix?: string;
|
|
1782
1789
|
}
|
|
1783
1790
|
interface ComposeErrorBase {
|
|
1784
|
-
|
|
1785
|
-
|
|
1786
|
-
|
|
1787
|
-
|
|
1791
|
+
readonly message: string;
|
|
1792
|
+
readonly path?: string;
|
|
1793
|
+
readonly port?: string;
|
|
1794
|
+
readonly fix?: string;
|
|
1788
1795
|
}
|
|
1789
1796
|
interface PreparationComposeError extends ComposeErrorBase {
|
|
1790
|
-
|
|
1791
|
-
|
|
1792
|
-
|
|
1797
|
+
readonly kind: 'preparation_error';
|
|
1798
|
+
readonly failedOps: readonly FailedPreparedOp[];
|
|
1799
|
+
readonly succeededOps: readonly string[];
|
|
1793
1800
|
}
|
|
1794
1801
|
interface SimulationRevertComposeError extends ComposeErrorBase {
|
|
1795
|
-
|
|
1796
|
-
|
|
1802
|
+
readonly kind: 'simulation_revert';
|
|
1803
|
+
readonly details?: SimulationRevert;
|
|
1797
1804
|
}
|
|
1798
1805
|
interface GenericComposeError extends ComposeErrorBase {
|
|
1799
|
-
|
|
1800
|
-
|
|
1806
|
+
readonly kind: GenericComposeErrorKind;
|
|
1807
|
+
readonly [key: string]: unknown;
|
|
1801
1808
|
}
|
|
1802
1809
|
type ComposeError = PreparationComposeError | SimulationRevertComposeError | GenericComposeError;
|
|
1803
1810
|
interface MaterialiserInputBase {
|
|
1804
|
-
|
|
1811
|
+
readonly kind: string;
|
|
1805
1812
|
}
|
|
1806
1813
|
type MaterialiserInput = MaterialiserInputBase & Record<string, unknown>;
|
|
1807
1814
|
type MaterialiserInputOf<C extends object> = MaterialiserInputBase & C;
|
|
1808
1815
|
type MaterialiserConfigOf<C extends object> = C;
|
|
1809
|
-
declare const isMaterialiserInput: (s: InputSpec) => s is MaterialiserInput;
|
|
1816
|
+
export declare const isMaterialiserInput: (s: InputSpec) => s is MaterialiserInput;
|
|
1810
1817
|
type InputSpec = bigint | string | MaterialiserInput;
|
|
1811
1818
|
interface PreconditionBase {
|
|
1812
|
-
|
|
1819
|
+
readonly type: string;
|
|
1813
1820
|
}
|
|
1814
1821
|
type Precondition = PreconditionBase & Record<string, unknown>;
|
|
1815
1822
|
type PreconditionOf<C extends object> = PreconditionBase & C;
|
|
1816
1823
|
type PreconditionConfigOf<C extends object> = Omit<PreconditionBase, 'type'> & C;
|
|
1817
|
-
|
|
1818
|
-
|
|
1819
|
-
|
|
1820
|
-
|
|
1821
|
-
|
|
1822
|
-
|
|
1824
|
+
//#endregion
|
|
1825
|
+
//#region src/flashloan.d.ts
|
|
1826
|
+
export declare const PROVIDER_KIND: {
|
|
1827
|
+
readonly AAVE_V3: 0;
|
|
1828
|
+
readonly ERC3156: 1;
|
|
1829
|
+
readonly BALANCER_V2: 2;
|
|
1830
|
+
readonly MORPHO_BLUE: 3;
|
|
1823
1831
|
};
|
|
1824
|
-
declare const providerKindNames: readonly ["aave-v3", "erc3156", "balancer-v2", "morpho-blue"];
|
|
1832
|
+
export declare const providerKindNames: readonly ["aave-v3", "erc3156", "balancer-v2", "morpho-blue"];
|
|
1825
1833
|
type ProviderKindName = (typeof providerKindNames)[number];
|
|
1826
|
-
declare const providerKindByName: Record<ProviderKindName, number>;
|
|
1834
|
+
export declare const providerKindByName: Record<ProviderKindName, number>;
|
|
1827
1835
|
interface FlashloanMaterialiserInput {
|
|
1828
|
-
|
|
1829
|
-
|
|
1830
|
-
|
|
1836
|
+
readonly kind: 'flashloan';
|
|
1837
|
+
readonly providerKind: ProviderKindName;
|
|
1838
|
+
readonly amount: string;
|
|
1831
1839
|
}
|
|
1832
|
-
|
|
1840
|
+
//#endregion
|
|
1841
|
+
//#region src/constructors.d.ts
|
|
1833
1842
|
interface OpHandleOptions<Opt extends boolean = boolean> {
|
|
1834
|
-
|
|
1835
|
-
|
|
1836
|
-
|
|
1843
|
+
readonly expose?: boolean;
|
|
1844
|
+
readonly units?: HandleUnits;
|
|
1845
|
+
readonly optional?: Opt;
|
|
1837
1846
|
}
|
|
1838
|
-
declare const linear: <N extends string, T extends SolType>(name: N, type: T) => Port & {
|
|
1839
|
-
|
|
1840
|
-
|
|
1841
|
-
|
|
1847
|
+
export declare const linear: <N extends string, T extends SolType>(name: N, type: T) => Port & {
|
|
1848
|
+
readonly name: N;
|
|
1849
|
+
readonly type: T;
|
|
1850
|
+
readonly mode: "linear";
|
|
1842
1851
|
};
|
|
1843
|
-
declare const copy: <N extends string, T extends SolType>(name: N, type: T) => Port & {
|
|
1844
|
-
|
|
1845
|
-
|
|
1846
|
-
|
|
1852
|
+
export declare const copy: <N extends string, T extends SolType>(name: N, type: T) => Port & {
|
|
1853
|
+
readonly name: N;
|
|
1854
|
+
readonly type: T;
|
|
1855
|
+
readonly mode: "copy";
|
|
1847
1856
|
};
|
|
1848
|
-
declare const handle: <N extends string, T extends SolType>(name: N, type: T) => HandleInput & {
|
|
1849
|
-
|
|
1850
|
-
|
|
1857
|
+
export declare const handle: <N extends string, T extends SolType>(name: N, type: T) => HandleInput & {
|
|
1858
|
+
readonly name: N;
|
|
1859
|
+
readonly type: T;
|
|
1851
1860
|
};
|
|
1852
|
-
declare const native: <N extends string>(name: N, chainId: number) => ResourceInput & {
|
|
1853
|
-
|
|
1861
|
+
export declare const native: <N extends string>(name: N, chainId: number) => ResourceInput & {
|
|
1862
|
+
readonly name: N;
|
|
1854
1863
|
};
|
|
1855
|
-
declare const erc20: <N extends string>(name: N, token: string, chainId: number) => ResourceInput & {
|
|
1856
|
-
|
|
1864
|
+
export declare const erc20: <N extends string>(name: N, token: string, chainId: number) => ResourceInput & {
|
|
1865
|
+
readonly name: N;
|
|
1857
1866
|
};
|
|
1858
|
-
declare const resource: <N extends string, Opt extends boolean = false>(name: N, accepts: "erc20" | "native" | "any", options?: {
|
|
1859
|
-
|
|
1867
|
+
export declare const resource: <N extends string, Opt extends boolean = false>(name: N, accepts: "erc20" | "native" | "any", options?: {
|
|
1868
|
+
readonly optional?: Opt;
|
|
1860
1869
|
}) => ResourcePort & {
|
|
1861
|
-
|
|
1862
|
-
|
|
1870
|
+
readonly name: N;
|
|
1871
|
+
readonly optional: NoInfer<Opt>;
|
|
1863
1872
|
};
|
|
1864
|
-
declare const readResource: <N extends string>(name: N, accepts: "erc20" | "native" | "any") => ResourcePort & {
|
|
1865
|
-
|
|
1866
|
-
|
|
1873
|
+
export declare const readResource: <N extends string>(name: N, accepts: "erc20" | "native" | "any") => ResourcePort & {
|
|
1874
|
+
readonly name: N;
|
|
1875
|
+
readonly mode: "copy";
|
|
1867
1876
|
};
|
|
1868
|
-
declare const opHandle: <N extends string, T extends SolType, Opt extends boolean = false>(name: N, type: T, options?: OpHandleOptions<Opt>) => HandlePort & {
|
|
1869
|
-
|
|
1870
|
-
|
|
1871
|
-
|
|
1877
|
+
export declare const opHandle: <N extends string, T extends SolType, Opt extends boolean = false>(name: N, type: T, options?: OpHandleOptions<Opt>) => HandlePort & {
|
|
1878
|
+
readonly name: N;
|
|
1879
|
+
readonly type: T;
|
|
1880
|
+
readonly optional: NoInfer<Opt>;
|
|
1872
1881
|
};
|
|
1873
1882
|
type ResourceOutputOptions = Availability | {
|
|
1874
|
-
|
|
1875
|
-
|
|
1876
|
-
|
|
1877
|
-
|
|
1878
|
-
|
|
1883
|
+
readonly availability?: Availability;
|
|
1884
|
+
readonly providesMinimum?: boolean;
|
|
1885
|
+
readonly omitIfZero?: boolean;
|
|
1886
|
+
readonly deliveryAddressInput?: string;
|
|
1887
|
+
readonly countFrom?: string;
|
|
1879
1888
|
};
|
|
1880
1889
|
type OutputCountFrom<O> = O extends {
|
|
1881
|
-
|
|
1890
|
+
readonly countFrom: infer K extends string;
|
|
1882
1891
|
} ? {
|
|
1883
|
-
|
|
1892
|
+
readonly countFrom: K;
|
|
1884
1893
|
} : unknown;
|
|
1885
1894
|
type OutputAvailability<O> = [O] extends ['future'] ? 'future' : [O] extends ['now'] ? 'now' : [O] extends [string] ? Availability : O extends {
|
|
1886
|
-
|
|
1895
|
+
readonly availability: infer A;
|
|
1887
1896
|
} ? [A] extends ['future'] ? 'future' : [A] extends ['now'] ? 'now' : Availability : 'now';
|
|
1888
|
-
declare const resourceOutput: <N extends string, const O extends ResourceOutputOptions = "now">(name: N, options?: O) => ResourceOutputPort & {
|
|
1889
|
-
|
|
1890
|
-
|
|
1897
|
+
export declare const resourceOutput: <N extends string, const O extends ResourceOutputOptions = "now">(name: N, options?: O) => ResourceOutputPort & {
|
|
1898
|
+
readonly name: N;
|
|
1899
|
+
readonly availability: OutputAvailability<O>;
|
|
1891
1900
|
} & OutputCountFrom<O>;
|
|
1892
|
-
|
|
1901
|
+
//#endregion
|
|
1902
|
+
//#region src/outputFamilies.d.ts
|
|
1893
1903
|
type OutputFamilyPort = ResourceOutputPort & {
|
|
1894
|
-
|
|
1904
|
+
readonly countFrom: string;
|
|
1895
1905
|
};
|
|
1896
|
-
declare const isOutputFamily: (port: OpOutputPort) => port is OutputFamilyPort;
|
|
1897
|
-
declare const instancePortName: (family: string, index: number) => string;
|
|
1898
|
-
declare const familySize: (family: Pick<OutputFamilyPort, "name" | "countFrom">, config: Call["config"]) => number;
|
|
1899
|
-
declare const expandOutputPorts: (declared: readonly OpOutputPort[], config: Call["config"]) => readonly OpOutputPort[];
|
|
1900
|
-
|
|
1906
|
+
export declare const isOutputFamily: (port: OpOutputPort) => port is OutputFamilyPort;
|
|
1907
|
+
export declare const instancePortName: (family: string, index: number) => string;
|
|
1908
|
+
export declare const familySize: (family: Pick<OutputFamilyPort, "name" | "countFrom">, config: Call["config"]) => number;
|
|
1909
|
+
export declare const expandOutputPorts: (declared: readonly OpOutputPort[], config: Call["config"]) => readonly OpOutputPort[];
|
|
1910
|
+
//#endregion
|
|
1911
|
+
//#region src/ref.d.ts
|
|
1901
1912
|
type ParsedRef = {
|
|
1902
|
-
|
|
1903
|
-
|
|
1913
|
+
readonly scope: 'input';
|
|
1914
|
+
readonly port: string;
|
|
1904
1915
|
} | {
|
|
1905
|
-
|
|
1906
|
-
|
|
1907
|
-
|
|
1916
|
+
readonly scope: 'output';
|
|
1917
|
+
readonly node: string;
|
|
1918
|
+
readonly port: string;
|
|
1908
1919
|
} | {
|
|
1909
|
-
|
|
1910
|
-
|
|
1920
|
+
readonly scope: 'context';
|
|
1921
|
+
readonly key: ContextKey;
|
|
1911
1922
|
};
|
|
1912
1923
|
type RefScope = ParsedRef['scope'];
|
|
1913
1924
|
type ContextKey = 'sender' | 'executionAddress';
|
|
1914
|
-
declare const isContextKey: (key: string) => key is ContextKey;
|
|
1925
|
+
export declare const isContextKey: (key: string) => key is ContextKey;
|
|
1915
1926
|
/**
|
|
1916
1927
|
* Ref prefixes that parseRef intercepts before the fallback `output` scope.
|
|
1917
1928
|
* A node whose id matches one of these would produce ambiguous refs
|
|
1918
1929
|
* (e.g. `context.sender` could be a context ref or node-output ref).
|
|
1919
1930
|
* Validation must reject these as node ids.
|
|
1920
1931
|
*/
|
|
1921
|
-
declare const RESERVED_REF_SCOPES: ReadonlySet<string>;
|
|
1922
|
-
declare const isRef: (v: unknown) => v is Ref;
|
|
1923
|
-
declare const parseRef: (ref: Ref) => ParsedRef;
|
|
1932
|
+
export declare const RESERVED_REF_SCOPES: ReadonlySet<string>;
|
|
1933
|
+
export declare const isRef: (v: unknown) => v is Ref;
|
|
1934
|
+
export declare const parseRef: (ref: Ref) => ParsedRef;
|
|
1924
1935
|
/** A ref path: a dotpath such as `input.amount` or `nodeId.port`. */
|
|
1925
1936
|
type RefPath = `${string}.${string}`;
|
|
1926
1937
|
/**
|
|
@@ -1930,20 +1941,19 @@ type RefPath = `${string}.${string}`;
|
|
|
1930
1941
|
* so a misspelled `input.`/`context.` silently becomes an output ref.
|
|
1931
1942
|
*/
|
|
1932
1943
|
interface RefBuilder {
|
|
1933
|
-
|
|
1934
|
-
|
|
1935
|
-
|
|
1936
|
-
readonly [K in ContextKey]: Ref;
|
|
1937
|
-
};
|
|
1944
|
+
(path: RefPath): Ref;
|
|
1945
|
+
input(port: string): Ref;
|
|
1946
|
+
readonly context: { readonly [K in ContextKey]: Ref; };
|
|
1938
1947
|
}
|
|
1939
|
-
declare const ref: RefBuilder;
|
|
1940
|
-
declare const foldRef: <R>(ref: ParsedRef, cases: {
|
|
1941
|
-
|
|
1942
|
-
|
|
1943
|
-
|
|
1948
|
+
export declare const ref: RefBuilder;
|
|
1949
|
+
export declare const foldRef: <R>(ref: ParsedRef, cases: {
|
|
1950
|
+
readonly input: (port: string) => R;
|
|
1951
|
+
readonly context: (key: ContextKey) => R;
|
|
1952
|
+
readonly output: (node: string, port: string) => R;
|
|
1944
1953
|
}) => R;
|
|
1945
|
-
declare const refKey: (ref: Ref) => string;
|
|
1946
|
-
|
|
1954
|
+
export declare const refKey: (ref: Ref) => string;
|
|
1955
|
+
//#endregion
|
|
1956
|
+
//#region src/chainCapabilities.d.ts
|
|
1947
1957
|
/**
|
|
1948
1958
|
* Per-chain native-asset semantics.
|
|
1949
1959
|
*
|
|
@@ -1975,23 +1985,23 @@ declare const refKey: (ref: Ref) => string;
|
|
|
1975
1985
|
* rewritten. No such chain exists yet, so the arm is not defined here.
|
|
1976
1986
|
*/
|
|
1977
1987
|
type ChainCapabilities = {
|
|
1978
|
-
|
|
1979
|
-
|
|
1988
|
+
readonly kind: 'evm-native';
|
|
1989
|
+
readonly chainId: number;
|
|
1980
1990
|
} | {
|
|
1981
|
-
|
|
1982
|
-
|
|
1983
|
-
|
|
1991
|
+
readonly kind: 'as-erc20';
|
|
1992
|
+
readonly chainId: number;
|
|
1993
|
+
readonly nativeErc20: NativeErc20;
|
|
1984
1994
|
} | {
|
|
1985
|
-
|
|
1986
|
-
|
|
1987
|
-
|
|
1988
|
-
|
|
1989
|
-
|
|
1995
|
+
readonly kind: 'native-mirrored-erc20';
|
|
1996
|
+
readonly chainId: number;
|
|
1997
|
+
readonly nativeErc20: NativeErc20;
|
|
1998
|
+
/** Native wei per 1 unit of the facade ERC-20 (1e12 on Arc: 18-dec native, 6-dec USDC). */
|
|
1999
|
+
readonly nativeScale: bigint;
|
|
1990
2000
|
};
|
|
1991
2001
|
interface NativeErc20 {
|
|
1992
|
-
|
|
1993
|
-
|
|
1994
|
-
|
|
2002
|
+
readonly token: `0x${string}`;
|
|
2003
|
+
readonly symbol: string;
|
|
2004
|
+
readonly decimals: number;
|
|
1995
2005
|
}
|
|
1996
2006
|
/**
|
|
1997
2007
|
* The zero-address sentinel that represents the native gas coin on
|
|
@@ -2002,10 +2012,10 @@ interface NativeErc20 {
|
|
|
2002
2012
|
* is the wire-format leaf package and carries no `@lifi/*` dependencies
|
|
2003
2013
|
* (enforced by `scripts/check-compose-boundaries.mjs`).
|
|
2004
2014
|
*/
|
|
2005
|
-
declare const EVM_NATIVE_SENTINEL: `0x${string}`;
|
|
2006
|
-
declare const TEMPO_CHAIN_ID = 4217;
|
|
2007
|
-
declare const TEMPO_NATIVE_ERC20: NativeErc20;
|
|
2008
|
-
declare const ARC_CHAIN_ID = 5042;
|
|
2015
|
+
export declare const EVM_NATIVE_SENTINEL: `0x${string}`;
|
|
2016
|
+
export declare const TEMPO_CHAIN_ID = 4217;
|
|
2017
|
+
export declare const TEMPO_NATIVE_ERC20: NativeErc20;
|
|
2018
|
+
export declare const ARC_CHAIN_ID = 5042;
|
|
2009
2019
|
/**
|
|
2010
2020
|
* Arc's native gas coin is USDC (18-decimal wei at the EVM level). The USDC
|
|
2011
2021
|
* ERC-20 at this address is a view over native balances: `balanceOf` returns
|
|
@@ -2013,9 +2023,9 @@ declare const ARC_CHAIN_ID = 5042;
|
|
|
2013
2023
|
* regular storage. The composer interacts with USDC exclusively through this
|
|
2014
2024
|
* facade, never via `msg.value`.
|
|
2015
2025
|
*/
|
|
2016
|
-
declare const ARC_NATIVE_ERC20: NativeErc20;
|
|
2017
|
-
declare const ARC_NATIVE_SCALE: bigint;
|
|
2018
|
-
declare const getChainCapabilities: (chainId: number) => ChainCapabilities;
|
|
2026
|
+
export declare const ARC_NATIVE_ERC20: NativeErc20;
|
|
2027
|
+
export declare const ARC_NATIVE_SCALE: bigint;
|
|
2028
|
+
export declare const getChainCapabilities: (chainId: number) => ChainCapabilities;
|
|
2019
2029
|
/**
|
|
2020
2030
|
* Structural fold over the `ChainCapabilities` union — the capabilities
|
|
2021
2031
|
* counterpart of `foldResource`/`foldRef`. Dispatches on `kind` and hands each
|
|
@@ -2025,10 +2035,10 @@ declare const getChainCapabilities: (chainId: number) => ChainCapabilities;
|
|
|
2025
2035
|
* the union above turns every `foldChainCapabilities` call into a type error
|
|
2026
2036
|
* until it handles the new case.
|
|
2027
2037
|
*/
|
|
2028
|
-
declare const foldChainCapabilities: <R>(caps: ChainCapabilities, cases: {
|
|
2029
|
-
|
|
2030
|
-
|
|
2031
|
-
|
|
2038
|
+
export declare const foldChainCapabilities: <R>(caps: ChainCapabilities, cases: {
|
|
2039
|
+
readonly evmNative: (chainId: number) => R;
|
|
2040
|
+
readonly asErc20: (nativeErc20: NativeErc20, chainId: number) => R;
|
|
2041
|
+
readonly nativeMirroredErc20: (nativeErc20: NativeErc20, nativeScale: bigint, chainId: number) => R;
|
|
2032
2042
|
}) => R;
|
|
2033
2043
|
/**
|
|
2034
2044
|
* What a wire-level native-balance check (`nativeBalanceGte`) must become on
|
|
@@ -2050,15 +2060,15 @@ declare const foldChainCapabilities: <R>(caps: ChainCapabilities, cases: {
|
|
|
2050
2060
|
* and the fold's exhaustiveness reaches every site.
|
|
2051
2061
|
*/
|
|
2052
2062
|
type NativeCheckPolicy = {
|
|
2053
|
-
|
|
2063
|
+
readonly kind: 'keep';
|
|
2054
2064
|
} | {
|
|
2055
|
-
|
|
2056
|
-
|
|
2065
|
+
readonly kind: 'rewrite';
|
|
2066
|
+
readonly token: `0x${string}`;
|
|
2057
2067
|
} | {
|
|
2058
|
-
|
|
2059
|
-
|
|
2068
|
+
readonly kind: 'reject';
|
|
2069
|
+
readonly reason: string;
|
|
2060
2070
|
};
|
|
2061
|
-
declare const nativeCheckPolicy: (chainId: number) => NativeCheckPolicy;
|
|
2071
|
+
export declare const nativeCheckPolicy: (chainId: number) => NativeCheckPolicy;
|
|
2062
2072
|
/**
|
|
2063
2073
|
* Exact-kind check for `as-erc20` (currently Tempo only) — the rare case that
|
|
2064
2074
|
* genuinely means "no `msg.value` coin exists on this chain". Most consumers
|
|
@@ -2068,7 +2078,7 @@ declare const nativeCheckPolicy: (chainId: number) => NativeCheckPolicy;
|
|
|
2068
2078
|
* ERC-20-native kinds differently goes through `foldChainCapabilities` or
|
|
2069
2079
|
* `nativeCheckPolicy`, never a second exact-kind predicate.
|
|
2070
2080
|
*/
|
|
2071
|
-
declare const isAsErc20Chain: (chainId: number) => boolean;
|
|
2081
|
+
export declare const isAsErc20Chain: (chainId: number) => boolean;
|
|
2072
2082
|
/**
|
|
2073
2083
|
* Whether the chain's canonical native asset is an ERC-20 — true for both
|
|
2074
2084
|
* `as-erc20` chains (Tempo: no `msg.value` coin exists) and
|
|
@@ -2077,7 +2087,7 @@ declare const isAsErc20Chain: (chainId: number) => boolean;
|
|
|
2077
2087
|
* resources are rewritten to the ERC-20, native routing edges are dropped, and
|
|
2078
2088
|
* a surviving native resource is a compile error.
|
|
2079
2089
|
*/
|
|
2080
|
-
declare const hasErc20CanonicalNative: (chainId: number) => boolean;
|
|
2090
|
+
export declare const hasErc20CanonicalNative: (chainId: number) => boolean;
|
|
2081
2091
|
/**
|
|
2082
2092
|
* The address that represents the chain's native asset.
|
|
2083
2093
|
*
|
|
@@ -2085,7 +2095,7 @@ declare const hasErc20CanonicalNative: (chainId: number) => boolean;
|
|
|
2085
2095
|
* whose canonical native asset is an ERC-20 it is the chain's stand-in token
|
|
2086
2096
|
* (PathUSD on Tempo, the USDC facade on Arc).
|
|
2087
2097
|
*/
|
|
2088
|
-
declare const canonicalNativeAddress: (chainId: number) => `0x${string}`;
|
|
2098
|
+
export declare const canonicalNativeAddress: (chainId: number) => `0x${string}`;
|
|
2089
2099
|
/**
|
|
2090
2100
|
* Whether `address` represents the native asset of `chainId`.
|
|
2091
2101
|
*
|
|
@@ -2093,7 +2103,7 @@ declare const canonicalNativeAddress: (chainId: number) => `0x${string}`;
|
|
|
2093
2103
|
* chains whose canonical native asset is an ERC-20, the literal zero address
|
|
2094
2104
|
* returns `false` — only the chain's stand-in ERC-20 address matches.
|
|
2095
2105
|
*/
|
|
2096
|
-
declare const isNativeAddressForChain: (chainId: number, address: string) => boolean;
|
|
2106
|
+
export declare const isNativeAddressForChain: (chainId: number, address: string) => boolean;
|
|
2097
2107
|
/**
|
|
2098
2108
|
* Whether `address` on `chainId` is the genuine `msg.value`-style native coin:
|
|
2099
2109
|
* an `evm-native` chain's zero-address sentinel.
|
|
@@ -2110,7 +2120,7 @@ declare const isNativeAddressForChain: (chainId: number, address: string) => boo
|
|
|
2110
2120
|
* `isNativeAddressForChain`, which returns `true` for the stand-in ERC-20
|
|
2111
2121
|
* (PathUSD on Tempo) and would wrongly route it to `msg.value`.
|
|
2112
2122
|
*/
|
|
2113
|
-
declare const isMsgValueNative: (chainId: number, address: string) => boolean;
|
|
2123
|
+
export declare const isMsgValueNative: (chainId: number, address: string) => boolean;
|
|
2114
2124
|
/**
|
|
2115
2125
|
* Rewrite a single `Resource` according to its chain's capabilities.
|
|
2116
2126
|
*
|
|
@@ -2130,49 +2140,16 @@ declare const isMsgValueNative: (chainId: number, address: string) => boolean;
|
|
|
2130
2140
|
* input `r` unchanged on evm-native chains and for ERC-20 resources) and is
|
|
2131
2141
|
* idempotent: running it on an already-rewritten resource is a no-op.
|
|
2132
2142
|
*/
|
|
2133
|
-
declare const normalizeResource: (r: Resource) => Resource;
|
|
2143
|
+
export declare const normalizeResource: (r: Resource) => Resource;
|
|
2134
2144
|
/**
|
|
2135
2145
|
* Address-level counterpart of `normalizeResource` for wire fields that carry a
|
|
2136
2146
|
* native asset as a bare token string (a continuation outcome's `token`). On
|
|
2137
2147
|
* chains whose canonical native asset is an ERC-20, the native sentinel is
|
|
2138
2148
|
* rewritten to the chain's stand-in ERC-20; every other address passes through.
|
|
2139
2149
|
*/
|
|
2140
|
-
declare const normalizeNativeTokenAddress: (token: string, chainId: number) => string;
|
|
2141
|
-
|
|
2142
|
-
|
|
2143
|
-
* Canonical request types for the `POST /compose/route` convenience endpoint.
|
|
2144
|
-
* Amounts accept `bigint | string` for authoring convenience; the JSON wire
|
|
2145
|
-
* format is always a decimal string, which the SDK serialises for you.
|
|
2146
|
-
*
|
|
2147
|
-
* `/compose/route` trades authoring power for brevity. Instead of a full flow
|
|
2148
|
-
* document it takes a single from/to token pair; the server plans a route for
|
|
2149
|
-
* that pair, builds the flow with a `directDeposit` input on the caller's
|
|
2150
|
-
* behalf, and runs it through the same compile pipeline as `POST /compose`.
|
|
2151
|
-
* The route is the shortest admissible chain of routing-catalog edges up to an
|
|
2152
|
-
* operator-set hop ceiling, and may begin with an aggregator swap when the
|
|
2153
|
-
* catalog alone cannot connect the pair. Terminal hops route through
|
|
2154
|
-
* `lifi.zap`, or `lifi.zapAsync` when the pair is reachable only
|
|
2155
|
-
* asynchronously and the request set `allowAsyncRoutes`. The route itself is
|
|
2156
|
-
* not disclosed: node ids are `hop0`, `hop1`, … with the terminal always
|
|
2157
|
-
* `zap`, so `outputs['zap.amountOut']` is the terminal output at every route
|
|
2158
|
-
* length and intermediate outputs carry `role: 'consumed'`. Its response body
|
|
2159
|
-
* is byte-identical to that of `POST /compose` — the enveloped
|
|
2160
|
-
* `ComposeCompileSuccessData` on HTTP 200 and `ComposeCompilePartialData` on
|
|
2161
|
-
* HTTP 206 — so this file declares only the request shape and reuses
|
|
2162
|
-
* `ComposeCompileResult` from `./compile.js` for the result.
|
|
2163
|
-
*
|
|
2164
|
-
* These are the single source of truth for the request shape, hand-authored
|
|
2165
|
-
* here for the same reason as `./compile.ts` and `./simulate.ts` rather than
|
|
2166
|
-
* derived from the validating schema: that schema is the Zod one in
|
|
2167
|
-
* `@lifi/api-schemas` (`src/routes/composeRoute.ts`), a package that depends on
|
|
2168
|
-
* this one, so importing its inferred types here would invert the dependency —
|
|
2169
|
-
* and the public SDK ships this package as its only peer dependency, never the
|
|
2170
|
-
* server's schema package. The two definitions are held in lockstep by a
|
|
2171
|
-
* compile-time conformance assertion
|
|
2172
|
-
* (`api-schemas/src/routes/composeRoute.typecheck.ts`), which fails the build
|
|
2173
|
-
* if either side drifts.
|
|
2174
|
-
*/
|
|
2175
|
-
|
|
2150
|
+
export declare const normalizeNativeTokenAddress: (token: string, chainId: number) => string;
|
|
2151
|
+
//#endregion
|
|
2152
|
+
//#region src/route.d.ts
|
|
2176
2153
|
/**
|
|
2177
2154
|
* Spend an exact amount of `fromToken`.
|
|
2178
2155
|
*
|
|
@@ -2180,8 +2157,8 @@ declare const normalizeNativeTokenAddress: (token: string, chainId: number) => s
|
|
|
2180
2157
|
* format is a non-negative decimal string.
|
|
2181
2158
|
*/
|
|
2182
2159
|
interface RouteAmountExact {
|
|
2183
|
-
|
|
2184
|
-
|
|
2160
|
+
readonly type: 'EXACT';
|
|
2161
|
+
readonly amount: bigint | string;
|
|
2185
2162
|
}
|
|
2186
2163
|
/**
|
|
2187
2164
|
* Spend the signer's entire `fromToken` balance, whatever it is at execution
|
|
@@ -2209,8 +2186,8 @@ interface RouteAmountExact {
|
|
|
2209
2186
|
* moved to `sweepTo` by the whole-balance sweep independently of that output.
|
|
2210
2187
|
*/
|
|
2211
2188
|
interface RouteAmountAll {
|
|
2212
|
-
|
|
2213
|
-
|
|
2189
|
+
readonly type: 'ALL';
|
|
2190
|
+
readonly simAmount: bigint | string;
|
|
2214
2191
|
}
|
|
2215
2192
|
/**
|
|
2216
2193
|
* How much of `fromToken` a route spends. Two variants, discriminated by
|
|
@@ -2219,92 +2196,93 @@ interface RouteAmountAll {
|
|
|
2219
2196
|
type RouteAmount = RouteAmountExact | RouteAmountAll;
|
|
2220
2197
|
/** Request body for `POST /compose/route`. */
|
|
2221
2198
|
interface ComposeRouteRequest {
|
|
2222
|
-
|
|
2223
|
-
|
|
2224
|
-
|
|
2225
|
-
|
|
2226
|
-
|
|
2227
|
-
|
|
2228
|
-
|
|
2229
|
-
|
|
2230
|
-
|
|
2231
|
-
|
|
2232
|
-
|
|
2233
|
-
|
|
2234
|
-
|
|
2235
|
-
|
|
2236
|
-
|
|
2237
|
-
|
|
2238
|
-
|
|
2239
|
-
|
|
2240
|
-
|
|
2241
|
-
|
|
2242
|
-
|
|
2243
|
-
|
|
2244
|
-
|
|
2245
|
-
|
|
2246
|
-
|
|
2247
|
-
|
|
2248
|
-
|
|
2249
|
-
|
|
2250
|
-
|
|
2251
|
-
|
|
2252
|
-
|
|
2253
|
-
|
|
2254
|
-
|
|
2255
|
-
|
|
2256
|
-
|
|
2257
|
-
|
|
2258
|
-
|
|
2259
|
-
|
|
2260
|
-
|
|
2261
|
-
|
|
2262
|
-
|
|
2263
|
-
|
|
2264
|
-
|
|
2265
|
-
|
|
2266
|
-
|
|
2267
|
-
|
|
2268
|
-
|
|
2269
|
-
|
|
2270
|
-
|
|
2271
|
-
|
|
2272
|
-
|
|
2273
|
-
|
|
2274
|
-
|
|
2275
|
-
|
|
2276
|
-
|
|
2277
|
-
|
|
2278
|
-
|
|
2279
|
-
|
|
2280
|
-
|
|
2281
|
-
|
|
2282
|
-
|
|
2283
|
-
|
|
2284
|
-
|
|
2285
|
-
|
|
2286
|
-
|
|
2287
|
-
|
|
2288
|
-
|
|
2289
|
-
|
|
2290
|
-
|
|
2291
|
-
|
|
2292
|
-
|
|
2293
|
-
|
|
2294
|
-
|
|
2295
|
-
|
|
2296
|
-
|
|
2297
|
-
|
|
2298
|
-
|
|
2299
|
-
|
|
2300
|
-
|
|
2301
|
-
|
|
2302
|
-
|
|
2303
|
-
|
|
2304
|
-
|
|
2305
|
-
|
|
2199
|
+
/** EVM chain id. Both tokens must live on this chain — routes are same-chain. */
|
|
2200
|
+
readonly chainId: number;
|
|
2201
|
+
/**
|
|
2202
|
+
* Token to spend. Use the chain's native sentinel address for the gas coin
|
|
2203
|
+
* (the zero address on EVM-native chains).
|
|
2204
|
+
*/
|
|
2205
|
+
readonly fromToken: string;
|
|
2206
|
+
/** Token to receive. */
|
|
2207
|
+
readonly toToken: string;
|
|
2208
|
+
/** How much of `fromToken` to spend — an exact amount or the whole balance. */
|
|
2209
|
+
readonly amount: RouteAmount;
|
|
2210
|
+
/** Address that funds the route and, by default, owns its output. */
|
|
2211
|
+
readonly signer: string;
|
|
2212
|
+
/**
|
|
2213
|
+
* Slippage tolerance in basis points. Range 0–10000. Defaults to `100` (1%)
|
|
2214
|
+
* server-side when omitted. It is an end-to-end tolerance: the floor is the
|
|
2215
|
+
* simulated final output of the whole route, so a multi-hop route is not
|
|
2216
|
+
* bounded hop by hop. When the route begins with an aggregator swap the same
|
|
2217
|
+
* value is also the swap's own tolerance, which nests inside the end-to-end
|
|
2218
|
+
* floor rather than compounding with it.
|
|
2219
|
+
*/
|
|
2220
|
+
readonly slippageBps?: number;
|
|
2221
|
+
/**
|
|
2222
|
+
* Reject the route when its quoted price impact exceeds this many basis
|
|
2223
|
+
* points. Range 0–10000. Omitted ⇒ the server's default of 500 bps applies;
|
|
2224
|
+
* `0` disables the check.
|
|
2225
|
+
*/
|
|
2226
|
+
readonly maxPriceImpactBps?: number;
|
|
2227
|
+
/**
|
|
2228
|
+
* Integrator fee in basis points, taken from the input amount. Range 0–9000.
|
|
2229
|
+
* Defaults to `0` server-side when omitted. A non-zero value requires an
|
|
2230
|
+
* integration-scoped API key; the server rejects it otherwise.
|
|
2231
|
+
*/
|
|
2232
|
+
readonly integratorFeeBps?: number;
|
|
2233
|
+
/** Opaque referrer tag forwarded to the underlying quote provider. */
|
|
2234
|
+
readonly referrer?: string;
|
|
2235
|
+
/**
|
|
2236
|
+
* Owner of every asset the route leaves behind; defaults to `signer` on a
|
|
2237
|
+
* route with no aggregator swap. Routes whose protocol mints to a named
|
|
2238
|
+
* receiver (surfaced as `recipient: 'required'` by `GET /compose/zap-packs`)
|
|
2239
|
+
* and asynchronous routes bind this address at mint time rather than
|
|
2240
|
+
* transferring afterwards; otherwise the proxy's whole balance of each
|
|
2241
|
+
* asset the route leaves is transferred here.
|
|
2242
|
+
*
|
|
2243
|
+
* **Required when the route includes an aggregator swap.** Such a route can
|
|
2244
|
+
* leave an asset the caller did not plan for — the swap's unspent input —
|
|
2245
|
+
* and this address receives it alongside the terminal output, so it must be
|
|
2246
|
+
* named explicitly; omitting it fails with `validation_error`.
|
|
2247
|
+
*
|
|
2248
|
+
* Accepts an address or `{ $ref: 'context.sender' }` (which counts as
|
|
2249
|
+
* explicit); `{ $ref: 'context.executionAddress' }` is rejected.
|
|
2250
|
+
*/
|
|
2251
|
+
readonly sweepTo?: SweepTo;
|
|
2252
|
+
/**
|
|
2253
|
+
* `'strict'` (the default) fails the request when simulation detects a
|
|
2254
|
+
* revert; `'allow-revert'` returns a partial result with revert diagnostics
|
|
2255
|
+
* instead.
|
|
2256
|
+
*/
|
|
2257
|
+
readonly simulationPolicy?: SimulationPolicy;
|
|
2258
|
+
/**
|
|
2259
|
+
* Also simulate the final user-facing transaction after the structured
|
|
2260
|
+
* simulation succeeds. Reverts honour `simulationPolicy`. Defaults to `false`.
|
|
2261
|
+
*/
|
|
2262
|
+
readonly simulateUserProgram?: boolean;
|
|
2263
|
+
/**
|
|
2264
|
+
* Filter the returned `approvals` against current on-chain allowances,
|
|
2265
|
+
* omitting approvals that are already sufficient. Defaults to `false`.
|
|
2266
|
+
*/
|
|
2267
|
+
readonly checkOnChainAllowances?: boolean;
|
|
2268
|
+
/**
|
|
2269
|
+
* Accept a route whose output is delivered only after the initiating
|
|
2270
|
+
* transaction settles (`delivery.when: 'future'` on the terminal output).
|
|
2271
|
+
* Such a route obliges you to track settlement rather than treat the
|
|
2272
|
+
* transaction as completing the job, and carries no slippage floor, so it is
|
|
2273
|
+
* opt-in. Defaults to `false` server-side, which leaves a pair reachable
|
|
2274
|
+
* only asynchronously rejected with `no_route_error` and guarantees every
|
|
2275
|
+
* terminal output is `delivery.when: 'now'`.
|
|
2276
|
+
*
|
|
2277
|
+
* It widens reach, it is not a preference: a synchronous route wins at any
|
|
2278
|
+
* length, so a pair with both a one-hop asynchronous edge and a longer
|
|
2279
|
+
* synchronous route is served synchronously. Opting in never costs you a
|
|
2280
|
+
* synchronous route.
|
|
2281
|
+
*/
|
|
2282
|
+
readonly allowAsyncRoutes?: boolean;
|
|
2306
2283
|
}
|
|
2307
|
-
|
|
2284
|
+
//#endregion
|
|
2285
|
+
//#region src/preconditions.d.ts
|
|
2308
2286
|
/**
|
|
2309
2287
|
* The three concrete precondition shapes the stack exchanges today. One
|
|
2310
2288
|
* definition serves every producer and consumer: op/materialiser declarations,
|
|
@@ -2315,48 +2293,31 @@ interface ComposeRouteRequest {
|
|
|
2315
2293
|
* string; the string side covers values already stringified.
|
|
2316
2294
|
*/
|
|
2317
2295
|
type Erc20BalancePrecondition = {
|
|
2318
|
-
|
|
2319
|
-
|
|
2320
|
-
|
|
2321
|
-
|
|
2296
|
+
readonly type: 'Erc20Balance';
|
|
2297
|
+
readonly wallet: string;
|
|
2298
|
+
readonly token: string;
|
|
2299
|
+
readonly balance: bigint | string;
|
|
2322
2300
|
};
|
|
2323
2301
|
type NativeBalancePrecondition = {
|
|
2324
|
-
|
|
2325
|
-
|
|
2326
|
-
|
|
2302
|
+
readonly type: 'NativeBalance';
|
|
2303
|
+
readonly wallet: string;
|
|
2304
|
+
readonly balance: bigint | string;
|
|
2327
2305
|
};
|
|
2328
2306
|
type Erc20AllowancePrecondition = {
|
|
2329
|
-
|
|
2330
|
-
|
|
2331
|
-
|
|
2332
|
-
|
|
2333
|
-
|
|
2307
|
+
readonly type: 'Erc20Allowance';
|
|
2308
|
+
readonly owner: string;
|
|
2309
|
+
readonly spender: string;
|
|
2310
|
+
readonly token: string;
|
|
2311
|
+
readonly allowance: bigint | string;
|
|
2334
2312
|
};
|
|
2335
|
-
declare const erc20Balance: (config: Omit<Erc20BalancePrecondition, "type">) => Erc20BalancePrecondition;
|
|
2336
|
-
declare const nativeBalance: (config: Omit<NativeBalancePrecondition, "type">) => NativeBalancePrecondition;
|
|
2337
|
-
declare const erc20Allowance: (config: Omit<Erc20AllowancePrecondition, "type">) => Erc20AllowancePrecondition;
|
|
2338
|
-
declare const isErc20BalancePrecondition: (p: Precondition) => p is Erc20BalancePrecondition;
|
|
2339
|
-
declare const isErc20AllowancePrecondition: (p: Precondition) => p is Erc20AllowancePrecondition;
|
|
2340
|
-
declare const isNativeBalancePrecondition: (p: Precondition) => p is NativeBalancePrecondition;
|
|
2341
|
-
|
|
2342
|
-
|
|
2343
|
-
* Canonical wire-format types for the standalone `POST /simulate` endpoint.
|
|
2344
|
-
*
|
|
2345
|
-
* `/simulate` takes a raw, pre-encoded transaction (a `to` address, hex `data`,
|
|
2346
|
-
* optional native `value`), funds a sender, runs it in one `eth_call`, and
|
|
2347
|
-
* reports the watched balances before and after, their signed deltas, and the
|
|
2348
|
-
* inner-call gas. Unlike `POST /compose`, its response body is **un-enveloped**:
|
|
2349
|
-
* `{ status, block, timestamp, ... }` lives at the top level (no `{ data }`
|
|
2350
|
-
* wrapper).
|
|
2351
|
-
*
|
|
2352
|
-
* These are the single source of truth for the request/response shapes. The
|
|
2353
|
-
* server-side Zod schemas in `@lifi/api-schemas` (`src/routes/simulate.ts`)
|
|
2354
|
-
* validate the same contract and are kept in lockstep by a compile-time
|
|
2355
|
-
* conformance assertion (`src/routes/simulate.typecheck.ts`).
|
|
2356
|
-
*
|
|
2357
|
-
* Mirrors the hand-authored style of `src/compile.ts`.
|
|
2358
|
-
*/
|
|
2359
|
-
|
|
2313
|
+
export declare const erc20Balance: (config: Omit<Erc20BalancePrecondition, "type">) => Erc20BalancePrecondition;
|
|
2314
|
+
export declare const nativeBalance: (config: Omit<NativeBalancePrecondition, "type">) => NativeBalancePrecondition;
|
|
2315
|
+
export declare const erc20Allowance: (config: Omit<Erc20AllowancePrecondition, "type">) => Erc20AllowancePrecondition;
|
|
2316
|
+
export declare const isErc20BalancePrecondition: (p: Precondition) => p is Erc20BalancePrecondition;
|
|
2317
|
+
export declare const isErc20AllowancePrecondition: (p: Precondition) => p is Erc20AllowancePrecondition;
|
|
2318
|
+
export declare const isNativeBalancePrecondition: (p: Precondition) => p is NativeBalancePrecondition;
|
|
2319
|
+
//#endregion
|
|
2320
|
+
//#region src/simulate.d.ts
|
|
2360
2321
|
/**
|
|
2361
2322
|
* Maximum number of watched `(token, owner)` pairs accepted by `POST /simulate`.
|
|
2362
2323
|
*
|
|
@@ -2368,7 +2329,7 @@ declare const isNativeBalancePrecondition: (p: Precondition) => p is NativeBalan
|
|
|
2368
2329
|
* merges identical-valued literals into one register. The cap leaves headroom
|
|
2369
2330
|
* for the inner-call / gas-measurement / abi-encode scaffolding.
|
|
2370
2331
|
*/
|
|
2371
|
-
declare const SIMULATE_MAX_TRACKED_BALANCES = 40;
|
|
2332
|
+
export declare const SIMULATE_MAX_TRACKED_BALANCES = 40;
|
|
2372
2333
|
/**
|
|
2373
2334
|
* Maximum number of funding `requirements` accepted by `POST /simulate`.
|
|
2374
2335
|
*
|
|
@@ -2377,13 +2338,13 @@ declare const SIMULATE_MAX_TRACKED_BALANCES = 40;
|
|
|
2377
2338
|
* single request amplify into arbitrary upstream RPC work. Bounded here at the
|
|
2378
2339
|
* trust boundary and re-enforced server-side in `rawSimulation.ts`.
|
|
2379
2340
|
*/
|
|
2380
|
-
declare const SIMULATE_MAX_REQUIREMENTS = 40;
|
|
2341
|
+
export declare const SIMULATE_MAX_REQUIREMENTS = 40;
|
|
2381
2342
|
/** A `(token, owner)` pair whose balance is watched across the simulation. */
|
|
2382
2343
|
interface TrackedBalance {
|
|
2383
|
-
|
|
2384
|
-
|
|
2385
|
-
|
|
2386
|
-
|
|
2344
|
+
/** Token to watch (use the zero address for native balance). */
|
|
2345
|
+
readonly token: string;
|
|
2346
|
+
/** Account whose balance of `token` is watched. */
|
|
2347
|
+
readonly owner: string;
|
|
2387
2348
|
}
|
|
2388
2349
|
/** Funding instruction: seed an ERC-20 balance on a wallet before simulation. */
|
|
2389
2350
|
type Erc20BalanceRequirement = Erc20BalancePrecondition;
|
|
@@ -2398,40 +2359,40 @@ type Erc20AllowanceRequirement = Erc20AllowancePrecondition;
|
|
|
2398
2359
|
type SlotFinderRequirement = Erc20BalanceRequirement | NativeBalanceRequirement | Erc20AllowanceRequirement;
|
|
2399
2360
|
/** Request body for `POST /simulate`. */
|
|
2400
2361
|
interface SimulateRequest {
|
|
2401
|
-
|
|
2402
|
-
|
|
2403
|
-
|
|
2404
|
-
|
|
2405
|
-
|
|
2406
|
-
|
|
2407
|
-
|
|
2408
|
-
|
|
2409
|
-
|
|
2410
|
-
|
|
2411
|
-
|
|
2412
|
-
|
|
2413
|
-
|
|
2414
|
-
|
|
2415
|
-
|
|
2416
|
-
|
|
2417
|
-
|
|
2418
|
-
|
|
2419
|
-
|
|
2420
|
-
|
|
2421
|
-
|
|
2422
|
-
|
|
2423
|
-
|
|
2424
|
-
|
|
2425
|
-
|
|
2362
|
+
/** EVM chain id. */
|
|
2363
|
+
readonly chainId: number;
|
|
2364
|
+
/**
|
|
2365
|
+
* Sender of the simulated transaction. The VM bytecode is injected here so
|
|
2366
|
+
* the inner call carries `msg.sender == from`.
|
|
2367
|
+
*/
|
|
2368
|
+
readonly from: string;
|
|
2369
|
+
/** Target contract of the raw transaction. */
|
|
2370
|
+
readonly to: string;
|
|
2371
|
+
/** Pre-encoded transaction calldata (`0x`-prefixed hex). */
|
|
2372
|
+
readonly data: string;
|
|
2373
|
+
/**
|
|
2374
|
+
* Native value (wei) sent with the inner call. Accepts `bigint | string`;
|
|
2375
|
+
* defaults to `"0"` server-side when omitted.
|
|
2376
|
+
*/
|
|
2377
|
+
readonly value?: bigint | string;
|
|
2378
|
+
/**
|
|
2379
|
+
* Block number to simulate against. Omitted ⇒ the chain head. Named tags
|
|
2380
|
+
* (e.g. "latest") are rejected with HTTP 400.
|
|
2381
|
+
*/
|
|
2382
|
+
readonly block?: number;
|
|
2383
|
+
/** Funding instructions applied before simulation (max 40). */
|
|
2384
|
+
readonly requirements?: readonly SlotFinderRequirement[];
|
|
2385
|
+
/** Balances to read before and after the transaction (1–40 pairs). */
|
|
2386
|
+
readonly trackedBalances: readonly TrackedBalance[];
|
|
2426
2387
|
}
|
|
2427
2388
|
/**
|
|
2428
2389
|
* One watched balance in a simulation response. `amount` is a decimal string;
|
|
2429
2390
|
* for `deltas` it is signed (`after - before`).
|
|
2430
2391
|
*/
|
|
2431
2392
|
interface SimulateBalanceEntry {
|
|
2432
|
-
|
|
2433
|
-
|
|
2434
|
-
|
|
2393
|
+
readonly token: string;
|
|
2394
|
+
readonly owner: string;
|
|
2395
|
+
readonly amount: string;
|
|
2435
2396
|
}
|
|
2436
2397
|
/**
|
|
2437
2398
|
* HTTP 200, `status: "ok"`: the simulation ran successfully. Balance arrays are
|
|
@@ -2444,49 +2405,50 @@ interface SimulateBalanceEntry {
|
|
|
2444
2405
|
* bidirectional conformance assertion in `@lifi/api-schemas` relies on this.
|
|
2445
2406
|
*/
|
|
2446
2407
|
interface SimulateOkResult {
|
|
2447
|
-
|
|
2448
|
-
|
|
2449
|
-
|
|
2450
|
-
|
|
2451
|
-
|
|
2452
|
-
|
|
2453
|
-
|
|
2408
|
+
readonly status: 'ok';
|
|
2409
|
+
readonly block: number;
|
|
2410
|
+
readonly timestamp: number;
|
|
2411
|
+
readonly balancesBefore: SimulateBalanceEntry[];
|
|
2412
|
+
readonly balancesAfter: SimulateBalanceEntry[];
|
|
2413
|
+
readonly deltas: SimulateBalanceEntry[];
|
|
2414
|
+
readonly gasUsed: string;
|
|
2454
2415
|
}
|
|
2455
2416
|
/** Decoded revert diagnostics, when slot-finder can parse the revert reason. */
|
|
2456
2417
|
interface SimulateRevertDecodeResult {
|
|
2457
|
-
|
|
2458
|
-
|
|
2459
|
-
|
|
2460
|
-
|
|
2461
|
-
|
|
2418
|
+
readonly errorCandidates?: {
|
|
2419
|
+
readonly decodedErrorSignature: string;
|
|
2420
|
+
readonly decodedParams: string[];
|
|
2421
|
+
}[];
|
|
2422
|
+
readonly error?: string;
|
|
2462
2423
|
}
|
|
2463
2424
|
/**
|
|
2464
2425
|
* HTTP 200, `status: "revert"`: the simulation ran but the transaction reverted
|
|
2465
2426
|
* on-chain. A revert is a *successful simulation*, not a transport error.
|
|
2466
2427
|
*/
|
|
2467
2428
|
interface SimulateRevertResult {
|
|
2468
|
-
|
|
2469
|
-
|
|
2470
|
-
|
|
2471
|
-
|
|
2472
|
-
|
|
2473
|
-
|
|
2474
|
-
|
|
2429
|
+
readonly status: 'revert';
|
|
2430
|
+
readonly block: number;
|
|
2431
|
+
readonly timestamp: number;
|
|
2432
|
+
readonly revertReason?: string;
|
|
2433
|
+
readonly code?: number;
|
|
2434
|
+
readonly rawErrorBytes?: string;
|
|
2435
|
+
readonly decodeResult?: SimulateRevertDecodeResult;
|
|
2475
2436
|
}
|
|
2476
2437
|
/**
|
|
2477
2438
|
* HTTP 422, `status: "error"`: the request was well-formed but the simulation
|
|
2478
2439
|
* could not be set up or run. `message` is intentionally generic.
|
|
2479
2440
|
*/
|
|
2480
2441
|
interface SimulateSetupErrorResult {
|
|
2481
|
-
|
|
2482
|
-
|
|
2442
|
+
readonly status: 'error';
|
|
2443
|
+
readonly message: string;
|
|
2483
2444
|
}
|
|
2484
2445
|
/**
|
|
2485
2446
|
* Discriminated result of `POST /simulate`. `switch (result.status)` narrows to
|
|
2486
2447
|
* one member: `ok` and `revert` come back with HTTP 200, `error` with HTTP 422.
|
|
2487
2448
|
*/
|
|
2488
2449
|
type SimulateResult = SimulateOkResult | SimulateRevertResult | SimulateSetupErrorResult;
|
|
2489
|
-
|
|
2450
|
+
//#endregion
|
|
2451
|
+
//#region src/headers.d.ts
|
|
2490
2452
|
/**
|
|
2491
2453
|
* HTTP header names on the compose wire.
|
|
2492
2454
|
*
|
|
@@ -2495,10 +2457,11 @@ type SimulateResult = SimulateOkResult | SimulateRevertResult | SimulateSetupErr
|
|
|
2495
2457
|
* names belong to the wire format rather than to either side of it.
|
|
2496
2458
|
*/
|
|
2497
2459
|
/** Compose contract version the client was built against. Sent on every request. */
|
|
2498
|
-
declare const COMPOSER_SDK_VERSION_HEADER = "x-lifi-composer-sdk";
|
|
2460
|
+
export declare const COMPOSER_SDK_VERSION_HEADER = "x-lifi-composer-sdk";
|
|
2499
2461
|
/** Compose contract version the backend serves. Returned on every compose response. */
|
|
2500
|
-
declare const COMPOSE_VERSION_HEADER = "x-lifi-composer-version";
|
|
2501
|
-
|
|
2462
|
+
export declare const COMPOSE_VERSION_HEADER = "x-lifi-composer-version";
|
|
2463
|
+
//#endregion
|
|
2464
|
+
//#region src/version.d.ts
|
|
2502
2465
|
/**
|
|
2503
2466
|
* Compose contract version compatibility.
|
|
2504
2467
|
*
|
|
@@ -2511,9 +2474,9 @@ declare const COMPOSE_VERSION_HEADER = "x-lifi-composer-version";
|
|
|
2511
2474
|
* so the rule lives in exactly one place.
|
|
2512
2475
|
*/
|
|
2513
2476
|
interface ComposeVersion {
|
|
2514
|
-
|
|
2515
|
-
|
|
2516
|
-
|
|
2477
|
+
readonly major: number;
|
|
2478
|
+
readonly minor: number;
|
|
2479
|
+
readonly patch: number;
|
|
2517
2480
|
}
|
|
2518
2481
|
type VersionCompatibility = 'compatible' | 'sdk_outdated' | 'server_outdated';
|
|
2519
2482
|
/**
|
|
@@ -2522,7 +2485,7 @@ type VersionCompatibility = 'compatible' | 'sdk_outdated' | 'server_outdated';
|
|
|
2522
2485
|
* Returns `undefined` for anything that is not a complete semver string,
|
|
2523
2486
|
* including the `dev` sentinel the SDK sends when it runs unbundled.
|
|
2524
2487
|
*/
|
|
2525
|
-
declare const parseVersion: (version: string) => ComposeVersion | undefined;
|
|
2488
|
+
export declare const parseVersion: (version: string) => ComposeVersion | undefined;
|
|
2526
2489
|
/**
|
|
2527
2490
|
* Decides whether a client built against `client` may talk to a server that
|
|
2528
2491
|
* serves `server` and accepts clients down to `minimum`.
|
|
@@ -2543,29 +2506,31 @@ declare const parseVersion: (version: string) => ComposeVersion | undefined;
|
|
|
2543
2506
|
* bump can ship with the previous line still accepted; the SDK passes no floor
|
|
2544
2507
|
* because the server, not the client, decides how far back it serves.
|
|
2545
2508
|
*/
|
|
2546
|
-
declare const checkCompatibility: (client: ComposeVersion, server: ComposeVersion, minimum?: ComposeVersion) => VersionCompatibility;
|
|
2547
|
-
|
|
2509
|
+
export declare const checkCompatibility: (client: ComposeVersion, server: ComposeVersion, minimum?: ComposeVersion) => VersionCompatibility;
|
|
2510
|
+
//#endregion
|
|
2511
|
+
//#region src/materialiserMetadata.d.ts
|
|
2548
2512
|
type MaterialiserMetadata = {
|
|
2549
|
-
|
|
2550
|
-
|
|
2513
|
+
readonly kind: 'exact';
|
|
2514
|
+
readonly amount: bigint;
|
|
2551
2515
|
} | {
|
|
2552
|
-
|
|
2553
|
-
|
|
2516
|
+
readonly kind: 'exact-native';
|
|
2517
|
+
readonly amount: bigint;
|
|
2554
2518
|
} | {
|
|
2555
|
-
|
|
2556
|
-
|
|
2519
|
+
readonly kind: 'capped';
|
|
2520
|
+
readonly amount: bigint;
|
|
2521
|
+
readonly min?: bigint;
|
|
2557
2522
|
} | {
|
|
2558
|
-
|
|
2523
|
+
readonly kind: 'runtime';
|
|
2559
2524
|
};
|
|
2560
2525
|
interface MaterialiserResolution {
|
|
2561
|
-
|
|
2562
|
-
|
|
2526
|
+
readonly meta: MaterialiserMetadata;
|
|
2527
|
+
readonly preconditions: readonly Precondition[];
|
|
2563
2528
|
}
|
|
2564
|
-
declare const foldMaterialiserMetadata: <R>(meta: MaterialiserMetadata, cases: {
|
|
2565
|
-
|
|
2566
|
-
|
|
2567
|
-
|
|
2568
|
-
|
|
2529
|
+
export declare const foldMaterialiserMetadata: <R>(meta: MaterialiserMetadata, cases: {
|
|
2530
|
+
readonly exact: (amount: bigint) => R;
|
|
2531
|
+
readonly exactNative: (amount: bigint) => R;
|
|
2532
|
+
readonly capped: (amount: bigint, min: bigint | undefined) => R;
|
|
2533
|
+
readonly runtime: () => R;
|
|
2569
2534
|
}) => R;
|
|
2570
|
-
|
|
2571
|
-
export {
|
|
2535
|
+
//#endregion
|
|
2536
|
+
export type { Amount, AppliedGuard, ApprovalEntry, AssertedPredicate, AssertedPredicateWire, AssertionOwner, AssertionSpec, AssertionSpecWire, Availability, BindValue, Call, ChainCapabilities, ComposeAction, ComposeCompilePartialData, ComposeCompileRequest, ComposeCompileResult, ComposeCompileSuccessData, ComposeError, ComposeErrorKind, ComposeFee, ComposeFill, ComposeManifest, ComposeRouteErrorKind, ComposeRouteRequest, ComposeRun, ComposeTransactionRequest, ComposeUserProgramSimulation, ComposeVersion, ConsumedOutput, ContextKey, ContinuationIntent, ContinuationOutcome, Delivery, Erc20AllowancePrecondition, Erc20AllowanceRequirement, Erc20BalancePrecondition, Erc20BalanceRequirement, Estimate, EstimateBasis, FailedPreparedOp, FlashloanMaterialiserInput, Flow, FlowInput, GenericComposeError, GenericComposeErrorKind, GuardCompatibility, GuardSelector, HandleInput, HandlePort, HandleUnits, InputSpec, Lineage, LiteralBinding, ManifestGuard, ManifestMaterialiser, ManifestOperation, ManifestPrecondition, MaterialiserConfigOf, MaterialiserInput, MaterialiserInputBase, MaterialiserInputOf, MaterialiserMetadata, MaterialiserResolution, Minimum, MinimumBasis, NativeBalancePrecondition, NativeBalanceRequirement, NativeCheckPolicy, NativeErc20, OpInputPort, OpOutputPort, Output, OutputAmount, OutputFamilyPort, Outputs, ParsedRef, Phase1Artifact, Port, Precondition, PreconditionBase, PreconditionConfigOf, PreconditionOf, PreparationComposeError, PriceImpact, ProviderKindName, Ref, RefBuilder, RefPath, RefScope, Resource, ResourceInput, ResourceOutputPort, ResourcePort, RouteAmount, RouteAmountAll, RouteAmountExact, SettlementEscrowWire, SettlementWire, SimulateBalanceEntry, SimulateOkResult, SimulateRequest, SimulateResult, SimulateRevertDecodeResult, SimulateRevertResult, SimulateSetupErrorResult, SimulationPolicy, SimulationRevert, SimulationRevertComposeError, SlotFinderRequirement, SolType, SpendEntry, StaticSolType, SweepTo, TerminalOutput, TrackedBalance, VerificationDescriptor, VerificationDescriptorWire, VersionCompatibility };
|