payment-kit 1.15.33 → 1.15.34

package/api/src/queues/subscription.ts

@@ -23,7 +23,7 @@ import {
   shouldCancelSubscription,
 } from '../libs/subscription';
 import { ensureInvoiceAndItems } from '../routes/connect/shared';
-import { PaymentCurrency, PaymentIntent, PaymentMethod, Refund, UsageRecord } from '../store/models';
+import { PaymentCurrency, PaymentIntent, PaymentMethod, Refund, SetupIntent, UsageRecord } from '../store/models';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
 import { Price } from '../store/models/price';
@@ -325,24 +325,39 @@ const handleSubscriptionAfterRecover = async (subscription: Subscription) => {
 };
 
 const handleStakeSlashAfterCancel = async (subscription: Subscription) => {
-  const method = await PaymentMethod.findByPk(subscription.default_payment_method_id);
-  if (!method || method.type !== 'arcblock') {
+  const invoice = await Invoice.findByPk(subscription.latest_invoice_id);
+  if (!invoice || invoice.status !== 'uncollectible') {
+    logger.warn('Stake slashing aborted because invoice status', {
+      subscription: subscription.id,
+      invoice: invoice?.id,
+      status: invoice?.status,
+    });
     return;
   }
-  const currency = await PaymentCurrency.findByPk(subscription.currency_id);
+  const currency = await PaymentCurrency.findByPk(invoice.currency_id || subscription.currency_id);
   if (!currency) {
+    logger.warn('Stake slashing aborted because currency not found', {
+      subscription: subscription.id,
+      invoice: invoice.id,
+      currency: invoice.currency_id || subscription.currency_id,
+    });
     return;
   }
-  const customer = await Customer.findByPk(subscription.customer_id);
-  if (!customer) {
+  const method = await PaymentMethod.findByPk(currency.payment_method_id);
+  if (!method || method.type !== 'arcblock') {
+    logger.warn('Stake slashing aborted because payment method not arcblock', {
+      subscription: subscription.id,
+      invoice: invoice.id,
+      method: method?.id,
+    });
     return;
   }
-  const invoice = await Invoice.findByPk(subscription.latest_invoice_id);
-  if (!invoice || invoice.status !== 'uncollectible') {
-    logger.warn('Stake slashing aborted because invoice status', {
+  const customer = await Customer.findByPk(subscription.customer_id);
+  if (!customer) {
+    logger.warn('Stake slashing aborted because customer not found', {
       subscription: subscription.id,
-      invoice: invoice?.id,
-      status: invoice?.status,
+      invoice: invoice.id,
+      customer: subscription.customer_id,
     });
     return;
   }
@@ -468,8 +483,18 @@ const handleStakeSlashAfterCancel = async (subscription: Subscription) => {
   });
 };
 
-const ensureReturnStake = async (subscription: Subscription) => {
-  const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+const ensureReturnStake = async (subscription: Subscription, paymentCurrencyId?: string, stakingAddress?: string) => {
+  const paymentCurrency = await PaymentCurrency.findByPk(paymentCurrencyId || subscription.currency_id);
+  if (!paymentCurrency) {
+    logger.warn('Stake return skipped because no payment currency', {
+      subscription: subscription.id,
+      currency: subscription.currency_id,
+    });
+    return;
+  }
+  const paymentMethod = await PaymentMethod.findByPk(
+    paymentCurrency.payment_method_id || subscription.default_payment_method_id
+  );
   if (paymentMethod?.type !== 'arcblock') {
     logger.warn('Stake return skipped because payment method not arcblock', {
       subscription: subscription.id,
@@ -477,7 +502,7 @@ const ensureReturnStake = async (subscription: Subscription) => {
     });
     return;
   }
-  const address = subscription?.payment_details?.arcblock?.staking?.address;
+  const address = stakingAddress || subscription?.payment_details?.arcblock?.staking?.address;
   if (!address) {
     logger.warn('Stake return skipped because no staking address', {
       subscription: subscription.id,
@@ -486,21 +511,7 @@ const ensureReturnStake = async (subscription: Subscription) => {
     return;
   }
 
-  const refunds = await Refund.findAll({ where: { subscription_id: subscription.id, type: 'stake_return' } });
-  if (refunds.length > 0) {
-    logger.info(`Stake return skipped because subscription ${subscription.id} already has stake return records.`);
-    return;
-  }
-  const paymentCurrency = await PaymentCurrency.findByPk(subscription.currency_id);
-  if (!paymentCurrency) {
-    logger.warn('Stake return skipped because no payment currency', {
-      subscription: subscription.id,
-      currency: subscription.currency_id,
-    });
-    return;
-  }
-
-  const result = await getSubscriptionStakeReturnSetup(subscription, address, paymentMethod);
+  const result = await getSubscriptionStakeReturnSetup(subscription, address, paymentMethod, paymentCurrencyId);
 
   const stakeEnough = await checkRemainingStake(paymentMethod, paymentCurrency, address, result.return_amount);
   if (!stakeEnough.enough) {
@@ -513,17 +524,27 @@ const ensureReturnStake = async (subscription: Subscription) => {
     return;
   }
   if (result.return_amount !== '0') {
+    const invoice = await Invoice.findOne({
+      where: {
+        billing_reason: 'stake',
+        subscription_id: subscription.id,
+        currency_id: paymentCurrency.id,
+        status: 'paid',
+      },
+      order: [['created_at', 'DESC']],
+    });
     // do the stake return
     const item = await Refund.create({
       type: 'stake_return',
       livemode: subscription.livemode,
       amount: result.return_amount,
-      description: 'stake_return_on_subscription_cancel',
+      description: 'stake_return_for_subscription',
       status: 'pending',
       reason: 'requested_by_admin',
-      currency_id: subscription.currency_id,
+      currency_id: paymentCurrency.id,
+      invoice_id: invoice?.id,
       customer_id: subscription.customer_id,
-      payment_method_id: subscription.default_payment_method_id,
+      payment_method_id: paymentMethod.id,
       payment_intent_id: result?.lastInvoice?.payment_intent_id as string,
       subscription_id: subscription.id,
       attempt_count: 0,
@@ -538,6 +559,10 @@ const ensureReturnStake = async (subscription: Subscription) => {
         // @ts-ignore
         arcblock: {
           receiver: result.sender,
+          staking: {
+            address,
+            tx_hash: '',
+          },
         },
       },
     });
@@ -547,7 +572,7 @@ const ensureReturnStake = async (subscription: Subscription) => {
       item: item.toJSON(),
     });
   } else {
-    logger.info('Skipped stake return for canceled subscription', {
+    logger.info('Skipped stake return for subscription', {
       subscription: subscription.id,
       return_amount: result.return_amount,
     });
@@ -668,7 +693,15 @@ const ensureRefundOnCancel = async (subscription: Subscription) => {
     });
     return;
   }
-  const result = await getSubscriptionRefundSetup(subscription, subscription.cancel_at);
+  const lastInvoice = await Invoice.findByPk(subscription.latest_invoice_id);
+  if (!lastInvoice) {
+    logger.warn('Refund skipped because no latest invoice', {
+      subscription: subscription.id,
+    });
+    return;
+  }
+
+  const result = await getSubscriptionRefundSetup(subscription, subscription.cancel_at, lastInvoice.currency_id);
   if (result.unused === '0') {
     logger.warn('Refund skipped because unused amount is 0', {
       subscription: subscription.id,
@@ -676,6 +709,7 @@ const ensureRefundOnCancel = async (subscription: Subscription) => {
     });
     return;
   }
+  const currency = await PaymentCurrency.findByPk(lastInvoice?.currency_id);
   const item = await Refund.create({
     type: 'refund',
     livemode: subscription.livemode,
@@ -683,9 +717,9 @@ const ensureRefundOnCancel = async (subscription: Subscription) => {
     description: 'refund_transfer_on_subscription_cancel',
     status: 'pending',
     reason: 'requested_by_admin',
-    currency_id: subscription.currency_id,
+    currency_id: result.lastInvoice?.currency_id,
     customer_id: subscription.customer_id,
-    payment_method_id: subscription.default_payment_method_id,
+    payment_method_id: currency?.payment_method_id || subscription.default_payment_method_id,
     payment_intent_id: result.lastInvoice.payment_intent_id as string,
     invoice_id: result.lastInvoice.id,
     subscription_id: subscription.id,
@@ -852,12 +886,12 @@ export const slashStakeQueue = createQueue({
 export const returnStakeQueue = createQueue({
   name: 'returnStake',
   onJob: async (job) => {
-    const { subscriptionId } = job;
+    const { subscriptionId, stakingAddress, paymentCurrencyId } = job;
     const subscription = await Subscription.findByPk(subscriptionId);
     if (!subscription) {
       return;
     }
-    await ensureReturnStake(subscription);
+    await ensureReturnStake(subscription, paymentCurrencyId, stakingAddress);
   },
   options: {
     concurrency: 1,
@@ -997,3 +1031,40 @@ events.on('customer.stake.revoked', async ({ subscriptionId, tx }: { subscriptio
   await new SubscriptionWillCanceledSchedule().reScheduleSubscriptionTasks([subscription]);
   await addSubscriptionJob(subscription, 'cancel', true, subscription.current_period_end);
 });
+
+events.on('setup_intent.succeeded', async (setupIntent: SetupIntent) => {
+  logger.info('setup intent succeeded', { setupIntent: setupIntent.id });
+  if (setupIntent.metadata?.from_currency && setupIntent?.metadata?.subscription_id) {
+    const subscription = await Subscription.findByPk(setupIntent.metadata.subscription_id);
+    if (!subscription) {
+      logger.info('skip return stake because no subscription found', { setupIntent: setupIntent.id });
+      return;
+    }
+    const stakingInvoice = await Invoice.findOne({
+      where: {
+        subscription_id: subscription.id,
+        billing_reason: 'stake',
+        currency_id: setupIntent.metadata?.from_currency,
+        status: 'paid',
+      },
+      order: [['created_at', 'DESC']],
+    });
+    logger.info('staking invoice', { stakingInvoice });
+    if (stakingInvoice) {
+      returnStakeQueue.push({
+        id: `return-stake-${subscription.id}-${stakingInvoice.id}`,
+        job: {
+          subscriptionId: subscription.id,
+          stakingAddress: stakingInvoice?.metadata?.payment_details?.arcblock?.address,
+          paymentCurrencyId: setupIntent.metadata?.from_currency,
+        },
+      });
+      logger.info('subscription return stake job scheduled', {
+        jobId: `return-stake-${subscription.id}-${stakingInvoice.id}`,
+        subscription: subscription.id,
+        stakingAddress: stakingInvoice?.metadata?.payment_details?.arcblock?.address,
+        paymentCurrencyId: setupIntent.metadata?.from_currency,
+      });
+    }
+  }
+});

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

@@ -17,7 +17,11 @@ import { MetadataSchema } from '../libs/api';
 import { checkPassportForPaymentLink } from '../integrations/blocklet/passport';
 import { handleStripePaymentSucceed } from '../integrations/stripe/handlers/payment-intent';
 import { handleStripeSubscriptionSucceed } from '../integrations/stripe/handlers/subscription';
-import { ensureStripePaymentIntent, ensureStripeSubscription } from '../integrations/stripe/resource';
+import {
+  ensureStripePaymentCustomer,
+  ensureStripePaymentIntent,
+  ensureStripeSubscription,
+} from '../integrations/stripe/resource';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import { isCreditSufficientForPayment, isDelegationSufficientForPayment } from '../libs/payment';
@@ -141,11 +145,11 @@ const SubscriptionDataSchema = Joi.object({
     .items(
       Joi.object({
         name: Joi.string().optional(),
-        color: Joi.string().allow('primary', 'secondary', 'success', 'error', 'warning').optional(),
-        variant: Joi.string().allow('text', 'contained', 'outlined').optional(),
+        color: Joi.string().valid('primary', 'secondary', 'success', 'error', 'warning').optional(),
+        variant: Joi.string().valid('text', 'contained', 'outlined').optional(),
         text: Joi.object().required(),
         link: Joi.string().uri().required(),
-        type: Joi.string().allow('notification', 'custom').optional(),
+        type: Joi.string().valid('notification', 'custom').optional(),
         triggerEvents: Joi.array().items(Joi.string()).optional(),
       })
     )
@@ -1027,6 +1031,18 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
           trialInDays,
           trialEnd
         );
+        const stripeCustomer = await ensureStripePaymentCustomer(subscription, paymentMethod);
+        if (stripeSubscription) {
+          await subscription.update({
+            payment_details: {
+              stripe: {
+                customer_id: stripeCustomer.id,
+                subscription_id: stripeSubscription.id,
+                setup_intent_id: stripeSubscription.pending_setup_intent?.id,
+              },
+            },
+          });
+        }
         logger.info('ensureStripeSubscription', {
           subscriptionId: subscription.id,
           stripeSubscriptionId: stripeSubscription?.id,

package/api/src/routes/connect/change-payment.ts

@@ -1,15 +1,15 @@
 import { executeEvmTransaction, waitForEvmTxConfirm } from '../../integrations/ethereum/tx';
 import type { CallbackArgs } from '../../libs/auth';
-import { isDelegationSufficientForPayment } from '../../libs/payment';
-import { getFastCheckoutAmount } from '../../libs/session';
 import { getTxMetadata } from '../../libs/util';
-import type { TLineItemExpanded } from '../../store/models';
+import { Lock, type TLineItemExpanded } from '../../store/models';
 import {
   ensureChangePaymentContext,
+  ensureStakeInvoice,
   executeOcapTransactions,
   getAuthPrincipalClaim,
   getDelegationTxClaim,
   getStakeTxClaim,
+  updateStripeSubscriptionAfterChangePayment,
 } from './shared';
 
 export default {
@@ -23,42 +23,31 @@ export default {
   },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
     const { subscriptionId } = extraParams;
-    const { subscription, customer, paymentMethod, paymentCurrency } = await ensureChangePaymentContext(subscriptionId);
+    const { subscription, paymentMethod, paymentCurrency } = await ensureChangePaymentContext(subscriptionId);
 
     const claims: { [type: string]: [string, object] } = {};
 
     // @ts-ignore
     const items = subscription!.items as TLineItemExpanded[];
-    const trialing = false;
+    const trialing = true;
     const billingThreshold = Number(subscription.billing_thresholds?.amount_gte || 0);
-    const fastCheckoutAmount = getFastCheckoutAmount(items, 'setup', paymentCurrency.id, trialing);
 
     if (paymentMethod.type === 'arcblock') {
-      const delegation = await isDelegationSufficientForPayment({
-        paymentMethod,
-        paymentCurrency,
-        userDid: customer!.did,
-        amount: fastCheckoutAmount,
-      });
-
-      // if we can complete purchase without any wallet interaction
-      if (delegation.sufficient === false) {
-        claims.delegation = [
-          'signature',
-          await getDelegationTxClaim({
-            mode: 'setup',
-            userDid,
-            userPk,
-            nonce: `change-method-${subscription.id}`,
-            data: getTxMetadata({ subscriptionId: subscription.id }),
-            paymentCurrency,
-            paymentMethod,
-            trialing,
-            billingThreshold,
-            items,
-          }),
-        ];
-      }
+      claims.delegation = [
+        'signature',
+        await getDelegationTxClaim({
+          mode: 'setup',
+          userDid,
+          userPk,
+          nonce: `change-method-${subscription.id}`,
+          data: getTxMetadata({ subscriptionId: subscription.id }),
+          paymentCurrency,
+          paymentMethod,
+          trialing,
+          billingThreshold,
+          items,
+        }),
+      ];
 
       // we always need to stake for the subscription
       claims.staking = [
@@ -105,7 +94,7 @@ export default {
 
   onAuth: async ({ request, userDid, userPk, claims, extraParams }: CallbackArgs) => {
     const { subscriptionId } = extraParams;
-    const { subscription, setupIntent, paymentCurrency, paymentMethod } =
+    const { subscription, setupIntent, paymentCurrency, paymentMethod, customer } =
       await ensureChangePaymentContext(subscriptionId);
 
     const prepareTxExecution = async () => {
@@ -135,18 +124,46 @@ export default {
       await subscription?.update({
         currency_id: paymentCurrency.id,
         default_payment_method_id: paymentMethod.id,
+        payment_details: {
+          ...subscription.payment_details,
+          [paymentMethod.type]: paymentDetails,
+        },
       });
+
+      await Lock.acquire(`${subscription.id}-change-plan`, subscription.current_period_end);
+      // update stripe subscription
+      await updateStripeSubscriptionAfterChangePayment(setupIntent, subscription);
     };
 
     if (paymentMethod.type === 'arcblock') {
       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 payment change',
+          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);
       return { hash: paymentDetails.tx_hash };

package/api/src/routes/connect/change-plan.ts

@@ -8,6 +8,7 @@ import { invoiceQueue } from '../../queues/invoice';
 import { addSubscriptionJob, subscriptionQueue } from '../../queues/subscription';
 import type { TLineItemExpanded } from '../../store/models';
 import {
+  ensureStakeInvoice,
   ensureSubscription,
   executeOcapTransactions,
   getAuthPrincipalClaim,
@@ -107,7 +108,8 @@ export default {
 
   onAuth: async ({ request, userDid, userPk, claims, extraParams }: CallbackArgs) => {
     const { subscriptionId } = extraParams;
-    const { invoice, paymentMethod, subscription } = await ensureSubscription(subscriptionId);
+    const { invoice, paymentMethod, subscription, paymentCurrency, customer } =
+      await ensureSubscription(subscriptionId);
 
     const prepareTxExecution = async () => {
       await subscription?.update({
@@ -142,13 +144,33 @@ export default {
     if (paymentMethod.type === 'arcblock') {
       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 plan change',
+          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/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);