payment-kit 1.21.16 → 1.22.0

package/api/src/index.ts

@@ -2,7 +2,7 @@ import 'express-async-errors';
 
 import path from 'path';
 
-import fallback from '@blocklet/sdk/lib/middlewares/fallback';
+import { fallback } from '@blocklet/sdk/lib/middlewares/fallback';
 import cookieParser from 'cookie-parser';
 import cors from 'cors';
 import dotenv from 'dotenv-flow';
@@ -53,6 +53,7 @@ import rechargeHandlers from './routes/connect/recharge';
 import rechargeAccountHandlers from './routes/connect/recharge-account';
 import setupHandlers from './routes/connect/setup';
 import subscribeHandlers from './routes/connect/subscribe';
+import changePayerHandlers from './routes/connect/change-payer';
 import { initialize } from './store/models';
 import { sequelize } from './store/sequelize';
 
@@ -92,6 +93,7 @@ handlers.attach(Object.assign({ app: router }, delegationHandlers));
 handlers.attach(Object.assign({ app: router }, overdraftProtectionHandlers));
 handlers.attach(Object.assign({ app: router }, reStakeHandlers));
 handlers.attach(Object.assign({ app: router }, autoRechargeAuthorizationHandlers));
+handlers.attach(Object.assign({ app: router }, changePayerHandlers));
 router.use('/api', routes);
 
 const isProduction = process.env.BLOCKLET_MODE === 'production';

package/api/src/integrations/blocklet/user.ts

@@ -32,6 +32,6 @@ const handleUserUpdate = async ({ user }: { user: any }) => {
   }
 };
 
-export function initUserHandler() {
-  notification.on('user.updated', handleUserUpdate);
+export async function initUserHandler() {
+  await notification.on('user.updated', handleUserUpdate);
 }

package/api/src/integrations/ethereum/token.ts

@@ -1,6 +1,7 @@
 import { JsonRpcProvider, TransactionReceipt, ethers } from 'ethers';
 
 import { ethWallet } from '../../libs/auth';
+import { RemoteSigner } from '../../libs/remote-signer';
 import { getApproveFunction } from './contract';
 import erc20Abi from './erc20-abi.json';
 
@@ -92,12 +93,11 @@ export async function transferErc20FromUser(
   user: string,
   amount: string
 ): Promise<TransactionReceipt> {
-  const wallet = new ethers.Wallet(ethWallet.secretKey);
-  const signer = wallet.connect(provider);
+  const signer = new RemoteSigner(ethWallet, provider);
   const contract = new ethers.Contract(contractAddress, erc20Abi, signer);
 
   // @ts-ignore
-  const res = await contract.transferFrom(user, wallet.address, amount);
+  const res = await contract.transferFrom(user, ethWallet.address, amount);
 
   // Wait for the transaction to be mined
   const receipt = await res.wait();
@@ -111,8 +111,7 @@ export async function sendErc20ToUser(
   user: string,
   amount: string
 ): Promise<TransactionReceipt> {
-  const wallet = new ethers.Wallet(ethWallet.secretKey);
-  const signer = wallet.connect(provider);
+  const signer = new RemoteSigner(ethWallet, provider);
   const contract = new ethers.Contract(contractAddress, erc20Abi, signer);
 
   // @ts-ignore

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

@@ -1,4 +1,4 @@
-import env from '@blocklet/sdk/lib/env';
+import { env } from '@blocklet/sdk/lib/env';
 import merge from 'lodash/merge';
 import pick from 'lodash/pick';
 import pWaitFor from 'p-wait-for';
@@ -91,7 +91,7 @@ export function getStripeInvoicePeriod(invoice: any) {
   };
 }
 
-export async function syncStripeInvoice(invoice: Invoice) {
+export async function syncStripeInvoice(invoice: Invoice, sync = true) {
   if (!invoice.metadata?.stripe_id) {
     return;
   }
@@ -103,6 +103,28 @@ export async function syncStripeInvoice(invoice: Invoice) {
 
   const client = await method.getStripeClient();
   const stripeInvoice = await client.invoices.retrieve(invoice.metadata.stripe_id);
+  const updates = [
+    'amount_due',
+    'amount_paid',
+    'amount_remaining',
+    'last_finalization_error',
+    'paid_out_of_band',
+    'paid',
+    'status',
+    'status_transitions',
+    'subtotal_excluding_tax',
+    'subtotal',
+    'tax',
+    'total_discount_amounts',
+    'total',
+  ];
+  if (!sync && stripeInvoice.status !== 'paid' && invoice.status === 'uncollectible') {
+    // remove status from updates
+    const statusIndex = updates.indexOf('status');
+    if (statusIndex !== -1) {
+      updates.splice(statusIndex, 1);
+    }
+  }
   if (stripeInvoice) {
     const processDiscounts = await processInvoiceDiscounts(
       stripeInvoice,
@@ -111,27 +133,9 @@ export async function syncStripeInvoice(invoice: Invoice) {
     );
     await invoice.update(
       // @ts-ignore
-      merge(
-        pick(stripeInvoice, [
-          'amount_due',
-          'amount_paid',
-          'amount_remaining',
-          'last_finalization_error',
-          'paid_out_of_band',
-          'paid',
-          'status_transitions',
-          'status',
-          'subtotal_excluding_tax',
-          'subtotal',
-          'tax',
-          'total_discount_amounts',
-          'total',
-        ]),
-        getStripeInvoicePeriod(stripeInvoice),
-        {
-          total_discount_amounts: processDiscounts,
-        }
-      )
+      merge(pick(stripeInvoice, updates), getStripeInvoicePeriod(stripeInvoice), {
+        total_discount_amounts: processDiscounts,
+      })
     );
     logger.info('stripe invoice synced', { locale: invoice.id, remote: stripeInvoice.id });
     const failedStatuses = ['uncollectible', 'finalization_failed', 'payment_failed'];
@@ -416,7 +420,8 @@ export async function handleInvoiceEvent(event: TEventExpanded, client: Stripe)
   }
 
   if (event.type === 'invoice.finalized') {
-    await invoice.update({ status: 'finalized', status_transitions: event.data.object.status_transitions });
+    // invoice from draft to open
+    await invoice.update({ status: 'open', status_transitions: event.data.object.status_transitions });
     logger.info('invoice finalized on stripe event', { locale: invoice.id });
     return;
   }
@@ -442,14 +447,14 @@ export async function handleInvoiceEvent(event: TEventExpanded, client: Stripe)
 
   if (event.type === 'invoice.finalization_failed') {
     await invoice.update({
-      status: 'finalization_failed',
+      status: 'uncollectible',
       last_finalization_error: event.data.object.last_finalization_error,
     });
     logger.info('invoice finalization failed on stripe event', { locale: invoice.id });
   }
 
   if (event.type === 'invoice.payment_failed') {
-    await invoice.update({ status: 'payment_failed' });
+    await invoice.update({ status: 'uncollectible' });
     logger.info('invoice payment failed on stripe event', { locale: invoice.id });
   }
 

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

@@ -1,4 +1,4 @@
-import env from '@blocklet/sdk/lib/env';
+import { env } from '@blocklet/sdk/lib/env';
 import merge from 'lodash/merge';
 import pick from 'lodash/pick';
 import pWaitFor from 'p-wait-for';

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

@@ -1,10 +1,15 @@
 import type Stripe from 'stripe';
+import { Op } from 'sequelize';
 
 import logger from '../../../libs/logger';
 import {
   AutoRechargeConfig,
   CheckoutSession,
+  Customer,
+  Invoice,
   Lock,
+  PaymentCurrency,
+  PaymentMethod,
   SetupIntent,
   Subscription,
   TEventExpanded,
@@ -150,6 +155,230 @@ async function handleAutoRechargeOnSetupSucceeded(event: TEventExpanded, stripeI
   }
 }
 
+async function handleUpdateStripePaymentMethodOnSetupSucceeded(event: TEventExpanded, stripeIntentId: string) {
+  const { metadata } = event.data.object;
+
+  if (metadata?.action !== 'update_payment_method' || !metadata?.subscription_id) {
+    return;
+  }
+
+  if (event.type !== 'setup_intent.succeeded') {
+    return;
+  }
+
+  const subscription = await Subscription.findByPk(metadata.subscription_id);
+  if (!subscription) {
+    logger.warn('subscription not found for update payment method', {
+      id: event.id,
+      stripeIntentId,
+      subscriptionId: metadata.subscription_id,
+    });
+    return;
+  }
+
+  const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+  if (!paymentMethod || paymentMethod.type !== 'stripe') {
+    logger.warn('stripe payment method not found for subscription', {
+      id: event.id,
+      stripeIntentId,
+      subscriptionId: subscription.id,
+    });
+    return;
+  }
+
+  const stripeSubscriptionId = subscription.payment_details?.stripe?.subscription_id;
+  if (!stripeSubscriptionId) {
+    logger.warn('stripe subscription id not found', {
+      id: event.id,
+      stripeIntentId,
+      subscriptionId: subscription.id,
+    });
+    return;
+  }
+
+  const client = paymentMethod.getStripeClient();
+  const stripePaymentMethodId = event.data.object.payment_method as string;
+
+  await client.subscriptions.update(stripeSubscriptionId, {
+    default_payment_method: stripePaymentMethodId,
+  });
+
+  logger.info('stripe payment method updated via webhook', {
+    subscriptionId: subscription.id,
+    stripeIntentId,
+    paymentMethod: stripePaymentMethodId,
+  });
+}
+
+async function handleBatchOverduePaymentOnSetupSucceeded(event: TEventExpanded, stripeIntentId: string) {
+  const { metadata } = event.data.object;
+
+  if (metadata?.action !== 'pay_overdue_batch' || !metadata?.currency_id) {
+    return;
+  }
+
+  if (event.type !== 'setup_intent.succeeded') {
+    return;
+  }
+
+  const paymentCurrency = await PaymentCurrency.findByPk(metadata.currency_id);
+  if (!paymentCurrency) {
+    logger.warn('payment currency not found for batch overdue payment', {
+      id: event.id,
+      stripeIntentId,
+      currencyId: metadata.currency_id,
+    });
+    return;
+  }
+
+  const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+  if (!paymentMethod || paymentMethod.type !== 'stripe') {
+    logger.warn('stripe payment method not found or invalid type', {
+      id: event.id,
+      stripeIntentId,
+      currencyId: metadata.currency_id,
+      paymentMethodType: paymentMethod?.type,
+    });
+    return;
+  }
+
+  let invoices: Invoice[];
+
+  if (metadata.invoices) {
+    let invoiceIds: string[];
+    try {
+      invoiceIds = JSON.parse(metadata.invoices);
+    } catch (err) {
+      logger.error('failed to parse invoices from setup intent metadata', {
+        id: event.id,
+        stripeIntentId,
+        metadata,
+      });
+      return;
+    }
+
+    invoices = await Invoice.findAll({
+      where: {
+        id: { [Op.in]: invoiceIds },
+        currency_id: metadata.currency_id,
+      },
+    });
+
+    const subscriptionIds = [...new Set(invoices.map((inv) => inv.subscription_id).filter(Boolean) as string[])];
+
+    if (subscriptionIds.length > 0) {
+      const additionalInvoices = await Invoice.findAll({
+        where: {
+          subscription_id: { [Op.in]: subscriptionIds },
+          currency_id: metadata.currency_id,
+          status: { [Op.in]: ['open', 'uncollectible'] },
+          id: { [Op.notIn]: invoiceIds },
+        },
+      });
+
+      invoices = [...invoices, ...additionalInvoices];
+
+      logger.info('found additional overdue invoices for subscriptions', {
+        stripeIntentId,
+        subscriptionIds,
+        originalCount: invoiceIds.length,
+        additionalCount: additionalInvoices.length,
+        totalCount: invoices.length,
+      });
+    }
+  } else if (metadata.subscription_id) {
+    invoices = await Invoice.findAll({
+      where: {
+        subscription_id: metadata.subscription_id,
+        currency_id: metadata.currency_id,
+        status: { [Op.in]: ['open', 'uncollectible'] },
+      },
+    });
+  } else if (metadata.customer_id) {
+    const customer = await Customer.findByPkOrDid(metadata.customer_id);
+    if (!customer) {
+      logger.warn('customer not found for batch overdue payment', {
+        id: event.id,
+        stripeIntentId,
+        customerId: metadata.customer_id,
+      });
+      return;
+    }
+
+    invoices = await Invoice.findAll({
+      where: {
+        customer_id: customer.id,
+        currency_id: metadata.currency_id,
+        status: { [Op.in]: ['open', 'uncollectible'] },
+      },
+    });
+  } else {
+    logger.error('invalid metadata for batch overdue payment, must provide invoices, subscription_id or customer_id', {
+      id: event.id,
+      stripeIntentId,
+      metadata,
+    });
+    return;
+  }
+
+  if (invoices.length === 0) {
+    logger.warn('no invoices found for batch overdue payment', {
+      id: event.id,
+      stripeIntentId,
+      metadata,
+    });
+    return;
+  }
+
+  const validInvoices = invoices.filter((inv) => inv.metadata?.stripe_id);
+  if (validInvoices.length === 0) {
+    logger.warn('no valid stripe invoices found for batch overdue payment', {
+      id: event.id,
+      stripeIntentId,
+      totalInvoices: invoices.length,
+    });
+    return;
+  }
+
+  const client = paymentMethod.getStripeClient();
+  const stripePaymentMethodId = event.data.object.payment_method as string;
+
+  const payResults = await Promise.all(
+    validInvoices.map(async (invoice) => {
+      try {
+        await client.invoices.pay(invoice.metadata!.stripe_id, {
+          payment_method: stripePaymentMethodId,
+        });
+
+        logger.info('stripe invoice payment initiated via webhook', {
+          invoiceId: invoice.id,
+          stripeInvoiceId: invoice.metadata!.stripe_id,
+          stripeIntentId,
+        });
+
+        return { invoiceId: invoice.id, success: true };
+      } catch (err) {
+        logger.error('failed to pay stripe invoice via webhook', {
+          invoiceId: invoice.id,
+          stripeInvoiceId: invoice.metadata!.stripe_id,
+          stripeIntentId,
+          error: err,
+        });
+        return { invoiceId: invoice.id, success: false, error: err.message };
+      }
+    })
+  );
+
+  logger.info('batch overdue payment completed via webhook', {
+    stripeIntentId,
+    currencyId: metadata.currency_id,
+    totalInvoices: invoices.length,
+    validInvoices: validInvoices.length,
+    succeeded: payResults.filter((r) => r.success).length,
+    failed: payResults.filter((r) => !r.success).length,
+  });
+}
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function handleSetupIntentEvent(event: TEventExpanded, _: Stripe) {
   const stripeIntentId = event.data.object.id;
@@ -159,4 +388,6 @@ export async function handleSetupIntentEvent(event: TEventExpanded, _: Stripe) {
   await handleSetupIntentOnSetupSucceeded(event, stripeIntentId);
   await handleCheckoutSessionOnSetupSucceeded(event, stripeIntentId);
   await handleAutoRechargeOnSetupSucceeded(event, stripeIntentId);
+  await handleUpdateStripePaymentMethodOnSetupSucceeded(event, stripeIntentId);
+  await handleBatchOverduePaymentOnSetupSucceeded(event, stripeIntentId);
 }

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

@@ -197,11 +197,25 @@ export async function handleSubscriptionOnPaymentFailure(
   eventType: string,
   client: Stripe
 ) {
-  if (!subscription || !subscription.isActive()) {
-    logger.warn('Subscription is not active or not found', { subscription: subscription.id });
+  if (!subscription || subscription.isImmutable()) {
+    logger.warn('Subscription is immutable or not found', { subscription: subscription.id });
     return;
   }
 
+  const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+  if (paymentMethod && paymentMethod.type !== 'stripe') {
+    logger.info('Subscription payment method is not stripe', {
+      subscription: subscription.id,
+      paymentMethod: paymentMethod?.type,
+    });
+    return;
+  }
+
+  logger.info('start handle stripe subscription on payment failure', {
+    subscription: subscription.id,
+    eventType,
+  });
+
   const now = dayjs().unix();
   const { interval } = subscription.pending_invoice_item_interval;
   const dueUnit = getDueUnit(interval);
@@ -256,13 +270,25 @@ export async function handleSubscriptionOnPaymentFailure(
   // sync to stripe
   if (subscription.payment_details?.stripe?.subscription_id && client) {
     try {
-      const method = await PaymentMethod.findByPk(subscription.default_payment_method_id);
-      if (method && method.type === 'stripe') {
+      if (paymentMethod && paymentMethod.type === 'stripe') {
+        if (cancelSubscription) {
+          await client.subscriptions.cancel(subscription.payment_details.stripe.subscription_id, {
+            cancellation_details: {
+              comment: 'exceed_current_period',
+              feedback: 'other',
+            },
+          });
+          logger.info('subscription in Stripe has canceled after payment failed', {
+            subscription: subscription.id,
+            stripeSubscription: subscription.payment_details.stripe.subscription_id,
+            eventType,
+          });
+          return;
+        }
         const stripeUpdates: any = {
           cancellation_details: {
             comment: 'past_due',
             feedback: 'other',
-            reason: 'payment_failed',
           },
         };
 
@@ -271,10 +297,6 @@ export async function handleSubscriptionOnPaymentFailure(
         } else if (cancelUpdates.cancel_at_period_end) {
           stripeUpdates.cancel_at_period_end = true;
         }
-        if (cancelSubscription) {
-          stripeUpdates.cancel_at = now;
-          stripeUpdates.cancel_at_period_end = false;
-        }
 
         await client.subscriptions.update(subscription.payment_details.stripe.subscription_id, stripeUpdates);
         logger.info(`[${eventType}] Updated subscription in Stripe after payment failed`, {

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

@@ -1,6 +1,6 @@
 /* eslint-disable no-continue */
 /* eslint-disable no-await-in-loop */
-import env from '@blocklet/sdk/lib/env';
+import { env } from '@blocklet/sdk/lib/env';
 import merge from 'lodash/merge';
 import omit from 'lodash/omit';
 import pick from 'lodash/pick';
@@ -855,6 +855,35 @@ export async function ensureStripeSetupIntentForAutoRecharge(
   return setupIntent;
 }
 
+export async function ensureStripeSetupIntentForInvoicePayment(
+  customer: Customer,
+  method: PaymentMethod,
+  metadata: Record<string, string>
+) {
+  const client = method.getStripeClient();
+  const stripeCustomer = await ensureStripeCustomer(customer, method);
+
+  const setupIntent = await client.setupIntents.create({
+    customer: stripeCustomer.id,
+    payment_method_types: ['card'],
+    usage: 'off_session',
+    metadata: {
+      appPid: env.appPid,
+      customer_id: customer.id,
+      action: 'pay_overdue_batch',
+      ...metadata,
+    },
+  });
+
+  logger.info('stripe setup intent created for invoice payment', {
+    customerId: customer.id,
+    setupIntentId: setupIntent.id,
+    metadata,
+  });
+
+  return setupIntent;
+}
+
 export async function updateAutoRechargeConfigPaymentMethod(params: {
   stripePaymentMethodId: string;
   autoRechargeConfig: AutoRechargeConfig;

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

@@ -1,6 +1,6 @@
 /* eslint-disable no-await-in-loop */
 
-import env from '@blocklet/sdk/lib/env';
+import { env } from '@blocklet/sdk/lib/env';
 
 import Stripe from 'stripe';
 import logger from '../../libs/logger';

package/api/src/libs/auth.ts

@@ -1,10 +1,11 @@
 import path from 'path';
 
 import AuthStorage from '@arcblock/did-connect-storage-nedb';
-import AuthService from '@blocklet/sdk/service/auth';
-import getWallet from '@blocklet/sdk/lib/wallet';
-import WalletAuthenticator from '@blocklet/sdk/lib/wallet-authenticator';
-import WalletHandler from '@blocklet/sdk/lib/wallet-handler';
+// @ts-ignore
+import { BlockletService } from '@blocklet/sdk/service/auth';
+import { getWallet } from '@blocklet/sdk/lib/wallet';
+import { WalletAuthenticator } from '@blocklet/sdk/lib/wallet-authenticator';
+import { WalletHandlers } from '@blocklet/sdk/lib/wallet-handler';
 import type { Request } from 'express';
 import type { LiteralUnion } from 'type-fest';
 import type { WalletObject } from '@ocap/wallet';
@@ -15,7 +16,7 @@ import logger from './logger';
 export const wallet: WalletObject = getWallet();
 export const ethWallet: WalletObject = getWallet('ethereum');
 export const authenticator = new WalletAuthenticator();
-export const handlers = new WalletHandler({
+export const handlers = new WalletHandlers({
   authenticator,
   tokenStorage: new AuthStorage({
     dbPath: path.join(env.dataDir, 'auth.db'),
@@ -24,7 +25,7 @@ export const handlers = new WalletHandler({
   }),
 });
 
-export const blocklet = new AuthService();
+export const blocklet = new BlockletService();
 
 export async function getVaultAddress() {
   try {

package/api/src/libs/env.ts

@@ -1,4 +1,4 @@
-import env from '@blocklet/sdk/lib/env';
+import { env } from '@blocklet/sdk/lib/env';
 
 export const paymentStatCronTime: string = '0 1 0 * * *'; // 默认每天一次，计算前一天的
 export const subscriptionCronTime: string = process.env.SUBSCRIPTION_CRON_TIME || '0 */30 * * * *'; // 默认每 30 min 行一次

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

@@ -92,6 +92,7 @@ export class SubscriptionTrialWillEndEmailTemplate extends BaseSubscriptionEmail
       const paymentAddress = subscription.payment_details?.[paymentMethod.type]?.payer ?? undefined;
       const balance = await getTokenByAddress(paymentAddress, paymentMethod, paymentCurrency);
 
+      // @ts-ignore
       paymentDetail.balance = +fromUnitToToken(balance, paymentCurrency.decimal);
     }
 

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

@@ -100,7 +100,7 @@ export class SubscriptionWillRenewEmailTemplate extends BaseSubscriptionEmailTem
       const paymentAddress = getSubscriptionPaymentAddress(subscription, paymentInfoResult.paymentMethod!.type);
       const balance = await getTokenByAddress(paymentAddress, paymentInfoResult.paymentMethod!, paymentCurrency);
 
-      paymentDetail.balanceFormatted = fromUnitToToken(balance, paymentCurrency.decimal);
+      paymentDetail.balanceFormatted = fromUnitToToken(balance || '0', paymentCurrency.decimal);
       paymentDetail.balance = +paymentDetail.balanceFormatted;
     }
 

package/api/src/libs/payment.ts

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/indent */
 import { isEthereumDid } from '@arcblock/did';
 import { toDelegateAddress } from '@arcblock/did-util';
-import { sign } from '@arcblock/jwt';
 import { getWalletDid } from '@blocklet/sdk/lib/did';
 import type { DelegateState, TokenLimit } from '@ocap/client';
 import { toTxHash } from '@ocap/mcrypto';
@@ -25,7 +24,13 @@ import {
 import type { TPaymentCurrency } from '../store/models/payment-currency';
 import { blocklet, ethWallet, wallet, getVaultAddress } from './auth';
 import logger from './logger';
-import { getBlockletJson, getUserOrAppInfo, OCAP_PAYMENT_TX_TYPE, resolveAddressChainTypes } from './util';
+import {
+  formatLinkWithLocale,
+  getBlockletJson,
+  getUserOrAppInfo,
+  OCAP_PAYMENT_TX_TYPE,
+  resolveAddressChainTypes,
+} from './util';
 import { CHARGE_SUPPORTED_CHAIN_TYPES, EVM_CHAIN_TYPES } from './constants';
 import { getTokenByAddress } from '../integrations/arcblock/stake';
 import { isCreditMetered } from './session';
@@ -378,7 +383,7 @@ export function isCreditSufficientForPayment(args: {
   return { sufficient: true, balance };
 }
 
-export function getGasPayerExtra(txBuffer: Buffer, headers?: { [key: string]: string }) {
+export async function getGasPayerExtra(txBuffer: Buffer, headers?: { [key: string]: string }) {
   if (headers && headers['x-gas-payer-sig'] && headers['x-gas-payer-pk']) {
     return { headers };
   }
@@ -386,7 +391,7 @@ export function getGasPayerExtra(txBuffer: Buffer, headers?: { [key: string]: st
   const txHash = toTxHash(txBuffer);
   return {
     headers: {
-      'x-gas-payer-sig': sign(wallet.address, wallet.secretKey, { txHash }),
+      'x-gas-payer-sig': await wallet.signJWT({ txHash }),
       'x-gas-payer-pk': wallet.publicKey,
     },
   };
@@ -564,7 +569,7 @@ export async function isBalanceSufficientForRefund(args: {
   throw new Error(`isBalanceSufficientForRefund: Payment method ${paymentMethod.type} not supported`);
 }
 
-export async function getDonationBenefits(paymentLink: PaymentLink, url?: string) {
+export async function getDonationBenefits(paymentLink: PaymentLink, url?: string, locale?: string) {
   const { donation_settings: donationSettings } = paymentLink;
   if (!donationSettings) {
     return [];
@@ -585,7 +590,7 @@ export async function getDonationBenefits(paymentLink: PaymentLink, url?: string
           percent: (Number(share) * 100) / total,
           name: name || info?.name || '',
           avatar: avatar || info?.avatar || '',
-          url: info?.url || '',
+          url: formatLinkWithLocale(info?.url || '', locale),
           type: info?.type || 'user',
         };
       } catch (error) {

package/api/src/libs/refund.ts

@@ -50,7 +50,7 @@ export async function getRefundAmountSetup({
       paymentIntentId,
     });
     return {
-      amount: paymentIntent.amount_received,
+      amount: paymentIntent.amount_received || '0',
       totalAmount: paymentIntent.amount_received,
     };
   }