payment-kit 1.15.33 → 1.15.35

package/api/src/routes/connect/setup.ts

@@ -11,6 +11,7 @@ import { addSubscriptionJob } from '../../queues/subscription';
 import type { TLineItemExpanded } from '../../store/models';
 import {
   ensureSetupIntent,
+  ensureStakeInvoice,
   executeOcapTransactions,
   getAuthPrincipalClaim,
   getDelegationTxClaim,
@@ -122,10 +123,8 @@ export default {
   onAuth: async (args: CallbackArgs) => {
     const { request, userDid, userPk, claims, extraParams } = args;
     const { checkoutSessionId, connectedDid } = extraParams;
-    const { setupIntent, checkoutSession, paymentMethod, subscription, invoice } = await ensureSetupIntent(
-      checkoutSessionId,
-      connectedDid || userDid
-    );
+    const { setupIntent, checkoutSession, paymentMethod, subscription, invoice, paymentCurrency, customer } =
+      await ensureSetupIntent(checkoutSessionId, connectedDid || userDid);
 
     if (!subscription) {
       throw new Error('Subscription for checkoutSession not found');
@@ -174,13 +173,35 @@ export default {
       try {
         await prepareTxExecution();
 
-        const paymentDetails = await executeOcapTransactions(
+        const { stakingAmount, ...paymentDetails } = await executeOcapTransactions(
           userDid,
           userPk,
           claims,
           paymentMethod,
           request,
-          subscription?.id
+          subscription?.id,
+          paymentCurrency?.contract
+        );
+
+        await ensureStakeInvoice(
+          {
+            total: stakingAmount,
+            description: 'Stake for subscription',
+            checkout_session_id: checkoutSessionId,
+            currency_id: paymentCurrency.id,
+            metadata: {
+              payment_details: {
+                arcblock: {
+                  tx_hash: paymentDetails?.staking?.tx_hash,
+                  payer: paymentDetails?.payer,
+                  address: paymentDetails?.staking?.address,
+                },
+              },
+            },
+          },
+          subscription,
+          paymentMethod,
+          customer
         );
         await afterTxExecution(paymentDetails);
 

package/api/src/routes/connect/shared.ts

@@ -624,10 +624,17 @@ export async function ensureSubscriptionRecharge(subscriptionId: string) {
   if (!receiverAddress) {
     throw new Error(`Receiver address not found for subscription ${subscriptionId}`);
   }
+
+  const customer = await Customer.findByPk(subscription.customer_id);
+  if (!customer) {
+    throw new Error(`Customer ${subscription.customer_id} not found`);
+  }
   return {
     paymentCurrency: paymentCurrency as PaymentCurrency,
     paymentMethod: paymentMethod as PaymentMethod,
     receiverAddress,
+    subscription,
+    customer
   };
 }
 
@@ -1021,7 +1028,8 @@ export async function executeOcapTransactions(
   claims: any[],
   paymentMethod: PaymentMethod,
   request: Request,
-  subscriptionId?: string
+  subscriptionId?: string,
+  paymentCurrencyContract?: string
 ) {
   const client = paymentMethod.getOcapClient();
   const delegation = claims.find((x) => x.type === 'signature' && x.meta?.purpose === 'delegation');
@@ -1031,6 +1039,9 @@ export async function executeOcapTransactions(
     [staking, 'Stake'],
   ];
 
+  const stakingAmount =
+    staking?.requirement?.tokens?.find((x: any) => x.address === paymentCurrencyContract)?.value || '0';
+
   const [delegationTxHash, stakingTxHash] = await Promise.all(
     transactions.map(async ([claim, type]) => {
       if (!claim) {
@@ -1065,5 +1076,216 @@ export async function executeOcapTransactions(
       tx_hash: stakingTxHash,
       address: await getCustomerStakeAddress(userDid, nonce),
     },
+    stakingAmount,
   };
 }
+
+export async function ensureStakeInvoice(
+  invoiceProps: { total: string; description?: string; checkout_session_id?: string; currency_id: string; metadata?: any; payment_settings?: any },
+  subscription: Subscription,
+  paymentMethod: PaymentMethod,
+  customer: Customer
+) {
+  if (paymentMethod.type !== 'arcblock') {
+    return;
+  }
+  try {
+    const stakingInvoice = await Invoice.create({
+      livemode: subscription.livemode,
+      number: await customer.getInvoiceNumber(),
+      description: invoiceProps?.description || 'Stake for subscription',
+      statement_descriptor: '',
+      period_start: dayjs().unix(),
+      period_end: subscription.current_period_end,
+
+      auto_advance: false,
+      paid: true,
+      paid_out_of_band: false,
+
+      status: 'paid',
+      collection_method: 'charge_automatically',
+      billing_reason: 'stake',
+
+      currency_id: invoiceProps.currency_id,
+      customer_id: customer.id,
+      payment_intent_id: '',
+      subscription_id: subscription?.id,
+      checkout_session_id: invoiceProps?.checkout_session_id || '',
+
+      total: invoiceProps.total || '0',
+      subtotal: invoiceProps.total || '0',
+      tax: '0',
+      subtotal_excluding_tax: invoiceProps.total || '0',
+
+      amount_due: '0',
+      amount_paid: invoiceProps.total || '0',
+      amount_remaining: '0',
+      amount_shipping: '0',
+
+      starting_balance: '0',
+      ending_balance: '0',
+      starting_token_balance: {},
+      ending_token_balance: {},
+
+      attempt_count: 0,
+      attempted: false,
+      // next_payment_attempt: undefined,
+
+      custom_fields: [],
+      customer_address: customer.address,
+      customer_email: customer.email,
+      customer_name: customer.name,
+      customer_phone: customer.phone,
+
+      discounts: [],
+      total_discount_amounts: [],
+
+      due_date: undefined,
+      effective_at: dayjs().unix(), 
+      status_transitions: {
+        finalized_at: dayjs().unix(),
+      },
+
+      payment_settings: invoiceProps?.payment_settings || subscription?.payment_settings,
+      default_payment_method_id: paymentMethod.id,
+
+      account_country: '',
+      account_name: '',
+      metadata: invoiceProps.metadata || {},
+    });
+    logger.info('create staking invoice success', {
+      stakingInvoice,
+      subscriptionId: subscription?.id,
+      paymentMethod: paymentMethod.id,
+      customerId: customer.id,
+    });
+  } catch (error) {
+    logger.error('ensureStake: create invoice failed', { error, subscriptionId: subscription?.id, paymentMethod: paymentMethod.id, customerId: customer.id });
+  }
+}
+
+
+export async function updateStripeSubscriptionAfterChangePayment(setupIntent: SetupIntent, subscription: Subscription) {
+  const { from_method: fromMethodId, to_method: toMethodId } = setupIntent.metadata || {};
+  const fromMethod = await PaymentMethod.findByPk(fromMethodId);
+  if (fromMethod?.type === 'stripe') {
+    // pause Stripe
+    const client = fromMethod?.getStripeClient();
+    const stripeSubscriptionId = subscription.payment_details?.stripe?.subscription_id as string;
+    if (client && stripeSubscriptionId) {
+      const stripeSubscription = await client.subscriptions.retrieve(stripeSubscriptionId);
+      if (stripeSubscription) {
+        const result = await client.subscriptions.update(stripeSubscriptionId, {
+          pause_collection: {
+            behavior: 'void',
+          },
+        });
+        logger.info('stripe subscription paused on payment change', {
+          subscription: subscription.id,
+          stripeSubscription: stripeSubscriptionId,
+          result,
+        });
+      }
+    }
+  } else {
+    const toMethod = await PaymentMethod.findByPk(toMethodId);
+    if (toMethod?.type === 'stripe') {
+      // resume stripe
+      const client =  toMethod?.getStripeClient();
+      const stripeSubscriptionId = subscription.payment_details?.stripe?.subscription_id as string;
+      if (client && stripeSubscriptionId) {
+        const stripeSubscription = await client.subscriptions.retrieve(stripeSubscriptionId);
+        if (stripeSubscription.status === 'paused') {
+          await client.subscriptions.resume(stripeSubscriptionId, {
+            proration_behavior: 'none',
+          });
+          logger.info('stripe subscription resumed on payment change', {
+            subscription: subscription.id,
+            stripeSubscription: stripeSubscriptionId,
+          });
+        }
+      }
+    }
+  }
+}
+
+export async function ensureRechargeInvoice(
+  invoiceProps: { total: string; description?: string; checkout_session_id?: string; currency_id: string; metadata?: any; payment_settings?: any },
+  subscription: Subscription,
+  paymentMethod: PaymentMethod,
+  customer: Customer
+) {
+  try {
+    const rechargeInvoice = await Invoice.create({
+      livemode: subscription.livemode,
+      number: await customer.getInvoiceNumber(),
+      description: invoiceProps?.description || 'Subscription recharge',
+      statement_descriptor: '',
+      period_start: dayjs().unix(),
+      period_end: dayjs().unix(),
+
+      auto_advance: false,
+      paid: true,
+      paid_out_of_band: false,
+
+      status: 'paid',
+      collection_method: 'charge_automatically',
+      billing_reason: 'recharge',
+
+      currency_id: invoiceProps.currency_id,
+      customer_id: customer.id,
+      payment_intent_id: '',
+      subscription_id: subscription?.id,
+      checkout_session_id: invoiceProps?.checkout_session_id || '',
+
+      total: invoiceProps.total || '0',
+      subtotal: invoiceProps.total || '0',
+      tax: '0',
+      subtotal_excluding_tax: invoiceProps.total || '0',
+
+      amount_due: '0',
+      amount_paid: invoiceProps.total || '0',
+      amount_remaining: '0',
+      amount_shipping: '0',
+
+      starting_balance: '0',
+      ending_balance: '0',
+      starting_token_balance: {},
+      ending_token_balance: {},
+
+      attempt_count: 0,
+      attempted: false,
+      // next_payment_attempt: undefined,
+
+      custom_fields: [],
+      customer_address: customer.address,
+      customer_email: customer.email,
+      customer_name: customer.name,
+      customer_phone: customer.phone,
+
+      discounts: [],
+      total_discount_amounts: [],
+
+      due_date: undefined,
+      effective_at: dayjs().unix(), 
+      status_transitions: {
+        finalized_at: dayjs().unix(),
+      },
+
+      payment_settings: invoiceProps?.payment_settings || subscription?.payment_settings,
+      default_payment_method_id: paymentMethod.id,
+
+      account_country: '',
+      account_name: '',
+      metadata: invoiceProps.metadata || {},
+    });
+    logger.info('create recharge invoice success', {
+      rechargeInvoice,
+      subscriptionId: subscription?.id,
+      paymentMethod: paymentMethod.id,
+      customerId: customer.id,
+    });
+  } catch (error) {
+    logger.error('ensureRechargeInvoice: create invoice failed', { error, subscriptionId: subscription?.id, paymentMethod: paymentMethod.id, customerId: customer.id });
+  }
+}

package/api/src/routes/connect/subscribe.ts

@@ -12,6 +12,7 @@ import type { Invoice, TLineItemExpanded } from '../../store/models';
 import {
   ensureInvoiceForCheckout,
   ensurePaymentIntent,
+  ensureStakeInvoice,
   executeOcapTransactions,
   getAuthPrincipalClaim,
   getDelegationTxClaim,
@@ -122,7 +123,7 @@ export default {
   onAuth: async (args: CallbackArgs) => {
     const { request, userDid, userPk, claims, extraParams } = args;
     const { checkoutSessionId, connectedDid } = extraParams;
-    const { checkoutSession, customer, paymentMethod, subscription } = await ensurePaymentIntent(
+    const { checkoutSession, customer, paymentMethod, subscription, paymentCurrency } = await ensurePaymentIntent(
       checkoutSessionId,
       connectedDid || userDid
     );
@@ -159,13 +160,34 @@ export default {
       await prepareTxExecution();
       const { invoice } = await ensureInvoiceForCheckout({ checkoutSession, customer, subscription });
 
-      const paymentDetails = await executeOcapTransactions(
+      const { stakingAmount, ...paymentDetails } = await executeOcapTransactions(
         userDid,
         userPk,
         claims,
         paymentMethod,
         request,
-        subscription?.id
+        subscription?.id,
+        paymentCurrency?.contract
+      );
+      await ensureStakeInvoice(
+        {
+          total: stakingAmount,
+          description: 'Stake for subscription',
+          checkout_session_id: checkoutSessionId,
+          currency_id: paymentCurrency.id,
+          metadata: {
+            payment_details: {
+              arcblock: {
+                tx_hash: paymentDetails?.staking?.tx_hash,
+                payer: paymentDetails?.payer,
+                address: paymentDetails?.staking?.address,
+              },
+            },
+          },
+        },
+        subscription,
+        paymentMethod,
+        customer
       );
       await afterTxExecution(invoice!, paymentDetails);
 

package/api/src/routes/customers.ts

@@ -1,4 +1,4 @@
-import { user } from '@blocklet/sdk/lib/middlewares';
+import sessionMiddleware from '@blocklet/sdk/lib/middlewares/session';
 import { Router } from 'express';
 import Joi from 'joi';
 import pick from 'lodash/pick';
@@ -79,7 +79,7 @@ router.get('/search', auth, async (req, res) => {
 });
 
 // eslint-disable-next-line consistent-return
-router.get('/me', user(), async (req, res) => {
+router.get('/me', sessionMiddleware(), async (req, res) => {
   if (!req.user) {
     return res.status(403).json({ error: 'Unauthorized' });
   }

package/api/src/routes/invoices.ts

@@ -10,7 +10,6 @@ import { createListParamSchema, getWhereFromKvQuery, MetadataSchema } from '../l
 import { authenticate } from '../libs/security';
 import { expandLineItems } from '../libs/session';
 import { formatMetadata } from '../libs/util';
-import { Refund, SetupIntent } from '../store/models';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
 import { InvoiceItem } from '../store/models/invoice-item';
@@ -20,7 +19,7 @@ import { PaymentMethod } from '../store/models/payment-method';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
 import { Subscription } from '../store/models/subscription';
-import { getSubscriptionStakeAmountSetup } from '../libs/subscription';
+import { getReturnStakeInvoices, getStakingInvoices } from '../libs/invoice';
 
 const router = Router();
 const authAdmin = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
@@ -43,6 +42,7 @@ const schema = createListParamSchema<{
   currency_id?: string;
   ignore_zero?: boolean;
   include_staking?: boolean;
+  include_return_staking?: boolean;
   include_recovered_from?: boolean;
 }>({
   status: Joi.string().empty(''),
@@ -52,17 +52,16 @@ const schema = createListParamSchema<{
   currency_id: Joi.string().empty(''),
   ignore_zero: Joi.boolean().empty(false),
   include_staking: Joi.boolean().empty(false),
+  include_return_staking: Joi.boolean().empty(false),
   include_recovered_from: Joi.boolean().empty(false),
 });
 router.get('/', authMine, async (req, res) => {
   // eslint-disable-next-line @typescript-eslint/naming-convention
-  const { page, pageSize, livemode, status, ignore_zero, include_staking, ...query } = await schema.validateAsync(
-    req.query,
-    {
+  const { page, pageSize, livemode, status, ignore_zero, include_staking, include_return_staking, ...query } =
+    await schema.validateAsync(req.query, {
       stripUnknown: false,
       allowUnknown: true,
-    }
-  );
+    });
   const where = getWhereFromKvQuery(query.q);
 
   if (status) {
@@ -108,7 +107,13 @@ router.get('/', authMine, async (req, res) => {
       // @ts-ignore
       where[key] = query[key];
     });
-
+  const excludeBillingReasons = ['recharge'];
+  if (!!(include_staking && query.subscription_id) || !include_staking) {
+    excludeBillingReasons.push('stake');
+  }
+  if (excludeBillingReasons.length > 0) {
+    where.billing_reason = { [Op.notIn]: excludeBillingReasons };
+  }
   try {
     const { rows: list, count } = await Invoice.findAndCountAll({
       where,
@@ -117,7 +122,7 @@ router.get('/', authMine, async (req, res) => {
       limit: pageSize,
       include: [
         { model: PaymentCurrency, as: 'paymentCurrency' },
-        // { model: PaymentMethod, as: 'paymentMethod' },
+        { model: PaymentMethod, as: 'paymentMethod' },
         // { model: PaymentIntent, as: 'paymentIntent' },
         // { model: Subscription, as: 'subscription' },
         { model: Customer, as: 'customer' },
@@ -126,113 +131,30 @@ router.get('/', authMine, async (req, res) => {
 
     // push staking info as first invoice if we are on the last page
     let subscription;
+    let invoices = list;
     if (query.subscription_id && include_staking && page === Math.ceil((count || 1) / pageSize)) {
       try {
         subscription = await Subscription.findByPk(query.subscription_id);
         if (subscription?.payment_details?.arcblock?.staking?.tx_hash) {
-          const method = await PaymentMethod.findOne({ where: { type: 'arcblock', livemode: subscription.livemode } });
-          const setup = await SetupIntent.findOne({
-            where: {
-              customer_id: subscription.customer_id,
-              payment_method_id: method?.id,
-              metadata: { subscription_id: subscription.id },
-            },
-            order: [['created_at', 'ASC']],
-          });
-          const currencyId = setup?.currency_id || subscription.currency_id;
-          const currency = await PaymentCurrency.findByPk(currencyId);
-          if (method && currency) {
-            const { address } = subscription.payment_details.arcblock.staking;
-            const firstInvoice = await Invoice.findOne({
-              where: { subscription_id: subscription.id, currency_id: currencyId },
-              order: [['created_at', 'ASC']],
-              include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
-            });
-            if (firstInvoice) {
-              const customer = await Customer.findByPk(firstInvoice.customer_id);
-              const stakeAmountResult = await getSubscriptionStakeAmountSetup(subscription, method);
-              // @ts-ignore
-              const stakeAmount = stakeAmountResult?.[currency?.contract] || '0';
-
-              list.push({
-                id: address as string,
-                status: 'paid',
-                description: 'Subscription staking',
-                billing_reason: 'subscription_create',
-                total: stakeAmount,
-                amount_due: '0',
-                amount_paid: stakeAmount,
-                amount_remaining: '0',
-                ...pick(firstInvoice, [
-                  'number',
-                  'paid',
-                  'auto_advance',
-                  'currency_id',
-                  'customer_id',
-                  'subscription_id',
-                  'period_start',
-                  'period_end',
-                  'created_at',
-                  'updated_at',
-                ]),
-                // @ts-ignore
-                paymentCurrency: currency,
-                paymentMethod: method,
-                customer,
-                metadata: {
-                  payment_details: {
-                    arcblock: {
-                      tx_hash: subscription.payment_details.arcblock.staking.tx_hash,
-                      payer: subscription.payment_details.arcblock.payer,
-                    },
-                  },
-                },
-              });
-              const stakeRefundRecord = await Refund.findOne({
-                where: { subscription_id: subscription.id, status: 'succeeded', type: 'stake_return' },
-              });
-              if (stakeRefundRecord) {
-                list.unshift({
-                  id: address as string,
-                  status: 'paid',
-                  description: 'Return Subscription staking',
-                  billing_reason: 'subscription_create',
-                  total: stakeRefundRecord.amount,
-                  amount_due: '0',
-                  amount_paid: stakeRefundRecord.amount,
-                  amount_remaining: '0',
-                  created_at: stakeRefundRecord.created_at,
-                  updated_at: stakeRefundRecord.updated_at,
-                  currency_id: stakeRefundRecord.currency_id,
-                  customer_id: stakeRefundRecord.customer_id,
-                  subscription_id: subscription.id,
-                  period_start: subscription.current_period_start,
-                  period_end: subscription.current_period_end,
-                  paid: true,
-                  ...pick(firstInvoice, ['number', 'auto_advance']),
-                  // @ts-ignore
-                  paymentCurrency: currency,
-                  paymentMethod: method,
-                  customer,
-                  metadata: {
-                    payment_details: {
-                      arcblock: {
-                        tx_hash: stakeRefundRecord?.payment_details?.arcblock?.tx_hash,
-                        payer: stakeRefundRecord?.payment_details?.arcblock?.payer,
-                      },
-                    },
-                  },
-                });
-              }
-            }
+          const stakingInvoices = await getStakingInvoices(subscription);
+          let returnStakeInvoices: any[] = [];
+          if (include_return_staking) {
+            returnStakeInvoices = await getReturnStakeInvoices(subscription);
           }
+          invoices = [...(stakingInvoices || []), ...(returnStakeInvoices || []), ...list]
+            .filter(Boolean)
+            .sort((a, b) =>
+              query.o === 'asc'
+                ? new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
+                : new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
+            );
         }
       } catch (err) {
         console.error('Failed to include staking record in invoice list', err);
       }
     }
 
-    res.json({ count, list, subscription, paging: { page, pageSize } });
+    res.json({ count, list: invoices, subscription, paging: { page, pageSize } });
   } catch (err) {
     console.error(err);
     res.json({ count: 0, list: [], paging: { page, pageSize } });

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

@@ -93,6 +93,9 @@ const formatBeforeSave = (payload: any) => {
 
   raw.line_items?.forEach((x) => {
     if (x.adjustable_quantity?.enabled) {
+      if (Number(x.adjustable_quantity?.minimum) >= Number(x.adjustable_quantity?.maximum)) {
+        throw new Error('adjustable_quantity.minimum must be less than adjustable_quantity.maximum');
+      }
       x.adjustable_quantity.minimum = Number(x.adjustable_quantity?.minimum);
       x.adjustable_quantity.maximum = Number(x.adjustable_quantity?.maximum);
     }

package/api/src/routes/refunds.ts

@@ -261,7 +261,28 @@ router.put('/:id', authAdmin, async (req, res) => {
       requestBody: req.body,
       requestedBy: req.user?.did,
     });
-    res.status(500).json({ error: 'Internal server error' });
+    return res.status(400).json({ error: err.message });
+  }
+});
+
+router.post('/:id/cancel', authAdmin, async (req, res) => {
+  const doc = await Refund.findByPk(req.params.id as string);
+  if (!doc) {
+    return res.status(404).json({ error: 'Refund not found' });
+  }
+  if (doc.status === 'succeeded') {
+    return res.status(400).json({ error: 'Refund is already succeeded' });
+  }
+  try {
+    await doc.update({ status: 'canceled' });
+    return res.json(doc);
+  } catch (err) {
+    logger.error('Cancel refund failed', {
+      refundId: req.params.id,
+      error: err.message,
+      requestedBy: req.user?.did,
+    });
+    return res.status(400).json({ error: err.message });
   }
 });