@otim/utils 0.0.2-development.0

package/dist/instructions/index.js

@@ -0,0 +1,1152 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/instructions/index.ts
+var instructions_exports = {};
+__export(instructions_exports, {
+  DEFAULT_INTERVAL_SECONDS: () => DEFAULT_INTERVAL_SECONDS,
+  INSTRUCTION_DEFAULT_TIMEOUT: () => INSTRUCTION_DEFAULT_TIMEOUT,
+  convertGweiToWei: () => convertGweiToWei,
+  createActivationPayload: () => createActivationPayload,
+  createBuildPayload: () => createBuildPayload,
+  createInstructionDomain: () => createInstructionDomain,
+  createInstructionTypedData: () => createInstructionTypedData,
+  createRefuelBuildPayload: () => createRefuelBuildPayload,
+  createScheduleInterval: () => createScheduleInterval,
+  createScheduleIntervalLatencyLimit: () => createScheduleIntervalLatencyLimit,
+  createScheduleRepeat: () => createScheduleRepeat,
+  createScheduleStart: () => createScheduleStart,
+  createSweepDepositAccountBuildPayload: () => createSweepDepositAccountBuildPayload,
+  createTransferBuildPayload: () => createTransferBuildPayload,
+  createUniswapV3ExactInputBuildPayload: () => createUniswapV3ExactInputBuildPayload,
+  decodeInstructionParameters: () => decodeInstructionParameters,
+  eip712TypesMap: () => eip712TypesMap,
+  resolveDepositorForSweepDepositAccountIfNeeded: () => resolveDepositorForSweepDepositAccountIfNeeded,
+  resolveFee: () => resolveFee,
+  resolveGasLimitIfNeeded: () => resolveGasLimitIfNeeded,
+  resolveRecipientForUniswapV3ExactInputIfNeeded: () => resolveRecipientForUniswapV3ExactInputIfNeeded,
+  resolveSchedule: () => resolveSchedule
+});
+module.exports = __toCommonJS(instructions_exports);
+
+// src/schemas/instruction.ts
+var import_zod2 = require("zod");
+
+// src/schemas/misc.ts
+var import_zod = require("zod");
+var DATE_REGEX = /^(19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+var DATE_ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/;
+var DATE_STANDARD_REGEX = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/(19|20)\d{2}$/;
+var TIME_REGEX = /^(0[1-9]|1[0-2]):[0-5][0-9]:[0-5][0-9] (AM|PM)$/;
+var regexSchema = (regex, message) => import_zod.z.string().regex(regex, message);
+var nonEmptyStringSchema = import_zod.z.string().min(1);
+var numberSchema = import_zod.z.union([
+  import_zod.z.number().finite(),
+  import_zod.z.string().regex(/^-?\d*\.?\d+(?:[eE][-+]?\d+)?$/).transform(Number)
+]);
+var decimalStringSchema = import_zod.z.string().regex(/^-?\d*\.?\d+$/).refine((val) => !isNaN(parseFloat(val)), {
+  message: "Must be a valid decimal number"
+});
+var bigintSchema = import_zod.z.union([
+  import_zod.z.bigint(),
+  import_zod.z.string().regex(/^-?\d+$/).transform(BigInt)
+]);
+var hexStringSchema = import_zod.z.string().startsWith("0x").transform((val) => val);
+var dateSchema = regexSchema(DATE_REGEX);
+var dateISO8601Schema = regexSchema(DATE_ISO_8601_REGEX);
+var dateStandardSchema = regexSchema(DATE_STANDARD_REGEX);
+var timeSchema = regexSchema(TIME_REGEX);
+var Sort = {
+  Asc: "asc",
+  Desc: "desc"
+};
+var sortValues = Object.values(Sort);
+var vrsSchema = import_zod.z.object({
+  v: import_zod.z.number(),
+  r: import_zod.z.string(),
+  s: import_zod.z.string()
+});
+var eip2098SignatureSchema = import_zod.z.object({
+  yParity: import_zod.z.number(),
+  r: import_zod.z.string(),
+  s: import_zod.z.string()
+});
+
+// src/schemas/instruction.ts
+var InstructionState = {
+  PendingActivation: "PendingActivation",
+  Active: "Active",
+  PendingDeactivation: "PendingDeactivation",
+  Deactivated: "Deactivated",
+  Errored: "Errored",
+  Completed: "Completed",
+  UserNotDelegated: "UserNotDelegated",
+  InFlight: "InFlight",
+  NotifyUser: "NotifyUser"
+};
+var instructionStateValues = Object.values(InstructionState);
+var instructionStateSchema = import_zod2.z.enum(instructionStateValues);
+var InstructionAction = {
+  RefuelERC20: "refuelERC20",
+  Refuel: "refuel",
+  Transfer: "transfer",
+  TransferERC20: "transferERC20",
+  UniswapV3ExactInput: "uniswapV3ExactInput",
+  Sweep: "sweep",
+  SweepERC20: "sweepERC20",
+  SweepCCTP: "sweepCCTP",
+  SweepUniswapV3: "sweepUniswapV3",
+  SweepDepositAccount: "sweepDepositAccount",
+  SweepDepositAccountERC20: "sweepDepositAccountERC20",
+  DeactivateInstruction: "deactivateInstruction",
+  SweepSkipCCTPDepositAccount: "sweepSkipCCTPDepositAccount"
+};
+var instructionActionValues = Object.values(InstructionAction);
+var instructionActionSchema = import_zod2.z.enum(instructionActionValues);
+var InstructionScheduleStartType = {
+  Now: "now",
+  DateTime: "datetime"
+};
+var instructionScheduleStartValues = Object.values(
+  InstructionScheduleStartType
+);
+var baseStartSchema = import_zod2.z.object({
+  type: import_zod2.z.enum(instructionScheduleStartValues)
+});
+var nowStartSchema = baseStartSchema.extend({
+  type: import_zod2.z.literal(InstructionScheduleStartType.Now)
+});
+var dateTimeStartSchema = baseStartSchema.extend({
+  type: import_zod2.z.literal(InstructionScheduleStartType.DateTime),
+  startDate: dateStandardSchema,
+  startTime: import_zod2.z.string()
+});
+var instructionScheduleStartSchema = import_zod2.z.discriminatedUnion("type", [
+  nowStartSchema,
+  dateTimeStartSchema
+]);
+var InstructionScheduleRepeatType = {
+  UntilDeactivated: "until-deactivated",
+  MaxExecutions: "max-executions"
+};
+var instructionScheduleRepeatValues = Object.values(
+  InstructionScheduleRepeatType
+);
+var baseRepeatSchema = import_zod2.z.object({});
+var untilDeactivatedRepeatSchema = baseRepeatSchema.extend({
+  type: import_zod2.z.literal(InstructionScheduleRepeatType.UntilDeactivated)
+});
+var maxExecutionsRepeatSchema = baseRepeatSchema.extend({
+  type: import_zod2.z.literal(InstructionScheduleRepeatType.MaxExecutions),
+  maxExecutions: numberSchema
+});
+var instructionScheduleRepeatSchema = import_zod2.z.discriminatedUnion("type", [
+  untilDeactivatedRepeatSchema,
+  maxExecutionsRepeatSchema
+]);
+var InstructionScheduleRetryType = {
+  UntilDeactivated: "until-deactivated",
+  TimeLimited: "time-limited"
+};
+var instructionScheduleRetryValues = Object.values(
+  InstructionScheduleRetryType
+);
+var baseRetrySchema = import_zod2.z.object({});
+var untilDeactivatedRetrySchema = baseRetrySchema.extend({
+  type: import_zod2.z.literal(InstructionScheduleRetryType.UntilDeactivated)
+});
+var timeLimitedRetrySchema = baseRetrySchema.extend({
+  type: import_zod2.z.literal(InstructionScheduleRetryType.TimeLimited),
+  retryCount: numberSchema
+});
+var instructionScheduleRetrySchema = import_zod2.z.discriminatedUnion("type", [
+  untilDeactivatedRetrySchema,
+  timeLimitedRetrySchema
+]);
+var TimeUnit = {
+  None: "none",
+  Second: "second",
+  Minute: "minute",
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var timeUnitValues = Object.values(TimeUnit);
+var timeUnitSchema = import_zod2.z.enum(timeUnitValues);
+var instructionExecutionStateSchema = import_zod2.z.object({
+  executionStatus: instructionStateSchema.optional(),
+  executionCounter: import_zod2.z.number().int().optional(),
+  lastExecuted: import_zod2.z.number().int().optional()
+});
+var instructionSchema = import_zod2.z.object({
+  instructionId: hexStringSchema,
+  createdAt: import_zod2.z.number().optional(),
+  startAt: import_zod2.z.string().nullish(),
+  interval: import_zod2.z.number().nullish(),
+  timeout: import_zod2.z.number().nullish(),
+  maxExecutions: import_zod2.z.number().nullish(),
+  executionState: instructionExecutionStateSchema.optional(),
+  actionName: import_zod2.z.string().optional(),
+  arguments: import_zod2.z.any(),
+  nickname: import_zod2.z.string().nullish(),
+  lastInstructedValue: import_zod2.z.string().optional(),
+  lastErrorCode: import_zod2.z.number().nullish(),
+  lastErrorMessage: import_zod2.z.string().nullish(),
+  totalInstructedValue: import_zod2.z.string().optional(),
+  instructedTokenAddress: hexStringSchema.nullish(),
+  chainId: import_zod2.z.number().nullish(),
+  chain: import_zod2.z.string().optional()
+});
+var instructionsSchema = import_zod2.z.array(instructionSchema);
+var instructionSummarySchema = import_zod2.z.object({
+  instructionId: hexStringSchema,
+  chainId: import_zod2.z.number().int(),
+  executionCount: import_zod2.z.number().int(),
+  onTimeCount: import_zod2.z.number().int(),
+  lateCount: import_zod2.z.number().int(),
+  wasActivatedDuring: import_zod2.z.boolean(),
+  amount: import_zod2.z.number().default(0),
+  instructedValue: import_zod2.z.string().nullish().default("0"),
+  instructedTokenAddress: import_zod2.z.string().nullish().default(null)
+});
+var instructionSummariesSchema = import_zod2.z.array(instructionSummarySchema);
+var instructionSummariesByDateSchema = import_zod2.z.record(
+  import_zod2.z.string(),
+  instructionSummariesSchema
+);
+var InstructionViewTimescale = {
+  Days: "days",
+  Hours: "hours",
+  Minutes: "minutes",
+  Seconds: "seconds"
+};
+var instructionViewTimescaleValues = Object.values(
+  InstructionViewTimescale
+);
+
+// src/instructions/build.ts
+var import_viem2 = require("viem");
+
+// src/helpers/blockchain.ts
+var import_viem = require("viem");
+var parseSignatureToVRS = (signature) => {
+  if (typeof signature !== "string") {
+    throw new Error("Signature must be a string");
+  }
+  if (!signature.startsWith("0x")) {
+    throw new Error('Signature must start with "0x"');
+  }
+  if (signature.length !== 132) {
+    throw new Error(
+      'Signature must be 65 bytes (130 hex chars) plus "0x" = 132 total length'
+    );
+  }
+  const r = signature.slice(2, 66);
+  const s = signature.slice(66, 130);
+  const vHex = signature.slice(130, 132);
+  const v = parseInt(vHex, 16);
+  return { v, r: `0x${r}`, s: `0x${s}` };
+};
+var isValidV = (v) => {
+  return v === 0 || v === 1 || v === 27 || v === 28 || v >= 35;
+};
+var normalizeV = (v) => {
+  if (!isValidV(v)) return 0;
+  const cmp = v <= 1 ? 1 : 0;
+  const result = v % 2 === cmp;
+  return Number(result) % 2;
+};
+var createEIP2098Signature = (vrs) => {
+  const v = vrs.v;
+  const r = vrs.r;
+  const s = vrs.s;
+  return { yParity: normalizeV(v), r, s };
+};
+
+// src/helpers/date.ts
+var import_zod3 = __toESM(require("zod"));
+var iso8601DateSchema = import_zod3.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 TimeUnit2 = {
+  Day: "day",
+  Month: "month",
+  Year: "year"
+};
+var units = {
+  [TimeUnit2.Day]: {
+    one: "day",
+    other: "days"
+  },
+  [TimeUnit2.Month]: {
+    one: "month",
+    other: "months"
+  },
+  [TimeUnit2.Year]: {
+    one: "year",
+    other: "years"
+  }
+};
+var parseDateTime = (dateInput, timeInput) => {
+  const dateRegex = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/;
+  const timeRegex = /^(\d{1,2}):(\d{2})(?::(\d{2}))?\s*(AM|PM|am|pm)?$/;
+  const dateMatch = dateRegex.exec(dateInput);
+  if (!dateMatch) {
+    return void 0;
+  }
+  const month = parseInt(dateMatch[1], 10) - 1;
+  const day = parseInt(dateMatch[2], 10);
+  const year = parseInt(dateMatch[3], 10);
+  let hours = 0;
+  let minutes = 0;
+  let seconds = 0;
+  if (timeInput) {
+    timeInput = timeInput.replace(/\u00A0/g, " ").trim();
+    const timeMatch = timeRegex.exec(timeInput);
+    if (!timeMatch) {
+      return void 0;
+    }
+    hours = parseInt(timeMatch[1], 10);
+    minutes = parseInt(timeMatch[2], 10);
+    seconds = timeMatch[3] ? parseInt(timeMatch[3], 10) : 0;
+    const meridiem = timeMatch[4] ? timeMatch[4].toUpperCase() : null;
+    if (meridiem === "PM" && hours < 12) {
+      hours += 12;
+    } else if (meridiem === "AM" && hours === 12) {
+      hours = 0;
+    }
+  }
+  const date = new Date(Date.UTC(year, month, day, hours, minutes, seconds));
+  if (isNaN(date.getTime())) {
+    return void 0;
+  }
+  return date;
+};
+
+// src/helpers/datetime.ts
+var import_zod4 = require("zod");
+var timeUnitInputValueSchema = import_zod4.z.object({
+  unit: timeUnitSchema,
+  value: import_zod4.z.number().finite(),
+  seconds: import_zod4.z.number().finite()
+});
+var coerceSecondsFromTimeUnitValue = (value) => {
+  if (!value) return 0;
+  if (typeof value === "object") {
+    const obj = value;
+    const seconds = obj?.seconds;
+    if (typeof seconds === "number" && Number.isFinite(seconds)) return seconds;
+  }
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      const seconds = parsed?.seconds;
+      if (typeof seconds === "number" && Number.isFinite(seconds))
+        return seconds;
+    } catch {
+    }
+  }
+  return 0;
+};
+
+// src/instructions/constants.ts
+var DEFAULT_INTERVAL_SECONDS = 12;
+var INSTRUCTION_DEFAULT_TIMEOUT = 3e4;
+
+// src/instructions/build.ts
+function createBuildPayload({
+  action,
+  address,
+  chainId,
+  maxExecutions,
+  salt,
+  actionArguments
+}) {
+  return {
+    address,
+    chainId,
+    maxExecutions,
+    salt: salt ?? Math.floor(Math.random() * Number.MAX_SAFE_INTEGER),
+    actionArguments: {
+      [action]: actionArguments
+    }
+  };
+}
+var createScheduleStart = (values) => {
+  if (values && values.type === "datetime") {
+    const date = parseDateTime(values.startDate, values.startTime);
+    if (!date) throw new Error("Invalid start date or time");
+    return { startAt: Math.floor(date.getTime() / 1e3), startBy: 0 };
+  }
+  return { startAt: 0, startBy: 0 };
+};
+var createScheduleInterval = (values) => {
+  if (!values) return { interval: DEFAULT_INTERVAL_SECONDS };
+  const seconds = coerceSecondsFromTimeUnitValue(values);
+  return { interval: seconds || DEFAULT_INTERVAL_SECONDS };
+};
+var createScheduleIntervalLatencyLimit = (values) => {
+  if (!values) return { timeout: 0 };
+  const seconds = coerceSecondsFromTimeUnitValue(values);
+  return { timeout: seconds };
+};
+var createScheduleRepeat = (values) => {
+  if (values.type === "max-executions") {
+    return { maxExecutions: values.maxExecutions };
+  }
+  return { maxExecutions: 0 };
+};
+var resolveSchedule = (repeat, start, interval, advanced) => {
+  const { maxExecutions } = createScheduleRepeat(repeat);
+  if (!start && !interval && !advanced?.intervalLatencyLimit) {
+    return { maxExecutions };
+  }
+  const { startAt, startBy } = createScheduleStart(start);
+  const { interval: intervalSeconds } = createScheduleInterval(interval);
+  const { timeout } = createScheduleIntervalLatencyLimit(
+    advanced?.intervalLatencyLimit
+  );
+  return {
+    maxExecutions,
+    schedule: { interval: intervalSeconds, startBy, startAt, timeout }
+  };
+};
+var convertGweiToWei = (gweiValue) => {
+  try {
+    if (isNaN(Number(gweiValue)) || Number(gweiValue) < 0) {
+      throw new Error(`Invalid Gwei value: ${gweiValue}`);
+    }
+    const gweiString = Number(gweiValue).toFixed(18);
+    return (0, import_viem2.toHex)((0, import_viem2.parseUnits)(gweiString, 9));
+  } catch {
+    return (0, import_viem2.toHex)(0n);
+  }
+};
+var resolveFee = (fee, advanced) => {
+  const baseFee = {
+    fee: {
+      executionFee: 0,
+      token: fee.token,
+      maxBaseFeePerGas: convertGweiToWei(advanced?.maxBaseFeePerGas ?? 0),
+      maxPriorityFeePerGas: convertGweiToWei(
+        advanced?.maxPriorityFeePerGas ?? 0
+      )
+    }
+  };
+  const additionalFields = {};
+  if (advanced?.meanPriceLookBack) {
+    additionalFields.meanPriceLookBack = coerceSecondsFromTimeUnitValue(
+      advanced.meanPriceLookBack
+    );
+  }
+  if (advanced?.maxPriceDeviationBps) {
+    const bpsValue = parseInt(String(advanced.maxPriceDeviationBps), 10);
+    if (!isNaN(bpsValue)) {
+      additionalFields.maxPriceDeviationBps = bpsValue;
+    }
+  }
+  return { ...baseFee, ...additionalFields };
+};
+var resolveGasLimitIfNeeded = (action) => {
+  const actionsWithGasLimit = [
+    "refuel",
+    "transfer"
+  ];
+  return actionsWithGasLimit.includes(action) ? { gasLimit: 0 } : {};
+};
+var resolveDepositorForSweepDepositAccountIfNeeded = (action, depositorAddress) => {
+  const actions = [
+    "sweepDepositAccount",
+    "sweepDepositAccountERC20"
+  ];
+  return actions.includes(action) ? { depositor: depositorAddress } : {};
+};
+var resolveRecipientForUniswapV3ExactInputIfNeeded = (action, recipientAddress) => {
+  return action === "uniswapV3ExactInput" ? { recipient: recipientAddress } : {};
+};
+
+// src/instructions/actions/refuel/index.ts
+function createRefuelBuildPayload(payload) {
+  const { address, chainId, maxExecutions, salt } = payload;
+  const action = payload.token ? InstructionAction.RefuelERC20 : InstructionAction.Refuel;
+  const actionArguments = {
+    target: payload.target,
+    threshold: payload.threshold,
+    endBalance: payload.endBalance,
+    fee: payload.fee,
+    schedule: payload.schedule
+  };
+  if (payload.token) {
+    actionArguments.token = payload.token;
+  }
+  if (payload.gasLimit !== void 0) {
+    actionArguments.gasLimit = payload.gasLimit;
+  }
+  return createBuildPayload({
+    action,
+    actionArguments,
+    address,
+    chainId,
+    maxExecutions,
+    salt
+  });
+}
+
+// src/instructions/actions/sweep/index.ts
+function createSweepDepositAccountBuildPayload(payload) {
+  const { address, chainId, maxExecutions, salt } = payload;
+  const action = payload.token ? InstructionAction.SweepDepositAccountERC20 : InstructionAction.SweepDepositAccount;
+  const actionArguments = {
+    depositor: payload.depositor,
+    recipient: payload.recipient,
+    threshold: payload.threshold,
+    fee: payload.fee
+  };
+  if (payload.token) {
+    actionArguments.token = payload.token;
+  }
+  return createBuildPayload({
+    action,
+    actionArguments,
+    address,
+    chainId,
+    maxExecutions,
+    salt
+  });
+}
+
+// src/instructions/actions/swap/index.ts
+function createUniswapV3ExactInputBuildPayload(payload) {
+  const { address, chainId, maxExecutions, salt } = payload;
+  const action = InstructionAction.UniswapV3ExactInput;
+  const actionArguments = {
+    recipient: payload.recipient,
+    tokenIn: payload.tokenIn,
+    tokenOut: payload.tokenOut,
+    feeTier: payload.feeTier,
+    amountIn: payload.amountIn,
+    floorAmountOut: payload.floorAmountOut,
+    meanPriceLookBack: payload.meanPriceLookBack ?? 500,
+    maxPriceDeviationBps: payload.maxPriceDeviationBps ?? 500,
+    schedule: payload.schedule,
+    fee: payload.fee
+  };
+  return createBuildPayload({
+    action,
+    actionArguments,
+    address,
+    chainId,
+    maxExecutions,
+    salt
+  });
+}
+
+// src/instructions/actions/transfer/index.ts
+function createTransferBuildPayload(payload) {
+  const { address, chainId, maxExecutions, salt } = payload;
+  const action = payload.token ? InstructionAction.TransferERC20 : InstructionAction.Transfer;
+  const actionArguments = {
+    target: payload.target,
+    value: payload.value,
+    fee: payload.fee,
+    schedule: payload.schedule
+  };
+  if (payload.token) {
+    actionArguments.token = payload.token;
+  }
+  if (payload.gasLimit !== void 0) {
+    actionArguments.gasLimit = payload.gasLimit;
+  }
+  return createBuildPayload({
+    action,
+    actionArguments,
+    address,
+    chainId,
+    maxExecutions,
+    salt
+  });
+}
+
+// src/instructions/activate.ts
+var import_viem3 = require("viem");
+
+// src/instructions/contracts/artifacts/abi/build-instruction-action-arguments-abi.ts
+var targetField = {
+  name: "target",
+  type: "address"
+};
+var scheduleField = {
+  name: "schedule",
+  type: "tuple",
+  components: [
+    { name: "startAt", type: "uint256" },
+    { name: "startBy", type: "uint256" },
+    { name: "interval", type: "uint256" },
+    { name: "timeout", type: "uint256" }
+  ]
+};
+var tokenField = {
+  name: "token",
+  type: "address"
+};
+var feeField = {
+  name: "fee",
+  type: "tuple",
+  components: [
+    { name: "token", type: "address" },
+    { name: "maxBaseFeePerGas", type: "uint256" },
+    { name: "maxPriorityFeePerGas", type: "uint256" },
+    { name: "executionFee", type: "uint256" }
+  ]
+};
+var refuelArgumentsAbi = [
+  targetField,
+  { name: "threshold", type: "uint256" },
+  { name: "endBalance", type: "uint256" },
+  { name: "gasLimit", type: "uint256" },
+  feeField
+];
+var refuelERC20ArgumentsAbi = [
+  tokenField,
+  targetField,
+  { name: "threshold", type: "uint256" },
+  { name: "endBalance", type: "uint256" },
+  feeField
+];
+var transferArgumentsAbi = [
+  targetField,
+  { name: "value", type: "uint256" },
+  { name: "gasLimit", type: "uint256" },
+  scheduleField,
+  feeField
+];
+var transferERC20ArgumentsAbi = [
+  tokenField,
+  targetField,
+  { name: "value", type: "uint256" },
+  scheduleField,
+  feeField
+];
+var uniswapV3ExactInputArgumentsAbi = [
+  { 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" },
+  scheduleField,
+  feeField
+];
+var sweepDepositAccountArgumentsAbi = [
+  { name: "depositor", type: "address" },
+  { name: "recipient", type: "address" },
+  { name: "threshold", type: "uint256" },
+  feeField
+];
+var sweepDepositAccountERC20ArgumentsAbi = [
+  tokenField,
+  { name: "depositor", type: "address" },
+  { name: "recipient", type: "address" },
+  { name: "threshold", type: "uint256" },
+  feeField
+];
+var sweepSkipCCTPDepositAccountArgumentsAbi = [
+  { name: "depositor", type: "address" },
+  { name: "destinationDomain", type: "uint32" },
+  { name: "destinationMintRecipient", type: "bytes32" },
+  { name: "threshold", type: "uint256" },
+  feeField
+];
+var deactivateInstructionArgumentsAbi = [
+  { name: "instructionId", type: "bytes32" },
+  feeField
+];
+var buildInstructionActionArgumentsAbiMap = {
+  [InstructionAction.Refuel]: refuelArgumentsAbi,
+  [InstructionAction.RefuelERC20]: refuelERC20ArgumentsAbi,
+  [InstructionAction.Transfer]: transferArgumentsAbi,
+  [InstructionAction.TransferERC20]: transferERC20ArgumentsAbi,
+  [InstructionAction.UniswapV3ExactInput]: uniswapV3ExactInputArgumentsAbi,
+  [InstructionAction.SweepDepositAccount]: sweepDepositAccountArgumentsAbi,
+  [InstructionAction.SweepDepositAccountERC20]: sweepDepositAccountERC20ArgumentsAbi,
+  [InstructionAction.SweepSkipCCTPDepositAccount]: sweepSkipCCTPDepositAccountArgumentsAbi,
+  [InstructionAction.DeactivateInstruction]: deactivateInstructionArgumentsAbi
+};
+
+// 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/instructions/activate.ts
+function createInstructionDomain(config) {
+  return {
+    chainId: config.chainId,
+    name: "OtimDelegate",
+    salt: (0, import_viem3.keccak256)((0, import_viem3.toHex)("ON_TIME_INSTRUCTED_MONEY")),
+    verifyingContract: config.delegateAddress,
+    version: "1"
+  };
+}
+function decodeInstructionParameters(salt, maxExecutions, argumentsHex, actionName) {
+  const eip712Types = eip712TypesMap[actionName];
+  const argumentsAbi = buildInstructionActionArgumentsAbiMap[actionName];
+  if (!eip712Types) {
+    throw new Error(`No EIP-712 types found for action: ${actionName}`);
+  }
+  if (!argumentsAbi) {
+    throw new Error(`No arguments ABI found for action: ${actionName}`);
+  }
+  const [decodedSalt] = (0, import_viem3.decodeAbiParameters)(
+    [eip712Types.types.Instruction[0]],
+    (0, import_viem3.pad)(salt)
+  );
+  const [decodedMaxExecutions] = (0, import_viem3.decodeAbiParameters)(
+    [eip712Types.types.Instruction[1]],
+    (0, import_viem3.pad)(maxExecutions)
+  );
+  const decodedArgsArray = (0, import_viem3.decodeAbiParameters)(argumentsAbi, argumentsHex);
+  const decodedArguments = {};
+  argumentsAbi.forEach((param, index) => {
+    decodedArguments[param.name] = decodedArgsArray[index];
+  });
+  return {
+    decodedSalt,
+    decodedMaxExecutions,
+    decodedArguments
+  };
+}
+function createInstructionTypedData(payload, config) {
+  const { decodedSalt, decodedMaxExecutions, decodedArguments } = decodeInstructionParameters(
+    payload.salt,
+    payload.maxExecutions,
+    payload.arguments,
+    payload.actionName
+  );
+  const eip712Types = eip712TypesMap[payload.actionName];
+  if (!eip712Types) {
+    throw new Error(`No EIP-712 types found for action: ${payload.actionName}`);
+  }
+  const domain = createInstructionDomain(config);
+  return {
+    domain,
+    primaryType: "Instruction",
+    types: eip712Types.types,
+    message: {
+      [payload.actionName]: decodedArguments,
+      salt: decodedSalt,
+      maxExecutions: decodedMaxExecutions,
+      action: payload.action
+    }
+  };
+}
+function createActivationPayload(payload) {
+  const vrs = parseSignatureToVRS(payload.signature);
+  const primitiveSignature = createEIP2098Signature(vrs);
+  return {
+    nickname: payload.nickname,
+    address: payload.address,
+    chainId: payload.chainId,
+    salt: payload.salt,
+    maxExecutions: payload.maxExecutions,
+    action: payload.action,
+    arguments: payload.arguments,
+    activationSignature: primitiveSignature
+  };
+}
+//# sourceMappingURL=index.js.map