payment-kit 1.13.174 → 1.13.176

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

@@ -1,22 +1,26 @@
 /* eslint-disable @typescript-eslint/indent */
 /* eslint-disable prettier/prettier */
 import { toTypeInfo } from '@arcblock/did';
-import { toDelegateAddress } from '@arcblock/did-util';
-import { BN } from '@ocap/util';
+import { toDelegateAddress, toStakeAddress } from '@arcblock/did-util';
+import type { Transaction } from '@ocap/client';
+import { BN, fromTokenToUnit } from '@ocap/util';
 import { fromPublicKey } from '@ocap/wallet';
 import isEmpty from 'lodash/isEmpty';
 
 import { estimateMaxGasForTx, hasStakedForGas } from '../../integrations/blockchain/stake';
 import { blocklet, wallet } from '../../libs/auth';
 import dayjs from '../../libs/dayjs';
+import env from '../../libs/env';
 import logger from '../../libs/logger';
-import { getTokenLimitsForDelegation } from '../../libs/payment';
+import { getGasPayerExtra, getTokenLimitsForDelegation } from '../../libs/payment';
+import { getFastCheckoutAmount, getPriceUintAmountByCurrency, getStatementDescriptor } from '../../libs/session';
 import {
-  getFastCheckoutAmount,
-  getPriceUintAmountByCurrency,
-  getStatementDescriptor,
-} from '../../libs/session';
-import { expandSubscriptionItems, getSubscriptionItemPrice } from '../../libs/subscription';
+  expandSubscriptionItems,
+  getSubscriptionCreateSetup,
+  getSubscriptionItemPrice,
+  getSubscriptionStakeSetup,
+} from '../../libs/subscription';
+import { OCAP_PAYMENT_TX_TYPE } from '../../libs/util';
 import type { TLineItemExpanded } from '../../store/models';
 import { CheckoutSession } from '../../store/models/checkout-session';
 import { Customer } from '../../store/models/customer';
@@ -29,7 +33,6 @@ import { Price } from '../../store/models/price';
 import { SetupIntent } from '../../store/models/setup-intent';
 import { Subscription } from '../../store/models/subscription';
 import { SubscriptionItem } from '../../store/models/subscription-item';
-import { OCAP_PAYMENT_TX_TYPE } from '../../libs/util';
 
 type Result = {
   checkoutSession: CheckoutSession;
@@ -589,21 +592,23 @@ export async function getDelegationTxClaim({
   userPk,
   nonce,
   mode,
-  trial,
   data,
   items,
   paymentCurrency,
   paymentMethod,
+  trialInDays = 0,
+  billingThreshold = 0,
 }: {
   userDid: string;
   userPk: string;
   nonce: string;
-  mode: string;
-  trial: boolean;
+    mode: string;
   data: any;
   items: TLineItemExpanded[];
   paymentCurrency: PaymentCurrency;
   paymentMethod: PaymentMethod;
+    trialInDays: number;
+    billingThreshold?: number;
 }) {
   const amount = getFastCheckoutAmount(items, mode, paymentCurrency.id);
   const address = toDelegateAddress(userDid, wallet.address);
@@ -611,7 +616,8 @@ export async function getDelegationTxClaim({
   const tokenRequirements = await getTokenRequirements({
     items,
     mode,
-    includeFreeTrial: trial,
+    trialInDays,
+    billingThreshold,
     paymentMethod,
     paymentCurrency,
   });
@@ -637,26 +643,102 @@ export async function getDelegationTxClaim({
       host: paymentMethod.settings?.arcblock?.api_host as string,
       id: paymentMethod.settings?.arcblock?.chain_id as string,
     },
+    meta: {
+      purpose: 'delegation',
+      address,
+    },
+  };
+}
+
+export async function getStakeTxClaim({
+  userDid,
+  userPk,
+  items,
+  subscription,
+  paymentCurrency,
+  paymentMethod,
+}: {
+  userDid: string;
+  userPk: string;
+  subscription: Subscription;
+  items: TLineItemExpanded[];
+  paymentCurrency: PaymentCurrency;
+  paymentMethod: PaymentMethod;
+}) {
+  // create staking amount
+  const billingThreshold = fromTokenToUnit(subscription.billing_thresholds?.amount_gte || 0, paymentCurrency.decimal);
+  const staking = getSubscriptionStakeSetup(items, paymentCurrency.id, billingThreshold.toString());
+  const amount = staking.licensed.add(staking.metered).toString();
+
+  // create staking data
+  const client = paymentMethod.getOcapClient();
+  const address = toStakeAddress(userDid, wallet.address);
+  const { state } = await client.getStakeState({ address });
+  const data = {
+    type: 'json',
+    value: Object.assign(
+      {
+        appId: wallet.address,
+      },
+      JSON.parse(state?.data?.value || '{}'),
+      { [subscription.id]: amount }
+    ),
+  };
+
+  const setup = getSubscriptionCreateSetup(items, paymentCurrency.id, 0, 0);
+
+  return {
+    type: 'StakeTx',
+    description: 'Sign the staking to continue',
+    partialTx: {
+      from: userDid,
+      pk: userPk,
+      itx: {
+        address,
+        receiver: wallet.address,
+        slashers: [wallet.address],
+        revokeWaitingPeriod: setup.cycle.duration / 1000, // wait for at least 1 billing cycle
+        message: `Stake for subscription on ${env.appName}`,
+        inputs: [],
+        data,
+      },
+      signatures: [],
+    },
+    requirement: {
+      tokens: [{ address: paymentCurrency.contract as string, value: amount }],
+    },
+    nonce: `stake-${subscription.id}`,
+    chainInfo: {
+      type: paymentMethod.type,
+      host: paymentMethod.settings?.arcblock?.api_host as string,
+      id: paymentMethod.settings?.arcblock?.chain_id as string,
+    },
+    meta: {
+      purpose: 'staking',
+      address,
+    },
   };
 }
 
 export type TokenRequirementArgs = {
   items: TLineItemExpanded[];
   mode: string;
-  includeFreeTrial: boolean;
   paymentMethod: PaymentMethod;
   paymentCurrency: PaymentCurrency;
+  trialInDays: number;
+  billingThreshold: number;
 };
 
 export async function getTokenRequirements({
   items,
   mode,
-  includeFreeTrial,
   paymentMethod,
   paymentCurrency,
+  trialInDays = 0,
+  billingThreshold = 0,
 }: TokenRequirementArgs) {
   const tokenRequirements = [];
-  let amount = getFastCheckoutAmount(items, mode, paymentCurrency.id, !!includeFreeTrial);
+  let amount = getFastCheckoutAmount(items, mode, paymentCurrency.id, !!trialInDays);
 
   // If the app has not staked, we need to add the gas fee to the amount
   if ((await hasStakedForGas(paymentMethod)) === false) {
@@ -680,10 +762,21 @@ export async function getTokenRequirements({
     tokenRequirements.push({ address: paymentCurrency.contract as string, value: amount });
   }
 
+  // Add stake requirement to token requirement
+  const staking = getSubscriptionStakeSetup(
+    items,
+    paymentCurrency.id,
+    fromTokenToUnit(billingThreshold, paymentCurrency.decimal).toString()
+  );
+  const exist = tokenRequirements.find((x) => x.address === paymentCurrency.contract);
+  if (exist) {
+    exist.value = new BN(exist.value).add(staking.licensed).add(staking.metered).toString();
+  }
+
   return tokenRequirements;
 }
 
-export async function ensureSubscription(subscriptionId: string): Promise<Result> {
+export async function ensureSubscription(subscriptionId: string): Promise<Result & { customer: Customer }> {
   const subscription = await Subscription.findByPk(subscriptionId);
   if (!subscription) {
     throw new Error(`Subscription not found: ${subscriptionId}`);
@@ -722,6 +815,8 @@ export async function ensureSubscription(subscriptionId: string): Promise<Result
     paymentCurrency,
     // @ts-ignore
     invoice,
+    // @ts-ignore
+    customer: await Customer.findByPk(subscription.customer_id),
   };
 }
 
@@ -770,6 +865,7 @@ export async function ensureChangePaymentContext(subscriptionId: string) {
     setupIntent,
     paymentMethod,
     paymentCurrency,
+    customer: await Customer.findByPk(subscription.customer_id),
   };
 }
 
@@ -803,3 +899,52 @@ export async function ensureSubscriptionForCollectBatch(subscriptionId: string,
     invoices: detail[currencyId],
   };
 }
+
+export async function executeOcapTransactions(
+  userDid: string,
+  userPk: string,
+  claims: any[],
+  paymentMethod: PaymentMethod
+) {
+  const client = paymentMethod.getOcapClient();
+  const delegation = claims.find((x) => x.type === 'signature' && x.meta?.purpose === 'delegation');
+  const staking = claims.find((x) => x.type === 'prepareTx' && x.meta?.purpose === 'staking');
+  const transactions = [
+    [delegation, 'Delegate'],
+    [staking, 'Stake'],
+  ];
+
+  const [delegationTxHash, stakingTxHash] = await Promise.all(
+    transactions.map(async ([claim, type]) => {
+      if (!claim) {
+        return '';
+      }
+
+      const tx: Partial<Transaction> = client.decodeTx(claim.finalTx || claim.origin);
+      if (claim.sig) {
+        tx.signature = claim.sig;
+      }
+
+      // @ts-ignore
+      const { buffer } = await client[`encode${type}Tx`]({ tx });
+      // @ts-ignore
+      const txHash = await client[`send${type}Tx`](
+        // @ts-ignore
+        { tx, wallet: fromPublicKey(userPk, toTypeInfo(userDid)) },
+        getGasPayerExtra(buffer)
+      );
+
+      return txHash;
+    })
+  );
+
+  return {
+    tx_hash: delegationTxHash,
+    payer: userDid,
+    type: 'delegate',
+    staking: {
+      tx_hash: stakingTxHash,
+      address: toStakeAddress(userDid, wallet.address),
+    },
+  };
+}

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

@@ -1,15 +1,19 @@
-import { toTypeInfo } from '@arcblock/did';
-import type { Transaction } from '@ocap/client';
-import { BN } from '@ocap/util';
-import { fromPublicKey } from '@ocap/wallet';
-
 import type { CallbackArgs } from '../../libs/auth';
-import { getGasPayerExtra } from '../../libs/payment';
+import logger from '../../libs/logger';
+import { isDelegationSufficientForPayment } from '../../libs/payment';
+import { getFastCheckoutAmount } from '../../libs/session';
 import { getTxMetadata } from '../../libs/util';
 import { invoiceQueue } from '../../queues/invoice';
 import { addSubscriptionJob } from '../../queues/subscription';
 import type { TLineItemExpanded } from '../../store/models';
-import { ensureInvoiceForCheckout, ensurePaymentIntent, getAuthPrincipalClaim, getDelegationTxClaim } from './shared';
+import {
+  ensureInvoiceForCheckout,
+  ensurePaymentIntent,
+  executeOcapTransactions,
+  getAuthPrincipalClaim,
+  getDelegationTxClaim,
+  getStakeTxClaim,
+} from './shared';
 
 export default {
   action: 'subscription',
@@ -22,7 +26,7 @@ export default {
   },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
     const { checkoutSessionId } = extraParams;
-    const { checkoutSession, paymentMethod, paymentCurrency, subscription } = await ensurePaymentIntent(
+    const { checkoutSession, paymentMethod, paymentCurrency, subscription, customer } = await ensurePaymentIntent(
       checkoutSessionId,
       userDid
     );
@@ -31,28 +35,59 @@ export default {
     }
 
     if (paymentMethod.type === 'arcblock') {
+      const claims: { [type: string]: [string, object] } = {};
+
       const items = checkoutSession.line_items as TLineItemExpanded[];
+      const trialInDays = Number(checkoutSession.subscription_data?.trial_period_days || 0);
+      const billingThreshold = Number(checkoutSession.subscription_data?.billing_threshold_amount || 0);
+      const fastCheckoutAmount = getFastCheckoutAmount(items, checkoutSession.mode, paymentCurrency.id, !!trialInDays);
+      const delegation = await isDelegationSufficientForPayment({
+        paymentMethod,
+        paymentCurrency,
+        userDid: customer.did,
+        amount: fastCheckoutAmount,
+      });
+
+      // if we can complete purchase without any wallet interaction
+      if (delegation.sufficient === false) {
+        claims.delegation = [
+          'signature',
+          await getDelegationTxClaim({
+            mode: checkoutSession.mode,
+            userDid,
+            userPk,
+            nonce: checkoutSession.id,
+            data: getTxMetadata({ subscriptionId: subscription.id, checkoutSessionId }),
+            paymentCurrency,
+            paymentMethod,
+            trialInDays,
+            billingThreshold,
+            items,
+          }),
+        ];
+      }
 
-      return {
-        signature: await getDelegationTxClaim({
-          mode: checkoutSession.mode,
+      // we always need to stake for the subscription
+      claims.staking = [
+        'prepareTx',
+        await getStakeTxClaim({
           userDid,
           userPk,
-          nonce: checkoutSession.id,
-          data: getTxMetadata({ subscriptionId: subscription.id, checkoutSessionId }),
           paymentCurrency,
           paymentMethod,
-          trial: !!checkoutSession.subscription_data?.trial_period_days,
           items,
+          subscription,
         }),
-      };
+      ];
+
+      return claims;
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);
   },
   onAuth: async ({ userDid, userPk, claims, extraParams }: CallbackArgs) => {
     const { checkoutSessionId } = extraParams;
-    const { checkoutSession, customer, paymentMethod, paymentCurrency, subscription } = await ensurePaymentIntent(
+    const { checkoutSession, customer, paymentMethod, subscription } = await ensurePaymentIntent(
       checkoutSessionId,
       userDid
     );
@@ -61,17 +96,6 @@ export default {
       throw new Error('Subscription for checkoutSession not found');
     }
 
-    if (checkoutSession.amount_total > '0') {
-      const client = paymentMethod.getOcapClient();
-      const result = await client.getAccountTokens({ address: userDid, token: paymentCurrency.contract });
-      const balance = result.tokens[0]?.balance || '0';
-      if (new BN(balance).lt(new BN(checkoutSession.amount_total))) {
-        throw new Error(
-          `Your account ${userDid} does not have enough ${paymentCurrency.symbol} to complete this subscription`
-        );
-      }
-    }
-
     if (paymentMethod.type === 'arcblock') {
       await subscription.update({
         payment_settings: {
@@ -83,37 +107,19 @@ export default {
       });
 
       const { invoice } = await ensureInvoiceForCheckout({ checkoutSession, customer, subscription });
-
-      const client = paymentMethod.getOcapClient();
-      const claim = claims.find((x) => x.type === 'signature');
-
-      // execute the delegate tx
-      const tx: Partial<Transaction> = client.decodeTx(claim.origin);
-      tx.signature = claim.sig;
-
-      // @ts-ignore
-      const { buffer } = await client.encodeDelegateTx({ tx });
-      const txHash = await client.sendDelegateTx(
-        // @ts-ignore
-        { tx, wallet: fromPublicKey(userPk, toTypeInfo(userDid)) },
-        getGasPayerExtra(buffer)
-      );
-
-      await subscription.update({
-        payment_details: {
-          arcblock: {
-            tx_hash: txHash,
-            payer: userDid,
-          },
-        },
-      });
-
+      const paymentDetails = await executeOcapTransactions(userDid, userPk, claims, paymentMethod);
+      await subscription.update({ payment_details: { arcblock: paymentDetails } });
       if (invoice) {
-        invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
+        invoiceQueue.pushAndWait({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
       }
       await addSubscriptionJob(subscription, 'cycle', false, subscription.trial_end);
+      logger.info('CheckoutSession updated on subscription done', {
+        checkoutSession: checkoutSession.id,
+        subscription: subscription.id,
+        paymentDetails,
+      });
 
-      return { hash: txHash };
+      return { hash: paymentDetails.tx_hash };
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);

package/api/src/routes/invoices.ts

@@ -4,6 +4,7 @@ import Joi from 'joi';
 import pick from 'lodash/pick';
 
 import { syncStripeInvoice } from '../integrations/stripe/handlers/invoice';
+import { syncStripePayment } from '../integrations/stripe/handlers/payment-intent';
 import { getWhereFromKvQuery } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { expandLineItems } from '../libs/session';
@@ -175,6 +176,10 @@ router.get('/:id', authPortal, async (req, res) => {
       if (doc.status !== 'paid' && doc.metadata?.stripe_id) {
         await syncStripeInvoice(doc);
       }
+      if (doc.payment_intent_id) {
+        const paymentIntent = await PaymentIntent.findByPk(doc.payment_intent_id);
+        await syncStripePayment(paymentIntent!);
+      }
 
       const json = doc.toJSON();
       const products = (await Product.findAll()).map((x) => x.toJSON());

package/api/src/routes/payment-intents.ts

@@ -3,6 +3,7 @@ import { Router } from 'express';
 import Joi from 'joi';
 import pick from 'lodash/pick';
 
+import { syncStripeInvoice } from '../integrations/stripe/handlers/invoice';
 import { syncStripePayment } from '../integrations/stripe/handlers/payment-intent';
 import { getWhereFromKvQuery, getWhereFromQuery } from '../libs/api';
 import { authenticate } from '../libs/security';
@@ -175,12 +176,15 @@ router.get('/:id', authPortal, async (req, res) => {
 
     if (doc) {
       const shouldSync = doc.status !== 'succeeded' || req.query.sync === '1';
-      if (doc.metadata?.stripe_id && shouldSync) {
+      if (shouldSync) {
         await syncStripePayment(doc);
       }
+      invoice = await Invoice.findByPk(doc.invoice_id);
+      if (invoice?.metadata?.stripe_id) {
+        await syncStripeInvoice(invoice);
+      }
 
       checkoutSession = await CheckoutSession.findOne({ where: { payment_intent_id: doc.id } });
-      invoice = await Invoice.findByPk(doc.invoice_id);
       if (invoice && invoice.subscription_id) {
         subscription = await Subscription.findByPk(invoice.subscription_id);
       }

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

@@ -59,7 +59,7 @@ export class Subscription extends Model<InferAttributes<Subscription>, InferCrea
       | 'other',
       string
     >;
-    reason: LiteralUnion<'cancellation_requested' | 'payment_disputed' | 'payment_failed', string>;
+    reason: LiteralUnion<'cancellation_requested' | 'payment_disputed' | 'payment_failed' | 'stake_revoked', string>;
   };
 
   declare billing_cycle_anchor: number;
@@ -328,11 +328,6 @@ export class Subscription extends Model<InferAttributes<Subscription>, InferCrea
               }
             }
 
-            // 发射 canceled 事件
-            if (model.status === 'canceled' && model.previous('status') !== model.status) {
-              createEvent('Subscription', 'customer.subscription.canceled', model, options).catch(console.error);
-            }
-
             createStatusEvent(
               'Subscription',
               'customer.subscription',

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

@@ -260,6 +260,11 @@ export type PaymentDetails = {
   arcblock?: {
     tx_hash: string;
     payer: string;
+    type?: LiteralUnion<'slash' | 'transfer' | 'delegate', string>;
+    staking?: {
+      tx_hash: string;
+      address: string;
+    };
   };
   stripe?: {
     payment_intent_id?: string;
@@ -434,7 +439,6 @@ export type EventType = LiteralUnion<
   | 'customer.subscription.trial_end'
   | 'customer.subscription.started'
   | 'customer.subscription.updated'
-  | 'customer.subscription.canceled'
   | 'customer.tax_id.created'
   | 'customer.tax_id.deleted'
   | 'customer.tax_id.updated'

package/api/tests/libs/subscription.spec.ts

@@ -6,6 +6,7 @@ import {
   getMaxRetryCount,
   getMinRetryMail,
   getSubscriptionCreateSetup,
+  getSubscriptionStakeSetup,
   shouldCancelSubscription,
 } from '../../src/libs/subscription';
 
@@ -165,7 +166,7 @@ describe('getSubscriptionCreateSetup', () => {
     expect(result.cycle.duration).toBe(24 * 60 * 60 * 1000);
   });
 
-  it('should calculate trial period when trialInDays is provided', () => {
+  it('should calculate trial period when only trialInDays is provided', () => {
     const items = [
       {
         price: { type: 'recurring', currency_options: currencies, recurring: { interval: 'day', interval_count: '1' } },
@@ -182,7 +183,7 @@ describe('getSubscriptionCreateSetup', () => {
     );
   });
 
-  it('should calculate trial period when trialEnds is provided', () => {
+  it('should trialEnds overwrite trialInDays', () => {
     const items = [
       {
         price: { type: 'recurring', currency_options: currencies, recurring: { interval: 'day', interval_count: '1' } },
@@ -199,7 +200,7 @@ describe('getSubscriptionCreateSetup', () => {
     );
   });
 
-  it('should calculate trial period when trialEnds is provided', () => {
+  it('should calculate trial period when only trialEnds is provided', () => {
     const items = [
       {
         price: { type: 'recurring', currency_options: currencies, recurring: { interval: 'day', interval_count: '1' } },
@@ -305,3 +306,84 @@ describe('shouldCancelSubscription', () => {
     expect(result).toBe(false);
   });
 });
+
+describe('getSubscriptionStakeSetup', () => {
+  const items: any[] = [
+    {
+      price: {
+        type: 'one_time',
+        currency_options: [
+          {
+            currency_id: 'usd',
+            unit_amount: '1',
+          },
+        ],
+      },
+      quantity: 1,
+    },
+    {
+      price: {
+        type: 'recurring',
+        currency_options: [
+          {
+            currency_id: 'usd',
+            unit_amount: '1',
+          },
+        ],
+        recurring: {
+          interval: 'day',
+          interval_count: '1',
+          usage_type: 'licensed',
+        },
+      },
+      quantity: 2,
+    },
+    {
+      price: {
+        type: 'recurring',
+        currency_options: [
+          {
+            currency_id: 'usd',
+            unit_amount: '1',
+          },
+        ],
+        recurring: {
+          interval: 'day',
+          interval_count: '1',
+          usage_type: 'metered',
+        },
+      },
+      quantity: 2,
+    },
+  ];
+
+  it('should calculate staking for recurring licensed price type #1', () => {
+    const result = getSubscriptionStakeSetup(items, 'usd');
+    expect(result.licensed.toString()).toBe('2');
+    expect(result.metered.toString()).toBe('2');
+  });
+
+  it('should calculate staking for recurring licensed price type #2', () => {
+    const result = getSubscriptionStakeSetup(items.slice(0, 2), 'usd');
+    expect(result.licensed.toString()).toBe('2');
+    expect(result.metered.toString()).toBe('0');
+  });
+
+  it('should calculate staking for recurring metered price type when billingThreshold is 0 #1', () => {
+    const result = getSubscriptionStakeSetup(items.slice(2, 3), 'usd', '10');
+    expect(result.licensed.toString()).toBe('0');
+    expect(result.metered.toString()).toBe('10');
+  });
+
+  it('should calculate staking for recurring metered price type when billingThreshold is 0 #2', () => {
+    const result = getSubscriptionStakeSetup(items, 'usd', '0');
+    expect(result.licensed.toString()).toBe('2');
+    expect(result.metered.toString()).toBe('2');
+  });
+
+  it('should calculate staking for recurring metered price type when billingThreshold is greater than 0', () => {
+    const result = getSubscriptionStakeSetup(items, 'usd', '10');
+    expect(result.licensed.toString()).toBe('2');
+    expect(result.metered.toString()).toBe('10');
+  });
+});

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.13.174
+version: 1.13.176
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.13.174",
+  "version": "1.13.176",
   "scripts": {
     "dev": "cross-env COMPONENT_STORE_URL=https://test.store.blocklet.dev blocklet dev --open",
     "eject": "vite eject",
@@ -50,7 +50,7 @@
     "@arcblock/jwt": "^1.18.110",
     "@arcblock/ux": "^2.9.39",
     "@blocklet/logger": "1.16.23",
-    "@blocklet/payment-react": "1.13.174",
+    "@blocklet/payment-react": "1.13.176",
     "@blocklet/sdk": "1.16.23",
     "@blocklet/ui-react": "^2.9.39",
     "@blocklet/uploader": "^0.0.74",
@@ -110,7 +110,7 @@
   "devDependencies": {
     "@abtnode/types": "1.16.23",
     "@arcblock/eslint-config-ts": "^0.2.4",
-    "@blocklet/payment-types": "1.13.174",
+    "@blocklet/payment-types": "1.13.176",
     "@types/cookie-parser": "^1.4.6",
     "@types/cors": "^2.8.17",
     "@types/dotenv-flow": "^3.3.3",
@@ -149,5 +149,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "6aa0d712bf8f36a3592fd564f14fd9ca05b5c7a9"
+  "gitHead": "d39e02f65d5f7a168b3ee3d589b47c4d77c53125"
 }