payment-kit 1.24.3 → 1.25.0

package/api/src/queues/auto-recharge.ts

@@ -4,6 +4,7 @@ import { Op } from 'sequelize';
 import createQueue from '../libs/queue';
 import {
   AutoRechargeConfig,
+  ChainType,
   CreditGrant,
   Customer,
   Invoice,
@@ -11,6 +12,7 @@ import {
   PaymentCurrency,
   PaymentMethod,
   Price,
+  PriceQuote,
   Product,
   TPriceExpanded,
 } from '../store/models';
@@ -21,6 +23,11 @@ import { ensureInvoiceAndItems } from '../libs/invoice';
 import dayjs from '../libs/dayjs';
 import { invoiceQueue } from './invoice';
 import { getPriceUintAmountByCurrency } from '../libs/price';
+import { getExchangeRateService } from '../libs/exchange-rate/service';
+import { getExchangeRateSymbol, hasTokenAddress } from '../libs/exchange-rate/token-address-mapping';
+import { isRateBelowMinAcceptableRate } from '../libs/slippage';
+import { getQuoteService } from '../libs/quote-service';
+import { events } from '../libs/event';
 import { isDelegationSufficientForPayment } from '../libs/payment';
 
 export interface AutoRechargeJobData {
@@ -136,8 +143,209 @@ export async function processAutoRecharge(job: AutoRechargeJobData) {
     return;
   }
 
-  // 4. execute auto recharge
-  await executeAutoRecharge(customer, config, currency);
+  // 4. Check dynamic pricing constraints
+  const isDynamicPricing = config.price.pricing_type === 'dynamic';
+  let rateResult: DynamicPricingCheckResult['rateResult'];
+
+  if (isDynamicPricing) {
+    const dynamicPricingResult = await checkDynamicPricingConstraints({
+      customer,
+      config,
+    });
+
+    if (!dynamicPricingResult.canProceed) {
+      // Emit event for notification
+      events.emit('auto_recharge.skipped', {
+        config_id: config.id,
+        customer_id: customerId,
+        reason: dynamicPricingResult.reason,
+        current_rate: dynamicPricingResult.currentRate,
+        min_acceptable_rate: config.slippage_config?.min_acceptable_rate,
+        // Additional context for notification
+        payment_currency_symbol: config.rechargeCurrency.symbol,
+        payment_currency_name: config.rechargeCurrency.name,
+        credit_currency_name: currency.name,
+      });
+
+      logger.info('Auto recharge skipped due to dynamic pricing constraints', {
+        customerId,
+        currencyId,
+        reason: dynamicPricingResult.reason,
+        currentRate: dynamicPricingResult.currentRate,
+        minAcceptableRate: config.slippage_config?.min_acceptable_rate,
+      });
+      return;
+    }
+
+    rateResult = dynamicPricingResult.rateResult;
+  }
+
+  // 5. execute auto recharge
+  await executeAutoRecharge(customer, config, currency, rateResult);
+}
+
+interface DynamicPricingCheckResult {
+  canProceed: boolean;
+  reason?: 'slippage_exceeded' | 'exchange_rate_not_supported' | 'exchange_rate_fetch_failed';
+  currentRate?: string;
+  rateResult?: {
+    rate: string;
+    provider_id: string;
+    provider_name: string;
+    timestamp_ms: number;
+    degraded: boolean;
+    consensus_method?: string;
+    providers?: Array<{
+      provider_id: string;
+      provider_name: string;
+      rate: string;
+      timestamp_ms: number;
+      degraded: boolean;
+    }>;
+  };
+}
+
+/**
+ * Check if dynamic pricing constraints are met before creating quotes
+ * This only validates exchange rate availability and slippage threshold
+ * Quotes are created later when building the invoice
+ */
+async function checkDynamicPricingConstraints({
+  customer,
+  config,
+}: {
+  customer: Customer;
+  config: AutoRechargeConfig & {
+    paymentMethod: PaymentMethod;
+    price: TPriceExpanded;
+    rechargeCurrency: PaymentCurrency;
+  };
+}): Promise<DynamicPricingCheckResult> {
+  const methodType = config.paymentMethod.type as ChainType;
+
+  // Check if exchange rate is supported
+  if (!hasTokenAddress(config.rechargeCurrency.symbol, methodType)) {
+    return {
+      canProceed: false,
+      reason: 'exchange_rate_not_supported',
+    };
+  }
+
+  // Get current exchange rate
+  let rateResult;
+  try {
+    const exchangeRateService = getExchangeRateService();
+    const rateSymbol = getExchangeRateSymbol(config.rechargeCurrency.symbol, methodType);
+    rateResult = await exchangeRateService.getRate(rateSymbol);
+  } catch (error: any) {
+    logger.warn('Failed to fetch exchange rate for auto-recharge', {
+      error: error.message,
+      symbol: config.rechargeCurrency.symbol,
+      customerId: customer.id,
+    });
+    return {
+      canProceed: false,
+      reason: 'exchange_rate_fetch_failed',
+    };
+  }
+
+  // Check slippage if config exists
+  if (config.slippage_config?.min_acceptable_rate) {
+    const rateBelowMin = isRateBelowMinAcceptableRate(rateResult.rate, config.slippage_config.min_acceptable_rate);
+
+    if (rateBelowMin) {
+      return {
+        canProceed: false,
+        reason: 'slippage_exceeded',
+        currentRate: rateResult.rate,
+      };
+    }
+  }
+
+  return {
+    canProceed: true,
+    currentRate: rateResult.rate,
+    rateResult,
+  };
+}
+
+/**
+ * Create quotes for each line item and enrich them with quote info
+ * This follows the same pattern as attachQuotesForInvoice in subscription.ts
+ */
+async function attachQuotesForAutoRecharge(
+  lineItems: any[],
+  invoiceId: string,
+  config: AutoRechargeConfig & {
+    rechargeCurrency: PaymentCurrency;
+    slippage_config?: { percent?: number; min_acceptable_rate?: string };
+  },
+  rateResult: DynamicPricingCheckResult['rateResult']
+): Promise<{
+  enrichedLineItems: any[];
+  quotes: PriceQuote[];
+  totalAmount: BN;
+}> {
+  const quoteService = getQuoteService();
+  const slippagePercent = config.slippage_config?.percent;
+
+  // Create quotes for each line item
+  const quoteResults = await Promise.all(
+    lineItems.map(async (item) => {
+      const quoteResponse = await quoteService.createQuoteWithRate({
+        price_id: item.price_id,
+        invoice_id: invoiceId,
+        target_currency_id: config.recharge_currency_id!,
+        quantity: item.quantity,
+        rateResult: rateResult!,
+        slippage_percent: slippagePercent,
+      });
+      return { item, quoteResponse };
+    })
+  );
+
+  // Build quote map for lookup
+  const quoteMap = new Map<string, (typeof quoteResults)[number]>();
+  quoteResults.forEach((result) => {
+    quoteMap.set(result.item.price_id, result);
+  });
+
+  // Enrich line items with quote info
+  // Only store quote_id in metadata - full quote info is attached dynamically when querying
+  // See: invoices.ts attachQuoteMetadataToLines()
+  const enrichedLineItems = lineItems.map((item) => {
+    const hit = quoteMap.get(item.price_id);
+    if (!hit) {
+      return item;
+    }
+    const { quoteResponse } = hit;
+    return {
+      ...item,
+      quote_id: quoteResponse.quote.id,
+      custom_amount: quoteResponse.computed_unit_amount,
+      // Only store quote_id in metadata, not the full quote object
+      metadata: {
+        ...(item.metadata || {}),
+        quote_id: quoteResponse.quote.id,
+      },
+    };
+  });
+
+  // Calculate total amount from quotes
+  const totalAmount = quoteResults.reduce((sum, result) => {
+    return sum.add(new BN(result.quoteResponse.computed_unit_amount));
+  }, new BN(0));
+
+  const quotes = quoteResults.map((r) => r.quoteResponse.quote);
+
+  logger.info('Created quotes for auto-recharge line items', {
+    configId: config.id,
+    quoteIds: quotes.map((q) => q.id),
+    totalAmount: totalAmount.toString(),
+    slippagePercent,
+  });
+
+  return { enrichedLineItems, quotes, totalAmount };
 }
 
 async function createInvoiceForAutoRecharge({
@@ -145,26 +353,31 @@ async function createInvoiceForAutoRecharge({
   config,
   currency,
   price,
-  totalAmount,
   paymentMethod,
   rechargeCurrency,
+  isDynamicPricing,
+  rateResult,
 }: {
   customer: Customer;
   config: AutoRechargeConfig;
   currency: PaymentCurrency;
   price: TPriceExpanded;
-  totalAmount: BN;
   paymentMethod: PaymentMethod;
   rechargeCurrency: PaymentCurrency;
+  isDynamicPricing: boolean;
+  rateResult?: DynamicPricingCheckResult['rateResult'];
 }) {
   const now = dayjs().unix();
   const expandedItems = await Price.expand([{ price_id: price.id, quantity: config.quantity }], {
     product: true,
   });
+
   let status = 'open';
   if (paymentMethod.type === 'stripe') {
     status = 'draft'; // stripe invoice will be finalized and paid automatically
   }
+
+  // Check for existing invoice
   const existInvoice = await Invoice.findOne({
     where: {
       customer_id: customer.id,
@@ -180,14 +393,55 @@ async function createInvoiceForAutoRecharge({
       customerId: customer.id,
       configId: config.id,
     });
-    return existInvoice;
+    return { invoice: existInvoice, quotes: [] };
   }
+
+  // For dynamic pricing, create quotes for each line item
+  let lineItems = expandedItems;
+  let totalAmount: BN;
+  let quotes: PriceQuote[] = [];
+
+  if (isDynamicPricing && rateResult) {
+    // Generate a temporary invoice ID for quote creation
+    // We'll update the quotes with the actual invoice ID after creation
+    const tempInvoiceId = `temp-auto-recharge-${config.id}-${Date.now()}`;
+    const quoteResult = await attachQuotesForAutoRecharge(expandedItems, tempInvoiceId, config as any, rateResult);
+    lineItems = quoteResult.enrichedLineItems;
+    totalAmount = quoteResult.totalAmount;
+    quotes = quoteResult.quotes;
+  } else {
+    // Fixed pricing: calculate from price config
+    const priceAmount = await getPriceUintAmountByCurrency(price, rechargeCurrency.id);
+    totalAmount = new BN(priceAmount).mul(new BN(config.quantity ?? 1));
+  }
+
+  // Build metadata
+  const invoiceMetadata: Record<string, any> = {
+    auto_recharge: {
+      config_id: config.id,
+      currency_id: rechargeCurrency.id,
+    },
+  };
+
+  const firstQuote = quotes.length > 0 ? quotes[0] : undefined;
+  if (firstQuote) {
+    invoiceMetadata.quote_ids = quotes.map((q) => q.id);
+    // Also store the first quote's info for backwards compatibility
+    invoiceMetadata.quote = {
+      quote_id: firstQuote.id,
+      exchange_rate: firstQuote.exchange_rate,
+      quoted_amount: firstQuote.quoted_amount,
+      max_payable_token: firstQuote.max_payable_token,
+      slippage_percent: firstQuote.slippage_percent,
+    };
+  }
+
   const { invoice } = await ensureInvoiceAndItems({
     customer,
     currency: rechargeCurrency,
     trialing: false,
     metered: false,
-    lineItems: expandedItems,
+    lineItems,
     applyCredit: false,
     props: {
       status,
@@ -204,19 +458,26 @@ async function createInvoiceForAutoRecharge({
       custom_fields: [],
       footer: '',
       payment_settings: config.payment_settings,
-      metadata: {
-        auto_recharge: {
-          config_id: config.id,
-          currency_id: rechargeCurrency.id,
-        },
-      },
+      metadata: invoiceMetadata,
     } as unknown as Invoice,
   });
+
+  // Link all quotes to the actual invoice
+  if (quotes.length > 0) {
+    await Promise.all(quotes.map((q) => q.update({ invoice_id: invoice.id })));
+    logger.info('Quotes linked to auto recharge invoice', {
+      quoteIds: quotes.map((q) => q.id),
+      invoiceId: invoice.id,
+    });
+  }
+
   logger.info('New invoice created for auto recharge', {
     customerId: customer.id,
     configId: config.id,
     invoiceId: invoice.id,
-    amount: totalAmount,
+    amount: totalAmount.toString(),
+    quoteIds: quotes.map((q) => q.id),
+    isDynamicPricing: quotes.length > 0,
   });
   if (status !== 'draft') {
     invoiceQueue.push({
@@ -225,7 +486,7 @@ async function createInvoiceForAutoRecharge({
     });
     logger.info('Invoice job scheduled for auto recharge', { invoice: invoice.id, customerId: customer.id });
   }
-  return invoice;
+  return { invoice, quotes };
 }
 
 async function executeAutoRecharge(
@@ -235,15 +496,15 @@ async function executeAutoRecharge(
     price: TPriceExpanded;
     rechargeCurrency: PaymentCurrency;
   },
-  currency: PaymentCurrency
+  currency: PaymentCurrency,
+  rateResult?: DynamicPricingCheckResult['rateResult']
 ) {
   const paymentMethod = config.paymentMethod!;
   const price = config.price! as TPriceExpanded;
   const rechargeCurrency = config.rechargeCurrency!;
+  const isDynamicPricing = price.pricing_type === 'dynamic';
 
   try {
-    const priceAmount = await getPriceUintAmountByCurrency(price, rechargeCurrency.id);
-    const totalAmount = new BN(priceAmount).mul(new BN(config.quantity ?? 0));
     const paymentSettings = config.payment_settings;
     if (!paymentSettings) {
       throw new Error('No payment settings found for auto recharge');
@@ -253,12 +514,20 @@ async function executeAutoRecharge(
       throw new Error('No payer found for auto recharge');
     }
 
+    // Calculate totalAmount for balance check
+    const priceAmount = await getPriceUintAmountByCurrency(price, rechargeCurrency.id);
+    if (!priceAmount) {
+      throw new Error('Price amount is not valid');
+    }
+    const totalAmount = new BN(priceAmount).mul(new BN(config.quantity ?? 1)).toString();
+
+    // Check delegation balance for non-stripe payment methods
     if (paymentMethod.type !== 'stripe') {
       const balanceCheck = await isDelegationSufficientForPayment({
         paymentMethod,
         paymentCurrency: rechargeCurrency,
         userDid: payer,
-        amount: totalAmount.toString(),
+        amount: totalAmount,
       });
 
       if (!balanceCheck.sufficient) {
@@ -266,22 +535,27 @@ async function executeAutoRecharge(
           customerId: customer.id,
           configId: config.id,
           reason: balanceCheck.reason,
-          totalAmount: totalAmount.toString(),
+          totalAmount,
           payer,
         });
         throw new Error(`Insufficient balance: ${balanceCheck.reason}`);
       }
     }
 
-    const invoice = await createInvoiceForAutoRecharge({
+    const result = await createInvoiceForAutoRecharge({
       customer,
       config,
       currency,
       price,
-      totalAmount,
       paymentMethod,
       rechargeCurrency,
+      isDynamicPricing,
+      rateResult,
     });
+
+    // Handle both return types (existing invoice or new invoice)
+    const invoice = 'invoice' in result ? result.invoice : result;
+
     if (paymentMethod.type === 'stripe') {
       await createStripeInvoiceForAutoRecharge({
         autoRechargeConfig: config,

package/api/src/queues/exchange-rate-health.ts

@@ -0,0 +1,242 @@
+import createQueue from '../libs/queue';
+import logger from '../libs/logger';
+import { ExchangeRateProvider } from '../store/models/exchange-rate-provider';
+import { getExchangeRateService } from '../libs/exchange-rate';
+import { createEvent } from '../libs/audit';
+
+// Representative tokens to test for health checks
+const REPRESENTATIVE_TOKENS = ['ABT', 'ETH', 'USDC'];
+
+interface HealthCheckJob {
+  type: 'health_check';
+  timestamp: number;
+}
+
+interface HealthCheckResult {
+  providerId: string;
+  providerName: string;
+  success: boolean;
+  testedTokens: string[];
+  failedTokens: string[];
+  error?: string;
+}
+
+/**
+ * Perform health check on all active exchange rate providers
+ */
+async function performHealthCheck(): Promise<HealthCheckResult[]> {
+  logger.info('Starting exchange rate provider health check');
+
+  const providers = await ExchangeRateProvider.findAll({
+    where: { enabled: true },
+    order: [['priority', 'ASC']],
+  });
+
+  if (providers.length === 0) {
+    logger.warn('No enabled exchange rate providers found');
+    return [];
+  }
+
+  const results: HealthCheckResult[] = [];
+  const exchangeRateService = getExchangeRateService();
+
+  // Note: Sequential provider testing is intentional for health check isolation
+  // eslint-disable-next-line no-restricted-syntax
+  for (const provider of providers) {
+    const result: HealthCheckResult = {
+      providerId: provider.id,
+      providerName: provider.name,
+      success: true,
+      testedTokens: [],
+      failedTokens: [],
+    };
+
+    let hasSuccess = false;
+
+    // eslint-disable-next-line no-restricted-syntax
+    for (const symbol of REPRESENTATIVE_TOKENS) {
+      try {
+        // Clear cache to force fresh fetch
+        exchangeRateService.clearCache(symbol);
+
+        // Test fetching rate
+        // eslint-disable-next-line no-await-in-loop
+        await exchangeRateService.getRate(symbol);
+
+        result.testedTokens.push(symbol);
+        hasSuccess = true;
+
+        logger.debug('Health check success', {
+          provider: provider.name,
+          symbol,
+        });
+      } catch (error: any) {
+        result.failedTokens.push(symbol);
+
+        logger.warn('Health check failed for token', {
+          provider: provider.name,
+          symbol,
+          error: error.message,
+        });
+      }
+    }
+
+    result.success = hasSuccess;
+    if (!hasSuccess) {
+      result.error = `Failed to fetch rates for all representative tokens: ${REPRESENTATIVE_TOKENS.join(', ')}`;
+    }
+
+    results.push(result);
+  }
+
+  return results;
+}
+
+/**
+ * Send alert notification when all providers are unavailable
+ */
+async function sendProviderAlert(results: HealthCheckResult[]): Promise<void> {
+  const allProvidersFailed = results.every((r) => !r.success);
+
+  if (!allProvidersFailed) {
+    return;
+  }
+
+  const alertData = {
+    severity: 'critical',
+    title: 'All Exchange Rate Providers Unavailable',
+    message: 'All enabled exchange rate providers have failed health checks. Dynamic pricing is currently unavailable.',
+    timestamp: new Date().toISOString(),
+    providers: results.map((r) => ({
+      id: r.providerId,
+      name: r.providerName,
+      failedTokens: r.failedTokens,
+      error: r.error,
+    })),
+    impact: 'Users cannot create or view dynamic pricing quotes',
+    action: 'Please check provider configurations and network connectivity',
+  };
+
+  // Log critical alert
+  logger.error('CRITICAL: All exchange rate providers unavailable', alertData);
+
+  // Create audit event - this will trigger webhooks and emit event internally
+  try {
+    await createEvent('System', 'exchange_rate.providers_unavailable', alertData, {});
+  } catch (err) {
+    logger.error('Failed to create audit event for provider alert', { error: err });
+  }
+}
+
+/**
+ * Log health check results
+ *
+ * Note: We don't call recordFailure/recordSuccess here because
+ * exchangeRateService.getRate() already handles provider status updates internally.
+ * Calling them here would cause duplicate updates (failure_count += 2 instead of 1).
+ */
+function logHealthCheckResults(results: HealthCheckResult[]): void {
+  for (const result of results) {
+    if (result.success) {
+      logger.info('Provider health check passed', {
+        provider: result.providerName,
+        testedTokens: result.testedTokens,
+      });
+    } else {
+      logger.warn('Provider health check failed', {
+        provider: result.providerName,
+        failedTokens: result.failedTokens,
+        error: result.error,
+      });
+    }
+  }
+}
+
+/**
+ * Main health check job handler
+ */
+async function handleHealthCheckJob(job: HealthCheckJob): Promise<void> {
+  logger.info('Executing exchange rate provider health check job', { job });
+
+  try {
+    const results = await performHealthCheck();
+
+    // Log health check results (provider status already updated by service.getRate())
+    logHealthCheckResults(results);
+
+    // Send alert if all providers failed
+    await sendProviderAlert(results);
+
+    const failedCount = results.filter((r) => !r.success).length;
+    const successCount = results.length - failedCount;
+
+    logger.info('Health check completed', {
+      total: results.length,
+      success: successCount,
+      failed: failedCount,
+      timestamp: job.timestamp,
+    });
+  } catch (error: any) {
+    logger.error('Health check job failed', {
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+// Create the queue with scheduled job support
+export const exchangeRateHealthQueue = createQueue<HealthCheckJob>({
+  name: 'exchange-rate-health',
+  onJob: handleHealthCheckJob,
+  options: {
+    concurrency: 1,
+    maxRetries: 3,
+    retryDelay: 60 * 1000, // 1 minute
+    enableScheduledJob: true,
+  },
+});
+
+// Schedule health checks every 6 hours
+const HEALTH_CHECK_INTERVAL = 6 * 60 * 60; // 6 hours in seconds
+
+/**
+ * Initialize and schedule periodic health checks
+ */
+export function scheduleHealthChecks(): void {
+  const scheduleNext = () => {
+    const now = Math.floor(Date.now() / 1000);
+    const nextRun = now + HEALTH_CHECK_INTERVAL;
+
+    exchangeRateHealthQueue.push({
+      job: {
+        type: 'health_check',
+        timestamp: Date.now(),
+      },
+      runAt: nextRun,
+      persist: true,
+    });
+
+    logger.info('Scheduled next exchange rate health check', {
+      nextRunAt: new Date(nextRun * 1000).toISOString(),
+      intervalHours: HEALTH_CHECK_INTERVAL / 3600,
+    });
+  };
+
+  // Schedule initial check
+  scheduleNext();
+
+  // Listen for completed checks and schedule next one
+  exchangeRateHealthQueue.on('finished', () => {
+    scheduleNext();
+  });
+
+  logger.info('Exchange rate health check scheduling initialized', {
+    intervalHours: HEALTH_CHECK_INTERVAL / 3600,
+  });
+}
+
+// Export for explicit initialization in index.ts
+export function startExchangeRateHealthQueue(): void {
+  scheduleHealthChecks();
+}