@otim/utils 0.0.2-development.0

package/dist/payments/index.js

@@ -0,0 +1,1303 @@
+"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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/payments/index.ts
+var payments_exports = {};
+__export(payments_exports, {
+  DefaultCCTPConfig: () => DefaultCCTPConfig,
+  PaymentAction: () => PaymentAction,
+  SignatureValidator: () => SignatureValidator,
+  UniswapV3FeeTier: () => UniswapV3FeeTier,
+  addActionNamesToInstructions: () => addActionNamesToInstructions,
+  assertMinimumSignatures: () => assertMinimumSignatures,
+  assertSignatureCount: () => assertSignatureCount,
+  buildInvoiceMetadata: () => buildInvoiceMetadata,
+  buildPaymentMetadata: () => buildPaymentMetadata,
+  createChainTokenConfigs: () => createChainTokenConfigs,
+  createComprehensivePaymentRequest: () => createComprehensivePaymentRequest,
+  createDefaultFee: () => createDefaultFee,
+  createFeeWithToken: () => createFeeWithToken,
+  createPaymentRequestBuildPayload: () => createPaymentRequestBuildPayload,
+  createSweepActionArguments: () => createSweepActionArguments,
+  createSweepCCTPActionArguments: () => createSweepCCTPActionArguments,
+  createSweepERC20ActionArguments: () => createSweepERC20ActionArguments,
+  createSweepUniswapV3ActionArguments: () => createSweepUniswapV3ActionArguments,
+  createTokenIdentifier: () => createTokenIdentifier,
+  defaultCCTPConfig: () => defaultCCTPConfig,
+  extractActionNamesMap: () => extractActionNamesMap,
+  getRecommendedFeeTier: () => getRecommendedFeeTier,
+  instructionRegistry: () => instructionRegistry,
+  isNativeToken: () => isNativeToken,
+  resolvePreferredStablecoin: () => resolvePreferredStablecoin,
+  validatePaymentMetadata: () => validatePaymentMetadata
+});
+module.exports = __toCommonJS(payments_exports);
+
+// src/payments/types.ts
+var PaymentAction = {
+  Sweep: "sweep",
+  SweepCCTP: "sweepCCTP",
+  SweepERC20: "sweepERC20",
+  SweepUniswapV3: "sweepUniswapV3"
+};
+var UniswapV3FeeTier = {
+  Lowest: "100",
+  Low: "500",
+  Medium: "3000",
+  High: "10000"
+};
+
+// src/payments/config/cctp.ts
+var import_chains = require("viem/chains");
+var cctpSupportedChains = /* @__PURE__ */ new Set([
+  import_chains.mainnet.id,
+  import_chains.optimism.id,
+  import_chains.arbitrum.id,
+  import_chains.base.id,
+  import_chains.sepolia.id,
+  import_chains.optimismSepolia.id,
+  import_chains.arbitrumSepolia.id,
+  import_chains.baseSepolia.id
+]);
+var cctpDomainMapping = {
+  [import_chains.mainnet.id]: 0,
+  [import_chains.optimism.id]: 2,
+  [import_chains.arbitrum.id]: 3,
+  [import_chains.base.id]: 6,
+  [import_chains.sepolia.id]: 0,
+  [import_chains.optimismSepolia.id]: 2,
+  [import_chains.arbitrumSepolia.id]: 3,
+  [import_chains.baseSepolia.id]: 6
+};
+var DefaultCCTPConfig = class {
+  constructor() {
+    __publicField(this, "supportedChainIds");
+    this.supportedChainIds = cctpSupportedChains;
+  }
+  isSupported(chainId) {
+    return this.supportedChainIds.has(chainId);
+  }
+  getDomain(chainId) {
+    return cctpDomainMapping[chainId] ?? null;
+  }
+};
+var defaultCCTPConfig = new DefaultCCTPConfig();
+
+// src/helpers/blockchain.ts
+var import_viem = require("viem");
+var DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
+
+// src/helpers/date.ts
+var import_zod = __toESM(require("zod"));
+var iso8601DateSchema = import_zod.default.string().regex(
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/,
+  "Must be a valid ISO 8601 date format (e.g., 2024-12-31T23:59:59.000Z)"
+);
+var TimeUnit = {
+  Day: "day",
+  Month: "month",
+  Year: "year"
+};
+var units = {
+  [TimeUnit.Day]: {
+    one: "day",
+    other: "days"
+  },
+  [TimeUnit.Month]: {
+    one: "month",
+    other: "months"
+  },
+  [TimeUnit.Year]: {
+    one: "year",
+    other: "years"
+  }
+};
+var isDateInvalid = (date) => {
+  return date.toString() === "Invalid Date";
+};
+var isValidDate = (date) => {
+  return !isDateInvalid(date) && !isNaN(date.getTime());
+};
+
+// src/helpers/types.ts
+var isNumber = (value) => typeof value === "number";
+
+// src/chains/utils/stablecoin.ts
+var stablecoinSymbols = ["USDC", "USDT"];
+function isStablecoin(symbol) {
+  if (typeof symbol === "string") {
+    return stablecoinSymbols.includes(
+      symbol
+    );
+  }
+  return symbol.every(
+    (s) => stablecoinSymbols.includes(s)
+  );
+}
+
+// src/payments/config/tokens.ts
+function getRecommendedFeeTier(tokenIn, tokenOut) {
+  if (isStablecoin([tokenIn, tokenOut])) {
+    return UniswapV3FeeTier.Low;
+  }
+  return UniswapV3FeeTier.Medium;
+}
+
+// src/payments/build.ts
+var DEFAULT_SET_EPHEMERAL_TARGET = true;
+function createPaymentRequestBuildPayload(params) {
+  const {
+    payerAddress = null,
+    completionInstructions,
+    instructions = [],
+    metadata = {}
+  } = params;
+  return {
+    payerAddress,
+    completionInstructions: completionInstructions.map(processInstruction),
+    instructions: instructions.map(processInstruction),
+    metadata
+  };
+}
+function processInstruction(spec) {
+  return {
+    chainId: spec.chainId,
+    salt: spec.salt ?? generateRandomSalt(),
+    maxExecutions: spec.maxExecutions,
+    actionArguments: spec.actionArguments,
+    setEphemeralTarget: spec.setEphemeralTarget ?? DEFAULT_SET_EPHEMERAL_TARGET
+  };
+}
+function generateRandomSalt() {
+  return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+}
+function createDefaultFee(executionFee = 0, maxBaseFeePerGas = "0x0", maxPriorityFeePerGas = "0x0", token = DEFAULT_ADDRESS) {
+  return {
+    token,
+    executionFee,
+    maxBaseFeePerGas,
+    maxPriorityFeePerGas
+  };
+}
+function createFeeWithToken(token, maxPriorityFeePerGas) {
+  return createDefaultFee(0, "0x0", maxPriorityFeePerGas ?? "0x0", token);
+}
+
+// src/payments/comprehensive-payment-request.ts
+var import_viem3 = require("viem");
+
+// src/payments/actions/sweep-cctp.ts
+var import_viem2 = require("viem");
+function createSweepCCTPActionArguments(payload) {
+  const cctpConfig = payload.cctpConfig ?? defaultCCTPConfig;
+  const destinationDomain = resolveCCTPDomain(
+    payload.destinationChainId,
+    cctpConfig
+  );
+  return {
+    [PaymentAction.SweepCCTP]: {
+      token: payload.token,
+      destinationDomain,
+      /* CCTP requires the recipient address to be padded to 32 bytes */
+      destinationMintRecipient: (0, import_viem2.pad)(payload.destinationMintRecipient, {
+        size: 32
+      }),
+      threshold: payload.threshold,
+      endBalance: payload.endBalance,
+      fee: payload.fee
+    }
+  };
+}
+function resolveCCTPDomain(destinationChainId, cctpConfig) {
+  const domain = cctpConfig.getDomain(destinationChainId);
+  if (domain === null) {
+    throw new Error(`Chain ${destinationChainId} does not support CCTP`);
+  }
+  return domain;
+}
+
+// src/payments/actions/sweep-erc20.ts
+function createSweepERC20ActionArguments(payload) {
+  return {
+    [PaymentAction.SweepERC20]: {
+      token: payload.token,
+      target: payload.target,
+      threshold: payload.threshold,
+      endBalance: payload.endBalance,
+      fee: payload.fee
+    }
+  };
+}
+
+// src/payments/actions/sweep-uniswap-v3.ts
+function createSweepUniswapV3ActionArguments(payload) {
+  return {
+    [PaymentAction.SweepUniswapV3]: {
+      recipient: payload.recipient,
+      tokenIn: payload.tokenIn,
+      tokenOut: payload.tokenOut,
+      feeTier: payload.feeTier,
+      threshold: payload.threshold,
+      endBalance: payload.endBalance,
+      floorAmountOut: payload.floorAmountOut,
+      meanPriceLookBack: payload.meanPriceLookBack,
+      maxPriceDeviationBps: payload.maxPriceDeviationBps,
+      fee: payload.fee
+    }
+  };
+}
+
+// src/payments/comprehensive-payment-request.ts
+var USDC_SYMBOL = "USDC";
+var USDT_SYMBOL = "USDT";
+var MINIMUM_THRESHOLD = 1n;
+var UNISWAP_MEAN_PRICE_LOOKBACK = 600;
+var ZERO_BALANCE = 0n;
+var USDT_MAX_PRICE_DEVIATION_BPS = 200;
+var DEFAULT_MAX_PRICE_DEVIATION_BPS = 500;
+var STABLE_SLIPPAGE_BPS = 1;
+var NON_STABLE_SLIPPAGE_BPS = 50;
+function createComprehensivePaymentRequest(params) {
+  const {
+    settlementChainId,
+    recipient,
+    amount,
+    ephemeralWalletAddress,
+    chainTokenConfigs,
+    payerAddress,
+    metadata,
+    feeToken,
+    cctpConfig = defaultCCTPConfig
+  } = params;
+  validateSettlementChainSupport(settlementChainId, cctpConfig);
+  const settlementConfig = findChainConfig(
+    settlementChainId,
+    chainTokenConfigs
+  );
+  const settlementUSDC = findSettlementUSDC(settlementConfig);
+  const threshold = calculateThreshold(amount, settlementUSDC.decimals);
+  const instructionFee = createFeeWithToken(feeToken);
+  const completionInstructions = createCompletionInstructions(
+    settlementChainId,
+    settlementUSDC.address,
+    recipient,
+    threshold,
+    instructionFee,
+    chainTokenConfigs
+  );
+  const instructions = createCrossChainInstructions(
+    chainTokenConfigs,
+    settlementChainId,
+    ephemeralWalletAddress,
+    instructionFee,
+    cctpConfig
+  );
+  return createPaymentRequestBuildPayload({
+    payerAddress,
+    completionInstructions,
+    instructions,
+    metadata
+  });
+}
+function validateSettlementChainSupport(chainId, cctpConfig) {
+  if (!cctpConfig.isSupported(chainId)) {
+    throw new Error(`Settlement chain ${chainId} does not support CCTP`);
+  }
+}
+function findChainConfig(chainId, configs) {
+  const config = configs.find((c) => c.chainId === chainId);
+  if (!config) {
+    throw new Error(
+      `Settlement chain ${chainId} not found in chain token configs`
+    );
+  }
+  return config;
+}
+function findSettlementUSDC(settlementConfig) {
+  const usdc = settlementConfig.tokens.find(
+    (token) => token.symbol.toUpperCase() === USDC_SYMBOL
+  );
+  if (!usdc) {
+    throw new Error(
+      `Settlement chain ${settlementConfig.chainId} does not have USDC configured`
+    );
+  }
+  return {
+    address: usdc.address,
+    decimals: usdc.decimals
+  };
+}
+function calculateThreshold(amount, decimals) {
+  return (0, import_viem3.toHex)((0, import_viem3.parseUnits)(amount, decimals));
+}
+function createCompletionInstructions(settlementChainId, settlementUSDCAddress, recipient, threshold, instructionFee, chainTokenConfigs) {
+  const instructions = [];
+  instructions.push(
+    createSettlementSweepInstruction(
+      settlementChainId,
+      settlementUSDCAddress,
+      recipient,
+      threshold,
+      instructionFee
+    )
+  );
+  const swapInstructions = createTokenSwapInstructions(
+    settlementChainId,
+    chainTokenConfigs,
+    recipient,
+    threshold,
+    instructionFee
+  );
+  instructions.push(...swapInstructions);
+  return instructions;
+}
+function createSettlementSweepInstruction(chainId, tokenAddress, recipient, threshold, fee) {
+  return {
+    chainId,
+    maxExecutions: 1,
+    actionArguments: createSweepERC20ActionArguments({
+      chainId,
+      maxExecutions: 1,
+      token: tokenAddress,
+      target: recipient,
+      threshold,
+      endBalance: (0, import_viem3.toHex)(ZERO_BALANCE),
+      fee
+    }),
+    setEphemeralTarget: false
+  };
+}
+function createTokenSwapInstructions(settlementChainId, chainTokenConfigs, settlementRecipient, threshold, instructionFee) {
+  const swapInstructions = [];
+  const settlementConfig = chainTokenConfigs.find(
+    (c) => c.chainId === settlementChainId
+  );
+  if (!settlementConfig) {
+    return swapInstructions;
+  }
+  const settlementUSDC = settlementConfig.tokens.find(
+    (t) => t.symbol.toUpperCase() === USDC_SYMBOL
+  );
+  if (!settlementUSDC) {
+    return swapInstructions;
+  }
+  for (const sourceToken of settlementConfig.tokens) {
+    if (sourceToken.symbol.toUpperCase() === USDC_SYMBOL) {
+      continue;
+    }
+    const swapInstruction = createSwapInstruction(
+      settlementChainId,
+      sourceToken,
+      settlementUSDC,
+      settlementRecipient,
+      threshold,
+      instructionFee
+    );
+    swapInstructions.push(swapInstruction);
+  }
+  return swapInstructions;
+}
+function createSwapInstruction(chainId, tokenIn, tokenOut, settlementRecipient, threshold, fee) {
+  const { instruction } = createSwapInstructionWithFloor(
+    chainId,
+    tokenIn,
+    tokenOut,
+    settlementRecipient,
+    threshold,
+    fee,
+    false
+  );
+  return instruction;
+}
+function createSwapInstructionWithFloor(chainId, tokenIn, tokenOut, recipient, threshold, fee, setEphemeralTarget) {
+  const feeTier = getRecommendedFeeTier(
+    tokenIn.symbol.toUpperCase(),
+    USDC_SYMBOL
+  );
+  const isStableToStableSwap = isStablecoin([
+    tokenIn.symbol.toUpperCase(),
+    tokenOut.symbol.toUpperCase()
+  ]);
+  const slippageBps = isStableToStableSwap ? STABLE_SLIPPAGE_BPS : NON_STABLE_SLIPPAGE_BPS;
+  const maxPriceDeviationBps = tokenIn.symbol.toUpperCase() === USDT_SYMBOL ? USDT_MAX_PRICE_DEVIATION_BPS : DEFAULT_MAX_PRICE_DEVIATION_BPS;
+  const baseAmount = BigInt(threshold);
+  const afterFeeAmount = baseAmount * BigInt(1e6 - Number(feeTier)) / 1000000n;
+  const floorAmountOut = afterFeeAmount * BigInt(1e4 - slippageBps) / 10000n;
+  const instruction = {
+    chainId,
+    maxExecutions: 1,
+    actionArguments: createSweepUniswapV3ActionArguments({
+      chainId,
+      maxExecutions: 1,
+      recipient,
+      tokenIn: tokenIn.address,
+      tokenOut: tokenOut.address,
+      feeTier,
+      threshold,
+      endBalance: (0, import_viem3.toHex)(ZERO_BALANCE),
+      floorAmountOut: (0, import_viem3.toHex)(floorAmountOut),
+      meanPriceLookBack: UNISWAP_MEAN_PRICE_LOOKBACK,
+      maxPriceDeviationBps,
+      fee
+    }),
+    setEphemeralTarget
+  };
+  return { instruction, floorAmountOut };
+}
+function createCrossChainSwapInstructions(chainConfig, chainUSDC, ephemeralWalletAddress, instructionFee) {
+  const swapInstructions = [];
+  for (const sourceToken of chainConfig.tokens) {
+    if (sourceToken.symbol.toUpperCase() === USDC_SYMBOL) {
+      continue;
+    }
+    const feeTier = getRecommendedFeeTier(
+      sourceToken.symbol.toUpperCase(),
+      USDC_SYMBOL
+    );
+    const maxPriceDeviationBps = sourceToken.symbol.toUpperCase() === USDT_SYMBOL ? USDT_MAX_PRICE_DEVIATION_BPS : DEFAULT_MAX_PRICE_DEVIATION_BPS;
+    const instruction = {
+      chainId: chainConfig.chainId,
+      maxExecutions: 1,
+      actionArguments: createSweepUniswapV3ActionArguments({
+        chainId: chainConfig.chainId,
+        maxExecutions: 1,
+        recipient: ephemeralWalletAddress,
+        tokenIn: sourceToken.address,
+        tokenOut: chainUSDC.address,
+        feeTier,
+        threshold: (0, import_viem3.toHex)(MINIMUM_THRESHOLD),
+        endBalance: (0, import_viem3.toHex)(ZERO_BALANCE),
+        floorAmountOut: (0, import_viem3.toHex)(0n),
+        meanPriceLookBack: UNISWAP_MEAN_PRICE_LOOKBACK,
+        maxPriceDeviationBps,
+        fee: instructionFee
+      }),
+      setEphemeralTarget: true
+    };
+    swapInstructions.push(instruction);
+  }
+  return swapInstructions;
+}
+function createCrossChainInstructions(chainTokenConfigs, settlementChainId, ephemeralWalletAddress, instructionFee, cctpConfig) {
+  const instructions = [];
+  for (const chainConfig of chainTokenConfigs) {
+    if (chainConfig.chainId === settlementChainId) {
+      continue;
+    }
+    const chainUSDC = chainConfig.tokens.find(
+      (token) => token.symbol.toUpperCase() === USDC_SYMBOL
+    );
+    if (!chainUSDC || !cctpConfig.isSupported(chainConfig.chainId)) {
+      continue;
+    }
+    const swapInstructions = createCrossChainSwapInstructions(
+      chainConfig,
+      chainUSDC,
+      ephemeralWalletAddress,
+      instructionFee
+    );
+    instructions.push(...swapInstructions);
+    const bridgeInstruction = createCCTPBridgeInstruction(
+      chainConfig.chainId,
+      chainUSDC.address,
+      settlementChainId,
+      ephemeralWalletAddress,
+      (0, import_viem3.toHex)(MINIMUM_THRESHOLD),
+      instructionFee,
+      cctpConfig
+    );
+    instructions.push(bridgeInstruction);
+  }
+  return instructions;
+}
+function createCCTPBridgeInstruction(sourceChainId, tokenAddress, destinationChainId, ephemeralWalletAddress, threshold, fee, cctpConfig) {
+  return {
+    chainId: sourceChainId,
+    maxExecutions: 1,
+    actionArguments: createSweepCCTPActionArguments({
+      chainId: sourceChainId,
+      maxExecutions: 1,
+      token: tokenAddress,
+      destinationChainId,
+      destinationMintRecipient: ephemeralWalletAddress,
+      threshold,
+      endBalance: (0, import_viem3.toHex)(ZERO_BALANCE),
+      fee,
+      cctpConfig
+    }),
+    setEphemeralTarget: true
+  };
+}
+
+// src/payments/actions/sweep.ts
+var import_viem4 = require("viem");
+function createSweepActionArguments(payload) {
+  return {
+    [PaymentAction.Sweep]: {
+      target: payload.target,
+      threshold: payload.threshold,
+      endBalance: payload.endBalance,
+      gasLimit: (0, import_viem4.toHex)(payload.gasLimit),
+      fee: payload.fee
+    }
+  };
+}
+
+// src/instructions/contracts/schemas/eip-712/actions/deactivate-instruction.json
+var deactivate_instruction_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "deactivateInstruction", type: "DeactivateInstruction" }
+    ],
+    DeactivateInstruction: [
+      { name: "instructionId", type: "bytes32" },
+      { name: "fee", type: "Fee" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/refuel-erc20.json
+var refuel_erc20_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "refuelERC20", type: "RefuelERC20" }
+    ],
+    RefuelERC20: [
+      { name: "token", type: "address" },
+      { name: "target", type: "address" },
+      { name: "threshold", type: "uint256" },
+      { name: "endBalance", type: "uint256" },
+      { name: "fee", type: "Fee" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/refuel.json
+var refuel_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "refuel", type: "Refuel" }
+    ],
+    Refuel: [
+      { name: "target", type: "address" },
+      { name: "threshold", type: "uint256" },
+      { name: "endBalance", type: "uint256" },
+      { name: "gasLimit", type: "uint256" },
+      { name: "fee", type: "Fee" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/sweep-cctp.json
+var sweep_cctp_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "sweepCCTP", type: "SweepCCTP" }
+    ],
+    SweepCCTP: [
+      { name: "token", type: "address" },
+      { name: "destinationDomain", type: "uint32" },
+      { name: "destinationMintRecipient", type: "bytes32" },
+      { name: "threshold", type: "uint256" },
+      { name: "endBalance", type: "uint256" },
+      { name: "fee", type: "Fee" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/sweep-deposit-account-erc20.json
+var sweep_deposit_account_erc20_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "sweepDepositAccountERC20", type: "SweepDepositAccountERC20" }
+    ],
+    SweepDepositAccountERC20: [
+      { name: "token", type: "address" },
+      { name: "depositor", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "threshold", type: "uint256" },
+      { name: "fee", type: "Fee" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/sweep-deposit-account.json
+var sweep_deposit_account_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "sweepDepositAccount", type: "SweepDepositAccount" }
+    ],
+    SweepDepositAccount: [
+      { name: "depositor", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "threshold", type: "uint256" },
+      { name: "fee", type: "Fee" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/sweep-erc20.json
+var sweep_erc20_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "sweepERC20", type: "SweepERC20" }
+    ],
+    SweepERC20: [
+      { name: "token", type: "address" },
+      { name: "target", type: "address" },
+      { name: "threshold", type: "uint256" },
+      { name: "endBalance", type: "uint256" },
+      { name: "fee", type: "Fee" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/sweep-skip-cctp-deposit-account.json
+var sweep_skip_cctp_deposit_account_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      {
+        name: "sweepSkipCCTPDepositAccount",
+        type: "SweepSkipCCTPDepositAccount"
+      }
+    ],
+    SweepSkipCCTPDepositAccount: [
+      { name: "depositor", type: "address" },
+      { name: "destinationDomain", type: "uint32" },
+      { name: "destinationMintRecipient", type: "bytes32" },
+      { name: "threshold", type: "uint256" },
+      { name: "fee", type: "Fee" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/sweep-uniswap-v3.json
+var sweep_uniswap_v3_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "sweepUniswapV3", type: "SweepUniswapV3" }
+    ],
+    SweepUniswapV3: [
+      { name: "recipient", type: "address" },
+      { name: "tokenIn", type: "address" },
+      { name: "tokenOut", type: "address" },
+      { name: "feeTier", type: "uint24" },
+      { name: "threshold", type: "uint256" },
+      { name: "endBalance", type: "uint256" },
+      { name: "floorAmountOut", type: "uint256" },
+      { name: "meanPriceLookBack", type: "uint32" },
+      { name: "maxPriceDeviationBPS", type: "uint32" },
+      { name: "fee", type: "Fee" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/sweep.json
+var sweep_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "sweep", type: "Sweep" }
+    ],
+    Sweep: [
+      { name: "target", type: "address" },
+      { name: "threshold", type: "uint256" },
+      { name: "endBalance", type: "uint256" },
+      { name: "gasLimit", type: "uint256" },
+      { name: "fee", type: "Fee" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/transfer-erc20.json
+var transfer_erc20_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "transferERC20", type: "TransferERC20" }
+    ],
+    TransferERC20: [
+      { name: "token", type: "address" },
+      { name: "target", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "schedule", type: "Schedule" },
+      { name: "fee", type: "Fee" }
+    ],
+    Schedule: [
+      { name: "startAt", type: "uint256" },
+      { name: "startBy", type: "uint256" },
+      { name: "interval", type: "uint256" },
+      { name: "timeout", type: "uint256" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/transfer.json
+var transfer_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "transfer", type: "Transfer" }
+    ],
+    Transfer: [
+      { name: "target", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "gasLimit", type: "uint256" },
+      { name: "schedule", type: "Schedule" },
+      { name: "fee", type: "Fee" }
+    ],
+    Schedule: [
+      { name: "startAt", type: "uint256" },
+      { name: "startBy", type: "uint256" },
+      { name: "interval", type: "uint256" },
+      { name: "timeout", type: "uint256" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/contracts/schemas/eip-712/actions/uniswap-v3-exact-input.json
+var uniswap_v3_exact_input_default = {
+  types: {
+    Instruction: [
+      { name: "salt", type: "uint256" },
+      { name: "maxExecutions", type: "uint256" },
+      { name: "action", type: "address" },
+      { name: "uniswapV3ExactInput", type: "UniswapV3ExactInput" }
+    ],
+    UniswapV3ExactInput: [
+      { name: "recipient", type: "address" },
+      { name: "tokenIn", type: "address" },
+      { name: "tokenOut", type: "address" },
+      { name: "feeTier", type: "uint24" },
+      { name: "amountIn", type: "uint256" },
+      { name: "floorAmountOut", type: "uint256" },
+      { name: "meanPriceLookBack", type: "uint32" },
+      { name: "maxPriceDeviationBPS", type: "uint32" },
+      { name: "schedule", type: "Schedule" },
+      { name: "fee", type: "Fee" }
+    ],
+    Schedule: [
+      { name: "startAt", type: "uint256" },
+      { name: "startBy", type: "uint256" },
+      { name: "interval", type: "uint256" },
+      { name: "timeout", type: "uint256" }
+    ],
+    Fee: [
+      { name: "token", type: "address" },
+      { name: "maxBaseFeePerGas", type: "uint256" },
+      { name: "maxPriorityFeePerGas", type: "uint256" },
+      { name: "executionFee", type: "uint256" }
+    ]
+  }
+};
+
+// src/instructions/types.ts
+var eip712TypesMap = {
+  refuel: refuel_default,
+  refuelERC20: refuel_erc20_default,
+  transfer: transfer_default,
+  transferERC20: transfer_erc20_default,
+  uniswapV3ExactInput: uniswap_v3_exact_input_default,
+  sweep: sweep_default,
+  sweepERC20: sweep_erc20_default,
+  sweepCCTP: sweep_cctp_default,
+  sweepUniswapV3: sweep_uniswap_v3_default,
+  sweepDepositAccount: sweep_deposit_account_default,
+  sweepDepositAccountERC20: sweep_deposit_account_erc20_default,
+  sweepSkipCCTPDepositAccount: sweep_skip_cctp_deposit_account_default,
+  deactivateInstruction: deactivate_instruction_default
+};
+
+// src/payments/instruction-registry.ts
+var feeAbiComponent = {
+  name: "fee",
+  type: "tuple",
+  components: [
+    { name: "token", type: "address" },
+    { name: "maxBaseFeePerGas", type: "uint256" },
+    { name: "maxPriorityFeePerGas", type: "uint256" },
+    { name: "executionFee", type: "uint256" }
+  ]
+};
+var sweepAbi = [
+  {
+    type: "tuple",
+    components: [
+      { name: "target", type: "address" },
+      { name: "threshold", type: "uint256" },
+      { name: "endBalance", type: "uint256" },
+      { name: "gasLimit", type: "uint256" },
+      feeAbiComponent
+    ]
+  }
+];
+var sweepERC20Abi = [
+  {
+    type: "tuple",
+    components: [
+      { name: "token", type: "address" },
+      { name: "target", type: "address" },
+      { name: "threshold", type: "uint256" },
+      { name: "endBalance", type: "uint256" },
+      feeAbiComponent
+    ]
+  }
+];
+var sweepCCTPAbi = [
+  {
+    type: "tuple",
+    components: [
+      { name: "token", type: "address" },
+      { name: "destinationDomain", type: "uint32" },
+      { name: "destinationMintRecipient", type: "bytes32" },
+      { name: "threshold", type: "uint256" },
+      { name: "endBalance", type: "uint256" },
+      feeAbiComponent
+    ]
+  }
+];
+var sweepUniswapV3Abi = [
+  {
+    type: "tuple",
+    components: [
+      { name: "recipient", type: "address" },
+      { name: "tokenIn", type: "address" },
+      { name: "tokenOut", type: "address" },
+      { name: "feeTier", type: "uint24" },
+      { name: "threshold", type: "uint256" },
+      { name: "endBalance", type: "uint256" },
+      { name: "floorAmountOut", type: "uint256" },
+      { name: "meanPriceLookBack", type: "uint32" },
+      { name: "maxPriceDeviationBPS", type: "uint32" },
+      feeAbiComponent
+    ]
+  }
+];
+var sweepDepositAccountAbi = [
+  {
+    type: "tuple",
+    components: [
+      { name: "depositor", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "threshold", type: "uint256" },
+      feeAbiComponent
+    ]
+  }
+];
+var sweepDepositAccountERC20Abi = [
+  {
+    type: "tuple",
+    components: [
+      { name: "token", type: "address" },
+      { name: "depositor", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "threshold", type: "uint256" },
+      feeAbiComponent
+    ]
+  }
+];
+var sweepSkipCCTPDepositAccountAbi = [
+  {
+    type: "tuple",
+    components: [
+      { name: "depositor", type: "address" },
+      { name: "destinationDomain", type: "uint32" },
+      { name: "destinationMintRecipient", type: "bytes32" },
+      { name: "threshold", type: "uint256" },
+      feeAbiComponent
+    ]
+  }
+];
+var actionAbiMap = {
+  sweep: sweepAbi,
+  sweepERC20: sweepERC20Abi,
+  sweepCCTP: sweepCCTPAbi,
+  sweepUniswapV3: sweepUniswapV3Abi,
+  sweepDepositAccount: sweepDepositAccountAbi,
+  sweepDepositAccountERC20: sweepDepositAccountERC20Abi,
+  sweepSkipCCTPDepositAccount: sweepSkipCCTPDepositAccountAbi
+};
+var InstructionTypeRegistry = class {
+  constructor() {
+    __publicField(this, "registry", /* @__PURE__ */ new Map());
+    this.initializeDefaultTypes();
+  }
+  register(actionName, definition) {
+    this.registry.set(actionName, definition);
+  }
+  get(actionName) {
+    const definition = this.registry.get(actionName);
+    if (!definition) {
+      throw this.createUnsupportedTypeError(actionName);
+    }
+    return definition;
+  }
+  has(actionName) {
+    return this.registry.has(actionName);
+  }
+  getAvailableTypes() {
+    return Array.from(this.registry.keys());
+  }
+  initializeDefaultTypes() {
+    const actionNames = Object.keys(actionAbiMap);
+    for (const actionName of actionNames) {
+      const abi = actionAbiMap[actionName];
+      const eip712Types = eip712TypesMap[actionName];
+      if (abi && eip712Types) {
+        this.register(actionName, { abi, eip712Types });
+      }
+    }
+  }
+  createUnsupportedTypeError(actionName) {
+    const availableTypes = this.getAvailableTypes().join(", ");
+    return new Error(
+      `Unsupported instruction type: ${actionName}. Available: ${availableTypes}`
+    );
+  }
+};
+var instructionRegistry = new InstructionTypeRegistry();
+
+// src/payments/action-names.ts
+function addActionNamesToInstructions(buildResponse, actionNames) {
+  const completionInstructionCount = buildResponse.completionInstructions.length;
+  return {
+    ...buildResponse,
+    completionInstructions: buildResponse.completionInstructions.map(
+      (instruction, index) => ({
+        ...instruction,
+        actionName: actionNames[index]
+      })
+    ),
+    instructions: buildResponse.instructions.map((instruction, index) => ({
+      ...instruction,
+      actionName: actionNames[completionInstructionCount + index]
+    }))
+  };
+}
+function extractActionNamesMap(completionInstructions, instructions = []) {
+  const allInstructions = [...completionInstructions, ...instructions];
+  return allInstructions.reduce(
+    (actionNamesMap, instruction, index) => {
+      const actionName = getFirstActionArgumentKey(instruction.actionArguments);
+      if (actionName) {
+        actionNamesMap[index] = actionName;
+      }
+      return actionNamesMap;
+    },
+    {}
+  );
+}
+function getFirstActionArgumentKey(actionArguments) {
+  const keys = Object.keys(actionArguments);
+  return keys[0];
+}
+
+// src/payments/validation.ts
+var SignatureValidator = class {
+  static assertExactCount(context) {
+    if (context.received !== context.expected) {
+      throw new Error(
+        `Signature count mismatch: expected ${context.expected}, received ${context.received}`
+      );
+    }
+  }
+  static assertMinimumCount(context) {
+    if (context.received < context.expected) {
+      throw new Error(
+        `Insufficient signatures: expected at least ${context.expected}, received ${context.received}`
+      );
+    }
+  }
+};
+function assertSignatureCount(signatures, expectedCount) {
+  SignatureValidator.assertExactCount({
+    expected: expectedCount,
+    received: signatures.length
+  });
+}
+function assertMinimumSignatures(signatures, minimumCount) {
+  SignatureValidator.assertMinimumCount({
+    expected: minimumCount,
+    received: signatures.length
+  });
+}
+
+// src/payments/chain-token-config-builder.ts
+function createChainTokenConfigs(tokens) {
+  const tokensByChain = groupTokensByChainId(tokens);
+  return convertToChainConfigs(tokensByChain);
+}
+function groupTokensByChainId(tokens) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const chainTokens = grouped.get(token.chainId) ?? [];
+    chainTokens.push(token);
+    grouped.set(token.chainId, chainTokens);
+  }
+  return grouped;
+}
+function convertToChainConfigs(tokensByChain) {
+  return Array.from(tokensByChain.entries()).map(([chainId, tokens]) => ({
+    chainId,
+    tokens: tokens.map((token) => ({
+      symbol: token.symbol,
+      address: token.address,
+      decimals: token.decimals
+    }))
+  }));
+}
+
+// src/payments/payment-request-token-resolver.ts
+function isNativeToken(token) {
+  if (!token) {
+    return false;
+  }
+  return token.symbol === "ETH" || token.address.toLowerCase() === DEFAULT_ADDRESS.toLowerCase();
+}
+function resolvePreferredStablecoin({
+  preferredToken,
+  getStablecoinBySymbol
+}) {
+  const stablecoin = getValidStablecoin(preferredToken);
+  if (stablecoin) {
+    return stablecoin;
+  }
+  return getDefaultStablecoin(getStablecoinBySymbol);
+}
+function getValidStablecoin(token) {
+  if (!token || isNativeToken(token) || !isStablecoin(token.symbol)) {
+    return null;
+  }
+  return token;
+}
+function getDefaultStablecoin(getStablecoinBySymbol) {
+  const usdc = getStablecoinBySymbol("USDC");
+  if (usdc) {
+    return usdc;
+  }
+  const usdt = getStablecoinBySymbol("USDT");
+  if (usdt) {
+    return usdt;
+  }
+  return null;
+}
+function createTokenIdentifier(chainId, tokenAddress) {
+  return `${chainId}:${tokenAddress}`;
+}
+
+// src/payments/payment-metadata-builder.ts
+var DEFAULT_CURRENCY = "USD";
+function isValidAmount(value) {
+  return isNumber(value) && Number.isFinite(value);
+}
+function buildPaymentMetadata(params) {
+  const {
+    note,
+    tokenSymbol,
+    dueDate,
+    amountInUSD,
+    hasInvoiceMetadata = false,
+    fromAccountAddress
+  } = params;
+  const metadata = {
+    token: tokenSymbol
+  };
+  if (!hasInvoiceMetadata) {
+    if (isValidAmount(amountInUSD)) {
+      metadata.amountDue = amountInUSD.toFixed(2);
+    }
+    metadata.currency = DEFAULT_CURRENCY;
+  }
+  if (dueDate) {
+    metadata.dueDate = dueDate;
+  }
+  if (note) {
+    metadata.note = note;
+  }
+  if (fromAccountAddress) {
+    metadata.fromAccountAddress = fromAccountAddress;
+  }
+  return metadata;
+}
+function buildInvoiceMetadata(params) {
+  const { invoiceMetadata, baseMetadata } = params;
+  return {
+    ...baseMetadata,
+    /**
+     * Invoice amounts/dates are authoritative - they override any manually
+     * entered values to prevent sync issues with external systems
+     */
+    amountDue: Number(invoiceMetadata.amount).toFixed(2),
+    currency: invoiceMetadata.currency,
+    dueDate: invoiceMetadata.dueDate,
+    /** Preserve user's manual note if invoice doesn't provide one */
+    note: invoiceMetadata.description ?? baseMetadata.note,
+    /** Track integration source for reconciliation and debugging */
+    source: invoiceMetadata.source,
+    invoiceId: invoiceMetadata.invoiceId,
+    invoiceNumber: invoiceMetadata.invoiceNumber
+  };
+}
+function validatePaymentMetadata(metadata) {
+  const errors = [];
+  const token = metadata["token"];
+  if (!token || typeof token !== "string") {
+    errors.push("Token symbol is required");
+  }
+  const amountDue = metadata["amountDue"];
+  if (amountDue !== void 0 && amountDue !== null) {
+    const amount = typeof amountDue === "string" ? parseFloat(amountDue) : Number(amountDue);
+    if (!isValidAmount(amount) || amount < 0) {
+      errors.push("Amount must be a valid positive number");
+    }
+  }
+  const dueDate = metadata["dueDate"];
+  if (dueDate !== void 0 && dueDate !== null) {
+    if (typeof dueDate !== "string") {
+      errors.push("Due date must be a string");
+    } else {
+      const date = new Date(dueDate);
+      if (!isValidDate(date)) {
+        errors.push("Due date must be a valid ISO date string");
+      }
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+//# sourceMappingURL=index.js.map