payment-kit 1.24.3 → 1.25.0

package/api/src/routes/connect/auto-recharge-auth.ts

@@ -53,6 +53,7 @@ export default {
           billingThreshold: 0,
           items: expandedItems,
           requiredStake: false,
+          slippageConfig: autoRechargeConfig.slippage_config || undefined,
         }),
       });
 
@@ -79,6 +80,7 @@ export default {
           billingThreshold: 0,
           items: expandedItems,
           requiredStake: false,
+          slippageConfig: autoRechargeConfig.slippage_config || undefined,
         }),
       });
 

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

@@ -48,6 +48,7 @@ export default {
           billingThreshold,
           items,
           requiredStake: false,
+          slippageConfig: subscription?.slippage_config || undefined,
         }),
       });
       return claimsList;
@@ -70,6 +71,7 @@ export default {
           trialing,
           billingThreshold,
           items,
+          slippageConfig: subscription?.slippage_config || undefined,
         }),
       });
 

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

@@ -13,8 +13,9 @@ import {
 import { ensureStakeInvoice } from '../../libs/invoice';
 import { EVM_CHAIN_TYPES } from '../../libs/constants';
 import logger from '../../libs/logger';
-import { getFastCheckoutAmount } from '../../libs/session';
+import { getFastCheckoutAmount, getSubscriptionCreateSetup, SlippageOptions } from '../../libs/session';
 import { isDelegationSufficientForPayment } from '../../libs/payment';
+import { getQuoteService } from '../../libs/quote-service';
 
 export default {
   action: 'change-payment',
@@ -35,19 +36,34 @@ export default {
     const items = subscription!.items as TLineItemExpanded[];
     const trialing = true;
     const billingThreshold = Number(subscription.billing_thresholds?.amount_gte || 0);
-    const fastCheckoutAmount = await getFastCheckoutAmount({
-      items,
-      mode: 'subscription',
-      currencyId: paymentCurrency.id,
-      trialing: false,
-    });
+
+    // Calculate required amount considering slippage_config for dynamic pricing
+    const slippageConfig = subscription?.slippage_config;
+    let requiredAmount: string;
+    if (slippageConfig?.min_acceptable_rate) {
+      // Use slippage_config for precise calculation
+      const slippageOptions: SlippageOptions = {
+        percent: slippageConfig.percent ?? 0.5,
+        minAcceptableRate: slippageConfig.min_acceptable_rate,
+        currencyDecimal: paymentCurrency.decimal,
+      };
+      const setup = getSubscriptionCreateSetup(items, paymentCurrency.id, 0, 0, slippageOptions);
+      requiredAmount = setup.amount.setup;
+    } else {
+      requiredAmount = await getFastCheckoutAmount({
+        items,
+        mode: 'subscription',
+        currencyId: paymentCurrency.id,
+        trialing: false,
+      });
+    }
 
     if (paymentMethod.type === 'arcblock') {
       const delegation = await isDelegationSufficientForPayment({
         paymentMethod,
         paymentCurrency,
         userDid,
-        amount: fastCheckoutAmount,
+        amount: requiredAmount,
       });
       const needDelegation = delegation.sufficient === false;
       const requiredStake = !subscription.billing_thresholds?.no_stake;
@@ -65,6 +81,7 @@ export default {
             billingThreshold,
             items,
             requiredStake,
+            slippageConfig: subscription?.slippage_config || undefined,
           }),
         });
       }
@@ -101,6 +118,7 @@ export default {
           trialing,
           billingThreshold,
           items,
+          slippageConfig: subscription?.slippage_config || undefined,
         }),
       });
 
@@ -183,6 +201,41 @@ export default {
         },
       });
 
+      // Create quotes for dynamic pricing items after payment method change
+      // @ts-ignore
+      const items = subscription!.items as TLineItemExpanded[];
+      const dynamicItems = items.filter(
+        (item: TLineItemExpanded) => (item.upsell_price || item.price)?.pricing_type === 'dynamic'
+      );
+      if (dynamicItems.length > 0) {
+        const quoteService = getQuoteService();
+        for (const item of dynamicItems) {
+          try {
+            const price = item.upsell_price || item.price;
+            // eslint-disable-next-line no-await-in-loop
+            await quoteService.getOrCreateQuote({
+              price_id: price.id,
+              target_currency_id: paymentCurrency.id,
+              quantity: item.quantity || 1,
+              idempotency_key_salt: `change-payment-${subscription!.id}-${Date.now()}`,
+            });
+            logger.info('Created quote for dynamic pricing item after payment change', {
+              subscriptionId: subscription!.id,
+              priceId: price.id,
+              currencyId: paymentCurrency.id,
+            });
+          } catch (error) {
+            logger.error('Failed to create quote for dynamic pricing item after payment change', {
+              subscriptionId: subscription!.id,
+              priceId: (item.upsell_price || item.price)?.id,
+              currencyId: paymentCurrency.id,
+              error,
+            });
+            // Continue with other items even if one fails
+          }
+        }
+      }
+
       await Lock.acquire(`${subscription.id}-change-plan`, subscription.current_period_end);
       // update stripe subscription
       await updateStripeSubscriptionAfterChangePayment(setupIntent, subscription);

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

@@ -1,12 +1,13 @@
 import { executeEvmTransaction, waitForEvmTxConfirm } from '../../integrations/ethereum/tx';
 import type { CallbackArgs } from '../../libs/auth';
 import { isDelegationSufficientForPayment } from '../../libs/payment';
-import { getFastCheckoutAmount } from '../../libs/session';
-import { onSubscriptionUpdateConnected } from '../../libs/subscription';
+import { getFastCheckoutAmount, getSubscriptionCreateSetup, type SlippageOptions } from '../../libs/session';
+import { checkRemainingStake, onSubscriptionUpdateConnected } from '../../libs/subscription';
 import { getTxMetadata } from '../../libs/util';
 import { invoiceQueue } from '../../queues/invoice';
 import { addSubscriptionJob, subscriptionQueue } from '../../queues/subscription';
 import type { TLineItemExpanded } from '../../store/models';
+import { Invoice } from '../../store/models/invoice';
 import {
   ensureSubscription,
   executeOcapTransactions,
@@ -37,23 +38,68 @@ export default {
     const items = subscription!.items as TLineItemExpanded[];
     const trialing = false;
     const billingThreshold = Number(subscription!.billing_thresholds?.amount_gte || 0);
-    const fastCheckoutAmount = await getFastCheckoutAmount({
-      items,
-      mode: 'subscription',
-      currencyId: paymentCurrency.id,
-      trialing: false,
-    });
+
+    // Calculate required amount considering slippage_config for dynamic pricing
+    const slippageConfig = subscription?.slippage_config;
+    let requiredAmount: string;
+    if (slippageConfig?.min_acceptable_rate) {
+      // Use slippage_config for precise calculation
+      const slippageOptions: SlippageOptions = {
+        percent: slippageConfig.percent ?? 0.5,
+        minAcceptableRate: slippageConfig.min_acceptable_rate,
+        currencyDecimal: paymentCurrency.decimal,
+      };
+      const setup = getSubscriptionCreateSetup(items, paymentCurrency.id, 0, 0, slippageOptions);
+      requiredAmount = setup.amount.setup;
+    } else {
+      requiredAmount = await getFastCheckoutAmount({
+        items,
+        mode: 'subscription',
+        currencyId: paymentCurrency.id,
+        trialing: false,
+      });
+    }
 
     if (paymentMethod.type === 'arcblock') {
+      const requiredStake = !subscription!.billing_thresholds?.no_stake;
+
+      // 1. First check if stake is needed and if there's a valid existing stake
+      let needsNewStake = false;
+      let existingStakeAddress: string | undefined;
+      if (requiredStake) {
+        existingStakeAddress = subscription?.payment_details?.arcblock?.staking?.address;
+        if (existingStakeAddress) {
+          const stakeCheck = await checkRemainingStake(paymentMethod, paymentCurrency, existingStakeAddress, '1');
+          needsNewStake = !stakeCheck.enough;
+          logger.info('Change plan: checking existing stake', {
+            subscriptionId: subscription!.id,
+            existingStakeAddress,
+            hasValidExistingStake: stakeCheck.enough,
+            needsNewStake,
+            stakeCheck,
+          });
+        } else {
+          needsNewStake = true;
+        }
+      }
+
+      // 2. Check if delegation is sufficient
       const delegation = await isDelegationSufficientForPayment({
         paymentMethod,
         paymentCurrency,
         userDid,
-        amount: fastCheckoutAmount,
+        amount: requiredAmount,
       });
 
-      const requiredStake = !subscription!.billing_thresholds?.no_stake;
+      logger.info('Change plan: delegation check', {
+        subscriptionId: subscription!.id,
+        delegationSufficient: delegation.sufficient,
+        needsNewStake,
+        requiredStake,
+      });
 
+      // 3. Add delegation claim if needed
+      // Need delegation if: delegation is not sufficient, OR we don't require stake (legacy behavior)
       if (delegation.sufficient === false || !requiredStake) {
         claimsList.push({
           signature: await getDelegationTxClaim({
@@ -67,11 +113,13 @@ export default {
             trialing,
             billingThreshold,
             items,
+            slippageConfig: subscription?.slippage_config || undefined,
           }),
         });
       }
 
-      if (requiredStake) {
+      // 4. Add stake claim only if we need a new stake
+      if (needsNewStake) {
         claimsList.push({
           prepareTx: await getStakeTxClaim({
             userDid,
@@ -82,10 +130,22 @@ export default {
             subscription: subscription!,
           }),
         });
+      } else if (requiredStake && existingStakeAddress) {
+        logger.info('Change plan: skipping stake request, reusing existing stake', {
+          subscriptionId: subscription!.id,
+          existingStakeAddress,
+        });
       }
 
+      // 5. If no claims needed, this is an error - API should have prevented entering connect flow
       if (claimsList.length === 0) {
-        throw new Error('No available claims for your subscription at this time.');
+        logger.warn('Change plan: no claims needed but entered connect flow', {
+          subscriptionId: subscription!.id,
+          delegationSufficient: delegation.sufficient,
+          needsNewStake,
+          requiredStake,
+        });
+        throw new Error('No authorization needed for this subscription update. Please try again.');
       }
 
       return claimsList;
@@ -108,6 +168,7 @@ export default {
           trialing,
           billingThreshold,
           items,
+          slippageConfig: subscription?.slippage_config || undefined,
         }),
       });
 
@@ -119,8 +180,46 @@ export default {
 
   onAuth: async ({ request, userDid, userPk, claims, extraParams, updateSession, step }: CallbackArgs) => {
     const { subscriptionId } = extraParams;
-    const { invoice, paymentMethod, subscription, paymentCurrency, customer } =
-      await ensureSubscription(subscriptionId);
+    const {
+      invoice: latestInvoice,
+      paymentMethod,
+      subscription,
+      paymentCurrency,
+      customer,
+    } = await ensureSubscription(subscriptionId);
+
+    // For plan change, use the pending_update invoice if exists, not the latest_invoice_id
+    // The plan change invoice is created in subscriptions.ts and stored in pending_update.updates.latest_invoice_id
+    const pendingInvoiceId = subscription?.pending_update?.updates?.latest_invoice_id;
+    let invoice = latestInvoice;
+    if (pendingInvoiceId && pendingInvoiceId !== latestInvoice?.id) {
+      const pendingInvoice = await Invoice.findByPk(pendingInvoiceId);
+      if (pendingInvoice) {
+        invoice = pendingInvoice;
+        logger.info('Change plan: using pending_update invoice instead of latest_invoice', {
+          subscriptionId,
+          pendingInvoiceId,
+          latestInvoiceId: latestInvoice?.id,
+        });
+      } else {
+        logger.error('Change plan: pending invoice not found in database', {
+          subscriptionId,
+          pendingInvoiceId,
+          latestInvoiceId: latestInvoice?.id,
+        });
+      }
+    }
+
+    // Validate invoice exists - change-plan should always have an invoice to process
+    if (!invoice) {
+      logger.error('Change plan: no invoice found for subscription update', {
+        subscriptionId,
+        pendingInvoiceId,
+        latestInvoiceId: latestInvoice?.id,
+        pendingUpdate: subscription?.pending_update,
+      });
+      throw new Error('Invoice not found for subscription plan change. Please try again.');
+    }
 
     const result = request?.context?.store?.result || [];
     result.push({
@@ -133,10 +232,22 @@ export default {
 
     const requiredStake = !subscription!.billing_thresholds?.no_stake;
 
+    // Check if we have a valid existing stake (which means no new staking claim was requested)
+    let hasValidExistingStake = false;
+    if (requiredStake && paymentMethod.type === 'arcblock') {
+      const existingStakeAddress = subscription?.payment_details?.arcblock?.staking?.address;
+      if (existingStakeAddress) {
+        const stakeCheck = await checkRemainingStake(paymentMethod, paymentCurrency, existingStakeAddress, '1');
+        hasValidExistingStake = stakeCheck.enough;
+      }
+    }
+
     // 判断是否为最后一步
+    // Final step if: we have a staking claim, OR stake is not required, OR we're reusing existing stake
     const staking = result.find((x: any) => x.claim?.type === 'prepareTx' && x.claim?.meta?.purpose === 'staking');
     const isFinalStep =
-      (paymentMethod.type === 'arcblock' && (staking || !requiredStake)) || paymentMethod.type !== 'arcblock';
+      (paymentMethod.type === 'arcblock' && (staking || !requiredStake || hasValidExistingStake)) ||
+      paymentMethod.type !== 'arcblock';
 
     if (!isFinalStep) {
       await updateSession({
@@ -172,13 +283,46 @@ export default {
       await subscription?.update({ payment_details: { [paymentMethod.type]: paymentDetails } });
 
       if (invoice) {
-        if (invoice.status === 'uncollectible') {
-          await invoice.update({ status: 'open' });
+        // Update invoice status and payment_settings before processing
+        const invoiceUpdates: any = {
+          payment_settings: {
+            payment_method_types: [paymentMethod.type],
+            payment_method_options: {
+              [paymentMethod.type]: { payer: userDid },
+            },
+          },
+        };
+        if (invoice.status === 'uncollectible' || invoice.status === 'draft') {
+          invoiceUpdates.status = 'open';
         }
+        await invoice.update(invoiceUpdates);
+        logger.info('Change plan: invoice updated before queue processing', {
+          invoiceId: invoice.id,
+          status: invoiceUpdates.status || invoice.status,
+          paymentMethodType: paymentMethod.type,
+        });
+
         await invoiceQueue.pushAndWait({
           id: invoice.id,
           job: { invoiceId: invoice.id, retryOnError: false, waitForPayment: true },
         });
+
+        // Reload invoice to check processing result
+        await invoice.reload();
+        logger.info('Change plan: invoice queue processing completed', {
+          invoiceId: invoice.id,
+          status: invoice.status,
+          paymentIntentId: invoice.payment_intent_id,
+          paid: invoice.paid,
+        });
+
+        if (!invoice.payment_intent_id && invoice.amount_remaining !== '0') {
+          logger.error('Change plan: invoice processed but no paymentIntent created', {
+            invoiceId: invoice.id,
+            status: invoice.status,
+            amountRemaining: invoice.amount_remaining,
+          });
+        }
       }
       if (subscription) {
         await onSubscriptionUpdateConnected(subscriptionId);

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

@@ -22,13 +22,16 @@ export default {
   authPrincipal: false,
   claims: {
     authPrincipal: async ({ extraParams }: CallbackArgs) => {
-      const { paymentMethod } = await ensureInvoiceForCollect(extraParams.invoiceId);
+      const { allowCreatePI } = extraParams;
+      const { paymentMethod } = await ensureInvoiceForCollect(extraParams.invoiceId, { allowCreatePI });
       return getAuthPrincipalClaim(paymentMethod, 'pay');
     },
   },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
-    const { invoiceId, action } = extraParams;
-    const { invoice, paymentIntent, paymentCurrency, paymentMethod } = await ensureInvoiceForCollect(invoiceId);
+    const { invoiceId, action, allowCreatePI } = extraParams;
+    const { invoice, paymentIntent, paymentCurrency, paymentMethod } = await ensureInvoiceForCollect(invoiceId, {
+      allowCreatePI,
+    });
 
     if (paymentMethod.type === 'arcblock') {
       const tokens = [{ address: paymentCurrency.contract as string, value: invoice.amount_due }];
@@ -69,6 +72,7 @@ export default {
           paymentMethod,
           items,
           requiredStake: false,
+          slippageConfig: subscription?.slippage_config || undefined,
         });
       }
 
@@ -100,9 +104,8 @@ export default {
     throw new Error(`Payment method ${paymentMethod.type} not supported`);
   },
   onAuth: async ({ request, userDid, claims, extraParams }: CallbackArgs) => {
-    const { invoiceId } = extraParams;
-    const { invoice, paymentIntent, paymentMethod } = await ensureInvoiceForCollect(invoiceId);
-
+    const { invoiceId, allowCreatePI } = extraParams;
+    const { invoice, paymentIntent, paymentMethod } = await ensureInvoiceForCollect(invoiceId, { allowCreatePI });
     const afterTxExecution = async (paymentDetails: any) => {
       await paymentIntent.update({
         status: 'succeeded',

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

@@ -43,6 +43,7 @@ export default {
           billingThreshold,
           items: subscription!.items as TLineItemExpanded[],
           requiredStake: false,
+          slippageConfig: subscription?.slippage_config || undefined,
         }),
       ],
     };

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

@@ -13,6 +13,7 @@ import { handlePaymentSucceed } from '../../queues/payment';
 import { ensureInvoiceForCheckout, ensurePaymentIntent, getAuthPrincipalClaim } from './shared';
 import { EVMChainType } from '../../store/models';
 import { EVM_CHAIN_TYPES } from '../../libs/constants';
+import { validateQuoteForPayment, handleExpiredQuotePayment } from '../../libs/quote-validation';
 
 export default {
   action: 'payment',
@@ -98,6 +99,31 @@ export default {
 
     await ensureInvoiceForCheckout({ checkoutSession, customer, paymentIntent });
 
+    const preQuoteValidation = await validateQuoteForPayment({
+      checkoutSessionId: checkoutSession?.id,
+      invoiceId: paymentIntent.invoice_id,
+      amount: paymentIntent.amount,
+    });
+
+    if (!preQuoteValidation.valid) {
+      const errorCode =
+        preQuoteValidation.action === 'require_manual_review' ? 'quote_expired' : 'quote_validation_failed';
+      logger.error('Payment blocked due to quote validation before submit', {
+        paymentIntentId: paymentIntent.id,
+        quoteId: preQuoteValidation.quoteId,
+        reason: preQuoteValidation.reason,
+      });
+      await paymentIntent.update({
+        status: 'requires_action',
+        last_payment_error: {
+          type: 'validation_error',
+          code: errorCode,
+          message: preQuoteValidation.reason || 'Quote validation failed',
+        },
+      });
+      throw new Error(`Payment validation failed: ${preQuoteValidation.reason}`);
+    }
+
     if (paymentMethod.type === 'arcblock') {
       try {
         await paymentIntent.update({ status: 'processing' });
@@ -118,6 +144,72 @@ export default {
           await getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
         );
 
+        const quoteValidation = await validateQuoteForPayment({
+          checkoutSessionId: checkoutSession?.id,
+          invoiceId: paymentIntent.invoice_id,
+          amount: paymentIntent.amount,
+        });
+
+        if (!quoteValidation.valid) {
+          if (quoteValidation.action === 'reject') {
+            // Reject the payment - mark as failed
+            logger.error('Payment rejected due to quote validation', {
+              paymentIntentId: paymentIntent.id,
+              quoteId: quoteValidation.quoteId,
+              reason: quoteValidation.reason,
+              txHash,
+            });
+            await paymentIntent.update({
+              status: 'requires_action',
+              last_payment_error: {
+                type: 'validation_error',
+                code: 'quote_validation_failed',
+                message: quoteValidation.reason || 'Quote validation failed',
+              },
+            });
+            throw new Error(`Payment validation failed: ${quoteValidation.reason}`);
+          }
+
+          if (quoteValidation.action === 'require_manual_review') {
+            // Hold for manual review
+            logger.error('Payment requires manual review due to expired quote', {
+              paymentIntentId: paymentIntent.id,
+              quoteId: quoteValidation.quoteId,
+              reason: quoteValidation.reason,
+              txHash,
+            });
+
+            await handleExpiredQuotePayment({
+              quoteId: quoteValidation.quoteId!,
+              checkoutSessionId: checkoutSession?.id,
+              invoiceId: paymentIntent.invoice_id,
+              paymentIntentId: paymentIntent.id,
+              amount: paymentIntent.amount,
+              currencyId: paymentIntent.currency_id,
+              txHash,
+            });
+
+            await paymentIntent.update({
+              status: 'requires_action',
+              last_payment_error: {
+                type: 'validation_error',
+                code: 'quote_expired',
+                message: quoteValidation.reason || 'Quote expired - manual review required',
+              },
+              metadata: {
+                ...paymentIntent.metadata,
+                quote_validation: {
+                  status: 'expired',
+                  quoteId: quoteValidation.quoteId,
+                  reason: quoteValidation.reason,
+                  held_for_review: true,
+                },
+              },
+            });
+            throw new Error(`Payment held for manual review: ${quoteValidation.reason}`);
+          }
+        }
+
         await paymentIntent.update({
           status: 'succeeded',
           amount_received: paymentIntent.amount,
@@ -153,6 +245,71 @@ export default {
           paymentMethod.confirmation.block
         )
           .then(async () => {
+            const quoteValidation = await validateQuoteForPayment({
+              checkoutSessionId: checkoutSession?.id,
+              invoiceId: paymentIntent.invoice_id,
+            });
+
+            if (!quoteValidation.valid) {
+              if (quoteValidation.action === 'reject') {
+                // Reject the payment - mark as failed
+                logger.error('Payment rejected due to quote validation', {
+                  paymentIntentId: paymentIntent.id,
+                  quoteId: quoteValidation.quoteId,
+                  reason: quoteValidation.reason,
+                  txHash: paymentDetails.tx_hash,
+                });
+                await paymentIntent.update({
+                  status: 'requires_action',
+                  last_payment_error: {
+                    type: 'validation_error',
+                    code: 'quote_validation_failed',
+                    message: quoteValidation.reason || 'Quote validation failed',
+                  },
+                });
+                return;
+              }
+
+              if (quoteValidation.action === 'require_manual_review') {
+                // Hold for manual review
+                logger.error('Payment requires manual review due to expired quote', {
+                  paymentIntentId: paymentIntent.id,
+                  quoteId: quoteValidation.quoteId,
+                  reason: quoteValidation.reason,
+                  txHash: paymentDetails.tx_hash,
+                });
+
+                await handleExpiredQuotePayment({
+                  quoteId: quoteValidation.quoteId!,
+                  checkoutSessionId: checkoutSession?.id,
+                  invoiceId: paymentIntent.invoice_id,
+                  paymentIntentId: paymentIntent.id,
+                  amount: paymentIntent.amount,
+                  currencyId: paymentIntent.currency_id,
+                  txHash: paymentDetails.tx_hash,
+                });
+
+                await paymentIntent.update({
+                  status: 'requires_action',
+                  last_payment_error: {
+                    type: 'validation_error',
+                    code: 'quote_expired',
+                    message: quoteValidation.reason || 'Quote expired - manual review required',
+                  },
+                  metadata: {
+                    ...paymentIntent.metadata,
+                    quote_validation: {
+                      status: 'expired',
+                      quoteId: quoteValidation.quoteId,
+                      reason: quoteValidation.reason,
+                      held_for_review: true,
+                    },
+                  },
+                });
+                return;
+              }
+            }
+
             await paymentIntent.update({
               status: 'succeeded',
               amount_received: paymentIntent.amount,