@provex/utils 1.0.16

package/dist/src/payment.js

@@ -0,0 +1,439 @@
+import { getAddress, parseUnits, zeroAddress } from "viem";
+import { base, pulsechain } from "viem/chains";
+import { contractsByChainId, getContracts } from "./contracts.js";
+import { formatUnits } from "./units.js";
+import { SUPPORTED_CURRENCIES } from "./currencies.js";
+/**
+ * Payment providers, including manual
+ */
+export const providers = {
+    VENMO: 'venmo',
+    ZELLE: 'zelle',
+    CASHAPP: 'cashapp',
+    REVOLUT: 'revolut',
+    WISE: 'wise',
+    MERCADOPAGO: 'mercadopago',
+    MANUAL: 'manual',
+    PAYPAL: 'paypal',
+    MONZO: 'monzo',
+};
+/** Distinct keys for payment sub-providers (currently only used by Zelle) */
+export const subProviders = {
+    CHASE: 'chase',
+    BANK_OF_AMERICA: 'bank_of_america',
+    CITI: 'citi',
+};
+/** Provider key to validation key */
+export const providerKeyToValidationKey = {
+    venmo: 'venmoUsername',
+    zelle: 'zelleEmail',
+    cashapp: 'cashtag',
+    revolut: 'revolutUsername',
+    wise: 'wisetag',
+    mercadopago: 'cvu',
+    paypal: 'paypalEmail',
+    monzo: 'monzoMeUsername',
+};
+/** Data encoding for zelle urls */
+export const dataEncoding = (data) => {
+    return btoa(JSON.stringify({
+        name: '',
+        action: 'payment',
+        token: data,
+    }));
+};
+/** Default Zelle send link */
+export const defaultZelleSendLink = (options) => (!options.username ? null
+    : `https://enroll.zellepay.com/qr-codes?data=${dataEncoding(options.username)}`);
+/** Global configuration for all supported sub-providers. Other modules can import this directly. */
+export const subProviderConfigs = {
+    zelle: {
+        chase: {
+            paymentMethod: 0,
+            key: subProviders.CHASE,
+            name: 'Chase',
+            icon: 'simple-icons:chase',
+            verifiers: (chain) => getContracts(chain).zelleChaseReclaimVerifier,
+            sendLink: (opts) => {
+                if (opts.qrCode) {
+                    return defaultZelleSendLink(opts);
+                }
+                return 'https://secure.chase.com/web/auth/dashboard#/dashboard/singleDoor/singleDoorController/index';
+            },
+        },
+        bank_of_america: {
+            paymentMethod: 1,
+            key: subProviders.BANK_OF_AMERICA,
+            name: 'Bank of America',
+            icon: 'simple-icons:bankofamerica',
+            verifiers: (chain) => getContracts(chain).zelleBoAReclaimVerifier,
+            sendLink: (opts) => {
+                if (opts.qrCode) {
+                    return `https://www.bankofamerica.com/movemoney`;
+                }
+                return 'https://www.bankofamerica.com/';
+            },
+        },
+        citi: {
+            paymentMethod: 2,
+            key: subProviders.CITI,
+            name: 'Citi',
+            icon: 'arcticons:citi-mobile',
+            verifiers: (chain) => getContracts(chain).zelleCitiReclaimVerifier,
+            sendLink: (opts) => {
+                if (opts.qrCode) {
+                    return defaultZelleSendLink(opts);
+                }
+                return 'https://online.citi.com/US/nga/zelle/transfer';
+            },
+        },
+    },
+};
+/** Payment method icon mappings */
+export const providerConfigs = (chainId) => {
+    const contracts = getContracts(chainId);
+    return {
+        venmo: {
+            key: providers.VENMO,
+            icon: 'ion:logo-venmo',
+            name: 'Venmo',
+            usernameType: 'Venmo Username',
+            validationKey: providerKeyToValidationKey.venmo,
+            color: 'rgb(0, 116, 222)',
+            verifiers: contracts.venmoReclaimVerifier,
+            limits: {
+                min: 1.0,
+            },
+            subProviders: new Set(),
+            sendLink: (options) => {
+                if (options.qrCode) {
+                    return `venmo://paycharge?txn=pay&recipients=${options.username}&note=cash&amount=${options.amount}`;
+                }
+                return `https://account.venmo.com/pay?recipients=${options.username}&note=cash&amount=${options.amount}`;
+            },
+            list: [
+                SUPPORTED_CURRENCIES.USD.contractId,
+            ],
+        },
+        zelle: {
+            key: providers.ZELLE,
+            icon: 'simple-icons:zelle',
+            name: 'Zelle',
+            color: '#6d1fd4',
+            usernameType: 'Zelle Email',
+            validationKey: providerKeyToValidationKey.zelle,
+            verifiers: contracts.zelleBaseVerifier,
+            limits: {
+                min: 1.0,
+            },
+            subProviders: new Set([
+                subProviderConfigs.zelle[subProviders.CHASE],
+                subProviderConfigs.zelle[subProviders.BANK_OF_AMERICA],
+                subProviderConfigs.zelle[subProviders.CITI],
+            ]),
+            // Delegate to sub-provider specific link when provided, otherwise fall back to generic QR URL
+            sendLink: (options) => {
+                if (options.subProvider) {
+                    return subProviderConfigs.zelle[options.subProvider].sendLink(options);
+                }
+                return defaultZelleSendLink(options);
+            },
+            list: [
+                SUPPORTED_CURRENCIES.USD.contractId,
+            ],
+        },
+        cashapp: {
+            key: providers.CASHAPP,
+            icon: 'simple-icons:cashapp',
+            name: 'Cash App',
+            color: 'rgba(0,224,19,1.0)',
+            usernameType: 'CashTag',
+            validationKey: providerKeyToValidationKey.cashapp,
+            verifiers: contracts.cashappReclaimVerifier,
+            limits: {
+                min: 1.0,
+            },
+            subProviders: new Set(),
+            list: [
+                SUPPORTED_CURRENCIES.USD.contractId,
+            ],
+            sendLink: (options) => {
+                const u = options.username.startsWith('$') ? options.username : `$${options.username}`;
+                return `https://cash.app/qr/${u}?size=288&margin=0`;
+            },
+        },
+        revolut: {
+            key: providers.REVOLUT,
+            icon: 'simple-icons:revolut',
+            name: 'Revolut',
+            color: '#191c1f',
+            usernameType: 'RevTag',
+            validationKey: providerKeyToValidationKey.revolut,
+            verifiers: contracts.revolutReclaimVerifier,
+            limits: {
+                min: 1.0,
+            },
+            subProviders: new Set(),
+            sendLink: (options) => `https://revolut.me/${options.username}`,
+            list: [
+                SUPPORTED_CURRENCIES.USD.contractId,
+                SUPPORTED_CURRENCIES.EUR.contractId,
+                SUPPORTED_CURRENCIES.GBP.contractId,
+                SUPPORTED_CURRENCIES.AUD.contractId,
+                SUPPORTED_CURRENCIES.CAD.contractId,
+                SUPPORTED_CURRENCIES.HKD.contractId,
+                SUPPORTED_CURRENCIES.MXN.contractId,
+                SUPPORTED_CURRENCIES.NZD.contractId,
+                SUPPORTED_CURRENCIES.PLN.contractId,
+                SUPPORTED_CURRENCIES.SAR.contractId,
+                SUPPORTED_CURRENCIES.SGD.contractId,
+                SUPPORTED_CURRENCIES.ZAR.contractId,
+                SUPPORTED_CURRENCIES.CHF.contractId,
+                SUPPORTED_CURRENCIES.THB.contractId,
+                SUPPORTED_CURRENCIES.TRY.contractId,
+                SUPPORTED_CURRENCIES.AED.contractId,
+            ],
+        },
+        wise: {
+            key: providers.WISE,
+            icon: 'simple-icons:wise',
+            name: 'Wise',
+            color: '#9fe870',
+            usernameType: 'WiseTag',
+            validationKey: providerKeyToValidationKey.wise,
+            verifiers: contracts.wiseReclaimVerifier,
+            limits: {
+                min: 1.0,
+            },
+            subProviders: new Set(),
+            sendLink: (options) => `https://wise.com/pay/me/${options.username}`,
+            list: [
+                SUPPORTED_CURRENCIES.USD.contractId,
+                SUPPORTED_CURRENCIES.EUR.contractId,
+                SUPPORTED_CURRENCIES.GBP.contractId,
+                SUPPORTED_CURRENCIES.AUD.contractId,
+                SUPPORTED_CURRENCIES.CAD.contractId,
+                SUPPORTED_CURRENCIES.CNY.contractId,
+                SUPPORTED_CURRENCIES.HKD.contractId,
+                SUPPORTED_CURRENCIES.IDR.contractId,
+                SUPPORTED_CURRENCIES.ILS.contractId,
+                SUPPORTED_CURRENCIES.JPY.contractId,
+                SUPPORTED_CURRENCIES.KES.contractId,
+                SUPPORTED_CURRENCIES.MYR.contractId,
+                SUPPORTED_CURRENCIES.MXN.contractId,
+                SUPPORTED_CURRENCIES.NZD.contractId,
+                SUPPORTED_CURRENCIES.PLN.contractId,
+                SUPPORTED_CURRENCIES.SGD.contractId,
+                SUPPORTED_CURRENCIES.ZAR.contractId,
+                SUPPORTED_CURRENCIES.CHF.contractId,
+                SUPPORTED_CURRENCIES.THB.contractId,
+                SUPPORTED_CURRENCIES.TRY.contractId,
+                SUPPORTED_CURRENCIES.UGX.contractId,
+                SUPPORTED_CURRENCIES.AED.contractId,
+                SUPPORTED_CURRENCIES.VND.contractId,
+            ],
+        },
+        mercadopago: {
+            key: providers.MERCADOPAGO,
+            icon: 'simple-icons:mercadopago',
+            name: 'Mercado Pago',
+            usernameType: 'Mercado Pago / Bank CVU',
+            color: '#ffe600',
+            validationKey: providerKeyToValidationKey.mercadopago,
+            verifiers: contracts.mercadopagoReclaimVerifier,
+            limits: {
+                min: 1.0,
+            },
+            subProviders: new Set(),
+            sendLink: () => `https://www.mercadopago.com.ar/money-out/transfer/`,
+            list: [
+                SUPPORTED_CURRENCIES.ARS.contractId,
+            ],
+        },
+        paypal: {
+            key: providers.PAYPAL,
+            icon: 'simple-icons:paypal',
+            name: 'PayPal',
+            usernameType: 'PayPal Email',
+            validationKey: providerKeyToValidationKey.paypal,
+            verifiers: contracts.paypalReclaimVerifier,
+            limits: {
+                min: 1.0,
+            },
+            subProviders: new Set(),
+            color: '#0070BA',
+            sendLink: (options) => {
+                if (options.qrCode) {
+                    return `paypal://`;
+                }
+                return `https://www.paypal.com/myaccount/transfer/homepage`;
+            },
+            list: [
+                SUPPORTED_CURRENCIES.USD.contractId,
+                SUPPORTED_CURRENCIES.EUR.contractId,
+                SUPPORTED_CURRENCIES.GBP.contractId,
+                SUPPORTED_CURRENCIES.AUD.contractId,
+                SUPPORTED_CURRENCIES.NZD.contractId,
+                SUPPORTED_CURRENCIES.CAD.contractId,
+                SUPPORTED_CURRENCIES.SGD.contractId,
+            ],
+        },
+        monzo: {
+            key: providers.MONZO,
+            icon: 'simple-icons:monzo',
+            name: 'Monzo',
+            usernameType: 'Monzo Me Username',
+            validationKey: providerKeyToValidationKey.monzo,
+            verifiers: contracts.monzoReclaimVerifier,
+            limits: {
+                min: 1.0,
+            },
+            subProviders: new Set(),
+            sendLink: (options) => `https://monzo.me/${options.username}`,
+            list: [
+                SUPPORTED_CURRENCIES.GBP.contractId,
+            ],
+            color: '#FC427B',
+        },
+        manual: {
+            key: providers.MANUAL,
+            icon: 'mdi:help-circle',
+            name: 'Manual Release',
+            color: 'gray',
+            usernameType: '',
+            validationKey: null,
+            verifiers: [zeroAddress],
+            limits: {
+                min: 0.0,
+            },
+            subProviders: new Set(),
+            list: [],
+        },
+    };
+};
+/** Payment verifier to key map */
+export const paymentVerifierToKey = (chainId) => (new Map(Object.values(chainId ? [chainId] : [...contractsByChainId.keys()]).flatMap(chainId => (Object.values(providerConfigs(chainId)).flatMap(config => {
+    return config.verifiers.map(verifier => [getAddress(verifier), config.key]);
+})))));
+/** Provider key to verifiers map */
+export const providerKeyToVerifiersMap = (chainId) => (new Map(Object.entries(providerConfigs(chainId)).map(([key, config]) => [key, config.verifiers])));
+/** Provider key to verifiers */
+export const providerKeyToVerifiers = (chainId, providerKey) => {
+    return providerKeyToVerifiersMap(chainId).get(providerKey) ?? null;
+};
+/** Verifier gets key */
+export const verifierGetsKey = (chainId, verifierAddress) => {
+    try {
+        return paymentVerifierToKey(chainId).get(getAddress(verifierAddress)) ?? providers.MANUAL;
+    }
+    catch (error) {
+        return providers.MANUAL;
+    }
+};
+/**
+ * Utility function to get payment method icon
+ * @param key - The provider key
+ * @returns The icon string used for iconify
+ */
+export const getPaymentIcon = (chainId, key) => {
+    const config = providerConfigs(chainId ?? pulsechain.id);
+    return config[key]?.icon || config[providers.MANUAL].icon;
+};
+/**
+ * Utility function to get payment method configuration by verifier address
+ * @param verifierAddress - The verifier address
+ * @returns The payment method configuration
+ */
+export const getPaymentMethodConfig = (chainId, verifierAddress) => {
+    return (chainId ? [chainId] : [...contractsByChainId.keys()]).reduce((result, chainId) => (result ?? Object.values(providerConfigs(chainId)).reduce((r, config) => (r ?? (config.verifiers.includes(getAddress(verifierAddress)) ? config : null)), result)), null);
+};
+/**
+ * Utility function to get payment method minimum limit by verifier address
+ * @param key - The provider key
+ * @returns The minimum limit
+ */
+export const getPaymentMethodMinimum = (chainId, key) => {
+    const config = providerConfigs(chainId ?? base.id)[key];
+    return config?.limits?.min ?? 0;
+};
+/**
+ * Utility function to get payment method name by verifier address
+ */
+export const getPaymentMethodName = (chainId, verifierAddress) => {
+    const providerKey = verifierAddress;
+    const providerConfig = providerConfigs(chainId ?? base.id)[providerKey];
+    if (providerConfig) {
+        return providerConfig.name;
+    }
+    const config = providerConfigs(chainId ?? base.id)[verifierAddress] ?? getPaymentMethodConfig(chainId ?? base.id, verifierAddress);
+    return config?.name || 'Unknown';
+};
+/**
+ * Calculate effective minimum amount (higher of user minimum or payment provider minimum)
+ * @param userMinAmountWei - The user minimum amount
+ * @param tokenInfo - The token info
+ * @param providerRates - The provider rates
+ * @returns The effective minimum amount
+ */
+export function calculateEffectiveMinimum(chainId, userMinAmountWei, tokenInfo, providerRates) {
+    const userMinAmountWeiBigInt = BigInt(userMinAmountWei);
+    let providerMinAmountWei = 0n;
+    if (providerRates) {
+        // Get unique payment providers from the rates
+        const paymentProviders = new Set();
+        for (const [providerKey] of providerRates.entries()) {
+            paymentProviders.add(providerKey);
+        }
+        // Calculate the highest provider minimum limit
+        for (const providerKey of paymentProviders) {
+            const providerConfig = providerConfigs(chainId)[providerKey];
+            if (providerConfig?.limits?.min) {
+                const providerMinWei = parseUnits(providerConfig.limits.min.toString(), tokenInfo.decimals);
+                if (providerMinWei > providerMinAmountWei) {
+                    providerMinAmountWei = providerMinWei;
+                }
+            }
+        }
+    }
+    const effectiveMinAmountWei = userMinAmountWeiBigInt > providerMinAmountWei
+        ? userMinAmountWeiBigInt
+        : providerMinAmountWei;
+    const formattedEffectiveMin = formatUnits(effectiveMinAmountWei, { decimals: tokenInfo.decimals });
+    return {
+        userMinAmountWei: userMinAmountWeiBigInt,
+        providerMinAmountWei,
+        effectiveMinAmountWei,
+        formattedEffectiveMin
+    };
+}
+/**
+ * Helper function to get payment provider minimum limit (returns decimal number for config)
+ * @param key - The provider key
+ * @returns The minimum limit
+ */
+export function getPaymentProviderMinimum(chainId, key) {
+    return getPaymentMethodMinimum(chainId, key) ?? 0;
+}
+/**
+ * Check if a payment method is known
+ * @param chainId - The chain ID
+ * @param verifierAddress - The verifier address
+ * @returns True if the payment method is known, false otherwise
+ */
+export const isPaymentMethodKnown = (chainId, verifierAddress) => {
+    return !!getPaymentMethodConfig(chainId, verifierAddress);
+};
+/**
+ * Get all payment methods
+ * @returns All payment methods
+ */
+export const getAllPaymentMethods = (chainId) => {
+    return Object.keys(providerConfigs(chainId));
+};
+/**
+ * Get all verifiable payment methods
+ * @returns All verifiable payment methods
+ */
+export const verifiablePaymentMethods = (chainId) => {
+    return getAllPaymentMethods(chainId).filter(key => key !== providers.MANUAL);
+};

package/dist/src/profit.d.ts

@@ -0,0 +1,28 @@
+import type { ChainId } from "./chain.js";
+/** BigIntish type */
+export type BigIntish = string | bigint | number;
+/** Profit calculation input */
+export interface ProfitCalculationInput {
+    amount: BigIntish;
+    chainId: ChainId;
+    conversionRate: {
+        value: BigIntish;
+        currency: string;
+    };
+}
+/**
+ * Calculate the profit of an intent fulfilled event
+ * @param param0.amount - The amount
+ * @param param0.conversionRate - The conversion rate
+ * @returns The profit
+ */
+export declare const calculateProfit: ({ amount: amountInput, conversionRate, chainId, }: ProfitCalculationInput) => bigint | null;
+/**
+ * Calculate the profits for a list of inputs
+ * @param inputs - The inputs to calculate the profits for a series of intents
+ * @returns The profits
+ */
+export declare const calculateProfits: (inputs: ProfitCalculationInput[]) => {
+    profit: bigint;
+    nullAmounts: number;
+};

package/dist/src/profit.js

@@ -0,0 +1,34 @@
+import { getCurrencyByContractId } from "./currencies.js";
+import { getDefaultToken } from "./tokens.js";
+/**
+ * Calculate the profit of an intent fulfilled event
+ * @param param0.amount - The amount
+ * @param param0.conversionRate - The conversion rate
+ * @returns The profit
+ */
+export const calculateProfit = ({ amount: amountInput, conversionRate, chainId, }) => {
+    const rate = BigInt(conversionRate.value);
+    const amount = BigInt(amountInput);
+    const valueReceived = amount * rate / 10n ** 18n;
+    const currency = getCurrencyByContractId(conversionRate.currency);
+    const inputTokenInfo = getDefaultToken(chainId);
+    const isOneForOne = currency.ticker === 'USD';
+    if (inputTokenInfo && isOneForOne) {
+        return valueReceived - amount;
+    }
+    return null;
+};
+/**
+ * Calculate the profits for a list of inputs
+ * @param inputs - The inputs to calculate the profits for a series of intents
+ * @returns The profits
+ */
+export const calculateProfits = (inputs) => {
+    const profitAmounts = inputs.map(calculateProfit);
+    const nullAmounts = profitAmounts.filter((amount) => amount === null).length;
+    const profit = profitAmounts.reduce((acc, curr) => !!curr ? acc + curr : acc, 0n);
+    return {
+        profit,
+        nullAmounts,
+    };
+};

package/dist/src/sort.d.ts

@@ -0,0 +1,36 @@
+export type SortDirection = 'asc' | 'desc';
+export type Sortable = string | number | bigint;
+/**
+ * Ordered sort
+ * @param aVal - The first value
+ * @param bVal - The second value
+ * @param orderDirection - The order direction
+ * @returns The sorted value
+ */
+export declare const orderedSort: (aVal: Sortable, bVal: Sortable, orderDirection: SortDirection) => number;
+/**
+ * Ordered sort then by deposit ID
+ * @param param0 - The parameters
+ * @returns The sorted value
+ */
+export declare const orderedSortThenById: ({ aVal, bVal, orderDirection, a, b, }: {
+    aVal: Sortable;
+    bVal: Sortable;
+    orderDirection: SortDirection;
+    a: {
+        depositId: bigint;
+        transaction: {
+            block: {
+                timestamp: string;
+            };
+        };
+    };
+    b: {
+        depositId: bigint;
+        transaction: {
+            block: {
+                timestamp: string;
+            };
+        };
+    };
+}) => number;

package/dist/src/sort.js

@@ -0,0 +1,39 @@
+/**
+ * Ordered sort
+ * @param aVal - The first value
+ * @param bVal - The second value
+ * @param orderDirection - The order direction
+ * @returns The sorted value
+ */
+export const orderedSort = (aVal, bVal, orderDirection) => {
+    if (typeof aVal === 'bigint' && typeof bVal === 'bigint') {
+        const compareResult = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+        return orderDirection === 'asc' ? compareResult : -compareResult;
+    }
+    else if (typeof aVal === 'string' && typeof bVal === 'string') {
+        const compareResult = aVal.localeCompare(bVal);
+        return orderDirection === 'asc' ? compareResult : -compareResult;
+    }
+    else if (typeof aVal === 'number' && typeof bVal === 'number') {
+        const compareResult = aVal - bVal;
+        return orderDirection === 'asc' ? compareResult : -compareResult;
+    }
+    else {
+        const compareResult = String(aVal).localeCompare(String(bVal));
+        return orderDirection === 'asc' ? compareResult : -compareResult;
+    }
+};
+/**
+ * Ordered sort then by deposit ID
+ * @param param0 - The parameters
+ * @returns The sorted value
+ */
+export const orderedSortThenById = ({ aVal, bVal, orderDirection, a, b, }) => {
+    let result = orderedSort(aVal, bVal, orderDirection);
+    if (result !== 0)
+        return result;
+    result = orderedSort(BigInt(a.transaction.block.timestamp), BigInt(b.transaction.block.timestamp), 'asc');
+    if (result !== 0)
+        return result;
+    return orderedSort(a.depositId, b.depositId, 'asc');
+};

package/dist/src/stats.d.ts

@@ -0,0 +1,7 @@
+export declare const statAction: {
+    readonly deposit: "deposit";
+    readonly withdrawal: "withdrawal";
+    readonly exchange: "exchange";
+};
+export type StatAction = (typeof statAction)[keyof typeof statAction];
+export declare const isStatAction: (action: string) => action is StatAction;

package/dist/src/stats.js

@@ -0,0 +1,8 @@
+export const statAction = {
+    deposit: 'deposit',
+    withdrawal: 'withdrawal',
+    exchange: 'exchange',
+};
+export const isStatAction = (action) => {
+    return action in statAction;
+};

package/dist/src/time.d.ts

@@ -0,0 +1,54 @@
+/** Interval in milliseconds */
+export declare const intervalIn: {
+    readonly yearInDays: 365;
+    readonly quarterInMonths: 3;
+    readonly monthInDays: 30;
+    readonly hourInDays: 24;
+    readonly daysInWeek: 7;
+    readonly minuteInHours: 60;
+    readonly secondInMinutes: 60;
+    readonly millisecondInSecond: 1000;
+};
+/** Intervals in milliseconds */
+export declare const interval: {
+    readonly second: 1000;
+    readonly minute: number;
+    readonly hour: number;
+    readonly day: number;
+    readonly month: number;
+    readonly year: number;
+};
+/** Default display intervals */
+export declare const defaultDisplayInterval: {
+    readonly hour: number;
+    readonly day: number;
+    readonly month: 60;
+};
+/**
+ * Format a timestamp
+ * @param timestamp - The timestamp to format
+ * @param param1.anchor - The anchor date
+ * @param param1.showSeconds - Whether to show seconds
+ * @returns The formatted timestamp
+ */
+export declare const formatTimestamp: (timestamp: number | Date | string, { anchor, showSeconds, }?: {
+    anchor?: Date;
+    showSeconds?: boolean;
+}) => string;
+/**
+ * Format a duration
+ * @param param0.start - The start date
+ * @param param0.until - The end date
+ * @returns The formatted duration
+ */
+export declare const formatDuration: ({ start, until, }?: {
+    start?: Date;
+    until?: Date;
+}) => string;
+/**
+ * Sleep for a given number of milliseconds
+ * @param ms - The number of milliseconds to sleep
+ * @returns A promise that resolves after the given number of milliseconds
+ */
+export declare const sleep: (ms: number) => Promise<unknown>;
+export type TimeResolutionKey = "hour" | "day" | "month";