payment-kit 1.21.13 → 1.21.15

package/api/src/crons/payment-stat.ts

@@ -125,29 +125,37 @@ export async function createPaymentStat(date?: string) {
     // eslint-disable-next-line @typescript-eslint/no-shadow
     dates.map(async (date) => {
       const { stats, timestamp, currencies } = await getPaymentStat(date);
-      await Promise.all(
-        currencies.map(async (currency) => {
-          const exist = await PaymentStat.findOne({ where: { timestamp, currency_id: currency.id } });
-          if (exist) {
-            await exist.update({
-              amount_paid: stats.payment![currency.id] || '0',
-              amount_payout: stats.payout![currency.id] || '0',
-              amount_refund: stats.refund![currency.id] || '0',
-            });
-            logger.info('PaymentStat updated', { date, timestamp, currency: currency.symbol });
-          } else {
-            await PaymentStat.create({
-              livemode: currency.livemode,
-              timestamp,
-              currency_id: currency.id,
-              amount_paid: stats.payment![currency.id] || '0',
-              amount_payout: stats.payout![currency.id] || '0',
-              amount_refund: stats.refund![currency.id] || '0',
-            });
-            logger.info('PaymentStat created', { date, timestamp, currency: currency.symbol });
-          }
-        })
-      );
+      const currencyIds = currencies.map((currency) => currency.id);
+      const existingStats = await PaymentStat.findAll({
+        where: {
+          timestamp,
+          currency_id: { [Op.in]: currencyIds },
+        },
+        attributes: ['id', 'currency_id'],
+      });
+      const existingMap = existingStats.reduce<Record<string, string>>((acc, item) => {
+        acc[item.currency_id] = item.id;
+        return acc;
+      }, {});
+      const records = currencies.map((currency) => {
+        const base = {
+          livemode: currency.livemode,
+          timestamp,
+          currency_id: currency.id,
+          amount_paid: stats.payment?.[currency.id] || '0',
+          amount_payout: stats.payout?.[currency.id] || '0',
+          amount_refund: stats.refund?.[currency.id] || '0',
+        } as any;
+        const existingId = existingMap[currency.id];
+        if (existingId) {
+          base.id = existingId;
+        }
+        return base;
+      });
+      await PaymentStat.bulkCreate(records, {
+        updateOnDuplicate: ['amount_paid', 'amount_payout', 'amount_refund'],
+      });
+      logger.info('PaymentStat synced', { date, timestamp, count: records.length });
     })
   );
 }

package/api/src/libs/invoice.ts

@@ -20,6 +20,7 @@ import {
   SimpleCustomField,
   Subscription,
   SubscriptionItem,
+  TaxRate,
   TInvoice,
   TLineItemExpanded,
   UsageRecord,
@@ -520,8 +521,31 @@ async function createInvoiceWithItems(props: BaseInvoiceProps): Promise<{
   }
   // create invoice items
   const items = await Promise.all(
-    itemsData.map((item) =>
-      InvoiceItem.create({
+    itemsData.map(async (item) => {
+      // Match tax rate for this specific item
+      let taxRateId: string | undefined;
+      if (customer.address?.country && item.price_id) {
+        try {
+          const price = await Price.findByPk(item.price_id);
+          if (price?.product_id) {
+            const product = await Product.findByPk(price.product_id);
+            if (product) {
+              const taxRate = await TaxRate.findMatchingRate({
+                country: customer.address.country,
+                state: customer.address.state,
+                postalCode: customer.address.postal_code,
+                taxCode: product.tax_code,
+                livemode,
+              });
+              taxRateId = taxRate?.id;
+            }
+          }
+        } catch (error) {
+          logger.error('Failed to match tax rate for invoice item:', error);
+        }
+      }
+
+      return InvoiceItem.create({
         livemode,
         amount: item.amount,
         quantity: item.quantity,
@@ -533,6 +557,7 @@ async function createInvoiceWithItems(props: BaseInvoiceProps): Promise<{
         invoice_id: invoice.id,
         subscription_id: subscription?.id,
         subscription_item_id: item.subscription_item_id,
+        tax_rate_id: taxRateId,
         discountable: item.discountable || false,
         discounts: [], // Keep as empty for now - this is legacy field
         discount_amounts:
@@ -541,8 +566,8 @@ async function createInvoiceWithItems(props: BaseInvoiceProps): Promise<{
         proration: false,
         proration_details: {},
         metadata: item.metadata || {},
-      })
-    )
+      });
+    })
   );
 
   return { invoice, items };

package/api/src/libs/product.ts

@@ -3,6 +3,7 @@ import isEmpty from 'lodash/isEmpty';
 import { Op } from 'sequelize';
 import { CheckoutSession, PaymentCurrency, PaymentMethod, Price, Product, Subscription } from '../store/models';
 import { EVM_CHAIN_TYPES } from './constants';
+import { getApproveFunction } from '../integrations/ethereum/contract';
 
 export async function getMainProductName(subscriptionId: string): Promise<string> {
   const subscription = await Subscription.findByPk(subscriptionId);
@@ -74,11 +75,34 @@ export async function checkCurrencySupportRecurring(currencyIds: string[] | stri
     where: { id: { [Op.in]: currencyIdsArray } },
     include: [{ model: PaymentMethod, as: 'payment_method' }],
   })) as (PaymentCurrency & { payment_method: PaymentMethod })[];
-  const notSupportCurrencies = currencies.filter(
-    (c) => EVM_CHAIN_TYPES.includes(c.payment_method?.type) && c.payment_method?.default_currency_id === c.id
-  );
+
+  const notSupportCurrencies = (
+    await Promise.all(
+      currencies.map(async (currency) => {
+        const paymentMethod = currency.payment_method;
+        if (!paymentMethod) return null;
+
+        if (EVM_CHAIN_TYPES.includes(paymentMethod.type) && paymentMethod.default_currency_id === currency.id) {
+          return currency;
+        }
+
+        if (['ethereum', 'base'].includes(paymentMethod.type) && currency.contract) {
+          try {
+            const provider = paymentMethod.getEvmClient();
+            await getApproveFunction(provider, currency.contract);
+            return null;
+          } catch (err) {
+            return currency;
+          }
+        }
+
+        return null;
+      })
+    )
+  ).filter((c) => c !== null);
+
   return {
     notSupportCurrencies,
-    validate: notSupportCurrencies?.length === 0,
+    validate: notSupportCurrencies.length === 0,
   };
 }

package/api/src/routes/checkout-sessions.ts

@@ -108,6 +108,7 @@ import {
 import { rollbackDiscountUsageForCheckoutSession, applyDiscountsToLineItems } from '../libs/discount/discount';
 import { formatToShortUrl } from '../libs/url';
 import { destroyExistingInvoice } from '../libs/invoice';
+import { getApproveFunction } from '../integrations/ethereum/contract';
 
 const router = Router();
 
@@ -120,7 +121,51 @@ const getPaymentMethods = async (doc: CheckoutSession) => {
   const paymentMethods = await PaymentMethod.expand(doc.livemode, { type: doc.payment_method_types });
   const supportedCurrencies = getSupportedPaymentCurrencies(doc.line_items as any[]);
   const methods = getSupportedPaymentMethods(paymentMethods as any[], (x) => supportedCurrencies.includes(x.id));
-  return sortBy(methods, (m) => (m.payment_currencies.some((c) => c.is_base_currency) ? 0 : 1));
+
+  const needsApprove = ['subscription', 'setup'].includes(doc.mode);
+  if (!needsApprove) {
+    return sortBy(methods, (m) => (m.payment_currencies.some((c) => c.is_base_currency) ? 0 : 1));
+  }
+
+  const filteredMethods = await Promise.all(
+    methods.map(async (method) => {
+      if (!['ethereum', 'base'].includes(method.type)) {
+        return method;
+      }
+
+      const filteredCurrencies = await Promise.all(
+        method.payment_currencies.map(async (currency) => {
+          if (!currency.contract) {
+            return currency;
+          }
+
+          try {
+            const paymentMethodInstance = await PaymentMethod.findByPk(method.id);
+            if (!paymentMethodInstance) {
+              return null;
+            }
+            const provider = paymentMethodInstance.getEvmClient();
+            await getApproveFunction(provider, currency.contract);
+            return currency;
+          } catch (err: any) {
+            logger.warn(`Currency ${currency.id} (${currency.symbol}) does not support approve function`, {
+              contract: currency.contract,
+              error: err.message,
+            });
+            return null;
+          }
+        })
+      );
+
+      return {
+        ...method,
+        payment_currencies: filteredCurrencies.filter((c) => c !== null),
+      };
+    })
+  );
+
+  const validMethods = filteredMethods.filter((m) => m.payment_currencies.length > 0);
+  return sortBy(validMethods, (m) => (m.payment_currencies.some((c) => c.is_base_currency) ? 0 : 1));
 };
 
 const getPaymentTypes = async (items: any[]) => {

package/api/src/routes/index.ts

@@ -12,6 +12,7 @@ import events from './events';
 import stripe from './integrations/stripe';
 import invoices from './invoices';
 import meterEvents from './meter-events';
+import taxRates from './tax-rates';
 import meters from './meters';
 import passports from './passports';
 import paymentCurrencies from './payment-currencies';
@@ -75,6 +76,7 @@ router.use('/payment-currencies', paymentCurrencies);
 router.use('/payment-stats', paymentStats);
 router.use('/prices', prices);
 router.use('/pricing-tables', pricingTables);
+router.use('/tax-rates', taxRates);
 router.use('/products', products);
 router.use('/promotion-codes', promotionCodes);
 router.use('/payouts', payouts);

package/api/src/routes/invoices.ts

@@ -31,6 +31,7 @@ import {
   Coupon,
   PromotionCode,
   CreditGrant,
+  TaxRate,
 } from '../store/models';
 import { mergePaginate, defaultTimeOrderBy, getCachedOrFetch, DataSource } from '../libs/pagination';
 import logger from '../libs/logger';
@@ -154,6 +155,7 @@ const schema = createListParamSchema<{
   include_return_staking?: boolean;
   include_overdraft_protection?: boolean;
   include_recovered_from?: boolean;
+  tax_rate_id?: string;
 }>({
   status: Joi.string().empty(''),
   customer_id: Joi.string().empty(''),
@@ -165,6 +167,7 @@ const schema = createListParamSchema<{
   include_return_staking: Joi.boolean().empty(false),
   include_overdraft_protection: Joi.boolean().default(true),
   include_recovered_from: Joi.boolean().empty(false),
+  tax_rate_id: Joi.string().empty(''),
 });
 
 router.get('/', authMine, async (req, res) => {
@@ -185,6 +188,9 @@ router.get('/', authMine, async (req, res) => {
       allowUnknown: true,
     });
 
+    const taxRateId = query.tax_rate_id;
+    delete query.tax_rate_id;
+
     const where = getWhereFromKvQuery(query.q);
 
     if (status) {
@@ -242,7 +248,51 @@ router.get('/', authMine, async (req, res) => {
       where.billing_reason = { [Op.notIn]: excludeBillingReasons };
     }
 
-    // Build data sources with proper metadata
+    if (taxRateId) {
+      const [count, list] = await Promise.all([
+        Invoice.count({
+          where,
+          include: [
+            {
+              model: InvoiceItem,
+              as: 'lines',
+              where: { tax_rate_id: taxRateId },
+              attributes: [],
+              required: true,
+            },
+          ],
+          distinct: true,
+        }),
+        Invoice.findAll({
+          where,
+          order: getOrder(req.query, [['created_at', query.o === 'asc' ? 'ASC' : 'DESC']]),
+          limit: pageSize,
+          offset: (page - 1) * pageSize,
+          subQuery: false,
+          include: [
+            {
+              model: InvoiceItem,
+              as: 'lines',
+              where: { tax_rate_id: taxRateId },
+              attributes: [],
+              required: true,
+            },
+            { model: PaymentCurrency, as: 'paymentCurrency' },
+            { model: PaymentMethod, as: 'paymentMethod' },
+            { model: Subscription, as: 'subscription', attributes: ['id', 'description'] },
+            { model: Customer, as: 'customer' },
+          ],
+        }),
+      ]);
+
+      res.json({
+        count,
+        list,
+        paging: { page, pageSize },
+      });
+      return;
+    }
+
     const sources: DataSource<Invoice>[] = [];
 
     // Primary data source: Invoice database records
@@ -595,7 +645,18 @@ router.get('/:id', authPortal, async (req, res) => {
         { model: PaymentMethod, as: 'paymentMethod' },
         { model: PaymentIntent, as: 'paymentIntent' },
         { model: Subscription, as: 'subscription' },
-        { model: InvoiceItem, as: 'lines' },
+        {
+          model: InvoiceItem,
+          as: 'lines',
+          include: [
+            {
+              model: TaxRate,
+              as: 'tax_rate',
+              attributes: ['id', 'display_name', 'percentage', 'country', 'state', 'postal_code'],
+              required: false,
+            },
+          ],
+        },
         { model: Customer, as: 'customer' },
       ],
     })) as TInvoiceExpanded | null;

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

@@ -3,6 +3,7 @@ import Joi from 'joi';
 import { Op, type WhereOptions } from 'sequelize';
 import { joinURL } from 'ufo';
 
+import { BN } from '@ocap/util';
 import { getPaymentStat } from '../crons/payment-stat';
 import { getTokenSummaryByDid } from '../integrations/arcblock/stake';
 import { createListParamSchema, getOrder } from '../libs/api';
@@ -12,6 +13,7 @@ import { authenticate } from '../libs/security';
 import {
   EVMChainType,
   Invoice,
+  InvoiceItem,
   PaymentCurrency,
   PaymentIntent,
   PaymentMethod,
@@ -25,12 +27,19 @@ import logger from '../libs/logger';
 
 const router = Router();
 const auth = authenticate<PaymentStat>({ component: true, roles: ['owner', 'admin'] });
+const BILLING_REASON_EXCLUSIONS = ['stake', 'stake_overdraft_protection', 'recharge'];
 
 const schema = createListParamSchema<{ currency_id?: string; start?: number; end?: number }>({
   currency_id: Joi.string().optional().empty(''),
   start: Joi.number().positive().optional().empty(''),
   end: Joi.number().positive().optional().empty(''),
 });
+
+const summaryQuerySchema = Joi.object({
+  currency_id: Joi.string().optional().empty(''),
+  start: Joi.number().positive().optional().empty(''),
+  end: Joi.number().positive().optional().empty(''),
+});
 router.get('/', auth, async (req, res) => {
   const { page, pageSize, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
   const where: WhereOptions = {};
@@ -41,17 +50,16 @@ router.get('/', auth, async (req, res) => {
   if (query.currency_id) {
     where.currency_id = query.currency_id;
   }
-  where.timestamp = {};
-  if (query.start) {
-    where.timestamp[Op.gte] = query.start;
-  } else {
-    where.timestamp[Op.gte] = dayjs().subtract(30, 'days').startOf('day').unix();
-  }
-  if (query.end) {
-    where.timestamp[Op.lt] = query.end;
-  } else {
-    where.timestamp[Op.lt] = dayjs().endOf('day').unix();
-  }
+
+  const startTime = query.start || dayjs().subtract(30, 'days').startOf('day').unix();
+  const endTime = query.end || dayjs().endOf('day').unix();
+  const todayStart = dayjs().startOf('day').unix();
+  const todayEnd = dayjs().endOf('day').unix();
+
+  where.timestamp = {
+    [Op.gte]: startTime,
+    [Op.lte]: endTime,
+  };
 
   try {
     const { rows: list, count } = await PaymentStat.findAndCountAll({
@@ -60,9 +68,8 @@ router.get('/', auth, async (req, res) => {
       include: [],
     });
 
-    // Append live data at the end
-    const now = dayjs().unix();
-    if (query.end && query.end >= now) {
+    const includesToday = startTime <= todayEnd && endTime >= todayStart;
+    if (includesToday) {
       const { stats, timestamp, currencies } = await getPaymentStat(dayjs().toDate().toString());
       list.push(
         // @ts-ignore
@@ -112,25 +119,240 @@ async function getCurrencyLinks(livemode: boolean) {
   }, {} as any);
 }
 
-// eslint-disable-next-line consistent-return
+type RevenueStats = {
+  totalRevenue: string;
+  promotionCost: string;
+  vendorCost: string;
+  taxedRevenue: string;
+  netRevenue: string;
+};
+
+const ZERO_REVENUE_STATS: RevenueStats = {
+  totalRevenue: '0',
+  promotionCost: '0',
+  vendorCost: '0',
+  taxedRevenue: '0',
+  netRevenue: '0',
+};
+
+const buildCurrencyFilter = (currencyIds?: string[]) => {
+  if (!currencyIds || currencyIds.length === 0) {
+    return undefined;
+  }
+  if (currencyIds.length === 1) {
+    return currencyIds[0];
+  }
+  return { [Op.in]: currencyIds };
+};
+
+const addToMap = (map: Record<string, string>, key: string | null | undefined, value: string | number) => {
+  if (!key) {
+    return;
+  }
+  const previous = map[key] || '0';
+  map[key] = new BN(previous).add(new BN(value || '0')).toString();
+};
+
+const hasNonZeroValue = (values: string[]) => values.some((value) => !new BN(value || '0').isZero());
+
+async function getTaxedInvoiceIds(
+  livemode: boolean,
+  currencyIds?: string[],
+  start?: number,
+  end?: number
+): Promise<Set<string>> {
+  const invoiceWhere: WhereOptions = {
+    livemode,
+    status: 'paid',
+    billing_reason: { [Op.notIn]: BILLING_REASON_EXCLUSIONS },
+  };
+
+  const currencyFilter = buildCurrencyFilter(currencyIds);
+  if (currencyFilter) {
+    invoiceWhere.currency_id = currencyFilter;
+  }
+
+  if (start || end) {
+    invoiceWhere.created_at = {};
+    if (start) {
+      invoiceWhere.created_at[Op.gte] = new Date(start * 1000);
+    }
+    if (end) {
+      invoiceWhere.created_at[Op.lt] = new Date(end * 1000);
+    }
+  }
+
+  const invoiceItems = await InvoiceItem.findAll({
+    where: {
+      tax_rate_id: { [Op.ne]: null },
+    } as any,
+    include: [
+      {
+        model: Invoice,
+        as: 'invoice',
+        where: invoiceWhere,
+        attributes: ['id'],
+      },
+    ],
+    attributes: ['invoice_id'],
+  });
+
+  return new Set(invoiceItems.map((item: any) => item.invoice_id).filter(Boolean));
+}
+
+async function getRevenueStats(livemode: boolean, currencyId?: string, start?: number, end?: number) {
+  const currencyFilter = currencyId ? [currencyId] : undefined;
+
+  const invoiceWhere: WhereOptions = {
+    livemode,
+    status: 'paid',
+    billing_reason: { [Op.notIn]: BILLING_REASON_EXCLUSIONS },
+  };
+
+  const invoiceCurrencyFilter = buildCurrencyFilter(currencyFilter);
+  if (invoiceCurrencyFilter) {
+    invoiceWhere.currency_id = invoiceCurrencyFilter;
+  }
+
+  if (start || end) {
+    invoiceWhere.created_at = {};
+    if (start) {
+      invoiceWhere.created_at[Op.gte] = new Date(start * 1000);
+    }
+    if (end) {
+      invoiceWhere.created_at[Op.lt] = new Date(end * 1000);
+    }
+  }
+
+  const [invoices, taxedInvoiceIds] = await Promise.all([
+    Invoice.findAll({
+      where: invoiceWhere,
+      attributes: ['id', 'total', 'total_discount_amounts', 'currency_id'],
+    }),
+    getTaxedInvoiceIds(livemode, currencyFilter, start, end),
+  ]);
+
+  const totalRevenueByCurrency: Record<string, string> = {};
+  const promotionCostByCurrency: Record<string, string> = {};
+  const taxedRevenueByCurrency: Record<string, string> = {};
+
+  invoices.forEach((inv) => {
+    addToMap(totalRevenueByCurrency, inv.currency_id, inv.total);
+
+    const discounts = inv.total_discount_amounts || [];
+    if (discounts.length > 0) {
+      const invoiceDiscount = discounts.reduce((sum: BN, discount: any) => {
+        const amount = discount.amount || 0;
+        return sum.add(new BN(amount));
+      }, new BN('0'));
+      if (!invoiceDiscount.isZero()) {
+        addToMap(promotionCostByCurrency, inv.currency_id, invoiceDiscount.toString());
+      }
+    }
+
+    if (taxedInvoiceIds.has(inv.id)) {
+      addToMap(taxedRevenueByCurrency, inv.currency_id, inv.total);
+    }
+  });
+
+  const payoutWhere: WhereOptions = {
+    livemode,
+    status: { [Op.in]: ['paid', 'deferred'] },
+    vendor_info: { [Op.ne]: null },
+  };
+
+  const payoutCurrencyFilter = buildCurrencyFilter(currencyFilter);
+  if (payoutCurrencyFilter) {
+    payoutWhere.currency_id = payoutCurrencyFilter;
+  }
+
+  if (start || end) {
+    payoutWhere.created_at = {};
+    if (start) {
+      payoutWhere.created_at[Op.gte] = new Date(start * 1000);
+    }
+    if (end) {
+      payoutWhere.created_at[Op.lt] = new Date(end * 1000);
+    }
+  }
+
+  const payouts = await Payout.findAll({
+    where: payoutWhere,
+    attributes: ['amount', 'currency_id'],
+  });
+
+  const vendorCostByCurrency: Record<string, string> = {};
+  payouts.forEach((payout) => {
+    addToMap(vendorCostByCurrency, payout.currency_id, payout.amount || '0');
+  });
+
+  const currencySet = new Set<string>(currencyFilter || []);
+  [totalRevenueByCurrency, promotionCostByCurrency, taxedRevenueByCurrency, vendorCostByCurrency].forEach((map) => {
+    Object.keys(map).forEach((id) => currencySet.add(id));
+  });
+
+  const currencyList = Array.from(currencySet);
+  const byCurrency: Record<string, RevenueStats> = {};
+
+  currencyList.forEach((id) => {
+    const totalRevenue = totalRevenueByCurrency[id] || '0';
+    const promotionCost = promotionCostByCurrency[id] || '0';
+    const taxedRevenue = taxedRevenueByCurrency[id] || '0';
+    const vendorCost = vendorCostByCurrency[id] || '0';
+
+    const includeEntry =
+      hasNonZeroValue([totalRevenue, promotionCost, taxedRevenue, vendorCost]) || Boolean(currencyFilter);
+
+    if (!includeEntry) {
+      return;
+    }
+
+    const netRevenue = new BN(totalRevenue).sub(new BN(vendorCost)).toString();
+
+    byCurrency[id] = {
+      totalRevenue,
+      promotionCost,
+      vendorCost,
+      taxedRevenue,
+      netRevenue,
+    };
+  });
+
+  if (currencyList.length === 0 && currencyId) {
+    byCurrency[currencyId] = { ...ZERO_REVENUE_STATS };
+  }
+
+  return byCurrency;
+}
+
 router.get('/summary', auth, async (req, res) => {
   try {
-    const [arcblock, ethereum, links] = await Promise.all([
+    const {
+      currency_id: currencyId,
+      start,
+      end,
+    } = await summaryQuerySchema.validateAsync(req.query, {
+      stripUnknown: true,
+    });
+    const livemode = !!req.livemode;
+    const [arcblock, ethereum, links, revenueByCurrency] = await Promise.all([
       getTokenSummaryByDid(wallet.address, !!req.livemode, 'arcblock'),
       getTokenSummaryByDid(ethWallet.address, !!req.livemode, EVM_CHAIN_TYPES),
-      getCurrencyLinks(!!req.livemode),
+      getCurrencyLinks(livemode),
+      getRevenueStats(livemode, currencyId, start, end),
     ]);
     res.json({
       links,
       balances: { ...arcblock, ...ethereum },
       addresses: { arcblock: wallet.address, ethereum: ethWallet.address },
       summary: {
-        subscription: await Subscription.getSummary(!!req.livemode),
-        invoice: await Invoice.getSummary(!!req.livemode),
-        payment: await PaymentIntent.getSummary(!!req.livemode),
-        payout: await Payout.getSummary(!!req.livemode),
-        refund: await Refund.getSummary(!!req.livemode),
+        subscription: await Subscription.getSummary(livemode),
+        invoice: await Invoice.getSummary(livemode),
+        payment: await PaymentIntent.getSummary(livemode),
+        payout: await Payout.getSummary(livemode),
+        refund: await Refund.getSummary(livemode),
       },
+      revenueByCurrency,
     });
   } catch (err) {
     logger.error(err);