@provex/utils 1.0.16

package/dist/src/tokens.js

@@ -0,0 +1,134 @@
+import { createPublicClient, getAddress, http } from 'viem';
+import { base, pulsechain } from 'viem/chains';
+import { chains } from './chain.js';
+const BASE_USDC = {
+    address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+    decimals: 6,
+    symbol: 'USDC',
+    name: 'USD Coin',
+    chainId: base.id,
+};
+export const PULSECHAIN_USDC = {
+    address: '0x15D38573d2feeb82e7ad5187aB8c1D52810B1f07',
+    decimals: 6,
+    symbol: 'USDC',
+    name: 'USD Coin from Ethereum',
+    chainId: pulsechain.id,
+    mainnetAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+};
+/** All tokens info */
+export const allTokensInfo = {
+    [base.id]: {
+        // Base Network Tokens
+        USDC: BASE_USDC,
+        // USDT: {
+        //   address: '0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2',
+        //   decimals: 6,
+        //   symbol: 'USDT',
+        //   name: 'Tether USD',
+        //   chainId: base.id,
+        // } as TokenInfo,
+        // ETH: {
+        //   address: '0x4200000000000000000000000000000000000006',
+        //   decimals: 18,
+        //   symbol: 'WETH',
+        //   name: 'Wrapped Ether',
+        //   chainId: base.id,
+        // } as TokenInfo,
+    },
+    // [mainnet.id]: {
+    //   // Ethereum Mainnet Tokens
+    //   USDC: {
+    //     address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    //     decimals: 6,
+    //     symbol: 'USDC',
+    //     name: 'USD Coin',
+    //     chainId: mainnet.id,
+    //   } as TokenInfo,
+    // USDT: {
+    //   address: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+    //   decimals: 6,
+    //   symbol: 'USDT',
+    //   name: 'Tether USD',
+    //   chainId: mainnet.id,
+    // } as TokenInfo,
+    // WETH: {
+    //   address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    //   decimals: 18,
+    //   symbol: 'WETH',
+    //   name: 'Wrapped Ether',
+    //   chainId: mainnet.id,
+    // } as TokenInfo,
+    // ETH: {
+    //   address: zeroAddress,
+    //   decimals: 18,
+    //   symbol: 'ETH',
+    //   name: 'Ether',
+    //   chainId: mainnet.id,
+    // } as TokenInfo,
+    // DAI: {
+    //   address: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+    //   decimals: 18,
+    //   symbol: 'DAI',
+    //   name: 'Dai Stablecoin',
+    //   chainId: mainnet.id,
+    // } as TokenInfo,
+    // },
+    [pulsechain.id]: {
+        USDC: PULSECHAIN_USDC,
+    },
+    // USDT: {
+    //   address: '0x0Cb6F5a34ad42ec934882A05265A7d5F59b51A2f',
+    //   decimals: 6,
+    //   symbol: 'USDT',
+    //   name: 'Tether USD from Ethereum',
+    //   chainId: pulsechain.id,
+    //   mainnetAddress: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+    // } as TokenInfo,
+    // ETH: {
+    //   address: '0x02DcdD04e3F455D838cd1249292C58f3B79e3C3C',
+    //   decimals: 18,
+    //   symbol: 'WETH',
+    //   name: 'Wrapped Ether from Ethereum',
+    //   chainId: pulsechain.id,
+    //   mainnetAddress: '0x0000000000000000000000000000000000000000',
+    // } as TokenInfo,
+};
+export const getDefaultToken = (chainId) => {
+    return allTokensInfo[chainId ?? pulsechain.id]?.USDC ?? null;
+};
+export const getDefaultTokens = (chainIds) => {
+    return chainIds.length ? chainIds.map((chainId) => getDefaultToken(chainId)) : chains.map((chain) => getDefaultToken(chain.id));
+};
+/**
+ * Get tokens by chain ID
+ * @param chainId - The chain ID
+ * @returns Array of tokens for that chain
+ */
+export const getTokensByChainId = (chainId) => {
+    return Object.values(allTokensInfo[chainId] ?? {});
+};
+/**
+ * Get a token by address
+ * @param address - The address of the token
+ * @returns The token info
+ */
+export const tokenByAddress = (chainId, address) => {
+    return !address ? null : Object.values(allTokensInfo[chainId] ?? {}).find(token => getAddress(token.address) === getAddress(address)) ?? null;
+};
+/**
+ * Create a public client for reading from contracts
+ * @param chain - The chain
+ * @returns The public client
+ */
+export const publicClient = (chain) => createPublicClient({
+    chain,
+    transport: http()
+});
+// export const pulseChainTokenToMainnet = (pulsechainToken: TokenInfo) => {
+//   const tokens = allTokensInfo[mainnet.id]
+//   const token = Object.values(tokens).find((t) => (
+//     getAddress(t.address) === getAddress(pulsechainToken.mainnetAddress!)
+//   ))
+//   return token!
+// }

package/dist/src/units.d.ts

@@ -0,0 +1,17 @@
+import type { TokenInfo } from './tokens.js';
+export declare const oneEther: bigint;
+export declare function addThousandsSeparator(numberString: string, delimiter?: string): string;
+export interface FormatRateDisplayOptions {
+    decimals: number;
+    truncateDecimals?: number;
+    padDecimals?: number;
+    cutoff?: bigint;
+    delimiter?: string;
+    roundUp?: boolean;
+}
+export declare const parseUnits: (amount: string, options: Pick<FormatRateDisplayOptions, "decimals" | "delimiter">) => bigint;
+export declare function formatUnits(amount: bigint, options: FormatRateDisplayOptions): string;
+export declare function formatTokenAmountForDisplay(amount: bigint, options: FormatRateDisplayOptions): string;
+export declare function parseIntegerSafe(value: string): number | null;
+export declare function timestampToDate(timestamp: string | number | bigint | undefined | null): Date | null;
+export declare const formatAmount: (token: TokenInfo, amount: bigint | null, options?: Partial<FormatRateDisplayOptions>) => string | null;

package/dist/src/units.js

@@ -0,0 +1,79 @@
+import { formatUnits as viemFormatUnits, parseUnits as viemParseUnits } from 'viem';
+export const oneEther = 10n ** 18n;
+// Add thousands separators to a number string
+export function addThousandsSeparator(numberString, delimiter = ',') {
+    let [integerPart, fractionalPart] = numberString.split('.');
+    integerPart = integerPart || '0';
+    fractionalPart = fractionalPart || '';
+    // Add thousands separators to integer part
+    const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, delimiter);
+    // Return with fractional part if it exists
+    return fractionalPart ? `${formattedInteger}.${fractionalPart}` : formattedInteger;
+}
+export const parseUnits = (amount, options) => {
+    return viemParseUnits(amount.split(options.delimiter ?? ',').join(''), options.decimals);
+};
+// Format exchange rates with natural precision, minimum 2 decimal places and thousands separators
+export function formatUnits(amount, options) {
+    const { decimals, truncateDecimals, padDecimals = 0, delimiter = ',', cutoff, roundUp = false } = options;
+    if (cutoff && amount < cutoff) {
+        return `<${formatUnits(cutoff, { ...options, truncateDecimals: 0, cutoff: undefined })}`;
+    }
+    if (roundUp && truncateDecimals !== undefined) {
+        // const minimumDecimal = decimals - truncateDecimals
+        const minimumDecimal = BigInt(decimals - truncateDecimals);
+        const minimalMod = amount % (10n ** minimumDecimal);
+        const halfMinimalDecimal = (10n ** minimumDecimal) / 2n;
+        if (minimalMod >= halfMinimalDecimal) {
+            amount = amount + (10n ** minimumDecimal) - minimalMod;
+        }
+    }
+    const formatted = viemFormatUnits(amount, decimals);
+    const [integerPart, fractionalPart = ''] = formatted.split('.');
+    // If truncateDecimals is specified, limit decimal places
+    let finalFractionalPart = fractionalPart;
+    if (truncateDecimals !== undefined) {
+        finalFractionalPart = fractionalPart.slice(0, truncateDecimals);
+    }
+    // Always pad to at least 2 decimal places (or padDecimals)
+    if (finalFractionalPart.length < padDecimals) {
+        finalFractionalPart = finalFractionalPart.padEnd(padDecimals, '0');
+    }
+    // If there are no decimals, still show .00
+    const numberString = `${integerPart}.${finalFractionalPart}`;
+    return addThousandsSeparator(numberString, delimiter);
+}
+export function formatTokenAmountForDisplay(amount, options) {
+    return formatUnits(amount, { truncateDecimals: 2, ...options });
+}
+// Safe integer parsing without using Number()
+export function parseIntegerSafe(value) {
+    // Use parseInt instead of Number() for integer parsing
+    const parsed = parseInt(value, 10);
+    return isNaN(parsed) ? null : parsed;
+}
+// // Get display title for limits (shows original user limits on hover)
+// export function getLimitsDisplayTitle(deposit: { formattedMinAmount: string; formattedMaxAmount: string }): string {
+//   return `User set: ${deposit.formattedMinAmount} - ${deposit.formattedMaxAmount}`
+// }
+// Convert blockchain timestamp (seconds) to Date object
+export function timestampToDate(timestamp) {
+    if (!timestamp)
+        return null;
+    // Convert seconds to milliseconds for Date constructor
+    const timestampMs = Number(timestamp) * 1000;
+    return new Date(timestampMs);
+}
+// export function formatTokenAmountForDisplay(amount: bigint, tokenInfo: TokenInfo): string {
+//   return formatUnits(amount, { decimals: tokenInfo.decimals })
+// }
+export const formatAmount = (token, amount, options = {}) => {
+    if (!amount)
+        return null;
+    return formatUnits(amount, {
+        decimals: token.decimals,
+        truncateDecimals: Math.min(token.decimals - 4, 8),
+        padDecimals: 2,
+        ...options,
+    });
+};

package/dist/src/zkp2p-types.d.ts

@@ -0,0 +1,48 @@
+import type { Hex } from "viem";
+import type { ProviderKey, ValidationDepositData } from "./payment.js";
+export type ValidationOptions = {
+    providerKey: ProviderKey;
+    telegramHandle: string;
+    providerId: string;
+};
+export type Zkp2pResponse<T> = {
+    success: boolean;
+    message: string;
+    statusCode: number;
+    responseObject: T;
+};
+export type CreateResponse = {
+    id: number;
+    processorName: string;
+    depositData: string;
+    hashedOnchainId: Hex;
+    createdAt: string;
+};
+export type PayeeDetails = {
+    id: number;
+    processorName: string;
+    createdAt: string;
+    hashedOnchainId: Hex;
+    depositData: ValidationDepositData;
+};
+export type IntentValidationOptions = {
+    processorName: ProviderKey;
+    depositId: string;
+    tokenAmount: string;
+    payeeDetails: Hex;
+    toAddress: Hex;
+    fiatCurrencyCode: Hex;
+    chainId: string;
+};
+export type IntentValidation = {
+    signedIntent: Hex;
+    intentData: {
+        depositId: string;
+        tokenAmount: string;
+        recipientAddress: Hex;
+        verifierAddress: Hex;
+        currencyCodeHash: Hex;
+        gatingServiceSignature: Hex;
+    };
+    depositData: ValidationDepositData;
+};

package/dist/src/zkp2p-types.js

@@ -0,0 +1 @@
+export {};