payment-kit 1.18.14 → 1.18.16

package/api/src/index.ts

@@ -39,6 +39,7 @@ import setupHandlers from './routes/connect/setup';
 import subscribeHandlers from './routes/connect/subscribe';
 import delegationHandlers from './routes/connect/delegation';
 import overdraftProtectionHandlers from './routes/connect/overdraft-protection';
+import rechargeAccountHandlers from './routes/connect/recharge-account';
 import { initialize } from './store/models';
 import { sequelize } from './store/sequelize';
 import { initUserHandler } from './integrations/blocklet/user';
@@ -74,6 +75,7 @@ handlers.attach(Object.assign({ app: router }, subscribeHandlers));
 handlers.attach(Object.assign({ app: router }, changePaymentHandlers));
 handlers.attach(Object.assign({ app: router }, changePlanHandlers));
 handlers.attach(Object.assign({ app: router }, rechargeHandlers));
+handlers.attach(Object.assign({ app: router }, rechargeAccountHandlers));
 handlers.attach(Object.assign({ app: router }, delegationHandlers));
 handlers.attach(Object.assign({ app: router }, overdraftProtectionHandlers));
 router.use('/api', routes);

package/api/src/libs/invoice.ts

@@ -363,7 +363,7 @@ export async function getStakingInvoices(subscription: Subscription): Promise<In
 
 type BaseInvoiceProps = {
   customer: Customer;
-  subscription?: Subscription;
+  subscription?: Subscription | null;
   currency_id: string;
   livemode: boolean;
   period_start: number;
@@ -660,17 +660,19 @@ export async function ensureRechargeInvoice(
     currency_id: string;
     metadata?: any;
     payment_settings?: any;
+    livemode?: boolean;
   },
-  subscription: Subscription,
+  subscription: Subscription | null,
   paymentMethod: PaymentMethod,
   customer: Customer
 ) {
   try {
+    const { livemode = true } = invoiceProps;
     const { invoice } = await createInvoiceWithItems({
       customer,
       subscription,
       currency_id: invoiceProps.currency_id,
-      livemode: subscription.livemode,
+      livemode: subscription?.livemode ?? livemode,
       period_start: dayjs().unix(),
       period_end: dayjs().unix(),
       status: 'paid',

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

@@ -99,6 +99,9 @@ export default {
     result.push({
       step,
       claim: claims?.[0],
+      stepRequest: {
+        headers: request?.headers,
+      },
     });
 
     // 判断是否为最后一步
@@ -164,12 +167,17 @@ export default {
 
     if (paymentMethod.type === 'arcblock') {
       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/change-plan.ts

@@ -113,6 +113,9 @@ export default {
     result.push({
       step,
       claim: claims?.[0],
+      stepRequest: {
+        headers: request?.headers,
+      },
     });
 
     // 判断是否为最后一步
@@ -171,12 +174,17 @@ export default {
     if (paymentMethod.type === 'arcblock') {
       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/collect-batch.ts

@@ -23,16 +23,18 @@ export default {
     authPrincipal: async ({ extraParams }: CallbackArgs) => {
       const { paymentMethod } = await ensureSubscriptionForCollectBatch(
         extraParams.subscriptionId,
-        extraParams.currencyId
+        extraParams.currencyId,
+        extraParams.customerId
       );
       return getAuthPrincipalClaim(paymentMethod, 'pay');
     },
   },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
-    const { subscriptionId, currencyId } = extraParams;
+    const { subscriptionId, currencyId, customerId } = extraParams;
     const { amount, invoices, paymentCurrency, paymentMethod } = await ensureSubscriptionForCollectBatch(
       subscriptionId,
-      currencyId
+      currencyId,
+      customerId
     );
 
     if (paymentMethod.type === 'arcblock') {
@@ -83,8 +85,8 @@ export default {
     throw new Error(`Payment method ${paymentMethod.type} not supported`);
   },
   onAuth: async ({ request, userDid, claims, extraParams }: CallbackArgs) => {
-    const { subscriptionId, currencyId } = extraParams;
-    const { invoices, paymentMethod } = await ensureSubscriptionForCollectBatch(subscriptionId, currencyId);
+    const { subscriptionId, currencyId, customerId } = extraParams;
+    const { invoices, paymentMethod } = await ensureSubscriptionForCollectBatch(subscriptionId, currencyId, customerId);
 
     const afterTxExecution = async (paymentDetails: any) => {
       const paymentIntents = await PaymentIntent.findAll({

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,7 +6,7 @@ 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';
@@ -481,6 +481,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 +953,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 +970,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 +1050,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 +1067,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
       );