@otim/utils 0.0.4 → 0.0.6

package/dist/helpers-BNiSxjGq.mjs

@@ -0,0 +1,895 @@
+import { t as _defineProperty } from "./defineProperty-DzhmunJg.mjs";
+import { T as logger } from "./date-gBac-Om9.mjs";
+import { z as z$1 } from "zod";
+import { hexStringSchema, timeUnitSchema } from "@otim/utils/schemas";
+import { isAddressEqual } from "viem";
+import { maskitoDateOptionsGenerator, maskitoTimeOptionsGenerator } from "@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 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 = z$1.object({
+	unit: timeUnitSchema,
+	value: z$1.number().finite(),
+	seconds: z$1.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 = z$1.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 = maskitoDateOptionsGenerator({
+	mode: "mm/dd/yyyy",
+	separator: "/"
+});
+const timeOptions = maskitoTimeOptionsGenerator({ mode: "HH:MM:SS AA" });
+const timeOptionsWithoutMeridiem = maskitoTimeOptionsGenerator({ mode: "HH:MM:SS" });
+const timeMaskOptionsHHMM = 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) {
+		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) {
+		logger.logError(error, { context: closeEmergentWindow.name });
+	}
+}
+function focusMainWindow() {
+	if (!isClient()) return;
+	try {
+		window.focus();
+	} catch (error) {
+		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 = {}) {
+		_defineProperty(this, "emergentWindow", null);
+		_defineProperty(this, "pollIntervalId", null);
+		_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) {
+					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 z$1.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 = () => z$1.preprocess((val) => {
+	if (val === void 0 || val === null) return "";
+	if (typeof val === "string" || typeof val === "number") return String(val);
+	return "";
+}, z$1.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 = () => z$1.preprocess((val) => val === void 0 || val === null || val === "" ? DEFAULT_ADDRESS : val, 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
+export { isValidEthereumAddress as $, uuidMaskOptions as A, formatExternalAccountName as B, dateMaskOptions as C, timeOptions as D, timeMaskOptionsHHMM as E, formatUsd as F, parseTimeUnitValue as G, coerceSecondsFromTimeUnitValue as H, formatUsdAmount as I, DEFAULT_ADDRESS as J, serializeTimeUnitValue as K, formattedNumber as L, formatAmount as M, formatCurrency as N, timeOptionsWithoutMeridiem as O, formatSmartCurrency as P, isNullAddress as Q, i18n as R, numFormatter as S, postalCodeMaskOptions as T, getSecondsFromTimeUnitValue as U, getBaseDomain as V, isValidTimeUnitValue as W, createEIP2098Signature as X, ETHEREUM_ADDRESS_REGEX as Y, getChainRpcUrl as Z, focusMainWindow as _, getDisplayableZodError as a, extractBaseActivityDetails as at, performRedirect as b, buildUrl as c, isErc4626WithdrawActivity as ct, formatSignatureToEIP2098 as d, timestampToISOString as dt, isValidV as et, isScriptLoaded as f, areAddressesEqual as ft, closeEmergentWindow as g, PollingManager as h, formHexStringSchema as i, truncateAddress as it, floorToDecimals as j, usdCurrencyMaskOptions as k, capitalize as l, isSwapActivity as lt, randomNumber as m, createTimeUnitValidator as n, parseHexAmount as nt, parseSchema as o, isCctpBurnActivity as ot, loadExternalSdk as p, timeUnitInputValueSchema as q, formDecimalStringSchema as r, parseSignatureToVRS as rt, buildQueryString as s, isErc4626DepositActivity as st, composeValidators as t, normalizeV as tt, toTitleCase as u, isTransferActivity as ut, isClient as v, formatUUID as w, formatNumberAsUSStandard as x, openCenteredEmergentWindow as y, localeSchema as z };
+//# sourceMappingURL=helpers-BNiSxjGq.mjs.map