@otim/utils 0.0.4 → 0.0.6

package/dist/helpers-DoC7Xl12.js

@@ -0,0 +1,1291 @@
+const require_chunk = require('./chunk-kSYXY2_d.js');
+const require_defineProperty = require('./defineProperty-DbMdhrDE.js');
+const require_date = require('./date-CFzrYcjE.js');
+let zod = require("zod");
+let _otim_utils_schemas = require("@otim/utils/schemas");
+let viem = require("viem");
+let _maskito_kit = require("@maskito/kit");
+
+//#region src/helpers/address.ts
+/**
+* Check if two addresses are equal (case-insensitive)
+* Works with Ethereum addresses and other blockchain addresses
+*/
+const areAddressesEqual = (address1, address2) => {
+	if (!address1 || !address2) return false;
+	return address1.toLowerCase() === address2.toLowerCase();
+};
+
+//#endregion
+//#region src/helpers/activity.ts
+function isTransferActivity(activity) {
+	return "transfer" in activity;
+}
+function isSwapActivity(activity) {
+	return "swap" in activity;
+}
+function isCctpBurnActivity(activity) {
+	return "cctpBurn" in activity;
+}
+function isErc4626DepositActivity(activity) {
+	return "erc4626Deposit" in activity;
+}
+function isErc4626WithdrawActivity(activity) {
+	return "erc4626Withdraw" in activity;
+}
+function extractBaseActivityDetails(activity) {
+	if (isTransferActivity(activity)) return {
+		from: activity.transfer.from,
+		to: activity.transfer.to,
+		amount: activity.transfer.value,
+		token: activity.transfer.token
+	};
+	if (isSwapActivity(activity)) return {
+		from: activity.swap.from,
+		to: activity.swap.to,
+		amount: activity.swap.fromAmount,
+		token: activity.swap.fromToken
+	};
+	if (isCctpBurnActivity(activity)) return {
+		from: activity.cctpBurn.from,
+		to: activity.cctpBurn.mintRecipient,
+		amount: activity.cctpBurn.value,
+		token: activity.cctpBurn.token
+	};
+	if (isErc4626DepositActivity(activity)) return {
+		from: activity.erc4626Deposit.from,
+		to: activity.erc4626Deposit.vault,
+		amount: activity.erc4626Deposit.value,
+		token: activity.erc4626Deposit.token
+	};
+	if (isErc4626WithdrawActivity(activity)) return {
+		from: activity.erc4626Withdraw.from,
+		to: activity.erc4626Withdraw.to,
+		amount: activity.erc4626Withdraw.value,
+		token: activity.erc4626Withdraw.token
+	};
+	return {
+		from: "0x0",
+		to: "0x0",
+		amount: "0",
+		token: "0x0"
+	};
+}
+/**
+* Converts a Unix timestamp (seconds) to an ISO date string.
+*
+* @param timestamp - Unix timestamp in seconds
+* @returns ISO date string
+*/
+function timestampToISOString(timestamp) {
+	return (/* @__PURE__ */ new Date(timestamp * 1e3)).toISOString();
+}
+
+//#endregion
+//#region src/helpers/blockchain.ts
+const truncateAddress = (address) => {
+	if (!address) return "";
+	return `${address.slice(0, 6)}...${address.slice(-4)}`;
+};
+/**
+* Ethereum address regex pattern
+* Matches addresses like 0x1234...abcd (40 hex characters after 0x prefix)
+*/
+const ETHEREUM_ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
+/**
+* Validates if a string is a valid Ethereum address format
+* @param address - The address string to validate
+* @returns true if the address matches the Ethereum address format
+*/
+const isValidEthereumAddress = (address) => {
+	return ETHEREUM_ADDRESS_REGEX.test(address);
+};
+/**
+* Parses a signature string into its v, r, s components.
+* @param signature - The signature string to parse (must be 0x-prefixed, 132 chars total)
+* @returns VRS object containing v, r, and s values
+*/
+const 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);
+	return {
+		v: parseInt(vHex, 16),
+		r: `0x${r}`,
+		s: `0x${s}`
+	};
+};
+const isValidV = (v) => {
+	return v === 0 || v === 1 || v === 27 || v === 28 || v >= 35;
+};
+const normalizeV = (v) => {
+	if (!isValidV(v)) return 0;
+	const cmp = v <= 1 ? 1 : 0;
+	const result = v % 2 === cmp;
+	return Number(result) % 2;
+};
+/**
+* Creates an EIP-2098 compact signature from VRS components.
+* @param vrs - The VRS signature components
+* @returns EIP2098Signature object with yParity, r, and s
+*/
+const createEIP2098Signature = (vrs) => {
+	const v = vrs.v;
+	const r = vrs.r;
+	const s = vrs.s;
+	return {
+		yParity: normalizeV(v),
+		r,
+		s
+	};
+};
+const getChainRpcUrl = (chainId, chains) => {
+	return chains.find((chain) => chain.id === chainId)?.rpcUrls.default;
+};
+const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
+const isNullAddress = (address) => {
+	return (0, viem.isAddressEqual)(address, DEFAULT_ADDRESS);
+};
+/**
+* Parses a hex amount string with decimals into a number.
+*
+* @param hexAmount - The hex string (e.g. "0x...")
+* @param decimals - Token decimals
+* @returns The parsed number
+*/
+function parseHexAmount(hexAmount, decimals) {
+	try {
+		const value = BigInt(hexAmount);
+		return Number(value) / 10 ** decimals;
+	} catch (error) {
+		console.warn(`Failed to parse hex amount: ${hexAmount}`, error);
+		return 0;
+	}
+}
+
+//#endregion
+//#region src/helpers/datetime.ts
+const timeUnitInputValueSchema = zod.z.object({
+	unit: _otim_utils_schemas.timeUnitSchema,
+	value: zod.z.number().finite(),
+	seconds: zod.z.number().finite()
+});
+const 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";
+};
+/**
+* safely parses a JSON string to TimeUnitInputValue.
+* returns undefined if parsing fails or result is invalid.
+*/
+const parseJsonToTimeUnitValue = (jsonString) => {
+	try {
+		const parsed = JSON.parse(jsonString);
+		return isTimeUnitInputValue(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+};
+/**
+* converts various value formats to TimeUnitInputValue.
+* handles both direct objects and JSON strings from form system.
+*
+* @param value – value from form field (can be object, string, or other)
+* @returns parsed TimeUnitInputValue or undefined if invalid
+*/
+const parseTimeUnitValue = (value) => {
+	if (!value) return void 0;
+	if (isTimeUnitInputValue(value)) return value;
+	if (typeof value === "string") return parseJsonToTimeUnitValue(value);
+};
+/**
+* serializes TimeUnitInputValue to JSON string for form compatibility.
+*
+* @param value – TimeUnitInputValue to serialize
+* @returns JSON string representation
+*/
+const serializeTimeUnitValue = (value) => {
+	return JSON.stringify(value);
+};
+/**
+* validates if a value can be converted to a valid TimeUnitInputValue.
+*
+* @param value – value to validate
+* @returns true if value is valid, false otherwise
+*/
+const isValidTimeUnitValue = (value) => {
+	return parseTimeUnitValue(value) !== void 0;
+};
+/**
+* gets the total seconds from a TimeUnitInputValue or its serialized form.
+*
+* @param value – TimeUnitInputValue or JSON string
+* @returns number of seconds or 0 if invalid
+*/
+const getSecondsFromTimeUnitValue = (value) => {
+	return parseTimeUnitValue(value)?.seconds ?? 0;
+};
+const coerceSecondsFromTimeUnitValue = (value) => {
+	if (!value) return 0;
+	if (typeof value === "object") {
+		const seconds = value?.seconds;
+		if (typeof seconds === "number" && Number.isFinite(seconds)) return seconds;
+	}
+	if (typeof value === "string") try {
+		const seconds = JSON.parse(value)?.seconds;
+		if (typeof seconds === "number" && Number.isFinite(seconds)) return seconds;
+	} catch {}
+	return 0;
+};
+
+//#endregion
+//#region src/helpers/domain.ts
+function getBaseDomain(hostname) {
+	/**
+	* Localhost: Preserve full hostname since WebAuthn allows subdomain RPIDs in
+	* development (app.localhost:3000, etc.)
+	*/
+	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(".");
+	if ([
+		"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"
+	].includes(lastTwoParts)) return parts.slice(-3).join(".");
+	if ([
+		"vercel.app",
+		"netlify.app",
+		"github.io",
+		"gitlab.io"
+	].includes(lastTwoParts)) return hostname;
+	return parts.slice(-2).join(".");
+}
+
+//#endregion
+//#region src/helpers/external-account.ts
+/**
+* External account display formatting helpers
+*/
+/**
+* Formats external account information for display
+*
+* @param externalAccount - External account object with optional properties
+* @returns Formatted display name for the external account
+*/
+function formatExternalAccountName(externalAccount) {
+	const { accountName, bankName, last_4 } = externalAccount;
+	if (accountName) {
+		const parts = [];
+		if (bankName) parts.push(bankName);
+		parts.push(accountName);
+		let name = parts.join(" · ");
+		if (last_4) name += ` (...${last_4})`;
+		return name;
+	}
+	if (bankName) {
+		let name = bankName;
+		if (last_4) name += ` (...${last_4})`;
+		return name;
+	}
+	if (last_4) return `Bank Account (...${last_4})`;
+	return "Bank Account";
+}
+
+//#endregion
+//#region src/helpers/intl.ts
+const locales = ["en", "es"];
+/**
+* Floors a number to a specific number of decimal places.
+* This ensures values are always rounded down, never up.
+*
+* @param value - The number to floor
+* @param decimals - Number of decimal places to keep
+* @returns The floored number
+*/
+const floorToDecimals = (value, decimals) => {
+	const multiplier = Math.pow(10, decimals);
+	return Math.floor(value * multiplier) / multiplier;
+};
+const i18n = {
+	defaultLocale: "en",
+	locales: [...locales]
+};
+const localeSchema = zod.z.enum(locales);
+const formattedNumber = (num) => {
+	if (!Number.isFinite(num)) return "0.00";
+	return new Intl.NumberFormat("en-US", {
+		minimumFractionDigits: 2,
+		maximumFractionDigits: 2
+	}).format(num);
+};
+/**
+* Formats a token or asset amount with appropriate decimal places
+* based on the magnitude of the value.
+* Values are floored (rounded down) to avoid showing inflated amounts.
+*
+* @param amount - The amount to format
+* @param decimals - Optional maximum decimal places
+*/
+const formatAmount = (amount, decimals) => {
+	if (amount === 0) return "0";
+	if (amount < 1e-6) return amount.toExponential(2);
+	if (amount < 1) return floorToDecimals(amount, decimals ?? 6).toString();
+	if (amount < 1e3) return floorToDecimals(amount, decimals ?? 2).toString();
+	const decimalPlaces = decimals ?? 2;
+	return floorToDecimals(amount, decimalPlaces).toLocaleString("en-US", {
+		minimumFractionDigits: 2,
+		maximumFractionDigits: decimalPlaces
+	});
+};
+/**
+* Formats a number as USD currency with proper locale formatting.
+* Values are floored (rounded down) to avoid showing inflated amounts.
+*
+* @param amount – The amount to format
+* @param options – Optional Intl.NumberFormatOptions to customize formatting
+* @returns – Formatted currency string (e.g., "$1,234.56")
+*/
+const formatCurrency = (amount, options) => {
+	const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
+	if (isNaN(numAmount)) return "$0.00";
+	const floored = floorToDecimals(numAmount, 2);
+	return new Intl.NumberFormat("en-US", {
+		style: "currency",
+		currency: "USD",
+		minimumFractionDigits: 2,
+		maximumFractionDigits: 2,
+		...options
+	}).format(floored);
+};
+/**
+* Formats a number as USD currency with smart decimal places based on magnitude.
+* Shows more precision for small values to avoid displaying "$0.00" for meaningful amounts.
+* Values are floored (rounded down) to avoid showing inflated amounts.
+*
+* @param amount – The amount to format
+* @returns – Formatted currency string with adaptive decimals
+*
+* @example
+* formatSmartCurrency(0)          // "$0"
+* formatSmartCurrency(0.0000001)  // "<$0.000001"
+* formatSmartCurrency(0.003456)   // "$0.003456"
+* formatSmartCurrency(0.5678)     // "$0.5678"
+* formatSmartCurrency(1234.56)    // "$1,234.56"
+*/
+const formatSmartCurrency = (amount) => {
+	const num = typeof amount === "string" ? parseFloat(amount) : amount;
+	if (isNaN(num) || num === 0) return "$0";
+	if (num < 1e-6) return "<$0.000001";
+	if (num < .01) return `$${floorToDecimals(num, 6)}`;
+	if (num < 1) return `$${floorToDecimals(num, 4)}`;
+	const floored = floorToDecimals(num, 2);
+	return new Intl.NumberFormat("en-US", {
+		style: "currency",
+		currency: "USD",
+		minimumFractionDigits: 2,
+		maximumFractionDigits: 2
+	}).format(floored);
+};
+/**
+* Alias for formatCurrency specifically for USD
+*/
+const formatUsd = formatCurrency;
+/**
+* Formats a USD amount without the currency symbol.
+* Values are floored (rounded down) to avoid showing inflated amounts.
+*
+* @param amount – The amount to format
+* @param options – Optional Intl.NumberFormatOptions to customize formatting
+* @returns – Formatted amount string (e.g., "1,234.56")
+*/
+const formatUsdAmount = (amount, options) => {
+	const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
+	if (isNaN(numAmount)) return "0.00";
+	return floorToDecimals(numAmount, 2).toLocaleString("en-US", {
+		minimumFractionDigits: 2,
+		maximumFractionDigits: 2,
+		...options
+	});
+};
+
+//#endregion
+//#region src/helpers/mask-options.ts
+const SHORT_FORM_POSTAL_MASK = [
+	/\d/,
+	/\d/,
+	/\d/,
+	/\d/,
+	/\d/
+];
+const LONG_FORM_POSTAL_MASK = [
+	/\d/,
+	/\d/,
+	/\d/,
+	/\d/,
+	/\d/,
+	"-",
+	/\d/,
+	/\d/,
+	/\d/,
+	/\d/
+];
+const postalCodeMaskOptions = { mask: (state) => {
+	return state.value.length > 5 ? LONG_FORM_POSTAL_MASK : SHORT_FORM_POSTAL_MASK;
+} };
+const dateMaskOptions = (0, _maskito_kit.maskitoDateOptionsGenerator)({
+	mode: "mm/dd/yyyy",
+	separator: "/"
+});
+const timeOptions = (0, _maskito_kit.maskitoTimeOptionsGenerator)({ mode: "HH:MM:SS AA" });
+const timeOptionsWithoutMeridiem = (0, _maskito_kit.maskitoTimeOptionsGenerator)({ mode: "HH:MM:SS" });
+const timeMaskOptionsHHMM = (0, _maskito_kit.maskitoTimeOptionsGenerator)({ mode: "HH:MM" });
+const formatUUID = (value) => {
+	if (!value) return "";
+	const limitedHex = value.replace(/[^0-9a-f-]/gi, "").replace(/-/g, "").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;
+};
+const uuidMaskOptions = { mask: /^[0-9a-f-]*$/i };
+const 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 formatted = formatCurrency(Number(clamped) / 100);
+		const nextCaret = Math.min(formatted.length, selectionEnd + (formatted.length - state.value.length));
+		return {
+			...state,
+			value: formatted,
+			selection: [nextCaret, nextCaret]
+		};
+	}]
+};
+
+//#endregion
+//#region src/helpers/num-formatter.ts
+const 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));
+};
+const formatNumberAsUSStandard = (num) => {
+	return num.toLocaleString("en-US", { maximumSignificantDigits: 3 });
+};
+
+//#endregion
+//#region src/helpers/window.ts
+const isClient = () => typeof globalThis !== "undefined" && "window" in globalThis;
+const DEFAULT_EMERGENT_WINDOW_CONFIG = {
+	width: 480,
+	height: 720,
+	name: "emergent_window"
+};
+/**
+* Opens an emergent window centered on the screen.
+* Used for authentication flows and external integrations.
+*
+* @param url - The URL to open in the emergent window
+* @param config - Optional configuration for the window
+* @returns The opened window or null if it failed
+*/
+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) {
+		require_date.logger.logError(error, { context: openCenteredEmergentWindow.name });
+	}
+	return emergentWindow ?? null;
+}
+/**
+* Closes an emergent window safely
+*
+* @param emergentWindow - The emergent window to close
+*/
+function closeEmergentWindow(emergentWindow) {
+	if (!emergentWindow) return;
+	try {
+		emergentWindow.close();
+	} catch (error) {
+		require_date.logger.logError(error, { context: closeEmergentWindow.name });
+	}
+}
+function focusMainWindow() {
+	if (!isClient()) return;
+	try {
+		window.focus();
+	} catch (error) {
+		require_date.logger.logError(error, { context: focusMainWindow.name });
+	}
+}
+/**
+* Performs a client-side redirect to the specified path
+*
+* @param path - The path to redirect to
+* @param fallbackPath - Optional fallback path if the main path is empty
+*/
+function performRedirect(path, fallbackPath = "/") {
+	if (!isClient()) return;
+	const redirectPath = path || fallbackPath;
+	window.location.href = redirectPath;
+}
+
+//#endregion
+//#region src/helpers/polling.ts
+const DEFAULT_POLLING_CONFIG = {
+	intervalMs: 1e3,
+	onComplete: () => {}
+};
+/**
+* Manages polling for emergent window completion status.
+* Generic utility that can be used for any async polling scenario.
+* Follows Single Responsibility Principle - only handles polling logic.
+*/
+var PollingManager = class {
+	constructor(config = {}) {
+		require_defineProperty._defineProperty(this, "emergentWindow", null);
+		require_defineProperty._defineProperty(this, "pollIntervalId", null);
+		require_defineProperty._defineProperty(this, "config", void 0);
+		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(() => {
+			(async () => {
+				try {
+					if (await checkFn()) {
+						this.finalize();
+						this.config.onComplete();
+					}
+				} catch (error) {
+					require_date.logger.logError(error, { context: this.start.name });
+				}
+			})();
+		}, this.config.intervalMs);
+	}
+	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();
+	}
+	dispose() {
+		this.finalize();
+	}
+};
+
+//#endregion
+//#region src/helpers/random.ts
+const 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;
+};
+
+//#endregion
+//#region src/helpers/sdk-loader.ts
+/**
+* Default timeout for SDK loading (10 seconds)
+*/
+const DEFAULT_SDK_TIMEOUT = 1e4;
+/**
+* Generic SDK loader utility for loading third-party scripts
+* Follows Single Responsibility Principle - only handles script loading
+*
+* @param config - SDK loader configuration
+* @returns Promise that resolves when SDK is loaded
+* @throws Error if SDK fails to load or times out
+*/
+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(/* @__PURE__ */ 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(/* @__PURE__ */ new Error(`Failed to load ${config.name} SDK from ${config.src}`));
+		};
+		document.body.appendChild(script);
+	});
+}
+/**
+* Checks if a script with the given src is already loaded
+*
+* @param src - Script source URL to check
+* @returns true if script is already in the DOM
+*/
+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;
+}
+
+//#endregion
+//#region src/helpers/signatures.ts
+/**
+* Converts a standard signature to EIP-2098 format
+*/
+const formatSignatureToEIP2098 = (signature) => {
+	const ensureHexPrefix = (value) => value.startsWith("0x") ? value : `0x${value}`;
+	const vNum = Number.parseInt(signature.v, 16);
+	return {
+		yParity: (() => {
+			if (Number.isNaN(vNum)) return 0;
+			if (vNum <= 1) return vNum;
+			return vNum % 2 === 0 ? 1 : 0;
+		})(),
+		r: ensureHexPrefix(signature.r),
+		s: ensureHexPrefix(signature.s)
+	};
+};
+
+//#endregion
+//#region src/helpers/string.ts
+/**
+* Capitalizes the first letter of a string
+*
+* @param str – The string to capitalize
+* @returns The string with first letter capitalized, or undefined if input is
+* nullish
+*/
+const capitalize = (str) => {
+	if (!str) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1);
+};
+/**
+* Converts a string to title case (capitalizes first letter, lowercase rest)
+*
+* @param str – The string to convert
+* @returns The string in title case, or undefined if input is nullish
+*/
+const toTitleCase = (str) => {
+	if (!str) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+
+//#endregion
+//#region src/helpers/url.ts
+/**
+* Builds a query string from a params object, skipping undefined/null values.
+* Encodes using encodeURIComponent. Returns empty string if no params.
+*/
+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}` : "";
+}
+/**
+* Build a URL by combining a base path with optional query params.
+*/
+function buildUrl(path, params) {
+	return `${path}${params ? buildQueryString(params) : ""}`;
+}
+
+//#endregion
+//#region src/helpers/zod.ts
+const composeValidators = (validators) => {
+	return (data, ctx) => {
+		for (const validator of validators) validator(data, ctx);
+	};
+};
+const 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`;
+};
+/**
+* creates a time unit validator for fields stored as JSON strings.
+* validates both the JSON format and the minimum seconds requirement.
+*
+* @param fieldName – the name of the field for error messages
+* @param options – configuration options
+* @param options.minSeconds – minimum seconds required (default: 60)
+* @param options.allowZero – whether to allow 0 seconds for "None" option (default: false)
+* @param options.useHumanReadable – whether to use human-readable time in error messages (default: true)
+*/
+const createTimeUnitValidator = (fieldName, options = {}) => {
+	const { minSeconds = 60, allowZero = false, useHumanReadable = true } = options;
+	return zod.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` });
+};
+/**
+* Parse the input values using the provided schema. If the input values are
+* invalid, throw a ResolverError.
+* @param values - The input values to parse.
+* @param schema - The schema to use to parse the input values.
+* @param error - The error code to use if the input values are invalid.
+* @returns The parsed input values.
+* @throws ResolverError if the input values are invalid.
+*/
+const 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;
+};
+/**
+* Creates a permissive decimal string schema that allows empty strings.
+* Converts undefined/null values to empty strings, preventing "expected string, received undefined" errors.
+* Useful for form fields where validation happens in a refine step.
+*/
+const formDecimalStringSchema = () => zod.z.preprocess((val) => {
+	if (val === void 0 || val === null) return "";
+	if (typeof val === "string" || typeof val === "number") return String(val);
+	return "";
+}, zod.z.string());
+/**
+* Creates a hex string schema with preprocessing that defaults to DEFAULT_ADDRESS.
+* Converts undefined/null/empty values to DEFAULT_ADDRESS before validation.
+* Useful for form fields that expect hex addresses.
+*/
+const formHexStringSchema = () => zod.z.preprocess((val) => val === void 0 || val === null || val === "" ? DEFAULT_ADDRESS : val, _otim_utils_schemas.hexStringSchema);
+/**
+* Checks if an error message is an internal Zod error that shouldn't be shown to users.
+*/
+const isInternalZodError = (error) => {
+	return error.includes("expected string, received") || error.includes("Invalid input") || error.includes("Expected string");
+};
+/**
+* Filters out Zod internal errors that shouldn't be shown to users.
+* Only returns user-friendly validation messages.
+*
+* @param errors - Array of error messages from Zod validation, or a single error string
+* @param fieldValue - The field value being validated
+* @returns User-friendly error message or undefined
+*/
+const getDisplayableZodError = (errors, fieldValue) => {
+	if (!errors || Array.isArray(errors) && errors.length === 0) return void 0;
+	if (!(typeof fieldValue === "string" ? fieldValue.trim() : "")) return void 0;
+	const filteredErrors = (Array.isArray(errors) ? errors : [errors]).filter((error) => !isInternalZodError(error));
+	return filteredErrors.length > 0 ? filteredErrors.join(", ") : void 0;
+};
+
+//#endregion
+Object.defineProperty(exports, 'DEFAULT_ADDRESS', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_ADDRESS;
+  }
+});
+Object.defineProperty(exports, 'ETHEREUM_ADDRESS_REGEX', {
+  enumerable: true,
+  get: function () {
+    return ETHEREUM_ADDRESS_REGEX;
+  }
+});
+Object.defineProperty(exports, 'PollingManager', {
+  enumerable: true,
+  get: function () {
+    return PollingManager;
+  }
+});
+Object.defineProperty(exports, 'areAddressesEqual', {
+  enumerable: true,
+  get: function () {
+    return areAddressesEqual;
+  }
+});
+Object.defineProperty(exports, 'buildQueryString', {
+  enumerable: true,
+  get: function () {
+    return buildQueryString;
+  }
+});
+Object.defineProperty(exports, 'buildUrl', {
+  enumerable: true,
+  get: function () {
+    return buildUrl;
+  }
+});
+Object.defineProperty(exports, 'capitalize', {
+  enumerable: true,
+  get: function () {
+    return capitalize;
+  }
+});
+Object.defineProperty(exports, 'closeEmergentWindow', {
+  enumerable: true,
+  get: function () {
+    return closeEmergentWindow;
+  }
+});
+Object.defineProperty(exports, 'coerceSecondsFromTimeUnitValue', {
+  enumerable: true,
+  get: function () {
+    return coerceSecondsFromTimeUnitValue;
+  }
+});
+Object.defineProperty(exports, 'composeValidators', {
+  enumerable: true,
+  get: function () {
+    return composeValidators;
+  }
+});
+Object.defineProperty(exports, 'createEIP2098Signature', {
+  enumerable: true,
+  get: function () {
+    return createEIP2098Signature;
+  }
+});
+Object.defineProperty(exports, 'createTimeUnitValidator', {
+  enumerable: true,
+  get: function () {
+    return createTimeUnitValidator;
+  }
+});
+Object.defineProperty(exports, 'dateMaskOptions', {
+  enumerable: true,
+  get: function () {
+    return dateMaskOptions;
+  }
+});
+Object.defineProperty(exports, 'extractBaseActivityDetails', {
+  enumerable: true,
+  get: function () {
+    return extractBaseActivityDetails;
+  }
+});
+Object.defineProperty(exports, 'floorToDecimals', {
+  enumerable: true,
+  get: function () {
+    return floorToDecimals;
+  }
+});
+Object.defineProperty(exports, 'focusMainWindow', {
+  enumerable: true,
+  get: function () {
+    return focusMainWindow;
+  }
+});
+Object.defineProperty(exports, 'formDecimalStringSchema', {
+  enumerable: true,
+  get: function () {
+    return formDecimalStringSchema;
+  }
+});
+Object.defineProperty(exports, 'formHexStringSchema', {
+  enumerable: true,
+  get: function () {
+    return formHexStringSchema;
+  }
+});
+Object.defineProperty(exports, 'formatAmount', {
+  enumerable: true,
+  get: function () {
+    return formatAmount;
+  }
+});
+Object.defineProperty(exports, 'formatCurrency', {
+  enumerable: true,
+  get: function () {
+    return formatCurrency;
+  }
+});
+Object.defineProperty(exports, 'formatExternalAccountName', {
+  enumerable: true,
+  get: function () {
+    return formatExternalAccountName;
+  }
+});
+Object.defineProperty(exports, 'formatNumberAsUSStandard', {
+  enumerable: true,
+  get: function () {
+    return formatNumberAsUSStandard;
+  }
+});
+Object.defineProperty(exports, 'formatSignatureToEIP2098', {
+  enumerable: true,
+  get: function () {
+    return formatSignatureToEIP2098;
+  }
+});
+Object.defineProperty(exports, 'formatSmartCurrency', {
+  enumerable: true,
+  get: function () {
+    return formatSmartCurrency;
+  }
+});
+Object.defineProperty(exports, 'formatUUID', {
+  enumerable: true,
+  get: function () {
+    return formatUUID;
+  }
+});
+Object.defineProperty(exports, 'formatUsd', {
+  enumerable: true,
+  get: function () {
+    return formatUsd;
+  }
+});
+Object.defineProperty(exports, 'formatUsdAmount', {
+  enumerable: true,
+  get: function () {
+    return formatUsdAmount;
+  }
+});
+Object.defineProperty(exports, 'formattedNumber', {
+  enumerable: true,
+  get: function () {
+    return formattedNumber;
+  }
+});
+Object.defineProperty(exports, 'getBaseDomain', {
+  enumerable: true,
+  get: function () {
+    return getBaseDomain;
+  }
+});
+Object.defineProperty(exports, 'getChainRpcUrl', {
+  enumerable: true,
+  get: function () {
+    return getChainRpcUrl;
+  }
+});
+Object.defineProperty(exports, 'getDisplayableZodError', {
+  enumerable: true,
+  get: function () {
+    return getDisplayableZodError;
+  }
+});
+Object.defineProperty(exports, 'getSecondsFromTimeUnitValue', {
+  enumerable: true,
+  get: function () {
+    return getSecondsFromTimeUnitValue;
+  }
+});
+Object.defineProperty(exports, 'i18n', {
+  enumerable: true,
+  get: function () {
+    return i18n;
+  }
+});
+Object.defineProperty(exports, 'isCctpBurnActivity', {
+  enumerable: true,
+  get: function () {
+    return isCctpBurnActivity;
+  }
+});
+Object.defineProperty(exports, 'isClient', {
+  enumerable: true,
+  get: function () {
+    return isClient;
+  }
+});
+Object.defineProperty(exports, 'isErc4626DepositActivity', {
+  enumerable: true,
+  get: function () {
+    return isErc4626DepositActivity;
+  }
+});
+Object.defineProperty(exports, 'isErc4626WithdrawActivity', {
+  enumerable: true,
+  get: function () {
+    return isErc4626WithdrawActivity;
+  }
+});
+Object.defineProperty(exports, 'isNullAddress', {
+  enumerable: true,
+  get: function () {
+    return isNullAddress;
+  }
+});
+Object.defineProperty(exports, 'isScriptLoaded', {
+  enumerable: true,
+  get: function () {
+    return isScriptLoaded;
+  }
+});
+Object.defineProperty(exports, 'isSwapActivity', {
+  enumerable: true,
+  get: function () {
+    return isSwapActivity;
+  }
+});
+Object.defineProperty(exports, 'isTransferActivity', {
+  enumerable: true,
+  get: function () {
+    return isTransferActivity;
+  }
+});
+Object.defineProperty(exports, 'isValidEthereumAddress', {
+  enumerable: true,
+  get: function () {
+    return isValidEthereumAddress;
+  }
+});
+Object.defineProperty(exports, 'isValidTimeUnitValue', {
+  enumerable: true,
+  get: function () {
+    return isValidTimeUnitValue;
+  }
+});
+Object.defineProperty(exports, 'isValidV', {
+  enumerable: true,
+  get: function () {
+    return isValidV;
+  }
+});
+Object.defineProperty(exports, 'loadExternalSdk', {
+  enumerable: true,
+  get: function () {
+    return loadExternalSdk;
+  }
+});
+Object.defineProperty(exports, 'localeSchema', {
+  enumerable: true,
+  get: function () {
+    return localeSchema;
+  }
+});
+Object.defineProperty(exports, 'normalizeV', {
+  enumerable: true,
+  get: function () {
+    return normalizeV;
+  }
+});
+Object.defineProperty(exports, 'numFormatter', {
+  enumerable: true,
+  get: function () {
+    return numFormatter;
+  }
+});
+Object.defineProperty(exports, 'openCenteredEmergentWindow', {
+  enumerable: true,
+  get: function () {
+    return openCenteredEmergentWindow;
+  }
+});
+Object.defineProperty(exports, 'parseHexAmount', {
+  enumerable: true,
+  get: function () {
+    return parseHexAmount;
+  }
+});
+Object.defineProperty(exports, 'parseSchema', {
+  enumerable: true,
+  get: function () {
+    return parseSchema;
+  }
+});
+Object.defineProperty(exports, 'parseSignatureToVRS', {
+  enumerable: true,
+  get: function () {
+    return parseSignatureToVRS;
+  }
+});
+Object.defineProperty(exports, 'parseTimeUnitValue', {
+  enumerable: true,
+  get: function () {
+    return parseTimeUnitValue;
+  }
+});
+Object.defineProperty(exports, 'performRedirect', {
+  enumerable: true,
+  get: function () {
+    return performRedirect;
+  }
+});
+Object.defineProperty(exports, 'postalCodeMaskOptions', {
+  enumerable: true,
+  get: function () {
+    return postalCodeMaskOptions;
+  }
+});
+Object.defineProperty(exports, 'randomNumber', {
+  enumerable: true,
+  get: function () {
+    return randomNumber;
+  }
+});
+Object.defineProperty(exports, 'serializeTimeUnitValue', {
+  enumerable: true,
+  get: function () {
+    return serializeTimeUnitValue;
+  }
+});
+Object.defineProperty(exports, 'timeMaskOptionsHHMM', {
+  enumerable: true,
+  get: function () {
+    return timeMaskOptionsHHMM;
+  }
+});
+Object.defineProperty(exports, 'timeOptions', {
+  enumerable: true,
+  get: function () {
+    return timeOptions;
+  }
+});
+Object.defineProperty(exports, 'timeOptionsWithoutMeridiem', {
+  enumerable: true,
+  get: function () {
+    return timeOptionsWithoutMeridiem;
+  }
+});
+Object.defineProperty(exports, 'timeUnitInputValueSchema', {
+  enumerable: true,
+  get: function () {
+    return timeUnitInputValueSchema;
+  }
+});
+Object.defineProperty(exports, 'timestampToISOString', {
+  enumerable: true,
+  get: function () {
+    return timestampToISOString;
+  }
+});
+Object.defineProperty(exports, 'toTitleCase', {
+  enumerable: true,
+  get: function () {
+    return toTitleCase;
+  }
+});
+Object.defineProperty(exports, 'truncateAddress', {
+  enumerable: true,
+  get: function () {
+    return truncateAddress;
+  }
+});
+Object.defineProperty(exports, 'usdCurrencyMaskOptions', {
+  enumerable: true,
+  get: function () {
+    return usdCurrencyMaskOptions;
+  }
+});
+Object.defineProperty(exports, 'uuidMaskOptions', {
+  enumerable: true,
+  get: function () {
+    return uuidMaskOptions;
+  }
+});
+//# sourceMappingURL=helpers-DoC7Xl12.js.map