@lifi/compose-spec/dist/index.cjs

Public wire-format types and schemas for Compose flows

"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);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  AppliedGuardSchema: () => AppliedGuardSchema,
  BindValueSchema: () => BindValueSchema,
  CallSchema: () => CallSchema,
  ComposeManifestZod: () => ComposeManifestZod,
  ContinuationSchema: () => ContinuationSchema,
  FlowInputSchema: () => FlowInputSchema,
  FlowSchema: () => FlowSchema,
  GuardCompatibilityZod: () => GuardCompatibilityZod,
  GuardSelectorZod: () => GuardSelectorZod,
  HANDLE_UNITS: () => HANDLE_UNITS,
  HandleInputSchema: () => HandleInputSchema,
  HandlePortZod: () => HandlePortZod,
  HandleUnitsZod: () => HandleUnitsZod,
  InputPortZod: () => InputPortZod,
  LiteralBindingSchema: () => LiteralBindingSchema,
  ManifestGuardZod: () => ManifestGuardZod,
  ManifestMaterialiserZod: () => ManifestMaterialiserZod,
  ManifestOperationZod: () => ManifestOperationZod,
  ManifestPreconditionZod: () => ManifestPreconditionZod,
  OutputPortZod: () => OutputPortZod,
  PROVIDER_KIND: () => PROVIDER_KIND,
  RESERVED_REF_SCOPES: () => RESERVED_REF_SCOPES,
  RefSchema: () => RefSchema,
  ResourceInputSchema: () => ResourceInputSchema,
  ResourceOutputPortZod: () => ResourceOutputPortZod,
  ResourcePortZod: () => ResourcePortZod,
  ResourceSchema: () => ResourceSchema,
  STATIC_SOL_TYPES: () => STATIC_SOL_TYPES,
  SolTypeSchema: () => SolTypeSchema,
  StaticSolTypeZod: () => StaticSolTypeZod,
  copy: () => copy,
  erc20: () => erc20,
  erc20Resource: () => erc20Resource,
  erc20Token: () => erc20Token,
  flowInputMode: () => flowInputMode,
  flowInputResource: () => flowInputResource,
  flowInputType: () => flowInputType,
  foldMaterialiserMetadata: () => foldMaterialiserMetadata,
  foldRef: () => foldRef,
  foldResource: () => foldResource,
  handle: () => handle,
  inputRef: () => inputRef,
  isContextKey: () => isContextKey,
  isERC20Resource: () => isERC20Resource,
  isHandlePort: () => isHandlePort,
  isMaterialiserInput: () => isMaterialiserInput,
  isNativeResource: () => isNativeResource,
  isRef: () => isRef,
  isResourceInput: () => isResourceInput,
  isResourceOutputPort: () => isResourceOutputPort,
  isResourcePort: () => isResourcePort,
  isStaticSolType: () => isStaticSolType,
  linear: () => linear,
  native: () => native,
  nativeResource: () => nativeResource,
  opHandle: () => opHandle,
  outputRef: () => outputRef,
  parseRef: () => parseRef,
  providerKindByName: () => providerKindByName,
  providerKindNames: () => providerKindNames,
  readResource: () => readResource,
  refKey: () => refKey,
  resource: () => resource,
  resourceKey: () => resourceKey,
  resourceOutput: () => resourceOutput,
  resourcesEqual: () => resourcesEqual
});
module.exports = __toCommonJS(index_exports);

// src/flowSchema.ts
var import_effect = require("effect");
var SolTypeSchema = import_effect.Schema.Literal(
  "uint8",
  "uint16",
  "uint32",
  "uint64",
  "uint128",
  "uint256",
  "int128",
  "int256",
  "address",
  "bool",
  "bytes",
  "bytes4",
  "bytes32",
  "string"
);
var ChainIdSchema = import_effect.Schema.Number.pipe(import_effect.Schema.int(), import_effect.Schema.positive());
var ResourceSchema = import_effect.Schema.Union(
  import_effect.Schema.Struct({ kind: import_effect.Schema.Literal("native"), chainId: ChainIdSchema }),
  import_effect.Schema.Struct({
    kind: import_effect.Schema.Literal("erc20"),
    token: import_effect.Schema.String,
    chainId: ChainIdSchema
  })
);
var ResourceInputSchema = import_effect.Schema.Struct({
  name: import_effect.Schema.String,
  resource: ResourceSchema
});
var HandleInputSchema = import_effect.Schema.Struct({
  name: import_effect.Schema.String,
  type: SolTypeSchema
});
var FlowInputSchema = import_effect.Schema.Union(
  ResourceInputSchema,
  HandleInputSchema
);
var RefSchema = import_effect.Schema.Struct({
  $ref: import_effect.Schema.String.pipe(
    import_effect.Schema.filter((s) => s.indexOf(".") > 0, {
      message: () => '$ref must be a dotpath like "input.name" or "nodeId.port"'
    })
  )
});
var LiteralBindingSchema = import_effect.Schema.Struct({
  kind: SolTypeSchema,
  value: import_effect.Schema.String
});
var BindValueSchema = import_effect.Schema.Union(RefSchema, LiteralBindingSchema);
var AppliedGuardSchema = import_effect.Schema.Struct(
  { kind: import_effect.Schema.String },
  { key: import_effect.Schema.String, value: import_effect.Schema.Unknown }
);
var CallSchema = import_effect.Schema.Struct({
  id: import_effect.Schema.String,
  op: import_effect.Schema.String,
  bind: import_effect.Schema.optionalWith(
    import_effect.Schema.Record({ key: import_effect.Schema.String, value: BindValueSchema }),
    { default: () => ({}) }
  ),
  config: import_effect.Schema.optionalWith(
    import_effect.Schema.Record({ key: import_effect.Schema.String, value: import_effect.Schema.Unknown }),
    { default: () => ({}) }
  ),
  guards: import_effect.Schema.optional(import_effect.Schema.Array(AppliedGuardSchema))
});
var ContinuationSchema = import_effect.Schema.Struct({
  awaits: import_effect.Schema.String,
  flowId: import_effect.Schema.String
});
var FlowSchema = import_effect.Schema.Struct({
  version: import_effect.Schema.Literal(1),
  id: import_effect.Schema.String,
  chainId: ChainIdSchema,
  inputs: import_effect.Schema.Array(FlowInputSchema),
  nodes: import_effect.Schema.Array(CallSchema),
  continuation: import_effect.Schema.optional(ContinuationSchema)
});

// src/flow.ts
var isResourceInput = (input) => "resource" in input;
var flowInputType = (input) => isResourceInput(input) ? "uint256" : input.type;
var flowInputMode = (input) => isResourceInput(input) ? "linear" : "copy";
var flowInputResource = (input) => isResourceInput(input) ? input.resource : void 0;
var isResourcePort = (port) => port.kind === "resource";
var isHandlePort = (port) => port.kind === "handle";
var isResourceOutputPort = (port) => port.kind === "resource_output";
var isMaterialiserInput = (s) => typeof s === "object" && s !== null && "kind" in s;

// src/resource.ts
var erc20Resource = (token, chainId) => ({
  kind: "erc20",
  token,
  chainId
});
var nativeResource = (chainId) => ({
  kind: "native",
  chainId
});
var isERC20Resource = (r) => r.kind === "erc20";
var isNativeResource = (r) => r.kind === "native";
var resourcesEqual = (a, b) => {
  if (isNativeResource(a) && isNativeResource(b)) {
    return a.chainId === b.chainId;
  }
  if (isERC20Resource(a) && isERC20Resource(b)) {
    return a.chainId === b.chainId && a.token.toLowerCase() === b.token.toLowerCase();
  }
  return false;
};
var foldResource = (r, cases) => r.kind === "native" ? cases.native(r.chainId) : cases.erc20(r.token, r.chainId);
var resourceKey = (r) => foldResource(r, {
  native: (chainId) => `native:${chainId}`,
  erc20: (token, chainId) => `erc20:${token.toLowerCase()}:${chainId}`
});
var erc20Token = (r) => {
  if (r.kind !== "erc20")
    throw new Error(`Expected erc20 resource, got ${r.kind}`);
  return r.token;
};

// src/flashloan.ts
var PROVIDER_KIND = {
  AAVE_V3: 0,
  ERC3156: 1,
  BALANCER_V2: 2,
  MORPHO_BLUE: 3
};
var providerKindNames = [
  "aave-v3",
  "erc3156",
  "balancer-v2",
  "morpho-blue"
];
var providerKindByName = {
  "aave-v3": PROVIDER_KIND.AAVE_V3,
  erc3156: PROVIDER_KIND.ERC3156,
  "balancer-v2": PROVIDER_KIND.BALANCER_V2,
  "morpho-blue": PROVIDER_KIND.MORPHO_BLUE
};

// src/constructors.ts
var inputRef = (port) => ({ $ref: `input.${port}` });
var outputRef = (node, port) => ({
  $ref: `${node}.${port}`
});
var optionalProp = (key, value) => value != null ? { [key]: value } : {};
var linear = (name, type) => ({ name, type, mode: "linear", availability: "now" });
var copy = (name, type) => ({ name, type, mode: "copy", availability: "now" });
var handle = (name, type) => ({ name, type });
var native = (name, chainId) => ({ name, resource: nativeResource(chainId) });
var erc20 = (name, token, chainId) => ({ name, resource: erc20Resource(token, chainId) });
var resource = (name, accepts, options) => ({
  kind: "resource",
  name,
  accepts,
  mode: "linear",
  ...optionalProp("optional", options?.optional)
});
var readResource = (name, accepts) => ({ kind: "resource", name, accepts, mode: "copy" });
var opHandle = (name, type, options) => ({
  kind: "handle",
  name,
  type,
  mode: "copy",
  ...optionalProp("expose", options?.expose),
  ...optionalProp("units", options?.units)
});
var resourceOutput = (name, options) => {
  const opts = typeof options === "string" ? { availability: options } : options;
  return {
    kind: "resource_output",
    name,
    mode: "linear",
    ...optionalProp("availability", opts?.availability),
    ...optionalProp("providesMinimum", opts?.providesMinimum),
    ...optionalProp("omitIfZero", opts?.omitIfZero),
    ...optionalProp("deliveryAddressInput", opts?.deliveryAddressInput)
  };
};

// src/ref.ts
var isContextKey = (key) => key === "sender" || key === "executionAddress";
var RESERVED_REF_SCOPES = /* @__PURE__ */ new Set([
  "input",
  "context",
  "literal"
]);
var isRef = (v) => typeof v === "object" && v !== null && "$ref" in v && typeof v.$ref === "string";
var parseRef = (ref) => {
  const dot = ref.$ref.indexOf(".");
  if (dot === -1)
    throw new Error(`Invalid ref: "${ref.$ref}" (must contain a dot)`);
  const prefix = ref.$ref.slice(0, dot);
  const suffix = ref.$ref.slice(dot + 1);
  if (prefix === "input") return { scope: "input", port: suffix };
  if (prefix === "context") {
    if (!isContextKey(suffix))
      throw new Error(`Unknown context key: "${suffix}"`);
    return { scope: "context", key: suffix };
  }
  return { scope: "output", node: prefix, port: suffix };
};
var foldRef = (ref, cases) => {
  if (ref.scope === "input") return cases.input(ref.port);
  if (ref.scope === "context") return cases.context(ref.key);
  return cases.output(ref.node, ref.port);
};
var refKey = (ref) => foldRef(parseRef(ref), {
  input: (port) => `input:${port}`,
  context: (key) => `context:${key}`,
  output: (node, port) => `output:${node}:${port}`
});

// src/materialiserMetadata.ts
var foldMaterialiserMetadata = (meta, cases) => {
  if (meta.kind === "exact") return cases.exact(meta.amount);
  if (meta.kind === "exact-native") return cases.exactNative(meta.amount);
  return cases.runtime();
};

// src/zodSchemas.ts
var import_zod = __toESM(require("zod"), 1);
var SolTypeZod = import_zod.default.enum([
  "uint8",
  "uint16",
  "uint32",
  "uint64",
  "uint128",
  "uint256",
  "int128",
  "int256",
  "address",
  "bool",
  "bytes",
  "bytes4",
  "bytes32",
  "string"
]);
var ResourcePortZod = import_zod.default.object({
  kind: import_zod.default.literal("resource"),
  name: import_zod.default.string(),
  accepts: import_zod.default.enum(["erc20", "native", "any"]),
  mode: import_zod.default.enum(["linear", "copy"]),
  optional: import_zod.default.boolean().optional()
});
var HANDLE_UNITS = [
  "raw",
  "wad",
  "ray",
  "bps",
  "token-decimals"
];
var STATIC_SOL_TYPES = [
  "uint256",
  "uint128",
  "uint64",
  "uint32",
  "uint16",
  "uint8",
  "address",
  "bool",
  "bytes32"
];
var HandleUnitsZod = import_zod.default.enum(HANDLE_UNITS);
var StaticSolTypeZod = import_zod.default.enum(STATIC_SOL_TYPES);
var STATIC_SOL_TYPE_SET = new Set(STATIC_SOL_TYPES);
var isStaticSolType = (value) => STATIC_SOL_TYPE_SET.has(value);
var HandlePortZod = import_zod.default.object({
  kind: import_zod.default.literal("handle"),
  name: import_zod.default.string(),
  type: SolTypeZod,
  mode: import_zod.default.enum(["linear", "copy"]),
  expose: import_zod.default.boolean().optional(),
  units: HandleUnitsZod.optional()
});
var InputPortZod = import_zod.default.discriminatedUnion("kind", [
  ResourcePortZod,
  HandlePortZod
]);
var ResourceOutputPortZod = import_zod.default.object({
  kind: import_zod.default.literal("resource_output"),
  name: import_zod.default.string(),
  mode: import_zod.default.enum(["linear", "copy"]),
  availability: import_zod.default.enum(["now", "future"]).optional(),
  providesMinimum: import_zod.default.boolean().optional(),
  omitIfZero: import_zod.default.boolean().optional(),
  deliveryAddressInput: import_zod.default.string().optional()
});
var OutputPortZod = import_zod.default.discriminatedUnion("kind", [
  ResourceOutputPortZod,
  HandlePortZod
]);
var ManifestOperationZod = import_zod.default.object({
  id: import_zod.default.string(),
  description: import_zod.default.string().optional(),
  inputs: import_zod.default.array(InputPortZod),
  outputs: import_zod.default.array(OutputPortZod),
  configSchema: import_zod.default.unknown().optional()
});
var PortKindEnum = import_zod.default.enum(["resource", "resource_output", "handle"]);
var SelectorMatchZod = import_zod.default.object({
  kind: import_zod.default.union([PortKindEnum, import_zod.default.array(PortKindEnum)]),
  mode: import_zod.default.enum(["linear", "copy"]).optional(),
  type: import_zod.default.enum(["erc20", "native", "any"]).optional()
});
var ConfigSelectionZod = import_zod.default.object({
  kind: import_zod.default.literal("config"),
  configKey: import_zod.default.string(),
  cardinality: import_zod.default.enum(["one", "many"])
});
var AllMatchingSelectionZod = import_zod.default.object({
  kind: import_zod.default.literal("all_matching")
});
var SelectorSelectionZod = import_zod.default.discriminatedUnion("kind", [
  ConfigSelectionZod,
  AllMatchingSelectionZod
]);
var GuardSelectorZod = import_zod.default.object({
  binding: import_zod.default.string(),
  source: import_zod.default.enum(["inputs", "outputs"]),
  match: SelectorMatchZod,
  selection: SelectorSelectionZod
});
var GuardCompatibilityZod = import_zod.default.object({
  selectors: import_zod.default.array(GuardSelectorZod)
});
var ManifestGuardZod = import_zod.default.object({
  kind: import_zod.default.string(),
  description: import_zod.default.string().optional(),
  configSchema: import_zod.default.unknown().optional(),
  compatibility: GuardCompatibilityZod.optional()
});
var ManifestMaterialiserZod = import_zod.default.object({
  kind: import_zod.default.string(),
  description: import_zod.default.string().optional(),
  accepts: import_zod.default.enum(["resource", "handle", "any"]),
  configSchema: import_zod.default.unknown().optional()
});
var ManifestPreconditionZod = import_zod.default.object({
  type: import_zod.default.string(),
  description: import_zod.default.string().optional(),
  configSchema: import_zod.default.unknown().optional()
});
var ComposeManifestZod = import_zod.default.object({
  manifestVersion: import_zod.default.number(),
  manifestHash: import_zod.default.string(),
  flowSchema: import_zod.default.object({}).passthrough(),
  operations: import_zod.default.array(ManifestOperationZod),
  guards: import_zod.default.array(ManifestGuardZod),
  materialisers: import_zod.default.array(ManifestMaterialiserZod),
  preconditions: import_zod.default.array(ManifestPreconditionZod).optional()
});
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  AppliedGuardSchema,
  BindValueSchema,
  CallSchema,
  ComposeManifestZod,
  ContinuationSchema,
  FlowInputSchema,
  FlowSchema,
  GuardCompatibilityZod,
  GuardSelectorZod,
  HANDLE_UNITS,
  HandleInputSchema,
  HandlePortZod,
  HandleUnitsZod,
  InputPortZod,
  LiteralBindingSchema,
  ManifestGuardZod,
  ManifestMaterialiserZod,
  ManifestOperationZod,
  ManifestPreconditionZod,
  OutputPortZod,
  PROVIDER_KIND,
  RESERVED_REF_SCOPES,
  RefSchema,
  ResourceInputSchema,
  ResourceOutputPortZod,
  ResourcePortZod,
  ResourceSchema,
  STATIC_SOL_TYPES,
  SolTypeSchema,
  StaticSolTypeZod,
  copy,
  erc20,
  erc20Resource,
  erc20Token,
  flowInputMode,
  flowInputResource,
  flowInputType,
  foldMaterialiserMetadata,
  foldRef,
  foldResource,
  handle,
  inputRef,
  isContextKey,
  isERC20Resource,
  isHandlePort,
  isMaterialiserInput,
  isNativeResource,
  isRef,
  isResourceInput,
  isResourceOutputPort,
  isResourcePort,
  isStaticSolType,
  linear,
  native,
  nativeResource,
  opHandle,
  outputRef,
  parseRef,
  providerKindByName,
  providerKindNames,
  readResource,
  refKey,
  resource,
  resourceKey,
  resourceOutput,
  resourcesEqual
});