payment-kit 1.21.16 → 1.22.0

package/api/src/libs/remote-signer.ts

@@ -0,0 +1,93 @@
+import { ethers, JsonRpcProvider, TransactionRequest } from 'ethers';
+import type { WalletObject } from '@ocap/wallet';
+
+/**
+ * Remote Signer that uses remote signing service for Ethereum transactions
+ * Implements required methods from AbstractSigner
+ */
+export class RemoteSigner extends ethers.AbstractSigner {
+  private wallet: WalletObject;
+
+  constructor(wallet: WalletObject, provider?: JsonRpcProvider) {
+    super(provider);
+    this.wallet = wallet;
+  }
+
+  /**
+   * Returns the address of the signer
+   * Required by AbstractSigner
+   */
+  getAddress(): Promise<string> {
+    return Promise.resolve(this.wallet.address);
+  }
+
+  /**
+   * Signs a transaction and returns the signed serialized transaction
+   * Required by AbstractSigner
+   */
+  async signTransaction(transaction: TransactionRequest): Promise<string> {
+    // Populate transaction fields (nonce, gasLimit, chainId, etc.)
+    const populatedTx = await this.populateTransaction(transaction);
+
+    // Remove 'from' field as it's not allowed in unsigned transactions
+    // The 'from' address is derived from the signature
+    const { from, ...txWithoutFrom } = populatedTx;
+
+    // Serialize unsigned transaction
+    const unsignedTx = ethers.Transaction.from(txWithoutFrom);
+    const serialized = unsignedTx.unsignedSerialized;
+
+    // Hash and sign via remote service using signETH (Ethereum-specific signing)
+    const hash = ethers.keccak256(serialized);
+    const signature = await this.wallet.signETH(hash, false); // hashBeforeSign=false because we already hashed
+
+    // Attach signature and return signed transaction
+    unsignedTx.signature = ethers.Signature.from(signature);
+    return unsignedTx.serialized;
+  }
+
+  /**
+   * Signs a message and returns the signature
+   * Required for message signing operations
+   */
+  async signMessage(message: string | Uint8Array): Promise<string> {
+    // Convert message to bytes if it's a string
+    const messageBytes = typeof message === 'string' ? ethers.toUtf8Bytes(message) : message;
+
+    // Calculate the Ethereum signed message hash
+    const messageHash = ethers.hashMessage(messageBytes);
+
+    // Sign via remote service using signETH (Ethereum-specific signing)
+    const signature = await this.wallet.signETH(messageHash, false); // hashBeforeSign=false because hashMessage already hashed
+
+    // Return signature as hex string
+    return ethers.hexlify(signature);
+  }
+
+  /**
+   * Signs typed data (EIP-712)
+   * Optional but useful for signing structured data
+   */
+  async signTypedData(
+    domain: ethers.TypedDataDomain,
+    types: Record<string, ethers.TypedDataField[]>,
+    value: Record<string, any>
+  ): Promise<string> {
+    // Calculate the EIP-712 hash
+    const hash = ethers.TypedDataEncoder.hash(domain, types, value);
+
+    // Sign via remote service using signETH (Ethereum-specific signing)
+    const signature = await this.wallet.signETH(hash, false); // hashBeforeSign=false because hash is already computed
+
+    // Return signature as hex string
+    return ethers.hexlify(signature);
+  }
+
+  /**
+   * Connects the signer to a new provider
+   * Required by AbstractSigner
+   */
+  connect(provider: JsonRpcProvider): RemoteSigner {
+    return new RemoteSigner(this.wallet, provider);
+  }
+}

package/api/src/libs/security.ts

@@ -1,6 +1,6 @@
 import { auth } from '@blocklet/sdk/lib/middlewares';
 import { getVerifyData, verify } from '@blocklet/sdk/lib/util/verify-sign';
-import getWallet from '@blocklet/sdk/lib/wallet';
+import { getWallet } from '@blocklet/sdk/lib/wallet';
 import type { NextFunction, Request, Response } from 'express';
 import type { Model } from 'sequelize';
 

package/api/src/libs/subscription.ts

@@ -1043,22 +1043,19 @@ export async function getSubscriptionStakeAmountSetup(
     logger.info('getSubscriptionStakeAmountSetup failed, no inputs', { txHash, info });
     return null;
   }
-  const amountRes: { [key: string]: BN } = {};
+  const amountRes: { [key: string]: string } = {};
   // calculate stake amount for each address
   inputs.forEach((input: any) => {
     const { tokens } = input;
     tokens.forEach((token: any) => {
       const { address, value } = token;
       if (amountRes[address]) {
-        amountRes[address] = amountRes[address].add(new BN(value));
+        amountRes[address] = new BN(amountRes[address]).add(new BN(value)).toString();
       } else {
-        amountRes[address] = new BN(value);
+        amountRes[address] = new BN(value).toString();
       }
     });
   });
-  Object.keys(amountRes).forEach((address) => {
-    amountRes[address] = amountRes[address].toString();
-  });
   logger.info('get subscription stake amount setup success', { txHash, amountRes });
   return amountRes;
 }
@@ -1489,7 +1486,7 @@ export async function slashOverdraftProtectionStake(subscription: Subscription,
         // @ts-ignore
         const { buffer } = await client.encodeSlashStakeTx({ tx: signed });
         // @ts-ignore
-        const txHash = await client.sendSlashStakeTx({ tx: signed, wallet }, getGasPayerExtra(buffer));
+        const txHash = await client.sendSlashStakeTx({ tx: signed, wallet }, await getGasPayerExtra(buffer));
 
         await paymentIntent.update({
           status: 'succeeded',

package/api/src/libs/util.ts

@@ -2,7 +2,7 @@ import crypto from 'crypto';
 import { Readable } from 'stream';
 import { buffer } from 'node:stream/consumers';
 import { getUrl } from '@blocklet/sdk/lib/component';
-import env from '@blocklet/sdk/lib/env';
+import { env } from '@blocklet/sdk/lib/env';
 import { getWalletDid } from '@blocklet/sdk/lib/did';
 import { toStakeAddress } from '@arcblock/did-util';
 import { customAlphabet } from 'nanoid';
@@ -603,3 +603,20 @@ export function formatNumber(
   const [left, right] = result.split('.');
   return right ? [left, trimEnd(right, '0')].filter(Boolean).join('.') : left;
 }
+
+export function formatLinkWithLocale(url: string, locale?: string) {
+  if (!locale || !url) {
+    return url;
+  }
+  try {
+    const urlObj = new URL(url);
+    urlObj.searchParams.set('locale', locale);
+    return urlObj.toString();
+  } catch (error) {
+    if (/[?&]locale=[^&]*/.test(url)) {
+      return url.replace(/([?&])locale=[^&]*/, `$1locale=${locale}`);
+    }
+    const separator = url.includes('?') ? '&' : '?';
+    return `${url}${separator}locale=${locale}`;
+  }
+}

package/api/src/libs/vendor-util/adapters/didnames-adapter.ts

@@ -94,7 +94,8 @@ export class DidnamesAdapter implements VendorAdapter {
       });
 
       // Generate bindDomainCap for this domain
-      const bindDomainCap = this.generateBindCap({
+      // eslint-disable-next-line no-await-in-loop
+      const bindDomainCap = await this.generateBindCap({
         domain,
         checkoutSessionId: orderData.checkoutSessionId,
       });
@@ -115,7 +116,8 @@ export class DidnamesAdapter implements VendorAdapter {
       };
 
       try {
-        const { headers, body } = VendorAuth.signRequestWithHeaders(updatedOrderData);
+        // eslint-disable-next-line no-await-in-loop
+        const { headers, body } = await VendorAuth.signRequestWithHeaders(updatedOrderData);
 
         // eslint-disable-next-line no-await-in-loop
         const response = await fetch(url, {
@@ -198,7 +200,13 @@ export class DidnamesAdapter implements VendorAdapter {
   /**
    * Generate bindDomainCap (binding capability) for domain authorization
    */
-  private generateBindCap({ domain, checkoutSessionId }: { domain: string; checkoutSessionId: string }): any {
+  private async generateBindCap({
+    domain,
+    checkoutSessionId,
+  }: {
+    domain: string;
+    checkoutSessionId: string;
+  }): Promise<any> {
     const now = Math.floor(Date.now() / 1000);
     const expireInMinutes = 30;
 
@@ -210,7 +218,7 @@ export class DidnamesAdapter implements VendorAdapter {
       nonce: uuidV4(),
     };
 
-    const signature = toBase58(wallet.sign(stableStringify(cap) || ''));
+    const signature = toBase58(await wallet.sign(stableStringify(cap) || ''));
 
     return {
       cap,
@@ -345,7 +353,7 @@ export class DidnamesAdapter implements VendorAdapter {
         customParams: params.customParams,
       };
 
-      const { headers, body } = VendorAuth.signRequestWithHeaders(returnRequest);
+      const { headers, body } = await VendorAuth.signRequestWithHeaders(returnRequest);
       const url = formatVendorUrl(vendorConfig, '/api/vendor/return');
       logger.info('submitting domain return to DID Names', {
         url,
@@ -449,7 +457,7 @@ export class DidnamesAdapter implements VendorAdapter {
   async getOrder(vendor: ProductVendor, orderId: string): Promise<any> {
     const url = formatVendorUrl(vendor, `/api/vendor/orders/${orderId}`);
 
-    const { headers } = VendorAuth.signRequestWithHeaders({});
+    const { headers } = await VendorAuth.signRequestWithHeaders({});
     const response = await fetch(url, { method: 'GET', headers });
 
     if (!response.ok) {
@@ -474,7 +482,7 @@ export class DidnamesAdapter implements VendorAdapter {
       orderId,
     });
 
-    const { headers } = VendorAuth.signRequestWithHeaders({});
+    const { headers } = await VendorAuth.signRequestWithHeaders({});
     const response = await fetch(url, { method: 'GET', headers });
 
     logger.info('didnames order status response', {
@@ -499,9 +507,9 @@ export class DidnamesAdapter implements VendorAdapter {
     return data;
   }
 
-  connectTest(): Promise<any> {
+  async connectTest(): Promise<any> {
     const url = formatVendorUrl(this.vendorConfig!, '/api/vendor/health');
-    const { headers } = VendorAuth.signRequestWithHeaders({});
+    const { headers } = await VendorAuth.signRequestWithHeaders({});
     return fetch(url, { headers }).then((res) => res.json());
   }
 }

package/api/src/libs/vendor-util/adapters/launcher-adapter.ts

@@ -17,8 +17,13 @@ import {
 } from './types';
 import { formatVendorUrl } from './util';
 
-const doRequestVendorData = (vendor: ProductVendor, orderId: string, url: string, options: { shortUrl: boolean }) => {
-  const { headers } = VendorAuth.signRequestWithHeaders({});
+const doRequestVendorData = async (
+  vendor: ProductVendor,
+  orderId: string,
+  url: string,
+  options: { shortUrl: boolean }
+) => {
+  const { headers } = await VendorAuth.signRequestWithHeaders({});
   const name = vendor?.name;
   const key = vendor?.vendor_key;
   const { shortUrl } = options;
@@ -124,7 +129,7 @@ export class LauncherAdapter implements VendorAdapter {
         };
       }
 
-      const { headers, body } = VendorAuth.signRequestWithHeaders(orderData);
+      const { headers, body } = await VendorAuth.signRequestWithHeaders(orderData);
       const url = formatVendorUrl(vendorConfig, '/api/vendor/deliveries');
       const response = await fetch(url, {
         method: 'POST',
@@ -207,7 +212,7 @@ export class LauncherAdapter implements VendorAdapter {
     });
 
     const vendorConfig = await this.getVendorConfig();
-    const { headers, body } = VendorAuth.signRequestWithHeaders(params);
+    const { headers, body } = await VendorAuth.signRequestWithHeaders(params);
 
     const response = await fetch(formatVendorUrl(vendorConfig, '/api/vendor/return'), {
       method: 'POST',
@@ -268,9 +273,9 @@ export class LauncherAdapter implements VendorAdapter {
     return doRequestVendorData(vendor, orderId, url, options);
   }
 
-  connectTest(): Promise<any> {
+  async connectTest(): Promise<any> {
     const url = formatVendorUrl(this.vendorConfig!, '/api/vendor/health');
-    const { headers } = VendorAuth.signRequestWithHeaders({});
+    const { headers } = await VendorAuth.signRequestWithHeaders({});
     return fetch(url, { headers }).then((res) => res.json());
   }
 }

package/api/src/queues/payment.ts

@@ -754,7 +754,7 @@ const handleStakeSlash = async (
   // @ts-ignore
   const { buffer } = await client.encodeSlashStakeTx({ tx: signed });
   // @ts-ignore
-  const txHash = await client.sendSlashStakeTx({ tx: signed, wallet }, getGasPayerExtra(buffer));
+  const txHash = await client.sendSlashStakeTx({ tx: signed, wallet }, await getGasPayerExtra(buffer));
   logger.info('Stake slashing done', {
     subscription: subscription.id,
     amount: slashAmount,
@@ -973,7 +973,7 @@ export const handlePayment = async (job: PaymentJob) => {
       const txHash = await client.sendTransferV2Tx(
         // @ts-ignore
         { tx: signed, wallet, delegator: result.delegator },
-        getGasPayerExtra(buffer)
+        await getGasPayerExtra(buffer)
       );
       logger.info('PaymentIntent txHash', { txHash });
       logger.info('PaymentIntent capture done', { id: paymentIntent.id, txHash });

package/api/src/queues/payout.ts

@@ -82,7 +82,7 @@ async function processArcblockPayout(payout: Payout, paymentMethod: PaymentMetho
   // @ts-ignore
   const { buffer } = await client.encodeTransferV2Tx({ tx: signed });
   // @ts-ignore
-  const txHash = await client.sendTransferV2Tx({ tx: signed, wallet }, getGasPayerExtra(buffer));
+  const txHash = await client.sendTransferV2Tx({ tx: signed, wallet }, await getGasPayerExtra(buffer));
 
   logger.info('Payout completed', { id: payout.id, txHash });
 

package/api/src/queues/refund.ts

@@ -167,7 +167,7 @@ const handleRefundJob = async (
       // @ts-ignore
       const { buffer } = await client.encodeTransferV2Tx({ tx: signed });
       // @ts-ignore
-      const txHash = await client.sendTransferV2Tx({ tx: signed, wallet }, getGasPayerExtra(buffer));
+      const txHash = await client.sendTransferV2Tx({ tx: signed, wallet }, await getGasPayerExtra(buffer));
 
       logger.info('refund transfer done', { id: refund.id, txHash });
       await refund.update({
@@ -366,7 +366,7 @@ const handleStakeReturnJob = async (
       // @ts-ignore
       const { buffer } = await client.encodeReturnStakeTx({ tx: signed });
       // @ts-ignore
-      const txHash = await client.sendReturnStakeTx({ tx: signed, wallet }, getGasPayerExtra(buffer));
+      const txHash = await client.sendReturnStakeTx({ tx: signed, wallet }, await getGasPayerExtra(buffer));
       logger.info('stake return done', { id: refund.id, txHash });
       await refund.update({
         status: 'succeeded',

package/api/src/queues/subscription.ts

@@ -743,7 +743,7 @@ export const handleStakeSlashAfterCancel = async (subscription: Subscription, fo
     // @ts-ignore
     const { buffer } = await client.encodeSlashStakeTx({ tx: signed });
     // @ts-ignore
-    const txHash = await client.sendSlashStakeTx({ tx: signed, wallet }, getGasPayerExtra(buffer));
+    const txHash = await client.sendSlashStakeTx({ tx: signed, wallet }, await getGasPayerExtra(buffer));
     logger.info('Stake slashing done', {
       subscription: subscription.id,
       amount: invoice.amount_remaining,

package/api/src/queues/usage-record.ts

@@ -108,7 +108,7 @@ export const doHandleUsageRecord = async (job: UsageRecordJob) => {
     rawQuantity,
     quantity,
 
-    unitAmount: fromUnitToToken(unitAmount, currency.decimal),
+    unitAmount: fromUnitToToken(unitAmount || '0', currency.decimal),
     totalAmount: fromUnitToToken(totalAmount.toString(), currency.decimal),
     threshold: fromUnitToToken(threshold.toString(), currency.decimal),
   });

package/api/src/queues/vendors/status-check.ts

@@ -103,7 +103,7 @@ export const handleVendorStatusCheck = async (job: VendorStatusCheckJob) => {
           '/api/vendor/status',
           vendor.order_id
         );
-        const { headers } = VendorAuth.signRequestWithHeaders({});
+        const { headers } = await VendorAuth.signRequestWithHeaders({});
 
         const result = await fetch(serverStatusUrl, { headers });
         const data = await result.json();

package/api/src/queues/webhook.ts

@@ -63,7 +63,7 @@ export const handleWebhook = async (job: WebhookJob) => {
       headers: {
         'x-app-id': wallet.address,
         'x-app-pk': wallet.publicKey,
-        'x-component-sig': sign(json),
+        'x-component-sig': await sign(json),
         'x-component-did': process.env.BLOCKLET_COMPONENT_DID as string,
       },
     });

package/api/src/routes/auto-recharge-configs.ts

@@ -3,7 +3,7 @@ import Joi from 'joi';
 
 import { CustomError } from '@blocklet/error';
 import { Op } from 'sequelize';
-import sessionMiddleware from '@blocklet/sdk/lib/middlewares/session';
+import { sessionMiddleware } from '@blocklet/sdk/lib/middlewares/session';
 import { BN, fromTokenToUnit, fromUnitToToken } from '@ocap/util';
 import { trimDecimals } from '../libs/math-utils';
 import {

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

@@ -1,7 +1,7 @@
 /* eslint-disable consistent-return */
 import { isValid } from '@arcblock/did';
 import { getUrl } from '@blocklet/sdk/lib/component';
-import sessionMiddleware from '@blocklet/sdk/lib/middlewares/session';
+import { sessionMiddleware } from '@blocklet/sdk/lib/middlewares/session';
 import { BN, fromUnitToToken } from '@ocap/util';
 import { NextFunction, Request, Response, Router } from 'express';
 import Joi from 'joi';
@@ -390,7 +390,7 @@ export async function calculateAndUpdateAmount(
     amount,
   });
 
-  if (checkoutSession.mode === 'payment' && amount.total < 0) {
+  if (checkoutSession.mode === 'payment' && new BN(amount.total || '0').lt(new BN('0'))) {
     throw new Error('Payment amount should be greater or equal to 0');
   }
 
@@ -2149,10 +2149,6 @@ router.post('/:id/fast-checkout-confirm', user, ensureCheckoutSessionOpen, async
       return res.status(400).json({ error: 'Payment method not found' });
     }
 
-    if (paymentMethod.type !== 'arcblock') {
-      return res.status(400).json({ error: 'Payment method not supported for fast checkout' });
-    }
-
     // Validate checkout session ownership if it was created for a specific customer
     if (checkoutSession.customer_id && checkoutSession.metadata?.createdBy) {
       const createdByDid = checkoutSession.metadata.createdBy;
@@ -2355,6 +2351,8 @@ router.post('/:id/fast-checkout-confirm', user, ensureCheckoutSessionOpen, async
         };
         canFastPay = true;
       }
+    } else if (paymentMethod.type !== 'arcblock') {
+      return res.status(400).json({ error: 'Payment method not supported for fast checkout' });
     }
 
     logger.info('Checkout session submitted successfully', {

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

@@ -0,0 +1,148 @@
+import { executeEvmTransaction, waitForEvmTxConfirm } from '../../integrations/ethereum/tx';
+import type { CallbackArgs } from '../../libs/auth';
+import { getTxMetadata } from '../../libs/util';
+import { type TLineItemExpanded } from '../../store/models';
+import {
+  ensurePayerChangeContext,
+  executeOcapTransactions,
+  getAuthPrincipalClaim,
+  getDelegationTxClaim,
+} from './shared';
+import { EVM_CHAIN_TYPES } from '../../libs/constants';
+
+export default {
+  action: 'change-payer',
+  authPrincipal: false,
+  persistentDynamicClaims: true,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensurePayerChangeContext(extraParams.subscriptionId);
+      return getAuthPrincipalClaim(paymentMethod, 'continue');
+    },
+  },
+  onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
+    const { subscriptionId } = extraParams;
+    const { subscription, paymentMethod, paymentCurrency, payerAddress } =
+      await ensurePayerChangeContext(subscriptionId);
+
+    if (userDid === payerAddress) {
+      throw new Error('The current payer is the same as the new payer, please use another account to change payer');
+    }
+    const claimsList: any[] = [];
+    // @ts-ignore
+    const items = subscription!.items as TLineItemExpanded[];
+    const trialing = true;
+    const billingThreshold = Number(subscription.billing_thresholds?.amount_gte || 0);
+
+    if (paymentMethod.type === 'arcblock') {
+      claimsList.push({
+        signature: await getDelegationTxClaim({
+          mode: 'delegation',
+          userDid,
+          userPk,
+          nonce: subscription.id,
+          data: getTxMetadata({ subscriptionId: subscription.id }),
+          paymentCurrency,
+          paymentMethod,
+          trialing,
+          billingThreshold,
+          items,
+          requiredStake: false,
+        }),
+      });
+      return claimsList;
+    }
+
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
+      if (!paymentCurrency.contract) {
+        throw new Error(`Payment currency ${paymentMethod.type}:${paymentCurrency.id} does not support subscription`);
+      }
+
+      claimsList.push({
+        signature: await getDelegationTxClaim({
+          mode: 'subscription',
+          userDid,
+          userPk,
+          nonce: `change-payer-${subscription!.id}`,
+          data: getTxMetadata({ subscriptionId: subscription!.id }),
+          paymentCurrency,
+          paymentMethod,
+          trialing,
+          billingThreshold,
+          items,
+        }),
+      });
+
+      return claimsList;
+    }
+
+    throw new Error(`ChangePayer: Payment method ${paymentMethod.type} not supported`);
+  },
+
+  onAuth: async ({ request, userDid, userPk, claims, extraParams, step }: CallbackArgs) => {
+    const { subscriptionId } = extraParams;
+    const { subscription, paymentMethod, paymentCurrency } = await ensurePayerChangeContext(subscriptionId);
+
+    const result = request?.context?.store?.result || [];
+    result.push({
+      step,
+      claim: claims?.[0],
+      stepRequest: {
+        headers: request?.headers,
+      },
+    });
+    const claimsList = result.map((x: any) => x.claim);
+
+    const afterTxExecution = async (paymentDetails: any) => {
+      await subscription?.update({
+        payment_settings: {
+          payment_method_types: [paymentMethod.type],
+          payment_method_options: {
+            [paymentMethod.type]: { payer: userDid },
+          },
+        },
+        payment_details: {
+          ...subscription.payment_details,
+          [paymentMethod.type]: {
+            ...(subscription.payment_details?.[paymentMethod.type as keyof typeof subscription.payment_details] || {}),
+            type: 'delegate',
+            payer: userDid,
+            tx_hash: paymentDetails.tx_hash,
+          },
+        },
+      });
+    };
+
+    if (paymentMethod.type === 'arcblock') {
+      const requestArray = result
+        .map((item: { stepRequest?: Request }) => item.stepRequest)
+        .filter(Boolean) as Request[];
+      const requestSource = requestArray.length > 0 ? requestArray : request;
+
+      const paymentDetails = await executeOcapTransactions(
+        userDid,
+        userPk,
+        claimsList,
+        paymentMethod,
+        requestSource,
+        subscription?.id,
+        paymentCurrency.contract
+      );
+
+      await afterTxExecution(paymentDetails);
+      return { hash: paymentDetails.tx_hash };
+    }
+
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
+      const paymentDetails = await executeEvmTransaction('approve', userDid, claimsList, paymentMethod);
+      waitForEvmTxConfirm(paymentMethod.getEvmClient(), +paymentDetails.block_height, paymentMethod.confirmation.block)
+        .then(async () => {
+          await afterTxExecution(paymentDetails);
+        })
+        .catch(console.error);
+      return { hash: paymentDetails.tx_hash };
+    }
+
+    throw new Error(`ChangePayer: Payment method ${paymentMethod.type} not supported`);
+  },
+};

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

@@ -136,7 +136,7 @@ export default {
       const txHash = await client.sendTransferV3Tx(
         // @ts-ignore
         { tx, wallet: fromAddress(userDid) },
-        getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
+        await getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
       );
       await afterTxExecution({ tx_hash: txHash, payer: userDid, type: 'transfer' });
 

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

@@ -155,7 +155,7 @@ export default {
         const txHash = await client.sendTransferV3Tx(
           // @ts-ignore
           { tx, wallet: fromAddress(userDid) },
-          getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
+          await getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
         );
 
         await afterTxExecution({

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

@@ -115,7 +115,7 @@ export default {
         const txHash = await client.sendTransferV3Tx(
           // @ts-ignore
           { tx, wallet: fromAddress(userDid) },
-          getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
+          await getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
         );
 
         await paymentIntent.update({

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

@@ -149,7 +149,7 @@ export default {
         const txHash = await client.sendTransferV3Tx(
           // @ts-ignore
           { tx, wallet: fromAddress(userDid) },
-          getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
+          await getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
         );
 
         await afterTxExecution({

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

@@ -128,7 +128,7 @@ export default {
         const txHash = await client.sendTransferV3Tx(
           // @ts-ignore
           { tx, wallet: fromAddress(userDid) },
-          getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
+          await getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
         );
 
         logger.info('Recharge successful', {