@lifi/compose-spec 0.2.0-staging.5 → 0.3.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.js CHANGED
@@ -1,5 +1,53 @@
1
1
  // src/flowSchema.ts
2
2
  import { Schema } from "effect";
3
+
4
+ // src/chainCapabilities.ts
5
+ var EVM_NATIVE_SENTINEL = (
6
+ // eslint-disable-next-line @lifi/prefer-utils-constants -- compose-spec is the wire-format leaf and must not import @lifi/utils (enforced by scripts/check-compose-boundaries.mjs); the literal is intentional here
7
+ "0x0000000000000000000000000000000000000000"
8
+ );
9
+ var isNativeSentinel = (address) => address.toLowerCase() === EVM_NATIVE_SENTINEL.toLowerCase();
10
+ var TEMPO_CHAIN_ID = 4217;
11
+ var TEMPO_NATIVE_ERC20 = {
12
+ token: "0x20C0000000000000000000000000000000000000",
13
+ symbol: "pathUSD",
14
+ decimals: 6
15
+ };
16
+ var REGISTRY = /* @__PURE__ */ new Map([
17
+ [
18
+ TEMPO_CHAIN_ID,
19
+ {
20
+ kind: "as-erc20",
21
+ chainId: TEMPO_CHAIN_ID,
22
+ nativeErc20: TEMPO_NATIVE_ERC20
23
+ }
24
+ ]
25
+ ]);
26
+ var getChainCapabilities = (chainId) => REGISTRY.get(chainId) ?? { kind: "evm-native", chainId };
27
+ var isAsErc20Chain = (chainId) => getChainCapabilities(chainId).kind === "as-erc20";
28
+ var canonicalNativeAddress = (chainId) => {
29
+ const caps = getChainCapabilities(chainId);
30
+ return caps.kind === "as-erc20" ? caps.nativeErc20.token : EVM_NATIVE_SENTINEL;
31
+ };
32
+ var isNativeAddressForChain = (chainId, address) => {
33
+ const caps = getChainCapabilities(chainId);
34
+ const target = caps.kind === "as-erc20" ? caps.nativeErc20.token : EVM_NATIVE_SENTINEL;
35
+ return address.toLowerCase() === target.toLowerCase();
36
+ };
37
+ var isMsgValueNative = (chainId, address) => !isAsErc20Chain(chainId) && isNativeSentinel(address);
38
+ var normalizeResource = (r) => {
39
+ if (r.kind !== "native") return r;
40
+ const caps = getChainCapabilities(r.chainId);
41
+ if (caps.kind !== "as-erc20") return r;
42
+ return {
43
+ kind: "erc20",
44
+ chainId: r.chainId,
45
+ token: caps.nativeErc20.token
46
+ };
47
+ };
48
+ var normalizeNativeTokenAddress = (token, chainId) => isAsErc20Chain(chainId) && isNativeSentinel(token) ? canonicalNativeAddress(chainId) : token;
49
+
50
+ // src/flowSchema.ts
3
51
  var SolTypeSchema = Schema.Literal(
4
52
  "uint8",
5
53
  "uint16",
@@ -16,8 +64,11 @@ var SolTypeSchema = Schema.Literal(
16
64
  "bytes32",
17
65
  "string"
18
66
  );
19
- var ChainIdSchema = Schema.Number.pipe(Schema.int(), Schema.positive());
20
- var ResourceSchema = Schema.Union(
67
+ var ChainIdSchema = Schema.Number.pipe(
68
+ Schema.int(),
69
+ Schema.positive()
70
+ );
71
+ var RawResourceSchema = Schema.Union(
21
72
  Schema.Struct({ kind: Schema.Literal("native"), chainId: ChainIdSchema }),
22
73
  Schema.Struct({
23
74
  kind: Schema.Literal("erc20"),
@@ -25,6 +76,15 @@ var ResourceSchema = Schema.Union(
25
76
  chainId: ChainIdSchema
26
77
  })
27
78
  );
79
+ var ResourceSchema = Schema.transform(
80
+ RawResourceSchema,
81
+ Schema.typeSchema(RawResourceSchema),
82
+ {
83
+ strict: true,
84
+ decode: (raw) => normalizeResource(raw),
85
+ encode: (resource2) => resource2
86
+ }
87
+ );
28
88
  var ResourceInputSchema = Schema.Struct({
29
89
  name: Schema.String,
30
90
  resource: ResourceSchema
@@ -76,9 +136,197 @@ var FlowSchema = Schema.Struct({
76
136
  chainId: ChainIdSchema,
77
137
  inputs: Schema.Array(FlowInputSchema),
78
138
  nodes: Schema.Array(CallSchema),
79
- continuation: Schema.optional(ContinuationSchema)
139
+ continuations: Schema.optional(Schema.Array(ContinuationSchema))
80
140
  });
81
141
 
142
+ // src/continuation.ts
143
+ import { Schema as Schema2 } from "effect";
144
+ var CONTINUATION_COMMITMENT_OP_ID = "continuation.commitment";
145
+ var RawContinuationOutcomeSchema = Schema2.Struct({
146
+ token: Schema2.String,
147
+ minAmount: Schema2.String,
148
+ destination: Schema2.String,
149
+ chainId: ChainIdSchema
150
+ });
151
+ var ContinuationOutcomeSchema = Schema2.transform(
152
+ RawContinuationOutcomeSchema,
153
+ Schema2.typeSchema(RawContinuationOutcomeSchema),
154
+ {
155
+ strict: true,
156
+ decode: (raw) => ({
157
+ ...raw,
158
+ token: normalizeNativeTokenAddress(raw.token, raw.chainId)
159
+ }),
160
+ encode: (outcome) => outcome
161
+ }
162
+ );
163
+ var ContinuationIntentSchema = Schema2.Struct({
164
+ // `NonEmptyArray` enforces ≥1 outcome at the parse boundary, so downstream needs no guard.
165
+ outcomes: Schema2.NonEmptyArray(ContinuationOutcomeSchema),
166
+ continuationFlow: Schema2.optional(FlowSchema),
167
+ validity: Schema2.Struct({ expiresAtMs: Schema2.Number }),
168
+ perpetual: Schema2.optional(Schema2.Boolean),
169
+ provider: Schema2.optional(Schema2.String)
170
+ });
171
+ var Phase1ArtifactSchema = Schema2.Union(
172
+ Schema2.Struct({
173
+ kind: Schema2.Literal("transaction"),
174
+ transactionRequest: Schema2.optional(
175
+ Schema2.Struct({
176
+ to: Schema2.String,
177
+ data: Schema2.String,
178
+ value: Schema2.String
179
+ })
180
+ )
181
+ }),
182
+ Schema2.Struct({
183
+ kind: Schema2.Literal("signables"),
184
+ typedData: Schema2.Array(Schema2.Unknown)
185
+ }),
186
+ Schema2.Struct({ kind: Schema2.Literal("none") })
187
+ );
188
+ var HexStringSchema = Schema2.String.pipe(Schema2.startsWith("0x"));
189
+ var AssertionOwnerSchema = Schema2.Union(
190
+ HexStringSchema,
191
+ Schema2.Literal("escrow", "delivery")
192
+ );
193
+ var Erc20BalanceGteSpecSchema = Schema2.Struct({
194
+ kind: Schema2.Literal("erc20BalanceGte"),
195
+ chainId: ChainIdSchema,
196
+ token: HexStringSchema,
197
+ owner: HexStringSchema,
198
+ minAmount: Schema2.String
199
+ });
200
+ var NativeBalanceGteSpecSchema = Schema2.Struct({
201
+ kind: Schema2.Literal("nativeBalanceGte"),
202
+ chainId: ChainIdSchema,
203
+ owner: HexStringSchema,
204
+ minAmount: Schema2.String
205
+ });
206
+ var CallCheckSpecSchema = Schema2.Struct({
207
+ kind: Schema2.Literal("call"),
208
+ chainId: ChainIdSchema,
209
+ to: HexStringSchema,
210
+ calldata: HexStringSchema,
211
+ comparator: Schema2.Literal("gte", "eq", "lte"),
212
+ value: Schema2.String
213
+ });
214
+ var asErc20BalanceGteCheck = (chainId, owner, minAmount) => ({
215
+ kind: "erc20BalanceGte",
216
+ chainId,
217
+ token: canonicalNativeAddress(chainId),
218
+ owner,
219
+ minAmount
220
+ });
221
+ var RawCheckSchema = Schema2.Union(
222
+ Erc20BalanceGteSpecSchema,
223
+ NativeBalanceGteSpecSchema,
224
+ CallCheckSpecSchema
225
+ );
226
+ var CheckSchema = Schema2.transform(
227
+ RawCheckSchema,
228
+ Schema2.typeSchema(RawCheckSchema),
229
+ {
230
+ strict: true,
231
+ decode: (check) => check.kind === "nativeBalanceGte" && isAsErc20Chain(check.chainId) ? asErc20BalanceGteCheck(check.chainId, check.owner, check.minAmount) : check,
232
+ encode: (check) => check
233
+ }
234
+ );
235
+ var Erc20BalanceDeltaGteSpecSchema = Schema2.Struct({
236
+ kind: Schema2.Literal("erc20BalanceDeltaGte"),
237
+ chainId: ChainIdSchema,
238
+ token: HexStringSchema,
239
+ owner: AssertionOwnerSchema,
240
+ minDelta: Schema2.String
241
+ });
242
+ var NativeBalanceDeltaGteSpecSchema = Schema2.Struct({
243
+ kind: Schema2.Literal("nativeBalanceDeltaGte"),
244
+ chainId: ChainIdSchema,
245
+ owner: AssertionOwnerSchema,
246
+ minDelta: Schema2.String
247
+ });
248
+ var AssertionSpecSchema = Schema2.Union(
249
+ Erc20BalanceGteSpecSchema,
250
+ NativeBalanceGteSpecSchema,
251
+ CallCheckSpecSchema,
252
+ Erc20BalanceDeltaGteSpecSchema,
253
+ NativeBalanceDeltaGteSpecSchema
254
+ );
255
+ var ContinuationPlanSchema = Schema2.Struct({
256
+ chainId: ChainIdSchema,
257
+ nextFlow: FlowSchema,
258
+ check: CheckSchema,
259
+ validity: Schema2.Struct({ expiresAtMs: Schema2.Number }),
260
+ correlationId: Schema2.optional(Schema2.String)
261
+ });
262
+ var isGTECheck = (check) => check.kind === "call" && check.comparator === "gte";
263
+ var isLTECheck = (check) => check.kind === "call" && check.comparator === "lte";
264
+ var isEQCheck = (check) => check.kind === "call" && check.comparator === "eq";
265
+
266
+ // src/descriptor.ts
267
+ import { Schema as Schema3 } from "effect";
268
+
269
+ // src/hexPatterns.ts
270
+ var BYTES32_LOWER_HEX = /^0x[0-9a-f]{64}$/;
271
+
272
+ // src/descriptor.ts
273
+ var Bytes32HexSchema = Schema3.String.pipe(
274
+ Schema3.pattern(BYTES32_LOWER_HEX)
275
+ );
276
+ var AssertedErc20BalanceGteSpecSchema = Schema3.Struct({
277
+ kind: Schema3.Literal("erc20BalanceGte"),
278
+ chainId: ChainIdSchema,
279
+ token: HexStringSchema,
280
+ owner: AssertionOwnerSchema,
281
+ minAmount: Schema3.String
282
+ });
283
+ var AssertedNativeBalanceGteSpecSchema = Schema3.Struct({
284
+ kind: Schema3.Literal("nativeBalanceGte"),
285
+ chainId: ChainIdSchema,
286
+ owner: AssertionOwnerSchema,
287
+ minAmount: Schema3.String
288
+ });
289
+ var RawAssertedPredicateSchema = Schema3.Union(
290
+ AssertedErc20BalanceGteSpecSchema,
291
+ AssertedNativeBalanceGteSpecSchema,
292
+ CallCheckSpecSchema,
293
+ Erc20BalanceDeltaGteSpecSchema,
294
+ NativeBalanceDeltaGteSpecSchema
295
+ );
296
+ var AssertedPredicateSchema = Schema3.transform(
297
+ RawAssertedPredicateSchema,
298
+ Schema3.typeSchema(RawAssertedPredicateSchema),
299
+ {
300
+ strict: true,
301
+ decode: (pred) => pred.kind === "nativeBalanceGte" && isAsErc20Chain(pred.chainId) ? asErc20BalanceGteCheck(pred.chainId, pred.owner, pred.minAmount) : pred,
302
+ encode: (pred) => pred
303
+ }
304
+ );
305
+ var VerificationDescriptorSchema = Schema3.Struct({
306
+ validationProgramHash: Bytes32HexSchema,
307
+ // The C5 echo's second hash (verified continuations, plan GD-8): `keccak256`
308
+ // over the canonical params vector (`paramsHash`, GD-2 seam C1). Required and
309
+ // jointly necessary with `validationProgramHash` — the program hash is
310
+ // value-blind (it never binds the delivery address or amounts), so a descriptor
311
+ // that enforces only it is a fund-redirect hole. Empty params still yield a
312
+ // present `0x00…00`, so a real descriptor never omits it. Strict 32-byte
313
+ // lowercase hex, same rule as `validationProgramHash`.
314
+ paramsHash: Bytes32HexSchema,
315
+ assertedPredicate: Schema3.Array(AssertedPredicateSchema)
316
+ });
317
+ var canonicalJson = (value) => {
318
+ if (Array.isArray(value)) {
319
+ return `[${value.map(canonicalJson).join(",")}]`;
320
+ }
321
+ if (value !== null && typeof value === "object") {
322
+ const record = value;
323
+ const entries = Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`);
324
+ return `{${entries.join(",")}}`;
325
+ }
326
+ return JSON.stringify(value);
327
+ };
328
+ var canonicalAssertedPredicate = (specs) => canonicalJson(specs);
329
+
82
330
  // src/flow.ts
83
331
  var isResourceInput = (input) => "resource" in input;
84
332
  var flowInputType = (input) => isResourceInput(input) ? "uint256" : input.type;
@@ -111,6 +359,10 @@ var resourcesEqual = (a, b) => {
111
359
  return false;
112
360
  };
113
361
  var foldResource = (r, cases) => r.kind === "native" ? cases.native(r.chainId) : cases.erc20(r.token, r.chainId);
362
+ var resourceToken = (r) => foldResource(r, {
363
+ native: () => EVM_NATIVE_SENTINEL,
364
+ erc20: (token) => token
365
+ });
114
366
  var resourceKey = (r) => foldResource(r, {
115
367
  native: (chainId) => `native:${chainId}`,
116
368
  erc20: (token, chainId) => `erc20:${token.toLowerCase()}:${chainId}`
@@ -146,7 +398,7 @@ var inputRef = (port) => ({ $ref: `input.${port}` });
146
398
  var outputRef = (node, port) => ({
147
399
  $ref: `${node}.${port}`
148
400
  });
149
- var optionalProp = (key, value) => value != null ? { [key]: value } : {};
401
+ var optionalProp = (key, value) => value !== void 0 && value !== null ? { [key]: value } : {};
150
402
  var linear = (name, type) => ({ name, type, mode: "linear", availability: "now" });
151
403
  var copy = (name, type) => ({ name, type, mode: "copy", availability: "now" });
152
404
  var handle = (name, type) => ({ name, type });
@@ -214,6 +466,10 @@ var refKey = (ref) => foldRef(parseRef(ref), {
214
466
  output: (node, port) => `output:${node}:${port}`
215
467
  });
216
468
 
469
+ // src/simulate.ts
470
+ var SIMULATE_MAX_TRACKED_BALANCES = 40;
471
+ var SIMULATE_MAX_REQUIREMENTS = 40;
472
+
217
473
  // src/materialiserMetadata.ts
218
474
  var foldMaterialiserMetadata = (meta, cases) => {
219
475
  if (meta.kind === "exact") return cases.exact(meta.amount);
@@ -223,6 +479,7 @@ var foldMaterialiserMetadata = (meta, cases) => {
223
479
 
224
480
  // src/zodSchemas.ts
225
481
  import z from "zod";
482
+ var chainIdZod = z.number().int().positive();
226
483
  var SolTypeZod = z.enum([
227
484
  "uint8",
228
485
  "uint16",
@@ -353,12 +610,134 @@ var ComposeManifestZod = z.object({
353
610
  materialisers: z.array(ManifestMaterialiserZod),
354
611
  preconditions: z.array(ManifestPreconditionZod).optional()
355
612
  });
613
+ var Phase1ArtifactZod = z.discriminatedUnion("kind", [
614
+ z.object({
615
+ kind: z.literal("transaction"),
616
+ transactionRequest: z.object({
617
+ to: z.string(),
618
+ data: z.string(),
619
+ value: z.string()
620
+ }).optional()
621
+ }),
622
+ z.object({
623
+ kind: z.literal("signables"),
624
+ typedData: z.array(z.unknown())
625
+ }),
626
+ z.object({
627
+ kind: z.literal("none")
628
+ })
629
+ ]);
630
+ var hexStringZod = z.string().startsWith("0x");
631
+ var assertionOwnerZod = z.union([
632
+ hexStringZod,
633
+ z.enum(["escrow", "delivery"])
634
+ ]);
635
+ var CheckZod = z.discriminatedUnion("kind", [
636
+ z.object({
637
+ kind: z.literal("erc20BalanceGte"),
638
+ chainId: chainIdZod,
639
+ token: hexStringZod,
640
+ owner: hexStringZod,
641
+ minAmount: z.string()
642
+ }),
643
+ z.object({
644
+ kind: z.literal("nativeBalanceGte"),
645
+ chainId: chainIdZod,
646
+ owner: hexStringZod,
647
+ minAmount: z.string()
648
+ }),
649
+ z.object({
650
+ kind: z.literal("call"),
651
+ chainId: chainIdZod,
652
+ to: hexStringZod,
653
+ calldata: hexStringZod,
654
+ comparator: z.enum(["gte", "eq", "lte"]),
655
+ value: z.string()
656
+ })
657
+ ]);
658
+ var AssertionSpecZod = z.discriminatedUnion("kind", [
659
+ ...CheckZod.options,
660
+ z.object({
661
+ kind: z.literal("erc20BalanceDeltaGte"),
662
+ chainId: z.number().int().positive(),
663
+ token: hexStringZod,
664
+ owner: assertionOwnerZod,
665
+ minDelta: z.string()
666
+ }),
667
+ z.object({
668
+ kind: z.literal("nativeBalanceDeltaGte"),
669
+ chainId: z.number().int().positive(),
670
+ owner: assertionOwnerZod,
671
+ minDelta: z.string()
672
+ })
673
+ ]);
674
+ var assertionSpecOptionByKind = (kind) => {
675
+ const option = AssertionSpecZod.options.find(
676
+ (o) => o.shape.kind.value === kind
677
+ );
678
+ if (option === void 0) {
679
+ throw new Error(`AssertionSpecZod has no member with kind "${kind}"`);
680
+ }
681
+ return option;
682
+ };
683
+ var AssertedPredicateZod = z.discriminatedUnion("kind", [
684
+ z.object({
685
+ kind: z.literal("erc20BalanceGte"),
686
+ chainId: z.number().int().positive(),
687
+ token: hexStringZod,
688
+ owner: assertionOwnerZod,
689
+ minAmount: z.string()
690
+ }),
691
+ z.object({
692
+ kind: z.literal("nativeBalanceGte"),
693
+ chainId: z.number().int().positive(),
694
+ owner: assertionOwnerZod,
695
+ minAmount: z.string()
696
+ }),
697
+ assertionSpecOptionByKind("call"),
698
+ assertionSpecOptionByKind("erc20BalanceDeltaGte"),
699
+ assertionSpecOptionByKind("nativeBalanceDeltaGte")
700
+ ]);
701
+ var VerificationDescriptorZod = z.object({
702
+ validationProgramHash: z.string().regex(BYTES32_LOWER_HEX),
703
+ // The C5 echo's second hash (GD-8): the params-vector content hash
704
+ // (`paramsHash`, C1). Required and jointly necessary with the value-blind
705
+ // `validationProgramHash`.
706
+ paramsHash: z.string().regex(BYTES32_LOWER_HEX),
707
+ assertedPredicate: z.array(AssertedPredicateZod)
708
+ });
709
+ var ContinuationPlanZod = z.object({
710
+ chainId: chainIdZod,
711
+ nextFlow: z.unknown(),
712
+ check: CheckZod,
713
+ validity: z.object({ expiresAtMs: z.number() }),
714
+ correlationId: z.string().optional()
715
+ });
356
716
  export {
357
717
  AppliedGuardSchema,
718
+ AssertedErc20BalanceGteSpecSchema,
719
+ AssertedNativeBalanceGteSpecSchema,
720
+ AssertedPredicateSchema,
721
+ AssertedPredicateZod,
722
+ AssertionOwnerSchema,
723
+ AssertionSpecSchema,
724
+ AssertionSpecZod,
358
725
  BindValueSchema,
726
+ Bytes32HexSchema,
727
+ CONTINUATION_COMMITMENT_OP_ID,
728
+ CallCheckSpecSchema,
359
729
  CallSchema,
730
+ CheckSchema,
731
+ CheckZod,
360
732
  ComposeManifestZod,
733
+ ContinuationIntentSchema,
734
+ ContinuationOutcomeSchema,
735
+ ContinuationPlanSchema,
736
+ ContinuationPlanZod,
361
737
  ContinuationSchema,
738
+ EVM_NATIVE_SENTINEL,
739
+ Erc20BalanceDeltaGteSpecSchema,
740
+ Erc20BalanceGteSpecSchema,
362
741
  FlowInputSchema,
363
742
  FlowSchema,
364
743
  GuardCompatibilityZod,
@@ -367,23 +746,36 @@ export {
367
746
  HandleInputSchema,
368
747
  HandlePortZod,
369
748
  HandleUnitsZod,
749
+ HexStringSchema,
370
750
  InputPortZod,
371
751
  LiteralBindingSchema,
372
752
  ManifestGuardZod,
373
753
  ManifestMaterialiserZod,
374
754
  ManifestOperationZod,
375
755
  ManifestPreconditionZod,
756
+ NativeBalanceDeltaGteSpecSchema,
757
+ NativeBalanceGteSpecSchema,
376
758
  OutputPortZod,
377
759
  PROVIDER_KIND,
760
+ Phase1ArtifactSchema,
761
+ Phase1ArtifactZod,
378
762
  RESERVED_REF_SCOPES,
379
763
  RefSchema,
380
764
  ResourceInputSchema,
381
765
  ResourceOutputPortZod,
382
766
  ResourcePortZod,
383
767
  ResourceSchema,
768
+ SIMULATE_MAX_REQUIREMENTS,
769
+ SIMULATE_MAX_TRACKED_BALANCES,
384
770
  STATIC_SOL_TYPES,
385
771
  SolTypeSchema,
386
772
  StaticSolTypeZod,
773
+ TEMPO_CHAIN_ID,
774
+ TEMPO_NATIVE_ERC20,
775
+ VerificationDescriptorSchema,
776
+ VerificationDescriptorZod,
777
+ canonicalAssertedPredicate,
778
+ canonicalNativeAddress,
387
779
  copy,
388
780
  erc20,
389
781
  erc20Resource,
@@ -394,12 +786,19 @@ export {
394
786
  foldMaterialiserMetadata,
395
787
  foldRef,
396
788
  foldResource,
789
+ getChainCapabilities,
397
790
  handle,
398
791
  inputRef,
792
+ isAsErc20Chain,
399
793
  isContextKey,
794
+ isEQCheck,
400
795
  isERC20Resource,
796
+ isGTECheck,
401
797
  isHandlePort,
798
+ isLTECheck,
402
799
  isMaterialiserInput,
800
+ isMsgValueNative,
801
+ isNativeAddressForChain,
403
802
  isNativeResource,
404
803
  isRef,
405
804
  isResourceInput,
@@ -409,6 +808,8 @@ export {
409
808
  linear,
410
809
  native,
411
810
  nativeResource,
811
+ normalizeNativeTokenAddress,
812
+ normalizeResource,
412
813
  opHandle,
413
814
  outputRef,
414
815
  parseRef,
@@ -419,5 +820,6 @@ export {
419
820
  resource,
420
821
  resourceKey,
421
822
  resourceOutput,
823
+ resourceToken,
422
824
  resourcesEqual
423
825
  };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@lifi/compose-spec",
3
- "version": "0.2.0-staging.5",
3
+ "version": "0.3.0",
4
4
  "description": "Public wire-format types and schemas for Compose flows",
5
5
  "license": "Apache-2.0",
6
6
  "repository": {
@@ -23,23 +23,43 @@
23
23
  "./package.json": "./package.json"
24
24
  },
25
25
  "engines": {
26
- "node": ">=18"
26
+ "node": ">=24"
27
27
  },
28
28
  "publishConfig": {
29
29
  "access": "public"
30
30
  },
31
+ "prettier": {
32
+ "singleQuote": true
33
+ },
31
34
  "scripts": {
32
35
  "build": "yarn check:types && tsup",
33
36
  "check:types": "tsc --noEmit",
34
37
  "clean": "rm -rf dist out",
35
38
  "pack:local": "yarn build && mkdir -p out && yarn pack --out 'out/%s-%v.tgz'",
36
- "test": "vitest run --config vitest.config.ts"
39
+ "test": "vitest run --config vitest.config.ts",
40
+ "fix": "run-s fix:lint fix:prettier",
41
+ "fix:lint": "eslint src --fix",
42
+ "fix:prettier": "prettier \"src/**/*.ts\" --write",
43
+ "lint": "eslint src",
44
+ "test:lint": "eslint src",
45
+ "test:prettier": "prettier \"src/**/*.ts\" --list-different"
37
46
  },
38
47
  "dependencies": {
39
48
  "effect": "^3.21.0",
40
49
  "zod": "^4.1.11"
41
50
  },
42
51
  "devDependencies": {
52
+ "@eslint/compat": "^1.4.0",
53
+ "@lifi/eslint-plugin": "workspace:^",
54
+ "@typescript-eslint/eslint-plugin": "^8.44.1",
55
+ "@typescript-eslint/parser": "^8.44.1",
56
+ "eslint": "^9.36.0",
57
+ "eslint-config-prettier": "^9.0.0",
58
+ "eslint-plugin-eslint-comments": "^3.2.0",
59
+ "eslint-plugin-import": "^2.22.0",
60
+ "eslint-plugin-require-extensions": "^0.1.3",
61
+ "npm-run-all": "^4.1.5",
62
+ "prettier": "^3.9.4",
43
63
  "tsup": "^8.5.1",
44
64
  "typescript": "^5.9.2",
45
65
  "vitest": "^3.2.4"