payment-kit 1.15.33 → 1.15.34

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

@@ -1,7 +1,7 @@
 import type Stripe from 'stripe';
 
 import logger from '../../../libs/logger';
-import { CheckoutSession, SetupIntent, Subscription, TEventExpanded } from '../../../store/models';
+import { CheckoutSession, Lock, SetupIntent, Subscription, TEventExpanded } from '../../../store/models';
 
 async function handleSubscriptionOnSetupSucceeded(event: TEventExpanded, stripeIntentId: string) {
   const subscription = await Subscription.findOne({
@@ -69,6 +69,8 @@ async function handleSetupIntentOnSetupSucceeded(event: TEventExpanded, stripeIn
             payment_method_options: {},
           },
         });
+        // lock the subscription to prevent concurrent change plan
+        await Lock.acquire(`${subscription.id}-change-plan`, subscription.current_period_end);
         logger.info('subscription payment changed to stripe on stripe setup intent succeeded', {
           subscriptionId: subscription.id,
           setupIntentId: setupIntent.id,

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

@@ -70,19 +70,13 @@ export async function handleSubscriptionEvent(event: TEventExpanded, _: Stripe)
       return;
     }
 
-    const fields = [
-      'cancel_at',
-      'cancel_at_period_end',
-      'canceled_at',
-      'current_period_start',
-      'current_period_end',
-      'trial_end',
-    ];
+    const fields = ['cancel_at', 'cancel_at_period_end', 'canceled_at', 'current_period_start', 'current_period_end'];
     if (subscription.payment_settings?.payment_method_types?.includes('stripe')) {
       fields.push('pause_collection');
     }
     if (subscription.status === 'trialing' && event.data.object.status === 'active') {
       fields.push('status');
+      fields.push('trial_end');
     }
 
     await finalizeStripeSubscriptionUpdate({

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

@@ -289,18 +289,7 @@ export async function ensureStripeSubscription(
         }
       })
     );
-
-    await internal.update({
-      payment_details: {
-        stripe: {
-          customer_id: customer.id,
-          subscription_id: stripeSubscription.id,
-          setup_intent_id: stripeSubscription.pending_setup_intent?.id,
-        },
-      },
-    });
   }
-
   return stripeSubscription;
 }
 

package/api/src/libs/invoice.ts

@@ -3,20 +3,25 @@ import type { LiteralUnion } from 'type-fest';
 import { withQuery } from 'ufo';
 
 import { fromUnitToToken } from '@ocap/util';
+import { Op } from 'sequelize';
+import { cloneDeep, pick } from 'lodash';
 import {
+  Customer,
   Invoice,
   InvoiceItem,
   PaymentCurrency,
   PaymentMethod,
   Price,
   Product,
+  Refund,
+  SetupIntent,
   Subscription,
   SubscriptionItem,
   UsageRecord,
 } from '../store/models';
 import { getConnectQueryParam } from './util';
 import { expandLineItems } from './session';
-import { getSubscriptionCycleAmount, getSubscriptionCycleSetup } from './subscription';
+import { getSubscriptionCycleAmount, getSubscriptionCycleSetup, getSubscriptionStakeAmountSetup } from './subscription';
 
 export function getCustomerInvoicePageUrl({
   invoiceId,
@@ -144,3 +149,199 @@ export async function getInvoiceShouldPayTotal(invoice: Invoice) {
     return invoice.total;
   }
 }
+
+export async function getReturnStakeInvoices(subscription: Subscription) {
+  const method = await PaymentMethod.findOne({ where: { type: 'arcblock', livemode: subscription.livemode } });
+  const returnStakeInvoice: Invoice[] = [];
+  const refunds = await Refund.findAll({
+    where: { subscription_id: subscription.id, status: 'succeeded', type: 'stake_return' },
+    include: [
+      { model: Invoice, as: 'invoice' },
+      { model: Customer, as: 'customer' },
+      { model: PaymentCurrency, as: 'paymentCurrency' },
+    ],
+  });
+
+  await Promise.all(
+    refunds.map(async (r: any) => {
+      const invoice =
+        r.invoice ||
+        (await Invoice.findOne({
+          where: {
+            subscription_id: subscription.id,
+            currency_id: r.currency_id,
+          },
+          order: [['created_at', 'ASC']],
+        }));
+      returnStakeInvoice.push({
+        id: r.id,
+        status: 'paid',
+        billing_reason: 'return_stake',
+        description: 'Return Subscription staking',
+        total: r.amount,
+        amount_due: '0',
+        amount_paid: r.amount,
+        amount_remaining: '0',
+        subscription_id: subscription.id,
+        paid: true,
+        ...pick(invoice, ['number', 'auto_advance', 'period_start', 'period_end']),
+        ...pick(r, ['created_at', 'updated_at', 'currency_id', 'customer_id']),
+        // @ts-ignore
+        paymentCurrency: r.paymentCurrency,
+        paymentMethod: method,
+        customer: r.customer,
+        metadata: {
+          payment_details: {
+            arcblock: {
+              tx_hash: r?.payment_details?.arcblock?.tx_hash,
+              payer: r?.payment_details?.arcblock?.payer,
+            },
+          },
+        },
+      });
+    })
+  );
+  return returnStakeInvoice;
+}
+
+export async function getSetupInvoice(
+  subscription: Subscription,
+  paymentMethod: PaymentMethod,
+  currencyId: string,
+  stakingProps: { tx_hash: string; payer: string; address: string }
+) {
+  const currency = await PaymentCurrency.findByPk(currencyId);
+  if (!currency) {
+    return null;
+  }
+  if (!stakingProps?.tx_hash) {
+    return null;
+  }
+  if (paymentMethod.type !== 'arcblock') {
+    return null;
+  }
+  const firstInvoice = await Invoice.findOne({
+    where: { subscription_id: subscription.id, currency_id: currency.id },
+    order: [['created_at', 'ASC']],
+    include: [{ model: Customer, as: 'customer' }],
+  });
+  if (!firstInvoice) {
+    return null;
+  }
+  const stakeAmountResult = await getSubscriptionStakeAmountSetup(subscription, paymentMethod, stakingProps.tx_hash);
+  // @ts-ignore
+  const stakeAmount = stakeAmountResult?.[currency?.contract] || '0';
+  return {
+    id: stakingProps.address as string,
+    status: 'paid',
+    description: 'Subscription staking',
+    billing_reason: 'stake',
+    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,
+    // @ts-ignore
+    customer: firstInvoice?.customer,
+    metadata: {
+      payment_details: {
+        arcblock: {
+          tx_hash: stakingProps?.tx_hash,
+          payer: stakingProps?.payer,
+        },
+      },
+    },
+  };
+}
+
+export async function getStakingInvoices(subscription: Subscription): Promise<Invoice[]> {
+  const method = await PaymentMethod.findOne({ where: { type: 'arcblock', livemode: subscription.livemode } });
+  if (!method) {
+    return [];
+  }
+  const stakeInvoices = await Invoice.findAll({
+    where: { subscription_id: subscription.id, billing_reason: 'stake', status: 'paid' },
+    include: [
+      { model: Customer, as: 'customer' },
+      { model: PaymentCurrency, as: 'paymentCurrency' },
+      { model: PaymentMethod, as: 'paymentMethod' },
+    ],
+  });
+  const invoices = cloneDeep(stakeInvoices);
+  const setups = await SetupIntent.findAll({
+    where: {
+      customer_id: subscription.customer_id,
+      payment_method_id: method?.id,
+      status: 'succeeded',
+      [Op.and]: [
+        { metadata: { [Op.not]: null } },
+        { 'metadata.subscription_id': subscription.id },
+        { setup_details: { [Op.not]: null } },
+        { 'setup_details.arcblock': { [Op.not]: null } },
+        { 'setup_details.arcblock.staking': { [Op.not]: null } },
+      ] as any,
+    },
+  });
+  if (setups.length === 0) {
+    // No payment change, use the first invoice
+    if (stakeInvoices.length > 0) {
+      return stakeInvoices;
+    }
+    const newInvoice = await getSetupInvoice(subscription, method, subscription.currency_id, {
+      tx_hash: subscription.payment_details?.arcblock?.staking?.tx_hash!,
+      payer: subscription.payment_details?.arcblock?.payer!,
+      address: subscription.payment_details?.arcblock?.staking?.address!,
+    });
+    // @ts-ignore
+    return [newInvoice].filter(Boolean);
+  }
+
+  await Promise.all(
+    setups.map(async (setup: SetupIntent, index: number) => {
+      if (
+        index === 0 &&
+        setup.metadata?.from_currency &&
+        !stakeInvoices.find((x) => x.currency_id === setup?.metadata?.from_currency)
+      ) {
+        const paymentDetails =
+          setup?.metadata?.from_payment_details?.arcblock || subscription.payment_details?.arcblock;
+        const fromMethod = await PaymentMethod.findByPk(setup?.metadata?.from_payment_method_id);
+        const newInvoice = await getSetupInvoice(subscription, fromMethod!, setup.metadata?.from_currency, {
+          tx_hash: paymentDetails?.staking?.tx_hash!,
+          payer: paymentDetails?.payer!,
+          address: paymentDetails?.staking?.address!,
+        });
+        if (newInvoice) {
+          // @ts-ignore
+          invoices.push(newInvoice);
+        }
+      }
+      if (setup.metadata?.to_currency && !stakeInvoices.find((x) => x.currency_id === setup?.metadata?.to_currency)) {
+        const newInvoice = await getSetupInvoice(subscription, method, setup.metadata?.to_currency, {
+          tx_hash: setup.setup_details?.arcblock?.staking?.tx_hash!,
+          payer: setup.setup_details?.arcblock?.payer!,
+          address: setup.setup_details?.arcblock?.staking?.address!,
+        });
+        if (newInvoice) {
+          // @ts-ignore
+          invoices.push(newInvoice);
+        }
+      }
+    })
+  );
+  return invoices;
+}

package/api/src/libs/notification/template/subscription-canceled.ts

@@ -56,7 +56,15 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
       throw new Error(`Customer(${subscription.customer_id}) not found`);
     }
 
-    const invoice = (await Invoice.findByPk(subscription.latest_invoice_id)) as Invoice;
+    const invoice = await Invoice.findOne({
+      where: {
+        id: subscription.latest_invoice_id,
+      },
+      include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
+    });
+    if (!invoice) {
+      throw new Error(`Invoice(${subscription.latest_invoice_id}) not found`);
+    }
     const paymentCurrency = (await PaymentCurrency.findOne({
       where: {
         id: subscription.currency_id,
@@ -68,7 +76,8 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
     const productName = await getMainProductName(subscription.id);
     const at: string = formatTime(subscription.canceled_at * 1000);
 
-    const paymentInfo: string = `${fromUnitToToken(invoice.total, paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
+    // @ts-ignore
+    const paymentInfo: string = `${fromUnitToToken(invoice.total, invoice?.paymentCurrency?.decimal)} ${invoice?.paymentCurrency?.symbol}`;
     const currentPeriodStart: string = formatTime(invoice.period_start * 1000);
     const currentPeriodEnd: string = formatTime(invoice.period_end * 1000);
     const duration: string = prettyMsI18n(

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

@@ -91,7 +91,7 @@ export class SubscriptionRenewFailedEmailTemplate
     const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
     const paymentCurrency = (await PaymentCurrency.findOne({
       where: {
-        id: subscription.currency_id,
+        id: invoice.currency_id,
       },
     })) as PaymentCurrency;
 

package/api/src/libs/notification/template/subscription-renewed.ts

@@ -82,7 +82,7 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
     const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
     const paymentCurrency = (await PaymentCurrency.findOne({
       where: {
-        id: subscription.currency_id,
+        id: invoice.currency_id,
       },
     })) as PaymentCurrency;
 

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

@@ -4,7 +4,7 @@ import { fromUnitToToken } from '@ocap/util';
 import type { ManipulateType } from 'dayjs';
 import prettyMsI18n from 'pretty-ms-i18n';
 
-import { getTokenSummaryByDid } from '../../../integrations/arcblock/stake';
+import { getTokenByAddress } from '../../../integrations/arcblock/stake';
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
 import { Customer, PaymentMethod, Subscription, PaymentCurrency } from '../../../store/models';
@@ -76,6 +76,10 @@ export class SubscriptionTrialWilEndEmailTemplate
 
     const paymentMethod: PaymentMethod | null = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
 
+    if (!paymentMethod) {
+      throw new Error(`Payment method not found: ${paymentCurrency.payment_method_id}`);
+    }
+
     const userDid = customer.did;
     const locale = await getUserLocale(userDid);
     const productName = await getMainProductName(subscription.id);
@@ -86,14 +90,14 @@ export class SubscriptionTrialWilEndEmailTemplate
     const at: string = formatTime((subscription.trial_end as number) * 1000);
 
     const willEndDuration: string = getSimplifyDuration((subscription.trial_end! - dayjs().unix()) * 1000, locale);
-    // const paymentDetail: PaymentDetail = await getPaymentDetail(userDid, invoice);
 
     const paymentAmount = await getPaymentAmountForCycleSubscription(subscription, paymentCurrency);
     const paymentDetail = { price: paymentAmount, balance: 0, symbol: paymentCurrency.symbol };
+    // @ts-ignore
+    const paymentAddress = subscription.payment_details?.[paymentMethod.type]?.payer ?? undefined;
+    const balance = await getTokenByAddress(paymentAddress, paymentMethod, paymentCurrency);
+    paymentDetail.balance = +fromUnitToToken(balance, paymentCurrency.decimal);
 
-    const token = await getTokenSummaryByDid(userDid, customer.livemode);
-
-    paymentDetail.balance = +fromUnitToToken(token?.[paymentCurrency.id] || '0', paymentCurrency.decimal);
     const paymentInfo: string = `${paymentAmount} ${paymentCurrency.symbol}`;
     const currentPeriodStart: string = formatTime((subscription.trial_start as number) * 1000);
     const currentPeriodEnd: string = formatTime((subscription.trial_end as number) * 1000);

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

@@ -78,19 +78,23 @@ export class SubscriptionWillCanceledEmailTemplate
       throw new Error(`Customer not found: ${subscription.customer_id}`);
     }
 
-    const invoice = (await Invoice.findByPk(subscription.latest_invoice_id)) as Invoice;
-    const paymentCurrency = (await PaymentCurrency.findOne({
+    const invoice = await Invoice.findOne({
       where: {
-        id: subscription.currency_id,
+        id: subscription.latest_invoice_id,
       },
-    })) as PaymentCurrency;
+      include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
+    });
+    if (!invoice) {
+      throw new Error(`Invoice(${subscription.latest_invoice_id}) not found`);
+    }
 
     const userDid = customer.did;
     const locale = await getUserLocale(userDid);
     const productName = await getMainProductName(subscription.id);
     const at: string = formatTime(cancelAt * 1000);
     const willCancelDuration: string = getSimplifyDuration((cancelAt - now) * 1000, locale);
-    const paymentInfo: string = `${fromUnitToToken(+invoice.total, paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
+    // @ts-ignore
+    const paymentInfo: string = `${fromUnitToToken(+invoice.total, invoice?.paymentCurrency?.decimal)} ${invoice?.paymentCurrency?.symbol}`;
 
     let body: string = translate('notification.subscriptWillCanceled.body', locale, {
       productName,

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

@@ -6,7 +6,7 @@ import type { LiteralUnion } from 'type-fest';
 
 import { fromUnitToToken } from '@ocap/util';
 import dayjs from '../../dayjs';
-import { getTokenSummaryByDid } from '../../../integrations/arcblock/stake';
+import { getTokenByAddress } from '../../../integrations/arcblock/stake';
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
 import {
@@ -93,19 +93,19 @@ export class SubscriptionWillRenewEmailTemplate
     const productName = await getMainProductName(subscription.id);
     const at: string = formatTime(invoice.period_end * 1000);
     const willRenewDuration = getSimplifyDuration((invoice.period_end - dayjs().unix()) * 1000, locale);
-    // const upcomingInvoiceAmount = await getUpcomingInvoiceAmount(subscription.id);
-    // const amount: string = fromUnitToToken(+upcomingInvoiceAmount.amount, upcomingInvoiceAmount.currency?.decimal);
-    // const paymentDetail: PaymentDetail = await getPaymentDetail(userDid, invoice, amount);
-    // paymentDetail.price = +amount;
 
     const paymentAmount = await getPaymentAmountForCycleSubscription(subscription, paymentCurrency);
     const paymentDetail = { price: paymentAmount, balance: 0, symbol: paymentCurrency.symbol, balanceFormatted: '0' };
 
-    const token = await getTokenSummaryByDid(userDid, customer.livemode);
-
-    const balance = fromUnitToToken(token?.[paymentCurrency.id] || '0', paymentCurrency.decimal);
-    paymentDetail.balanceFormatted = balance;
-    paymentDetail.balance = +balance;
+    const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+    if (!paymentMethod) {
+      throw new Error(`Payment method not found: ${paymentCurrency.payment_method_id}`);
+    }
+    // @ts-ignore
+    const paymentAddress = subscription.payment_details?.[paymentMethod.type]?.payer ?? undefined;
+    const balance = await getTokenByAddress(paymentAddress, paymentMethod, paymentCurrency);
+    paymentDetail.balanceFormatted = fromUnitToToken(balance, paymentCurrency.decimal);
+    paymentDetail.balance = +paymentDetail.balanceFormatted;
 
     const { isPrePaid, interval } = await this.getPaymentCategory({
       subscriptionId: subscription.id,
@@ -132,8 +132,6 @@ export class SubscriptionWillRenewEmailTemplate
       locale,
       userDid,
     });
-    const paymentMethod: PaymentMethod | null = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
-
     const addFundsLink: string = getCustomerRechargeLink({
       locale,
       userDid,

package/api/src/libs/payment.ts

@@ -211,13 +211,14 @@ export async function getPaymentDetail(
   if (!paymentMethod) {
     return defaultResult;
   }
-
+  const paymentSettings = invoice?.payment_settings;
   if (['arcblock', 'ethereum'].includes(paymentMethod.type)) {
     // balance enough token for payment?
+    const payer = paymentSettings?.payment_method_options.arcblock?.payer as string;
     const result = await isDelegationSufficientForPayment({
       paymentMethod,
       paymentCurrency,
-      userDid,
+      userDid: payer || userDid,
       amount: inputAmount,
     });
 

package/api/src/libs/subscription.ts

@@ -321,7 +321,7 @@ export async function createProration(
   const prorations = await Promise.all(
     prorationItems.map((x: TLineItemExpanded & { [key: string]: any }) => {
       const price = getSubscriptionItemPrice(x);
-      const unitAmount = getPriceUintAmountByCurrency(price, subscription.currency_id);
+      const unitAmount = getPriceUintAmountByCurrency(price, lastInvoice.currency_id);
       const amount = new BN(unitAmount)
         .mul(new BN(x.quantity))
         .mul(new BN(prorationRate))
@@ -402,10 +402,10 @@ export async function createProration(
   };
 }
 
-export async function getSubscriptionRefundSetup(subscription: Subscription, anchor: number) {
+export async function getSubscriptionRefundSetup(subscription: Subscription, anchor: number, currencyId?: string) {
   const items = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
   const expanded = await Price.expand(items.map((x) => x.toJSON()));
-  const setup = getSubscriptionCreateSetup(expanded, subscription.currency_id, 0);
+  const setup = getSubscriptionCreateSetup(expanded, currencyId || subscription.currency_id, 0);
   return createProration(subscription, setup, anchor);
 }
 
@@ -452,7 +452,7 @@ export async function getUpcomingInvoiceAmount(subscriptionId: string) {
     throw new Error('Subscription not found');
   }
 
-  if (subscription.isActive() === false) {
+  if (subscription.isActive() === false && subscription.status !== 'past_due') {
     throw new Error(`Subscription not active for ${subscriptionId}, so usage check is skipped`);
   }
 
@@ -726,10 +726,17 @@ export async function getRemainingStakes(subscriptionIds: string[], subscription
 export async function getSubscriptionStakeSlashSetup(
   subscription: Subscription,
   address: string,
-  paymentMethod: PaymentMethod
+  paymentMethod: PaymentMethod,
+  paymentCurrencyId?: string
 ) {
   const lastInvoice = await Invoice.findByPk(subscription.latest_invoice_id);
-  const result = await getSubscriptionRemainingStakeSetup(subscription, address, paymentMethod, 'slash');
+  const result = await getSubscriptionRemainingStakeSetup(
+    subscription,
+    address,
+    paymentMethod,
+    'slash',
+    paymentCurrencyId
+  );
   return {
     ...result,
     lastInvoice,
@@ -739,10 +746,17 @@ export async function getSubscriptionStakeSlashSetup(
 export async function getSubscriptionStakeReturnSetup(
   subscription: Subscription,
   address: string,
-  paymentMethod: PaymentMethod
+  paymentMethod: PaymentMethod,
+  paymentCurrencyId?: string
 ) {
   const lastInvoice = await Invoice.findByPk(subscription.latest_invoice_id);
-  const result = await getSubscriptionRemainingStakeSetup(subscription, address, paymentMethod, 'return');
+  const result = await getSubscriptionRemainingStakeSetup(
+    subscription,
+    address,
+    paymentMethod,
+    'return',
+    paymentCurrencyId
+  );
   return {
     ...result,
     lastInvoice,
@@ -753,9 +767,10 @@ export async function getSubscriptionRemainingStakeSetup(
   subscription: Subscription,
   address: string,
   paymentMethod: PaymentMethod,
-  action: 'return' | 'slash' = 'return'
+  action: 'return' | 'slash' = 'return',
+  paymentCurrencyId?: string
 ) {
-  const currency = await PaymentCurrency.findByPk(subscription.currency_id);
+  const currency = await PaymentCurrency.findByPk(paymentCurrencyId || subscription.currency_id);
   if (!currency) {
     return {
       total: '0',
@@ -782,12 +797,12 @@ export async function getSubscriptionRemainingStakeSetup(
   }
   const [summary] = await Invoice.getUncollectibleAmount({
     subscriptionId: subscription.id,
-    currencyId: subscription.currency_id,
+    currencyId: currency.id,
     customerId: subscription.customer_id,
   });
   const subscriptionInitStakes = JSON.parse(state.data?.value || '{}');
   const initStake = subscriptionInitStakes[subscription.id];
-  const uncollectibleAmountBN = new BN(summary?.[subscription.currency_id] || '0');
+  const uncollectibleAmountBN = new BN(summary?.[currency.id] || '0');
   if (state.nonce) {
     const returnStake = total.sub(uncollectibleAmountBN);
     return {
@@ -909,11 +924,15 @@ export async function getSubscriptionStakeCancellation(
   return cancellation;
 }
 
-export async function getSubscriptionStakeAmountSetup(subscription: Subscription, paymentMethod: PaymentMethod) {
+export async function getSubscriptionStakeAmountSetup(
+  subscription: Subscription,
+  paymentMethod: PaymentMethod,
+  stakingTxHash?: string
+) {
   if (paymentMethod.type !== 'arcblock') {
     return null;
   }
-  const txHash = subscription?.payment_details?.arcblock?.staking?.tx_hash;
+  const txHash = stakingTxHash || subscription?.payment_details?.arcblock?.staking?.tx_hash;
   if (!txHash) {
     return null;
   }

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 ', {