@provex/utils 1.0.16

package/src/time.ts

@@ -0,0 +1,123 @@
+/** Interval in milliseconds */
+export const intervalIn = {
+  yearInDays: 365,
+  quarterInMonths: 3,
+  monthInDays: 30,
+  hourInDays: 24,
+  daysInWeek: 7,
+  minuteInHours: 60,
+  secondInMinutes: 60,
+  millisecondInSecond: 1000,
+} as const
+const second = intervalIn.millisecondInSecond
+const minute = intervalIn.secondInMinutes * second
+const hour = intervalIn.minuteInHours * minute
+const day = intervalIn.hourInDays * hour
+const month = intervalIn.monthInDays * day
+const year = intervalIn.yearInDays * month
+
+/** Intervals in milliseconds */
+export const interval = {
+  second,
+  minute,
+  hour,
+  day,
+  month,
+  year,
+} as const
+
+/** Default display intervals */
+export const defaultDisplayInterval = {
+  hour: 7 * 24,
+  day: 6 * 30,
+  month: 60,
+} as const
+
+/**
+ * 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 const formatTimestamp = (timestamp: number | Date | string, {
+  anchor = new Date(),
+  showSeconds = false,
+}: {
+  anchor?: Date,
+  showSeconds?: boolean,
+} = {}) => {
+  const date = new Date(timestamp)
+  const diffMs = anchor.getTime() - date.getTime()
+  const diffMins = Math.floor(diffMs / interval.minute)
+  const diffHours = Math.floor(diffMs / interval.hour)
+  const diffDays = Math.floor(diffMs / interval.day)
+  const diffMonths = Math.floor(diffDays / interval.month)
+  if (diffMonths > 0) {
+    if (diffMonths < intervalIn.quarterInMonths) {
+      return `${diffMonths}mo ${diffDays % intervalIn.monthInDays}d ago`
+    }
+    return `${diffMonths}mo ago`
+  }
+  if (diffMins < 1) {
+    if (showSeconds) {
+      if (diffMs < 10 * interval.second) {
+        return 'Just now'
+      }
+      return `${Math.floor(diffMs / interval.second)}s ago`
+    }
+    return 'Just now'
+  }
+  if (diffMins < intervalIn.secondInMinutes) {
+    return `${diffMins}m ago`
+  } else if (diffHours < intervalIn.hourInDays) {
+    if (diffHours < 6) {
+      return `${diffHours}h ${diffMins % intervalIn.minuteInHours}m ago`
+    }
+    return `${diffHours}h ago`
+  } else {
+    if (diffDays < intervalIn.daysInWeek) {
+      return `${diffDays}d ${diffHours % intervalIn.hourInDays}h ago`
+    }
+    return `${diffDays}d ago`
+  }
+}
+
+/**
+ * Format a duration
+ * @param param0.start - The start date
+ * @param param0.until - The end date
+ * @returns The formatted duration
+ */
+export const formatDuration = ({
+  start = new Date(),
+  until = new Date(),
+}: {
+  start?: Date,
+  until?: Date,
+} = {}) => {
+  const diffMs = until.getTime() - start.getTime()
+  const diffMins = Math.floor(diffMs / interval.minute)
+  const diffHours = Math.floor(diffMs / interval.hour)
+  const diffDays = Math.floor(diffMs / interval.day)
+  const diffMonths = Math.floor(diffDays / intervalIn.monthInDays)
+  if (diffMonths > 0) {
+    return `${diffMonths}mo ${diffDays % intervalIn.monthInDays}d`
+  }
+  if (diffDays > 0) {
+    return `${diffDays}d ${diffHours % intervalIn.hourInDays}h`
+  }
+  if (diffHours > 0) {
+    return `${diffHours}h ${diffMins % intervalIn.minuteInHours}m`
+  }
+  return `${diffMins % intervalIn.minuteInHours}m`
+}
+
+/**
+ * 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 const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
+
+export type TimeResolutionKey = "hour" | "day" | "month"

package/src/tokens.ts

@@ -0,0 +1,159 @@
+import {
+  createPublicClient, getAddress, http, type Chain
+} from 'viem'
+import { base, pulsechain } from 'viem/chains'
+import { chains, type ChainId } from './chain.js'
+
+/**
+ * Complete token information including address, symbol, name, and decimals.
+ * This is the root interface for all token-related operations.
+ */
+export interface TokenInfo {
+  address: string
+  decimals: number
+  symbol: string
+  name: string
+  chainId: ChainId
+  mainnetAddress?: string
+}
+
+const BASE_USDC = {
+  address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+  decimals: 6,
+  symbol: 'USDC',
+  name: 'USD Coin',
+  chainId: base.id,
+} as TokenInfo
+
+export const PULSECHAIN_USDC = {
+  address: '0x15D38573d2feeb82e7ad5187aB8c1D52810B1f07',
+  decimals: 6,
+  symbol: 'USDC',
+  name: 'USD Coin from Ethereum',
+  chainId: pulsechain.id,
+  mainnetAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+} as TokenInfo
+
+/** 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,
+} as Record<ChainId, Record<string, TokenInfo>>
+
+export const getDefaultToken = (chainId: ChainId | null) => {
+  return allTokensInfo[chainId ?? pulsechain.id]?.USDC ?? null
+}
+
+export const getDefaultTokens = (chainIds: ChainId[]) => {
+  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: ChainId): TokenInfo[] => {
+  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: ChainId, address: string | undefined): TokenInfo | null => {
+  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: 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/src/units.ts

@@ -0,0 +1,120 @@
+import { formatUnits as viemFormatUnits, parseUnits as viemParseUnits } from 'viem'
+import type { TokenInfo } from './tokens.js'
+
+export const oneEther = 10n ** 18n
+
+// Add thousands separators to a number string
+export function addThousandsSeparator(numberString: string, delimiter: string = ','): string {
+  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
+}
+
+// // Format currency amounts with exactly 2 decimal places and thousands separators
+// export function formatCurrencyDisplay(amount: bigint, decimals: number): string {
+//   const formatted = formatUnits(amount, decimals)
+//   const [integerPart, fractionalPart = ''] = formatted.split('.')
+
+//   // Ensure exactly 2 decimal places for currency
+//   const paddedFractional = fractionalPart.padEnd(2, '0').substring(0, 2)
+//   const numberString = `${integerPart}.${paddedFractional}`
+
+//   // Add thousands separators for better readability
+//   return addThousandsSeparator(numberString)
+// }
+
+// Options for formatRateDisplay function
+export interface FormatRateDisplayOptions {
+  decimals: number
+  truncateDecimals?: number
+  padDecimals?: number
+  cutoff?: bigint
+  delimiter?: string
+  roundUp?: boolean
+}
+
+export const parseUnits = (amount: string, options: Pick<FormatRateDisplayOptions, 'decimals' | 'delimiter'>): bigint => {
+  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: bigint, options: FormatRateDisplayOptions): string {
+  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: bigint, options: FormatRateDisplayOptions): string {
+  return formatUnits(amount, { truncateDecimals: 2, ...options })
+}
+
+// Safe integer parsing without using Number()
+export function parseIntegerSafe(value: string): number | null {
+  // 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: string | number | bigint | undefined | null): Date | null {
+  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: TokenInfo, amount: bigint | null, options: Partial<FormatRateDisplayOptions> = {}) => {
+  if (!amount) return null
+  return formatUnits(amount, {
+    decimals: token.decimals,
+    truncateDecimals: Math.min(token.decimals - 4, 8),
+    padDecimals: 2,
+    ...options,
+  })
+}

package/src/zkp2p-types.ts

@@ -0,0 +1,55 @@
+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/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "useDefineForClassFields": true,
+    "module": "NodeNext",
+    "composite": true,
+    "allowJs": true,
+    "outDir": "./dist",
+    "strict": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "moduleDetection": "force",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "nodenext"
+  },
+  "include": ["src/**/*.ts", "src/**/*.json", "src/**/*.svg", "scripts/**/*.ts"]
+}