@otim/utils 0.0.2-development.0

package/dist/helpers/index.js

@@ -0,0 +1,1322 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/helpers/index.ts
+var helpers_exports = {};
+__export(helpers_exports, {
+  DEFAULT_ADDRESS: () => DEFAULT_ADDRESS,
+  ETHEREUM_ADDRESS_REGEX: () => ETHEREUM_ADDRESS_REGEX,
+  PollingManager: () => PollingManager,
+  TimeUnit: () => TimeUnit,
+  areAddressesEqual: () => areAddressesEqual,
+  buildQueryString: () => buildQueryString,
+  buildUrl: () => buildUrl,
+  capitalize: () => capitalize,
+  closeEmergentWindow: () => closeEmergentWindow,
+  coerceSecondsFromTimeUnitValue: () => coerceSecondsFromTimeUnitValue,
+  composeValidators: () => composeValidators,
+  createEIP2098Signature: () => createEIP2098Signature,
+  createTimeUnitValidator: () => createTimeUnitValidator,
+  dateMaskOptions: () => dateMaskOptions,
+  extractNumber: () => extractNumber,
+  extractString: () => extractString,
+  focusMainWindow: () => focusMainWindow,
+  formatCurrency: () => formatCurrency,
+  formatDateAsISO: () => formatDateAsISO,
+  formatDateAsUSStandard: () => formatDateAsUSStandard,
+  formatDateTime: () => formatDateTime,
+  formatDateToYYYYMMDD: () => formatDateToYYYYMMDD,
+  formatFullDate: () => formatFullDate,
+  formatLongDate: () => formatLongDate,
+  formatLongDateTime: () => formatLongDateTime,
+  formatNumberAsUSStandard: () => formatNumberAsUSStandard,
+  formatSignatureToEIP2098: () => formatSignatureToEIP2098,
+  formatTime: () => formatTime,
+  formatToJustDate: () => formatToJustDate,
+  formatToShortDate: () => formatToShortDate,
+  formatToShortDateWithYear: () => formatToShortDateWithYear,
+  formatUUID: () => formatUUID,
+  formattedNumber: () => formattedNumber,
+  getBaseDomain: () => getBaseDomain,
+  getChainRpcUrl: () => getChainRpcUrl,
+  getPluralizedUnit: () => getPluralizedUnit,
+  getRelativeDateDescription: () => getRelativeDateDescription,
+  getSecondsFromTimeUnitValue: () => getSecondsFromTimeUnitValue,
+  i18n: () => i18n,
+  isBoolean: () => isBoolean,
+  isClient: () => isClient,
+  isDateEpoc: () => isDateEpoc,
+  isDateInPast: () => isDateInPast,
+  isDateInRange: () => isDateInRange,
+  isDateInvalid: () => isDateInvalid,
+  isError: () => isError,
+  isFunction: () => isFunction,
+  isNullAddress: () => isNullAddress,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isSameDate: () => isSameDate,
+  isScriptLoaded: () => isScriptLoaded,
+  isString: () => isString,
+  isUndefined: () => isUndefined,
+  isValidDate: () => isValidDate,
+  isValidEthereumAddress: () => isValidEthereumAddress,
+  isValidTimeUnitValue: () => isValidTimeUnitValue,
+  isValidV: () => isValidV,
+  iso8601DateSchema: () => iso8601DateSchema,
+  loadExternalSdk: () => loadExternalSdk,
+  localeSchema: () => localeSchema,
+  logger: () => logger,
+  normalizeV: () => normalizeV,
+  numFormatter: () => numFormatter,
+  openCenteredEmergentWindow: () => openCenteredEmergentWindow,
+  parseDateTime: () => parseDateTime,
+  parseDateTimeStrict: () => parseDateTimeStrict,
+  parseSchema: () => parseSchema,
+  parseSignatureToVRS: () => parseSignatureToVRS,
+  parseTimeUnitValue: () => parseTimeUnitValue,
+  performRedirect: () => performRedirect,
+  postalCodeMaskOptions: () => postalCodeMaskOptions,
+  randomNumber: () => randomNumber,
+  safeFormatDate: () => safeFormatDate,
+  serializeTimeUnitValue: () => serializeTimeUnitValue,
+  timeMaskOptionsHHMM: () => timeMaskOptionsHHMM,
+  timeOptions: () => timeOptions,
+  timeOptionsWithoutMeridiem: () => timeOptionsWithoutMeridiem,
+  timeUnitInputValueSchema: () => timeUnitInputValueSchema,
+  toTitleCase: () => toTitleCase,
+  truncateAddress: () => truncateAddress,
+  usdCurrencyMaskOptions: () => usdCurrencyMaskOptions,
+  uuidMaskOptions: () => uuidMaskOptions,
+  validateIso8601Date: () => validateIso8601Date
+});
+module.exports = __toCommonJS(helpers_exports);
+
+// src/helpers/address.ts
+var areAddressesEqual = (address1, address2) => {
+  if (!address1 || !address2) return false;
+  return address1.toLowerCase() === address2.toLowerCase();
+};
+
+// src/helpers/blockchain.ts
+var import_viem = require("viem");
+var truncateAddress = (address) => {
+  if (!address) return "";
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+};
+var ETHEREUM_ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
+var isValidEthereumAddress = (address) => {
+  return ETHEREUM_ADDRESS_REGEX.test(address);
+};
+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 };
+};
+var getChainRpcUrl = (chainId, chains) => {
+  const chain = chains.find((chain2) => chain2.id === chainId);
+  return chain?.rpcUrls.default;
+};
+var DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
+var isNullAddress = (address) => {
+  return (0, import_viem.isAddressEqual)(address, DEFAULT_ADDRESS);
+};
+
+// src/helpers/date.ts
+var import_zod = __toESM(require("zod"));
+
+// src/env.ts
+var BUILD_MODE = "development";
+
+// src/helpers/logger.ts
+var Logger = class {
+  constructor() {
+    __publicField(this, "isDevelopment", BUILD_MODE === "development");
+  }
+  debug(message, options) {
+    if (this.isDevelopment) {
+      this.log("debug", message, options);
+    }
+  }
+  info(message, options) {
+    this.log("info", message, options);
+  }
+  warn(message, options) {
+    this.log("warn", message, options);
+  }
+  error(message, options) {
+    this.log("error", message, options);
+  }
+  /**
+   * Log errors with context - useful for non-API errors
+   * For API errors, use the existing getErrorMessage from @otim/utils/api
+   */
+  logError(error, options = {}) {
+    const { context, operation, metadata } = options;
+    const prefix = this.buildPrefix(context, operation);
+    let message = "Unknown error";
+    if (error instanceof Error) {
+      message = error.message;
+    } else if (typeof error === "string") {
+      message = error;
+    } else if (error && typeof error === "object" && "message" in error) {
+      message = String(error.message);
+    }
+    console.error(prefix ? `${prefix} ${message}` : message);
+    if (metadata && Object.keys(metadata).length > 0) {
+      console.error("Context:", metadata);
+    }
+    if (error instanceof Error && error.stack) {
+      console.error("Stack:", error.stack);
+    } else {
+      console.error("Error details:", error);
+    }
+  }
+  buildPrefix(context, operation) {
+    const parts = [];
+    if (context) parts.push(`[${context}]`);
+    if (operation) parts.push(`[${operation}]`);
+    return parts.join(" ");
+  }
+  log(level, message, options) {
+    const prefix = options?.context ? `[${options.context}]` : "";
+    const fullMessage = `${prefix} ${message}`.trim();
+    switch (level) {
+      case "debug":
+      case "info":
+        console.log(fullMessage);
+        break;
+      case "warn":
+        console.warn(fullMessage);
+        break;
+      case "error":
+        console.error(fullMessage);
+        break;
+    }
+    if (options?.data) {
+      console.dir(options.data, { depth: null });
+    }
+  }
+};
+var logger = new Logger();
+
+// src/helpers/date.ts
+var iso8601DateSchema = import_zod.default.string().regex(
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/,
+  "Must be a valid ISO 8601 date format (e.g., 2024-12-31T23:59:59.000Z)"
+);
+var TimeUnit = {
+  Day: "day",
+  Month: "month",
+  Year: "year"
+};
+var units = {
+  [TimeUnit.Day]: {
+    one: "day",
+    other: "days"
+  },
+  [TimeUnit.Month]: {
+    one: "month",
+    other: "months"
+  },
+  [TimeUnit.Year]: {
+    one: "year",
+    other: "years"
+  }
+};
+var formatDateAsUSStandard = (date, opts) => date.toLocaleString("en-US", {
+  month: "2-digit",
+  day: "2-digit",
+  year: "numeric",
+  ...opts
+});
+var formatDateAsISO = (date) => date.toISOString();
+var formatFullDate = (date) => {
+  const options = {
+    year: "numeric",
+    month: "long",
+    day: "2-digit",
+    timeZone: "UTC"
+  };
+  return new Intl.DateTimeFormat("en-US", options).format(date);
+};
+var formatTime = (date) => {
+  return date.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    timeZone: "UTC",
+    timeZoneName: "short"
+  });
+};
+var formatDateTime = (date) => {
+  const dateOptions = {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    timeZone: "UTC"
+  };
+  const timeOptions2 = {
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZone: "UTC"
+  };
+  const formattedDate = new Intl.DateTimeFormat("en-US", dateOptions).format(
+    date
+  );
+  const formattedTime = new Intl.DateTimeFormat("en-US", timeOptions2).format(
+    date
+  );
+  return `${formattedDate} at ${formattedTime}`;
+};
+var formatLongDate = (date) => {
+  const options = {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    timeZone: "UTC"
+  };
+  return new Intl.DateTimeFormat("en-US", options).format(date);
+};
+var formatLongDateTime = (date) => {
+  const dateOptions = {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    timeZone: "UTC"
+  };
+  const timeOptions2 = {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: true,
+    timeZone: "UTC"
+  };
+  const formattedDate = new Intl.DateTimeFormat("en-US", dateOptions).format(
+    date
+  );
+  const formattedTime = new Intl.DateTimeFormat("en-US", timeOptions2).format(date).toLowerCase();
+  return `${formattedDate} at ${formattedTime}`;
+};
+var formatToShortDate = (dateString) => {
+  const date = typeof dateString === "string" ? new Date(dateString) : dateString;
+  if (isNaN(date.getTime())) {
+    return "Jan 1";
+  }
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    timeZone: "UTC"
+  });
+};
+var formatToShortDateWithYear = (dateString) => {
+  const date = typeof dateString === "string" ? new Date(dateString) : dateString;
+  if (isNaN(date.getTime())) {
+    return "Unknown";
+  }
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    timeZone: "UTC"
+  });
+};
+var formatToJustDate = (dateString) => {
+  const date = new Date(dateString);
+  if (isNaN(date.getTime())) {
+    return "1";
+  }
+  return date.getUTCDate().toString();
+};
+var formatDateToYYYYMMDD = (date) => {
+  return new Intl.DateTimeFormat("en-CA", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(date);
+};
+var isDateInvalid = (date) => {
+  return date.toString() === "Invalid Date";
+};
+var isValidDate = (date) => {
+  return !isDateInvalid(date) && !isNaN(date.getTime());
+};
+var isDateEpoc = (date) => {
+  return date.getTime() <= 0;
+};
+var isDateInRange = (arg) => {
+  if (typeof arg !== "string") {
+    return false;
+  }
+  const date = new Date(arg);
+  const startDate = /* @__PURE__ */ new Date("1800-01-01T00:00:00.000Z");
+  const endDate = /* @__PURE__ */ new Date("2999-12-31T23:59:59.999Z");
+  return date >= startDate && date <= endDate;
+};
+var isDateInPast = (input) => {
+  let date;
+  if (input instanceof Date) {
+    date = input;
+  } else if (typeof input === "number") {
+    const ms = input < 1e12 ? input * 1e3 : input;
+    date = new Date(ms);
+  } else {
+    date = new Date(input);
+  }
+  if (isNaN(date.getTime())) {
+    return false;
+  }
+  return date.getTime() < Date.now();
+};
+var isSameDate = (dateA, dateB) => {
+  return dateA.getFullYear() === dateB.getFullYear() && dateA.getMonth() === dateB.getMonth() && dateA.getDate() === dateB.getDate();
+};
+var getPluralizedUnit = (unit, count, locale = "en") => {
+  const pluralRules = new Intl.PluralRules(locale, {
+    type: "cardinal"
+  });
+  const pluralCategory = pluralRules.select(count);
+  if (pluralCategory === "one" || pluralCategory === "other") {
+    return `${count} ${units[unit][pluralCategory]}`;
+  }
+  return `${count} ${units[unit].other}`;
+};
+var getRelativeDateDescription = (targetDate, locale = "en") => {
+  const currentDate = /* @__PURE__ */ new Date();
+  const oneDay = 1e3 * 60 * 60 * 24;
+  const oneMonth = oneDay * 30;
+  const oneYear = oneDay * 365;
+  const diffInMilliseconds = targetDate.getTime() - currentDate.getTime();
+  const diffInDays = Math.round(diffInMilliseconds / oneDay);
+  const diffInMonths = Math.round(diffInMilliseconds / oneMonth);
+  const diffInYears = Math.round(diffInMilliseconds / oneYear);
+  if (Math.abs(diffInYears) >= 1) {
+    return getPluralizedUnit("year", Math.abs(diffInYears), locale);
+  }
+  if (Math.abs(diffInMonths) >= 1) {
+    return getPluralizedUnit("month", Math.abs(diffInMonths), locale);
+  }
+  return getPluralizedUnit("day", Math.abs(diffInDays), locale);
+};
+var safeFormatDate = (date, formatter, fallback) => {
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+  if (!isValidDate(dateObj)) {
+    return fallback;
+  }
+  try {
+    return formatter(dateObj);
+  } catch (error) {
+    logger.logError(error, {
+      context: safeFormatDate.name
+    });
+    return fallback;
+  }
+};
+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;
+};
+var validateIso8601Date = (dueDate) => {
+  const result = iso8601DateSchema.safeParse(dueDate);
+  if (!result.success) {
+    const errorMessage = result.error.issues[0]?.message || "Invalid ISO 8601 format";
+    throw new Error(`Invalid due date format: ${errorMessage}`);
+  }
+};
+
+// src/helpers/datetime.ts
+var import_zod4 = require("zod");
+
+// src/schemas/instruction.ts
+var import_zod3 = require("zod");
+
+// src/schemas/misc.ts
+var import_zod2 = 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_zod2.z.string().regex(regex, message);
+var nonEmptyStringSchema = import_zod2.z.string().min(1);
+var numberSchema = import_zod2.z.union([
+  import_zod2.z.number().finite(),
+  import_zod2.z.string().regex(/^-?\d*\.?\d+(?:[eE][-+]?\d+)?$/).transform(Number)
+]);
+var decimalStringSchema = import_zod2.z.string().regex(/^-?\d*\.?\d+$/).refine((val) => !isNaN(parseFloat(val)), {
+  message: "Must be a valid decimal number"
+});
+var bigintSchema = import_zod2.z.union([
+  import_zod2.z.bigint(),
+  import_zod2.z.string().regex(/^-?\d+$/).transform(BigInt)
+]);
+var hexStringSchema = import_zod2.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_zod2.z.object({
+  v: import_zod2.z.number(),
+  r: import_zod2.z.string(),
+  s: import_zod2.z.string()
+});
+var eip2098SignatureSchema = import_zod2.z.object({
+  yParity: import_zod2.z.number(),
+  r: import_zod2.z.string(),
+  s: import_zod2.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_zod3.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_zod3.z.enum(instructionActionValues);
+var InstructionScheduleStartType = {
+  Now: "now",
+  DateTime: "datetime"
+};
+var instructionScheduleStartValues = Object.values(
+  InstructionScheduleStartType
+);
+var baseStartSchema = import_zod3.z.object({
+  type: import_zod3.z.enum(instructionScheduleStartValues)
+});
+var nowStartSchema = baseStartSchema.extend({
+  type: import_zod3.z.literal(InstructionScheduleStartType.Now)
+});
+var dateTimeStartSchema = baseStartSchema.extend({
+  type: import_zod3.z.literal(InstructionScheduleStartType.DateTime),
+  startDate: dateStandardSchema,
+  startTime: import_zod3.z.string()
+});
+var instructionScheduleStartSchema = import_zod3.z.discriminatedUnion("type", [
+  nowStartSchema,
+  dateTimeStartSchema
+]);
+var InstructionScheduleRepeatType = {
+  UntilDeactivated: "until-deactivated",
+  MaxExecutions: "max-executions"
+};
+var instructionScheduleRepeatValues = Object.values(
+  InstructionScheduleRepeatType
+);
+var baseRepeatSchema = import_zod3.z.object({});
+var untilDeactivatedRepeatSchema = baseRepeatSchema.extend({
+  type: import_zod3.z.literal(InstructionScheduleRepeatType.UntilDeactivated)
+});
+var maxExecutionsRepeatSchema = baseRepeatSchema.extend({
+  type: import_zod3.z.literal(InstructionScheduleRepeatType.MaxExecutions),
+  maxExecutions: numberSchema
+});
+var instructionScheduleRepeatSchema = import_zod3.z.discriminatedUnion("type", [
+  untilDeactivatedRepeatSchema,
+  maxExecutionsRepeatSchema
+]);
+var InstructionScheduleRetryType = {
+  UntilDeactivated: "until-deactivated",
+  TimeLimited: "time-limited"
+};
+var instructionScheduleRetryValues = Object.values(
+  InstructionScheduleRetryType
+);
+var baseRetrySchema = import_zod3.z.object({});
+var untilDeactivatedRetrySchema = baseRetrySchema.extend({
+  type: import_zod3.z.literal(InstructionScheduleRetryType.UntilDeactivated)
+});
+var timeLimitedRetrySchema = baseRetrySchema.extend({
+  type: import_zod3.z.literal(InstructionScheduleRetryType.TimeLimited),
+  retryCount: numberSchema
+});
+var instructionScheduleRetrySchema = import_zod3.z.discriminatedUnion("type", [
+  untilDeactivatedRetrySchema,
+  timeLimitedRetrySchema
+]);
+var TimeUnit2 = {
+  None: "none",
+  Second: "second",
+  Minute: "minute",
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var timeUnitValues = Object.values(TimeUnit2);
+var timeUnitSchema = import_zod3.z.enum(timeUnitValues);
+var instructionExecutionStateSchema = import_zod3.z.object({
+  executionStatus: instructionStateSchema.optional(),
+  executionCounter: import_zod3.z.number().int().optional(),
+  lastExecuted: import_zod3.z.number().int().optional()
+});
+var instructionSchema = import_zod3.z.object({
+  instructionId: hexStringSchema,
+  createdAt: import_zod3.z.number().optional(),
+  startAt: import_zod3.z.string().nullish(),
+  interval: import_zod3.z.number().nullish(),
+  timeout: import_zod3.z.number().nullish(),
+  maxExecutions: import_zod3.z.number().nullish(),
+  executionState: instructionExecutionStateSchema.optional(),
+  actionName: import_zod3.z.string().optional(),
+  arguments: import_zod3.z.any(),
+  nickname: import_zod3.z.string().nullish(),
+  lastInstructedValue: import_zod3.z.string().optional(),
+  lastErrorCode: import_zod3.z.number().nullish(),
+  lastErrorMessage: import_zod3.z.string().nullish(),
+  totalInstructedValue: import_zod3.z.string().optional(),
+  instructedTokenAddress: hexStringSchema.nullish(),
+  chainId: import_zod3.z.number().nullish(),
+  chain: import_zod3.z.string().optional()
+});
+var instructionsSchema = import_zod3.z.array(instructionSchema);
+var instructionSummarySchema = import_zod3.z.object({
+  instructionId: hexStringSchema,
+  chainId: import_zod3.z.number().int(),
+  executionCount: import_zod3.z.number().int(),
+  onTimeCount: import_zod3.z.number().int(),
+  lateCount: import_zod3.z.number().int(),
+  wasActivatedDuring: import_zod3.z.boolean(),
+  amount: import_zod3.z.number().default(0),
+  instructedValue: import_zod3.z.string().nullish().default("0"),
+  instructedTokenAddress: import_zod3.z.string().nullish().default(null)
+});
+var instructionSummariesSchema = import_zod3.z.array(instructionSummarySchema);
+var instructionSummariesByDateSchema = import_zod3.z.record(
+  import_zod3.z.string(),
+  instructionSummariesSchema
+);
+var InstructionViewTimescale = {
+  Days: "days",
+  Hours: "hours",
+  Minutes: "minutes",
+  Seconds: "seconds"
+};
+var instructionViewTimescaleValues = Object.values(
+  InstructionViewTimescale
+);
+
+// src/helpers/datetime.ts
+var timeUnitInputValueSchema = import_zod4.z.object({
+  unit: timeUnitSchema,
+  value: import_zod4.z.number().finite(),
+  seconds: import_zod4.z.number().finite()
+});
+var isTimeUnitInputValue = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return "unit" in obj && "value" in obj && "seconds" in obj && typeof obj.unit === "string" && typeof obj.value === "number" && typeof obj.seconds === "number";
+};
+var parseJsonToTimeUnitValue = (jsonString) => {
+  try {
+    const parsed = JSON.parse(jsonString);
+    return isTimeUnitInputValue(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var parseTimeUnitValue = (value) => {
+  if (!value) return void 0;
+  if (isTimeUnitInputValue(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return parseJsonToTimeUnitValue(value);
+  }
+  return void 0;
+};
+var serializeTimeUnitValue = (value) => {
+  return JSON.stringify(value);
+};
+var isValidTimeUnitValue = (value) => {
+  return parseTimeUnitValue(value) !== void 0;
+};
+var getSecondsFromTimeUnitValue = (value) => {
+  const parsed = parseTimeUnitValue(value);
+  return parsed?.seconds ?? 0;
+};
+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;
+};
+function parseDateTimeStrict(date, time) {
+  try {
+    const parts = date?.split("/") ?? [];
+    const month = Number(parts[0]);
+    const day = Number(parts[1]);
+    const year = Number(parts[2]);
+    const timeParts = time?.split(" ") ?? [];
+    const timePart = timeParts[0] ?? "00:00:00";
+    const ampm = timeParts[1] ?? "AM";
+    const [hoursStr, minutesStr, secondsStr] = timePart.split(":");
+    let hours = Number(hoursStr ?? 0);
+    const minutes = Number(minutesStr ?? 0);
+    const seconds = Number(secondsStr ?? 0);
+    if (ampm === "PM" && hours < 12) hours += 12;
+    if (ampm === "AM" && hours === 12) hours = 0;
+    const dt = new Date(
+      year || 0,
+      (month || 1) - 1,
+      day || 1,
+      hours,
+      minutes,
+      seconds
+    );
+    return isNaN(dt.getTime()) ? null : dt;
+  } catch {
+    return null;
+  }
+}
+
+// src/helpers/domain.ts
+function getBaseDomain(hostname) {
+  if (hostname.includes("localhost")) {
+    return hostname;
+  }
+  const parts = hostname.split(".");
+  if (parts.length < 2) {
+    return hostname;
+  }
+  if (parts.length === 2) {
+    return hostname;
+  }
+  const lastTwoParts = parts.slice(-2).join(".");
+  const traditionalMultiPartTlds = [
+    "co.uk",
+    "com.au",
+    "co.jp",
+    "co.kr",
+    "co.za",
+    "co.in",
+    "com.br",
+    "com.mx",
+    "com.ar",
+    "com.cn",
+    "com.tw",
+    "org.uk",
+    "net.uk",
+    "ac.uk",
+    "gov.uk"
+  ];
+  if (traditionalMultiPartTlds.includes(lastTwoParts)) {
+    return parts.slice(-3).join(".");
+  }
+  const deploymentTlds = [
+    "vercel.app",
+    "netlify.app",
+    "github.io",
+    "gitlab.io"
+  ];
+  if (deploymentTlds.includes(lastTwoParts)) {
+    return hostname;
+  }
+  return parts.slice(-2).join(".");
+}
+
+// src/helpers/intl.ts
+var import_zod5 = require("zod");
+var locales = ["en", "es"];
+var i18n = {
+  defaultLocale: "en",
+  locales: [...locales]
+};
+var localeSchema = import_zod5.z.enum(locales);
+var formattedNumber = (num) => {
+  if (!Number.isFinite(num)) {
+    return "0";
+  }
+  return num.toLocaleString("en-US");
+};
+var formatCurrency = (amount, options) => {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+    ...options
+  }).format(amount);
+};
+
+// src/helpers/mask-options.ts
+var import_kit = require("@maskito/kit");
+var SHORT_FORM_POSTAL_MASK = [/\d/, /\d/, /\d/, /\d/, /\d/];
+var LONG_FORM_POSTAL_MASK = [
+  /\d/,
+  /\d/,
+  /\d/,
+  /\d/,
+  /\d/,
+  "-",
+  /\d/,
+  /\d/,
+  /\d/,
+  /\d/
+];
+var postalCodeMaskOptions = {
+  mask: (state) => {
+    return state.value.length > 5 ? LONG_FORM_POSTAL_MASK : SHORT_FORM_POSTAL_MASK;
+  }
+};
+var dateMaskOptions = (0, import_kit.maskitoDateOptionsGenerator)({
+  mode: "mm/dd/yyyy",
+  separator: "/"
+});
+var timeOptions = (0, import_kit.maskitoTimeOptionsGenerator)({
+  mode: "HH:MM:SS AA"
+});
+var timeOptionsWithoutMeridiem = (0, import_kit.maskitoTimeOptionsGenerator)({
+  mode: "HH:MM:SS"
+});
+var timeMaskOptionsHHMM = (0, import_kit.maskitoTimeOptionsGenerator)({
+  mode: "HH:MM"
+});
+var formatUUID = (value) => {
+  if (!value) {
+    return "";
+  }
+  const cleanValue = value.replace(/[^0-9a-f-]/gi, "");
+  const hexOnly = cleanValue.replace(/-/g, "");
+  const limitedHex = hexOnly.slice(0, 32);
+  if (limitedHex.length === 32) {
+    return [
+      limitedHex.slice(0, 8),
+      limitedHex.slice(8, 12),
+      limitedHex.slice(12, 16),
+      limitedHex.slice(16, 20),
+      limitedHex.slice(20, 32)
+    ].join("-");
+  }
+  let formatted = "";
+  let index = 0;
+  if (index < limitedHex.length) {
+    const group1 = limitedHex.slice(
+      index,
+      Math.min(index + 8, limitedHex.length)
+    );
+    formatted += group1;
+    index += 8;
+    if (index <= limitedHex.length && group1.length === 8) {
+      formatted += "-";
+    }
+  }
+  if (index < limitedHex.length) {
+    const group2 = limitedHex.slice(
+      index,
+      Math.min(index + 4, limitedHex.length)
+    );
+    formatted += group2;
+    index += 4;
+    if (index <= limitedHex.length && group2.length === 4) {
+      formatted += "-";
+    }
+  }
+  if (index < limitedHex.length) {
+    const group3 = limitedHex.slice(
+      index,
+      Math.min(index + 4, limitedHex.length)
+    );
+    formatted += group3;
+    index += 4;
+    if (index <= limitedHex.length && group3.length === 4) {
+      formatted += "-";
+    }
+  }
+  if (index < limitedHex.length) {
+    const group4 = limitedHex.slice(
+      index,
+      Math.min(index + 4, limitedHex.length)
+    );
+    formatted += group4;
+    index += 4;
+    if (index <= limitedHex.length && group4.length === 4) {
+      formatted += "-";
+    }
+  }
+  if (index < limitedHex.length) {
+    formatted += limitedHex.slice(
+      index,
+      Math.min(index + 12, limitedHex.length)
+    );
+  }
+  return formatted;
+};
+var uuidMaskOptions = {
+  mask: /^[0-9a-f-]*$/i
+};
+var usdCurrencyMaskOptions = {
+  mask: /^[0-9., $]*$/,
+  postprocessors: [
+    (state) => {
+      const selectionEnd = state.selection?.[1] ?? state.value.length;
+      const numeric = state.value.replace(/[^0-9]/g, "");
+      if (numeric.length === 0) {
+        return { ...state, value: "", selection: [0, 0] };
+      }
+      const clamped = numeric.slice(0, 11);
+      const amount = Number(clamped) / 100;
+      const formatted = amount.toLocaleString("en-US", {
+        style: "currency",
+        currency: "USD",
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2
+      });
+      const nextCaret = Math.min(
+        formatted.length,
+        selectionEnd + (formatted.length - state.value.length)
+      );
+      return { ...state, value: formatted, selection: [nextCaret, nextCaret] };
+    }
+  ]
+};
+
+// src/helpers/num-formatter.ts
+var numFormatter = (num, round) => {
+  if (num >= 1e3 && num < 1e6) {
+    return `${(num / 1e3).toFixed(typeof round === "number" ? round : num % 1e3 === 0 ? 0 : 1)}K`;
+  }
+  if (num >= 1e6 && num < 1e9) {
+    return `${(num / 1e6).toFixed(typeof round === "number" ? round : num % 1e6 === 0 ? 0 : 2)}M`;
+  }
+  if (num > 1e9) {
+    return `${(num / 1e9).toFixed(typeof round === "number" ? round : num % 1e9 === 0 ? 0 : 2)}B`;
+  }
+  return Number(
+    Number(num).toFixed(
+      typeof round === "number" ? round : num * 100 % 100 === 0 ? 0 : 2
+    )
+  );
+};
+var formatNumberAsUSStandard = (num) => {
+  return num.toLocaleString("en-US", {
+    maximumSignificantDigits: 3
+  });
+};
+
+// src/helpers/window.ts
+var isClient = () => typeof globalThis !== "undefined" && "window" in globalThis;
+var DEFAULT_EMERGENT_WINDOW_CONFIG = {
+  width: 480,
+  height: 720,
+  name: "emergent_window"
+};
+function openCenteredEmergentWindow(url, config = {}) {
+  if (!isClient()) {
+    return null;
+  }
+  const { width, height, name } = {
+    ...DEFAULT_EMERGENT_WINDOW_CONFIG,
+    ...config
+  };
+  const screenLeft = window.screenLeft ?? window.screenX ?? 0;
+  const screenTop = window.screenTop ?? window.screenY ?? 0;
+  const viewportWidth = window.innerWidth || document.documentElement.clientWidth || screen.width;
+  const viewportHeight = window.innerHeight || document.documentElement.clientHeight || screen.height;
+  const left = Math.max(0, screenLeft + (viewportWidth - width) / 2);
+  const top = Math.max(0, screenTop + (viewportHeight - height) / 2);
+  const features = [
+    "noopener",
+    "noreferrer",
+    `width=${width}`,
+    `height=${height}`,
+    `left=${left}`,
+    `top=${top}`,
+    "menubar=no",
+    "toolbar=no",
+    "location=no",
+    "status=no",
+    "scrollbars=yes"
+  ].join(",");
+  const emergentWindow = window.open(url, name, features);
+  try {
+    emergentWindow?.focus();
+  } catch (error) {
+    logger.logError(error, {
+      context: openCenteredEmergentWindow.name
+    });
+  }
+  return emergentWindow ?? null;
+}
+function closeEmergentWindow(emergentWindow) {
+  if (!emergentWindow) return;
+  try {
+    emergentWindow.close();
+  } catch (error) {
+    logger.logError(error, {
+      context: closeEmergentWindow.name
+    });
+  }
+}
+function focusMainWindow() {
+  if (!isClient()) return;
+  try {
+    window.focus();
+  } catch (error) {
+    logger.logError(error, {
+      context: focusMainWindow.name
+    });
+  }
+}
+function performRedirect(path, fallbackPath = "/") {
+  if (!isClient()) return;
+  const redirectPath = path || fallbackPath;
+  window.location.href = redirectPath;
+}
+
+// src/helpers/polling.ts
+var DEFAULT_POLLING_CONFIG = {
+  intervalMs: 1e3,
+  onComplete: () => {
+  }
+};
+var PollingManager = class {
+  constructor(config = {}) {
+    __publicField(this, "emergentWindow", null);
+    __publicField(this, "pollIntervalId", null);
+    __publicField(this, "config");
+    this.config = { ...DEFAULT_POLLING_CONFIG, ...config };
+  }
+  /**
+   * Starts polling for the given check function
+   *
+   * @param emergentWindow - The emergent window to monitor (optional)
+   * @param checkFn - Function that returns true when polling should stop
+   */
+  start(emergentWindow, checkFn) {
+    this.emergentWindow = emergentWindow;
+    this.stop();
+    this.pollIntervalId = window.setInterval(() => {
+      void (async () => {
+        try {
+          const isComplete = await checkFn();
+          if (isComplete) {
+            this.finalize();
+            this.config.onComplete();
+          }
+        } catch (error) {
+          logger.logError(error, {
+            context: this.start.name
+          });
+        }
+      })();
+    }, this.config.intervalMs);
+  }
+  /**
+   * Stops polling and cleans up resources
+   */
+  stop() {
+    if (this.pollIntervalId !== null) {
+      clearInterval(this.pollIntervalId);
+      this.pollIntervalId = null;
+    }
+  }
+  /**
+   * Finalizes polling by closing emergent window, stopping interval, and returning focus
+   */
+  finalize() {
+    closeEmergentWindow(this.emergentWindow);
+    this.emergentWindow = null;
+    this.stop();
+    focusMainWindow();
+  }
+  /**
+   * Cleans up resources
+   */
+  dispose() {
+    this.finalize();
+  }
+};
+
+// src/helpers/random.ts
+var randomNumber = (opts) => {
+  const { value, min, max } = opts;
+  let hash = 0;
+  for (let i = 0; i < value.length; i++) {
+    hash = (hash << 5) - hash + value.charCodeAt(i);
+    hash |= 0;
+  }
+  const normalizedHash = Math.abs(hash);
+  return Math.floor(normalizedHash % (max - min + 1)) + min;
+};
+
+// src/helpers/sdk-loader.ts
+var DEFAULT_SDK_TIMEOUT = 1e4;
+async function loadExternalSdk(config) {
+  if (typeof window === "undefined") {
+    throw new Error(`${config.name} SDK can only be loaded in the browser`);
+  }
+  const timeout = config.timeout ?? DEFAULT_SDK_TIMEOUT;
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(
+        new Error(`${config.name} SDK loading timed out after ${timeout}ms`)
+      );
+    }, timeout);
+    const script = document.createElement("script");
+    script.src = config.src;
+    script.async = true;
+    script.onload = () => {
+      clearTimeout(timeoutId);
+      resolve();
+    };
+    script.onerror = () => {
+      clearTimeout(timeoutId);
+      reject(new Error(`Failed to load ${config.name} SDK from ${config.src}`));
+    };
+    document.body.appendChild(script);
+  });
+}
+function isScriptLoaded(src) {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  const scripts = document.getElementsByTagName("script");
+  for (let i = 0; i < scripts.length; i++) {
+    if (scripts[i]?.src === src) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/helpers/signatures.ts
+var formatSignatureToEIP2098 = (signature) => {
+  const ensureHexPrefix = (value) => value.startsWith("0x") ? value : `0x${value}`;
+  const vNum = Number.parseInt(signature.v, 16);
+  const yParity = (() => {
+    if (Number.isNaN(vNum)) return 0;
+    if (vNum <= 1) return vNum;
+    return vNum % 2 === 0 ? 1 : 0;
+  })();
+  return {
+    yParity,
+    r: ensureHexPrefix(signature.r),
+    s: ensureHexPrefix(signature.s)
+  };
+};
+
+// src/helpers/string.ts
+var capitalize = (str) => {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var toTitleCase = (str) => {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+
+// src/helpers/types.ts
+var isError = (value) => value instanceof Error;
+var isFunction = (value) => typeof value === "function";
+var isObject = (value) => typeof value === "object" && value !== null;
+var isNumber = (value) => typeof value === "number";
+var isString = (value) => typeof value === "string";
+var isUndefined = (value) => typeof value === "undefined";
+var isBoolean = (value) => typeof value === "boolean";
+var extractString = (value, fallback) => {
+  return isString(value) ? value : fallback;
+};
+var extractNumber = (value) => {
+  if (isNumber(value)) {
+    return value;
+  }
+  if (isString(value)) {
+    const parsed = Number.parseFloat(value);
+    return Number.isNaN(parsed) ? void 0 : parsed;
+  }
+  return void 0;
+};
+
+// src/helpers/url.ts
+function buildQueryString(params) {
+  const usp = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === void 0 || value === null) return;
+    usp.set(key, String(value));
+  });
+  const qs = usp.toString();
+  return qs ? `?${qs}` : "";
+}
+function buildUrl(path, params) {
+  const qs = params ? buildQueryString(params) : "";
+  return `${path}${qs}`;
+}
+
+// src/helpers/zod.ts
+var import_zod6 = require("zod");
+var composeValidators = (validators) => {
+  return (data, ctx) => {
+    for (const validator of validators) {
+      validator(data, ctx);
+    }
+  };
+};
+var secondsToHumanReadable = (seconds) => {
+  if (seconds >= 3600) {
+    const hours = seconds / 3600;
+    const roundedHours = Math.round(hours * 10) / 10;
+    return roundedHours === 1 ? "1 hour" : `${roundedHours} hours`;
+  } else if (seconds >= 60) {
+    const minutes = seconds / 60;
+    const roundedMinutes = Math.round(minutes * 10) / 10;
+    return roundedMinutes === 1 ? "1 minute" : `${roundedMinutes} minutes`;
+  } else {
+    return seconds === 1 ? "1 second" : `${seconds} seconds`;
+  }
+};
+var createTimeUnitValidator = (fieldName, options = {}) => {
+  const {
+    minSeconds = 60,
+    allowZero = false,
+    useHumanReadable = true
+  } = options;
+  return import_zod6.z.string().optional().refine(
+    (value) => {
+      if (!value) return true;
+      const parsed = parseTimeUnitValue(value);
+      if (!parsed) return false;
+      const seconds = getSecondsFromTimeUnitValue(parsed);
+      return allowZero ? seconds >= 0 : seconds >= minSeconds;
+    },
+    {
+      message: useHumanReadable ? `${fieldName} must be at least ${secondsToHumanReadable(minSeconds)}` : `${fieldName} must be at least ${minSeconds} seconds`
+    }
+  );
+};
+var parseSchema = (values, schema) => {
+  const inputValues = schema.safeParse(values);
+  if (!inputValues.success) {
+    throw new Error(
+      `parseSchema: invalid input values ${JSON.stringify(inputValues.error)}`
+    );
+  }
+  return inputValues.data;
+};
+//# sourceMappingURL=index.js.map