@lifi/compose-spec 0.8.1 → 0.9.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.d.cts CHANGED
@@ -1,9 +1,9 @@
1
- import { Schema } from 'effect';
2
- import z from 'zod';
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 { 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
- }, never>>;
46
- declare const ResourceInputSchema: Schema.Struct<{
47
- name: typeof Schema.String;
48
- resource: Schema.transform<Schema.Union<[Schema.Struct<{
49
- kind: Schema.Literal<["native"]>;
50
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
51
- }>, Schema.Struct<{
52
- kind: Schema.Literal<["erc20"]>;
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 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"]>;
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<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 FlowInputSchema: Schema.Union<[Schema.Struct<{
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
- kind: Schema.Literal<["native"]>;
79
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
155
+ kind: Schema.Literal<["native"]>;
156
+ chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
80
157
  }>, Schema.Struct<{
81
- kind: Schema.Literal<["erc20"]>;
82
- token: Schema.refine<string, typeof Schema.String>;
83
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
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
- readonly kind: "native";
86
- readonly chainId: number;
162
+ readonly kind: "native";
163
+ readonly chainId: number;
87
164
  } | {
88
- readonly token: string;
89
- readonly kind: "erc20";
90
- readonly chainId: number;
165
+ readonly kind: "erc20";
166
+ readonly chainId: number;
167
+ readonly token: string;
91
168
  }, {
92
- readonly kind: "native";
93
- readonly chainId: number;
169
+ readonly kind: "native";
170
+ readonly chainId: number;
94
171
  } | {
95
- readonly token: string;
96
- readonly kind: "erc20";
97
- readonly chainId: number;
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
- declare const RefSchema: Schema.Struct<{
104
- $ref: Schema.filter<typeof Schema.String>;
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<{
179
+ }>]>>;
180
+ nodes: Schema.Array$<Schema.Struct<{
123
181
  id: 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
- $ref: Schema.filter<typeof Schema.String>;
184
+ $ref: Schema.filter<typeof Schema.String>;
127
185
  }>, 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;
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
- default: () => {};
189
+ default: () => {};
132
190
  }>;
133
191
  config: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>, {
134
- default: () => {};
192
+ default: () => {};
135
193
  }>;
136
194
  guards: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
137
- kind: typeof Schema.String;
195
+ kind: typeof Schema.String;
138
196
  }, readonly [{
139
- readonly key: typeof Schema.String;
140
- readonly value: typeof Schema.Unknown;
197
+ readonly key: typeof Schema.String;
198
+ readonly value: typeof Schema.Unknown;
141
199
  }]>>>;
142
- }>;
143
- declare const UuidSchema: Schema.filter<typeof Schema.String>;
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
- declare const CONTINUATION_COMMITMENT_OP_ID = "continuation.commitment";
219
- declare const ContinuationOutcomeSchema: Schema.transform<Schema.Struct<{
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
- declare const ContinuationIntentSchema: Schema.Struct<{
236
- outcomes: Schema.NonEmptyArray<Schema.transform<Schema.Struct<{
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
- }>, Schema.SchemaClass<{
242
- readonly token: string;
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
- readonly minAmount: string;
250
- readonly destination: string;
251
- }, never>>>;
252
- continuationFlow: Schema.optional<Schema.Struct<{
253
- version: Schema.Literal<[1]>;
254
- id: typeof Schema.String;
255
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
256
- inputs: Schema.Array$<Schema.Union<[Schema.Struct<{
257
- name: typeof Schema.String;
258
- resource: Schema.transform<Schema.Union<[Schema.Struct<{
259
- kind: Schema.Literal<["native"]>;
260
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
261
- }>, Schema.Struct<{
262
- kind: Schema.Literal<["erc20"]>;
263
- token: Schema.refine<string, typeof Schema.String>;
264
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
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<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
- chainId: typeof Schema.Number;
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
- escrow: Schema.optional<Schema.Struct<{
328
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
329
- address: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["signables"]>;
339
- typedData: Schema.Array$<typeof Schema.Unknown>;
339
+ kind: Schema.Literal<["signables"]>;
340
+ typedData: Schema.Array$<typeof Schema.Unknown>;
340
341
  }>, Schema.Struct<{
341
- kind: Schema.Literal<["none"]>;
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
- kind: Schema.Literal<["erc20BalanceGte"]>;
347
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
348
- token: Schema.refine<string, typeof Schema.String>;
349
- owner: Schema.refine<string, typeof Schema.String>;
350
- minAmount: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["nativeBalanceGte"]>;
354
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
355
- owner: Schema.refine<string, typeof Schema.String>;
356
- minAmount: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["call"]>;
360
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
361
- to: Schema.refine<string, typeof Schema.String>;
362
- calldata: Schema.refine<string, typeof Schema.String>;
363
- comparator: Schema.Literal<["gte", "eq", "lte"]>;
364
- value: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["erc20BalanceDeltaGte"]>;
368
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
369
- token: Schema.refine<string, typeof Schema.String>;
370
- owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
371
- minDelta: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["nativeBalanceDeltaGte"]>;
375
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
376
- owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
377
- minDelta: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["erc20BalanceGte"]>;
381
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
382
- token: Schema.refine<string, typeof Schema.String>;
383
- owner: Schema.refine<string, typeof Schema.String>;
384
- minAmount: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["nativeBalanceGte"]>;
387
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
388
- owner: Schema.refine<string, typeof Schema.String>;
389
- minAmount: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["call"]>;
392
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
393
- to: Schema.refine<string, typeof Schema.String>;
394
- calldata: Schema.refine<string, typeof Schema.String>;
395
- comparator: Schema.Literal<["gte", "eq", "lte"]>;
396
- value: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["erc20BalanceDeltaGte"]>;
399
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
400
- token: Schema.refine<string, typeof Schema.String>;
401
- owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
402
- minDelta: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["nativeBalanceDeltaGte"]>;
405
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
406
- owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
407
- minDelta: Schema.filter<typeof Schema.String>;
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
- declare const Bytes32HexSchema: Schema.filter<typeof Schema.String>;
416
- declare const AssertedErc20BalanceGteSpecSchema: Schema.Struct<{
417
- kind: Schema.Literal<["erc20BalanceGte"]>;
418
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
419
- token: Schema.refine<string, typeof Schema.String>;
420
- owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
421
- minAmount: Schema.filter<typeof Schema.String>;
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
- kind: Schema.Literal<["nativeBalanceGte"]>;
425
- chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
426
- owner: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Literal<["escrow", "delivery"]>]>;
427
- minAmount: Schema.filter<typeof Schema.String>;
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 minAmount: string;
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 minAmount: string;
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
- }, never>, never>;
517
- declare const VerificationDescriptorSchema: Schema.Struct<{
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
- readonly expected: bigint;
616
- readonly min?: bigint;
618
+ readonly expected: bigint;
619
+ readonly min?: bigint;
617
620
  }
618
621
  type Resource = {
619
- readonly kind: 'native';
620
- readonly chainId: number;
622
+ readonly kind: 'native';
623
+ readonly chainId: number;
621
624
  } | {
622
- readonly kind: 'erc20';
623
- readonly token: string;
624
- readonly chainId: number;
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
- kind: "erc20";
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
- kind: "native";
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
- readonly native: (chainId: number) => R;
637
- readonly erc20: (token: string, chainId: number) => R;
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
- readonly basis: EstimateBasis;
647
- readonly value: bigint;
650
+ readonly basis: EstimateBasis;
651
+ readonly value: bigint;
648
652
  }
649
653
  interface Minimum {
650
- readonly basis: MinimumBasis;
651
- readonly value: bigint;
654
+ readonly basis: MinimumBasis;
655
+ readonly value: bigint;
652
656
  }
653
657
  interface Amount {
654
- readonly estimate?: Estimate;
655
- readonly minimum?: Minimum;
658
+ readonly estimate?: Estimate;
659
+ readonly minimum?: Minimum;
656
660
  }
657
661
  type Delivery = {
658
- readonly when: 'now';
662
+ readonly when: 'now';
659
663
  } | {
660
- readonly when: 'future';
661
- readonly etaSeconds?: number;
662
- readonly provider?: string;
664
+ readonly when: 'future';
665
+ readonly etaSeconds?: number;
666
+ readonly provider?: string;
663
667
  };
664
668
  interface OutputBase {
665
- readonly resource: Resource;
666
- readonly amount: Amount;
669
+ readonly resource: Resource;
670
+ readonly amount: Amount;
667
671
  }
668
672
  interface ConsumedOutput extends OutputBase {
669
- readonly role: 'consumed';
670
- readonly consumedBy: string;
673
+ readonly role: 'consumed';
674
+ readonly consumedBy: string;
671
675
  }
672
676
  interface TerminalOutput extends OutputBase {
673
- readonly role: 'terminal';
674
- readonly owner: string;
675
- readonly delivery: Delivery;
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
- declare const ResourcePortZod: z.ZodObject<{
681
- kind: z.ZodLiteral<"resource">;
682
- name: z.ZodString;
683
- accepts: z.ZodEnum<{
684
- native: "native";
685
- erc20: "erc20";
686
- any: "any";
687
- }>;
688
- mode: z.ZodEnum<{
689
- linear: "linear";
690
- copy: "copy";
691
- }>;
692
- optional: z.ZodOptional<z.ZodBoolean>;
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
- declare const StaticSolTypeZod: z.ZodEnum<{
704
- uint8: "uint8";
705
- uint16: "uint16";
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
- uint64: "uint64";
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
- declare const isStaticSolType: (value: string) => value is StaticSolType;
715
- declare const HandlePortZod: z.ZodObject<{
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
- string: "string";
720
- uint8: "uint8";
721
- uint16: "uint16";
722
- uint32: "uint32";
723
- uint64: "uint64";
724
- uint128: "uint128";
725
- uint256: "uint256";
726
- int128: "int128";
727
- int256: "int256";
728
- address: "address";
729
- bool: "bool";
730
- bytes: "bytes";
731
- bytes4: "bytes4";
732
- bytes32: "bytes32";
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
- linear: "linear";
736
- copy: "copy";
899
+ linear: "linear";
900
+ copy: "copy";
737
901
  }>;
738
902
  expose: z.ZodOptional<z.ZodBoolean>;
739
903
  units: z.ZodOptional<z.ZodEnum<{
740
- raw: "raw";
741
- wad: "wad";
742
- ray: "ray";
743
- bps: "bps";
744
- "token-decimals": "token-decimals";
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
- declare const InputPortZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
749
- kind: z.ZodLiteral<"resource">;
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
- linear: "linear";
758
- copy: "copy";
916
+ linear: "linear";
917
+ copy: "copy";
759
918
  }>;
760
- optional: z.ZodOptional<z.ZodBoolean>;
761
- }, z.core.$strip>, z.ZodObject<{
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
- int128: "int128";
773
- int256: "int256";
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
- bytes32: "bytes32";
779
- }>;
780
- mode: z.ZodEnum<{
1135
+ }>;
1136
+ mode: z.ZodEnum<{
781
1137
  linear: "linear";
782
1138
  copy: "copy";
783
- }>;
784
- expose: z.ZodOptional<z.ZodBoolean>;
785
- units: z.ZodOptional<z.ZodEnum<{
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
- optional: z.ZodOptional<z.ZodBoolean>;
793
- }, z.core.$strip>], "kind">;
794
- declare const ResourceOutputPortZod: z.ZodObject<{
795
- kind: z.ZodLiteral<"resource_output">;
796
- name: z.ZodString;
797
- mode: z.ZodEnum<{
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
- availability: z.ZodOptional<z.ZodEnum<{
1156
+ }>;
1157
+ availability: z.ZodOptional<z.ZodEnum<{
818
1158
  now: "now";
819
1159
  future: "future";
820
- }>>;
821
- providesMinimum: z.ZodOptional<z.ZodBoolean>;
822
- omitIfZero: z.ZodOptional<z.ZodBoolean>;
823
- deliveryAddressInput: z.ZodOptional<z.ZodString>;
824
- countFrom: z.ZodOptional<z.ZodString>;
825
- }, z.core.$strip>, z.ZodObject<{
826
- kind: z.ZodLiteral<"handle">;
827
- name: z.ZodString;
828
- type: z.ZodEnum<{
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
- int128: "int128";
837
- int256: "int256";
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
- bytes32: "bytes32";
843
- }>;
844
- mode: z.ZodEnum<{
1183
+ }>;
1184
+ mode: z.ZodEnum<{
845
1185
  linear: "linear";
846
1186
  copy: "copy";
847
- }>;
848
- expose: z.ZodOptional<z.ZodBoolean>;
849
- units: z.ZodOptional<z.ZodEnum<{
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
- optional: z.ZodOptional<z.ZodBoolean>;
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
- declare const GuardSelectorZod: z.ZodObject<{
958
- binding: z.ZodString;
959
- source: z.ZodEnum<{
960
- inputs: "inputs";
961
- outputs: "outputs";
962
- }>;
963
- match: z.ZodObject<{
964
- kind: z.ZodUnion<readonly [z.ZodEnum<{
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
- }>, z.ZodArray<z.ZodEnum<{
1216
+ }>, z.ZodArray<z.ZodEnum<{
969
1217
  resource: "resource";
970
1218
  handle: "handle";
971
1219
  resource_output: "resource_output";
972
- }>>]>;
973
- mode: z.ZodOptional<z.ZodEnum<{
1220
+ }>>]>;
1221
+ mode: z.ZodOptional<z.ZodEnum<{
974
1222
  linear: "linear";
975
1223
  copy: "copy";
976
- }>>;
977
- type: z.ZodOptional<z.ZodEnum<{
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
- kind: z.ZodLiteral<"config">;
1023
- configKey: z.ZodString;
1024
- cardinality: z.ZodEnum<{
1025
- one: "one";
1026
- many: "many";
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
- kind: z.ZodLiteral<"all_matching">;
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
- declare const ManifestGuardZod: z.ZodObject<{
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
- resource: "resource";
1082
- any: "any";
1083
- handle: "handle";
1248
+ resource: "resource";
1249
+ any: "any";
1250
+ handle: "handle";
1084
1251
  }>;
1085
1252
  configSchema: z.ZodOptional<z.ZodUnknown>;
1086
- }, z.core.$strip>;
1087
- declare const ManifestPreconditionZod: z.ZodObject<{
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
- chainId: z.ZodNumber;
1257
- address: z.ZodString;
1258
- token: z.ZodString;
1259
- amount: z.ZodString;
1260
- cap: z.ZodString;
1261
- owner: z.ZodString;
1262
- refund: z.ZodString;
1263
- expiresAtMs: z.ZodNumber;
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
- kind: z.ZodLiteral<"erc20BalanceGte">;
1267
- chainId: z.ZodNumber;
1268
- token: z.ZodString;
1269
- owner: z.ZodString;
1270
- minAmount: z.ZodString;
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
- kind: z.ZodLiteral<"nativeBalanceGte">;
1273
- chainId: z.ZodNumber;
1274
- owner: z.ZodString;
1275
- minAmount: z.ZodString;
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
- kind: z.ZodLiteral<"call">;
1278
- chainId: z.ZodNumber;
1279
- to: z.ZodString;
1280
- calldata: z.ZodString;
1281
- comparator: z.ZodEnum<{
1282
- gte: "gte";
1283
- eq: "eq";
1284
- lte: "lte";
1285
- }>;
1286
- value: z.ZodString;
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
- kind: z.ZodLiteral<"erc20BalanceDeltaGte">;
1289
- chainId: z.ZodNumber;
1290
- token: z.ZodString;
1291
- owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
1292
- escrow: "escrow";
1293
- delivery: "delivery";
1294
- }>]>;
1295
- minDelta: z.ZodString;
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
- kind: z.ZodLiteral<"nativeBalanceDeltaGte">;
1298
- chainId: z.ZodNumber;
1299
- owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
1300
- escrow: "escrow";
1301
- delivery: "delivery";
1302
- }>]>;
1303
- minDelta: z.ZodString;
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
- escrow: "escrow";
1312
- delivery: "delivery";
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
- escrow: "escrow";
1320
- delivery: "delivery";
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
- gte: "gte";
1341
- eq: "eq";
1342
- lte: "lte";
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
- escrow: "escrow";
1351
- delivery: "delivery";
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
- escrow: "escrow";
1359
- delivery: "delivery";
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
- gte: "gte";
1380
- eq: "eq";
1381
- lte: "lte";
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
- escrow: "escrow";
1390
- delivery: "delivery";
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
- escrow: "escrow";
1398
- delivery: "delivery";
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
- gte: "gte";
1419
- eq: "eq";
1420
- lte: "lte";
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
- escrow: "escrow";
1429
- delivery: "delivery";
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
- escrow: "escrow";
1437
- delivery: "delivery";
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
- escrow: z.ZodOptional<z.ZodObject<{
1584
- chainId: z.ZodNumber;
1585
- address: z.ZodString;
1586
- token: z.ZodString;
1587
- amount: z.ZodString;
1588
- cap: z.ZodString;
1589
- owner: z.ZodString;
1590
- refund: z.ZodString;
1591
- expiresAtMs: z.ZodNumber;
1592
- }, z.core.$strip>>;
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
- readonly $ref: string;
1624
+ readonly $ref: string;
1619
1625
  };
1620
1626
  interface ComposeRun {
1621
- readonly inputs: Record<string, InputSpec>;
1622
- readonly preconditions?: readonly Precondition[];
1623
- readonly signer: string;
1624
- readonly assumptions?: Record<string, bigint>;
1625
- readonly referrer?: string;
1626
- readonly integratorFeeBps?: number;
1627
- readonly maxPriceImpactBps?: number;
1628
- readonly sweepTo?: SweepTo;
1629
- readonly simulationPolicy?: SimulationPolicy;
1630
- /**
1631
- * Also simulate the final user-facing transaction. Defaults to `false`;
1632
- * reverts honour `simulationPolicy` and a success is echoed back as
1633
- * `userProgramSimulation`.
1634
- */
1635
- readonly simulateUserProgram?: boolean;
1636
- readonly checkOnChainAllowances?: boolean;
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
- readonly flow: Flow;
1640
- readonly run: ComposeRun;
1645
+ readonly flow: Flow;
1646
+ readonly run: ComposeRun;
1641
1647
  }
1642
1648
  interface PriceImpact {
1643
- readonly inputValueUsd: number;
1644
- readonly outputValueUsd: number;
1645
- readonly impactBps: number;
1646
- readonly unpricedInputs: readonly string[];
1647
- readonly unpricedOutputs: readonly string[];
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
- readonly token: string;
1651
- readonly spender: string;
1652
- readonly amount: string;
1653
- readonly transactionRequest: {
1654
- readonly to: string;
1655
- readonly data: string;
1656
- readonly value: '0';
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
- readonly code: number;
1661
- readonly rawErrorBytes: string;
1662
- readonly decodeResult?: {
1663
- readonly errorCandidates?: readonly {
1664
- readonly decodedErrorSignature: string;
1665
- readonly decodedParams: readonly string[];
1666
- }[];
1667
- readonly error?: string;
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
- readonly to: string;
1672
- readonly chainId: number;
1673
- readonly data: string;
1674
- readonly value: string;
1675
- readonly gasLimit?: string;
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
- readonly kind: 'transaction';
1679
- readonly purpose: 'approval' | 'execute';
1680
- readonly submitter: 'signer' | 'anyone';
1681
- readonly transactionRequest: ComposeTransactionRequest;
1684
+ readonly kind: 'transaction';
1685
+ readonly purpose: 'approval' | 'execute';
1686
+ readonly submitter: 'signer' | 'anyone';
1687
+ readonly transactionRequest: ComposeTransactionRequest;
1682
1688
  } | {
1683
- readonly kind: 'transaction';
1684
- readonly purpose: 'fundEscrow';
1685
- readonly submitter: 'signer' | 'anyone';
1686
- readonly transactionRequest: ComposeTransactionRequest;
1687
- readonly nodeId: string;
1689
+ readonly kind: 'transaction';
1690
+ readonly purpose: 'fundEscrow';
1691
+ readonly submitter: 'signer' | 'anyone';
1692
+ readonly transactionRequest: ComposeTransactionRequest;
1693
+ readonly nodeId: string;
1688
1694
  } | {
1689
- readonly kind: 'typedData';
1690
- readonly purpose: 'signOrder';
1691
- readonly submitter: 'signer';
1692
- readonly nodeId: string;
1693
- readonly typedData: readonly unknown[];
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
- readonly settlements?: Record<string, SettlementWire>;
1702
+ readonly settlements?: Record<string, SettlementWire>;
1697
1703
  }
1698
1704
  interface SpendEntry {
1699
- readonly input: string;
1700
- readonly token: string;
1701
- readonly chainId: number;
1702
- readonly amount: string;
1703
- readonly nodeId?: string;
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
- readonly input: string;
1707
- readonly token: string;
1708
- readonly recipient: 'lifi' | 'integrator';
1709
- readonly recipientAddress: string;
1710
- readonly bps: number;
1711
- readonly amount?: string;
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
- readonly status: 'ok';
1715
- readonly returnData: string;
1720
+ readonly status: 'ok';
1721
+ readonly returnData: string;
1716
1722
  }
1717
1723
  interface ComposeFill {
1718
- readonly spends: readonly SpendEntry[];
1719
- readonly validUntilMs?: number;
1724
+ readonly spends: readonly SpendEntry[];
1725
+ readonly validUntilMs?: number;
1720
1726
  }
1721
1727
  interface ComposeCompileSuccessData extends ComposeContinuationData {
1722
- readonly outputs: Outputs;
1723
- readonly transactionRequest?: ComposeTransactionRequest;
1724
- readonly actions?: readonly ComposeAction[];
1725
- readonly userProxy: string;
1726
- readonly priceImpact?: PriceImpact;
1727
- readonly approvals?: readonly ApprovalEntry[];
1728
- readonly fees?: readonly ComposeFee[];
1729
- readonly userProgramSimulation?: ComposeUserProgramSimulation;
1730
- readonly fill?: ComposeFill;
1731
- readonly verificationByNode?: Record<string, VerificationDescriptor>;
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
- readonly outputs: Outputs;
1735
- readonly transactionRequest: ComposeTransactionRequest;
1736
- readonly userProxy: string;
1737
- readonly simulationRevert: SimulationRevert;
1738
- readonly approvals?: readonly ApprovalEntry[];
1739
- readonly actions?: readonly ComposeAction[];
1740
- readonly fees?: readonly ComposeFee[];
1741
- readonly userProgramSimulation?: ComposeUserProgramSimulation;
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
- readonly status: 'success';
1750
+ readonly status: 'success';
1745
1751
  }) | (ComposeCompilePartialData & {
1746
- readonly status: 'partial';
1747
- readonly error: {
1748
- readonly kind: string;
1749
- readonly message: string;
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
- readonly name: string;
1755
- readonly type: SolType;
1756
- readonly mode: 'linear' | 'copy';
1757
- readonly availability?: Availability;
1758
- readonly resource?: Resource;
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
- readonly callId: string;
1776
- readonly op: string;
1777
- readonly kind: GenericComposeErrorKind;
1778
- readonly message: string;
1779
- readonly path?: string;
1780
- readonly port?: string;
1781
- readonly fix?: string;
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
- readonly message: string;
1785
- readonly path?: string;
1786
- readonly port?: string;
1787
- readonly fix?: string;
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
- readonly kind: 'preparation_error';
1791
- readonly failedOps: readonly FailedPreparedOp[];
1792
- readonly succeededOps: readonly string[];
1797
+ readonly kind: 'preparation_error';
1798
+ readonly failedOps: readonly FailedPreparedOp[];
1799
+ readonly succeededOps: readonly string[];
1793
1800
  }
1794
1801
  interface SimulationRevertComposeError extends ComposeErrorBase {
1795
- readonly kind: 'simulation_revert';
1796
- readonly details?: SimulationRevert;
1802
+ readonly kind: 'simulation_revert';
1803
+ readonly details?: SimulationRevert;
1797
1804
  }
1798
1805
  interface GenericComposeError extends ComposeErrorBase {
1799
- readonly kind: GenericComposeErrorKind;
1800
- readonly [key: string]: unknown;
1806
+ readonly kind: GenericComposeErrorKind;
1807
+ readonly [key: string]: unknown;
1801
1808
  }
1802
1809
  type ComposeError = PreparationComposeError | SimulationRevertComposeError | GenericComposeError;
1803
1810
  interface MaterialiserInputBase {
1804
- readonly kind: string;
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
- readonly type: string;
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
- declare const PROVIDER_KIND: {
1819
- readonly AAVE_V3: 0;
1820
- readonly ERC3156: 1;
1821
- readonly BALANCER_V2: 2;
1822
- readonly MORPHO_BLUE: 3;
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
- readonly kind: 'flashloan';
1829
- readonly providerKind: ProviderKindName;
1830
- readonly amount: string;
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
- readonly expose?: boolean;
1835
- readonly units?: HandleUnits;
1836
- readonly optional?: Opt;
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
- readonly name: N;
1840
- readonly type: T;
1841
- readonly mode: "linear";
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
- readonly name: N;
1845
- readonly type: T;
1846
- readonly mode: "copy";
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
- readonly name: N;
1850
- readonly type: T;
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
- readonly name: N;
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
- readonly name: N;
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
- readonly optional?: Opt;
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
- readonly name: N;
1862
- readonly optional: NoInfer<Opt>;
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
- readonly name: N;
1866
- readonly mode: "copy";
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
- readonly name: N;
1870
- readonly type: T;
1871
- readonly optional: NoInfer<Opt>;
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
- readonly availability?: Availability;
1875
- readonly providesMinimum?: boolean;
1876
- readonly omitIfZero?: boolean;
1877
- readonly deliveryAddressInput?: string;
1878
- readonly countFrom?: string;
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
- readonly countFrom: infer K extends string;
1890
+ readonly countFrom: infer K extends string;
1882
1891
  } ? {
1883
- readonly countFrom: K;
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
- readonly availability: infer A;
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
- readonly name: N;
1890
- readonly availability: OutputAvailability<O>;
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
- readonly countFrom: string;
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
- readonly scope: 'input';
1903
- readonly port: string;
1913
+ readonly scope: 'input';
1914
+ readonly port: string;
1904
1915
  } | {
1905
- readonly scope: 'output';
1906
- readonly node: string;
1907
- readonly port: string;
1916
+ readonly scope: 'output';
1917
+ readonly node: string;
1918
+ readonly port: string;
1908
1919
  } | {
1909
- readonly scope: 'context';
1910
- readonly key: ContextKey;
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
- (path: RefPath): Ref;
1934
- input(port: string): Ref;
1935
- readonly context: {
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
- readonly input: (port: string) => R;
1942
- readonly context: (key: ContextKey) => R;
1943
- readonly output: (node: string, port: string) => R;
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
- readonly kind: 'evm-native';
1979
- readonly chainId: number;
1988
+ readonly kind: 'evm-native';
1989
+ readonly chainId: number;
1980
1990
  } | {
1981
- readonly kind: 'as-erc20';
1982
- readonly chainId: number;
1983
- readonly nativeErc20: NativeErc20;
1991
+ readonly kind: 'as-erc20';
1992
+ readonly chainId: number;
1993
+ readonly nativeErc20: NativeErc20;
1984
1994
  } | {
1985
- readonly kind: 'native-mirrored-erc20';
1986
- readonly chainId: number;
1987
- readonly nativeErc20: NativeErc20;
1988
- /** Native wei per 1 unit of the facade ERC-20 (1e12 on Arc: 18-dec native, 6-dec USDC). */
1989
- readonly nativeScale: bigint;
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
- readonly token: `0x${string}`;
1993
- readonly symbol: string;
1994
- readonly decimals: number;
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
- readonly evmNative: (chainId: number) => R;
2030
- readonly asErc20: (nativeErc20: NativeErc20, chainId: number) => R;
2031
- readonly nativeMirroredErc20: (nativeErc20: NativeErc20, nativeScale: bigint, chainId: number) => R;
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
- readonly kind: 'keep';
2063
+ readonly kind: 'keep';
2054
2064
  } | {
2055
- readonly kind: 'rewrite';
2056
- readonly token: `0x${string}`;
2065
+ readonly kind: 'rewrite';
2066
+ readonly token: `0x${string}`;
2057
2067
  } | {
2058
- readonly kind: 'reject';
2059
- readonly reason: string;
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
- readonly type: 'EXACT';
2184
- readonly amount: bigint | string;
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
- readonly type: 'ALL';
2213
- readonly simAmount: bigint | string;
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
- /** EVM chain id. Both tokens must live on this chain — routes are same-chain. */
2223
- readonly chainId: number;
2224
- /**
2225
- * Token to spend. Use the chain's native sentinel address for the gas coin
2226
- * (the zero address on EVM-native chains).
2227
- */
2228
- readonly fromToken: string;
2229
- /** Token to receive. */
2230
- readonly toToken: string;
2231
- /** How much of `fromToken` to spend — an exact amount or the whole balance. */
2232
- readonly amount: RouteAmount;
2233
- /** Address that funds the route and, by default, owns its output. */
2234
- readonly signer: string;
2235
- /**
2236
- * Slippage tolerance in basis points. Range 0–10000. Defaults to `100` (1%)
2237
- * server-side when omitted. It is an end-to-end tolerance: the floor is the
2238
- * simulated final output of the whole route, so a multi-hop route is not
2239
- * bounded hop by hop. When the route begins with an aggregator swap the same
2240
- * value is also the swap's own tolerance, which nests inside the end-to-end
2241
- * floor rather than compounding with it.
2242
- */
2243
- readonly slippageBps?: number;
2244
- /**
2245
- * Reject the route when its quoted price impact exceeds this many basis
2246
- * points. Range 0–10000. Omitted ⇒ the server's default of 500 bps applies;
2247
- * `0` disables the check.
2248
- */
2249
- readonly maxPriceImpactBps?: number;
2250
- /**
2251
- * Integrator fee in basis points, taken from the input amount. Range 0–9000.
2252
- * Defaults to `0` server-side when omitted. A non-zero value requires an
2253
- * integration-scoped API key; the server rejects it otherwise.
2254
- */
2255
- readonly integratorFeeBps?: number;
2256
- /** Opaque referrer tag forwarded to the underlying quote provider. */
2257
- readonly referrer?: string;
2258
- /**
2259
- * Owner of every asset the route leaves behind; defaults to `signer` on a
2260
- * route with no aggregator swap. Routes whose protocol mints to a named
2261
- * receiver (surfaced as `recipient: 'required'` by `GET /compose/zap-packs`)
2262
- * and asynchronous routes bind this address at mint time rather than
2263
- * transferring afterwards; otherwise the proxy's whole balance of each
2264
- * asset the route leaves is transferred here.
2265
- *
2266
- * **Required when the route includes an aggregator swap.** Such a route can
2267
- * leave an asset the caller did not plan for — the swap's unspent input —
2268
- * and this address receives it alongside the terminal output, so it must be
2269
- * named explicitly; omitting it fails with `validation_error`.
2270
- *
2271
- * Accepts an address or `{ $ref: 'context.sender' }` (which counts as
2272
- * explicit); `{ $ref: 'context.executionAddress' }` is rejected.
2273
- */
2274
- readonly sweepTo?: SweepTo;
2275
- /**
2276
- * `'strict'` (the default) fails the request when simulation detects a
2277
- * revert; `'allow-revert'` returns a partial result with revert diagnostics
2278
- * instead.
2279
- */
2280
- readonly simulationPolicy?: SimulationPolicy;
2281
- /**
2282
- * Also simulate the final user-facing transaction after the structured
2283
- * simulation succeeds. Reverts honour `simulationPolicy`. Defaults to `false`.
2284
- */
2285
- readonly simulateUserProgram?: boolean;
2286
- /**
2287
- * Filter the returned `approvals` against current on-chain allowances,
2288
- * omitting approvals that are already sufficient. Defaults to `false`.
2289
- */
2290
- readonly checkOnChainAllowances?: boolean;
2291
- /**
2292
- * Accept a route whose output is delivered only after the initiating
2293
- * transaction settles (`delivery.when: 'future'` on the terminal output).
2294
- * Such a route obliges you to track settlement rather than treat the
2295
- * transaction as completing the job, and carries no slippage floor, so it is
2296
- * opt-in. Defaults to `false` server-side, which leaves a pair reachable
2297
- * only asynchronously rejected with `no_route_error` and guarantees every
2298
- * terminal output is `delivery.when: 'now'`.
2299
- *
2300
- * It widens reach, it is not a preference: a synchronous route wins at any
2301
- * length, so a pair with both a one-hop asynchronous edge and a longer
2302
- * synchronous route is served synchronously. Opting in never costs you a
2303
- * synchronous route.
2304
- */
2305
- readonly allowAsyncRoutes?: boolean;
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
- readonly type: 'Erc20Balance';
2319
- readonly wallet: string;
2320
- readonly token: string;
2321
- readonly balance: bigint | string;
2296
+ readonly type: 'Erc20Balance';
2297
+ readonly wallet: string;
2298
+ readonly token: string;
2299
+ readonly balance: bigint | string;
2322
2300
  };
2323
2301
  type NativeBalancePrecondition = {
2324
- readonly type: 'NativeBalance';
2325
- readonly wallet: string;
2326
- readonly balance: bigint | string;
2302
+ readonly type: 'NativeBalance';
2303
+ readonly wallet: string;
2304
+ readonly balance: bigint | string;
2327
2305
  };
2328
2306
  type Erc20AllowancePrecondition = {
2329
- readonly type: 'Erc20Allowance';
2330
- readonly owner: string;
2331
- readonly spender: string;
2332
- readonly token: string;
2333
- readonly allowance: bigint | string;
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
- /** Token to watch (use the zero address for native balance). */
2384
- readonly token: string;
2385
- /** Account whose balance of `token` is watched. */
2386
- readonly owner: string;
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
- /** EVM chain id. */
2402
- readonly chainId: number;
2403
- /**
2404
- * Sender of the simulated transaction. The VM bytecode is injected here so
2405
- * the inner call carries `msg.sender == from`.
2406
- */
2407
- readonly from: string;
2408
- /** Target contract of the raw transaction. */
2409
- readonly to: string;
2410
- /** Pre-encoded transaction calldata (`0x`-prefixed hex). */
2411
- readonly data: string;
2412
- /**
2413
- * Native value (wei) sent with the inner call. Accepts `bigint | string`;
2414
- * defaults to `"0"` server-side when omitted.
2415
- */
2416
- readonly value?: bigint | string;
2417
- /**
2418
- * Block number to simulate against. Omitted ⇒ the chain head. Named tags
2419
- * (e.g. "latest") are rejected with HTTP 400.
2420
- */
2421
- readonly block?: number;
2422
- /** Funding instructions applied before simulation (max 40). */
2423
- readonly requirements?: readonly SlotFinderRequirement[];
2424
- /** Balances to read before and after the transaction (1–40 pairs). */
2425
- readonly trackedBalances: readonly TrackedBalance[];
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
- readonly token: string;
2433
- readonly owner: string;
2434
- readonly amount: string;
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
- readonly status: 'ok';
2448
- readonly block: number;
2449
- readonly timestamp: number;
2450
- readonly balancesBefore: SimulateBalanceEntry[];
2451
- readonly balancesAfter: SimulateBalanceEntry[];
2452
- readonly deltas: SimulateBalanceEntry[];
2453
- readonly gasUsed: string;
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
- readonly errorCandidates?: {
2458
- readonly decodedErrorSignature: string;
2459
- readonly decodedParams: string[];
2460
- }[];
2461
- readonly error?: string;
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
- readonly status: 'revert';
2469
- readonly block: number;
2470
- readonly timestamp: number;
2471
- readonly revertReason?: string;
2472
- readonly code?: number;
2473
- readonly rawErrorBytes?: string;
2474
- readonly decodeResult?: SimulateRevertDecodeResult;
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
- readonly status: 'error';
2482
- readonly message: string;
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
- readonly major: number;
2515
- readonly minor: number;
2516
- readonly patch: number;
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,30 @@ 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
- readonly kind: 'exact';
2550
- readonly amount: bigint;
2513
+ readonly kind: 'exact';
2514
+ readonly amount: bigint;
2551
2515
  } | {
2552
- readonly kind: 'exact-native';
2553
- readonly amount: bigint;
2516
+ readonly kind: 'exact-native';
2517
+ readonly amount: bigint;
2554
2518
  } | {
2555
- readonly kind: 'capped';
2556
- readonly amount: bigint;
2519
+ readonly kind: 'capped';
2520
+ readonly amount: bigint;
2557
2521
  } | {
2558
- readonly kind: 'runtime';
2522
+ readonly kind: 'runtime';
2559
2523
  };
2560
2524
  interface MaterialiserResolution {
2561
- readonly meta: MaterialiserMetadata;
2562
- readonly preconditions: readonly Precondition[];
2525
+ readonly meta: MaterialiserMetadata;
2526
+ readonly preconditions: readonly Precondition[];
2563
2527
  }
2564
- declare const foldMaterialiserMetadata: <R>(meta: MaterialiserMetadata, cases: {
2565
- readonly exact: (amount: bigint) => R;
2566
- readonly exactNative: (amount: bigint) => R;
2567
- readonly capped: (amount: bigint) => R;
2568
- readonly runtime: () => R;
2528
+ export declare const foldMaterialiserMetadata: <R>(meta: MaterialiserMetadata, cases: {
2529
+ readonly exact: (amount: bigint) => R;
2530
+ readonly exactNative: (amount: bigint) => R;
2531
+ readonly capped: (amount: bigint) => R;
2532
+ readonly runtime: () => R;
2569
2533
  }) => R;
2570
-
2571
- export { ARC_CHAIN_ID, ARC_NATIVE_ERC20, ARC_NATIVE_SCALE, type Amount, type AppliedGuard, AppliedGuardSchema, type ApprovalEntry, AssertedErc20BalanceGteSpecSchema, AssertedNativeBalanceGteSpecSchema, type AssertedPredicate, AssertedPredicateSchema, type AssertedPredicateWire, AssertedPredicateZod, type AssertionOwner, AssertionOwnerSchema, type AssertionSpec, AssertionSpecSchema, type AssertionSpecWire, AssertionSpecZod, type Availability, type BindValue, BindValueSchema, Bytes32HexSchema, COMPOSER_SDK_VERSION_HEADER, COMPOSE_VERSION_HEADER, CONTINUATION_COMMITMENT_OP_ID, type Call, CallCheckSpecSchema, CallSchema, type ChainCapabilities, type ComposeAction, type ComposeCompilePartialData, type ComposeCompileRequest, type ComposeCompileResult, type ComposeCompileSuccessData, type ComposeError, type ComposeErrorKind, type ComposeFee, type ComposeFill, type ComposeManifest, ComposeManifestZod, type ComposeRouteErrorKind, type ComposeRouteRequest, type ComposeRun, type ComposeTransactionRequest, type ComposeUserProgramSimulation, type ComposeVersion, type ConsumedOutput, type ContextKey, type ContinuationIntent, ContinuationIntentSchema, type ContinuationOutcome, ContinuationOutcomeSchema, type Delivery, EVMAddressString, EVM_NATIVE_SENTINEL, type Erc20AllowancePrecondition, type Erc20AllowanceRequirement, Erc20BalanceDeltaGteSpecSchema, Erc20BalanceGteSpecSchema, type Erc20BalancePrecondition, type Erc20BalanceRequirement, type Estimate, type EstimateBasis, type FailedPreparedOp, type FlashloanMaterialiserInput, type Flow, type FlowInput, FlowInputSchema, FlowSchema, type GenericComposeError, type GenericComposeErrorKind, type GuardCompatibility, GuardCompatibilityZod, type GuardSelector, GuardSelectorZod, HANDLE_UNITS, type HandleInput, HandleInputSchema, type HandlePort, HandlePortZod, type HandleUnits, HandleUnitsZod, HexStringSchema, InputPortZod, type InputSpec, IntegerString, type Lineage, LineageSchema, type LiteralBinding, LiteralBindingSchema, type ManifestGuard, ManifestGuardZod, type ManifestMaterialiser, ManifestMaterialiserZod, type ManifestOperation, ManifestOperationZod, type ManifestPrecondition, ManifestPreconditionZod, type MaterialiserConfigOf, type MaterialiserInput, type MaterialiserInputBase, type MaterialiserInputOf, type MaterialiserMetadata, type MaterialiserResolution, type Minimum, type MinimumBasis, NativeBalanceDeltaGteSpecSchema, NativeBalanceGteSpecSchema, type NativeBalancePrecondition, type NativeBalanceRequirement, type NativeCheckPolicy, type NativeErc20, type OpInputPort, type OpOutputPort, type Output, type OutputAmount, type OutputFamilyPort, OutputPortZod, type Outputs, PROVIDER_KIND, type ParsedRef, type Phase1Artifact, Phase1ArtifactSchema, type Port, type Precondition, type PreconditionBase, type PreconditionConfigOf, type PreconditionOf, type PreparationComposeError, type PriceImpact, type ProviderKindName, RESERVED_REF_SCOPES, type Ref, type RefBuilder, type RefPath, RefSchema, type RefScope, type Resource, type ResourceInput, ResourceInputSchema, type ResourceOutputPort, ResourceOutputPortZod, type ResourcePort, ResourcePortZod, ResourceSchema, type RouteAmount, type RouteAmountAll, type RouteAmountExact, SIMULATE_MAX_REQUIREMENTS, SIMULATE_MAX_TRACKED_BALANCES, STATIC_SOL_TYPES, type SettlementEscrowWire, type SettlementWire, SettlementZod, type SimulateBalanceEntry, type SimulateOkResult, type SimulateRequest, type SimulateResult, type SimulateRevertDecodeResult, type SimulateRevertResult, type SimulateSetupErrorResult, type SimulationPolicy, type SimulationRevert, type SimulationRevertComposeError, type SlotFinderRequirement, type SolType, SolTypeSchema, type SpendEntry, type StaticSolType, StaticSolTypeZod, type SweepTo, TEMPO_CHAIN_ID, TEMPO_NATIVE_ERC20, type TerminalOutput, type TrackedBalance, UuidSchema, type VerificationDescriptor, VerificationDescriptorSchema, type VerificationDescriptorWire, VerificationDescriptorZod, type VersionCompatibility, canonicalAssertedPredicate, canonicalNativeAddress, checkCompatibility, copy, erc20, erc20Allowance, erc20Balance, erc20Resource, erc20Token, expandOutputPorts, familySize, flowInputMode, flowInputResource, flowInputType, foldChainCapabilities, foldMaterialiserMetadata, foldRef, foldResource, getChainCapabilities, handle, hasErc20CanonicalNative, instancePortName, isAsErc20Chain, isContextKey, isERC20Resource, isErc20AllowancePrecondition, isErc20BalancePrecondition, isFutureResourceOutput, isHandlePort, isMaterialiserInput, isMsgValueNative, isNativeAddressForChain, isNativeBalancePrecondition, isNativeResource, isOutputFamily, isRef, isResourceInput, isResourceOutputPort, isResourcePort, isStaticSolType, linear, native, nativeBalance, nativeCheckPolicy, nativeResource, normalizeNativeTokenAddress, normalizeResource, opHandle, parseRef, parseVersion, providerKindByName, providerKindNames, readResource, ref, refKey, resource, resourceKey, resourceOutput, resourceToken, resourcesEqual, settledOutcome };
2534
+ //#endregion
2535
+ 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 };