@lifi/composer-sdk 0.8.1 → 0.10.0

package/dist/responseSchemas.d.ts

@@ -1,57 +1,57 @@
-import { SimulationRevert, SimulateResult } from '@lifi/compose-spec';
-
+import { SimulateResult, SimulationRevert } from "@lifi/compose-spec";
+//#region src/responseSchemas.d.ts
 /**
  * Parses a `POST /simulate` body into a {@link SimulateResult}. Returns `null`
  * when the body does not match the `ok`/`revert`/`error` union, letting the
  * caller raise a transport-level error.
  */
-declare const parseSimulateResult: (body: unknown) => SimulateResult | null;
+export declare const parseSimulateResult: (body: unknown) => SimulateResult | null;
 /**
  * The validated members of an HTTP 206 partial compile envelope. `data` is
  * verified to be an object at runtime but left `unknown` here — compose-spec
  * owns its full shape (`ComposeCompilePartialData`) as a hand-authored type, so
  * the caller narrows it in one step. `error` is fully validated.
  */
-interface CompilePartialEnvelope {
-    readonly data: unknown;
-    readonly error: {
-        readonly kind: string;
-        readonly message: string;
-    };
+export interface CompilePartialEnvelope {
+  readonly data: unknown;
+  readonly error: {
+    readonly kind: string;
+    readonly message: string;
+  };
 }
 /** Parses an HTTP 206 partial compile envelope; `null` when it does not match. */
-declare const parseCompilePartialEnvelope: (body: unknown) => CompilePartialEnvelope | null;
+export declare const parseCompilePartialEnvelope: (body: unknown) => CompilePartialEnvelope | null;
 /**
  * A single prepared-op failure inside a `preparation_error` envelope. `kind` is
  * kept as `string` here — the narrowing to `GenericComposeErrorKind` happens in
  * `errorFromHttpResponse`, where the value is lifted onto `ComposeError`.
  */
-interface ServerFailedPreparedOp {
-    readonly callId: string;
-    readonly op: string;
-    readonly kind: string;
-    readonly message: string;
+export interface ServerFailedPreparedOp {
+  readonly callId: string;
+  readonly op: string;
+  readonly kind: string;
+  readonly message: string;
+  readonly path?: string;
+  readonly port?: string;
+  readonly fix?: string;
+}
+/** Error envelope returned on non-2xx responses. */
+export interface ServerErrorBody {
+  readonly error?: {
+    readonly kind?: string;
+    readonly message?: string;
     readonly path?: string;
     readonly port?: string;
     readonly fix?: string;
-}
-/** Error envelope returned on non-2xx responses. */
-interface ServerErrorBody {
-    readonly error?: {
-        readonly kind?: string;
-        readonly message?: string;
-        readonly path?: string;
-        readonly port?: string;
-        readonly fix?: string;
-        readonly sdkVersion?: string;
-        readonly serverVersion?: string;
-        readonly minimumSdkVersion?: string;
-        readonly details?: SimulationRevert;
-        readonly failedOps?: readonly ServerFailedPreparedOp[];
-        readonly succeededOps?: readonly string[];
-    };
+    readonly sdkVersion?: string;
+    readonly serverVersion?: string;
+    readonly minimumSdkVersion?: string;
+    readonly details?: SimulationRevert;
+    readonly failedOps?: readonly ServerFailedPreparedOp[];
+    readonly succeededOps?: readonly string[];
+  };
 }
 /** Validates an already-parsed error envelope; `null` when it does not match. */
-declare const parseServerErrorBody: (json: unknown) => ServerErrorBody | null;
-
-export { type CompilePartialEnvelope, type ServerErrorBody, type ServerFailedPreparedOp, parseCompilePartialEnvelope, parseServerErrorBody, parseSimulateResult };
+export declare const parseServerErrorBody: (json: unknown) => ServerErrorBody | null;
+//#endregion
+//# sourceMappingURL=responseSchemas.d.ts.map

package/dist/responseSchemas.js

@@ -1,90 +1,109 @@
 import z from "zod";
+//#region src/responseSchemas.ts
+/**
+* Zod-backed parsers for Compose API response bodies.
+*
+* Server responses are untrusted input crossing into the SDK, so the shapes the
+* client reads back are validated here rather than asserted with `as` casts. The
+* schemas are module-private (the package builds with `--isolatedDeclarations`,
+* which forbids exporting un-annotated complex values); the public surface is
+* the typed `parse*` helpers, whose explicit return types double as the contract.
+*
+* The simulate union is the one response the SDK fully owns and parses itself
+* (it is un-enveloped, unlike `/compose`), so it gets a complete schema kept in
+* lockstep with the canonical `SimulateResult` in `@lifi/compose-spec` by the
+* compile-time assertion below — the same anchoring `@lifi/api-schemas` uses for
+* its server-side simulate schema, so the two cannot silently drift.
+*/
 const balanceEntrySchema = z.object({
-  token: z.string(),
-  owner: z.string(),
-  amount: z.string()
+	token: z.string(),
+	owner: z.string(),
+	amount: z.string()
 });
 const simulateOkSchema = z.object({
-  status: z.literal("ok"),
-  block: z.number(),
-  timestamp: z.number(),
-  balancesBefore: z.array(balanceEntrySchema),
-  balancesAfter: z.array(balanceEntrySchema),
-  deltas: z.array(balanceEntrySchema),
-  gasUsed: z.string()
+	status: z.literal("ok"),
+	block: z.number(),
+	timestamp: z.number(),
+	balancesBefore: z.array(balanceEntrySchema),
+	balancesAfter: z.array(balanceEntrySchema),
+	deltas: z.array(balanceEntrySchema),
+	gasUsed: z.string()
 });
 const simulateRevertDecodeResultSchema = z.object({
-  errorCandidates: z.array(
-    z.object({
-      decodedErrorSignature: z.string(),
-      decodedParams: z.array(z.string())
-    })
-  ).optional(),
-  error: z.string().optional()
+	errorCandidates: z.array(z.object({
+		decodedErrorSignature: z.string(),
+		decodedParams: z.array(z.string())
+	})).optional(),
+	error: z.string().optional()
 });
 const simulateRevertSchema = z.object({
-  status: z.literal("revert"),
-  block: z.number(),
-  timestamp: z.number(),
-  revertReason: z.string().optional(),
-  code: z.number().optional(),
-  rawErrorBytes: z.string().optional(),
-  decodeResult: simulateRevertDecodeResultSchema.optional()
+	status: z.literal("revert"),
+	block: z.number(),
+	timestamp: z.number(),
+	revertReason: z.string().optional(),
+	code: z.number().optional(),
+	rawErrorBytes: z.string().optional(),
+	decodeResult: simulateRevertDecodeResultSchema.optional()
 });
 const simulateSetupErrorSchema = z.object({
-  status: z.literal("error"),
-  message: z.string()
+	status: z.literal("error"),
+	message: z.string()
 });
 const simulateResultSchema = z.discriminatedUnion("status", [
-  simulateOkSchema,
-  simulateRevertSchema,
-  simulateSetupErrorSchema
+	simulateOkSchema,
+	simulateRevertSchema,
+	simulateSetupErrorSchema
 ]);
+/**
+* Parses a `POST /simulate` body into a {@link SimulateResult}. Returns `null`
+* when the body does not match the `ok`/`revert`/`error` union, letting the
+* caller raise a transport-level error.
+*/
 const parseSimulateResult = (body) => {
-  const parsed = simulateResultSchema.safeParse(body);
-  if (!parsed.success) return null;
-  const result = parsed.data;
-  return result;
+	const parsed = simulateResultSchema.safeParse(body);
+	if (!parsed.success) return null;
+	return parsed.data;
 };
 const compilePartialEnvelopeSchema = z.object({
-  data: z.record(z.string(), z.unknown()),
-  error: z.object({ kind: z.string(), message: z.string() })
+	data: z.record(z.string(), z.unknown()),
+	error: z.object({
+		kind: z.string(),
+		message: z.string()
+	})
 });
+/** Parses an HTTP 206 partial compile envelope; `null` when it does not match. */
 const parseCompilePartialEnvelope = (body) => {
-  const parsed = compilePartialEnvelopeSchema.safeParse(body);
-  return parsed.success ? parsed.data : null;
+	const parsed = compilePartialEnvelopeSchema.safeParse(body);
+	return parsed.success ? parsed.data : null;
 };
 const failedPreparedOpSchema = z.object({
-  callId: z.string(),
-  op: z.string(),
-  kind: z.string(),
-  message: z.string(),
-  path: z.string().optional(),
-  port: z.string().optional(),
-  fix: z.string().optional()
-});
-const serverErrorBodySchema = z.object({
-  error: z.object({
-    kind: z.string().optional(),
-    message: z.string().optional(),
-    path: z.string().optional(),
-    port: z.string().optional(),
-    fix: z.string().optional(),
-    sdkVersion: z.string().optional(),
-    serverVersion: z.string().optional(),
-    minimumSdkVersion: z.string().optional(),
-    details: z.custom().optional(),
-    failedOps: z.array(failedPreparedOpSchema).readonly().optional(),
-    succeededOps: z.array(z.string()).readonly().optional()
-  }).optional()
+	callId: z.string(),
+	op: z.string(),
+	kind: z.string(),
+	message: z.string(),
+	path: z.string().optional(),
+	port: z.string().optional(),
+	fix: z.string().optional()
 });
+const serverErrorBodySchema = z.object({ error: z.object({
+	kind: z.string().optional(),
+	message: z.string().optional(),
+	path: z.string().optional(),
+	port: z.string().optional(),
+	fix: z.string().optional(),
+	sdkVersion: z.string().optional(),
+	serverVersion: z.string().optional(),
+	minimumSdkVersion: z.string().optional(),
+	details: z.custom().optional(),
+	failedOps: z.array(failedPreparedOpSchema).readonly().optional(),
+	succeededOps: z.array(z.string()).readonly().optional()
+}).optional() });
+/** Validates an already-parsed error envelope; `null` when it does not match. */
 const parseServerErrorBody = (json) => {
-  const parsed = serverErrorBodySchema.safeParse(json);
-  return parsed.success ? parsed.data : null;
-};
-export {
-  parseCompilePartialEnvelope,
-  parseServerErrorBody,
-  parseSimulateResult
+	const parsed = serverErrorBodySchema.safeParse(json);
+	return parsed.success ? parsed.data : null;
 };
+//#endregion
+export { parseCompilePartialEnvelope, parseServerErrorBody, parseSimulateResult };
+
 //# sourceMappingURL=responseSchemas.js.map

package/dist/responseSchemas.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/responseSchemas.ts"],"sourcesContent":["import type { SimulateResult, SimulationRevert } from '@lifi/compose-spec';\nimport z from 'zod';\n\n/**\n * Zod-backed parsers for Compose API response bodies.\n *\n * Server responses are untrusted input crossing into the SDK, so the shapes the\n * client reads back are validated here rather than asserted with `as` casts. The\n * schemas are module-private (the package builds with `--isolatedDeclarations`,\n * which forbids exporting un-annotated complex values); the public surface is\n * the typed `parse*` helpers, whose explicit return types double as the contract.\n *\n * The simulate union is the one response the SDK fully owns and parses itself\n * (it is un-enveloped, unlike `/compose`), so it gets a complete schema kept in\n * lockstep with the canonical `SimulateResult` in `@lifi/compose-spec` by the\n * compile-time assertion below — the same anchoring `@lifi/api-schemas` uses for\n * its server-side simulate schema, so the two cannot silently drift.\n */\n\nconst balanceEntrySchema = z.object({\n  token: z.string(),\n  owner: z.string(),\n  amount: z.string(),\n});\n\nconst simulateOkSchema = z.object({\n  status: z.literal('ok'),\n  block: z.number(),\n  timestamp: z.number(),\n  balancesBefore: z.array(balanceEntrySchema),\n  balancesAfter: z.array(balanceEntrySchema),\n  deltas: z.array(balanceEntrySchema),\n  gasUsed: z.string(),\n});\n\nconst simulateRevertDecodeResultSchema = z.object({\n  errorCandidates: z\n    .array(\n      z.object({\n        decodedErrorSignature: z.string(),\n        decodedParams: z.array(z.string()),\n      }),\n    )\n    .optional(),\n  error: z.string().optional(),\n});\n\nconst simulateRevertSchema = z.object({\n  status: z.literal('revert'),\n  block: z.number(),\n  timestamp: z.number(),\n  revertReason: z.string().optional(),\n  code: z.number().optional(),\n  rawErrorBytes: z.string().optional(),\n  decodeResult: simulateRevertDecodeResultSchema.optional(),\n});\n\nconst simulateSetupErrorSchema = z.object({\n  status: z.literal('error'),\n  message: z.string(),\n});\n\nconst simulateResultSchema = z.discriminatedUnion('status', [\n  simulateOkSchema,\n  simulateRevertSchema,\n  simulateSetupErrorSchema,\n]);\n\n// The type the schema actually parses out. Kept private (referencing it from an\n// exported declaration would break `--isolatedDeclarations`) and pinned to the\n// canonical `SimulateResult` inside `parseSimulateResult` below.\ntype SimulateResultWire = z.infer<typeof simulateResultSchema>;\n\n/**\n * Parses a `POST /simulate` body into a {@link SimulateResult}. Returns `null`\n * when the body does not match the `ok`/`revert`/`error` union, letting the\n * caller raise a transport-level error.\n */\nexport const parseSimulateResult = (body: unknown): SimulateResult | null => {\n  const parsed = simulateResultSchema.safeParse(body);\n  if (!parsed.success) return null;\n  // Pin the schema to the canonical contract in both directions, so it cannot\n  // silently drift (mirroring the conformance assertion `@lifi/api-schemas` runs\n  // on its server-side simulate schema). Assigning the inferred wire value to a\n  // `SimulateResult` checks wire→spec; `satisfies SimulateResultWire` checks\n  // spec→wire. A missing or mistyped field on either side fails to compile.\n  const result: SimulateResult = parsed.data;\n  return result satisfies SimulateResultWire;\n};\n\n/**\n * The validated members of an HTTP 206 partial compile envelope. `data` is\n * verified to be an object at runtime but left `unknown` here — compose-spec\n * owns its full shape (`ComposeCompilePartialData`) as a hand-authored type, so\n * the caller narrows it in one step. `error` is fully validated.\n */\nexport interface CompilePartialEnvelope {\n  readonly data: unknown;\n  readonly error: { readonly kind: string; readonly message: string };\n}\n\nconst compilePartialEnvelopeSchema = z.object({\n  data: z.record(z.string(), z.unknown()),\n  error: z.object({ kind: z.string(), message: z.string() }),\n});\n\n/** Parses an HTTP 206 partial compile envelope; `null` when it does not match. */\nexport const parseCompilePartialEnvelope = (\n  body: unknown,\n): CompilePartialEnvelope | null => {\n  const parsed = compilePartialEnvelopeSchema.safeParse(body);\n  return parsed.success ? parsed.data : null;\n};\n\n/**\n * A single prepared-op failure inside a `preparation_error` envelope. `kind` is\n * kept as `string` here — the narrowing to `GenericComposeErrorKind` happens in\n * `errorFromHttpResponse`, where the value is lifted onto `ComposeError`.\n */\nexport interface ServerFailedPreparedOp {\n  readonly callId: string;\n  readonly op: string;\n  readonly kind: string;\n  readonly message: string;\n  readonly path?: string;\n  readonly port?: string;\n  readonly fix?: string;\n}\n\n/** Error envelope returned on non-2xx responses. */\nexport interface ServerErrorBody {\n  readonly error?: {\n    readonly kind?: string;\n    readonly message?: string;\n    readonly path?: string;\n    readonly port?: string;\n    readonly fix?: string;\n    readonly sdkVersion?: string;\n    readonly serverVersion?: string;\n    readonly minimumSdkVersion?: string;\n    readonly details?: SimulationRevert;\n    readonly failedOps?: readonly ServerFailedPreparedOp[];\n    readonly succeededOps?: readonly string[];\n  };\n}\n\nconst failedPreparedOpSchema = z.object({\n  callId: z.string(),\n  op: z.string(),\n  kind: z.string(),\n  message: z.string(),\n  path: z.string().optional(),\n  port: z.string().optional(),\n  fix: z.string().optional(),\n});\n\n// `details` is passed through (`z.custom`) rather than parsed: the SDK does not\n// own the `SimulationRevert` schema and forwards the field verbatim onto\n// `ComposeError`.\n//\n// `failedOps`/`succeededOps` are optional here because every error kind shares\n// this envelope; they are only populated for `preparation_error` (422). Zod\n// strips undeclared keys, so omitting them would silently drop them — which is\n// also why `port` and `fix`, set on every author-caused `validation_error`,\n// have to be declared here to reach the caller.\nconst serverErrorBodySchema = z.object({\n  error: z\n    .object({\n      kind: z.string().optional(),\n      message: z.string().optional(),\n      path: z.string().optional(),\n      port: z.string().optional(),\n      fix: z.string().optional(),\n      sdkVersion: z.string().optional(),\n      serverVersion: z.string().optional(),\n      minimumSdkVersion: z.string().optional(),\n      details: z.custom<SimulationRevert>().optional(),\n      failedOps: z.array(failedPreparedOpSchema).readonly().optional(),\n      succeededOps: z.array(z.string()).readonly().optional(),\n    })\n    .optional(),\n});\n\n/** Validates an already-parsed error envelope; `null` when it does not match. */\nexport const parseServerErrorBody = (json: unknown): ServerErrorBody | null => {\n  const parsed = serverErrorBodySchema.safeParse(json);\n  return parsed.success ? parsed.data : null;\n};\n"],"mappings":"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","names":[]}
+{"version":3,"file":"responseSchemas.js","names":[],"sources":["../src/responseSchemas.ts"],"sourcesContent":["import type { SimulateResult, SimulationRevert } from '@lifi/compose-spec';\nimport z from 'zod';\n\n/**\n * Zod-backed parsers for Compose API response bodies.\n *\n * Server responses are untrusted input crossing into the SDK, so the shapes the\n * client reads back are validated here rather than asserted with `as` casts. The\n * schemas are module-private (the package builds with `--isolatedDeclarations`,\n * which forbids exporting un-annotated complex values); the public surface is\n * the typed `parse*` helpers, whose explicit return types double as the contract.\n *\n * The simulate union is the one response the SDK fully owns and parses itself\n * (it is un-enveloped, unlike `/compose`), so it gets a complete schema kept in\n * lockstep with the canonical `SimulateResult` in `@lifi/compose-spec` by the\n * compile-time assertion below — the same anchoring `@lifi/api-schemas` uses for\n * its server-side simulate schema, so the two cannot silently drift.\n */\n\nconst balanceEntrySchema = z.object({\n  token: z.string(),\n  owner: z.string(),\n  amount: z.string(),\n});\n\nconst simulateOkSchema = z.object({\n  status: z.literal('ok'),\n  block: z.number(),\n  timestamp: z.number(),\n  balancesBefore: z.array(balanceEntrySchema),\n  balancesAfter: z.array(balanceEntrySchema),\n  deltas: z.array(balanceEntrySchema),\n  gasUsed: z.string(),\n});\n\nconst simulateRevertDecodeResultSchema = z.object({\n  errorCandidates: z\n    .array(\n      z.object({\n        decodedErrorSignature: z.string(),\n        decodedParams: z.array(z.string()),\n      }),\n    )\n    .optional(),\n  error: z.string().optional(),\n});\n\nconst simulateRevertSchema = z.object({\n  status: z.literal('revert'),\n  block: z.number(),\n  timestamp: z.number(),\n  revertReason: z.string().optional(),\n  code: z.number().optional(),\n  rawErrorBytes: z.string().optional(),\n  decodeResult: simulateRevertDecodeResultSchema.optional(),\n});\n\nconst simulateSetupErrorSchema = z.object({\n  status: z.literal('error'),\n  message: z.string(),\n});\n\nconst simulateResultSchema = z.discriminatedUnion('status', [\n  simulateOkSchema,\n  simulateRevertSchema,\n  simulateSetupErrorSchema,\n]);\n\n// The type the schema actually parses out. Kept private (referencing it from an\n// exported declaration would break `--isolatedDeclarations`) and pinned to the\n// canonical `SimulateResult` inside `parseSimulateResult` below.\ntype SimulateResultWire = z.infer<typeof simulateResultSchema>;\n\n/**\n * Parses a `POST /simulate` body into a {@link SimulateResult}. Returns `null`\n * when the body does not match the `ok`/`revert`/`error` union, letting the\n * caller raise a transport-level error.\n */\nexport const parseSimulateResult = (body: unknown): SimulateResult | null => {\n  const parsed = simulateResultSchema.safeParse(body);\n  if (!parsed.success) return null;\n  // Pin the schema to the canonical contract in both directions, so it cannot\n  // silently drift (mirroring the conformance assertion `@lifi/api-schemas` runs\n  // on its server-side simulate schema). Assigning the inferred wire value to a\n  // `SimulateResult` checks wire→spec; `satisfies SimulateResultWire` checks\n  // spec→wire. A missing or mistyped field on either side fails to compile.\n  const result: SimulateResult = parsed.data;\n  return result satisfies SimulateResultWire;\n};\n\n/**\n * The validated members of an HTTP 206 partial compile envelope. `data` is\n * verified to be an object at runtime but left `unknown` here — compose-spec\n * owns its full shape (`ComposeCompilePartialData`) as a hand-authored type, so\n * the caller narrows it in one step. `error` is fully validated.\n */\nexport interface CompilePartialEnvelope {\n  readonly data: unknown;\n  readonly error: { readonly kind: string; readonly message: string };\n}\n\nconst compilePartialEnvelopeSchema = z.object({\n  data: z.record(z.string(), z.unknown()),\n  error: z.object({ kind: z.string(), message: z.string() }),\n});\n\n/** Parses an HTTP 206 partial compile envelope; `null` when it does not match. */\nexport const parseCompilePartialEnvelope = (\n  body: unknown,\n): CompilePartialEnvelope | null => {\n  const parsed = compilePartialEnvelopeSchema.safeParse(body);\n  return parsed.success ? parsed.data : null;\n};\n\n/**\n * A single prepared-op failure inside a `preparation_error` envelope. `kind` is\n * kept as `string` here — the narrowing to `GenericComposeErrorKind` happens in\n * `errorFromHttpResponse`, where the value is lifted onto `ComposeError`.\n */\nexport interface ServerFailedPreparedOp {\n  readonly callId: string;\n  readonly op: string;\n  readonly kind: string;\n  readonly message: string;\n  readonly path?: string;\n  readonly port?: string;\n  readonly fix?: string;\n}\n\n/** Error envelope returned on non-2xx responses. */\nexport interface ServerErrorBody {\n  readonly error?: {\n    readonly kind?: string;\n    readonly message?: string;\n    readonly path?: string;\n    readonly port?: string;\n    readonly fix?: string;\n    readonly sdkVersion?: string;\n    readonly serverVersion?: string;\n    readonly minimumSdkVersion?: string;\n    readonly details?: SimulationRevert;\n    readonly failedOps?: readonly ServerFailedPreparedOp[];\n    readonly succeededOps?: readonly string[];\n  };\n}\n\nconst failedPreparedOpSchema = z.object({\n  callId: z.string(),\n  op: z.string(),\n  kind: z.string(),\n  message: z.string(),\n  path: z.string().optional(),\n  port: z.string().optional(),\n  fix: z.string().optional(),\n});\n\n// `details` is passed through (`z.custom`) rather than parsed: the SDK does not\n// own the `SimulationRevert` schema and forwards the field verbatim onto\n// `ComposeError`.\n//\n// `failedOps`/`succeededOps` are optional here because every error kind shares\n// this envelope; they are only populated for `preparation_error` (422). Zod\n// strips undeclared keys, so omitting them would silently drop them — which is\n// also why `port` and `fix`, set on every author-caused `validation_error`,\n// have to be declared here to reach the caller.\nconst serverErrorBodySchema = z.object({\n  error: z\n    .object({\n      kind: z.string().optional(),\n      message: z.string().optional(),\n      path: z.string().optional(),\n      port: z.string().optional(),\n      fix: z.string().optional(),\n      sdkVersion: z.string().optional(),\n      serverVersion: z.string().optional(),\n      minimumSdkVersion: z.string().optional(),\n      details: z.custom<SimulationRevert>().optional(),\n      failedOps: z.array(failedPreparedOpSchema).readonly().optional(),\n      succeededOps: z.array(z.string()).readonly().optional(),\n    })\n    .optional(),\n});\n\n/** Validates an already-parsed error envelope; `null` when it does not match. */\nexport const parseServerErrorBody = (json: unknown): ServerErrorBody | null => {\n  const parsed = serverErrorBodySchema.safeParse(json);\n  return parsed.success ? parsed.data : null;\n};\n"],"mappings":"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"}

package/dist/routeAmount.cjs

@@ -1,38 +1,68 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all2) => {
-  for (var name in all2)
-    __defProp(target, name, { get: all2[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var routeAmount_exports = {};
-__export(routeAmount_exports, {
-  all: () => all,
-  exact: () => exact
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/routeAmount.ts
+var routeAmount_exports = /* @__PURE__ */ require("./_virtual/_rolldown/runtime.cjs").__exportAll({
+	all: () => all,
+	exact: () => exact
 });
-module.exports = __toCommonJS(routeAmount_exports);
+/**
+* Spend an exact amount of the route's `fromToken`.
+*
+* @param amount - Amount in the token's smallest unit. `bigint` is serialised
+*   to a decimal string when the request is sent.
+* @returns The `EXACT` member of the route amount union.
+*
+* @example
+* ```ts
+* const result = await sdk.route({
+*   chainId: 1,
+*   fromToken: NATIVE_ETH,
+*   toToken: WETH,
+*   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped
+*   signer: OWNER,
+* });
+* ```
+*/
 const exact = (amount) => ({
-  type: "EXACT",
-  amount
+	type: "EXACT",
+	amount
 });
+/**
+* Spend the signer's entire `fromToken` balance, resolved on-chain at execution
+* time.
+*
+* Not supported when `fromToken` is the chain's native sentinel — the server
+* rejects it. A gas coin is sent via `msg.value`, so there is no on-chain
+* balance to sweep; use {@link exact} for native inputs.
+*
+* @param simAmount - A realistic estimate of that balance, in the token's
+*   smallest unit. The server quotes and simulates against this value, so it
+*   shapes the returned quote and preconditions — but the amount actually moved
+*   is whatever the balance turns out to be.
+* @returns The `ALL` member of the route amount union.
+*
+* @example
+* ```ts
+* const result = await sdk.route({
+*   chainId: 1,
+*   fromToken: USDC,
+*   toToken: A_ETH_USDC,
+*   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand
+*   signer: OWNER,
+* });
+* ```
+*/
 const all = (simAmount) => ({
-  type: "ALL",
-  simAmount
+	type: "ALL",
+	simAmount
 });
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  all,
-  exact
+//#endregion
+exports.all = all;
+exports.exact = exact;
+Object.defineProperty(exports, "routeAmount_exports", {
+	enumerable: true,
+	get: function() {
+		return routeAmount_exports;
+	}
 });
+
 //# sourceMappingURL=routeAmount.cjs.map

package/dist/routeAmount.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/routeAmount.ts"],"sourcesContent":["import type { RouteAmountAll, RouteAmountExact } from '@lifi/compose-spec';\n\n// Constructors for the `amount` member of a `ComposeRouteRequest`. The wire\n// union is discriminated by `type` and — deliberately, because the two variants\n// mean different things — names its payload field differently in each variant:\n// `amount` is the sum actually moved, `simAmount` is only a quoting stand-in for\n// a balance resolved on-chain. These helpers keep call sites from having to\n// remember which name goes with which discriminant.\n\n/**\n * Spend an exact amount of the route's `fromToken`.\n *\n * @param amount - Amount in the token's smallest unit. `bigint` is serialised\n *   to a decimal string when the request is sent.\n * @returns The `EXACT` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: NATIVE_ETH,\n *   toToken: WETH,\n *   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped\n *   signer: OWNER,\n * });\n * ```\n */\nexport const exact = (amount: bigint | string): RouteAmountExact => ({\n  type: 'EXACT',\n  amount,\n});\n\n/**\n * Spend the signer's entire `fromToken` balance, resolved on-chain at execution\n * time.\n *\n * Not supported when `fromToken` is the chain's native sentinel — the server\n * rejects it. A gas coin is sent via `msg.value`, so there is no on-chain\n * balance to sweep; use {@link exact} for native inputs.\n *\n * @param simAmount - A realistic estimate of that balance, in the token's\n *   smallest unit. The server quotes and simulates against this value, so it\n *   shapes the returned quote and preconditions — but the amount actually moved\n *   is whatever the balance turns out to be.\n * @returns The `ALL` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: USDC,\n *   toToken: A_ETH_USDC,\n *   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand\n *   signer: OWNER,\n * });\n * ```\n */\nexport const all = (simAmount: bigint | string): RouteAmountAll => ({\n  type: 'ALL',\n  simAmount,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BO,MAAM,QAAQ,CAAC,YAA+C;AAAA,EACnE,MAAM;AAAA,EACN;AACF;AA2BO,MAAM,MAAM,CAAC,eAAgD;AAAA,EAClE,MAAM;AAAA,EACN;AACF;","names":[]}
+{"version":3,"file":"routeAmount.cjs","names":[],"sources":["../src/routeAmount.ts"],"sourcesContent":["import type { RouteAmountAll, RouteAmountExact } from '@lifi/compose-spec';\n\n// Constructors for the `amount` member of a `ComposeRouteRequest`. The wire\n// union is discriminated by `type` and — deliberately, because the two variants\n// mean different things — names its payload field differently in each variant:\n// `amount` is the sum actually moved, `simAmount` is only a quoting stand-in for\n// a balance resolved on-chain. These helpers keep call sites from having to\n// remember which name goes with which discriminant.\n\n/**\n * Spend an exact amount of the route's `fromToken`.\n *\n * @param amount - Amount in the token's smallest unit. `bigint` is serialised\n *   to a decimal string when the request is sent.\n * @returns The `EXACT` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: NATIVE_ETH,\n *   toToken: WETH,\n *   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped\n *   signer: OWNER,\n * });\n * ```\n */\nexport const exact = (amount: bigint | string): RouteAmountExact => ({\n  type: 'EXACT',\n  amount,\n});\n\n/**\n * Spend the signer's entire `fromToken` balance, resolved on-chain at execution\n * time.\n *\n * Not supported when `fromToken` is the chain's native sentinel — the server\n * rejects it. A gas coin is sent via `msg.value`, so there is no on-chain\n * balance to sweep; use {@link exact} for native inputs.\n *\n * @param simAmount - A realistic estimate of that balance, in the token's\n *   smallest unit. The server quotes and simulates against this value, so it\n *   shapes the returned quote and preconditions — but the amount actually moved\n *   is whatever the balance turns out to be.\n * @returns The `ALL` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: USDC,\n *   toToken: A_ETH_USDC,\n *   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand\n *   signer: OWNER,\n * });\n * ```\n */\nexport const all = (simAmount: bigint | string): RouteAmountAll => ({\n  type: 'ALL',\n  simAmount,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,SAAS,YAA+C;CACnE,MAAM;CACN;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,OAAO,eAAgD;CAClE,MAAM;CACN;AACF"}

package/dist/routeAmount.d.cts

@@ -1,2 +1,52 @@
-import '@lifi/compose-spec';
-export { a as all, e as exact } from './routeAmount-DdbJYJyM.cjs';
+import { RouteAmountAll, RouteAmountExact } from "@lifi/compose-spec";
+declare namespace routeAmount_d_exports {
+  export { all, exact };
+}
+/**
+ * Spend an exact amount of the route's `fromToken`.
+ *
+ * @param amount - Amount in the token's smallest unit. `bigint` is serialised
+ *   to a decimal string when the request is sent.
+ * @returns The `EXACT` member of the route amount union.
+ *
+ * @example
+ * ```ts
+ * const result = await sdk.route({
+ *   chainId: 1,
+ *   fromToken: NATIVE_ETH,
+ *   toToken: WETH,
+ *   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped
+ *   signer: OWNER,
+ * });
+ * ```
+ */
+export declare const exact: (amount: bigint | string) => RouteAmountExact;
+/**
+ * Spend the signer's entire `fromToken` balance, resolved on-chain at execution
+ * time.
+ *
+ * Not supported when `fromToken` is the chain's native sentinel — the server
+ * rejects it. A gas coin is sent via `msg.value`, so there is no on-chain
+ * balance to sweep; use {@link exact} for native inputs.
+ *
+ * @param simAmount - A realistic estimate of that balance, in the token's
+ *   smallest unit. The server quotes and simulates against this value, so it
+ *   shapes the returned quote and preconditions — but the amount actually moved
+ *   is whatever the balance turns out to be.
+ * @returns The `ALL` member of the route amount union.
+ *
+ * @example
+ * ```ts
+ * const result = await sdk.route({
+ *   chainId: 1,
+ *   fromToken: USDC,
+ *   toToken: A_ETH_USDC,
+ *   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand
+ *   signer: OWNER,
+ * });
+ * ```
+ */
+export declare const all: (simAmount: bigint | string) => RouteAmountAll;
+//#endregion
+export { routeAmount_d_exports };
+//# sourceMappingURL=routeAmount.d.cts.map

package/dist/routeAmount.d.ts

@@ -1,2 +1,52 @@
-import '@lifi/compose-spec';
-export { a as all, e as exact } from './routeAmount-DdbJYJyM.js';
+import { RouteAmountAll, RouteAmountExact } from "@lifi/compose-spec";
+declare namespace routeAmount_d_exports {
+  export { all, exact };
+}
+/**
+ * Spend an exact amount of the route's `fromToken`.
+ *
+ * @param amount - Amount in the token's smallest unit. `bigint` is serialised
+ *   to a decimal string when the request is sent.
+ * @returns The `EXACT` member of the route amount union.
+ *
+ * @example
+ * ```ts
+ * const result = await sdk.route({
+ *   chainId: 1,
+ *   fromToken: NATIVE_ETH,
+ *   toToken: WETH,
+ *   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped
+ *   signer: OWNER,
+ * });
+ * ```
+ */
+export declare const exact: (amount: bigint | string) => RouteAmountExact;
+/**
+ * Spend the signer's entire `fromToken` balance, resolved on-chain at execution
+ * time.
+ *
+ * Not supported when `fromToken` is the chain's native sentinel — the server
+ * rejects it. A gas coin is sent via `msg.value`, so there is no on-chain
+ * balance to sweep; use {@link exact} for native inputs.
+ *
+ * @param simAmount - A realistic estimate of that balance, in the token's
+ *   smallest unit. The server quotes and simulates against this value, so it
+ *   shapes the returned quote and preconditions — but the amount actually moved
+ *   is whatever the balance turns out to be.
+ * @returns The `ALL` member of the route amount union.
+ *
+ * @example
+ * ```ts
+ * const result = await sdk.route({
+ *   chainId: 1,
+ *   fromToken: USDC,
+ *   toToken: A_ETH_USDC,
+ *   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand
+ *   signer: OWNER,
+ * });
+ * ```
+ */
+export declare const all: (simAmount: bigint | string) => RouteAmountAll;
+//#endregion
+export { routeAmount_d_exports };
+//# sourceMappingURL=routeAmount.d.ts.map

package/dist/routeAmount.js

@@ -1,13 +1,61 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+//#region src/routeAmount.ts
+var routeAmount_exports = /* @__PURE__ */ __exportAll({
+	all: () => all,
+	exact: () => exact
+});
+/**
+* Spend an exact amount of the route's `fromToken`.
+*
+* @param amount - Amount in the token's smallest unit. `bigint` is serialised
+*   to a decimal string when the request is sent.
+* @returns The `EXACT` member of the route amount union.
+*
+* @example
+* ```ts
+* const result = await sdk.route({
+*   chainId: 1,
+*   fromToken: NATIVE_ETH,
+*   toToken: WETH,
+*   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped
+*   signer: OWNER,
+* });
+* ```
+*/
 const exact = (amount) => ({
-  type: "EXACT",
-  amount
+	type: "EXACT",
+	amount
 });
+/**
+* Spend the signer's entire `fromToken` balance, resolved on-chain at execution
+* time.
+*
+* Not supported when `fromToken` is the chain's native sentinel — the server
+* rejects it. A gas coin is sent via `msg.value`, so there is no on-chain
+* balance to sweep; use {@link exact} for native inputs.
+*
+* @param simAmount - A realistic estimate of that balance, in the token's
+*   smallest unit. The server quotes and simulates against this value, so it
+*   shapes the returned quote and preconditions — but the amount actually moved
+*   is whatever the balance turns out to be.
+* @returns The `ALL` member of the route amount union.
+*
+* @example
+* ```ts
+* const result = await sdk.route({
+*   chainId: 1,
+*   fromToken: USDC,
+*   toToken: A_ETH_USDC,
+*   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand
+*   signer: OWNER,
+* });
+* ```
+*/
 const all = (simAmount) => ({
-  type: "ALL",
-  simAmount
+	type: "ALL",
+	simAmount
 });
-export {
-  all,
-  exact
-};
+//#endregion
+export { all, exact, routeAmount_exports };
+
 //# sourceMappingURL=routeAmount.js.map

package/dist/routeAmount.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/routeAmount.ts"],"sourcesContent":["import type { RouteAmountAll, RouteAmountExact } from '@lifi/compose-spec';\n\n// Constructors for the `amount` member of a `ComposeRouteRequest`. The wire\n// union is discriminated by `type` and — deliberately, because the two variants\n// mean different things — names its payload field differently in each variant:\n// `amount` is the sum actually moved, `simAmount` is only a quoting stand-in for\n// a balance resolved on-chain. These helpers keep call sites from having to\n// remember which name goes with which discriminant.\n\n/**\n * Spend an exact amount of the route's `fromToken`.\n *\n * @param amount - Amount in the token's smallest unit. `bigint` is serialised\n *   to a decimal string when the request is sent.\n * @returns The `EXACT` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: NATIVE_ETH,\n *   toToken: WETH,\n *   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped\n *   signer: OWNER,\n * });\n * ```\n */\nexport const exact = (amount: bigint | string): RouteAmountExact => ({\n  type: 'EXACT',\n  amount,\n});\n\n/**\n * Spend the signer's entire `fromToken` balance, resolved on-chain at execution\n * time.\n *\n * Not supported when `fromToken` is the chain's native sentinel — the server\n * rejects it. A gas coin is sent via `msg.value`, so there is no on-chain\n * balance to sweep; use {@link exact} for native inputs.\n *\n * @param simAmount - A realistic estimate of that balance, in the token's\n *   smallest unit. The server quotes and simulates against this value, so it\n *   shapes the returned quote and preconditions — but the amount actually moved\n *   is whatever the balance turns out to be.\n * @returns The `ALL` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: USDC,\n *   toToken: A_ETH_USDC,\n *   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand\n *   signer: OWNER,\n * });\n * ```\n */\nexport const all = (simAmount: bigint | string): RouteAmountAll => ({\n  type: 'ALL',\n  simAmount,\n});\n"],"mappings":"AA2BO,MAAM,QAAQ,CAAC,YAA+C;AAAA,EACnE,MAAM;AAAA,EACN;AACF;AA2BO,MAAM,MAAM,CAAC,eAAgD;AAAA,EAClE,MAAM;AAAA,EACN;AACF;","names":[]}
+{"version":3,"file":"routeAmount.js","names":[],"sources":["../src/routeAmount.ts"],"sourcesContent":["import type { RouteAmountAll, RouteAmountExact } from '@lifi/compose-spec';\n\n// Constructors for the `amount` member of a `ComposeRouteRequest`. The wire\n// union is discriminated by `type` and — deliberately, because the two variants\n// mean different things — names its payload field differently in each variant:\n// `amount` is the sum actually moved, `simAmount` is only a quoting stand-in for\n// a balance resolved on-chain. These helpers keep call sites from having to\n// remember which name goes with which discriminant.\n\n/**\n * Spend an exact amount of the route's `fromToken`.\n *\n * @param amount - Amount in the token's smallest unit. `bigint` is serialised\n *   to a decimal string when the request is sent.\n * @returns The `EXACT` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: NATIVE_ETH,\n *   toToken: WETH,\n *   amount: routeAmount.exact(10n ** 17n), // 0.1 ETH, wrapped\n *   signer: OWNER,\n * });\n * ```\n */\nexport const exact = (amount: bigint | string): RouteAmountExact => ({\n  type: 'EXACT',\n  amount,\n});\n\n/**\n * Spend the signer's entire `fromToken` balance, resolved on-chain at execution\n * time.\n *\n * Not supported when `fromToken` is the chain's native sentinel — the server\n * rejects it. A gas coin is sent via `msg.value`, so there is no on-chain\n * balance to sweep; use {@link exact} for native inputs.\n *\n * @param simAmount - A realistic estimate of that balance, in the token's\n *   smallest unit. The server quotes and simulates against this value, so it\n *   shapes the returned quote and preconditions — but the amount actually moved\n *   is whatever the balance turns out to be.\n * @returns The `ALL` member of the route amount union.\n *\n * @example\n * ```ts\n * const result = await sdk.route({\n *   chainId: 1,\n *   fromToken: USDC,\n *   toToken: A_ETH_USDC,\n *   amount: routeAmount.all(1_000_000n), // estimate: ~1 USDC on hand\n *   signer: OWNER,\n * });\n * ```\n */\nexport const all = (simAmount: bigint | string): RouteAmountAll => ({\n  type: 'ALL',\n  simAmount,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,SAAS,YAA+C;CACnE,MAAM;CACN;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,OAAO,eAAgD;CAClE,MAAM;CACN;AACF"}