payment-kit 1.15.33 → 1.15.34

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

@@ -1021,7 +1021,8 @@ export async function executeOcapTransactions(
   claims: any[],
   paymentMethod: PaymentMethod,
   request: Request,
-  subscriptionId?: string
+  subscriptionId?: string,
+  paymentCurrencyContract?: string
 ) {
   const client = paymentMethod.getOcapClient();
   const delegation = claims.find((x) => x.type === 'signature' && x.meta?.purpose === 'delegation');
@@ -1031,6 +1032,9 @@ export async function executeOcapTransactions(
     [staking, 'Stake'],
   ];
 
+  const stakingAmount =
+    staking?.requirement?.tokens?.find((x: any) => x.address === paymentCurrencyContract)?.value || '0';
+
   const [delegationTxHash, stakingTxHash] = await Promise.all(
     transactions.map(async ([claim, type]) => {
       if (!claim) {
@@ -1065,5 +1069,135 @@ export async function executeOcapTransactions(
       tx_hash: stakingTxHash,
       address: await getCustomerStakeAddress(userDid, nonce),
     },
+    stakingAmount,
   };
 }
+
+export async function ensureStakeInvoice(
+  invoiceProps: { total: string; description?: string; checkout_session_id?: string; currency_id: string; metadata?: any; payment_settings?: any },
+  subscription: Subscription,
+  paymentMethod: PaymentMethod,
+  customer: Customer
+) {
+  if (paymentMethod.type !== 'arcblock') {
+    return;
+  }
+  try {
+    const stakingInvoice = await Invoice.create({
+      livemode: subscription.livemode,
+      number: await customer.getInvoiceNumber(),
+      description: invoiceProps?.description || 'Stake for subscription',
+      statement_descriptor: '',
+      period_start: dayjs().unix(),
+      period_end: subscription.current_period_end,
+
+      auto_advance: false,
+      paid: true,
+      paid_out_of_band: false,
+
+      status: 'paid',
+      collection_method: 'charge_automatically',
+      billing_reason: 'stake',
+
+      currency_id: invoiceProps.currency_id,
+      customer_id: customer.id,
+      payment_intent_id: '',
+      subscription_id: subscription?.id,
+      checkout_session_id: invoiceProps?.checkout_session_id || '',
+
+      total: invoiceProps.total || '0',
+      subtotal: invoiceProps.total || '0',
+      tax: '0',
+      subtotal_excluding_tax: invoiceProps.total || '0',
+
+      amount_due: '0',
+      amount_paid: invoiceProps.total || '0',
+      amount_remaining: '0',
+      amount_shipping: '0',
+
+      starting_balance: '0',
+      ending_balance: '0',
+      starting_token_balance: {},
+      ending_token_balance: {},
+
+      attempt_count: 0,
+      attempted: false,
+      // next_payment_attempt: undefined,
+
+      custom_fields: [],
+      customer_address: customer.address,
+      customer_email: customer.email,
+      customer_name: customer.name,
+      customer_phone: customer.phone,
+
+      discounts: [],
+      total_discount_amounts: [],
+
+      due_date: undefined,
+      effective_at: dayjs().unix(), 
+      status_transitions: {
+        finalized_at: dayjs().unix(),
+      },
+
+      payment_settings: invoiceProps?.payment_settings || subscription?.payment_settings,
+      default_payment_method_id: paymentMethod.id,
+
+      account_country: '',
+      account_name: '',
+      metadata: invoiceProps.metadata || {},
+    });
+    logger.info('create staking invoice success', {
+      stakingInvoice,
+      subscriptionId: subscription?.id,
+      paymentMethod: paymentMethod.id,
+      customerId: customer.id,
+    });
+  } catch (error) {
+    logger.error('ensureStake: create invoice failed', { error, subscriptionId: subscription?.id, paymentMethod: paymentMethod.id, customerId: customer.id });
+  }
+}
+
+
+export async function updateStripeSubscriptionAfterChangePayment(setupIntent: SetupIntent, subscription: Subscription) {
+  const { from_method: fromMethodId, to_method: toMethodId } = setupIntent.metadata || {};
+  const fromMethod = await PaymentMethod.findByPk(fromMethodId);
+  if (fromMethod?.type === 'stripe') {
+    // pause Stripe
+    const client = fromMethod?.getStripeClient();
+    const stripeSubscriptionId = subscription.payment_details?.stripe?.subscription_id as string;
+    if (client && stripeSubscriptionId) {
+      const stripeSubscription = await client.subscriptions.retrieve(stripeSubscriptionId);
+      if (stripeSubscription) {
+        const result = await client.subscriptions.update(stripeSubscriptionId, {
+          pause_collection: {
+            behavior: 'void',
+          },
+        });
+        logger.info('stripe subscription paused on payment change', {
+          subscription: subscription.id,
+          stripeSubscription: stripeSubscriptionId,
+          result,
+        });
+      }
+    }
+  } else {
+    const toMethod = await PaymentMethod.findByPk(toMethodId);
+    if (toMethod?.type === 'stripe') {
+      // resume stripe
+      const client =  toMethod?.getStripeClient();
+      const stripeSubscriptionId = subscription.payment_details?.stripe?.subscription_id as string;
+      if (client && stripeSubscriptionId) {
+        const stripeSubscription = await client.subscriptions.retrieve(stripeSubscriptionId);
+        if (stripeSubscription.status === 'paused') {
+          await client.subscriptions.resume(stripeSubscriptionId, {
+            proration_behavior: 'none',
+          });
+          logger.info('stripe subscription resumed on payment change', {
+            subscription: subscription.id,
+            stripeSubscription: stripeSubscriptionId,
+          });
+        }
+      }
+    }
+  }
+}

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

@@ -12,6 +12,7 @@ import type { Invoice, TLineItemExpanded } from '../../store/models';
 import {
   ensureInvoiceForCheckout,
   ensurePaymentIntent,
+  ensureStakeInvoice,
   executeOcapTransactions,
   getAuthPrincipalClaim,
   getDelegationTxClaim,
@@ -122,7 +123,7 @@ export default {
   onAuth: async (args: CallbackArgs) => {
     const { request, userDid, userPk, claims, extraParams } = args;
     const { checkoutSessionId, connectedDid } = extraParams;
-    const { checkoutSession, customer, paymentMethod, subscription } = await ensurePaymentIntent(
+    const { checkoutSession, customer, paymentMethod, subscription, paymentCurrency } = await ensurePaymentIntent(
       checkoutSessionId,
       connectedDid || userDid
     );
@@ -159,13 +160,34 @@ export default {
       await prepareTxExecution();
       const { invoice } = await ensureInvoiceForCheckout({ checkoutSession, customer, subscription });
 
-      const paymentDetails = await executeOcapTransactions(
+      const { stakingAmount, ...paymentDetails } = await executeOcapTransactions(
         userDid,
         userPk,
         claims,
         paymentMethod,
         request,
-        subscription?.id
+        subscription?.id,
+        paymentCurrency?.contract
+      );
+      await ensureStakeInvoice(
+        {
+          total: stakingAmount,
+          description: 'Stake for subscription',
+          checkout_session_id: checkoutSessionId,
+          currency_id: paymentCurrency.id,
+          metadata: {
+            payment_details: {
+              arcblock: {
+                tx_hash: paymentDetails?.staking?.tx_hash,
+                payer: paymentDetails?.payer,
+                address: paymentDetails?.staking?.address,
+              },
+            },
+          },
+        },
+        subscription,
+        paymentMethod,
+        customer
       );
       await afterTxExecution(invoice!, paymentDetails);
 

package/api/src/routes/invoices.ts

@@ -10,7 +10,6 @@ import { createListParamSchema, getWhereFromKvQuery, MetadataSchema } from '../l
 import { authenticate } from '../libs/security';
 import { expandLineItems } from '../libs/session';
 import { formatMetadata } from '../libs/util';
-import { Refund, SetupIntent } from '../store/models';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
 import { InvoiceItem } from '../store/models/invoice-item';
@@ -20,7 +19,7 @@ import { PaymentMethod } from '../store/models/payment-method';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
 import { Subscription } from '../store/models/subscription';
-import { getSubscriptionStakeAmountSetup } from '../libs/subscription';
+import { getReturnStakeInvoices, getStakingInvoices } from '../libs/invoice';
 
 const router = Router();
 const authAdmin = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
@@ -43,6 +42,7 @@ const schema = createListParamSchema<{
   currency_id?: string;
   ignore_zero?: boolean;
   include_staking?: boolean;
+  include_return_staking?: boolean;
   include_recovered_from?: boolean;
 }>({
   status: Joi.string().empty(''),
@@ -52,17 +52,16 @@ const schema = createListParamSchema<{
   currency_id: Joi.string().empty(''),
   ignore_zero: Joi.boolean().empty(false),
   include_staking: Joi.boolean().empty(false),
+  include_return_staking: Joi.boolean().empty(false),
   include_recovered_from: Joi.boolean().empty(false),
 });
 router.get('/', authMine, async (req, res) => {
   // eslint-disable-next-line @typescript-eslint/naming-convention
-  const { page, pageSize, livemode, status, ignore_zero, include_staking, ...query } = await schema.validateAsync(
-    req.query,
-    {
+  const { page, pageSize, livemode, status, ignore_zero, include_staking, include_return_staking, ...query } =
+    await schema.validateAsync(req.query, {
       stripUnknown: false,
       allowUnknown: true,
-    }
-  );
+    });
   const where = getWhereFromKvQuery(query.q);
 
   if (status) {
@@ -108,7 +107,9 @@ router.get('/', authMine, async (req, res) => {
       // @ts-ignore
       where[key] = query[key];
     });
-
+  if (!!(include_staking && query.subscription_id) || !include_staking) {
+    where.billing_reason = { [Op.ne]: 'stake' };
+  }
   try {
     const { rows: list, count } = await Invoice.findAndCountAll({
       where,
@@ -117,7 +118,7 @@ router.get('/', authMine, async (req, res) => {
       limit: pageSize,
       include: [
         { model: PaymentCurrency, as: 'paymentCurrency' },
-        // { model: PaymentMethod, as: 'paymentMethod' },
+        { model: PaymentMethod, as: 'paymentMethod' },
         // { model: PaymentIntent, as: 'paymentIntent' },
         // { model: Subscription, as: 'subscription' },
         { model: Customer, as: 'customer' },
@@ -126,113 +127,30 @@ router.get('/', authMine, async (req, res) => {
 
     // push staking info as first invoice if we are on the last page
     let subscription;
+    let invoices = list;
     if (query.subscription_id && include_staking && page === Math.ceil((count || 1) / pageSize)) {
       try {
         subscription = await Subscription.findByPk(query.subscription_id);
         if (subscription?.payment_details?.arcblock?.staking?.tx_hash) {
-          const method = await PaymentMethod.findOne({ where: { type: 'arcblock', livemode: subscription.livemode } });
-          const setup = await SetupIntent.findOne({
-            where: {
-              customer_id: subscription.customer_id,
-              payment_method_id: method?.id,
-              metadata: { subscription_id: subscription.id },
-            },
-            order: [['created_at', 'ASC']],
-          });
-          const currencyId = setup?.currency_id || subscription.currency_id;
-          const currency = await PaymentCurrency.findByPk(currencyId);
-          if (method && currency) {
-            const { address } = subscription.payment_details.arcblock.staking;
-            const firstInvoice = await Invoice.findOne({
-              where: { subscription_id: subscription.id, currency_id: currencyId },
-              order: [['created_at', 'ASC']],
-              include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
-            });
-            if (firstInvoice) {
-              const customer = await Customer.findByPk(firstInvoice.customer_id);
-              const stakeAmountResult = await getSubscriptionStakeAmountSetup(subscription, method);
-              // @ts-ignore
-              const stakeAmount = stakeAmountResult?.[currency?.contract] || '0';
-
-              list.push({
-                id: address as string,
-                status: 'paid',
-                description: 'Subscription staking',
-                billing_reason: 'subscription_create',
-                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: method,
-                customer,
-                metadata: {
-                  payment_details: {
-                    arcblock: {
-                      tx_hash: subscription.payment_details.arcblock.staking.tx_hash,
-                      payer: subscription.payment_details.arcblock.payer,
-                    },
-                  },
-                },
-              });
-              const stakeRefundRecord = await Refund.findOne({
-                where: { subscription_id: subscription.id, status: 'succeeded', type: 'stake_return' },
-              });
-              if (stakeRefundRecord) {
-                list.unshift({
-                  id: address as string,
-                  status: 'paid',
-                  description: 'Return Subscription staking',
-                  billing_reason: 'subscription_create',
-                  total: stakeRefundRecord.amount,
-                  amount_due: '0',
-                  amount_paid: stakeRefundRecord.amount,
-                  amount_remaining: '0',
-                  created_at: stakeRefundRecord.created_at,
-                  updated_at: stakeRefundRecord.updated_at,
-                  currency_id: stakeRefundRecord.currency_id,
-                  customer_id: stakeRefundRecord.customer_id,
-                  subscription_id: subscription.id,
-                  period_start: subscription.current_period_start,
-                  period_end: subscription.current_period_end,
-                  paid: true,
-                  ...pick(firstInvoice, ['number', 'auto_advance']),
-                  // @ts-ignore
-                  paymentCurrency: currency,
-                  paymentMethod: method,
-                  customer,
-                  metadata: {
-                    payment_details: {
-                      arcblock: {
-                        tx_hash: stakeRefundRecord?.payment_details?.arcblock?.tx_hash,
-                        payer: stakeRefundRecord?.payment_details?.arcblock?.payer,
-                      },
-                    },
-                  },
-                });
-              }
-            }
+          const stakingInvoices = await getStakingInvoices(subscription);
+          let returnStakeInvoices: any[] = [];
+          if (include_return_staking) {
+            returnStakeInvoices = await getReturnStakeInvoices(subscription);
           }
+          invoices = [...(stakingInvoices || []), ...(returnStakeInvoices || []), ...list]
+            .filter(Boolean)
+            .sort((a, b) =>
+              query.o === 'asc'
+                ? new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
+                : new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
+            );
         }
       } catch (err) {
         console.error('Failed to include staking record in invoice list', err);
       }
     }
 
-    res.json({ count, list, subscription, paging: { page, pageSize } });
+    res.json({ count, list: invoices, subscription, paging: { page, pageSize } });
   } catch (err) {
     console.error(err);
     res.json({ count: 0, list: [], paging: { page, pageSize } });

package/api/src/routes/subscriptions.ts

@@ -8,7 +8,12 @@ import uniq from 'lodash/uniq';
 
 import { literal, OrderItem } from 'sequelize';
 import { createEvent } from '../libs/audit';
-import { ensureStripeCustomer, ensureStripePrice, ensureStripeSubscription } from '../integrations/stripe/resource';
+import {
+  ensureStripeCustomer,
+  ensureStripePaymentCustomer,
+  ensureStripePrice,
+  ensureStripeSubscription,
+} from '../integrations/stripe/resource';
 import { createListParamSchema, getWhereFromKvQuery, getWhereFromQuery, MetadataSchema } from '../libs/api';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
@@ -258,7 +263,8 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
     return res.status(400).json({ error: `comment invalid: ${commentError.message}` });
   }
 
-  const slashStake = req.body?.requestByAdmin && req.body?.staking === 'slash';
+  const requestByAdmin = ['owner', 'admin'].includes(req.user?.role as string);
+  const slashStake = requestByAdmin && req.body?.staking === 'slash';
 
   if (slashStake) {
     const { error: slashReasonError } = SlashStakeSchema.validate(req.body?.slashReason);
@@ -292,7 +298,6 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
   }
 
   let canReturnStake = false;
-  const requestByAdmin = ['owner', 'admin'].includes(req.user?.role as string);
   if ((requestByAdmin && staking === 'proration') || req.body?.cancel_from === 'customer') {
     canReturnStake = true;
   }
@@ -680,11 +685,11 @@ const updateSchema = Joi.object<{
     .items(
       Joi.object({
         name: Joi.string().optional(),
-        color: Joi.string().allow('primary', 'secondary', 'success', 'error', 'warning').optional(),
-        variant: Joi.string().allow('text', 'contained', 'outlined').optional(),
+        color: Joi.string().valid('primary', 'secondary', 'success', 'error', 'warning').optional(),
+        variant: Joi.string().valid('text', 'contained', 'outlined').optional(),
         text: Joi.object().required(),
         link: Joi.string().uri().required(),
-        type: Joi.string().allow('notification', 'custom').optional(),
+        type: Joi.string().valid('notification', 'custom').optional(),
         triggerEvents: Joi.array().items(Joi.string()).optional(),
       })
     )
@@ -1263,11 +1268,6 @@ router.get('/:id/proration', authPortal, async (req, res) => {
       return res.status(400).json({ error: 'Subscription is not active' });
     }
 
-    const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
-    if (paymentMethod?.type === 'stripe') {
-      return res.status(400).json({ error: 'Not supported for subscriptions paid with stripe' });
-    }
-
     const invoice = await Invoice.findOne({
       where: {
         subscription_id: subscription.id,
@@ -1278,16 +1278,23 @@ router.get('/:id/proration', authPortal, async (req, res) => {
     });
 
     const anchor = req.query.time ? dayjs(req.query.time as any).unix() : dayjs().unix();
-    const result = await getSubscriptionRefundSetup(subscription, anchor);
+    const result = await getSubscriptionRefundSetup(subscription, anchor, invoice?.currency_id);
     if (result.total === '0') {
       return res.json(null);
     }
+    const paymentCurrency = await PaymentCurrency.findByPk(result.lastInvoice?.currency_id);
+    const paymentMethod = await PaymentMethod.findByPk(paymentCurrency?.payment_method_id);
+    if (paymentMethod?.type === 'stripe') {
+      return res.status(400).json({ error: 'Not supported for subscriptions paid with stripe' });
+    }
+
     return res.json({
       total: result.total,
       latest: invoice?.total,
       unused: result.unused,
       used: result.used,
       prorations: result.prorations,
+      paymentCurrency,
     });
   } catch (err) {
     console.error(err);
@@ -1418,6 +1425,8 @@ router.post('/:id/change-payment', authPortal, async (req, res) => {
           to_currency: paymentCurrency.id,
           from_method: subscription.default_payment_method_id,
           to_method: paymentMethod.id,
+          // @ts-ignore
+          from_payment_details: subscription.payment_details?.[previousPaymentMethod?.type],
         },
       });
 
@@ -1444,9 +1453,32 @@ router.post('/:id/change-payment', authPortal, async (req, res) => {
       const client = paymentMethod.getStripeClient();
       let exist;
       if (subscription.payment_details?.stripe?.subscription_id) {
-        exist = await client.subscriptions.retrieve(subscription.payment_details.stripe.subscription_id);
+        exist = await client.subscriptions.retrieve(subscription.payment_details.stripe.subscription_id, {
+          expand: ['latest_invoice.payment_intent', 'pending_setup_intent'],
+        });
       }
       if (exist) {
+        if (!exist.default_payment_method) {
+          const settings = PaymentMethod.decryptSettings(paymentMethod.settings);
+          stripeContext = {
+            type: 'subscription',
+            id: exist.id,
+            client_secret:
+              // @ts-ignore
+              exist.latest_invoice?.payment_intent?.client_secret || exist.pending_setup_intent?.client_secret,
+            // @ts-ignore
+            intent_type: exist.latest_invoice?.payment_intent ? 'payment_intent' : 'setup_intent',
+            publishable_key: settings.stripe?.publishable_key,
+            status: exist.status,
+          };
+          return res.json({
+            setupIntent,
+            stripeContext,
+            subscription,
+            customer,
+            delegation,
+          });
+        }
         if (exist.status === 'paused') {
           await client.subscriptions.resume(exist.id, {
             proration_behavior: 'none',
@@ -1457,6 +1489,7 @@ router.post('/:id/change-payment', authPortal, async (req, res) => {
           proration_behavior: 'none',
           pause_collection: '',
         });
+        await Lock.acquire(`${subscription.id}-change-plan`, subscription.current_period_end);
         logger.info('stripe subscription updated on subscription payment change', {
           subscription: subscription.id,
           intent: setupIntent.id,
@@ -1480,6 +1513,7 @@ router.post('/:id/change-payment', authPortal, async (req, res) => {
         const settings = PaymentMethod.decryptSettings(paymentMethod.settings);
 
         // changing from crypto to stripe: create/resume stripe subscription, pause crypto subscription
+        const stripeCustomer = await ensureStripePaymentCustomer(subscription, paymentMethod);
         const stripeSubscription = await ensureStripeSubscription(
           subscription,
           paymentMethod,
@@ -1488,7 +1522,18 @@ router.post('/:id/change-payment', authPortal, async (req, res) => {
           0,
           subscription.current_period_end
         );
-
+        if (stripeSubscription) {
+          await subscription.update({
+            payment_details: {
+              ...subscription.payment_details,
+              stripe: {
+                customer_id: stripeCustomer.id,
+                subscription_id: stripeSubscription.id,
+                setup_intent_id: stripeSubscription.pending_setup_intent?.id,
+              },
+            },
+          });
+        }
         stripeContext = {
           type: 'subscription',
           id: stripeSubscription.id,
@@ -1500,7 +1545,6 @@ router.post('/:id/change-payment', authPortal, async (req, res) => {
           publishable_key: settings.stripe?.publishable_key,
           status: stripeSubscription.status,
         };
-
         await setupIntent.update({
           setup_details: {
             stripe: {
@@ -1519,6 +1563,10 @@ router.post('/:id/change-payment', authPortal, async (req, res) => {
         userDid: customer!.did,
         amount: getFastCheckoutAmount(lineItems, 'subscription', paymentCurrency.id, false),
       });
+      if (paymentMethod.type === 'arcblock' && delegation.sufficient) {
+        delegation.sufficient = false;
+        delegation.reason = 'NO_ENOUGH_TOKEN';
+      }
       if (delegation.sufficient) {
         await setupIntent.update({
           status: 'succeeded',
@@ -1541,7 +1589,7 @@ router.post('/:id/change-payment', authPortal, async (req, res) => {
 
       // NOTE: this should only happen when local subscription is updated
       // changing from stripe to crypto: pause stripe subscription
-      if (previousPaymentMethod!.type === 'stripe') {
+      if (previousPaymentMethod!.type === 'stripe' && setupIntent.status === 'succeeded') {
         const client = await previousPaymentMethod?.getStripeClient();
         const stripeSubscriptionId = subscription.payment_details?.stripe?.subscription_id as string;
         const result = await client?.subscriptions.update(stripeSubscriptionId, {
@@ -1569,7 +1617,6 @@ router.post('/:id/change-payment', authPortal, async (req, res) => {
     return res.status(500).json({ code: err.code, error: err.message });
   }
 });
-
 // FIXME: this should be removed in future
 // Clean up subscriptions that have invalid invoices and payments
 router.delete('/cleanup', auth, async (req, res) => {
@@ -1767,4 +1814,6 @@ router.get('/:id/payer-token', authMine, async (req, res) => {
   const token = await getTokenByAddress(paymentAddress, paymentMethod, paymentCurrency);
   return res.json({ token, paymentAddress });
 });
+
+router.get('/:id/change-plan');
 export default router;

package/api/src/store/models/invoice.ts

@@ -59,7 +59,8 @@ export class Invoice extends Model<InferAttributes<Invoice>, InferCreationAttrib
     | 'subscription'
     | 'manual'
     | 'upcoming'
-    | 'slash_stake',
+    | 'slash_stake'
+    | 'stake',
     string
   >;
 

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.15.33
+version: 1.15.34
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.15.33",
+  "version": "1.15.34",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -53,7 +53,7 @@
     "@arcblock/validator": "^1.18.139",
     "@blocklet/js-sdk": "1.16.33-beta-20241031-073543-49b1ff9b",
     "@blocklet/logger": "1.16.33-beta-20241031-073543-49b1ff9b",
-    "@blocklet/payment-react": "1.15.33",
+    "@blocklet/payment-react": "1.15.34",
     "@blocklet/sdk": "1.16.33-beta-20241031-073543-49b1ff9b",
     "@blocklet/ui-react": "^2.10.65",
     "@blocklet/uploader": "^0.1.51",
@@ -120,7 +120,7 @@
   "devDependencies": {
     "@abtnode/types": "1.16.33-beta-20241031-073543-49b1ff9b",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.15.33",
+    "@blocklet/payment-types": "1.15.34",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -165,5 +165,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "88e0986e379d9ed673435ea96305f16b4a54097e"
+  "gitHead": "95c0d3ddd12382f694014c05015ca46c19424e3e"
 }