@provex/utils 1.0.16

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@provex/utils",
+  "version": "1.0.16",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "type": "module",
+  "access": "public",
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./contracts": "./dist/src/contracts.js",
+    "./currencies": "./dist/src/currencies.js",
+    "./units": "./dist/src/units.js",
+    "./payment": "./dist/src/payment.js",
+    "./sort": "./dist/src/sort.js",
+    "./time": "./dist/src/time.js",
+    "./tokens": "./dist/src/tokens.js",
+    "./intent": "./dist/src/intent.js",
+    "./conversionRates": "./dist/src/conversionRates.js",
+    "./json": "./dist/src/json.js",
+    "./profit": "./dist/src/profit.js",
+    "./chain": "./dist/src/chain.js",
+    "./participants": "./dist/src/participants.js",
+    "./input": "./dist/src/input.js",
+    "./stats": "./dist/src/stats.js",
+    "./ids": "./dist/src/ids.js",
+    "./events": "./dist/src/events.js",
+    "./zkp2p-types": "./dist/src/zkp2p-types.js",
+    "./deposit": "./dist/src/deposit.js"
+  },
+  "scripts": {
+    "build": "tsx scripts/convert-svg && tsc && cp -r src/data dist/src/"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "tsx": "^4.20.3",
+    "typescript": "^5.9.2",
+    "viem": "^2.38.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0"
+  }
+}

package/scripts/convert-svg.ts

@@ -0,0 +1,22 @@
+import fs from 'fs';
+import path from 'path';
+
+const __dirname = import.meta.dirname;
+
+// Read SVG files and convert to TypeScript constants
+const svgDir = path.join(__dirname, '../src/flags');
+const outputFile = path.join(__dirname, '../src/flags.ts');
+
+const svgFiles = ['usd.svg', 'eur.svg'];
+let output = '// Auto-generated from SVG files\n\n';
+
+svgFiles.forEach(filename => {
+  const svgPath = path.join(svgDir, filename);
+  const svgContent = fs.readFileSync(svgPath, 'utf8');
+  const cleanSvg = svgContent.replace(/[\r\n]/g, ' ').replace(/\s+/g, ' ').trim();
+  const constName = filename.replace('.svg', '').toUpperCase() + '_FLAG_SVG';
+  output += `export const ${constName} = '${cleanSvg}';\n`;
+});
+
+fs.writeFileSync(outputFile, output);
+console.log('Generated flags.ts from SVG files');

package/src/chain.ts

@@ -0,0 +1,27 @@
+import { base, pulsechain, type Chain } from 'viem/chains'
+
+export const chains = [pulsechain, base] as [Chain, ...Chain[]]
+
+export const chainIds = chains.map((chain) => chain.id)
+
+export type ChainId = (typeof chainIds)[number]
+
+/**
+ * Get the explorer URL for a given chain, type, and hash
+ * @param chain - The chain to get the explorer URL for
+ * @param type - The type of explorer to use (tx or address)
+ * @param hash - The hash to get the explorer URL for
+ * @returns The explorer URL
+ */
+export function getExplorerUrl(chain: Chain, type: 'tx' | 'address', hash: string) {
+  return `${chain.blockExplorers?.default.url}/${type}/${hash}`
+}
+
+export const chainIdToChain = new Map<ChainId, Chain>(
+  chains.map((chain) => [chain.id, chain] as const)
+)
+
+export const chainIdToTargetBlockTime = new Map<number, number>([
+  [369, 10_000],
+  [8453, 2_000],
+])

package/src/contracts.ts

@@ -0,0 +1,89 @@
+import { getAddress, type Hex } from 'viem'
+import { base, pulsechain } from 'viem/chains'
+import type { ChainId } from './chain.js'
+
+/**
+ * Contracts for the app
+ */
+export type Contracts = {
+  gatingService: Hex
+  usdc: Hex
+  escrow: Hex[]
+  venmoReclaimVerifier: Hex[]
+  revolutReclaimVerifier: Hex[]
+  cashappReclaimVerifier: Hex[]
+  wiseReclaimVerifier: Hex[]
+  mercadopagoReclaimVerifier: Hex[]
+  zelleBaseVerifier: Hex[]
+  zelleBoAReclaimVerifier: Hex[]
+  zelleChaseReclaimVerifier: Hex[]
+  zelleCitiReclaimVerifier: Hex[]
+  paypalReclaimVerifier: Hex[]
+  monzoReclaimVerifier: Hex[]
+}
+
+export const reclaimSigners = {
+  zkp2pWitnessSigner: '0x0636c417755E3ae25C6c166D181c0607F4C572A3',
+  reclaimWitnessSigner: '0x244897572368eadf65bfbc5aec98d8e5443a9072',
+} as const
+
+export const baseContracts = {
+  gatingService: getAddress('0x396D31055Db28C0C6f36e8b36f18FE7227248a97'),
+  usdc: getAddress('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'),
+  escrow: [getAddress('0xCA38607D85E8F6294Dc10728669605E6664C2D70')],
+  venmoReclaimVerifier: [getAddress('0x9a733B55a875D0DB4915c6B36350b24F8AB99dF5')],
+  revolutReclaimVerifier: [getAddress('0xAA5A1B62B01781E789C900d616300717CD9A41aB')],
+  cashappReclaimVerifier: [getAddress('0x76D33A33068D86016B806dF02376dDBb23Dd3703')],
+  wiseReclaimVerifier: [getAddress('0xFF0149799631D7A5bdE2e7eA9b306c42b3d9a9ca')],
+  mercadopagoReclaimVerifier: [
+    // getAddress('0x00d003c73eab8feaec04bab976235915fe7641e3'),
+    getAddress('0xf2AC5be14F32Cbe6A613CFF8931d95460D6c33A3'),
+  ],
+  zelleBaseVerifier: [
+    // getAddress('0x1783f040783c0827fb64d128ece548d9b3613ad5'),
+    getAddress('0x431a078A5029146aAB239c768A615CD484519aF7'),
+  ],
+  zelleChaseReclaimVerifier: [getAddress('0xBcD7C6BBcA5869fBefe3E322263EE1090221D7A9')],
+  zelleBoAReclaimVerifier: [getAddress('0x809c7A20A2dbBB3210fC73Dd7C01Cd7Fa70C195F')],
+  zelleCitiReclaimVerifier: [getAddress('0x3128badc46dbe2e37bdd2d64f33fb3b3a639570e')],
+  paypalReclaimVerifier: [getAddress('0x03d17E9371C858072E171276979f6B44571C5DeA')],
+  monzoReclaimVerifier: [getAddress('0x0dE46433bD251027f73eD8f28E01eF05DA36a2E0')],
+} as Contracts
+
+export const pulsechainContracts = {
+  gatingService: getAddress('0x4Bd6364FCC4D8A537aBfee33B16E959794fDf9Cf'),
+  usdc: getAddress('0x15D38573d2feeb82e7ad5187aB8c1D52810B1f07'),
+  escrow: [getAddress('0x2932E08BFD212Ef0732257bDd6463BF55E9b97d7')],
+  cashappReclaimVerifier: [getAddress('0x9224433D6AD9a5A774ca74Ca33c01747FA710A9d')],
+  mercadopagoReclaimVerifier: [getAddress('0xc4D0cf4DF12e329f9c951d1D9BB815da6138850A')],
+  monzoReclaimVerifier: [getAddress('0xBde2c79c1897459e66C0fdF6764EED0c6839C878')],
+  nullifierRegistry: [getAddress('0x471D3c6C9E32CE2556d0117aC161Aa82AEac17d8')],
+  paypalReclaimVerifier: [getAddress('0x1DdBfd39a141C5A2329d849CADa6a83404E0Ce4F')],
+  revolutReclaimVerifier: [getAddress('0x8234AA463C8B94778f58eA0bFEfcBAC3683341A9')],
+  venmoReclaimVerifier: [getAddress('0x0Dd524dA03f610480aF3F433B411b6016cFBDeab')],
+  wiseReclaimVerifier: [getAddress('0x7B72d7CfAfDfD397E2460c933e84D16dc121845a')],
+  zelleBaseVerifier: [getAddress('0x539566771f9c38c6038aafc1946bf11af9cdb201')],
+  zelleBoAReclaimVerifier: [getAddress('0x506a746b8228F9f9d4522105b973Dc7223A64EAC')],
+  zelleChaseReclaimVerifier: [getAddress('0xB0aA0a58959465bBCf0eCbD62A84B743A5435c99')],
+  zelleCitiReclaimVerifier: [getAddress('0x5624E479924eBFb25B51F36e3FDaE605dADb448b')],
+} as Contracts
+
+export const contractsByChainId = new Map<ChainId, Contracts>([
+  [base.id, baseContracts],
+  [pulsechain.id, pulsechainContracts],
+])
+
+export const getContracts = (chainId: ChainId) => {
+  return contractsByChainId.get(chainId) ?? null
+}
+
+export const getLatestContract = (chainId: ChainId, key: keyof Contracts) => {
+  const contracts = getContracts(chainId)
+  if (!contracts) return null
+  const target = contracts[key]
+  if (!target) return null
+  if (Array.isArray(target)) {
+    return target[target.length - 1] ?? null
+  }
+  return target
+}

package/src/conversionRates.ts

@@ -0,0 +1,356 @@
+import type { Hex } from 'viem'
+import { Currency, SUPPORTED_CURRENCIES } from './currencies.js'
+import { verifierGetsKey, type ProviderKey } from './payment.js'
+import type { SortDirection } from './sort.js'
+import type { TokenInfo } from './tokens.js'
+import type { ChainId } from './chain.js'
+
+/**
+ * Conversion rate info
+ */
+export interface ConversionRateInfo {
+  depositConversionRateUpdatedId: string
+  currency: string
+  verifier: string
+  value: string
+  orderId: string
+  depositId: string
+  transaction: {
+    hash: string
+    block: {
+      timestamp: string
+    }
+  }
+}
+
+/**
+ * Conversion rate info with current deposit conversion rate updated
+ */
+export interface ConversionRateInfoWithCurrent extends ConversionRateInfo {
+  currentDepositConversionRateUpdatedId: string
+  currentDepositConversionRateUpdated: {
+    value: string
+  }
+}
+
+/**
+ * Provider rates
+ */
+export type ProviderRates<RateInfo> = Map<ProviderKey, Map<Hex, RateInfo>>
+
+/**
+ * Process conversion rates options
+ */
+interface ProcessConversionRatesOptions {
+  chainId: ChainId
+  events: ConversionRateInfoWithCurrent[]
+  sortOrder?: SortDirection // Default: 'desc' (most recent first)
+  includeHistorical?: boolean // Default: false (only latest rates)
+}
+
+/**
+ * Get conversion rate options
+ */
+interface GetConversionRateOptions {
+  events: ConversionRateInfoWithCurrent[]
+  currency: Hex
+  verifier: string
+  chainId: ChainId
+  includeHistory?: boolean // Default: false (only latest rate)
+  fallbackRate?: { currency: string; value: string; verifier: string } | null
+}
+
+/**
+ * Extract currencies options
+ */
+interface ExtractCurrenciesOptions {
+  providerRates: ProviderRates<ConversionRateInfo[]>
+  providersOnly?: ProviderKey[] // Filter to specific providers
+  currenciesOnly?: string[] // Filter to specific currencies
+}
+
+/**
+ * Process deposit currency added events into organized conversion rates
+ */
+export function processConversionRates(options: ProcessConversionRatesOptions): ProviderRates<ConversionRateInfo[]> {
+  const {
+    events,
+    sortOrder = 'asc',
+    includeHistorical = false,
+    chainId,
+  } = options
+
+  const ratesMap = new Map<ProviderKey, Map<Hex, ConversionRateInfo[]>>()
+
+  // Sort events by orderId
+  const sortedEvents = [...events].sort((a, b) =>
+    sortOrder === 'desc'
+      ? b.orderId.localeCompare(a.orderId)
+      : a.orderId.localeCompare(b.orderId)
+  )
+
+  for (const event of sortedEvents) {
+    if (!event.currentDepositConversionRateUpdated) continue
+
+    const providerKey = verifierGetsKey(chainId, event.verifier)
+    const currency = event.currency as Hex
+
+    // Get or create provider rates map
+    const providerRates = ratesMap.get(providerKey) ?? new Map<Hex, ConversionRateInfo[]>()
+
+    // Get or create currency rates array
+    const currencyRates = providerRates.get(currency) ?? []
+
+    const rateInfo: ConversionRateInfo = {
+      currency,
+      depositConversionRateUpdatedId: event.currentDepositConversionRateUpdatedId,
+      value: event.currentDepositConversionRateUpdated.value ?? '',
+      verifier: event.verifier,
+      orderId: event.orderId,
+      depositId: event.depositId,
+      transaction: {
+        hash: event.transaction!.hash!,
+        block: {
+          timestamp: event.transaction!.block!.timestamp
+        }
+      },
+    }
+
+    if (includeHistorical) {
+      // Add all rates chronologically
+      currencyRates.push(rateInfo)
+    } else {
+      // Only keep the latest rate (first in desc order, last in asc order)
+      if (currencyRates.length === 0) {
+        currencyRates.push(rateInfo)
+      } else if (sortOrder === 'asc') {
+        // Replace with newer rate
+        currencyRates[0] = rateInfo
+      }
+      // For desc order with includeHistorical=false, we only add the first (most recent) rate
+    }
+
+    providerRates.set(currency, currencyRates)
+    ratesMap.set(providerKey, providerRates)
+  }
+
+  return ratesMap
+}
+
+/**
+ * Get conversion rate for a specific currency and verifier combination
+ */
+export function getConversionRate(options: GetConversionRateOptions): ConversionRateInfo | ConversionRateInfo[] | null {
+  const {
+    events,
+    currency,
+    verifier,
+    chainId,
+    includeHistory = false,
+    fallbackRate
+  } = options
+
+  // Process rates to get organized data
+  const providerRates = processConversionRates({
+    events,
+    includeHistorical: includeHistory,
+    chainId,
+  })
+
+  const providerKey = verifierGetsKey(chainId, verifier)
+  const rates = providerRates.get(providerKey)?.get(currency)
+
+  if (rates && rates.length > 0) {
+    return includeHistory ? rates : rates[0]
+  }
+
+  // Check fallback rate if provided
+  if (fallbackRate &&
+    fallbackRate.currency === currency &&
+    fallbackRate.verifier === verifier) {
+    return {
+      depositConversionRateUpdatedId: '0',
+      currency: fallbackRate.currency,
+      value: fallbackRate.value,
+      verifier: fallbackRate.verifier,
+      depositId: '0',
+      orderId: '0', // Indicate this is a fallback/original rate
+      transaction: {
+        hash: '0',
+        block: {
+          timestamp: '0'
+        }
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Extract unique currencies from processed provider rates
+ */
+export function extractCurrencies(options: ExtractCurrenciesOptions): string[] {
+  const { providerRates, providersOnly, currenciesOnly } = options
+
+  const currencySet = new Set<string>()
+
+  for (const [providerKey, currencyMap] of providerRates.entries()) {
+    // Filter by providers if specified
+    if (providersOnly && !providersOnly.includes(providerKey)) {
+      continue
+    }
+
+    for (const [currency] of currencyMap.entries()) {
+      // Filter by currencies if specified
+      if (currenciesOnly && !currenciesOnly.includes(currency)) {
+        continue
+      }
+
+      currencySet.add(currency)
+    }
+  }
+
+  return Array.from(currencySet)
+}
+
+/**
+ * Get the latest conversion rate across all providers for a currency
+ */
+export function getLatestRateForCurrency(options: {
+  providerRates: ProviderRates<ConversionRateInfo>
+  currency: Hex
+  preferredProvider?: ProviderKey
+}): ConversionRateInfo | null {
+  const { providerRates, currency, preferredProvider } = options
+
+  let latestRate: ConversionRateInfo | null = null
+  let latestTimestamp = BigInt(0)
+
+  // Check preferred provider first
+  if (preferredProvider) {
+    const providerRate = providerRates.get(preferredProvider)?.get(currency)
+    if (providerRate && providerRate.transaction.block.timestamp) {
+      const tsmp = BigInt(providerRate.transaction.block.timestamp)
+      if (tsmp > latestTimestamp) {
+        latestRate = providerRate
+        latestTimestamp = tsmp
+      }
+    }
+  }
+
+  // Check all other providers
+  for (const [providerKey, currencyMap] of providerRates.entries()) {
+    if (providerKey === preferredProvider) continue // Already checked
+
+    const rate = currencyMap.get(currency)
+    if (rate && rate.transaction.block.timestamp) {
+      const tsmp = BigInt(rate.transaction.block.timestamp)
+      if (tsmp > latestTimestamp) {
+        latestRate = rate
+        latestTimestamp = tsmp
+      }
+    }
+  }
+
+  return latestRate
+}
+
+/**
+ * Get the primary conversion rate from processed provider rates
+ * Returns the first available rate, prioritizing by provider order
+ */
+export function getPrimaryConversionRate(providerRates: ProviderRates<ConversionRateInfo>): ConversionRateInfo | null {
+  for (const [, currencyMap] of providerRates) {
+    const usd = currencyMap.get(SUPPORTED_CURRENCIES.USD.contractId)
+    if (usd) {
+      return usd
+    }
+  }
+  for (const [, currencyMap] of providerRates) {
+    for (const [, rate] of currencyMap.entries()) {
+      return rate
+    }
+  }
+  return null
+}
+
+/**
+ * Get primary conversion rate for a specific currency across all providers
+ */
+export function getPrimaryRateForCurrency(
+  providerRates: ProviderRates<ConversionRateInfo>,
+  currency: Hex
+): ConversionRateInfo | null {
+  for (const [, currencyMap] of providerRates) {
+    const rates = currencyMap.get(currency)
+    if (rates) {
+      return rates
+    }
+  }
+  return null
+}
+
+/**
+ * Get the primary verifier (payment provider) from conversion rates
+ */
+export function getPrimaryVerifier(providerRates: ProviderRates<ConversionRateInfo>): string | null {
+  const primaryRate = getPrimaryConversionRate(providerRates)
+  return primaryRate?.verifier || null
+}
+
+/**
+ * Get the primary currency from conversion rates
+ */
+export function getPrimaryCurrency(providerRates: ProviderRates<ConversionRateInfo>): string | null {
+  const primaryRate = getPrimaryConversionRate(providerRates)
+  return primaryRate?.currency || null
+}
+
+/**
+ * Convert token input to currency
+ */
+export const convertTokenInputToCurrency = ({ token, amountOutInt, rate }: {
+  token: TokenInfo
+  amountOutInt: bigint
+  rate: bigint
+}): bigint => {
+  const oneCent = 10n ** BigInt(token.decimals - 2)
+  const oneEther = 10n ** 18n
+  const amountInInt = amountOutInt * BigInt(rate) / oneEther
+  const remainder = amountInInt % oneCent
+  const negativeSpace = oneCent - remainder
+  const finalAmountInInt = amountInInt + (negativeSpace === oneCent ? 0n : negativeSpace)
+  return finalAmountInInt
+}
+
+/**
+ * Convert currency amount to token amount out (inverse of convertTokenInputToCurrency)
+ * This accounts for the cent-rounding applied in the original function
+ */
+export const convertCurrencyToTokenOutput = ({
+  token,
+  currency,
+  currencyAmountInt,
+  rate,
+}: {
+  token: TokenInfo
+  currency: Currency
+  currencyAmountInt: bigint
+  rate: bigint
+}): bigint => {
+  const smallestUnit = 10n ** BigInt(token.decimals - currency.decimals)
+  const oneEther = 10n ** 18n
+
+  // First, we need to find the original amount before cent-rounding was applied
+  // The original function rounds up to the nearest cent, so we need to find
+  // the maximum token amount that would result in this currency amount after rounding
+
+  // Start with the direct inverse calculation
+  // console.log('currencyAmountInt', currencyAmountInt, smallestUnit, converter, rate)
+  let tokenAmountOut = (currencyAmountInt * smallestUnit * oneEther) / rate
+
+  const remainder = tokenAmountOut % smallestUnit
+  const finalTokenAmountOut = (tokenAmountOut - remainder)
+  return finalTokenAmountOut
+}