@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,
  AssertedErc20BalanceGteSpecSchema: () => AssertedErc20BalanceGteSpecSchema,
  AssertedNativeBalanceGteSpecSchema: () => AssertedNativeBalanceGteSpecSchema,
  AssertedPredicateSchema: () => AssertedPredicateSchema,
  AssertedPredicateZod: () => AssertedPredicateZod,
  AssertionOwnerSchema: () => AssertionOwnerSchema,
  AssertionSpecSchema: () => AssertionSpecSchema,
  AssertionSpecZod: () => AssertionSpecZod,
  BindValueSchema: () => BindValueSchema,
  Bytes32HexSchema: () => Bytes32HexSchema,
  CONTINUATION_COMMITMENT_OP_ID: () => CONTINUATION_COMMITMENT_OP_ID,
  CallCheckSpecSchema: () => CallCheckSpecSchema,
  CallSchema: () => CallSchema,
  CheckSchema: () => CheckSchema,
  CheckZod: () => CheckZod,
  ComposeManifestZod: () => ComposeManifestZod,
  ContinuationIntentSchema: () => ContinuationIntentSchema,
  ContinuationOutcomeSchema: () => ContinuationOutcomeSchema,
  ContinuationPlanSchema: () => ContinuationPlanSchema,
  ContinuationPlanZod: () => ContinuationPlanZod,
  ContinuationSchema: () => ContinuationSchema,
  EVM_NATIVE_SENTINEL: () => EVM_NATIVE_SENTINEL,
  Erc20BalanceDeltaGteSpecSchema: () => Erc20BalanceDeltaGteSpecSchema,
  Erc20BalanceGteSpecSchema: () => Erc20BalanceGteSpecSchema,
  FlowInputSchema: () => FlowInputSchema,
  FlowSchema: () => FlowSchema,
  GuardCompatibilityZod: () => GuardCompatibilityZod,
  GuardSelectorZod: () => GuardSelectorZod,
  HANDLE_UNITS: () => HANDLE_UNITS,
  HandleInputSchema: () => HandleInputSchema,
  HandlePortZod: () => HandlePortZod,
  HandleUnitsZod: () => HandleUnitsZod,
  HexStringSchema: () => HexStringSchema,
  InputPortZod: () => InputPortZod,
  LiteralBindingSchema: () => LiteralBindingSchema,
  ManifestGuardZod: () => ManifestGuardZod,
  ManifestMaterialiserZod: () => ManifestMaterialiserZod,
  ManifestOperationZod: () => ManifestOperationZod,
  ManifestPreconditionZod: () => ManifestPreconditionZod,
  NativeBalanceDeltaGteSpecSchema: () => NativeBalanceDeltaGteSpecSchema,
  NativeBalanceGteSpecSchema: () => NativeBalanceGteSpecSchema,
  OutputPortZod: () => OutputPortZod,
  PROVIDER_KIND: () => PROVIDER_KIND,
  Phase1ArtifactSchema: () => Phase1ArtifactSchema,
  Phase1ArtifactZod: () => Phase1ArtifactZod,
  RESERVED_REF_SCOPES: () => RESERVED_REF_SCOPES,
  RefSchema: () => RefSchema,
  ResourceInputSchema: () => ResourceInputSchema,
  ResourceOutputPortZod: () => ResourceOutputPortZod,
  ResourcePortZod: () => ResourcePortZod,
  ResourceSchema: () => ResourceSchema,
  SIMULATE_MAX_REQUIREMENTS: () => SIMULATE_MAX_REQUIREMENTS,
  SIMULATE_MAX_TRACKED_BALANCES: () => SIMULATE_MAX_TRACKED_BALANCES,
  STATIC_SOL_TYPES: () => STATIC_SOL_TYPES,
  SolTypeSchema: () => SolTypeSchema,
  StaticSolTypeZod: () => StaticSolTypeZod,
  TEMPO_CHAIN_ID: () => TEMPO_CHAIN_ID,
  TEMPO_NATIVE_ERC20: () => TEMPO_NATIVE_ERC20,
  VerificationDescriptorSchema: () => VerificationDescriptorSchema,
  VerificationDescriptorZod: () => VerificationDescriptorZod,
  canonicalAssertedPredicate: () => canonicalAssertedPredicate,
  canonicalNativeAddress: () => canonicalNativeAddress,
  copy: () => copy,
  erc20: () => erc20,
  erc20Allowance: () => erc20Allowance,
  erc20Balance: () => erc20Balance,
  erc20Resource: () => erc20Resource,
  erc20Token: () => erc20Token,
  flowInputMode: () => flowInputMode,
  flowInputResource: () => flowInputResource,
  flowInputType: () => flowInputType,
  foldMaterialiserMetadata: () => foldMaterialiserMetadata,
  foldRef: () => foldRef,
  foldResource: () => foldResource,
  getChainCapabilities: () => getChainCapabilities,
  handle: () => handle,
  inputRef: () => inputRef,
  isAsErc20Chain: () => isAsErc20Chain,
  isContextKey: () => isContextKey,
  isEQCheck: () => isEQCheck,
  isERC20Resource: () => isERC20Resource,
  isErc20AllowancePrecondition: () => isErc20AllowancePrecondition,
  isFutureResourceOutput: () => isFutureResourceOutput,
  isGTECheck: () => isGTECheck,
  isHandlePort: () => isHandlePort,
  isLTECheck: () => isLTECheck,
  isMaterialiserInput: () => isMaterialiserInput,
  isMsgValueNative: () => isMsgValueNative,
  isNativeAddressForChain: () => isNativeAddressForChain,
  isNativeBalancePrecondition: () => isNativeBalancePrecondition,
  isNativeResource: () => isNativeResource,
  isRef: () => isRef,
  isResourceInput: () => isResourceInput,
  isResourceOutputPort: () => isResourceOutputPort,
  isResourcePort: () => isResourcePort,
  isStaticSolType: () => isStaticSolType,
  linear: () => linear,
  native: () => native,
  nativeBalance: () => nativeBalance,
  nativeResource: () => nativeResource,
  normalizeNativeTokenAddress: () => normalizeNativeTokenAddress,
  normalizeResource: () => normalizeResource,
  opHandle: () => opHandle,
  outputRef: () => outputRef,
  parseRef: () => parseRef,
  providerKindByName: () => providerKindByName,
  providerKindNames: () => providerKindNames,
  readResource: () => readResource,
  refKey: () => refKey,
  resource: () => resource,
  resourceKey: () => resourceKey,
  resourceOutput: () => resourceOutput,
  resourceToken: () => resourceToken,
  resourcesEqual: () => resourcesEqual
});
module.exports = __toCommonJS(index_exports);

// src/flowSchema.ts
var import_effect = require("effect");

// src/chainCapabilities.ts
var EVM_NATIVE_SENTINEL = (
  // eslint-disable-next-line @lifi/prefer-utils-constants -- compose-spec is the wire-format leaf and must not import @lifi/utils (enforced by scripts/check-compose-boundaries.mjs); the literal is intentional here
  "0x0000000000000000000000000000000000000000"
);
var isNativeSentinel = (address) => address.toLowerCase() === EVM_NATIVE_SENTINEL.toLowerCase();
var TEMPO_CHAIN_ID = 4217;
var TEMPO_NATIVE_ERC20 = {
  token: "0x20C0000000000000000000000000000000000000",
  symbol: "pathUSD",
  decimals: 6
};
var REGISTRY = /* @__PURE__ */ new Map([
  [
    TEMPO_CHAIN_ID,
    {
      kind: "as-erc20",
      chainId: TEMPO_CHAIN_ID,
      nativeErc20: TEMPO_NATIVE_ERC20
    }
  ]
]);
var getChainCapabilities = (chainId) => REGISTRY.get(chainId) ?? { kind: "evm-native", chainId };
var isAsErc20Chain = (chainId) => getChainCapabilities(chainId).kind === "as-erc20";
var canonicalNativeAddress = (chainId) => {
  const caps = getChainCapabilities(chainId);
  return caps.kind === "as-erc20" ? caps.nativeErc20.token : EVM_NATIVE_SENTINEL;
};
var isNativeAddressForChain = (chainId, address) => {
  const caps = getChainCapabilities(chainId);
  const target = caps.kind === "as-erc20" ? caps.nativeErc20.token : EVM_NATIVE_SENTINEL;
  return address.toLowerCase() === target.toLowerCase();
};
var isMsgValueNative = (chainId, address) => !isAsErc20Chain(chainId) && isNativeSentinel(address);
var normalizeResource = (r) => {
  if (r.kind !== "native") return r;
  const caps = getChainCapabilities(r.chainId);
  if (caps.kind !== "as-erc20") return r;
  return {
    kind: "erc20",
    chainId: r.chainId,
    token: caps.nativeErc20.token
  };
};
var normalizeNativeTokenAddress = (token, chainId) => isAsErc20Chain(chainId) && isNativeSentinel(token) ? canonicalNativeAddress(chainId) : token;

// src/flowSchema.ts
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 RawResourceSchema = 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 ResourceSchema = import_effect.Schema.transform(
  RawResourceSchema,
  import_effect.Schema.typeSchema(RawResourceSchema),
  {
    strict: true,
    decode: (raw) => normalizeResource(raw),
    encode: (resource2) => resource2
  }
);
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),
  continuations: import_effect.Schema.optional(import_effect.Schema.Array(ContinuationSchema))
});

// src/continuation.ts
var import_effect2 = require("effect");
var CONTINUATION_COMMITMENT_OP_ID = "continuation.commitment";
var RawContinuationOutcomeSchema = import_effect2.Schema.Struct({
  token: import_effect2.Schema.String,
  minAmount: import_effect2.Schema.String,
  destination: import_effect2.Schema.String,
  chainId: ChainIdSchema
});
var ContinuationOutcomeSchema = import_effect2.Schema.transform(
  RawContinuationOutcomeSchema,
  import_effect2.Schema.typeSchema(RawContinuationOutcomeSchema),
  {
    strict: true,
    decode: (raw) => ({
      ...raw,
      token: normalizeNativeTokenAddress(raw.token, raw.chainId)
    }),
    encode: (outcome) => outcome
  }
);
var ContinuationIntentSchema = import_effect2.Schema.Struct({
  // `NonEmptyArray` enforces ≥1 outcome at the parse boundary, so downstream needs no guard.
  outcomes: import_effect2.Schema.NonEmptyArray(ContinuationOutcomeSchema),
  continuationFlow: import_effect2.Schema.optional(FlowSchema),
  validity: import_effect2.Schema.Struct({ expiresAtMs: import_effect2.Schema.Number }),
  perpetual: import_effect2.Schema.optional(import_effect2.Schema.Boolean),
  provider: import_effect2.Schema.optional(import_effect2.Schema.String)
});
var Phase1ArtifactSchema = import_effect2.Schema.Union(
  import_effect2.Schema.Struct({
    kind: import_effect2.Schema.Literal("transaction"),
    transactionRequest: import_effect2.Schema.optional(
      import_effect2.Schema.Struct({
        to: import_effect2.Schema.String,
        data: import_effect2.Schema.String,
        value: import_effect2.Schema.String
      })
    )
  }),
  import_effect2.Schema.Struct({
    kind: import_effect2.Schema.Literal("signables"),
    typedData: import_effect2.Schema.Array(import_effect2.Schema.Unknown)
  }),
  import_effect2.Schema.Struct({ kind: import_effect2.Schema.Literal("none") })
);
var HexStringSchema = import_effect2.Schema.String.pipe(import_effect2.Schema.startsWith("0x"));
var AssertionOwnerSchema = import_effect2.Schema.Union(
  HexStringSchema,
  import_effect2.Schema.Literal("escrow", "delivery")
);
var Erc20BalanceGteSpecSchema = import_effect2.Schema.Struct({
  kind: import_effect2.Schema.Literal("erc20BalanceGte"),
  chainId: ChainIdSchema,
  token: HexStringSchema,
  owner: HexStringSchema,
  minAmount: import_effect2.Schema.String
});
var NativeBalanceGteSpecSchema = import_effect2.Schema.Struct({
  kind: import_effect2.Schema.Literal("nativeBalanceGte"),
  chainId: ChainIdSchema,
  owner: HexStringSchema,
  minAmount: import_effect2.Schema.String
});
var CallCheckSpecSchema = import_effect2.Schema.Struct({
  kind: import_effect2.Schema.Literal("call"),
  chainId: ChainIdSchema,
  to: HexStringSchema,
  calldata: HexStringSchema,
  comparator: import_effect2.Schema.Literal("gte", "eq", "lte"),
  value: import_effect2.Schema.String
});
var asErc20BalanceGteCheck = (chainId, owner, minAmount) => ({
  kind: "erc20BalanceGte",
  chainId,
  token: canonicalNativeAddress(chainId),
  owner,
  minAmount
});
var RawCheckSchema = import_effect2.Schema.Union(
  Erc20BalanceGteSpecSchema,
  NativeBalanceGteSpecSchema,
  CallCheckSpecSchema
);
var CheckSchema = import_effect2.Schema.transform(
  RawCheckSchema,
  import_effect2.Schema.typeSchema(RawCheckSchema),
  {
    strict: true,
    decode: (check) => check.kind === "nativeBalanceGte" && isAsErc20Chain(check.chainId) ? asErc20BalanceGteCheck(check.chainId, check.owner, check.minAmount) : check,
    encode: (check) => check
  }
);
var Erc20BalanceDeltaGteSpecSchema = import_effect2.Schema.Struct({
  kind: import_effect2.Schema.Literal("erc20BalanceDeltaGte"),
  chainId: ChainIdSchema,
  token: HexStringSchema,
  owner: AssertionOwnerSchema,
  minDelta: import_effect2.Schema.String
});
var NativeBalanceDeltaGteSpecSchema = import_effect2.Schema.Struct({
  kind: import_effect2.Schema.Literal("nativeBalanceDeltaGte"),
  chainId: ChainIdSchema,
  owner: AssertionOwnerSchema,
  minDelta: import_effect2.Schema.String
});
var AssertionSpecSchema = import_effect2.Schema.Union(
  Erc20BalanceGteSpecSchema,
  NativeBalanceGteSpecSchema,
  CallCheckSpecSchema,
  Erc20BalanceDeltaGteSpecSchema,
  NativeBalanceDeltaGteSpecSchema
);
var ContinuationPlanSchema = import_effect2.Schema.Struct({
  chainId: ChainIdSchema,
  nextFlow: FlowSchema,
  check: CheckSchema,
  validity: import_effect2.Schema.Struct({ expiresAtMs: import_effect2.Schema.Number }),
  correlationId: import_effect2.Schema.optional(import_effect2.Schema.String)
});
var isGTECheck = (check) => check.kind === "call" && check.comparator === "gte";
var isLTECheck = (check) => check.kind === "call" && check.comparator === "lte";
var isEQCheck = (check) => check.kind === "call" && check.comparator === "eq";

// src/descriptor.ts
var import_effect3 = require("effect");

// src/hexPatterns.ts
var BYTES32_LOWER_HEX = /^0x[0-9a-f]{64}$/;

// src/descriptor.ts
var Bytes32HexSchema = import_effect3.Schema.String.pipe(
  import_effect3.Schema.pattern(BYTES32_LOWER_HEX)
);
var AssertedErc20BalanceGteSpecSchema = import_effect3.Schema.Struct({
  kind: import_effect3.Schema.Literal("erc20BalanceGte"),
  chainId: ChainIdSchema,
  token: HexStringSchema,
  owner: AssertionOwnerSchema,
  minAmount: import_effect3.Schema.String
});
var AssertedNativeBalanceGteSpecSchema = import_effect3.Schema.Struct({
  kind: import_effect3.Schema.Literal("nativeBalanceGte"),
  chainId: ChainIdSchema,
  owner: AssertionOwnerSchema,
  minAmount: import_effect3.Schema.String
});
var RawAssertedPredicateSchema = import_effect3.Schema.Union(
  AssertedErc20BalanceGteSpecSchema,
  AssertedNativeBalanceGteSpecSchema,
  CallCheckSpecSchema,
  Erc20BalanceDeltaGteSpecSchema,
  NativeBalanceDeltaGteSpecSchema
);
var AssertedPredicateSchema = import_effect3.Schema.transform(
  RawAssertedPredicateSchema,
  import_effect3.Schema.typeSchema(RawAssertedPredicateSchema),
  {
    strict: true,
    decode: (pred) => pred.kind === "nativeBalanceGte" && isAsErc20Chain(pred.chainId) ? asErc20BalanceGteCheck(pred.chainId, pred.owner, pred.minAmount) : pred,
    encode: (pred) => pred
  }
);
var VerificationDescriptorSchema = import_effect3.Schema.Struct({
  validationProgramHash: Bytes32HexSchema,
  // The C5 echo's second hash (verified continuations, plan GD-8): `keccak256`
  // over the canonical params vector (`paramsHash`, GD-2 seam C1). Required and
  // jointly necessary with `validationProgramHash` — the program hash is
  // value-blind (it never binds the delivery address or amounts), so a descriptor
  // that enforces only it is a fund-redirect hole. Empty params still yield a
  // present `0x00…00`, so a real descriptor never omits it. Strict 32-byte
  // lowercase hex, same rule as `validationProgramHash`.
  paramsHash: Bytes32HexSchema,
  assertedPredicate: import_effect3.Schema.Array(AssertedPredicateSchema)
});
var canonicalJson = (value) => {
  if (Array.isArray(value)) {
    return `[${value.map(canonicalJson).join(",")}]`;
  }
  if (value !== null && typeof value === "object") {
    const record = value;
    const entries = Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`);
    return `{${entries.join(",")}}`;
  }
  return JSON.stringify(value);
};
var canonicalAssertedPredicate = (specs) => canonicalJson(specs);

// 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 isFutureResourceOutput = (port) => isResourceOutputPort(port) && port.availability === "future";
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 resourceToken = (r) => foldResource(r, {
  native: () => EVM_NATIVE_SENTINEL,
  erc20: (token) => token
});
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 !== void 0 && 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),
  ...optionalProp("optional", options?.optional)
});
var resourceOutput = (name, options) => {
  const raw = options;
  const opts = typeof raw === "string" ? { availability: raw } : raw;
  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/preconditions.ts
var erc20Balance = (config) => ({ type: "Erc20Balance", ...config });
var nativeBalance = (config) => ({ type: "NativeBalance", ...config });
var erc20Allowance = (config) => ({ type: "Erc20Allowance", ...config });
var isErc20AllowancePrecondition = (p) => p.type === "Erc20Allowance";
var isNativeBalancePrecondition = (p) => p.type === "NativeBalance";

// src/simulate.ts
var SIMULATE_MAX_TRACKED_BALANCES = 40;
var SIMULATE_MAX_REQUIREMENTS = 40;

// 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 chainIdZod = import_zod.default.number().int().positive();
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(),
  optional: import_zod.default.boolean().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()
});
var Phase1ArtifactZod = import_zod.default.discriminatedUnion("kind", [
  import_zod.default.object({
    kind: import_zod.default.literal("transaction"),
    transactionRequest: import_zod.default.object({
      to: import_zod.default.string(),
      data: import_zod.default.string(),
      value: import_zod.default.string()
    }).optional()
  }),
  import_zod.default.object({
    kind: import_zod.default.literal("signables"),
    typedData: import_zod.default.array(import_zod.default.unknown())
  }),
  import_zod.default.object({
    kind: import_zod.default.literal("none")
  })
]);
var hexStringZod = import_zod.default.string().startsWith("0x");
var assertionOwnerZod = import_zod.default.union([
  hexStringZod,
  import_zod.default.enum(["escrow", "delivery"])
]);
var CheckZod = import_zod.default.discriminatedUnion("kind", [
  import_zod.default.object({
    kind: import_zod.default.literal("erc20BalanceGte"),
    chainId: chainIdZod,
    token: hexStringZod,
    owner: hexStringZod,
    minAmount: import_zod.default.string()
  }),
  import_zod.default.object({
    kind: import_zod.default.literal("nativeBalanceGte"),
    chainId: chainIdZod,
    owner: hexStringZod,
    minAmount: import_zod.default.string()
  }),
  import_zod.default.object({
    kind: import_zod.default.literal("call"),
    chainId: chainIdZod,
    to: hexStringZod,
    calldata: hexStringZod,
    comparator: import_zod.default.enum(["gte", "eq", "lte"]),
    value: import_zod.default.string()
  })
]);
var AssertionSpecZod = import_zod.default.discriminatedUnion("kind", [
  ...CheckZod.options,
  import_zod.default.object({
    kind: import_zod.default.literal("erc20BalanceDeltaGte"),
    chainId: import_zod.default.number().int().positive(),
    token: hexStringZod,
    owner: assertionOwnerZod,
    minDelta: import_zod.default.string()
  }),
  import_zod.default.object({
    kind: import_zod.default.literal("nativeBalanceDeltaGte"),
    chainId: import_zod.default.number().int().positive(),
    owner: assertionOwnerZod,
    minDelta: import_zod.default.string()
  })
]);
var assertionSpecOptionByKind = (kind) => {
  const option = AssertionSpecZod.options.find(
    (o) => o.shape.kind.value === kind
  );
  if (option === void 0) {
    throw new Error(`AssertionSpecZod has no member with kind "${kind}"`);
  }
  return option;
};
var AssertedPredicateZod = import_zod.default.discriminatedUnion("kind", [
  import_zod.default.object({
    kind: import_zod.default.literal("erc20BalanceGte"),
    chainId: import_zod.default.number().int().positive(),
    token: hexStringZod,
    owner: assertionOwnerZod,
    minAmount: import_zod.default.string()
  }),
  import_zod.default.object({
    kind: import_zod.default.literal("nativeBalanceGte"),
    chainId: import_zod.default.number().int().positive(),
    owner: assertionOwnerZod,
    minAmount: import_zod.default.string()
  }),
  assertionSpecOptionByKind("call"),
  assertionSpecOptionByKind("erc20BalanceDeltaGte"),
  assertionSpecOptionByKind("nativeBalanceDeltaGte")
]);
var VerificationDescriptorZod = import_zod.default.object({
  validationProgramHash: import_zod.default.string().regex(BYTES32_LOWER_HEX),
  // The C5 echo's second hash (GD-8): the params-vector content hash
  // (`paramsHash`, C1). Required and jointly necessary with the value-blind
  // `validationProgramHash`.
  paramsHash: import_zod.default.string().regex(BYTES32_LOWER_HEX),
  assertedPredicate: import_zod.default.array(AssertedPredicateZod)
});
var ContinuationPlanZod = import_zod.default.object({
  chainId: chainIdZod,
  nextFlow: import_zod.default.unknown(),
  check: CheckZod,
  validity: import_zod.default.object({ expiresAtMs: import_zod.default.number() }),
  correlationId: import_zod.default.string().optional()
});
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  AppliedGuardSchema,
  AssertedErc20BalanceGteSpecSchema,
  AssertedNativeBalanceGteSpecSchema,
  AssertedPredicateSchema,
  AssertedPredicateZod,
  AssertionOwnerSchema,
  AssertionSpecSchema,
  AssertionSpecZod,
  BindValueSchema,
  Bytes32HexSchema,
  CONTINUATION_COMMITMENT_OP_ID,
  CallCheckSpecSchema,
  CallSchema,
  CheckSchema,
  CheckZod,
  ComposeManifestZod,
  ContinuationIntentSchema,
  ContinuationOutcomeSchema,
  ContinuationPlanSchema,
  ContinuationPlanZod,
  ContinuationSchema,
  EVM_NATIVE_SENTINEL,
  Erc20BalanceDeltaGteSpecSchema,
  Erc20BalanceGteSpecSchema,
  FlowInputSchema,
  FlowSchema,
  GuardCompatibilityZod,
  GuardSelectorZod,
  HANDLE_UNITS,
  HandleInputSchema,
  HandlePortZod,
  HandleUnitsZod,
  HexStringSchema,
  InputPortZod,
  LiteralBindingSchema,
  ManifestGuardZod,
  ManifestMaterialiserZod,
  ManifestOperationZod,
  ManifestPreconditionZod,
  NativeBalanceDeltaGteSpecSchema,
  NativeBalanceGteSpecSchema,
  OutputPortZod,
  PROVIDER_KIND,
  Phase1ArtifactSchema,
  Phase1ArtifactZod,
  RESERVED_REF_SCOPES,
  RefSchema,
  ResourceInputSchema,
  ResourceOutputPortZod,
  ResourcePortZod,
  ResourceSchema,
  SIMULATE_MAX_REQUIREMENTS,
  SIMULATE_MAX_TRACKED_BALANCES,
  STATIC_SOL_TYPES,
  SolTypeSchema,
  StaticSolTypeZod,
  TEMPO_CHAIN_ID,
  TEMPO_NATIVE_ERC20,
  VerificationDescriptorSchema,
  VerificationDescriptorZod,
  canonicalAssertedPredicate,
  canonicalNativeAddress,
  copy,
  erc20,
  erc20Allowance,
  erc20Balance,
  erc20Resource,
  erc20Token,
  flowInputMode,
  flowInputResource,
  flowInputType,
  foldMaterialiserMetadata,
  foldRef,
  foldResource,
  getChainCapabilities,
  handle,
  inputRef,
  isAsErc20Chain,
  isContextKey,
  isEQCheck,
  isERC20Resource,
  isErc20AllowancePrecondition,
  isFutureResourceOutput,
  isGTECheck,
  isHandlePort,
  isLTECheck,
  isMaterialiserInput,
  isMsgValueNative,
  isNativeAddressForChain,
  isNativeBalancePrecondition,
  isNativeResource,
  isRef,
  isResourceInput,
  isResourceOutputPort,
  isResourcePort,
  isStaticSolType,
  linear,
  native,
  nativeBalance,
  nativeResource,
  normalizeNativeTokenAddress,
  normalizeResource,
  opHandle,
  outputRef,
  parseRef,
  providerKindByName,
  providerKindNames,
  readResource,
  refKey,
  resource,
  resourceKey,
  resourceOutput,
  resourceToken,
  resourcesEqual
});