payment-kit 1.18.49 → 1.18.51

package/api/src/crons/currency.ts

@@ -6,7 +6,12 @@ import logger from '../libs/logger';
 export async function syncCurrencyLogo() {
   const where = {
     logo: {
-      [Op.like]: '%/methods/%.png',
+      [Op.or]: [
+        { [Op.like]: '%/methods/%.png' },
+        { [Op.like]: '%/currencies/%.png' },
+        { [Op.like]: '%/methods/%.svg' },
+        { [Op.like]: '%/currencies/%.svg' },
+      ],
     },
   };
 
@@ -19,9 +24,24 @@ export async function syncCurrencyLogo() {
 
   const updateLogo = (item: PaymentMethod | PaymentCurrency) => {
     const { logo } = item;
-    if (/\/methods\/(stripe|arcblock|ethereum|base)\.png$/.test(logo)) {
-      const newLogo = getUrl(logo.replace(/^.*?(\/methods\/.*)$/, '$1'));
-      promises.push((item as any).update({ logo: newLogo }));
+
+    // 匹配 /methods/ 和 /currencies/ 路径下的 logo
+    const methodsMatch = /\/methods\/(stripe|arcblock|ethereum|base)\.(png|svg)$/.test(logo);
+    const currenciesMatch = /\/currencies\/[^/]+\.(png|svg)$/.test(logo);
+
+    if (methodsMatch || currenciesMatch) {
+      let newLogo: string;
+
+      if (methodsMatch) {
+        // 处理 /methods/ 路径
+        newLogo = getUrl(logo.replace(/^.*?(\/methods\/.*)$/, '$1'));
+      } else {
+        newLogo = getUrl(logo.replace(/^.*?(\/currencies\/.*)$/, '$1'));
+      }
+      if (newLogo !== logo) {
+        promises.push((item as any).update({ logo: newLogo }));
+        logger.info(`Updating logo: ${logo} -> ${newLogo}`);
+      }
     }
   };
 
@@ -30,6 +50,7 @@ export async function syncCurrencyLogo() {
 
   try {
     await Promise.all(promises);
+    logger.info(`Updated ${promises.length} logo(s)`);
   } catch (error) {
     logger.error('syncCurrency error', error);
   }

package/api/src/libs/invoice.ts

@@ -1119,3 +1119,234 @@ export async function retryUncollectibleInvoices(options: {
     logger.info('Released retry uncollectible lock', { lockKey });
   }
 }
+
+/**
+ * Migrate billing when a subscription's payment method changes.
+ * Steps:
+ * 1. Check if all subscription items are prepaid (licensed recurring).
+ * 2. If so, check if there is an unpaid invoice for the current period with the old payment method.
+ * 3. If such an invoice exists, void the old invoice and cancel its payment intent if present.
+ * 4. Create a new invoice for the current period with the new payment method.
+ * 5. If any step fails, throw an error and log details.
+ *
+ * @param subscription Subscription instance
+ * @param oldCurrencyId Old payment currency ID
+ * @param newCurrencyId New payment currency ID
+ * @returns Migration result: { migrated, oldInvoice, newInvoice }
+ */
+export const migrateSubscriptionPaymentMethodInvoice = async (
+  subscription: Subscription,
+  oldCurrencyId: string,
+  newCurrencyId: string
+) => {
+  // 1. Check if all subscription items are prepaid (licensed recurring)
+  const subscriptionItems = await SubscriptionItem.findAll({
+    where: { subscription_id: subscription.id },
+    include: [{ model: Price, as: 'price' }],
+  });
+
+  const subscriptionItemsExpanded = await Price.expand(subscriptionItems.map((x) => x.toJSON()));
+  const isPrepaid = subscriptionItemsExpanded.every((item: TLineItemExpanded) => {
+    const price = getSubscriptionItemPrice(item);
+    return price.type === 'recurring' && price.recurring?.usage_type === 'licensed';
+  });
+
+  if (!isPrepaid) {
+    logger.info('Skip billing migration for non-prepaid items', {
+      subscriptionId: subscription.id,
+    });
+    return { migrated: false, reason: 'has_non_prepaid_items' };
+  }
+
+  // 2. Find unpaid invoice for the current period with the old payment method
+  const currentPeriodInvoice = await Invoice.findOne({
+    where: {
+      subscription_id: subscription.id,
+      billing_reason: 'subscription_cycle',
+      status: ['open', 'uncollectible'],
+      currency_id: oldCurrencyId,
+      period_start: {
+        [Op.gte]: subscription.current_period_start,
+        [Op.lt]: subscription.current_period_end,
+      },
+    },
+    order: [['created_at', 'DESC']],
+  });
+
+  let voidedInvoice: Invoice | null = null;
+
+  if (!currentPeriodInvoice) {
+    voidedInvoice = await Invoice.findOne({
+      where: {
+        subscription_id: subscription.id,
+        billing_reason: 'subscription_cycle',
+        status: 'void',
+        currency_id: oldCurrencyId,
+        period_start: {
+          [Op.gte]: subscription.current_period_start,
+          [Op.lt]: subscription.current_period_end,
+        },
+      },
+      order: [['created_at', 'DESC']],
+    });
+    if (!voidedInvoice) {
+      logger.info('Skip billing migration for no unpaid invoice', {
+        subscriptionId: subscription.id,
+        periodStart: subscription.current_period_start,
+        periodEnd: subscription.current_period_end,
+        oldCurrencyId,
+      });
+      return { migrated: false, reason: 'no_unpaid_invoice' };
+    }
+  }
+
+  // 3. Get old and new payment method/currency
+  const oldPaymentCurrency = await PaymentCurrency.findByPk(oldCurrencyId);
+  if (!oldPaymentCurrency) {
+    throw new Error(`Payment currency ${oldCurrencyId} not found`);
+  }
+  const oldPaymentMethod = await PaymentMethod.findByPk(oldPaymentCurrency.payment_method_id);
+  if (!oldPaymentMethod) {
+    throw new Error(`Payment method for currency ${oldCurrencyId} not found`);
+  }
+
+  const newPaymentCurrency = await PaymentCurrency.findByPk(newCurrencyId);
+  if (!newPaymentCurrency) {
+    throw new Error(`Payment currency ${newCurrencyId} not found`);
+  }
+  const newPaymentMethod = await PaymentMethod.findByPk(newPaymentCurrency.payment_method_id);
+  if (!newPaymentMethod) {
+    throw new Error(`Payment method for currency ${newCurrencyId} not found`);
+  }
+
+  // 4. Stripe payment method is not supported for migration
+  if (newPaymentMethod.type === 'stripe') {
+    logger.info('Skip billing migration for stripe payment method', {
+      subscriptionId: subscription.id,
+    });
+    return { migrated: false, reason: 'stripe_payment_method' };
+  }
+
+  try {
+    const customer = await Customer.findByPk(subscription.customer_id);
+    if (!customer) {
+      throw new Error(`Customer ${subscription.customer_id} not found`);
+    }
+
+    const cancelOldInvoice = async (invoice: Invoice) => {
+      try {
+        if (invoice.payment_intent_id) {
+          const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
+          if (paymentIntent && paymentIntent.status !== 'canceled') {
+            await paymentIntent.update({
+              status: 'canceled',
+              canceled_at: dayjs().unix(),
+              cancellation_reason: 'void_invoice',
+            });
+          }
+        }
+
+        if (oldPaymentMethod.type === 'stripe' && invoice.metadata?.stripe_id) {
+          const client = oldPaymentMethod.getStripeClient();
+          await client.invoices.voidInvoice(invoice.metadata.stripe_id);
+        }
+
+        await invoice.update({
+          status: 'void',
+          status_transitions: {
+            ...(invoice.status_transitions || {}),
+            voided_at: dayjs().unix(),
+          },
+        });
+
+        logger.info('Successfully voided old invoice for payment method change', {
+          subscriptionId: subscription.id,
+          oldInvoice: invoice.id,
+          oldCurrency: oldCurrencyId,
+          newCurrency: newCurrencyId,
+        });
+      } catch (error) {
+        logger.error('Failed to void old invoice', {
+          subscription: subscription.id,
+          invoiceId: invoice.id,
+          error: error.message,
+        });
+        throw error;
+      }
+    };
+
+    const createNewInvoice = async () => {
+      const preInvoice = currentPeriodInvoice || voidedInvoice;
+      if (!preInvoice) {
+        throw new Error('No unpaid invoice found');
+      }
+      const metadata: Record<string, any> = {
+        prev_invoice_id: preInvoice.id,
+      };
+      const amount = getSubscriptionCycleAmount(subscriptionItemsExpanded, newCurrencyId);
+
+      const { invoice } = await ensureInvoiceAndItems({
+        customer,
+        currency: newPaymentCurrency,
+        subscription,
+        trialing: subscription.status === 'trialing',
+        metered: false,
+        lineItems: subscriptionItemsExpanded,
+        applyCredit: false,
+        props: {
+          status: 'open',
+          total: amount.total,
+          livemode: subscription.livemode,
+          description: 'Subscription cycle',
+          statement_descriptor: preInvoice.statement_descriptor,
+          period_start: preInvoice.period_start,
+          period_end: preInvoice.period_end,
+          auto_advance: true,
+          billing_reason: 'subscription_cycle',
+          currency_id: newCurrencyId,
+          default_payment_method_id: newPaymentMethod.id,
+          custom_fields: preInvoice.custom_fields || [],
+          footer: preInvoice.footer || '',
+          payment_settings: subscription.payment_settings,
+          metadata,
+        } as Invoice,
+      });
+      return invoice;
+    };
+
+    // 5. Cancel old invoice, then create new invoice
+    if (currentPeriodInvoice) {
+      await cancelOldInvoice(currentPeriodInvoice);
+    }
+
+    const invoice = await createNewInvoice();
+    if (invoice) {
+      await emitAsync('invoice.queued', invoice.id, { invoiceId: invoice.id, retryOnError: true }, { sync: false });
+      logger.info('Successfully queued new invoice for payment method change', {
+        subscriptionId: subscription.id,
+        invoiceId: invoice.id,
+      });
+    }
+
+    logger.info('Successfully migrated invoice for payment method change', {
+      subscriptionId: subscription.id,
+      oldInvoiceId: currentPeriodInvoice?.id || voidedInvoice?.id,
+      oldCurrency: oldCurrencyId,
+      newCurrency: newCurrencyId,
+      newInvoiceId: invoice.id,
+    });
+    return {
+      migrated: true,
+      oldInvoice: currentPeriodInvoice,
+      newInvoice: invoice,
+    };
+  } catch (error) {
+    logger.error('Failed to migrate invoice for payment method change', {
+      subscriptionId: subscription.id,
+      oldCurrencyId,
+      newCurrencyId,
+      error: error.message,
+    });
+    throw error;
+  }
+};

package/api/src/libs/payment.ts

@@ -47,6 +47,98 @@ export interface SufficientForPaymentResult {
   requestedAmount?: string;
 }
 
+export async function checkTokenBalance(args: {
+  paymentMethod: PaymentMethod;
+  paymentCurrency: TPaymentCurrency;
+  userDid: string;
+  amount: string;
+}): Promise<SufficientForPaymentResult> {
+  const { paymentMethod, paymentCurrency, userDid, amount } = args;
+  const tokenAddress = paymentCurrency.contract as string;
+  const totalAmount = new BN(amount);
+
+  if (paymentMethod.type === 'arcblock') {
+    // get user wallet did
+    const { user } = await blocklet.getUser(userDid, { enableConnectedAccount: true });
+    const delegator = getWalletDid(user);
+    if (!delegator) {
+      return {
+        sufficient: false,
+        reason: 'NO_DID_WALLET',
+        requestedAmount: totalAmount.toString(),
+      };
+    }
+
+    const client = paymentMethod.getOcapClient();
+
+    // check token balance
+    const { tokens } = await client.getAccountTokens({ address: delegator, token: tokenAddress });
+    const [token] = tokens;
+    if (!token) {
+      return {
+        sufficient: false,
+        reason: 'NO_TOKEN',
+        requestedAmount: totalAmount.toString(),
+      };
+    }
+
+    if (new BN(token.balance).lt(totalAmount)) {
+      return {
+        sufficient: false,
+        reason: 'NO_ENOUGH_TOKEN',
+        token,
+        requestedAmount: totalAmount.toString(),
+      };
+    }
+
+    return {
+      sufficient: true,
+      token,
+      requestedAmount: totalAmount.toString(),
+    };
+  }
+
+  if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
+    if (!paymentCurrency.contract) {
+      return {
+        sufficient: false,
+        reason: 'NO_TOKEN',
+        requestedAmount: totalAmount.toString(),
+      };
+    }
+    if (isEthereumDid(userDid) === false) {
+      return {
+        sufficient: false,
+        reason: 'NO_TOKEN',
+        requestedAmount: totalAmount.toString(),
+      };
+    }
+
+    const provider = paymentMethod.getEvmClient();
+    const balance = await fetchErc20Balance(provider, paymentCurrency.contract, userDid);
+
+    if (new BN(balance).lt(totalAmount)) {
+      return {
+        sufficient: false,
+        reason: 'NO_ENOUGH_TOKEN',
+        token: { address: tokenAddress, balance },
+        requestedAmount: totalAmount.toString(),
+      };
+    }
+
+    return {
+      sufficient: true,
+      token: { address: tokenAddress, balance },
+      requestedAmount: totalAmount.toString(),
+    };
+  }
+
+  return {
+    sufficient: true,
+    requestedAmount: totalAmount.toString(),
+  };
+}
+
 export async function isDelegationSufficientForPayment(args: {
   paymentMethod: PaymentMethod;
   paymentCurrency: TPaymentCurrency;

package/api/src/queues/payment.ts

@@ -846,10 +846,8 @@ export const handlePayment = async (job: PaymentJob) => {
         wallet,
         delegator: result.delegator,
       });
-      logger.info('PaymentIntent signed', { signed });
       // @ts-ignore
       const { buffer } = await client.encodeTransferV2Tx({ tx: signed });
-      logger.info('PaymentIntent buffer', { buffer, gas: getGasPayerExtra(buffer) });
       const txHash = await client.sendTransferV2Tx(
         // @ts-ignore
         { tx: signed, wallet, delegator: result.delegator },

package/api/src/queues/subscription.ts

@@ -26,7 +26,7 @@ import {
   shouldCancelSubscription,
   slashOverdraftProtectionStake,
 } from '../libs/subscription';
-import { ensureInvoiceAndItems } from '../libs/invoice';
+import { ensureInvoiceAndItems, migrateSubscriptionPaymentMethodInvoice } from '../libs/invoice';
 import { PaymentCurrency, PaymentIntent, PaymentMethod, Refund, SetupIntent, UsageRecord } from '../store/models';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
@@ -1280,5 +1280,28 @@ events.on('setup_intent.succeeded', async (setupIntent: SetupIntent) => {
         logger.error('create return overdraft protection stake job failed', { error, subscription: subscription.id });
       }
     }
+
+    try {
+      const migrationResult = await migrateSubscriptionPaymentMethodInvoice(
+        subscription,
+        setupIntent.metadata?.from_currency,
+        setupIntent.metadata?.to_currency
+      );
+      if (migrationResult.migrated) {
+        logger.info('Subscription payment method billing migration completed', {
+          subscription: subscription.id,
+          migrated: migrationResult.migrated,
+          oldInvoice: migrationResult.oldInvoice?.id,
+          newInvoice: migrationResult.newInvoice?.id,
+        });
+      }
+    } catch (error) {
+      logger.error('Failed to migrate billing for payment method change', {
+        subscription: subscription.id,
+        fromCurrency: setupIntent.metadata?.from_currency,
+        toCurrency: setupIntent.metadata?.to_currency,
+        error,
+      });
+    }
   }
 });

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

@@ -13,6 +13,8 @@ import {
 import { ensureStakeInvoice } from '../../libs/invoice';
 import { EVM_CHAIN_TYPES } from '../../libs/constants';
 import logger from '../../libs/logger';
+import { getFastCheckoutAmount } from '../../libs/session';
+import { isDelegationSufficientForPayment } from '../../libs/payment';
 
 export default {
   action: 'change-payment',
@@ -26,41 +28,53 @@ export default {
   },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
     const { subscriptionId } = extraParams;
-    const { subscription, paymentMethod, paymentCurrency } = await ensureChangePaymentContext(subscriptionId);
+    const { subscription, paymentMethod, paymentCurrency, customer } = await ensureChangePaymentContext(subscriptionId);
 
     const claimsList: any[] = [];
     // @ts-ignore
     const items = subscription!.items as TLineItemExpanded[];
     const trialing = true;
     const billingThreshold = Number(subscription.billing_thresholds?.amount_gte || 0);
+    const fastCheckoutAmount = getFastCheckoutAmount(items, 'subscription', paymentCurrency.id, false);
 
     if (paymentMethod.type === 'arcblock') {
-      claimsList.push({
-        signature: await getDelegationTxClaim({
-          mode: 'setup',
-          userDid,
-          userPk,
-          nonce: `change-method-${subscription.id}`,
-          data: getTxMetadata({ subscriptionId: subscription.id }),
-          paymentCurrency,
-          paymentMethod,
-          trialing,
-          billingThreshold,
-          items,
-        }),
-      });
-
-      claimsList.push({
-        prepareTx: await getStakeTxClaim({
-          userDid,
-          userPk,
-          paymentCurrency,
-          paymentMethod,
-          items,
-          subscription,
-        }),
+      const delegation = await isDelegationSufficientForPayment({
+        paymentMethod,
+        paymentCurrency,
+        userDid: customer!.did,
+        amount: fastCheckoutAmount,
       });
+      const needDelegation = delegation.sufficient === false;
+      const noStake = subscription.billing_thresholds?.no_stake;
+      if (needDelegation || noStake) {
+        claimsList.push({
+          signature: await getDelegationTxClaim({
+            mode: 'setup',
+            userDid,
+            userPk,
+            nonce: `change-method-${subscription.id}`,
+            data: getTxMetadata({ subscriptionId: subscription.id }),
+            paymentCurrency,
+            paymentMethod,
+            trialing,
+            billingThreshold,
+            items,
+          }),
+        });
+      }
 
+      if (!noStake) {
+        claimsList.push({
+          prepareTx: await getStakeTxClaim({
+            userDid,
+            userPk,
+            paymentCurrency,
+            paymentMethod,
+            items,
+            subscription,
+          }),
+        });
+      }
       return claimsList;
     }
 
@@ -95,6 +109,8 @@ export default {
     const { setupIntent, subscription, paymentMethod, paymentCurrency, customer } =
       await ensureChangePaymentContext(subscriptionId);
 
+    const noStake = subscription.billing_thresholds?.no_stake;
+
     const result = request?.context?.store?.result || [];
     result.push({
       step,
@@ -106,7 +122,8 @@ export default {
 
     // 判断是否为最后一步
     const staking = result.find((x: any) => x.claim?.type === 'prepareTx' && x.claim?.meta?.purpose === 'staking');
-    const isFinalStep = (paymentMethod.type === 'arcblock' && staking) || paymentMethod.type !== 'arcblock';
+    const isFinalStep =
+      (paymentMethod.type === 'arcblock' && (staking || noStake)) || paymentMethod.type !== 'arcblock';
 
     if (!isFinalStep) {
       await updateSession({
@@ -181,25 +198,28 @@ export default {
         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,
+      if (stakingAmount && stakingAmount !== '0') {
+        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!
-      );
+          subscription!,
+          paymentMethod,
+          customer!
+        );
+      }
+
       await afterTxExecution(paymentDetails);
       return { hash: paymentDetails.tx_hash };
     }

package/api/src/routes/connect/shared.ts

@@ -400,7 +400,7 @@ export async function ensureInvoiceForCheckout({
       }
 
       // invoice currency is aligned
-      if (invoice.currency_id === checkoutSession.currency_id) {
+      if (invoice.currency_id === checkoutSession.currency_id && invoice.status !== 'draft') {
         await invoice.update({ status: 'open' });
         logger.info(`Invoice status reset for checkout session ${checkoutSession.id}: ${existingInvoice}`);
 
@@ -512,7 +512,8 @@ export async function ensureInvoicesForSubscriptions({
   checkoutSession,
   customer,
   subscriptions,
-}: Omit<Args, 'subscription'> & { subscriptions: Subscription[] }): Promise<{ 
+  invoiceProps,
+}: Omit<Args, 'subscription'> & { subscriptions: Subscription[]; invoiceProps?: Partial<TInvoice> }): Promise<{ 
   invoices: Invoice[]; 
 }> {
   if (!subscriptions?.length) {
@@ -531,7 +532,8 @@ export async function ensureInvoicesForSubscriptions({
         customer, 
         subscription, 
         subscriptions, 
-        lineItems: subItems 
+        lineItems: subItems,
+        props: invoiceProps,
       });
       return invoice;
     })