payment-kit 1.13.174 → 1.13.176

package/api/src/crons/index.ts

@@ -1,10 +1,17 @@
 import Cron from '@abtnode/cron';
 
-import { batchHandleStripeInvoices, batchHandleStripeSubscriptions } from '../integrations/stripe/resource';
+import { checkStakeRevokeTx } from '../integrations/blockchain/stake';
+import {
+  batchHandleStripeInvoices,
+  batchHandleStripePayments,
+  batchHandleStripeSubscriptions,
+} from '../integrations/stripe/resource';
 import {
   expiredSessionCleanupCronTime,
   notificationCronTime,
+  revokeStakeCronTime,
   stripeInvoiceCronTime,
+  stripePaymentCronTime,
   stripeSubscriptionCronTime,
   subscriptionCronTime,
 } from '../libs/env';
@@ -58,12 +65,24 @@ function init() {
         fn: batchHandleStripeInvoices,
         options: { runOnInit: false },
       },
+      {
+        name: 'stripe.payment.sync',
+        time: stripePaymentCronTime,
+        fn: batchHandleStripePayments,
+        options: { runOnInit: false },
+      },
       {
         name: 'stripe.subscription.sync',
         time: stripeSubscriptionCronTime,
         fn: batchHandleStripeSubscriptions,
         options: { runOnInit: false },
       },
+      {
+        name: 'customer.stake.revoked',
+        time: revokeStakeCronTime,
+        fn: checkStakeRevokeTx,
+        options: { runOnInit: false },
+      },
     ],
     onError: (error: Error, name: string) => {
       logger.error('run job failed', { name, error: error.message, stack: error.stack });

package/api/src/integrations/blockchain/stake.ts

@@ -1,12 +1,15 @@
 /* eslint-disable no-continue */
 /* eslint-disable no-await-in-loop */
+import assert from 'assert';
+
 import { toStakeAddress } from '@arcblock/did-util';
 import env from '@blocklet/sdk/lib/env';
 import { fromUnitToToken, toBN } from '@ocap/util';
 
 import { wallet } from '../../libs/auth';
+import { events } from '../../libs/event';
 import logger from '../../libs/logger';
-import { PaymentCurrency, PaymentMethod } from '../../store/models';
+import { Customer, PaymentCurrency, PaymentMethod, Subscription } from '../../store/models';
 
 export async function ensureStakedForGas() {
   const currencies = await PaymentCurrency.findAll({ where: { active: true, is_base_currency: true } });
@@ -74,3 +77,98 @@ export async function estimateMaxGasForTx(method: PaymentMethod, typeUrl = 'fg:t
 
   return '0';
 }
+
+export async function getAllResults(dataKey: string, fn: Function) {
+  const results = [];
+  const pageSize = 40;
+
+  const { page, [dataKey]: firstPage } = await fn({ size: pageSize });
+  if (page.total < pageSize) {
+    return firstPage;
+  }
+
+  results.push(...firstPage);
+
+  const total = Math.floor(page.total / pageSize);
+  const tasks = [];
+  for (let i = 1; i <= total; i++) {
+    tasks.push(async () => {
+      const { [dataKey]: nextPage } = await fn({ size: pageSize, cursor: i * pageSize });
+      results.push(...nextPage);
+    });
+  }
+  await Promise.all(tasks.map((x) => x()));
+  assert.equal(results.length, page.total, `fetched ${dataKey} count does not match`);
+
+  return results;
+}
+
+export async function checkStakeRevokeTx() {
+  const methods = await PaymentMethod.findAll({ where: { type: 'arcblock' } });
+  if (methods.length === 0) {
+    return;
+  }
+
+  const interval = 1000 * 60 * 10;
+  const startDateTime = new Date(Date.now() - interval).toISOString();
+  const endDateTime = new Date().toISOString();
+
+  for (const method of methods) {
+    const client = method.getOcapClient();
+    const txs = await getAllResults('transactions', (paging: any) =>
+      client.listTransactions({
+        paging,
+        typeFilter: { types: ['revoke_stake'] },
+        timeFilter: {
+          field: 'time',
+          startDateTime,
+          endDateTime,
+        },
+      })
+    );
+
+    logger.info(`Found ${txs.length} revoke stake tx on chain ${method.name}`, {
+      interval,
+      startDateTime,
+      endDateTime,
+      txs: txs.map((x: any) => x.hash),
+    });
+
+    await Promise.all(
+      txs.map(async (t: any) => {
+        const customer = await Customer.findByPkOrDid(t.tx.from);
+        if (!customer) {
+          return;
+        }
+
+        const address = toStakeAddress(customer.did, wallet.address);
+        if (t.tx.itxJson.address !== address) {
+          return;
+        }
+
+        // Check related subscriptions in the stake
+        const subscriptions = await Subscription.findAll({
+          where: { 'payment_details.arcblock.staking.address': address },
+        });
+        if (subscriptions.length === 0) {
+          return;
+        }
+        logger.info(`Active subscriptions found for revoked stake on chain ${method.name}`, {
+          address,
+          customer: customer.did,
+          subscriptions: subscriptions.map((x) => x.id),
+          txHash: t.hash,
+        });
+
+        const { state: stake } = await client.getStakeState({ address });
+        const data = JSON.parse(stake.data?.value || '{}');
+        subscriptions
+          .filter((s) => s.isActive())
+          .filter((s) => data[s.id])
+          .forEach((s) => {
+            events.emit('customer.stake.revoked', { subscriptionId: s.id, tx: t });
+          });
+      })
+    );
+  }
+}

package/api/src/integrations/stripe/handlers/invoice.ts

@@ -141,7 +141,11 @@ export async function ensureStripeInvoice(stripeInvoice: any, subscription: Subs
   if (checkoutSession) {
     await checkoutSession.update({ invoice_id: invoice.id });
   }
+  if (subscription) {
+    await subscription.update({ latest_invoice_id: invoice.id });
+  }
   await client.invoices.update(stripeInvoice.id, { metadata: { appPid: env.appPid, id: invoice.id } });
+
   logger.info('stripe invoice mirrored', { local: invoice.id, remote: stripeInvoice.id });
 
   await Promise.all(

package/api/src/integrations/stripe/handlers/payment-intent.ts

@@ -26,7 +26,7 @@ export async function handleStripePaymentSucceed(paymentIntent: PaymentIntent, e
 }
 
 export async function syncStripePayment(paymentIntent: PaymentIntent) {
-  if (!paymentIntent.metadata?.stripe_id) {
+  if (!paymentIntent?.metadata?.stripe_id) {
     return;
   }
 

package/api/src/integrations/stripe/resource.ts

@@ -346,7 +346,7 @@ export async function batchHandleStripeInvoices() {
 
   const stripeInvoices = await Invoice.findAll({
     where: {
-      status: ['draft', 'open'],
+      status: ['draft', 'open', 'finalized'],
       'metadata.stripe_id': { [Op.not]: null },
     },
   });
@@ -364,22 +364,22 @@ export async function batchHandleStripeInvoices() {
 
     const client = method.getStripeClient();
     try {
-      const exist = await client.invoices.retrieve(stripeInvoiceId);
+      let exist = await client.invoices.retrieve(stripeInvoiceId);
       if (exist) {
         if (exist.status === 'draft') {
-          await client.invoices.finalizeInvoice(stripeInvoiceId);
+          exist = await client.invoices.finalizeInvoice(stripeInvoiceId);
           logger.info('stripe invoice finalized', { local: invoice.id, stripe: stripeInvoiceId });
         }
-        await client.invoices.pay(stripeInvoiceId);
-        logger.info('stripe invoice payment requested', { local: invoice.id, stripe: stripeInvoiceId });
+        if (exist.status !== 'paid') {
+          exist = await client.invoices.pay(stripeInvoiceId);
+          logger.info('stripe invoice payment requested', { local: invoice.id, stripe: stripeInvoiceId });
+        }
 
         await syncStripeInvoice(invoice);
 
         if (invoice.payment_intent_id) {
           const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
-          if (paymentIntent) {
-            await syncStripePayment(paymentIntent);
-          }
+          await syncStripePayment(paymentIntent!);
         }
       } else {
         await Invoice.destroy({ where: { id: invoice.id } });
@@ -395,7 +395,7 @@ export async function batchHandleStripeInvoices() {
       }
     }
 
-    await sleep(5000);
+    await sleep(2000);
   }
 }
 
@@ -437,8 +437,16 @@ export async function batchHandleStripeSubscriptions() {
         if (subscription.payment_settings?.payment_method_types?.includes('stripe')) {
           fields.push('pause_collection');
         }
-        await subscription.update(pick(exist, fields) as any);
-        logger.warn('stripe subscription synced', { local: subscription.id, stripe: subscriptionId });
+        const updates: any = pick(exist, fields);
+        if (exist.latest_invoice) {
+          const invoice = await Invoice.findOne({ where: { 'metadata.stripe_id': exist.latest_invoice } });
+          if (invoice) {
+            updates.latest_invoice_id = invoice.id;
+          }
+        }
+
+        await subscription.update(updates);
+        logger.warn('stripe subscription synced', { local: subscription.id, stripe: subscriptionId, updates });
       } else {
         logger.warn('stripe subscription missing', { local: subscription.id, stripe: subscriptionId });
       }
@@ -454,6 +462,49 @@ export async function batchHandleStripeSubscriptions() {
       }
     }
 
-    await sleep(3000);
+    await sleep(2000);
+  }
+}
+
+export async function batchHandleStripePayments() {
+  const stripeMethods = await PaymentMethod.findAll({ where: { type: 'stripe' } });
+  if (stripeMethods.length === 0) {
+    return;
+  }
+
+  const stripePayments = await PaymentIntent.findAll({
+    where: {
+      status: ['requires_payment_method'],
+      'metadata.stripe_id': { [Op.not]: null },
+    },
+  });
+
+  for (const payment of stripePayments) {
+    const stripePaymentId = payment.metadata?.stripe_id;
+    if (!stripePaymentId) {
+      continue;
+    }
+
+    const method = stripeMethods.find((m) => m.livemode === payment.livemode);
+    if (!method) {
+      continue;
+    }
+
+    const client = method.getStripeClient();
+    try {
+      const exist = await client.paymentIntents.retrieve(stripePaymentId);
+      if (exist) {
+        await syncStripePayment(payment);
+      }
+    } catch (error) {
+      if (error.message.includes('No such payment')) {
+        await PaymentIntent.destroy({ where: { id: payment.id } });
+        logger.warn('stripe payment intent purged', { local: payment.id, stripe: stripePaymentId });
+      } else {
+        logger.error('stripe payment sync error', error);
+      }
+    }
+
+    await sleep(1000);
   }
 }

package/api/src/libs/audit.ts

@@ -8,13 +8,13 @@ import { events } from './event';
 const API_VERSION = '2023-09-05';
 
 export async function createEvent(scope: string, type: LiteralUnion<EventType, string>, model: any, options: any = {}) {
-  // console.log('createEvent', scope, type, model, options);
   const data: any = {
     object: model.dataValues,
   };
   if (type.endsWith('updated')) {
     data.previous_attributes = pick(model._previousDataValues, options.fields);
   }
+  // console.log('createEvent', scope, type, data, options);
 
   const event = await Event.create({
     type,
@@ -43,7 +43,6 @@ export async function createStatusEvent(
   model: any,
   options: any = {}
 ) {
-  // console.log('createStatusEvent', scope, prefix, config, model, options);
   if (options.fields.includes('status') === false) {
     return;
   }
@@ -57,6 +56,7 @@ export async function createStatusEvent(
     return;
   }
 
+  // console.log('createStatusEvent', scope, prefix, config, data, options);
   const suffix = config[data.object.status];
   const event = await Event.create({
     type: [prefix, suffix].join('.'),
@@ -85,7 +85,6 @@ export async function createCustomEvent(
   model: any,
   options: any
 ) {
-  // console.log('createCustomEvent', scope, prefix, type, model, options);
   const data: any = {
     object: model.dataValues,
     previous_attributes: pick(model._previousDataValues, options.fields),
@@ -96,6 +95,7 @@ export async function createCustomEvent(
     return;
   }
 
+  // console.log('createCustomEvent', scope, prefix, type, data, options);
   const event = await Event.create({
     type: [prefix, suffix].join('.'),
     api_version: API_VERSION,

package/api/src/libs/env.ts

@@ -5,7 +5,9 @@ export const notificationCronTime: string = process.env.NOTIFICATION_CRON_TIME |
 export const expiredSessionCleanupCronTime: string = process.env.EXPIRED_SESSION_CLEANUP_CRON_TIME || '0 1 */2 * * *'; // 默认每2个小时执行一次
 export const notificationCronConcurrency: number = Number(process.env.NOTIFICATION_CRON_CONCURRENCY) || 8; // 默认并发数为 8
 export const stripeInvoiceCronTime: string = process.env.STRIPE_INVOICE_CRON_TIME || '0 */30 * * * *'; // 默认每 30min 执行一次
+export const stripePaymentCronTime: string = process.env.STRIPE_PAYMENT_CRON_TIME || '0 */20 * * * *'; // 默认每 20min 执行一次
 export const stripeSubscriptionCronTime: string = process.env.STRIPE_SUBSCRIPTION_CRON_TIME || '0 10 */8 * * *'; // 默认每 8小时 执行一次
+export const revokeStakeCronTime: string = process.env.REVOKE_STAKE_CRON_TIME || '0 */5 * * * *'; // 默认每 5 min 行一次
 
 export default {
   ...env,

package/api/src/libs/notification/template/subscription-will-renew.ts

@@ -52,7 +52,7 @@ export class SubscriptionWillRenewEmailTemplate
     if (!subscription) {
       throw new Error(`Subscription not found: ${this.options.subscriptionId}`);
     }
-    if (subscription.status !== 'active') {
+    if (subscription.isActive() === false) {
       throw new Error(`Subscription not active: ${this.options.subscriptionId}`);
     }
     if (subscription.isScheduledToCancel()) {

package/api/src/libs/subscription.ts

@@ -98,6 +98,33 @@ export const getMinRetryMail = (interval: string) => {
   return 15; // 18 hours
 };
 
+export function getSubscriptionStakeSetup(items: TLineItemExpanded[], currencyId: string, billingThreshold = '0') {
+  const staking = {
+    licensed: new BN(0),
+    metered: new BN(0),
+  };
+
+  items.forEach((x) => {
+    const price = getSubscriptionItemPrice(x);
+    const unit = getPriceUintAmountByCurrency(price, currencyId);
+    const amount = new BN(unit).mul(new BN(x.quantity));
+    if (price.type === 'recurring' && price.recurring) {
+      if (price.recurring.usage_type === 'licensed') {
+        staking.licensed = staking.licensed.add(amount);
+      }
+      if (price.recurring.usage_type === 'metered') {
+        if (+billingThreshold) {
+          staking.metered = new BN(billingThreshold);
+        } else {
+          staking.metered = staking.metered.add(amount);
+        }
+      }
+    }
+  });
+
+  return staking;
+}
+
 export function getSubscriptionCreateSetup(
   items: TLineItemExpanded[],
   currencyId: string,
@@ -109,8 +136,14 @@ export function getSubscriptionCreateSetup(
   items.forEach((x) => {
     const price = getSubscriptionItemPrice(x);
     const unit = getPriceUintAmountByCurrency(price, currencyId);
-    if (price.type === 'one_time' || (price.type === 'recurring' && price.recurring?.usage_type === 'licensed')) {
-      setup = setup.add(new BN(unit).mul(new BN(x.quantity)));
+    const amount = new BN(unit).mul(new BN(x.quantity));
+    if (price.type === 'recurring') {
+      if (price.recurring?.usage_type === 'licensed') {
+        setup = setup.add(amount);
+      }
+    }
+    if (price.type === 'one_time') {
+      setup = setup.add(amount);
     }
   });
 

package/api/src/queues/checkout-session.ts

@@ -67,28 +67,18 @@ export async function handleCheckoutSessionJob(job: CheckoutSessionJob): Promise
 
 // eslint-disable-next-line require-await
 export async function startCheckoutSessionQueue() {
-  events.on('checkout.session.completed', (checkoutSession: CheckoutSession) => {
-    ensurePassportIssued(checkoutSession).catch((err) => {
-      logger.error('ensurePassportIssued failed', { error: err, checkoutSession: checkoutSession.id });
-    });
-    mintNftForCheckoutSession(checkoutSession.id).catch((err) => {
-      logger.error('mintNftForCheckoutSession failed', { error: err, checkoutSession: checkoutSession.id });
-    });
-
-    // lock prices used
-    Price.update(
-      { locked: true },
-      { where: { id: checkoutSession.line_items.map((x) => x.upsell_price_id || x.price_id) } }
-    ).catch((err) => {
-      logger.error('lock price on checkout session complete failed', {
-        error: err,
-        checkoutSession: checkoutSession.id,
-      });
-    });
+  // Auto populate subscription queue
+  const now = dayjs().unix();
+  const checkoutSessions = await CheckoutSession.findAll({
+    where: {
+      status: 'open',
+      expires_at: { [Op.lte]: now },
+    },
   });
 
-  events.on('checkout.session.created', (checkoutSession: CheckoutSession) => {
-    if (checkoutSession.expires_at) {
+  checkoutSessions.forEach(async (checkoutSession) => {
+    const exist = await checkoutSessionQueue.get(checkoutSession.id);
+    if (!exist) {
       checkoutSessionQueue.push({
         id: checkoutSession.id,
         job: { id: checkoutSession.id, action: 'expire' },
@@ -96,89 +86,103 @@ export async function startCheckoutSessionQueue() {
       });
     }
   });
+}
+
+checkoutSessionQueue.on('failed', ({ id, job, error }) => {
+  logger.error('CheckoutSession job failed', { id, job, error });
+});
+
+events.on('checkout.session.completed', (checkoutSession: CheckoutSession) => {
+  ensurePassportIssued(checkoutSession).catch((err) => {
+    logger.error('ensurePassportIssued failed', { error: err, checkoutSession: checkoutSession.id });
+  });
+  mintNftForCheckoutSession(checkoutSession.id).catch((err) => {
+    logger.error('mintNftForCheckoutSession failed', { error: err, checkoutSession: checkoutSession.id });
+  });
+
+  // lock prices used
+  Price.update(
+    { locked: true },
+    { where: { id: checkoutSession.line_items.map((x) => x.upsell_price_id || x.price_id) } }
+  ).catch((err) => {
+    logger.error('lock price on checkout session complete failed', {
+      error: err,
+      checkoutSession: checkoutSession.id,
+    });
+  });
+});
 
-  events.on('checkout.session.expired', async (checkoutSession: CheckoutSession) => {
-    // Do some cleanup
-    if (checkoutSession.invoice_id) {
-      await InvoiceItem.destroy({ where: { invoice_id: checkoutSession.invoice_id } });
-      await Invoice.destroy({ where: { id: checkoutSession.invoice_id } });
+events.on('checkout.session.created', (checkoutSession: CheckoutSession) => {
+  if (checkoutSession.expires_at) {
+    checkoutSessionQueue.push({
+      id: checkoutSession.id,
+      job: { id: checkoutSession.id, action: 'expire' },
+      runAt: checkoutSession.expires_at,
+    });
+  }
+});
+
+events.on('checkout.session.expired', async (checkoutSession: CheckoutSession) => {
+  // Do some cleanup
+  if (checkoutSession.invoice_id) {
+    await InvoiceItem.destroy({ where: { invoice_id: checkoutSession.invoice_id } });
+    await Invoice.destroy({ where: { id: checkoutSession.invoice_id } });
+    logger.info('Invoice and InvoiceItem for checkout session deleted on expire', {
+      checkoutSession: checkoutSession.id,
+      invoice: checkoutSession.invoice_id,
+    });
+  } else {
+    // Do some reverse lookup if invoice is not related to checkout session
+    const invoice = await Invoice.findOne({ where: { checkout_session_id: checkoutSession.id } });
+    if (invoice) {
+      await InvoiceItem.destroy({ where: { invoice_id: invoice.id } });
+      await Invoice.destroy({ where: { id: invoice.id } });
       logger.info('Invoice and InvoiceItem for checkout session deleted on expire', {
         checkoutSession: checkoutSession.id,
-        invoice: checkoutSession.invoice_id,
+        invoice: invoice.id,
       });
-    } else {
-      // Do some reverse lookup if invoice is not related to checkout session
-      const invoice = await Invoice.findOne({ where: { checkout_session_id: checkoutSession.id } });
-      if (invoice) {
-        await InvoiceItem.destroy({ where: { invoice_id: invoice.id } });
-        await Invoice.destroy({ where: { id: invoice.id } });
-        logger.info('Invoice and InvoiceItem for checkout session deleted on expire', {
-          checkoutSession: checkoutSession.id,
-          invoice: invoice.id,
-        });
-      }
     }
-    if (checkoutSession.setup_intent_id) {
-      await SetupIntent.destroy({ where: { id: checkoutSession.setup_intent_id } });
-      logger.info('SetupIntent for checkout session deleted on expire', {
-        checkoutSession: checkoutSession.id,
-        setupIntent: checkoutSession.setup_intent_id,
-      });
-    }
-    if (checkoutSession.payment_intent_id && checkoutSession.payment_status !== 'paid') {
-      await PaymentIntent.destroy({ where: { id: checkoutSession.payment_intent_id } });
-      logger.info('PaymentIntent for checkout session deleted on expire', {
-        checkoutSession: checkoutSession.id,
-        paymentIntent: checkoutSession.payment_intent_id,
-      });
-    }
-    if (checkoutSession.subscription_id) {
-      await SubscriptionItem.destroy({ where: { subscription_id: checkoutSession.subscription_id } });
-      await Subscription.destroy({ where: { id: checkoutSession.subscription_id } });
-      logger.info('Subscription and SubscriptionItem for checkout session deleted on expire', {
+  }
+  if (checkoutSession.setup_intent_id) {
+    await SetupIntent.destroy({ where: { id: checkoutSession.setup_intent_id } });
+    logger.info('SetupIntent for checkout session deleted on expire', {
+      checkoutSession: checkoutSession.id,
+      setupIntent: checkoutSession.setup_intent_id,
+    });
+  }
+  if (checkoutSession.payment_intent_id && checkoutSession.payment_status !== 'paid') {
+    await PaymentIntent.destroy({ where: { id: checkoutSession.payment_intent_id } });
+    logger.info('PaymentIntent for checkout session deleted on expire', {
+      checkoutSession: checkoutSession.id,
+      paymentIntent: checkoutSession.payment_intent_id,
+    });
+  }
+  if (checkoutSession.subscription_id) {
+    await SubscriptionItem.destroy({ where: { subscription_id: checkoutSession.subscription_id } });
+    await Subscription.destroy({ where: { id: checkoutSession.subscription_id } });
+    logger.info('Subscription and SubscriptionItem for checkout session deleted on expire', {
+      checkoutSession: checkoutSession.id,
+      subscription: checkoutSession.subscription_id,
+    });
+  }
+
+  // update price lock status
+  for (const item of checkoutSession.line_items) {
+    const price = await Price.findByPk(item.price_id);
+    if (price?.locked) {
+      const used = await price.isUsed(false);
+      logger.info('Price used status recheck on expire', {
         checkoutSession: checkoutSession.id,
-        subscription: checkoutSession.subscription_id,
+        priceId: item.price_id,
+        used,
       });
-    }
-
-    // update price lock status
-    for (const item of checkoutSession.line_items) {
-      const price = await Price.findByPk(item.price_id);
-      if (price?.locked) {
-        const used = await price.isUsed(false);
-        logger.info('Price used status recheck on expire', {
+      if (!used) {
+        await price.update({ locked: false });
+        logger.info('Price for checkout session unlocked on expire', {
           checkoutSession: checkoutSession.id,
           priceId: item.price_id,
-          used,
         });
-        if (!used) {
-          await price.update({ locked: false });
-          logger.info('Price for checkout session unlocked on expire', {
-            checkoutSession: checkoutSession.id,
-            priceId: item.price_id,
-          });
-        }
       }
     }
-  });
-
-  // Auto populate subscription queue
-  const now = dayjs().unix();
-  const checkoutSessions = await CheckoutSession.findAll({
-    where: {
-      status: 'open',
-      expires_at: { [Op.lte]: now },
-    },
-  });
-
-  checkoutSessions.forEach(async (checkoutSession) => {
-    const exist = await checkoutSessionQueue.get(checkoutSession.id);
-    if (!exist) {
-      checkoutSessionQueue.push({
-        id: checkoutSession.id,
-        job: { id: checkoutSession.id, action: 'expire' },
-        runAt: checkoutSession.expires_at,
-      });
-    }
-  });
-}
+  }
+});