@lifi/composer-sdk 0.7.1 → 0.9.0

package/dist/resources.d.cts

@@ -1,3 +1,50 @@
-import './types.cjs';
-export { E as Erc20Resource, N as NativeResource, R as Resource, e as erc20, n as native } from './resources-BKlFxjo8.cjs';
-import '@lifi/compose-spec';
+import { Address } from "./types.cjs";
+declare namespace resources_d_exports {
+  export { Erc20Resource, NativeResource, Resource, erc20, native };
+}
+/** A resource declaration representing the chain's native token (e.g. ETH, MATIC). */
+export interface NativeResource {
+  readonly kind: "native";
+  readonly chainId: number;
+}
+/** A resource declaration representing an ERC-20 token at a specific address. */
+export interface Erc20Resource {
+  readonly kind: "erc20";
+  readonly token: Address;
+  readonly chainId: number;
+}
+/** A token resource — either the chain's native token or an ERC-20. */
+export type Resource = NativeResource | Erc20Resource;
+/**
+ * Creates a native token resource declaration.
+ *
+ * @param chainId - The EVM chain ID the native token belongs to.
+ * @returns A {@link NativeResource} for use in flow input schemas.
+ *
+ * @example
+ * ```ts
+ * const builder = sdk.flow(1, {
+ *   inputs: { eth: native(1) },
+ * });
+ * ```
+ */
+export declare const native: (chainId: number) => NativeResource;
+/**
+ * Creates an ERC-20 token resource declaration.
+ *
+ * @param token - The `0x`-prefixed contract address of the ERC-20 token.
+ * @param chainId - The EVM chain ID the token is deployed on.
+ * @returns An {@link Erc20Resource} for use in flow input schemas.
+ *
+ * @example
+ * ```ts
+ * const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+ * const builder = sdk.flow(1, {
+ *   inputs: { usdc: erc20(USDC, 1) },
+ * });
+ * ```
+ */
+export declare const erc20: (token: Address, chainId: number) => Erc20Resource;
+//#endregion
+export { resources_d_exports };
+//# sourceMappingURL=resources.d.cts.map

package/dist/resources.d.ts

@@ -1,3 +1,50 @@
-import './types.js';
-export { E as Erc20Resource, N as NativeResource, R as Resource, e as erc20, n as native } from './resources-CYis1_DS.js';
-import '@lifi/compose-spec';
+import { Address } from "./types.js";
+declare namespace resources_d_exports {
+  export { Erc20Resource, NativeResource, Resource, erc20, native };
+}
+/** A resource declaration representing the chain's native token (e.g. ETH, MATIC). */
+export interface NativeResource {
+  readonly kind: "native";
+  readonly chainId: number;
+}
+/** A resource declaration representing an ERC-20 token at a specific address. */
+export interface Erc20Resource {
+  readonly kind: "erc20";
+  readonly token: Address;
+  readonly chainId: number;
+}
+/** A token resource — either the chain's native token or an ERC-20. */
+export type Resource = NativeResource | Erc20Resource;
+/**
+ * Creates a native token resource declaration.
+ *
+ * @param chainId - The EVM chain ID the native token belongs to.
+ * @returns A {@link NativeResource} for use in flow input schemas.
+ *
+ * @example
+ * ```ts
+ * const builder = sdk.flow(1, {
+ *   inputs: { eth: native(1) },
+ * });
+ * ```
+ */
+export declare const native: (chainId: number) => NativeResource;
+/**
+ * Creates an ERC-20 token resource declaration.
+ *
+ * @param token - The `0x`-prefixed contract address of the ERC-20 token.
+ * @param chainId - The EVM chain ID the token is deployed on.
+ * @returns An {@link Erc20Resource} for use in flow input schemas.
+ *
+ * @example
+ * ```ts
+ * const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+ * const builder = sdk.flow(1, {
+ *   inputs: { usdc: erc20(USDC, 1) },
+ * });
+ * ```
+ */
+export declare const erc20: (token: Address, chainId: number) => Erc20Resource;
+//#endregion
+export { resources_d_exports };
+//# sourceMappingURL=resources.d.ts.map

package/dist/resources.js

@@ -1,14 +1,47 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+//#region src/resources.ts
+var resources_exports = /* @__PURE__ */ __exportAll({
+	erc20: () => erc20,
+	native: () => native
+});
+/**
+* Creates a native token resource declaration.
+*
+* @param chainId - The EVM chain ID the native token belongs to.
+* @returns A {@link NativeResource} for use in flow input schemas.
+*
+* @example
+* ```ts
+* const builder = sdk.flow(1, {
+*   inputs: { eth: native(1) },
+* });
+* ```
+*/
 const native = (chainId) => ({
-  kind: "native",
-  chainId
+	kind: "native",
+	chainId
 });
+/**
+* Creates an ERC-20 token resource declaration.
+*
+* @param token - The `0x`-prefixed contract address of the ERC-20 token.
+* @param chainId - The EVM chain ID the token is deployed on.
+* @returns An {@link Erc20Resource} for use in flow input schemas.
+*
+* @example
+* ```ts
+* const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+* const builder = sdk.flow(1, {
+*   inputs: { usdc: erc20(USDC, 1) },
+* });
+* ```
+*/
 const erc20 = (token, chainId) => ({
-  kind: "erc20",
-  token,
-  chainId
+	kind: "erc20",
+	token,
+	chainId
 });
-export {
-  erc20,
-  native
-};
+//#endregion
+export { erc20, native, resources_exports };
+
 //# sourceMappingURL=resources.js.map

package/dist/resources.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/resources.ts"],"sourcesContent":["import type { Address } from './types.js';\n\n// These resource types are SDK-local declarations that mirror the shape of\n// `Resource` from `@lifi/compose-spec`. They exist so the SDK can be used\n// without directly depending on `@lifi/compose-spec` at the call site.\n// The types are structurally compatible, so they are assignable to each other.\n\n/** A resource declaration representing the chain's native token (e.g. ETH, MATIC). */\nexport interface NativeResource {\n  readonly kind: 'native';\n  readonly chainId: number;\n}\n\n/** A resource declaration representing an ERC-20 token at a specific address. */\nexport interface Erc20Resource {\n  readonly kind: 'erc20';\n  readonly token: Address;\n  readonly chainId: number;\n}\n\n/** A token resource — either the chain's native token or an ERC-20. */\nexport type Resource = NativeResource | Erc20Resource;\n\n/**\n * Creates a native token resource declaration.\n *\n * @param chainId - The EVM chain ID the native token belongs to.\n * @returns A {@link NativeResource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const builder = sdk.flow(1, {\n *   inputs: { eth: native(1) },\n * });\n * ```\n */\nexport const native = (chainId: number): NativeResource => ({\n  kind: 'native',\n  chainId,\n});\n\n/**\n * Creates an ERC-20 token resource declaration.\n *\n * @param token - The `0x`-prefixed contract address of the ERC-20 token.\n * @param chainId - The EVM chain ID the token is deployed on.\n * @returns An {@link Erc20Resource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: erc20(USDC, 1) },\n * });\n * ```\n */\nexport const erc20 = (token: Address, chainId: number): Erc20Resource => ({\n  kind: 'erc20',\n  token,\n  chainId,\n});\n"],"mappings":"AAoCO,MAAM,SAAS,CAAC,aAAqC;AAAA,EAC1D,MAAM;AAAA,EACN;AACF;AAiBO,MAAM,QAAQ,CAAC,OAAgB,aAAoC;AAAA,EACxE,MAAM;AAAA,EACN;AAAA,EACA;AACF;","names":[]}
+{"version":3,"file":"resources.js","names":[],"sources":["../src/resources.ts"],"sourcesContent":["import type { Address } from './types.js';\n\n// These resource types are SDK-local declarations that mirror the shape of\n// `Resource` from `@lifi/compose-spec`. They exist so the SDK can be used\n// without directly depending on `@lifi/compose-spec` at the call site.\n// The types are structurally compatible, so they are assignable to each other.\n\n/** A resource declaration representing the chain's native token (e.g. ETH, MATIC). */\nexport interface NativeResource {\n  readonly kind: 'native';\n  readonly chainId: number;\n}\n\n/** A resource declaration representing an ERC-20 token at a specific address. */\nexport interface Erc20Resource {\n  readonly kind: 'erc20';\n  readonly token: Address;\n  readonly chainId: number;\n}\n\n/** A token resource — either the chain's native token or an ERC-20. */\nexport type Resource = NativeResource | Erc20Resource;\n\n/**\n * Creates a native token resource declaration.\n *\n * @param chainId - The EVM chain ID the native token belongs to.\n * @returns A {@link NativeResource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const builder = sdk.flow(1, {\n *   inputs: { eth: native(1) },\n * });\n * ```\n */\nexport const native = (chainId: number): NativeResource => ({\n  kind: 'native',\n  chainId,\n});\n\n/**\n * Creates an ERC-20 token resource declaration.\n *\n * @param token - The `0x`-prefixed contract address of the ERC-20 token.\n * @param chainId - The EVM chain ID the token is deployed on.\n * @returns An {@link Erc20Resource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: erc20(USDC, 1) },\n * });\n * ```\n */\nexport const erc20 = (token: Address, chainId: number): Erc20Resource => ({\n  kind: 'erc20',\n  token,\n  chainId,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoCA,MAAa,UAAU,aAAqC;CAC1D,MAAM;CACN;AACF;;;;;;;;;;;;;;;;AAiBA,MAAa,SAAS,OAAgB,aAAoC;CACxE,MAAM;CACN;CACA;AACF"}

package/dist/responseSchemas.cjs

@@ -1,126 +1,114 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var responseSchemas_exports = {};
-__export(responseSchemas_exports, {
-  parseCompilePartialEnvelope: () => parseCompilePartialEnvelope,
-  parseServerErrorBody: () => parseServerErrorBody,
-  parseSimulateResult: () => parseSimulateResult
-});
-module.exports = __toCommonJS(responseSchemas_exports);
-var import_zod = __toESM(require("zod"), 1);
-const balanceEntrySchema = import_zod.default.object({
-  token: import_zod.default.string(),
-  owner: import_zod.default.string(),
-  amount: import_zod.default.string()
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let zod = require("zod");
+zod = require_runtime.__toESM(zod, 1);
+//#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 = zod.default.object({
+	token: zod.default.string(),
+	owner: zod.default.string(),
+	amount: zod.default.string()
 });
-const simulateOkSchema = import_zod.default.object({
-  status: import_zod.default.literal("ok"),
-  block: import_zod.default.number(),
-  timestamp: import_zod.default.number(),
-  balancesBefore: import_zod.default.array(balanceEntrySchema),
-  balancesAfter: import_zod.default.array(balanceEntrySchema),
-  deltas: import_zod.default.array(balanceEntrySchema),
-  gasUsed: import_zod.default.string()
+const simulateOkSchema = zod.default.object({
+	status: zod.default.literal("ok"),
+	block: zod.default.number(),
+	timestamp: zod.default.number(),
+	balancesBefore: zod.default.array(balanceEntrySchema),
+	balancesAfter: zod.default.array(balanceEntrySchema),
+	deltas: zod.default.array(balanceEntrySchema),
+	gasUsed: zod.default.string()
 });
-const simulateRevertDecodeResultSchema = import_zod.default.object({
-  errorCandidates: import_zod.default.array(
-    import_zod.default.object({
-      decodedErrorSignature: import_zod.default.string(),
-      decodedParams: import_zod.default.array(import_zod.default.string())
-    })
-  ).optional(),
-  error: import_zod.default.string().optional()
+const simulateRevertDecodeResultSchema = zod.default.object({
+	errorCandidates: zod.default.array(zod.default.object({
+		decodedErrorSignature: zod.default.string(),
+		decodedParams: zod.default.array(zod.default.string())
+	})).optional(),
+	error: zod.default.string().optional()
 });
-const simulateRevertSchema = import_zod.default.object({
-  status: import_zod.default.literal("revert"),
-  block: import_zod.default.number(),
-  timestamp: import_zod.default.number(),
-  revertReason: import_zod.default.string().optional(),
-  code: import_zod.default.number().optional(),
-  rawErrorBytes: import_zod.default.string().optional(),
-  decodeResult: simulateRevertDecodeResultSchema.optional()
+const simulateRevertSchema = zod.default.object({
+	status: zod.default.literal("revert"),
+	block: zod.default.number(),
+	timestamp: zod.default.number(),
+	revertReason: zod.default.string().optional(),
+	code: zod.default.number().optional(),
+	rawErrorBytes: zod.default.string().optional(),
+	decodeResult: simulateRevertDecodeResultSchema.optional()
 });
-const simulateSetupErrorSchema = import_zod.default.object({
-  status: import_zod.default.literal("error"),
-  message: import_zod.default.string()
+const simulateSetupErrorSchema = zod.default.object({
+	status: zod.default.literal("error"),
+	message: zod.default.string()
 });
-const simulateResultSchema = import_zod.default.discriminatedUnion("status", [
-  simulateOkSchema,
-  simulateRevertSchema,
-  simulateSetupErrorSchema
+const simulateResultSchema = zod.default.discriminatedUnion("status", [
+	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 = import_zod.default.object({
-  data: import_zod.default.record(import_zod.default.string(), import_zod.default.unknown()),
-  error: import_zod.default.object({ kind: import_zod.default.string(), message: import_zod.default.string() })
+const compilePartialEnvelopeSchema = zod.default.object({
+	data: zod.default.record(zod.default.string(), zod.default.unknown()),
+	error: zod.default.object({
+		kind: zod.default.string(),
+		message: zod.default.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 = import_zod.default.object({
-  callId: import_zod.default.string(),
-  op: import_zod.default.string(),
-  kind: import_zod.default.string(),
-  message: import_zod.default.string(),
-  path: import_zod.default.string().optional(),
-  port: import_zod.default.string().optional(),
-  fix: import_zod.default.string().optional()
-});
-const serverErrorBodySchema = import_zod.default.object({
-  error: import_zod.default.object({
-    kind: import_zod.default.string().optional(),
-    message: import_zod.default.string().optional(),
-    path: import_zod.default.string().optional(),
-    port: import_zod.default.string().optional(),
-    fix: import_zod.default.string().optional(),
-    sdkVersion: import_zod.default.string().optional(),
-    serverVersion: import_zod.default.string().optional(),
-    minimumSdkVersion: import_zod.default.string().optional(),
-    details: import_zod.default.custom().optional(),
-    failedOps: import_zod.default.array(failedPreparedOpSchema).readonly().optional(),
-    succeededOps: import_zod.default.array(import_zod.default.string()).readonly().optional()
-  }).optional()
+const failedPreparedOpSchema = zod.default.object({
+	callId: zod.default.string(),
+	op: zod.default.string(),
+	kind: zod.default.string(),
+	message: zod.default.string(),
+	path: zod.default.string().optional(),
+	port: zod.default.string().optional(),
+	fix: zod.default.string().optional()
 });
+const serverErrorBodySchema = zod.default.object({ error: zod.default.object({
+	kind: zod.default.string().optional(),
+	message: zod.default.string().optional(),
+	path: zod.default.string().optional(),
+	port: zod.default.string().optional(),
+	fix: zod.default.string().optional(),
+	sdkVersion: zod.default.string().optional(),
+	serverVersion: zod.default.string().optional(),
+	minimumSdkVersion: zod.default.string().optional(),
+	details: zod.default.custom().optional(),
+	failedOps: zod.default.array(failedPreparedOpSchema).readonly().optional(),
+	succeededOps: zod.default.array(zod.default.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;
+	const parsed = serverErrorBodySchema.safeParse(json);
+	return parsed.success ? parsed.data : null;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  parseCompilePartialEnvelope,
-  parseServerErrorBody,
-  parseSimulateResult
-});
+//#endregion
+exports.parseCompilePartialEnvelope = parseCompilePartialEnvelope;
+exports.parseServerErrorBody = parseServerErrorBody;
+exports.parseSimulateResult = parseSimulateResult;
+
 //# sourceMappingURL=responseSchemas.cjs.map

package/dist/responseSchemas.cjs.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":["z"]}
+{"version":3,"file":"responseSchemas.cjs","names":["z"],"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/responseSchemas.d.cts

@@ -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.cts.map