payment-kit 1.18.15 → 1.18.17

package/api/src/routes/connect/recharge-account.ts

@@ -0,0 +1,124 @@
+import type { Transaction } from '@ocap/client';
+import { fromAddress } from '@ocap/wallet';
+import { fromTokenToUnit } from '@ocap/util';
+import type { CallbackArgs } from '../../libs/auth';
+import { getGasPayerExtra } from '../../libs/payment';
+import { getTxMetadata } from '../../libs/util';
+import { ensureAccountRecharge, getAuthPrincipalClaim } from './shared';
+import logger from '../../libs/logger';
+import { ensureRechargeInvoice } from '../../libs/invoice';
+
+export default {
+  action: 'recharge-account',
+  authPrincipal: false,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensureAccountRecharge(extraParams.customerDid, extraParams.currencyId);
+      return getAuthPrincipalClaim(paymentMethod, 'recharge-account');
+    },
+  },
+  onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
+    const { customerDid, currencyId } = extraParams;
+    let { amount } = extraParams;
+    const { paymentMethod, paymentCurrency, customer } = await ensureAccountRecharge(customerDid, currencyId);
+    amount = fromTokenToUnit(amount, paymentCurrency.decimal).toString();
+    if (paymentMethod.type === 'arcblock') {
+      const tokens = [{ address: paymentCurrency.contract as string, value: amount }];
+      // @ts-ignore
+      const itx: TransferV3Tx = {
+        outputs: [{ owner: customerDid, tokens, assets: [] }],
+        data: getTxMetadata({
+          rechargeCustomerId: customer.id,
+          customerDid,
+          currencyId: paymentCurrency.id,
+          amount,
+          action: 'recharge-account',
+        }),
+      };
+
+      const claims: { [key: string]: object } = {
+        prepareTx: {
+          type: 'TransferV3Tx',
+          description: `Recharge account for ${customerDid}`,
+          partialTx: { from: userDid, pk: userPk, itx },
+          requirement: { tokens },
+          chainInfo: {
+            host: paymentMethod.settings?.arcblock?.api_host as string,
+            id: paymentMethod.settings?.arcblock?.chain_id as string,
+          },
+        },
+      };
+
+      return claims;
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+  onAuth: async ({ request, userDid, claims, extraParams }: CallbackArgs) => {
+    const { customerDid, currencyId } = extraParams;
+    const { paymentMethod, paymentCurrency, customer } = await ensureAccountRecharge(customerDid, currencyId);
+    let { amount } = extraParams;
+    amount = fromTokenToUnit(amount, paymentCurrency.decimal).toString();
+
+    const afterTxExecution = async (paymentDetails: any) => {
+      await ensureRechargeInvoice(
+        {
+          total: amount,
+          description: 'Add funds for account',
+          currency_id: paymentCurrency.id,
+          metadata: {
+            payment_details: {
+              [paymentMethod.type]: paymentDetails,
+              receiverAddress: customerDid,
+            },
+          },
+          livemode: paymentCurrency?.livemode,
+          payment_settings: {
+            payment_method_types: [paymentMethod.type],
+            payment_method_options: {
+              [paymentMethod.type]: {
+                payer: userDid,
+              },
+            },
+          },
+        },
+        null,
+        paymentMethod,
+        customer!
+      );
+    };
+    if (paymentMethod.type === 'arcblock') {
+      try {
+        const client = paymentMethod.getOcapClient();
+        const claim = claims.find((x) => x.type === 'prepareTx');
+
+        const tx: Partial<Transaction> = client.decodeTx(claim.finalTx);
+        if (claim.delegator && claim.from) {
+          tx.delegator = claim.delegator;
+          tx.from = claim.from;
+        }
+
+        // @ts-ignore
+        const { buffer } = await client.encodeTransferV3Tx({ tx });
+        const txHash = await client.sendTransferV3Tx(
+          // @ts-ignore
+          { tx, wallet: fromAddress(userDid) },
+          getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
+        );
+
+        await afterTxExecution({
+          tx_hash: txHash,
+          payer: userDid,
+          type: 'transfer',
+        });
+        return { hash: txHash };
+      } catch (err) {
+        console.error(err);
+        logger.error('Failed to finalize recharge on arcblock', { receiverAddress: customerDid, error: err });
+        throw err;
+      }
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+};

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

@@ -132,6 +132,9 @@ export default {
     result.push({
       step,
       claim: claims?.[0],
+      stepRequest: {
+        headers: request?.headers,
+      },
     });
 
     // 判断是否为最后一步
@@ -199,13 +202,17 @@ export default {
     if (paymentMethod.type === 'arcblock') {
       try {
         await prepareTxExecution();
+        const requestArray = result
+          .map((item: { stepRequest?: Request }) => item.stepRequest)
+          .filter(Boolean) as Request[];
+        const requestSource = requestArray.length > 0 ? requestArray : request;
 
         const { stakingAmount, ...paymentDetails } = await executeOcapTransactions(
           userDid,
           userPk,
           claimsList,
           paymentMethod,
-          request,
+          requestSource,
           subscription?.id,
           paymentCurrency?.contract
         );

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

@@ -6,14 +6,14 @@ import type { Transaction } from '@ocap/client';
 import { BN, fromTokenToUnit, toBase58 } from '@ocap/util';
 import { fromPublicKey } from '@ocap/wallet';
 import type { Request } from 'express';
-import isEmpty from 'lodash/isEmpty';
+import { isEmpty } from 'lodash';
 
 import { estimateMaxGasForTx, hasStakedForGas } from '../../integrations/arcblock/stake';
 import { encodeApproveItx } from '../../integrations/ethereum/token';
 import { blocklet, ethWallet, wallet } from '../../libs/auth';
 import logger from '../../libs/logger';
 import { getGasPayerExtra, getTokenLimitsForDelegation } from '../../libs/payment';
-import { getFastCheckoutAmount, getStatementDescriptor } from '../../libs/session';
+import { getFastCheckoutAmount, getStatementDescriptor, isDonationCheckoutSession } from '../../libs/session';
 import {
   expandSubscriptionItems,
   getSubscriptionCreateSetup,
@@ -59,7 +59,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, skipCustomer?: boolean): Promise<Result> {
   const checkoutSession = await ensureCheckoutSession(checkoutSessionId);
 
   let paymentCurrencyId;
@@ -98,12 +98,69 @@ export async function ensurePaymentIntent(checkoutSessionId: string, userDid?: s
     paymentCurrencyId = subscription.currency_id;
     paymentMethodId = subscription.default_payment_method_id;
   }
-
-  const customer = await Customer.findByPk(checkoutSession.customer_id);
+  let customer = null;
+  if (!skipCustomer) {
+  // 检查是否为打赏场景
+  const isDonation = isDonationCheckoutSession(checkoutSession);  
+  
+  // if donation, create customer if not exists
+  if (isDonation && !checkoutSession.customer_id && userDid) {
+    customer = await Customer.findByPkOrDid(userDid);
+    if (!customer) {
+      const { user } = await blocklet.getUser(userDid);
+      if (user) {
+        customer = await Customer.create({
+          did: userDid,
+          email: user.email,
+          name: user.fullName || userDid,
+          description: user.remark,
+          metadata: { fromDonation: true },
+          livemode: checkoutSession.livemode,
+          phone: user.phone,
+          delinquent: false,
+          balance: '0',
+          next_invoice_sequence: 1,
+          invoice_prefix: Customer.getInvoicePrefix(),
+        });
+        logger.info('Customer created for donation', { userDid, customerId: customer.id });
+      } else {
+        customer = await Customer.create({
+          did: userDid,
+          email: '',
+          name: 'anonymous',
+          description: 'Anonymous customer',
+          metadata: { fromDonation: true, anonymous: true },
+          livemode: checkoutSession.livemode,
+          phone:'',
+          delinquent: false,
+          balance: '0',
+          next_invoice_sequence: 1,
+          invoice_prefix: Customer.getInvoicePrefix(),
+        });
+      }
+    }
+    
+    if (customer) {
+      await checkoutSession.update({ customer_id: customer.id, customer_did: customer.did });
+      if (paymentIntent) {
+        await paymentIntent.update({ customer_id: customer.id });
+      }
+      logger.info('Customer associated with donation', { 
+        userDid, 
+        customerId: customer.id,
+        checkoutSessionId: checkoutSession.id,
+        paymentIntentId: paymentIntent?.id
+      });
+    }
+  } else {
+    // 非打赏场景或已有客户ID的情况
+    customer = await Customer.findByPk(checkoutSession.customer_id);
+  }
   if (!customer) {
     throw new Error('Customer not found');
   }
-  if (userDid) {
+  
+  if (userDid && !isDonation) {
     const { user } = await blocklet.getUser(userDid, { enableConnectedAccount: true });
     if (!user) {
       throw new Error('Seems you have not connected to this app before');
@@ -113,6 +170,8 @@ export async function ensurePaymentIntent(checkoutSessionId: string, userDid?: s
       throw new Error('This is not your payment intent');
     }
   }
+  }
+
 
   const [paymentMethod, paymentCurrency] = await Promise.all([
     PaymentMethod.findByPk(paymentMethodId),
@@ -134,7 +193,7 @@ export async function ensurePaymentIntent(checkoutSessionId: string, userDid?: s
   return {
     checkoutSession,
     paymentIntent,
-    customer,
+    customer: customer as Customer,
     subscription,
     paymentMethod,
     paymentCurrency,
@@ -481,6 +540,25 @@ export async function ensureSubscriptionRecharge(subscriptionId: string) {
   };
 }
 
+export async function ensureAccountRecharge(customerId: string, currencyId: string) {
+  const customer = await Customer.findByPkOrDid(customerId);
+  if (!customer) {
+    throw new Error(`Customer ${customerId} not found`);
+  }
+  const paymentCurrency = await PaymentCurrency.findByPk(currencyId);
+  if (!paymentCurrency) {
+    throw new Error(`Currency ${currencyId} not found`);
+  }
+  const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+  if (!paymentMethod) {
+    throw new Error(`Payment method ${paymentCurrency.payment_method_id} not found`);
+  }
+  return {
+    paymentCurrency: paymentCurrency as PaymentCurrency,
+    paymentMethod: paymentMethod as PaymentMethod,
+    customer,
+  };
+}
 export function getAuthPrincipalClaim(method: PaymentMethod, action: string) {
   let chainInfo = { type: 'none', id: 'none', host: 'none' };
   if (method.type === 'arcblock') {
@@ -934,10 +1012,16 @@ export async function ensureChangePaymentContext(subscriptionId: string) {
   };
 }
 
-export async function ensureSubscriptionForCollectBatch(subscriptionId: string, currencyId: string) {
-  const subscription = await Subscription.findByPk(subscriptionId);
-  if (!subscription) {
-    throw new Error(`Subscription ${subscriptionId} not found when prepare batch collect`);
+export async function ensureSubscriptionForCollectBatch(
+  subscriptionId?: string, 
+  currencyId?: string,
+  customerId?: string
+) {
+  if (!currencyId) {
+    throw new Error('Currency ID must be provided');
+  }
+  if (!subscriptionId && !customerId) {
+    throw new Error('Either subscriptionId or customerId must be provided');
   }
 
   const paymentCurrency = await PaymentCurrency.findByPk(currencyId);
@@ -945,16 +1029,36 @@ export async function ensureSubscriptionForCollectBatch(subscriptionId: string,
     throw new Error(`PaymentCurrency ${currencyId} not found when prepare batch collect`);
   }
 
+  let subscription;
+  let searchCustomerId = customerId;
+
+  if (subscriptionId) {
+    subscription = await Subscription.findByPk(subscriptionId);
+    if (!subscription) {
+      throw new Error(`Subscription ${subscriptionId} not found when prepare batch collect`);
+    }
+    searchCustomerId = subscription.customer_id;
+  } else if (customerId) {
+    const customer = await Customer.findByPkOrDid(customerId);
+    if (!customer) {
+      throw new Error(`Customer ${customerId} not found when prepare batch collect`);
+    }
+    searchCustomerId = customer.id;
+  }
+
   const [summary, detail] = await Invoice.getUncollectibleAmount({
-    subscriptionId: subscription.id,
-    customerId: subscription.customer_id,
+    ...(subscriptionId ? { subscriptionId } : {}),
+    customerId: searchCustomerId,
     currencyId,
   });
   if (isEmpty(summary) || !summary[currencyId] || summary[currencyId] === '0') {
-    throw new Error(`No uncollectible invoice found for subscription ${subscriptionId} to batch collect`);
+    throw new Error('No uncollectible invoice found to batch collect');
   }
 
   const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+  if (!paymentMethod) {
+    throw new Error(`Payment method not found for currency ${currencyId}`);
+  }
 
   return {
     subscription,
@@ -1005,7 +1109,7 @@ export async function executeOcapTransactions(
   userPk: string,
   claims: any[],
   paymentMethod: PaymentMethod,
-  request: Request,
+  requestSource: Request | Request[] | any[],
   subscriptionId?: string,
   paymentCurrencyContract?: string,
   nonce?: string
@@ -1022,47 +1126,64 @@ export async function executeOcapTransactions(
   const stakingAmount =
     staking?.requirement?.tokens?.find((x: any) => x.address === paymentCurrencyContract)?.value || '0';
 
-    try {
-      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, client.pickGasPayerHeaders(request))
-          );
-    
-          return txHash;
-        })
-      );
+  try {
+    const getHeaders = (index: number): Record<string, string> => {
+      if (Array.isArray(requestSource)) {
+        if (requestSource.length === 0) {
+          return {};
+        }
+        const headerIndex = index < requestSource.length ? index : 0;
+        const req = requestSource[headerIndex];
+        return req ? client.pickGasPayerHeaders(req) : {};
+      }
       
-      return {
-        tx_hash: delegationTxHash,
-        payer: userDid,
-        type: 'delegate',
-        staking: {
-          tx_hash: stakingTxHash,
-          address: await getCustomerStakeAddress(userDid, nonce || subscriptionId || ''),
-        },
-        stakingAmount,
-      };
-    } catch (err) {
-      logger.error('executeOcapTransactions failed', err);
-      throw err;
-    }
-}
+      if (requestSource && typeof requestSource === 'object') {
+        return client.pickGasPayerHeaders(requestSource);
+      }
+      
+      return {};
+    };
 
+    const [delegationTxHash, stakingTxHash] = await Promise.all(
+      transactions.map(async ([claim, type], index) => {
+        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 });
+        const gasPayerHeaders = getHeaders(index);
+        // @ts-ignore
+        const txHash = await client[`send${type}Tx`](
+          // @ts-ignore
+          { tx, wallet: fromPublicKey(userPk, toTypeInfo(userDid)) },
+          getGasPayerExtra(buffer, gasPayerHeaders)
+        );
+  
+        return txHash;
+      })
+    );
+
+    return {
+      tx_hash: delegationTxHash,
+      payer: userDid,
+      type: 'delegate',
+      staking: {
+        tx_hash: stakingTxHash,
+        address: await getCustomerStakeAddress(userDid, nonce || subscriptionId || ''),
+      },
+      stakingAmount,
+    };
+  } catch (err) {
+    logger.error('executeOcapTransactions failed', err);
+    throw err;
+  }
+}
 
 export async function updateStripeSubscriptionAfterChangePayment(setupIntent: SetupIntent, subscription: Subscription) {
   const { from_method: fromMethodId, to_method: toMethodId } = setupIntent.metadata || {};

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

@@ -129,6 +129,9 @@ export default {
     result.push({
       step,
       claim: claims?.[0],
+      stepRequest: {
+        headers: request?.headers,
+      },
     });
     const staking = result.find((x: any) => x.claim?.type === 'prepareTx' && x.claim?.meta?.purpose === 'staking');
     const isFinalStep = (paymentMethod.type === 'arcblock' && staking) || paymentMethod.type !== 'arcblock';
@@ -183,12 +186,19 @@ export default {
       if (invoice) {
         await invoice.update({ payment_settings: paymentSettings });
       }
+
+      const requestArray = result
+        .map((item: { stepRequest?: Request }) => item.stepRequest)
+        .filter(Boolean) as Request[];
+
+      const requestSource = requestArray.length > 0 ? requestArray : request;
+
       const { stakingAmount, ...paymentDetails } = await executeOcapTransactions(
         userDid,
         userPk,
         claimsList,
         paymentMethod,
-        request,
+        requestSource,
         subscription?.id,
         paymentCurrency?.contract
       );

package/api/src/routes/customers.ts

@@ -4,14 +4,26 @@ import Joi from 'joi';
 import pick from 'lodash/pick';
 import isEmail from 'validator/es/lib/isEmail';
 
-import { getStakeSummaryByDid, getTokenSummaryByDid } from '../integrations/arcblock/stake';
+import { Op } from 'sequelize';
+import { BN } from '@ocap/util';
+import { getStakeSummaryByDid, getTokenSummaryByDid, getTokenByAddress } from '../integrations/arcblock/stake';
 import { createListParamSchema, getWhereFromKvQuery, getWhereFromQuery, MetadataSchema } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { formatMetadata } from '../libs/util';
 import { Customer } from '../store/models/customer';
 import { blocklet } from '../libs/auth';
 import logger from '../libs/logger';
-import { Invoice } from '../store/models';
+import {
+  Invoice,
+  PaymentCurrency,
+  PaymentMethod,
+  Price,
+  Product,
+  Subscription,
+  SubscriptionItem,
+} from '../store/models';
+import { getSubscriptionPaymentAddress } from '../libs/subscription';
+import { expandLineItems } from '../libs/session';
 
 const router = Router();
 const auth = authenticate<Customer>({ component: true, roles: ['owner', 'admin'] });
@@ -102,7 +114,7 @@ router.get('/me', sessionMiddleware(), async (req, res) => {
           did: req.user.did,
           name: user.fullName,
           email: user.email,
-          phone: '',
+          phone: user.phone,
           address: {},
           description: user.remark,
           metadata: {},
@@ -166,16 +178,48 @@ router.get('/:id/overdue/invoices', auth, async (req, res) => {
     if (!doc) {
       return res.status(404).json({ error: 'Customer not found' });
     }
-    const [summary, detail, invoices] = await Invoice!.getUncollectibleAmount({
-      customerId: doc.id,
-      livemode: req.query.livemode ? !!req.query.livemode : doc.livemode,
+    const { rows: invoices, count } = await Invoice.findAndCountAll({
+      where: {
+        customer_id: doc.id,
+        status: ['uncollectible'],
+        amount_remaining: { [Op.gt]: '0' },
+      },
+      include: [
+        { model: PaymentCurrency, as: 'paymentCurrency' },
+        { model: PaymentMethod, as: 'paymentMethod' },
+      ],
+    });
+    if (count === 0) {
+      return res.json({
+        summary: null,
+        invoices: [],
+        subscriptionCount: 0,
+      });
+    }
+    const summary: Record<string, { amount: string; currency: PaymentCurrency; method: PaymentMethod }> = {};
+    invoices.forEach((invoice) => {
+      const key = invoice.currency_id;
+      if (!summary[key]) {
+        summary[key] = {
+          amount: '0',
+          // @ts-ignore
+          currency: invoice.paymentCurrency,
+          // @ts-ignore
+          method: invoice.paymentMethod,
+        };
+      }
+      if (invoice && summary[key]) {
+        // @ts-ignore
+        summary[key].amount = new BN(summary[key]?.amount || '0')
+          .add(new BN(invoice.amount_remaining || '0'))
+          .toString();
+      }
     });
     const subscriptionCount = new Set(invoices.map((x) => x.subscription_id)).size;
     return res.json({
       summary,
       invoices,
       subscriptionCount,
-      detail,
     });
   } catch (err) {
     logger.error(err);
@@ -183,6 +227,105 @@ router.get('/:id/overdue/invoices', auth, async (req, res) => {
   }
 });
 
+router.get('/recharge', sessionMiddleware(), async (req, res) => {
+  if (!req.user) {
+    return res.status(403).json({ error: 'Unauthorized' });
+  }
+  if (!req.query.currencyId) {
+    return res.status(400).json({ error: 'Currency ID is required' });
+  }
+  try {
+    const customer = await Customer.findByPkOrDid(req.user.did as string);
+    if (!customer) {
+      return res.status(404).json({ error: 'Customer not found' });
+    }
+
+    const paymentCurrency = await PaymentCurrency.findByPk(req.query.currencyId as string);
+    if (!paymentCurrency) {
+      return res.status(404).json({ error: 'Currency not found' });
+    }
+
+    const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+    if (!paymentMethod) {
+      return res.status(404).json({ error: 'Payment method not found' });
+    }
+
+    let subscriptions = await Subscription.findAll({
+      where: {
+        customer_id: customer.id,
+        currency_id: paymentCurrency.id,
+        status: {
+          [Op.in]: ['active', 'trialing', 'past_due'],
+        },
+      },
+      include: [{ model: SubscriptionItem, as: 'items' }],
+    });
+
+    const products = (await Product.findAll()).map((x) => x.toJSON());
+    const prices = (await Price.findAll()).map((x) => x.toJSON());
+    subscriptions = subscriptions.map((x) => x.toJSON());
+    // @ts-ignore
+    subscriptions.forEach((x) => expandLineItems(x.items, products, prices));
+
+    const relatedSubscriptions = subscriptions.filter((sub) => {
+      const payerAddress = getSubscriptionPaymentAddress(sub, paymentMethod.type);
+      return payerAddress === customer.did;
+    });
+
+    return res.json({
+      currency: {
+        ...paymentCurrency.toJSON(),
+        paymentMethod,
+      },
+      relatedSubscriptions,
+    });
+  } catch (err) {
+    logger.error('Error getting balance recharge info', err);
+    return res.status(500).json({ error: err.message });
+  }
+});
+
+// get address token
+router.get('/payer-token', sessionMiddleware(), async (req, res) => {
+  if (!req.user) {
+    return res.status(403).json({ error: 'Unauthorized' });
+  }
+  if (!req.query.currencyId) {
+    return res.status(400).json({ error: 'Currency ID is required' });
+  }
+  try {
+    const customer = await Customer.findByPkOrDid(req.user.did as string);
+    if (!customer) {
+      return res.status(404).json({ error: 'Customer not found' });
+    }
+
+    const paymentCurrency = await PaymentCurrency.findByPk(req.query.currencyId as string);
+    if (!paymentCurrency) {
+      return res.status(404).json({ error: 'Currency not found' });
+    }
+
+    const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+    if (!paymentMethod) {
+      return res.status(404).json({ error: 'Payment method not found' });
+    }
+
+    if (paymentMethod.type !== 'arcblock') {
+      return res.status(400).json({ error: `Payment method not supported: ${paymentMethod.type}` });
+    }
+
+    const paymentAddress = customer.did;
+    if (!paymentAddress) {
+      return res.status(400).json({ error: `Payment address not found for customer: ${customer.id}` });
+    }
+
+    const token = await getTokenByAddress(paymentAddress, paymentMethod, paymentCurrency);
+    return res.json({ token, paymentAddress });
+  } catch (err) {
+    logger.error('Error getting customer payer token', err);
+    return res.status(500).json({ error: err.message });
+  }
+});
+
 router.get('/:id', auth, async (req, res) => {
   try {
     const doc = await Customer.findByPkOrDid(req.params.id as string);