@otim/utils 0.0.4 → 0.0.6

package/dist/payments/index.mjs

@@ -1,1285 +1,643 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/payments/types.ts
-var PaymentAction = {
-  Sweep: "sweep",
-  SweepCCTP: "sweepCCTP",
-  SweepERC20: "sweepERC20",
-  SweepUniswapV3: "sweepUniswapV3"
+import { t as _defineProperty } from "../defineProperty-DzhmunJg.mjs";
+import { P as isNumber, b as isValidDate } from "../date-gBac-Om9.mjs";
+import { InstructionAction } from "@otim/utils/schemas";
+import { DEFAULT_ADDRESS } from "@otim/utils/helpers";
+import { arbitrum, base, baseSepolia, mainnet, optimism, sepolia } from "viem/chains";
+import { isStablecoin } from "@otim/utils/chains";
+import { eip712TypesMap } from "@otim/utils/instructions";
+
+//#region src/payments/types.ts
+const PaymentAction = {
+	Sweep: "Sweep",
+	SweepCCTP: "SweepCCTP",
+	SweepERC20: "SweepERC20",
+	SweepUniswapV3: "SweepUniswapV3",
+	SweepDepositERC4626: "SweepDepositERC4626"
+};
+/**
+* Orchestration type discriminant.
+* Must match the Rust OrchestrationMetadata enum variants.
+*/
+const OrchestrationType = {
+	PaymentRequest: "PaymentRequest",
+	AutoEarn: "AutoEarn"
 };
-var UniswapV3FeeTier = {
-  Lowest: "100",
-  Low: "500",
-  Medium: "3000",
-  High: "10000"
+/**
+* Uniswap V3 fee tiers. Used to specify the fee tier for a Uniswap V3 swap.
+* @see https://docs.uniswap.org/concepts/protocol/fees
+*/
+const UniswapV3FeeTier = {
+	Lowest: "100",
+	Low: "500",
+	Medium: "3000",
+	High: "10000"
 };
 
-// src/payments/config/cctp.ts
-import {
-  arbitrum,
-  arbitrumSepolia,
-  base,
-  baseSepolia,
-  mainnet,
-  optimism,
-  optimismSepolia,
-  sepolia
-} from "viem/chains";
-var cctpSupportedChains = /* @__PURE__ */ new Set([
-  mainnet.id,
-  optimism.id,
-  arbitrum.id,
-  base.id,
-  sepolia.id,
-  optimismSepolia.id,
-  arbitrumSepolia.id,
-  baseSepolia.id
+//#endregion
+//#region src/payments/config/cctp.ts
+/**
+* List of chains that support CCTP
+* Only includes chains that have confirmed CCTP support from Circle
+* @see https://developers.circle.com/stablecoins/docs/supported-domains
+*/
+const cctpSupportedChains = new Set([
+	mainnet.id,
+	optimism.id,
+	arbitrum.id,
+	base.id,
+	sepolia.id,
+	baseSepolia.id
 ]);
-var cctpDomainMapping = {
-  [mainnet.id]: 0,
-  [optimism.id]: 2,
-  [arbitrum.id]: 3,
-  [base.id]: 6,
-  [sepolia.id]: 0,
-  [optimismSepolia.id]: 2,
-  [arbitrumSepolia.id]: 3,
-  [baseSepolia.id]: 6
+/**
+* CCTP Domain Mapping - Maps chain IDs to their Circle CCTP domain identifiers
+* Source: https://developers.circle.com/stablecoins/docs/supported-domains
+*
+* Domain IDs are used by Circle's Cross-Chain Transfer Protocol (CCTP) to
+* identify destination chains when burning and minting USDC across different
+* networks.
+*/
+const cctpDomainMapping = {
+	[mainnet.id]: 0,
+	[optimism.id]: 2,
+	[arbitrum.id]: 3,
+	[base.id]: 6,
+	[sepolia.id]: 0,
+	[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
-import { isAddressEqual } from "viem";
-var DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
-
-// src/helpers/date.ts
-import z from "zod";
-var iso8601DateSchema = z.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"
+	constructor() {
+		_defineProperty(this, "supportedChainIds", void 0);
+		this.supportedChainIds = cctpSupportedChains;
+	}
+	isSupported(chainId) {
+		return this.supportedChainIds.has(chainId);
+	}
+	getDomain(chainId) {
+		return cctpDomainMapping[chainId] ?? null;
+	}
 };
-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
+const defaultCCTPConfig = new DefaultCCTPConfig();
+
+//#endregion
+//#region src/payments/config/tokens.ts
+/**
+* Determines the recommended Uniswap V3 fee tier for a token pair
+*
+* Stable pairs (USDC/USDT swaps) use the Low fee tier (0.05%) since price
+* volatility is minimal. All other pairs use the Medium fee tier (0.3%) to
+* account for higher price volatility
+*
+* @param tokenIn - Symbol of the input token (e.g., "USDC", "USDT")
+* @param tokenOut - Symbol of the output token (e.g., "USDC", "USDT")
+* @returns The recommended Uniswap V3 fee tier for the swap
+*/
 function getRecommendedFeeTier(tokenIn, tokenOut) {
-  if (isStablecoin([tokenIn, tokenOut])) {
-    return UniswapV3FeeTier.Low;
-  }
-  return UniswapV3FeeTier.Medium;
+	if (isStablecoin([tokenIn, tokenOut])) return UniswapV3FeeTier.Low;
+	return UniswapV3FeeTier.Medium;
 }
 
-// src/payments/build.ts
-var DEFAULT_SET_EPHEMERAL_TARGET = true;
+//#endregion
+//#region src/payments/build.ts
+const DEFAULT_SET_EPHEMERAL_TARGET = true;
 function createPaymentRequestBuildPayload(params) {
-  const {
-    payerAddress = null,
-    completionInstructions,
-    instructions = [],
-    metadata = {},
-    maxRuns
-  } = params;
-  return {
-    payerAddress,
-    completionInstructions: completionInstructions.map(processInstruction),
-    instructions: instructions.map(processInstruction),
-    metadata,
-    maxRuns
-  };
+	const { payerAddress = null, completionInstructions, instructions = [], metadata = {}, maxRuns } = params;
+	return {
+		payerAddress,
+		completionInstructions: completionInstructions.map(processInstruction),
+		instructions: instructions.map(processInstruction),
+		metadata,
+		maxRuns
+	};
 }
 function processInstruction(spec) {
-  return {
-    chainId: spec.chainId,
-    salt: spec.salt ?? generateRandomSalt(),
-    maxExecutions: spec.maxExecutions,
-    actionArguments: spec.actionArguments,
-    setEphemeralTarget: spec.setEphemeralTarget ?? DEFAULT_SET_EPHEMERAL_TARGET
-  };
+	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);
+	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
-  };
+	return {
+		token,
+		executionFee,
+		maxBaseFeePerGas,
+		maxPriorityFeePerGas
+	};
 }
 function createFeeWithToken(token, maxPriorityFeePerGas) {
-  return createDefaultFee(0, "0x0", maxPriorityFeePerGas ?? "0x0", token);
-}
-
-// src/payments/comprehensive-payment-request.ts
-import { parseUnits, toHex } from "viem";
-
-// src/payments/actions/sweep-cctp.ts
-import { pad } from "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: 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,
-    maxRuns = 1
-  } = 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,
-    maxRuns
-  });
-}
-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 toHex(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: 0,
-    actionArguments: createSweepERC20ActionArguments({
-      chainId,
-      maxExecutions: 0,
-      token: tokenAddress,
-      target: recipient,
-      threshold,
-      endBalance: 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: 0,
-    actionArguments: createSweepUniswapV3ActionArguments({
-      chainId,
-      maxExecutions: 0,
-      recipient,
-      tokenIn: tokenIn.address,
-      tokenOut: tokenOut.address,
-      feeTier,
-      threshold,
-      endBalance: toHex(ZERO_BALANCE),
-      floorAmountOut: 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: 0,
-      actionArguments: createSweepUniswapV3ActionArguments({
-        chainId: chainConfig.chainId,
-        maxExecutions: 0,
-        recipient: ephemeralWalletAddress,
-        tokenIn: sourceToken.address,
-        tokenOut: chainUSDC.address,
-        feeTier,
-        threshold: toHex(MINIMUM_THRESHOLD),
-        endBalance: toHex(ZERO_BALANCE),
-        floorAmountOut: 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,
-      toHex(MINIMUM_THRESHOLD),
-      instructionFee,
-      cctpConfig
-    );
-    instructions.push(bridgeInstruction);
-  }
-  return instructions;
-}
-function createCCTPBridgeInstruction(sourceChainId, tokenAddress, destinationChainId, ephemeralWalletAddress, threshold, fee, cctpConfig) {
-  return {
-    chainId: sourceChainId,
-    maxExecutions: 0,
-    actionArguments: createSweepCCTPActionArguments({
-      chainId: sourceChainId,
-      maxExecutions: 0,
-      token: tokenAddress,
-      destinationChainId,
-      destinationMintRecipient: ephemeralWalletAddress,
-      threshold,
-      endBalance: toHex(ZERO_BALANCE),
-      fee,
-      cctpConfig
-    }),
-    setEphemeralTarget: true
-  };
-}
-
-// src/payments/actions/sweep.ts
-import { toHex as toHex2 } from "viem";
-function createSweepActionArguments(payload) {
-  return {
-    [PaymentAction.Sweep]: {
-      target: payload.target,
-      threshold: payload.threshold,
-      endBalance: payload.endBalance,
-      gasLimit: toHex2(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" }
-    ]
-  }
+	return createDefaultFee(0, "0x0", maxPriorityFeePerGas ?? "0x0", token);
+}
+
+//#endregion
+//#region src/payments/instruction-registry.ts
+const feeAbiComponent = {
+	name: "fee",
+	type: "tuple",
+	components: [
+		{
+			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
+const sweepAbi = [{
+	type: "tuple",
+	components: [
+		{
+			name: "target",
+			type: "address"
+		},
+		{
+			name: "threshold",
+			type: "uint256"
+		},
+		{
+			name: "endBalance",
+			type: "uint256"
+		},
+		{
+			name: "gasLimit",
+			type: "uint256"
+		},
+		feeAbiComponent
+	]
+}];
+const sweepERC20Abi = [{
+	type: "tuple",
+	components: [
+		{
+			name: "token",
+			type: "address"
+		},
+		{
+			name: "target",
+			type: "address"
+		},
+		{
+			name: "threshold",
+			type: "uint256"
+		},
+		{
+			name: "endBalance",
+			type: "uint256"
+		},
+		feeAbiComponent
+	]
+}];
+const 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
+	]
+}];
+const 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
+	]
+}];
+const sweepSkipCCTPDepositAccountAbi = [{
+	type: "tuple",
+	components: [
+		{
+			name: "depositor",
+			type: "address"
+		},
+		{
+			name: "destinationDomain",
+			type: "uint32"
+		},
+		{
+			name: "destinationMintRecipient",
+			type: "bytes32"
+		},
+		{
+			name: "threshold",
+			type: "uint256"
+		},
+		feeAbiComponent
+	]
+}];
+const sweepDepositERC4626Abi = [{
+	type: "tuple",
+	components: [
+		{
+			name: "vault",
+			type: "address"
+		},
+		{
+			name: "recipient",
+			type: "address"
+		},
+		{
+			name: "threshold",
+			type: "uint256"
+		},
+		{
+			name: "endBalance",
+			type: "uint256"
+		},
+		{
+			name: "minDeposit",
+			type: "uint256"
+		},
+		{
+			name: "minTotalShares",
+			type: "uint256"
+		},
+		feeAbiComponent
+	]
+}];
+const sweepWithdrawERC4626Abi = [{
+	type: "tuple",
+	components: [
+		{
+			name: "vault",
+			type: "address"
+		},
+		{
+			name: "recipient",
+			type: "address"
+		},
+		{
+			name: "threshold",
+			type: "uint256"
+		},
+		{
+			name: "endBalance",
+			type: "uint256"
+		},
+		{
+			name: "minWithdraw",
+			type: "uint256"
+		},
+		feeAbiComponent
+	]
+}];
+const actionAbiMap = {
+	[InstructionAction.Sweep]: sweepAbi,
+	[InstructionAction.SweepERC20]: sweepERC20Abi,
+	[InstructionAction.SweepCCTP]: sweepCCTPAbi,
+	[InstructionAction.SweepUniswapV3]: sweepUniswapV3Abi,
+	[InstructionAction.SweepSkipCCTPDepositAccount]: sweepSkipCCTPDepositAccountAbi,
+	[InstructionAction.SweepDepositERC4626]: sweepDepositERC4626Abi,
+	[InstructionAction.SweepWithdrawERC4626]: sweepWithdrawERC4626Abi
 };
 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}`
-    );
-  }
+	constructor() {
+		_defineProperty(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 /* @__PURE__ */ new Error(`Unsupported instruction type: ${actionName}. Available: ${availableTypes}`);
+	}
 };
-var instructionRegistry = new InstructionTypeRegistry();
+const instructionRegistry = new InstructionTypeRegistry();
 
-// src/payments/action-names.ts
+//#endregion
+//#region 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]
-    }))
-  };
+	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;
-    },
-    {}
-  );
+	return [...completionInstructions, ...instructions].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];
+	return Object.keys(actionArguments)[0];
 }
 
-// src/payments/validation.ts
+//#endregion
+//#region 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}`
-      );
-    }
-  }
+	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
-  });
+	SignatureValidator.assertExactCount({
+		expected: expectedCount,
+		received: signatures.length
+	});
 }
 function assertMinimumSignatures(signatures, minimumCount) {
-  SignatureValidator.assertMinimumCount({
-    expected: minimumCount,
-    received: signatures.length
-  });
+	SignatureValidator.assertMinimumCount({
+		expected: minimumCount,
+		received: signatures.length
+	});
 }
 
-// src/payments/chain-token-config-builder.ts
+//#endregion
+//#region src/payments/chain-token-config-builder.ts
 function createChainTokenConfigs(tokens) {
-  const tokensByChain = groupTokensByChainId(tokens);
-  return convertToChainConfigs(tokensByChain);
+	return convertToChainConfigs(groupTokensByChainId(tokens));
 }
 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;
+	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
+	return Array.from(tokensByChain.entries()).map(([chainId, tokens]) => ({
+		chainId,
+		tokens: tokens.map((token) => ({
+			symbol: token.symbol,
+			address: token.address,
+			decimals: token.decimals
+		}))
+	}));
+}
+
+//#endregion
+//#region 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;
+	if (!token) return false;
+	return token.symbol === "ETH" || token.address.toLowerCase() === DEFAULT_ADDRESS.toLowerCase();
 }
 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);
-}
+	return `${chainId}:${tokenAddress}`;
+}
+
+//#endregion
+//#region src/payments/payment-metadata-builder.ts
+const DEFAULT_CURRENCY = "USD";
+const DEFAULT_SOURCE = "Manual";
+/**
+* Formats a date to NaiveDateTime format expected by Rust backend.
+* Converts ISO 8601 strings like "2025-01-15T00:00:00.000Z" to "2025-01-15T00:00:00".
+*
+* Rust's chrono::NaiveDateTime expects format without timezone suffix.
+*
+* @param dateInput - Date string or Date object to format
+* @returns Formatted NaiveDateTime string
+* @throws Error if date is invalid
+*/
+function formatToNaiveDateTime(dateInput) {
+	const date = typeof dateInput === "string" ? new Date(dateInput) : dateInput;
+	if (!isValidDate(date)) throw new Error(`Invalid date provided: ${String(dateInput)}`);
+	return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}T${String(date.getUTCHours()).padStart(2, "0")}:${String(date.getUTCMinutes()).padStart(2, "0")}:${String(date.getUTCSeconds()).padStart(2, "0")}`;
+}
+/**
+* Formats a numeric amount to a decimal string with 2 decimal places.
+* Ensures consistent formatting for monetary values.
+*
+* @param amount - Numeric amount to format
+* @returns Formatted amount string (e.g., "150.00")
+*/
+function formatAmount(amount) {
+	return amount.toFixed(2);
+}
+/**
+* Validates that a value is a safe, finite number suitable for monetary amounts.
+* Excludes NaN and Infinity which could cause calculation errors downstream.
+*
+* @param value - Value to validate
+* @returns True if value is a valid monetary amount
+*/
+function isValidMonetaryAmount(value) {
+	return isNumber(value) && Number.isFinite(value);
+}
+/**
+* Constructs payment metadata for manually created payment requests.
+* Pure function with explicit input/output contract.
+*
+* @param params - Configuration for manual payment request
+* @returns Immutable PaymentRequestMetadata object
+*/
 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;
-}
+	const { tokenSymbol, note, dueDate, amountInUSD, fromAccountAddress, payer, source = DEFAULT_SOURCE } = params;
+	const baseMetadata = {
+		type: OrchestrationType.PaymentRequest,
+		token: tokenSymbol,
+		amountDue: formatAmount(amountInUSD),
+		currency: DEFAULT_CURRENCY,
+		dueDate: formatToNaiveDateTime(dueDate),
+		fromAccountAddress,
+		payer,
+		source
+	};
+	if (note !== void 0 && note !== "") return {
+		...baseMetadata,
+		note
+	};
+	return baseMetadata;
+}
+/**
+* Constructs payment metadata from invoice integration data.
+* Invoice fields are authoritative and override any defaults.
+* Pure function ensuring consistent metadata structure for integrations.
+*
+* @param params - Invoice and account configuration
+* @returns Immutable PaymentRequestMetadata object
+*/
+function buildPaymentMetadataFromInvoice(params) {
+	const { tokenSymbol, fromAccountAddress, payer, invoiceMetadata } = params;
+	const baseMetadata = {
+		type: OrchestrationType.PaymentRequest,
+		token: tokenSymbol,
+		amountDue: formatAmount(Number(invoiceMetadata.amount)),
+		currency: invoiceMetadata.currency,
+		dueDate: formatToNaiveDateTime(invoiceMetadata.dueDate),
+		fromAccountAddress,
+		payer,
+		source: invoiceMetadata.source,
+		invoiceId: invoiceMetadata.invoiceId,
+		invoiceNumber: invoiceMetadata.invoiceNumber
+	};
+	const optionalFields = {
+		...invoiceMetadata.description && { note: invoiceMetadata.description },
+		...invoiceMetadata.attachmentUrl && { attachmentUrl: invoiceMetadata.attachmentUrl },
+		...invoiceMetadata.attachmentName && { attachmentName: invoiceMetadata.attachmentName }
+	};
+	return {
+		...baseMetadata,
+		...optionalFields
+	};
+}
+/**
+* Merges invoice data from external integrations with base payment metadata.
+* Invoice fields override manual entries to ensure accuracy and maintain
+* audit trail through source/invoiceId tracking.
+*
+* @param params - Invoice and base metadata configuration
+* @returns Immutable PaymentRequestMetadata with merged fields
+*/
 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
-  };
-}
+	const { invoiceMetadata, baseMetadata } = params;
+	const mergedMetadata = {
+		...baseMetadata,
+		amountDue: formatAmount(Number(invoiceMetadata.amount)),
+		currency: invoiceMetadata.currency,
+		dueDate: formatToNaiveDateTime(invoiceMetadata.dueDate),
+		note: invoiceMetadata.description ?? baseMetadata.note,
+		source: invoiceMetadata.source,
+		invoiceId: invoiceMetadata.invoiceId,
+		invoiceNumber: invoiceMetadata.invoiceNumber
+	};
+	const attachmentFields = {
+		...invoiceMetadata.attachmentUrl && { attachmentUrl: invoiceMetadata.attachmentUrl },
+		...invoiceMetadata.attachmentName && { attachmentName: invoiceMetadata.attachmentName }
+	};
+	return {
+		...mergedMetadata,
+		...attachmentFields
+	};
+}
+/**
+* Validates payment metadata structure before sending to backend API.
+* Catches type mismatches and invalid values that would cause payment
+* creation failures or blockchain transaction errors.
+*
+* Pure function returning immutable result object.
+*
+* @param metadata - Metadata to validate
+* @returns Validation result with explicit errors array
+*/
 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
-  };
-}
-export {
-  DefaultCCTPConfig,
-  PaymentAction,
-  SignatureValidator,
-  UniswapV3FeeTier,
-  addActionNamesToInstructions,
-  assertMinimumSignatures,
-  assertSignatureCount,
-  buildInvoiceMetadata,
-  buildPaymentMetadata,
-  createChainTokenConfigs,
-  createComprehensivePaymentRequest,
-  createDefaultFee,
-  createFeeWithToken,
-  createPaymentRequestBuildPayload,
-  createSweepActionArguments,
-  createSweepCCTPActionArguments,
-  createSweepERC20ActionArguments,
-  createSweepUniswapV3ActionArguments,
-  createTokenIdentifier,
-  defaultCCTPConfig,
-  extractActionNamesMap,
-  getRecommendedFeeTier,
-  instructionRegistry,
-  isNativeToken,
-  resolvePreferredStablecoin,
-  validatePaymentMetadata
-};
-//# sourceMappingURL=index.mjs.map
+	const errors = [];
+	if (metadata.type !== OrchestrationType.PaymentRequest) errors.push(`Metadata type must be '${OrchestrationType.PaymentRequest}', got '${String(metadata.type)}'`);
+	if (!metadata.token || typeof metadata.token !== "string") errors.push("Token symbol is required and must be a string");
+	if (!metadata.amountDue || typeof metadata.amountDue !== "string") errors.push("Amount due is required and must be a string");
+	else {
+		const amount = parseFloat(metadata.amountDue);
+		if (!isValidMonetaryAmount(amount) || amount < 0) errors.push(`Amount must be a valid non-negative number, got '${metadata.amountDue}'`);
+	}
+	if (!metadata.currency || typeof metadata.currency !== "string") errors.push("Currency is required and must be a string");
+	if (!metadata.dueDate || typeof metadata.dueDate !== "string") errors.push("Due date is required and must be a string");
+	else if (!isValidDate(new Date(metadata.dueDate))) errors.push(`Due date must be a valid date string, got '${metadata.dueDate}'`);
+	if (!metadata.fromAccountAddress || typeof metadata.fromAccountAddress !== "string") errors.push("From account address is required and must be a string");
+	if (!metadata.payer) errors.push("Payer information is required");
+	else {
+		if (typeof metadata.payer.name !== "string") errors.push("Payer name must be a string");
+		if (!metadata.payer.address || typeof metadata.payer.address !== "string") errors.push("Payer address is required and must be a string");
+	}
+	if (!metadata.source || typeof metadata.source !== "string") errors.push("Source is required and must be a string");
+	return {
+		isValid: errors.length === 0,
+		errors
+	};
+}
+
+//#endregion
+export { DefaultCCTPConfig, OrchestrationType, PaymentAction, SignatureValidator, UniswapV3FeeTier, addActionNamesToInstructions, assertMinimumSignatures, assertSignatureCount, buildInvoiceMetadata, buildPaymentMetadata, buildPaymentMetadataFromInvoice, createChainTokenConfigs, createDefaultFee, createFeeWithToken, createPaymentRequestBuildPayload, createTokenIdentifier, defaultCCTPConfig, extractActionNamesMap, getRecommendedFeeTier, instructionRegistry, isNativeToken, validatePaymentMetadata };
+//# sourceMappingURL=index.mjs.map