payment-kit 1.24.4 → 1.25.0

package/api/src/routes/invoices.ts

@@ -5,7 +5,7 @@ import Joi from 'joi';
 import pick from 'lodash/pick';
 import { Op } from 'sequelize';
 
-import { BN } from '@ocap/util';
+import { BN, fromUnitToToken } from '@ocap/util';
 import { syncStripeInvoice } from '../integrations/stripe/handlers/invoice';
 import { syncStripePayment } from '../integrations/stripe/handlers/payment-intent';
 import { ensureStripeCustomer, ensureStripeSetupIntentForInvoicePayment } from '../integrations/stripe/resource';
@@ -33,11 +33,19 @@ import {
   PromotionCode,
   CreditGrant,
   TaxRate,
+  PriceQuote,
 } from '../store/models';
 import { mergePaginate, defaultTimeOrderBy, getCachedOrFetch, DataSource } from '../libs/pagination';
 import logger from '../libs/logger';
 import { returnOverdraftProtectionQueue, returnStakeQueue } from '../queues/subscription';
 import { checkRemainingStake } from '../libs/subscription';
+import { getExchangeRateService } from '../libs/exchange-rate';
+
+// Simple format amount helper for backend
+function formatAmountForDisplay(amount: string, decimal: number, symbol: string): string {
+  const tokenValue = fromUnitToToken(amount, decimal);
+  return `${parseFloat(tokenValue).toFixed(Math.min(decimal, 6))} ${symbol}`;
+}
 
 const router = Router();
 const authAdmin = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
@@ -156,6 +164,7 @@ const schema = createListParamSchema<{
   include_return_staking?: boolean;
   include_overdraft_protection?: boolean;
   include_recovered_from?: boolean;
+  include_quote?: boolean;
   tax_rate_id?: string;
 }>({
   status: Joi.string().empty(''),
@@ -168,9 +177,64 @@ const schema = createListParamSchema<{
   include_return_staking: Joi.boolean().empty(false),
   include_overdraft_protection: Joi.boolean().default(true),
   include_recovered_from: Joi.boolean().empty(false),
+  include_quote: Joi.boolean().empty(false),
   tax_rate_id: Joi.string().empty(''),
 });
 
+const buildQuoteMetadata = (quote: PriceQuote) => {
+  const slippagePercent = quote.slippage_percent ?? (quote.metadata as any)?.slippage?.percent ?? null;
+  const minAcceptableRate = quote.min_acceptable_rate ?? (quote.metadata as any)?.slippage?.min_acceptable_rate ?? null;
+  const maxPayableToken = quote.max_payable_token ?? (quote.metadata as any)?.slippage?.max_payable_token ?? null;
+  const derivedAtMs = quote.slippage_derived_at_ms ?? (quote.metadata as any)?.slippage?.derived_at_ms ?? null;
+  const degraded = (quote.metadata as any)?.risk?.degraded ?? null;
+  const degradedReason = (quote.metadata as any)?.risk?.degraded_reason ?? null;
+
+  return {
+    id: quote.id,
+    base_currency: quote.base_currency,
+    base_amount: quote.base_amount,
+    quoted_amount: quote.quoted_amount,
+    target_currency_id: quote.target_currency_id,
+    rate_currency_symbol: quote.rate_currency_symbol,
+    exchange_rate: quote.exchange_rate,
+    rate_provider_name: quote.rate_provider_name,
+    rate_provider_id: quote.rate_provider_id,
+    rate_timestamp_ms: quote.rate_timestamp_ms,
+    consensus_method: (quote.metadata as any)?.rate?.consensus_method || null,
+    providers: (quote.metadata as any)?.rate?.providers || [],
+    degraded,
+    degraded_reason: degradedReason,
+    slippage_percent: slippagePercent,
+    min_acceptable_rate: minAcceptableRate,
+    max_payable_token: maxPayableToken,
+    derived_at_ms: derivedAtMs,
+    status: quote.status,
+  };
+};
+
+const attachQuoteMetadataToLines = (lines: any[] | undefined, quotesById: Map<string, PriceQuote>) => {
+  if (!lines?.length) {
+    return;
+  }
+  lines.forEach((line) => {
+    const quoteId = line?.metadata?.quote_id;
+    if (!quoteId) {
+      return;
+    }
+    const quote = quotesById.get(quoteId);
+    if (!quote) {
+      return;
+    }
+    line.metadata = {
+      ...(line.metadata || {}),
+      quote: {
+        ...(line.metadata?.quote || {}),
+        ...buildQuoteMetadata(quote),
+      },
+    };
+  });
+};
+
 router.get('/', authMine, async (req, res) => {
   try {
     // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -183,6 +247,7 @@ router.get('/', authMine, async (req, res) => {
       include_staking,
       include_return_staking,
       include_overdraft_protection = true,
+      include_quote = false,
       ...query
     } = await schema.validateAsync(req.query, {
       stripUnknown: false,
@@ -191,6 +256,8 @@ router.get('/', authMine, async (req, res) => {
 
     const taxRateId = query.tax_rate_id;
     delete query.tax_rate_id;
+    delete (query as any).include_quote;
+    const includeQuote = include_quote === true;
 
     const where = getWhereFromKvQuery(query.q);
 
@@ -275,7 +342,7 @@ router.get('/', authMine, async (req, res) => {
               model: InvoiceItem,
               as: 'lines',
               where: { tax_rate_id: taxRateId },
-              attributes: [],
+              attributes: includeQuote ? ['id', 'metadata', 'amount', 'quantity', 'price_id'] : [],
               required: true,
             },
             { model: PaymentCurrency, as: 'paymentCurrency' },
@@ -283,6 +350,28 @@ router.get('/', authMine, async (req, res) => {
             { model: Subscription, as: 'subscription', attributes: ['id', 'description'] },
             { model: Customer, as: 'customer' },
           ],
+        }).then(async (result) => {
+          if (!includeQuote) {
+            return result;
+          }
+          const quoteIds = new Set<string>();
+          result.forEach((invoice) => {
+            (invoice as any).lines?.forEach((line: any) => {
+              const quoteId = line?.metadata?.quote_id;
+              if (typeof quoteId === 'string' && quoteId.length > 0) {
+                quoteIds.add(quoteId);
+              }
+            });
+          });
+          if (quoteIds.size === 0) {
+            return result;
+          }
+          const quotes = await PriceQuote.findAll({ where: { id: Array.from(quoteIds) } });
+          const quotesById = new Map(quotes.map((quote) => [quote.id, quote]));
+          result.forEach((invoice) => {
+            attachQuoteMetadataToLines((invoice as any).lines, quotesById);
+          });
+          return result;
         }),
       ]);
 
@@ -308,6 +397,15 @@ router.get('/', authMine, async (req, res) => {
           limit,
           offset,
           include: [
+            ...(includeQuote
+              ? [
+                  {
+                    model: InvoiceItem,
+                    as: 'lines',
+                    attributes: ['id', 'metadata', 'amount', 'quantity', 'price_id'],
+                  },
+                ]
+              : []),
             { model: PaymentCurrency, as: 'paymentCurrency' },
             { model: PaymentMethod, as: 'paymentMethod' },
             { model: Subscription, as: 'subscription', attributes: ['id', 'description'] },
@@ -326,6 +424,24 @@ router.get('/', authMine, async (req, res) => {
             { model: Customer, as: 'customer' },
           ],
         });
+        if (includeQuote && result.length > 0) {
+          const quoteIds = new Set<string>();
+          result.forEach((invoice) => {
+            (invoice as any).lines?.forEach((line: any) => {
+              const quoteId = line?.metadata?.quote_id;
+              if (typeof quoteId === 'string' && quoteId.length > 0) {
+                quoteIds.add(quoteId);
+              }
+            });
+          });
+          if (quoteIds.size > 0) {
+            const quotes = await PriceQuote.findAll({ where: { id: Array.from(quoteIds) } });
+            const quotesById = new Map(quotes.map((quote) => [quote.id, quote]));
+            result.forEach((invoice) => {
+              attachQuoteMetadataToLines((invoice as any).lines, quotesById);
+            });
+          }
+        }
         return result;
       },
       meta: {
@@ -786,6 +902,42 @@ router.get('/:id', authPortal, async (req, res) => {
         });
       }
 
+      // Fetch related price quotes
+      let quotes: any[] = [];
+      try {
+        quotes = await PriceQuote.findAll({
+          where: {
+            invoice_id: doc.id,
+          },
+          order: [['created_at', 'ASC']],
+        });
+        const quoteIds = new Set<string>();
+        (json as any).lines?.forEach((line: any) => {
+          const quoteId = line?.metadata?.quote_id;
+          if (typeof quoteId === 'string' && quoteId.length > 0) {
+            quoteIds.add(quoteId);
+          }
+        });
+        if (quoteIds.size > 0) {
+          const quotesById = new Map(quotes.map((quote) => [quote.id, quote]));
+          const missingIds = Array.from(quoteIds).filter((id) => !quotesById.has(id));
+          if (missingIds.length > 0) {
+            const quotesByLine = await PriceQuote.findAll({ where: { id: missingIds } });
+            quotesByLine.forEach((quote) => quotesById.set(quote.id, quote));
+          }
+          quotes = Array.from(quotesById.values());
+          attachQuoteMetadataToLines((json as any).lines, quotesById);
+        } else if (quotes.length > 0) {
+          const quotesById = new Map(quotes.map((quote) => [quote.id, quote]));
+          attachQuoteMetadataToLines((json as any).lines, quotesById);
+        }
+      } catch (error) {
+        logger.error('Failed to fetch related price quotes', {
+          error,
+          invoiceId: doc.id,
+        });
+      }
+
       if (doc.metadata?.invoice_id || doc.metadata?.prev_invoice_id) {
         const relatedInvoice = await Invoice.findByPk(doc.metadata.invoice_id || doc.metadata.prev_invoice_id, {
           attributes: ['id', 'number', 'status', 'billing_reason'],
@@ -797,6 +949,7 @@ router.get('/:id', authPortal, async (req, res) => {
           relatedCreditGrants,
           paymentLink,
           checkoutSession,
+          quotes,
         });
       }
       return res.json({
@@ -805,6 +958,7 @@ router.get('/:id', authPortal, async (req, res) => {
         relatedCreditGrants,
         paymentLink,
         checkoutSession,
+        quotes,
       });
     }
     return res.status(404).json(null);
@@ -814,6 +968,129 @@ router.get('/:id', authPortal, async (req, res) => {
   }
 });
 
+/**
+ * Get available payment options for an invoice with estimated prices
+ * Used when user wants to switch payment method after price change
+ */
+router.get('/:id/payment-options', authPortal, async (req, res) => {
+  try {
+    const invoice = await Invoice.findByPk(req.params.id, {
+      include: [
+        { model: InvoiceItem, as: 'lines' },
+        { model: PaymentCurrency, as: 'paymentCurrency' },
+      ],
+    });
+
+    if (!invoice) {
+      return res.status(404).json({ error: 'Invoice not found' });
+    }
+
+    // Get all available currencies for this invoice's products
+    const invoiceItems = (invoice as any).lines || [];
+    const priceIds = invoiceItems.map((item: any) => item.price_id).filter(Boolean);
+
+    // Get all unique product IDs from prices
+    const prices = await Price.findAll({
+      where: { id: priceIds },
+      include: [{ model: PaymentCurrency, as: 'currencies' }],
+    });
+
+    // Collect all unique currencies
+    const currencyMap = new Map<string, any>();
+    const currentCurrencyId = invoice.currency_id;
+
+    // Add current currency first
+    const { paymentCurrency } = invoice as any;
+    if (paymentCurrency) {
+      const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+      currencyMap.set(paymentCurrency.id, {
+        ...paymentCurrency.toJSON(),
+        method: paymentMethod?.toJSON(),
+      });
+    }
+
+    // Add other available currencies from prices
+    for (const price of prices) {
+      const priceCurrencies = (price as any).currencies || [];
+      for (const currency of priceCurrencies) {
+        if (!currencyMap.has(currency.id)) {
+          // eslint-disable-next-line no-await-in-loop
+          const paymentMethod = await PaymentMethod.findByPk(currency.payment_method_id);
+          currencyMap.set(currency.id, {
+            ...currency.toJSON(),
+            method: paymentMethod?.toJSON(),
+          });
+        }
+      }
+    }
+
+    // Calculate estimated amounts for each currency
+    const exchangeRateService = getExchangeRateService();
+    const options = [];
+
+    for (const [currencyId, currency] of currencyMap) {
+      let estimatedAmount = '';
+      const isCurrentMethod = currencyId === currentCurrencyId;
+
+      // For current method, use the invoice amount
+      if (isCurrentMethod) {
+        estimatedAmount = formatAmountForDisplay(invoice.amount_due, currency.decimal, currency.symbol);
+      } else {
+        // For other methods, calculate based on USD base amount and current exchange rate
+        try {
+          // Get USD total from line items
+          let usdTotal = 0;
+          for (const item of invoiceItems) {
+            const itemPrice = prices.find((p) => p.id === item.price_id);
+            if (itemPrice?.base_amount) {
+              usdTotal += parseFloat(itemPrice.base_amount) * item.quantity;
+            }
+          }
+
+          if (usdTotal > 0) {
+            // Get exchange rate for this currency
+            const rateSymbol =
+              currency.method?.type === 'arcblock' ? 'ABT' : `${currency.symbol}@${currency.method?.type}`;
+            // eslint-disable-next-line no-await-in-loop
+            const rateResult = await exchangeRateService.getRate(rateSymbol);
+            const rate = parseFloat(rateResult.rate);
+
+            if (rate > 0) {
+              const tokenAmount = usdTotal / rate;
+              const tokenAmountInUnits = Math.floor(tokenAmount * 10 ** currency.decimal);
+              estimatedAmount = `≈ ${formatAmountForDisplay(tokenAmountInUnits.toString(), currency.decimal, currency.symbol)}`;
+            }
+          }
+        } catch (error) {
+          logger.warn('Failed to calculate estimated amount for currency', {
+            currencyId,
+            error: (error as Error).message,
+          });
+          estimatedAmount = '—';
+        }
+      }
+
+      options.push({
+        currency,
+        estimatedAmount,
+        isCurrentMethod,
+      });
+    }
+
+    // Sort: current method first, then by symbol
+    options.sort((a, b) => {
+      if (a.isCurrentMethod) return -1;
+      if (b.isCurrentMethod) return 1;
+      return a.currency.symbol.localeCompare(b.currency.symbol);
+    });
+
+    return res.json({ options });
+  } catch (err: any) {
+    logger.error('Failed to get payment options for invoice', { error: err, invoiceId: req.params.id });
+    return res.status(500).json({ error: `Failed to get payment options: ${err.message}` });
+  }
+});
+
 router.post('/pay-stripe', authPortal, async (req, res) => {
   try {
     const { invoice_ids, subscription_id, customer_id, currency_id } = req.body;
@@ -1021,4 +1298,5 @@ router.post('/:id/void', authAdmin, async (req, res) => {
     return res.status(400).json({ error: 'Failed to void invoice' });
   }
 });
+
 export default router;

package/api/src/routes/payment-links.ts

@@ -138,6 +138,19 @@ export async function createPaymentLink(payload: any) {
     throw new Error('Multiple items with custom unit amount are not supported in payment link');
   }
 
+  // Check for mixed pricing types (fixed + dynamic)
+  const hasDynamicPricing = items.some((item) => {
+    return item.price?.pricing_type === 'dynamic';
+  });
+
+  const hasFixedPricing = items.some((item) => {
+    return !item.price?.pricing_type || item.price?.pricing_type === 'fixed';
+  });
+
+  if (hasDynamicPricing && hasFixedPricing) {
+    throw new Error('Cannot mix fixed pricing and dynamic pricing in the same payment link');
+  }
+
   for (let i = 0; i < items.length; i++) {
     const result = isLineItemAligned(items, i);
     if (result.currency === false) {

package/api/src/routes/prices.ts

@@ -5,6 +5,8 @@ import pick from 'lodash/pick';
 import type { WhereOptions } from 'sequelize';
 
 import { createListParamSchema, getOrder, getWhereFromQuery, MetadataSchema } from '../libs/api';
+import { getExchangeRateService } from '../libs/exchange-rate';
+import { getExchangeRateSymbol, hasTokenAddress } from '../libs/exchange-rate/token-address-mapping';
 import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
 import { canUpsell } from '../libs/session';
@@ -12,7 +14,7 @@ import { PaymentCurrency } from '../store/models/payment-currency';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
 import { checkCurrencySupportRecurring } from '../libs/product';
-import { Meter } from '../store/models';
+import { ChainType, Meter, PaymentMethod } from '../store/models';
 
 const router = Router();
 
@@ -66,6 +68,41 @@ const CreditConfigSchema = Joi.object({
     'any.invalid': 'valid_duration_* is mutually exclusive with schedule.expire_with_next_grant',
   });
 
+const exchangeRateService = getExchangeRateService();
+
+async function validateDynamicPricingCurrencies(currencyIds: string[]): Promise<string | null> {
+  if (!currencyIds?.length) {
+    return null;
+  }
+
+  const uniqueIds = Array.from(new Set(currencyIds.filter(Boolean)));
+  const currencies = (await PaymentCurrency.findAll({
+    where: { id: uniqueIds },
+    include: [{ model: PaymentMethod, as: 'payment_method' }],
+  })) as (PaymentCurrency & { payment_method: PaymentMethod })[];
+  const unsupported: string[] = [];
+
+  await Promise.all(
+    currencies.map(async (currency) => {
+      const rateSymbol = getExchangeRateSymbol(currency.symbol, currency.payment_method?.type as ChainType);
+      if (currency.payment_method.type === 'stripe') {
+        return;
+      }
+      if (!hasTokenAddress(rateSymbol)) {
+        unsupported.push(`${currency.symbol}: missing token mapping`);
+        return;
+      }
+      try {
+        await exchangeRateService.getRate(rateSymbol);
+      } catch (error: any) {
+        unsupported.push(`${currency.symbol}: ${error.message}`);
+      }
+    })
+  );
+
+  return unsupported.length ? `Exchange rate not available for ${unsupported.join(', ')}` : null;
+}
+
 export async function getExpandedPrice(id: string) {
   const price = await Price.findByPkOrLookupKey(id, {
     include: [
@@ -285,6 +322,18 @@ router.post('/', auth, async (req, res) => {
         return res.status(400).json({ error: `metadata invalid: ${metadataError.message}` });
       }
     }
+
+    if (req.body.pricing_type === 'dynamic') {
+      const currencyIds = req.body.currency_options?.map((x: any) => x.currency_id).filter(Boolean) || [];
+      if (req.body.currency_id) {
+        currencyIds.push(req.body.currency_id);
+      }
+      const validationError = await validateDynamicPricingCurrencies(currencyIds);
+      if (validationError) {
+        return res.status(400).json({ error: validationError });
+      }
+    }
+
     const result = await createPrice({
       ...req.body,
       livemode: !!req.livemode,
@@ -388,7 +437,28 @@ router.put('/:id', auth, async (req, res) => {
       req.body,
       locked
         ? ['nickname', 'description', 'metadata', 'upsell', 'lookup_key', ...quantityKeys]
-        : ['type', 'model', 'active', 'livemode', 'nickname', 'recurring', 'description', 'tiers', 'unit_amount', 'transform_quantity', 'metadata', 'currency_id', 'lookup_key', 'currency_options', 'upsell', ...quantityKeys] // prettier-ignore
+        : [
+            'type',
+            'model',
+            'active',
+            'livemode',
+            'nickname',
+            'recurring',
+            'description',
+            'tiers',
+            'unit_amount',
+            'transform_quantity',
+            'metadata',
+            'currency_id',
+            'lookup_key',
+            'currency_options',
+            'upsell',
+            'pricing_type',
+            'base_currency',
+            'base_amount',
+            'dynamic_pricing_config',
+            ...quantityKeys,
+          ] // prettier-ignore
     )
   );
 
@@ -454,6 +524,18 @@ router.put('/:id', auth, async (req, res) => {
       .json({ error: `currency ${notSupportCurrencies.map((x) => x.name).join(', ')} does not support recurring` });
   }
 
+  const pricingType = updates.pricing_type || doc.pricing_type;
+  if (pricingType === 'dynamic') {
+    const currencyOptions = updates.currency_options || doc.currency_options || [];
+    const currencyIds = currencyOptions.map((x: any) => x.currency_id).filter(Boolean);
+    const validationError = await validateDynamicPricingCurrencies(
+      currencyIds.length ? currencyIds : [updates.currency_id || doc.currency_id]
+    );
+    if (validationError) {
+      return res.status(400).json({ error: validationError });
+    }
+  }
+
   try {
     await doc.update(Price.formatBeforeSave(updates));
     logger.info(`Price updated: ${req.params.id}`, { priceId: req.params.id, updates, requestedBy: req.user?.did });