payment-kit 1.23.9 → 1.23.11

package/api/src/libs/invoice.ts

@@ -1121,20 +1121,27 @@ export async function retryUncollectibleInvoices(options: {
       failed: [] as Array<{ id: string; reason: string }>,
     };
 
+    const now = dayjs().unix();
+    const BATCH_SIZE = 10;
+    const BATCH_DELAY_SECONDS = 0.1;
+
     const settledResults = await Promise.allSettled(
       overdueInvoices.map(async (invoice, index) => {
         const { paymentIntent } = invoice;
-        const delay = index * 2;
         if (!paymentIntent) {
           throw new Error('No payment intent found');
         }
 
         await paymentIntent.update({ status: 'requires_capture' });
+
+        const batchIndex = Math.floor(index / BATCH_SIZE);
+        const runAt = now + batchIndex * BATCH_DELAY_SECONDS;
+
         await emitAsync(
           'payment.queued',
           paymentIntent.id,
           { paymentIntentId: paymentIntent.id, retryOnError: true, ignoreMaxRetryCheck: true },
-          { sync: false, delay }
+          { sync: false, runAt }
         );
 
         return invoice;

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

@@ -7,6 +7,7 @@ import {
   CreditGrant,
   Customer,
   Invoice,
+  Meter,
   PaymentCurrency,
   PaymentMethod,
   Price,
@@ -51,6 +52,22 @@ export async function processAutoRecharge(job: AutoRechargeJobData) {
     return;
   }
 
+  // Check if the associated meter is inactive
+  if (currency.type === 'credit') {
+    // Find meter by currency_id (meter.currency_id -> PaymentCurrency) or by metadata.meter_id
+    const meter = await Meter.findOne({
+      where: { currency_id: currencyId },
+    });
+    if (meter && meter.status === 'inactive') {
+      logger.info('Meter is inactive, skipping auto recharge', {
+        customerId,
+        currencyId,
+        meterId: meter.id,
+      });
+      return;
+    }
+  }
+
   // 1. find auto recharge config
   const config = (await AutoRechargeConfig.findOne({
     where: {
@@ -302,6 +319,24 @@ export async function checkAndTriggerAutoRecharge(
       currencyId,
       currentBalance,
     });
+
+    // Check if the associated meter is inactive
+    const currency = await PaymentCurrency.findByPk(currencyId);
+    if (currency?.type === 'credit') {
+      // Find meter by currency_id (meter.currency_id -> PaymentCurrency)
+      const meter = await Meter.findOne({
+        where: { currency_id: currencyId },
+      });
+      if (meter && meter.status === 'inactive') {
+        logger.info('Meter is inactive, skipping auto recharge check', {
+          customerId: customer.id,
+          currencyId,
+          meterId: meter.id,
+        });
+        return;
+      }
+    }
+
     const config = await AutoRechargeConfig.findOne({
       where: {
         customer_id: customer.id,

package/api/src/queues/credit-consume.ts

@@ -2,6 +2,7 @@ import { BN, fromUnitToToken } from '@ocap/util';
 
 import { getLock } from '../libs/lock';
 import logger from '../libs/logger';
+import dayjs from '../libs/dayjs';
 import createQueue from '../libs/queue';
 import { createEvent } from '../libs/audit';
 import {
@@ -551,7 +552,7 @@ export async function handleCreditConsumption(job: CreditConsumptionJob) {
       });
       await context.meterEvent.markAsCompleted();
       if (context.subscription && context.subscription.status === 'past_due') {
-        handlePastDueSubscriptionRecovery(context.subscription, null);
+        await handlePastDueSubscriptionRecovery(context.subscription, null);
       }
     } else {
       logger.warn('Credit consumption partially completed - insufficient balance', {
@@ -622,6 +623,7 @@ export const creditQueue = createQueue<CreditConsumptionJob>({
   options: {
     concurrency: 1,
     maxRetries: 0,
+    enableScheduledJob: true,
   },
 });
 
@@ -755,58 +757,128 @@ events.on('customer.credit_grant.granted', async (creditGrant: CreditGrant) => {
 });
 
 async function retryFailedEventsForCustomer(creditGrant: CreditGrant): Promise<void> {
+  const grant = await CreditGrant.findByPk(creditGrant.id);
+  if (!grant) {
+    logger.error('Credit grant not found', {
+      creditGrantId: creditGrant.id,
+    });
+    return;
+  }
+
+  const customerId = grant.customer_id;
+  const currencyId = grant.currency_id;
+  const lock = getLock(`retry-failed-events-${customerId}-${currencyId}`);
+
   try {
+    await lock.acquire();
+
     logger.info('Retrying failed events for customer', {
-      customerId: creditGrant.customer_id,
-      currencyId: creditGrant.currency_id,
-      livemode: creditGrant.livemode,
+      customerId,
+      currencyId,
+      livemode: grant.livemode,
+      grantAmount: grant.amount,
+      grantRemaining: grant.remaining_amount,
     });
+
+    const availableGrants = await CreditGrant.getAvailableCreditsForCustomer(customerId, currencyId);
+    const totalAvailableCredit = availableGrants.reduce((sum, g) => sum.add(new BN(g.remaining_amount)), new BN(0));
+
     const [, , failedEvents] = await MeterEvent.getPendingAmounts({
-      customerId: creditGrant.customer_id,
-      currencyId: creditGrant.currency_id,
+      customerId,
+      currencyId,
       status: ['requires_action', 'requires_capture'],
-      livemode: creditGrant.livemode,
+      livemode: grant.livemode,
     });
 
     if (failedEvents.length === 0) {
       logger.debug('No failed events with pending credit found', {
-        customerId: creditGrant.customer_id,
-        currencyId: creditGrant.currency_id,
+        customerId,
+        currencyId,
       });
       return;
     }
 
-    logger.info('Updating failed events status after credit grant', {
-      customerId: creditGrant.customer_id,
-      currencyId: creditGrant.currency_id,
-      eventCount: failedEvents.length,
+    if (totalAvailableCredit.lte(new BN(0))) {
+      logger.debug('No available credit to retry failed events', {
+        customerId,
+        currencyId,
+        totalAvailableCredit: totalAvailableCredit.toString(),
+      });
+      return;
+    }
+
+    const sortedEvents = failedEvents.sort((a, b) => {
+      const aPending = new BN(a.credit_pending);
+      const bPending = new BN(b.credit_pending);
+      return aPending.cmp(bPending);
     });
 
-    await Promise.all(
-      failedEvents.map((event) =>
-        event.update({
-          status: 'pending',
-          attempt_count: 0,
-          next_attempt: undefined,
-        })
-      )
-    );
+    let cumulativePending = new BN(0);
+    const affordableEvents: MeterEvent[] = [];
+    const now = dayjs().unix();
+    const BATCH_SIZE = 10;
+    const BATCH_DELAY_SECONDS = 0.1;
 
-    failedEvents.forEach((event, index) => {
-      const delay = index * 1000;
-      addCreditConsumptionJob(event.id, true, { delay });
-    });
+    for (let i = 0; i < sortedEvents.length; i++) {
+      const event = sortedEvents[i];
+      if (!event) {
+        break;
+      }
 
-    logger.info('Successfully updated failed events status', {
-      customerId: creditGrant.customer_id,
-      currencyId: creditGrant.currency_id,
-      eventCount: failedEvents.length,
+      const eventPending = new BN(event.credit_pending);
+      const newCumulative = cumulativePending.add(eventPending);
+
+      if (newCumulative.gt(totalAvailableCredit)) {
+        if (eventPending.gt(totalAvailableCredit)) {
+          break;
+        }
+      }
+
+      // eslint-disable-next-line no-await-in-loop
+      await event.update({
+        status: 'pending',
+        attempt_count: 0,
+        next_attempt: undefined,
+      });
+
+      const batchIndex = Math.floor(i / BATCH_SIZE);
+      const runAt = now + batchIndex * BATCH_DELAY_SECONDS;
+
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        await addCreditConsumptionJob(event.id, true, { runAt });
+      } catch (jobError: any) {
+        logger.error('Failed to add credit consumption job after status update', {
+          eventId: event.id,
+          customerId,
+          currencyId,
+          error: jobError.message,
+        });
+      }
+
+      affordableEvents.push(event);
+      cumulativePending = newCumulative;
+    }
+
+    const skippedEvents = failedEvents.length - affordableEvents.length;
+
+    logger.info('Completed retrying failed events', {
+      customerId,
+      currencyId,
+      totalEvents: failedEvents.length,
+      affordableEvents: affordableEvents.length,
+      skippedEvents,
+      totalAvailableCredit: totalAvailableCredit.toString(),
+      totalAffordablePending: cumulativePending.toString(),
+      grantCount: availableGrants.length,
     });
   } catch (error: any) {
-    logger.error('Failed to update failed events for customer', {
-      customerId: creditGrant.customer_id,
-      currencyId: creditGrant.currency_id,
+    logger.error('Failed to retry failed events for customer', {
+      customerId: grant.customer_id,
+      currencyId: grant.currency_id,
       error: error.message,
     });
+  } finally {
+    lock.release();
   }
 }

package/api/src/routes/auto-recharge-configs.ts

@@ -10,6 +10,7 @@ import {
   AutoRechargeConfig,
   Customer,
   EVMChainType,
+  Meter,
   PaymentCurrency,
   PaymentMethod,
   Price,
@@ -339,6 +340,16 @@ router.post('/submit', async (req, res) => {
     throw new CustomError(400, `Currency not found: ${value.currency_id}`);
   }
 
+  // Check if the associated meter is active when enabling auto-recharge
+  if (configData.enabled && currency.type === 'credit') {
+    const meter = await Meter.findOne({
+      where: { currency_id: value.currency_id },
+    });
+    if (meter && meter.status === 'inactive') {
+      throw new CustomError(400, 'Cannot enable auto top-up: the associated meter is inactive');
+    }
+  }
+
   if (currency.recharge_config?.base_price_id && currency.recharge_config?.base_price_id !== value.price_id) {
     throw new CustomError(400, 'Price is not the base price');
   }

package/api/src/routes/credit-grants.ts

@@ -2,7 +2,7 @@ import { Router } from 'express';
 import Joi from 'joi';
 import { BN, fromTokenToUnit } from '@ocap/util';
 
-import { literal, OrderItem } from 'sequelize';
+import { literal, OrderItem, fn, col, Op } from 'sequelize';
 import pick from 'lodash/pick';
 import { createListParamSchema, getOrder, getWhereFromKvQuery, MetadataSchema } from '../libs/api';
 import logger from '../libs/logger';
@@ -165,6 +165,89 @@ router.get('/summary', authMine, async (req, res) => {
   }
 });
 
+const holdersSchema = Joi.object({
+  currency_id: Joi.string().required(),
+  page: Joi.number().integer().min(1).default(1),
+  pageSize: Joi.number().integer().min(0).optional(), // 0 or undefined = return all
+  livemode: Joi.boolean().optional(),
+});
+
+// Get all holders (customers with balance) for a specific credit currency
+router.get('/holders', auth, async (req, res) => {
+  try {
+    const { error, value } = holdersSchema.validate(req.query, { stripUnknown: true });
+    if (error) {
+      return res.status(400).json({ error: error.message });
+    }
+
+    const { currency_id: currencyId, page, pageSize, livemode } = value;
+
+    const currency = await PaymentCurrency.findByPk(currencyId);
+    if (!currency) {
+      return res.status(404).json({ error: `PaymentCurrency ${currencyId} not found` });
+    }
+
+    if (currency.type !== 'credit') {
+      return res.status(400).json({ error: 'Currency must be of type credit' });
+    }
+
+    // Build where clause for credit grants
+    const grantWhere: any = {
+      currency_id: currencyId,
+      status: { [Op.in]: ['granted', 'pending'] }, // Only active grants
+    };
+    if (typeof livemode === 'boolean') {
+      grantWhere.livemode = livemode;
+    }
+
+    // Use database aggregation - only customer_id, no JOIN needed
+    const aggregatedData = (await CreditGrant.findAll({
+      where: grantWhere,
+      attributes: [
+        'customer_id',
+        [fn('COUNT', col('id')), 'grantCount'],
+        [fn('SUM', literal('CAST(remaining_amount AS DECIMAL(40,0))')), 'totalBalance'],
+      ],
+      group: ['customer_id'], // Only group by customer_id - much faster!
+      order: [[literal('totalBalance'), 'DESC']],
+      raw: true,
+    })) as any[];
+
+    const totalCount = aggregatedData.length;
+
+    // Paginate (pageSize = 0 or undefined means return all)
+    const shouldPaginate = pageSize && pageSize > 0;
+    const paginatedData = shouldPaginate
+      ? aggregatedData.slice((page - 1) * pageSize, page * pageSize)
+      : aggregatedData;
+
+    const holders = paginatedData.map((item) => ({
+      customer_id: item.customer_id,
+      balance: (item.totalBalance || '0').toString(),
+      grantCount: parseInt(item.grantCount || '0', 10),
+    }));
+
+    return res.json({
+      holders,
+      currency: {
+        id: currency.id,
+        name: currency.name,
+        symbol: currency.symbol,
+        decimal: currency.decimal,
+      },
+      paging: {
+        page: shouldPaginate ? page : 1,
+        pageSize: shouldPaginate ? pageSize : totalCount,
+        total: totalCount,
+        totalPages: shouldPaginate ? Math.ceil(totalCount / pageSize) : 1,
+      },
+    });
+  } catch (err: any) {
+    logger.error('Error getting credit holders', { error: err.message });
+    return res.status(400).json({ error: err.message });
+  }
+});
+
 const checkAutoRechargeSchema = Joi.object({
   customer_id: Joi.string().required(),
   currency_id: Joi.string().required(),

package/api/src/routes/meter-events.ts

@@ -327,7 +327,6 @@ router.post('/', auth, async (req, res) => {
 router.get('/pending-amount', authMine, async (req, res) => {
   try {
     const params: any = {
-      status: ['requires_action', 'requires_capture'],
       livemode: !!req.livemode,
     };
     if (req.query.subscription_id) {

package/api/src/store/models/meter-event.ts

@@ -427,7 +427,7 @@ export class MeterEvent extends Model<InferAttributes<MeterEvent>, InferCreation
     subscriptionId,
     livemode,
     currencyId,
-    status = ['requires_action', 'requires_capture'],
+    status,
     customerId,
   }: {
     subscriptionId?: string;

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.23.9
+version: 1.23.11
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.23.9",
+  "version": "1.23.11",
   "scripts": {
     "dev": "blocklet dev --open",
     "prelint": "npm run types",
@@ -59,9 +59,9 @@
     "@blocklet/error": "^0.3.5",
     "@blocklet/js-sdk": "^1.17.8-beta-20260104-120132-cb5b1914",
     "@blocklet/logger": "^1.17.8-beta-20260104-120132-cb5b1914",
-    "@blocklet/payment-broker-client": "1.23.9",
-    "@blocklet/payment-react": "1.23.9",
-    "@blocklet/payment-vendor": "1.23.9",
+    "@blocklet/payment-broker-client": "1.23.11",
+    "@blocklet/payment-react": "1.23.11",
+    "@blocklet/payment-vendor": "1.23.11",
     "@blocklet/sdk": "^1.17.8-beta-20260104-120132-cb5b1914",
     "@blocklet/ui-react": "^3.3.10",
     "@blocklet/uploader": "^0.3.19",
@@ -131,7 +131,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.17.8-beta-20260104-120132-cb5b1914",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.23.9",
+    "@blocklet/payment-types": "1.23.11",
     "@types/cookie-parser": "^1.4.9",
     "@types/cors": "^2.8.19",
     "@types/debug": "^4.1.12",
@@ -178,5 +178,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "98f0267cd0769183f21ea954a8fe0b4573f7d684"
+  "gitHead": "72af80fc6e91e88058665212985002966f55787c"
 }