payment-kit 1.15.33 → 1.15.35

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

@@ -3,6 +3,7 @@
 import { fromUnitToToken } from '@ocap/util';
 import prettyMsI18n from 'pretty-ms-i18n';
 
+import { Op } from 'sequelize';
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
 import { Customer, PaymentMethod, Refund, Subscription } from '../../../store/models';
@@ -56,7 +57,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 +77,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(
@@ -98,6 +108,9 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
         where: {
           subscription_id: subscription.id,
           type: 'refund',
+          status: {
+            [Op.not]: 'canceled',
+          },
         },
       });
       const conditions = [

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/refund.ts

@@ -1,6 +1,7 @@
 import { BN } from '@ocap/util';
 import { Op, type WhereOptions } from 'sequelize';
 import { PaymentIntent, Refund } from '../store/models';
+import logger from './logger';
 
 export async function getRefundAmountSetup({
   currencyId,
@@ -45,6 +46,9 @@ export async function getRefundAmountSetup({
     include: [],
   });
   if (count === 0) {
+    logger.info('No refund found for payment intent', {
+      paymentIntentId,
+    });
     return {
       amount: paymentIntent.amount_received,
       totalAmount: paymentIntent.amount_received,

package/api/src/libs/subscription.ts

@@ -313,6 +313,8 @@ export async function createProration(
       prorations: [],
       newCredit: '0',
       appliedCredit: '0',
+      remaining: '0',
+      remainingUnused: '0',
     };
   }
 
@@ -321,7 +323,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))
@@ -363,6 +365,25 @@ export async function createProration(
 
   // 5. adjust invoice total && update customer token balance
   const total = setup.amount.setup;
+
+  // 6. calculate remaining amount
+  const refunds = await Refund.findAll({
+    where: {
+      status: { [Op.not]: 'canceled' },
+      subscription_id: subscription.id,
+      currency_id: lastInvoice?.currency_id,
+      invoice_id: lastInvoice?.id,
+    },
+  });
+  const refundAmount = refunds.reduce((acc, x) => acc.add(new BN(x.amount || '0')), new BN(0));
+
+  // 7. calculate remaining amount, default refund recurring amount
+  const calcRemaining = (amount: BN, subtract: BN) =>
+    amount.sub(subtract).lt(new BN(0)) ? '0' : amount.sub(subtract).toString();
+
+  const remaining = calcRemaining(new BN(total), refundAmount);
+  const remainingUnused = calcRemaining(unused, refundAmount);
+
   let due = setup.amount.setup;
   let newCredit = '0';
   let appliedCredit = '0';
@@ -384,6 +405,8 @@ export async function createProration(
     prorationEnd,
     prorationRate,
     unused: unused.toString(),
+    remaining,
+    remainingUnused,
     total,
     due,
     newCredit,
@@ -394,6 +417,8 @@ export async function createProration(
     lastInvoice,
     total,
     due,
+    remaining,
+    remainingUnused,
     used: new BN(lastInvoice.amount_due).sub(unused).toString(),
     unused: unused.toString(),
     prorations,
@@ -402,10 +427,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 +477,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 +751,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 +771,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 +792,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 +822,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 +949,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;
   }