payment-kit 1.13.17 → 1.13.19

package/api/src/libs/util.ts

@@ -1,10 +1,56 @@
 import crypto from 'crypto';
 
+import { getUrl } from '@blocklet/sdk/lib/component';
 import { customAlphabet } from 'nanoid';
 
 import dayjs from './dayjs';
 
 export const MAX_RETRY_COUNT = 18; // 2^18 seconds ~~ 3 days, total retry time: 6 days
+export const STRIPE_API_VERSION = '2023-08-16';
+export const STRIPE_ENDPOINT: string = getUrl('/api/integrations/stripe/webhook');
+export const STRIPE_EVENTS: any[] = [
+  'checkout.session.async_payment_failed',
+  'checkout.session.async_payment_succeeded',
+  'checkout.session.completed',
+  'checkout.session.expired',
+
+  // 'customer.subscription.created',
+  'customer.subscription.deleted',
+  'customer.subscription.paused',
+  'customer.subscription.pending_update_applied',
+  'customer.subscription.pending_update_expired',
+  'customer.subscription.resumed',
+  'customer.subscription.trial_will_end',
+  'customer.subscription.updated',
+
+  'invoice.created',
+  'invoice.deleted',
+  'invoice.finalization_failed',
+  'invoice.finalized',
+  'invoice.marked_uncollectible',
+  'invoice.paid',
+  'invoice.payment_action_required',
+  'invoice.payment_failed',
+  'invoice.payment_succeeded',
+  'invoice.sent',
+  'invoice.upcoming',
+  'invoice.updated',
+  'invoice.voided',
+
+  'payment_intent.canceled',
+  'payment_intent.created',
+  'payment_intent.partially_funded',
+  'payment_intent.payment_failed',
+  'payment_intent.processing',
+  'payment_intent.requires_action',
+  'payment_intent.succeeded',
+
+  'setup_intent.canceled',
+  // 'setup_intent.created',
+  'setup_intent.requires_action',
+  'setup_intent.setup_failed',
+  'setup_intent.succeeded',
+];
 
 export function md5(input: string) {
   return crypto.createHash('md5').update(input).digest('hex');
@@ -40,7 +86,7 @@ export function formatMetadata(metadata?: Record<string, any>): Record<string, a
       acc[key] = metadata[key];
     }
     return acc;
-  }, []);
+  }, {});
 }
 
 export function sleep(timeout = 0) {

package/api/src/routes/checkout-sessions.ts

@@ -4,7 +4,12 @@ import userMiddleware from '@blocklet/sdk/lib/middlewares/user';
 import { Router } from 'express';
 import omit from 'lodash/omit';
 import pick from 'lodash/pick';
+import sortBy from 'lodash/sortBy';
+import uniq from 'lodash/uniq';
 
+import { handleStripePaymentSucceed } from '../integrations/stripe/handlers/payment-intent';
+import { handleStripeSubscriptionSucceed } from '../integrations/stripe/handlers/subscription';
+import { ensureStripePaymentIntent, ensureStripeSubscription } from '../integrations/stripe/resource';
 import { invoiceQueue } from '../jobs/invoice';
 import { paymentQueue } from '../jobs/payment';
 import { subscriptionQueue } from '../jobs/subscription';
@@ -17,9 +22,12 @@ import {
   getCheckoutMode,
   getStatementDescriptor,
   getSubscriptionCreateSetup,
+  getSupportedPaymentCurrencies,
+  getSupportedPaymentMethods,
+  isLineItemAligned,
 } from '../libs/session';
 import { createCodeGenerator, formatMetadata } from '../libs/util';
-import type { LineItem } from '../store/models';
+import type { LineItem, TPaymentCurrency } from '../store/models';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Customer } from '../store/models/customer';
 import { PaymentCurrency } from '../store/models/payment-currency';
@@ -39,7 +47,21 @@ const router = Router();
 const user = userMiddleware();
 const auth = authenticate<CheckoutSession>({ component: true, roles: ['owner', 'admin'] });
 
-const formatBeforeSave = async (payload: any) => {
+const getPaymentMethods = async (doc: CheckoutSession) => {
+  const paymentMethods = await PaymentMethod.expand(doc.livemode, { type: doc.payment_method_types });
+  const supportedCurrencies = getSupportedPaymentCurrencies(doc.line_items as any[]);
+  const methods = getSupportedPaymentMethods(paymentMethods as any[], (x) => supportedCurrencies.includes(x.id));
+  return sortBy(methods, (m) => (m.payment_currencies.some((c) => c.is_base_currency) ? 0 : 1));
+};
+
+const getPaymentTypes = async (items: any[]) => {
+  const supportedCurrencies = getSupportedPaymentCurrencies(items);
+  const currencies = await PaymentCurrency.findAll({ where: { id: supportedCurrencies } });
+  const methods = await PaymentMethod.findAll({ where: { id: uniq(currencies.map((x) => x.payment_method_id)) } });
+  return methods.map((x) => x.type);
+};
+
+const formatBeforeSave = async (payload: any, throwOnEmptyItems = true) => {
   const raw: Partial<CheckoutSession> = Object.assign(
     {
       allow_promotion_codes: false,
@@ -62,6 +84,7 @@ const formatBeforeSave = async (payload: any) => {
       submit_type: 'pay',
     },
     pick(payload, [
+      'currency_id',
       'expires_at',
       'line_items',
       'allow_promotion_codes',
@@ -97,6 +120,10 @@ const formatBeforeSave = async (payload: any) => {
 
   raw.metadata = formatMetadata(raw.metadata);
 
+  if (raw.line_items?.length === 0 && throwOnEmptyItems) {
+    throw new Error('line items should not be empty for checkout session');
+  }
+
   const items = await Price.expand(raw.line_items as LineItem[]);
   if (items.some((x) => !x.price)) {
     throw new Error('Invalid line items for checkout session, some price may have been deleted');
@@ -104,8 +131,23 @@ const formatBeforeSave = async (payload: any) => {
   if (items.some((x) => !x.price.active)) {
     throw new Error('Invalid line items for checkout session, some price may have been archived');
   }
+  for (let i = 0; i < items.length; i++) {
+    const result = isLineItemAligned(items, i);
+    if (result.currency === false) {
+      throw new Error('line_items should have same currency');
+    }
+    if (result.recurring === false) {
+      throw new Error('line_items should have same recurring');
+    }
+  }
 
-  const amount = getCheckoutAmount(items, !!raw.subscription_data?.trial_period_days);
+  // use first price currency as default
+  if (!raw.currency_id) {
+    raw.currency_id = items[0]?.price.currency_id;
+  }
+
+  const currency = await PaymentCurrency.findByPk(raw.currency_id);
+  const amount = getCheckoutAmount(items, currency as TPaymentCurrency, !!raw.subscription_data?.trial_period_days);
   const mode = getCheckoutMode(items);
 
   return Object.assign(raw, {
@@ -121,6 +163,8 @@ const formatBeforeSave = async (payload: any) => {
       amount_tax: amount.tax,
     },
 
+    payment_method_types: await getPaymentTypes(items),
+
     // always create invoice for subscriptions
     invoice_creation: mode === 'subscription' ? { enabled: true } : raw.invoice_creation,
   });
@@ -131,7 +175,6 @@ router.post('/', auth, async (req, res) => {
   const raw: Partial<CheckoutSession> = await formatBeforeSave(req.body);
   raw.livemode = !!req.livemode;
   raw.created_via = req.user?.via as string;
-  raw.currency_id = raw.currency_id || req.currency.id;
 
   const doc = await CheckoutSession.create(raw as any);
 
@@ -154,7 +197,7 @@ router.post('/start/:id', user, async (req, res) => {
 
   const items = await Price.expand(link.line_items);
 
-  const raw: Partial<CheckoutSession> = await formatBeforeSave(link);
+  const raw: Partial<CheckoutSession> = await formatBeforeSave(link, false);
   raw.livemode = link.livemode;
   raw.created_via = 'portal';
   raw.currency_id = link.currency_id || req.currency.id;
@@ -177,10 +220,11 @@ router.post('/start/:id', user, async (req, res) => {
 
     doc.line_items = items;
     res.json({
-      checkoutSession: { ...doc.toJSON(), currency: await PaymentCurrency.findByPk(doc.currency_id) },
-      paymentMethods: await PaymentMethod.expand(req.livemode),
+      checkoutSession: doc.toJSON(),
+      paymentMethods: await getPaymentMethods(doc),
       paymentLink: link,
       paymentIntent: null,
+      customer: req.user ? await Customer.findOne({ where: { did: req.user.did } }) : null,
     });
   } catch (err) {
     console.error(err);
@@ -188,17 +232,20 @@ router.post('/start/:id', user, async (req, res) => {
   }
 });
 
+// for Node.js SDK
 router.get('/:id', auth, async (req, res) => {
   const doc = await CheckoutSession.findByPk(req.params.id);
 
   if (doc) {
     // @ts-ignore
     doc.line_items = await Price.expand(doc.line_items);
+    doc.url = getUrl(`/checkout/${doc.submit_type}/${doc.id}`);
   }
 
   res.json(doc?.toJSON());
 });
 
+// for checkout page
 router.get('/retrieve/:id', user, async (req, res) => {
   const doc = await CheckoutSession.findByPk(req.params.id);
 
@@ -210,12 +257,15 @@ router.get('/retrieve/:id', user, async (req, res) => {
   // @ts-ignore
   doc.line_items = await Price.expand(doc.line_items);
 
+  // check payment intent
+  const paymentIntent = doc.payment_intent_id ? await PaymentIntent.findByPk(doc.payment_intent_id) : null;
+
   // FIXME: possible sensitive data leak
   res.json({
-    checkoutSession: { ...doc.toJSON(), currency: await PaymentCurrency.findByPk(doc.currency_id) },
-    paymentMethods: await PaymentMethod.expand(req.livemode),
+    checkoutSession: doc.toJSON(),
+    paymentMethods: await getPaymentMethods(doc),
     paymentLink: doc.payment_link_id ? await PaymentLink.findByPk(doc.payment_link_id) : null,
-    paymentIntent: doc.payment_intent_id ? await PaymentIntent.findByPk(doc.payment_intent_id) : null,
+    paymentIntent,
     customer: req.user ? await Customer.findOne({ where: { did: req.user.did } }) : null,
   });
 });
@@ -253,6 +303,20 @@ router.put('/:id/submit', user, async (req, res) => {
     }
     await checkoutSession.update({ currency_id: paymentCurrency.id });
 
+    // always update payment amount in case currency has changed
+    const lineItems = await Price.expand(checkoutSession.line_items, true);
+    const trialInDays = checkoutSession.subscription_data?.trial_period_days || 0;
+    const amount = getCheckoutAmount(lineItems, paymentCurrency, !!trialInDays);
+    await checkoutSession.update({
+      amount_subtotal: amount.subtotal,
+      amount_total: amount.total,
+      total_details: {
+        amount_discount: amount.discount,
+        amount_shipping: amount.shipping,
+        amount_tax: amount.tax,
+      },
+    });
+
     // ensure customer created or updated
     let customer = await Customer.findOne({ where: { did: req.user.did } });
     if (!customer) {
@@ -286,8 +350,7 @@ router.put('/:id/submit', user, async (req, res) => {
 
       await customer.update(updates);
     }
-
-    const lineItems = await Price.expand(checkoutSession.line_items, true);
+    await checkoutSession.update({ customer_id: customer.id, customer_did: req.user.did });
 
     // payment intent is only created when checkout session is in payment mode
     let paymentIntent: PaymentIntent | null = null;
@@ -316,8 +379,6 @@ router.put('/:id/submit', user, async (req, res) => {
           receipt_email: customer.email,
         });
       } else {
-        // ensure payment intent
-        // FIXME: support and validate currency converting here
         paymentIntent = await PaymentIntent.create({
           livemode: !!checkoutSession.livemode,
           amount: checkoutSession.amount_total,
@@ -330,7 +391,7 @@ router.put('/:id/submit', user, async (req, res) => {
           status: 'requires_payment_method',
           capture_method: 'automatic',
           confirmation_method: 'automatic',
-          payment_method_types: [],
+          payment_method_types: checkoutSession.payment_method_types,
           receipt_email: customer.email,
           statement_descriptor: getStatementDescriptor(lineItems),
           statement_descriptor_suffix: '',
@@ -338,21 +399,21 @@ router.put('/:id/submit', user, async (req, res) => {
           metadata: {},
         });
 
+        // lock prices used by this payment
+        await Price.update({ locked: true }, { where: { id: lineItems.map((x) => x.price_id) } });
+
         // persist payment intent id
         await checkoutSession.update({ payment_intent_id: paymentIntent.id });
       }
     }
 
-    // payment intent is only created when checkout session is in payment mode
     let setupIntent: SetupIntent | null = null;
-    if (checkoutSession.mode === 'setup') {
+    if (checkoutSession.mode === 'setup' || paymentMethod.type !== 'stripe') {
       if (checkoutSession.setup_intent_id) {
         setupIntent = await SetupIntent.findByPk(checkoutSession.setup_intent_id);
       }
 
-      // check existing payment intent
       if (setupIntent) {
-        // Check payment intent, if we have a payment intent, we should not create a new one
         if (setupIntent.status === 'succeeded') {
           return res.status(403).json({ error: 'Checkout session setup completed' });
         }
@@ -376,7 +437,7 @@ router.put('/:id/submit', user, async (req, res) => {
           currency_id: paymentCurrency.id,
           payment_method_id: paymentMethod.id,
           status: 'requires_payment_method',
-          payment_method_types: [],
+          payment_method_types: checkoutSession.payment_method_types,
           flow_directions: ['inbound', 'outbound'],
           usage: 'off_session',
           metadata: {},
@@ -397,16 +458,16 @@ router.put('/:id/submit', user, async (req, res) => {
           return res.status(403).json({ error: 'Checkout session subscription status unexpected' });
         }
         subscription = await subscription.update({
-          currency_id: req.body.payment_currency,
+          currency_id: paymentCurrency.id,
           customer_id: customer.id,
-          default_payment_method_id: req.body.payment_method,
+          default_payment_method_id: paymentMethod.id,
           pending_setup_intent: setupIntent?.id,
         });
       } else {
-        const setup = getSubscriptionCreateSetup(lineItems, checkoutSession.subscription_data?.trial_period_days);
+        const setup = getSubscriptionCreateSetup(lineItems, paymentCurrency, trialInDays);
         subscription = await Subscription.create({
           livemode: !!checkoutSession.livemode,
-          currency_id: req.body.payment_currency,
+          currency_id: paymentCurrency.id,
           customer_id: customer.id,
           status: 'incomplete',
           current_period_start: setup.period.start,
@@ -422,7 +483,7 @@ router.put('/:id/submit', user, async (req, res) => {
           },
           pending_invoice_item_interval: setup.recurring,
           pending_setup_intent: setupIntent?.id,
-          default_payment_method_id: req.body.payment_method,
+          default_payment_method_id: paymentMethod.id,
           cancel_at_period_end: false,
           collection_method: 'charge_automatically',
           // FIXME: support discount
@@ -445,6 +506,9 @@ router.put('/:id/submit', user, async (req, res) => {
             )
         );
 
+        // lock prices used by this subscription
+        await Price.update({ locked: true }, { where: { id: lineItems.map((x) => x.price_id) } });
+
         // persist subscription id
         await checkoutSession.update({ subscription_id: subscription.id });
       }
@@ -459,7 +523,7 @@ router.put('/:id/submit', user, async (req, res) => {
     });
     if (delegation.sufficient) {
       const paymentSettings = {
-        payment_method_types: ['arcblock'],
+        payment_method_types: checkoutSession.payment_method_types,
         payment_method_options: {
           arcblock: { payer: delegation.delegator as string },
         },
@@ -507,7 +571,50 @@ router.put('/:id/submit', user, async (req, res) => {
       }
     }
 
-    return res.json({ paymentIntent, setupIntent, subscription, checkoutSession, delegation });
+    let stripeContext: any = null;
+    if (paymentMethod.type === 'stripe') {
+      if (paymentIntent) {
+        const stripeIntent = await ensureStripePaymentIntent(paymentIntent, paymentMethod, paymentCurrency);
+        if (stripeIntent && paymentIntent?.payment_details?.stripe?.payment_intent_id === stripeIntent.id) {
+          if (stripeIntent.status === 'succeeded' && paymentIntent.status !== 'succeeded') {
+            await handleStripePaymentSucceed(paymentIntent);
+          }
+        }
+        stripeContext = {
+          type: 'payment_intent',
+          id: stripeIntent.id,
+          client_secret: stripeIntent.client_secret,
+          status: stripeIntent.status,
+        };
+      }
+
+      if (subscription) {
+        const stripeSubscription = await ensureStripeSubscription(
+          subscription,
+          paymentMethod,
+          paymentCurrency,
+          lineItems as any[],
+          trialInDays
+        );
+        if (stripeSubscription && subscription?.payment_details?.stripe?.subscription_id === stripeSubscription.id) {
+          if (stripeSubscription.status === 'active' && subscription.status === 'incomplete') {
+            await handleStripeSubscriptionSucceed(subscription);
+          }
+        }
+        stripeContext = {
+          type: 'subscription',
+          id: stripeSubscription.id,
+          // @ts-ignore
+          client_secret:
+            stripeSubscription.latest_invoice?.payment_intent?.client_secret ||
+            stripeSubscription.pending_setup_intent?.client_secret,
+          intent_type: stripeSubscription.latest_invoice?.payment_intent ? 'payment_intent' : 'setup_intent',
+          status: stripeSubscription.status,
+        };
+      }
+    }
+
+    return res.json({ paymentIntent, setupIntent, stripeContext, subscription, checkoutSession, customer, delegation });
   } catch (err) {
     console.error(err);
     res.status(500).json({ error: err.message });

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

@@ -7,12 +7,18 @@ import type { CallbackArgs } from '../../libs/auth';
 import { wallet } from '../../libs/auth';
 import { getClient } from '../../libs/chain/arcblock';
 import dayjs from '../../libs/dayjs';
-import { ensureInvoiceForCollect } from './shared';
+import { ensureInvoiceForCollect, getAuthPrincipalClaim } from './shared';
 
 // Used to collect an open invoice failed to collect automatically
-// TODO: support multiple chain and multiple currency
 export default {
   action: 'collect',
+  authPrincipal: false,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensureInvoiceForCollect(extraParams.invoiceId);
+      return getAuthPrincipalClaim(paymentMethod, 'pay');
+    },
+  },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
     const { invoiceId } = extraParams;
     const { invoice, paymentIntent, paymentCurrency, paymentMethod } = await ensureInvoiceForCollect(invoiceId);
@@ -75,8 +81,10 @@ export default {
         amount_received: invoice.amount_due,
         capture_method: 'manual',
         payment_details: {
-          tx_hash: txHash,
-          payer: userDid,
+          arcblock: {
+            tx_hash: txHash,
+            payer: userDid,
+          },
         },
       });
 

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

@@ -5,10 +5,17 @@ import type { CallbackArgs } from '../../libs/auth';
 import { wallet } from '../../libs/auth';
 import { getClient } from '../../libs/chain/arcblock';
 import dayjs from '../../libs/dayjs';
-import { ensureInvoiceForCheckout, ensurePaymentIntent } from './shared';
+import { ensureInvoiceForCheckout, ensurePaymentIntent, getAuthPrincipalClaim } from './shared';
 
 export default {
   action: 'pay',
+  authPrincipal: false,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensurePaymentIntent(extraParams.checkoutSessionId);
+      return getAuthPrincipalClaim(paymentMethod, 'pay');
+    },
+  },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
     const { checkoutSessionId } = extraParams;
     const { paymentIntent, paymentCurrency, paymentMethod } = await ensurePaymentIntent(checkoutSessionId, userDid);
@@ -16,23 +23,22 @@ export default {
       throw new Error('Payment intent not found');
     }
 
-    const tokens = [{ address: paymentCurrency.contract as string, value: paymentIntent.amount }];
-    // @ts-ignore
-    const itx: TransferV3Tx = {
-      outputs: [{ owner: wallet.address, tokens, assets: [] }],
-      data: {
-        type: 'json',
-        // @ts-ignore
-        value: {
-          appId: wallet.address,
-          paymentIntentId: paymentIntent.id,
-          checkoutSessionId,
+    if (paymentMethod.type === 'arcblock') {
+      const tokens = [{ address: paymentCurrency.contract as string, value: paymentIntent.amount }];
+      // @ts-ignore
+      const itx: TransferV3Tx = {
+        outputs: [{ owner: wallet.address, tokens, assets: [] }],
+        data: {
+          type: 'json',
+          // @ts-ignore
+          value: {
+            appId: wallet.address,
+            paymentIntentId: paymentIntent.id,
+            checkoutSessionId,
+          },
         },
-      },
-    };
+      };
 
-    // TODO: support multiple chain and multiple currency
-    if (paymentMethod.type === 'arcblock') {
       return {
         prepareTx: {
           type: 'TransferV3Tx',
@@ -82,16 +88,20 @@ export default {
         status: 'complete',
         payment_status: 'paid',
         payment_details: {
-          tx_hash: txHash,
-          payer: userDid,
+          arcblock: {
+            tx_hash: txHash,
+            payer: userDid,
+          },
         },
       });
       await paymentIntent.update({
         status: 'succeeded',
         amount_received: paymentIntent.amount,
         payment_details: {
-          tx_hash: txHash,
-          payer: userDid,
+          arcblock: {
+            tx_hash: txHash,
+            payer: userDid,
+          },
         },
       });
 

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

@@ -7,10 +7,17 @@ import { subscriptionQueue } from '../../jobs/subscription';
 import type { CallbackArgs } from '../../libs/auth';
 import { wallet } from '../../libs/auth';
 import { getClient } from '../../libs/chain/arcblock';
-import { ensureSetupIntent } from './shared';
+import { ensureSetupIntent, getAuthPrincipalClaim } from './shared';
 
 export default {
   action: 'setup',
+  authPrincipal: false,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensureSetupIntent(extraParams.checkoutSessionId);
+      return getAuthPrincipalClaim(paymentMethod, 'subscribe');
+    },
+  },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
     const { checkoutSessionId } = extraParams;
     const { paymentMethod, subscription } = await ensureSetupIntent(checkoutSessionId, userDid);
@@ -18,7 +25,6 @@ export default {
       throw new Error('Subscription for checkoutSession not found');
     }
 
-    // TODO: support multiple chain and multiple currency
     if (paymentMethod.type === 'arcblock') {
       return {
         signature: {
@@ -98,8 +104,10 @@ export default {
       await subscription.update({
         status: subscription.trail_end ? 'trialing' : 'active',
         payment_details: {
-          tx_hash: txHash,
-          payer: userDid,
+          arcblock: {
+            tx_hash: txHash,
+            payer: userDid,
+          },
         },
       });
 

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

@@ -40,7 +40,7 @@ export async function ensureCheckoutSession(checkoutSessionId: string) {
   return checkoutSession;
 }
 
-export async function ensurePaymentIntent(checkoutSessionId: string, userDid: string): Promise<Result> {
+export async function ensurePaymentIntent(checkoutSessionId: string, userDid?: string): Promise<Result> {
   const checkoutSession = await ensureCheckoutSession(checkoutSessionId);
 
   let customerId;
@@ -84,7 +84,7 @@ export async function ensurePaymentIntent(checkoutSessionId: string, userDid: st
   }
 
   let customer;
-  if (customerId) {
+  if (customerId && userDid) {
     customer = await Customer.findByPk(customerId);
     if (!customer) {
       throw new Error('Customer not found');
@@ -122,7 +122,7 @@ export async function ensurePaymentIntent(checkoutSessionId: string, userDid: st
   };
 }
 
-export async function ensureSetupIntent(checkoutSessionId: string, userDid: string) {
+export async function ensureSetupIntent(checkoutSessionId: string, userDid?: string) {
   const checkoutSession = await ensureCheckoutSession(checkoutSessionId);
 
   let customerId;
@@ -166,7 +166,7 @@ export async function ensureSetupIntent(checkoutSessionId: string, userDid: stri
   }
 
   let customer;
-  if (customerId) {
+  if (customerId && userDid) {
     customer = await Customer.findByPk(customerId);
     if (!customer) {
       throw new Error('Customer not found');
@@ -408,3 +408,27 @@ export async function ensureInvoiceForCollect(invoiceId: string) {
     paymentMethod: paymentMethod as PaymentMethod,
   };
 }
+
+export function getAuthPrincipalClaim(method: PaymentMethod, action: string) {
+  let chainInfo = { type: 'arcblock', id: 'none', host: 'none' };
+  if (method.type === 'arcblock') {
+    chainInfo = {
+      type: 'arcblock',
+      id: method.settings?.arcblock?.chain_id as string,
+      host: method.settings?.arcblock?.api_host as string,
+    };
+  }
+  if (method.type === 'ethereum') {
+    chainInfo = {
+      type: 'ethereum',
+      // @ts-ignore
+      id: method.settings?.ethereum?.chain_id as number,
+      host: method.settings?.ethereum?.api_host as string,
+    };
+  }
+
+  return {
+    description: `Select account to ${action}`,
+    chainInfo,
+  };
+}