payment-kit 1.15.33 → 1.15.35

package/api/src/queues/invoice.ts

@@ -220,6 +220,7 @@ export const startInvoiceQueue = async () => {
         status: 'open',
         collection_method: 'charge_automatically',
         amount_remaining: { [Op.gt]: '0' },
+        billing_reason: { [Op.ne]: 'stake' },
       },
     });
 

package/api/src/queues/payment.ts

@@ -587,11 +587,13 @@ export const handlePayment = async (job: PaymentJob) => {
       }
       const client = paymentMethod.getOcapClient();
 
+      const payer = paymentSettings?.payment_method_options.arcblock?.payer as string;
+
       // check balance before capture with transaction
       result = await isDelegationSufficientForPayment({
         paymentMethod,
         paymentCurrency,
-        userDid: customer.did,
+        userDid: payer || customer.did,
         amount: paymentIntent.amount,
       });
       if (result.sufficient === false) {

package/api/src/queues/refund.ts

@@ -126,10 +126,14 @@ const handleRefundJob = async (
   // try refund transfer and reschedule on error
   logger.info('Refund transfer attempt', { id: refund.id, attempt: refund.attempt_count });
   let result;
+  const paymentIntent = await PaymentIntent.findByPk(refund.payment_intent_id);
+  if (!paymentIntent) {
+    throw new Error('PaymentIntent not found');
+  }
+
   try {
     if (paymentMethod.type === 'arcblock') {
       const client = paymentMethod.getOcapClient();
-
       // check balance before transfer with transaction
       result = await isBalanceSufficientForRefund({ paymentMethod, paymentCurrency, amount: refund.amount });
       if (result.sufficient === false) {
@@ -137,11 +141,12 @@ const handleRefundJob = async (
         throw new CustomError(result.reason, 'app balance not sufficient for this refund');
       }
 
+      const payer = paymentIntent?.payment_details?.arcblock?.payer;
       // do the transfer
       const signed = await client.signTransferV2Tx({
         tx: {
           itx: {
-            to: customer.did,
+            to: payer || customer.did,
             value: '0',
             assets: [],
             tokens: [{ address: paymentCurrency.contract, value: refund.amount }],
@@ -192,7 +197,6 @@ const handleRefundJob = async (
 
       // do the capture
       const client = paymentMethod.getEvmClient();
-      const paymentIntent = await PaymentIntent.findByPk(refund.payment_intent_id);
       const payer = paymentIntent!.payment_details?.ethereum?.payer as string;
       const receipt = await sendErc20ToUser(client, paymentCurrency.contract, payer, refund.amount);
       logger.info('refund transfer done', { id: refund.id, txHash: receipt.hash });
@@ -216,10 +220,6 @@ const handleRefundJob = async (
       if (!refund.payment_intent_id) {
         throw new Error('payment intent id not found');
       }
-      const paymentIntent = await PaymentIntent.findByPk(refund.payment_intent_id);
-      if (!paymentIntent) {
-        throw new Error('PaymentIntent not found');
-      }
       const stripePaymentIntentId = paymentIntent?.payment_details?.stripe?.payment_intent_id;
       if (!stripePaymentIntentId) {
         throw new Error('paymentIntent should have stripe payment intent id');
@@ -315,7 +315,8 @@ const handleStakeReturnJob = async (
       }
       const client = paymentMethod.getOcapClient();
       const subscription = await Subscription.findByPk(refund.subscription_id);
-      const address = await getSubscriptionStakeAddress(subscription!, customer.did);
+      const address =
+        arcblockDetail?.staking?.address || (await getSubscriptionStakeAddress(subscription!, customer.did));
       const stakeEnough = await checkRemainingStake(paymentMethod, paymentCurrency, address, refund.amount);
       if (!stakeEnough.enough) {
         logger.warn('Stake return aborted because stake is not enough ', {

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,24 +693,33 @@ const ensureRefundOnCancel = async (subscription: Subscription) => {
     });
     return;
   }
-  const result = await getSubscriptionRefundSetup(subscription, subscription.cancel_at);
-  if (result.unused === '0') {
+  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.remainingUnused === '0') {
     logger.warn('Refund skipped because unused amount is 0', {
       subscription: subscription.id,
       unused: result.unused,
     });
     return;
   }
+  const currency = await PaymentCurrency.findByPk(lastInvoice?.currency_id);
   const item = await Refund.create({
     type: 'refund',
     livemode: subscription.livemode,
-    amount: refund === 'last' ? result.total : result.unused,
+    amount: refund === 'last' ? result.remaining : result.remainingUnused,
     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

@@ -1,7 +1,7 @@
 /* eslint-disable consistent-return */
 import { isValid } from '@arcblock/did';
 import { getUrl } from '@blocklet/sdk/lib/component';
-import userMiddleware from '@blocklet/sdk/lib/middlewares/user';
+import sessionMiddleware from '@blocklet/sdk/lib/middlewares/session';
 import { BN, fromUnitToToken } from '@ocap/util';
 import { NextFunction, Request, Response, Router } from 'express';
 import Joi from 'joi';
@@ -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';
@@ -69,7 +73,7 @@ import { ensureInvoiceForCheckout } from './connect/shared';
 
 const router = Router();
 
-const user = userMiddleware();
+const user = sessionMiddleware();
 const auth = authenticate<CheckoutSession>({ component: true, roles: ['owner', 'admin'] });
 
 const getPaymentMethods = async (doc: CheckoutSession) => {
@@ -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/recharge.ts

@@ -6,7 +6,7 @@ import { executeEvmTransaction, waitForEvmTxConfirm } from 'api/src/integrations
 import type { CallbackArgs } from '../../libs/auth';
 import { getGasPayerExtra } from '../../libs/payment';
 import { getTxMetadata } from '../../libs/util';
-import { ensureSubscriptionRecharge, getAuthPrincipalClaim } from './shared';
+import { ensureRechargeInvoice, ensureSubscriptionRecharge, getAuthPrincipalClaim } from './shared';
 import logger from '../../libs/logger';
 
 export default {
@@ -74,10 +74,29 @@ export default {
   },
   onAuth: async ({ request, userDid, claims, extraParams }: CallbackArgs) => {
     const { subscriptionId } = extraParams;
-    const { paymentMethod, paymentCurrency, receiverAddress } = await ensureSubscriptionRecharge(subscriptionId);
+    const { paymentMethod, paymentCurrency, receiverAddress, subscription, customer } =
+      await ensureSubscriptionRecharge(subscriptionId);
     let { amount } = extraParams;
     amount = fromTokenToUnit(amount, paymentCurrency.decimal).toString();
 
+    const afterTxExecution = async (paymentDetails: any) => {
+      await ensureRechargeInvoice(
+        {
+          total: amount,
+          description: 'Subscription recharge',
+          currency_id: paymentCurrency.id,
+          metadata: {
+            payment_details: {
+              [paymentMethod.type]: paymentDetails,
+              receiverAddress,
+            },
+          },
+        },
+        subscription!,
+        paymentMethod,
+        customer!
+      );
+    };
     if (paymentMethod.type === 'arcblock') {
       try {
         const client = paymentMethod.getOcapClient();
@@ -104,6 +123,11 @@ export default {
           paymentMethod: paymentMethod.type,
         });
 
+        await afterTxExecution({
+          tx_hash: txHash,
+          payer: userDid,
+          type: 'transfer',
+        });
         return { hash: txHash };
       } catch (err) {
         console.error(err);
@@ -120,13 +144,14 @@ export default {
           Number(paymentDetails.block_height),
           paymentMethod.confirmation.block
         )
-          .then(() => {
+          .then(async () => {
             logger.info('Recharge successful', {
               receiverAddress,
               amount,
               subscriptionId,
               paymentMethod: paymentMethod.type,
             });
+            await afterTxExecution(paymentDetails);
           })
           .catch(console.error);