payment-kit 1.18.24 → 1.18.25

package/api/src/libs/event.ts

@@ -13,8 +13,28 @@ export const events = new EventEmitter() as MyEventType;
 
 export const emitAsync = (event: string, ...args: any[]) => {
   return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error(`Event ${event} timed out after 10000ms`));
+    }, 10000);
+
+    const cleanup = () => {
+      clearTimeout(timeout);
+      events.removeListener(`${event}.done`, handleDone);
+      events.removeListener(`${event}.error`, handleError);
+    };
+
+    const handleDone = (...results: any[]) => {
+      cleanup();
+      resolve(results.length > 1 ? results : results[0]);
+    };
+
+    const handleError = (error: any) => {
+      cleanup();
+      reject(error);
+    };
+    events.once(`${event}.done`, handleDone);
+    events.once(`${event}.error`, handleError);
     events.emit(event, ...args);
-    events.once(`${event}.done`, resolve);
-    events.once(`${event}.error`, reject);
   });
 };

package/api/src/libs/invoice.ts

@@ -23,6 +23,7 @@ import {
   TInvoice,
   TLineItemExpanded,
   UsageRecord,
+  Lock,
 } from '../store/models';
 import { getConnectQueryParam } from './util';
 import { expandLineItems, getPriceUintAmountByCurrency } from './session';
@@ -37,6 +38,7 @@ import {
 import logger from './logger';
 import { ensureOverdraftProtectionPrice } from './overdraft-protection';
 import { CHARGE_SUPPORTED_CHAIN_TYPES } from './constants';
+import { emitAsync } from './event';
 
 export function getCustomerInvoicePageUrl({
   invoiceId,
@@ -930,3 +932,143 @@ export async function handleOverdraftProtectionInvoiceAfterPayment(invoice: Invo
     });
   }
 }
+
+/**
+ * retry uncollectible invoices
+ * @param options
+ */
+export async function retryUncollectibleInvoices(options: {
+  customerId?: string;
+  subscriptionId?: string;
+  invoiceId?: string;
+  invoiceIds?: string[];
+  currencyId?: string;
+}) {
+  const lockKey = `retry-uncollectible-${JSON.stringify(options)}`;
+
+  const isLocked = await Lock.isLocked(lockKey);
+  if (isLocked) {
+    logger.warn('Retry uncollectible invoices already in progress', {
+      lockKey,
+      options,
+    });
+    throw new Error('Retry already in progress');
+  }
+
+  try {
+    await Lock.acquire(lockKey, dayjs().add(5, 'minutes').unix());
+
+    const { customerId, subscriptionId, invoiceId, invoiceIds, currencyId } = options;
+
+    const where: any = {
+      status: { [Op.in]: ['uncollectible'] },
+      payment_intent_id: { [Op.ne]: null },
+    };
+
+    if (customerId) {
+      where.customer_id = customerId;
+    }
+
+    if (subscriptionId) {
+      where.subscription_id = subscriptionId;
+    }
+
+    if (invoiceId) {
+      where.id = invoiceId;
+    }
+
+    if (invoiceIds && invoiceIds.length > 0) {
+      where.id = { [Op.in]: invoiceIds };
+    }
+
+    if (currencyId) {
+      where.currency_id = currencyId;
+    }
+
+    const overdueInvoices = (await Invoice.findAll({
+      where,
+      include: [{ model: PaymentIntent, as: 'paymentIntent' }],
+      attributes: ['id', 'payment_intent_id', 'subscription_id', 'customer_id', 'created_at', 'status', 'currency_id'],
+      order: [['created_at', 'ASC']],
+    })) as (Invoice & { paymentIntent?: PaymentIntent })[];
+
+    const startTime = Date.now();
+    logger.info('Found uncollectible invoices to retry', {
+      count: overdueInvoices.length,
+      criteria: options,
+      invoiceIds: overdueInvoices.map((inv) => inv.id),
+    });
+
+    const results = {
+      processed: overdueInvoices.length,
+      successful: [] as string[],
+      failed: [] as Array<{ id: string; reason: string }>,
+    };
+
+    const settledResults = await Promise.allSettled(
+      overdueInvoices.map(async (invoice) => {
+        const { paymentIntent } = invoice;
+        if (!paymentIntent) {
+          throw new Error('No payment intent found');
+        }
+
+        await paymentIntent.update({ status: 'requires_capture' });
+        await emitAsync(
+          'payment.queued',
+          paymentIntent.id,
+          { paymentIntentId: paymentIntent.id, retryOnError: true, ignoreMaxRetryCheck: true },
+          { sync: false }
+        );
+
+        return invoice;
+      })
+    );
+
+    settledResults.forEach((result, index) => {
+      const invoice = overdueInvoices[index];
+      if (!invoice) {
+        return;
+      }
+      if (result.status === 'fulfilled') {
+        results.successful.push(invoice.id);
+        logger.info('Successfully queued uncollectible invoice retry', {
+          invoiceId: invoice.id,
+          customerId: invoice.customer_id,
+          paymentIntentId: invoice.payment_intent_id,
+        });
+      } else {
+        const error = result.reason;
+        const errorType = error.name || 'Unknown';
+        const errorCode = error.code || 'UNKNOWN_ERROR';
+
+        results.failed.push({
+          id: invoice.id,
+          reason: error.message || 'Unknown error',
+        });
+
+        logger.error('Failed to queue uncollectible invoice retry', {
+          invoiceId: invoice.id,
+          customerId: invoice.customer_id,
+          subscriptionId: invoice.subscription_id,
+          paymentIntentId: invoice.payment_intent_id,
+          errorType,
+          errorCode,
+          error,
+        });
+      }
+    });
+
+    const processingTime = Date.now() - startTime;
+    logger.info('Completed retrying uncollectible invoices', {
+      totalProcessed: results.processed,
+      successful: results.successful.length,
+      failed: results.failed.length,
+      processingTimeMs: processingTime,
+    });
+
+    return results;
+  } finally {
+    await Lock.release(lockKey);
+    logger.info('Released retry uncollectible lock', { lockKey });
+  }
+}

package/api/src/queues/invoice.ts

@@ -289,16 +289,30 @@ events.on('invoice.queued', async (id, job, args = {}) => {
         job,
         ...extraArgs,
       });
-      events.emit('invoice.queued.done');
+      events.emit('invoice.queued.done', { id });
     } catch (error) {
       logger.error('Error in invoice.queued', { id, job, error });
-      events.emit('invoice.queued.error', error);
+      events.emit('invoice.queued.error', { id, job, error });
     }
     return;
   }
-  invoiceQueue.push({
-    id,
-    job,
-    ...extraArgs,
-  });
+  try {
+    const existJob = await invoiceQueue.get(id);
+    if (existJob) {
+      await invoiceQueue.delete(id);
+      logger.info('Removed existing invoice job for immediate execution', {
+        id,
+        originalRunAt: existJob.runAt,
+      });
+    }
+    invoiceQueue.push({
+      id,
+      job,
+      ...extraArgs,
+    });
+    events.emit('invoice.queued.done', { id });
+  } catch (error) {
+    logger.error('Error in invoice.queued', { id, job, error });
+    events.emit('invoice.queued.error', { id, job, error });
+  }
 });

package/api/src/queues/payment.ts

@@ -45,6 +45,8 @@ type PaymentJob = {
   paymentIntentId: string;
   paymentSettings?: PaymentSettings;
   retryOnError?: boolean;
+  ignoreMaxRetryCheck?: boolean;
+  immediateRetry?: boolean;
 };
 
 type DepositVaultJob = {
@@ -721,7 +723,7 @@ export const handlePayment = async (job: PaymentJob) => {
   }
 
   // check max retry before doing any hard work
-  if (invoice && invoice.attempt_count >= MAX_RETRY_COUNT) {
+  if (invoice && invoice.attempt_count >= MAX_RETRY_COUNT && !job.ignoreMaxRetryCheck) {
     logger.info('PaymentIntent capture aborted since max retry exceeded', { id: paymentIntent.id });
     const updates = await handlePaymentFailed(
       paymentIntent,
@@ -882,7 +884,7 @@ export const handlePayment = async (job: PaymentJob) => {
     };
 
     if (!job.retryOnError) {
-      // To a final state without any retry
+      //  To a final state without any retry
       await paymentIntent.update({ status: 'requires_action', last_payment_error: error });
       if (invoice) {
         await invoice.update({
@@ -924,7 +926,6 @@ export const handlePayment = async (job: PaymentJob) => {
           }
         }
       }
-
       // reschedule next attempt
       const retryAt = updates.invoice.next_payment_attempt;
       if (retryAt) {
@@ -993,16 +994,31 @@ events.on('payment.queued', async (id, job, args = {}) => {
         job,
         ...extraArgs,
       });
-      events.emit('payment.queued.done');
+      events.emit('payment.queued.done', { id, job });
     } catch (error) {
       logger.error('Error in payment.queued', { id, job, error });
-      events.emit('payment.queued.error', error);
+      events.emit('payment.queued.error', { id, job, error });
     }
     return;
   }
-  paymentQueue.push({
-    id,
-    job,
-    ...extraArgs,
-  });
+
+  try {
+    const existingJob = await paymentQueue.get(id);
+    if (existingJob) {
+      await paymentQueue.delete(id);
+      logger.info('Removed existing payment job for immediate execution', {
+        id,
+        originalRunAt: existingJob.runAt,
+      });
+    }
+    paymentQueue.push({
+      id,
+      job,
+      ...extraArgs,
+    });
+    events.emit('payment.queued.done', { id, job });
+  } catch (error) {
+    logger.error('Error in payment.queued', { id, job, error });
+    events.emit('payment.queued.error', { id, job, error });
+  }
 });

package/api/src/queues/payout.ts

@@ -282,16 +282,30 @@ events.on('payout.queued', async (id, job, args = {}) => {
         job,
         ...extraArgs,
       });
-      events.emit('payout.queued.done');
+      events.emit('payout.queued.done', { id, job });
     } catch (error) {
       logger.error('Error in payout.queued', { id, job, error });
-      events.emit('payout.queued.error', error);
+      events.emit('payout.queued.error', { id, job, error });
     }
     return;
   }
-  payoutQueue.push({
-    id,
-    job,
-    ...extraArgs,
-  });
+  try {
+    const existJob = await payoutQueue.get(id);
+    if (existJob) {
+      await payoutQueue.delete(id);
+      logger.info('Removed existing payout job for immediate execution', {
+        id,
+        originalRunAt: existJob.runAt,
+      });
+    }
+    payoutQueue.push({
+      id,
+      job,
+      ...extraArgs,
+    });
+    events.emit('payout.queued.done', { id, job });
+  } catch (error) {
+    logger.error('Error in payout.queued', { id, job, error });
+    events.emit('payout.queued.error', { id, job, error });
+  }
 });

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

@@ -856,10 +856,17 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       });
       logger.info('customer created on checkout session submit', { did: req.user.did, id: customer.id });
       try {
-        await blocklet.updateUserAddress({
-          did: customer.did,
-          address: Customer.formatAddressFromCustomer(customer),
-        });
+        await blocklet.updateUserAddress(
+          {
+            did: customer.did,
+            address: Customer.formatAddressFromCustomer(customer),
+          },
+          {
+            headers: {
+              cookie: req.headers.cookie || '',
+            },
+          }
+        );
         logger.info('updateUserAddress success', {
           did: customer.did,
         });
@@ -870,14 +877,14 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         });
       }
     } else {
-      const updates: Record<string, string> = {};
+      const updates: Record<string, any> = {};
       if (checkoutSession.customer_update?.name) {
         updates.name = req.body.customer_name;
         updates.email = req.body.customer_email;
         updates.phone = req.body.customer_phone;
       }
       if (checkoutSession.customer_update?.address) {
-        updates.address = req.body.billing_address;
+        updates.address = Customer.formatUpdateAddress(req.body.billing_address, customer);
       }
       if (!customer.invoice_prefix) {
         updates.invoice_prefix = Customer.getInvoicePrefix();
@@ -885,12 +892,19 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
 
       await customer.update(updates);
       try {
-        await blocklet.updateUserAddress({
-          did: customer.did,
-          address: Customer.formatAddressFromCustomer(customer),
-          // @ts-ignore
-          phone: customer.phone,
-        });
+        await blocklet.updateUserAddress(
+          {
+            did: customer.did,
+            address: Customer.formatAddressFromCustomer(customer),
+            // @ts-ignore
+            phone: customer.phone,
+          },
+          {
+            headers: {
+              cookie: req.headers.cookie || '',
+            },
+          }
+        );
         logger.info('updateUserAddress success', {
           did: customer.did,
         });

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

@@ -6,7 +6,7 @@ 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';
+import { ensureRechargeInvoice, retryUncollectibleInvoices } from '../../libs/invoice';
 
 export default {
   action: 'recharge-account',
@@ -86,6 +86,18 @@ export default {
         paymentMethod,
         customer!
       );
+      try {
+        retryUncollectibleInvoices({
+          customerId: customer.id,
+          currencyId: paymentCurrency.id,
+        });
+      } catch (err) {
+        logger.error('Failed to retry uncollectible invoices', {
+          error: err,
+          customerId: customer.id,
+          currencyId: paymentCurrency.id,
+        });
+      }
     };
     if (paymentMethod.type === 'arcblock') {
       try {

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

@@ -8,7 +8,7 @@ import { getGasPayerExtra } from '../../libs/payment';
 import { getTxMetadata } from '../../libs/util';
 import { ensureSubscriptionRecharge, getAuthPrincipalClaim } from './shared';
 import logger from '../../libs/logger';
-import { ensureRechargeInvoice } from '../../libs/invoice';
+import { ensureRechargeInvoice, retryUncollectibleInvoices } from '../../libs/invoice';
 import { EVMChainType } from '../../store/models';
 import { EVM_CHAIN_TYPES } from '../../libs/constants';
 
@@ -99,6 +99,18 @@ export default {
         paymentMethod,
         customer!
       );
+      try {
+        retryUncollectibleInvoices({
+          currencyId: paymentCurrency.id,
+          subscriptionId,
+        });
+      } catch (err) {
+        logger.error('Failed to retry uncollectible invoices', {
+          error: err,
+          currencyId: paymentCurrency.id,
+          subscriptionId,
+        });
+      }
     };
     if (paymentMethod.type === 'arcblock') {
       try {

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

@@ -1105,6 +1105,29 @@ export async function ensureSubscriptionForOverdraftProtection(subscriptionId: s
   };
 }
 
+
+async function executeSingleTransaction(
+  client: any,
+  claim: any,
+  type: 'Delegate' | 'Stake',
+  userDid: string,
+  userPk: string,
+  gasPayerHeaders: Record<string, string>
+): Promise<string> {
+  if (!claim) return '';
+
+  const tx: Partial<Transaction> = client.decodeTx(claim.finalTx || claim.origin);
+  if (claim.sig) {
+    tx.signature = claim.sig;
+  }
+
+  const { buffer } = await client[`encode${type}Tx`]({ tx });
+  return client[`send${type}Tx`](
+    { tx, wallet: fromPublicKey(userPk, toTypeInfo(userDid)) },
+    getGasPayerExtra(buffer, gasPayerHeaders)
+  );
+}
+
 export async function executeOcapTransactions(
   userDid: string,
   userPk: string,
@@ -1116,16 +1139,14 @@ export async function executeOcapTransactions(
   nonce?: string
 ) {
   const client = paymentMethod.getOcapClient();
-  logger.info('start executeOcapTransactions', claims);
-  const delegation = claims.find((x) => x.type === 'signature' && x.meta?.purpose === 'delegation');
-  const staking = claims.find((x) => x.type === 'prepareTx' && x.meta?.purpose === 'staking');
-  const transactions = [
-    [delegation, 'Delegate'],
-    [staking, 'Stake'],
-  ];
-
-  const stakingAmount =
-    staking?.requirement?.tokens?.find((x: any) => x.address === paymentCurrencyContract)?.value || '0';
+  logger.info('start executeOcapTransactions', { userDid, claims });
+  
+  const delegation = claims.find(x => x.type === 'signature' && x.meta?.purpose === 'delegation');
+  const staking = claims.find(x => x.type === 'prepareTx' && x.meta?.purpose === 'staking');
+  
+  const stakingAmount = staking?.requirement?.tokens?.find(
+    (x: any) => x?.address === paymentCurrencyContract
+  )?.value || '0';
 
   try {
     const getHeaders = (index: number): Record<string, string> => {
@@ -1145,30 +1166,27 @@ export async function executeOcapTransactions(
       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;
-      })
-    );
+    const transactions = [
+      { claim: delegation, type: 'Delegate' },
+      { claim: staking, type: 'Stake' }
+    ];
+
+    const txHashes = [];
+    for (let i = 0; i < transactions.length; i++) {
+      const { claim, type } = transactions[i]!;
+      // eslint-disable-next-line no-await-in-loop
+      const hash = await executeSingleTransaction(
+        client,
+        claim,
+        type as 'Delegate' | 'Stake',
+        userDid,
+        userPk,
+        getHeaders(i)
+      );
+      txHashes.push(hash);
+    }
+
+    const [delegationTxHash, stakingTxHash] = txHashes;
 
     return {
       tx_hash: delegationTxHash,
@@ -1176,12 +1194,12 @@ export async function executeOcapTransactions(
       type: 'delegate',
       staking: {
         tx_hash: stakingTxHash,
-        address: await getCustomerStakeAddress(userDid, nonce || subscriptionId || ''),
+        address:  await getCustomerStakeAddress(userDid, nonce || subscriptionId || ''),
       },
       stakingAmount,
     };
   } catch (err) {
-    logger.error('executeOcapTransactions failed', err);
+    logger.error('executeOcapTransactions failed', { error: err, userDid });
     throw err;
   }
 }

package/api/src/routes/invoices.ts

@@ -21,7 +21,7 @@ import { PaymentMethod } from '../store/models/payment-method';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
 import { Subscription } from '../store/models/subscription';
-import { getReturnStakeInvoices, getStakingInvoices } from '../libs/invoice';
+import { getReturnStakeInvoices, getStakingInvoices, retryUncollectibleInvoices } from '../libs/invoice';
 import { CheckoutSession, PaymentLink, TInvoiceExpanded } from '../store/models';
 import logger from '../libs/logger';
 
@@ -253,6 +253,56 @@ router.get('/search', authMine, async (req, res) => {
   res.json({ count, list, paging: { page, pageSize } });
 });
 
+const retryUncollectibleSchema = Joi.object({
+  customerId: Joi.string().trim().allow('').optional(),
+  subscriptionId: Joi.string().trim().allow('').optional(),
+  invoiceId: Joi.string().trim().allow('').optional(),
+  invoiceIds: Joi.alternatives()
+    .try(
+      Joi.array().items(Joi.string().trim()),
+      Joi.string()
+        .trim()
+        .custom((value) => {
+          if (!value) return undefined;
+          return value
+            .split(',')
+            .map((id: string) => id.trim())
+            .filter(Boolean);
+        })
+    )
+    .optional(),
+  currencyId: Joi.string().trim().allow('').optional(),
+});
+router.get('/retry-uncollectible', authAdmin, async (req, res) => {
+  try {
+    const { error, value } = retryUncollectibleSchema.validate(req.query, {
+      stripUnknown: true,
+    });
+
+    if (error) {
+      return res.status(400).json({ error: error.message });
+    }
+
+    const { customerId, subscriptionId, invoiceId, invoiceIds, currencyId } = value;
+
+    const result = await retryUncollectibleInvoices({
+      customerId,
+      subscriptionId,
+      invoiceId,
+      invoiceIds,
+      currencyId,
+    });
+
+    return res.json(result);
+  } catch (error) {
+    logger.error('Failed to retry uncollectible invoices', { error });
+    return res.status(500).json({
+      error: 'Failed to retry uncollectible invoices',
+      message: error.message,
+    });
+  }
+});
+
 router.get('/:id', authPortal, async (req, res) => {
   try {
     const doc = (await Invoice.findOne({

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

@@ -12,6 +12,7 @@ import {
   Op,
 } from 'sequelize';
 
+import merge from 'lodash/merge';
 import { createEvent } from '../../libs/audit';
 import CustomError from '../../libs/error';
 import { getLock } from '../../libs/lock';
@@ -304,6 +305,32 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
       postalCode: customer.address?.postal_code || '',
     };
   }
+
+  public static formatUpdateAddress(address: CustomerAddress, customer: Customer): CustomerAddress {
+    const defaultAddress = {
+      country: 'us',
+      state: '',
+      city: '',
+      line1: '',
+      line2: '',
+      postal_code: '',
+    };
+
+    return merge(
+      defaultAddress,
+      customer.address || {},
+      address
+        ? {
+            country: address.country?.toLowerCase(),
+            state: address.state,
+            city: address.city,
+            line1: address.line1,
+            line2: address.line2,
+            postal_code: address.postal_code,
+          }
+        : {}
+    );
+  }
 }
 
 export type TCustomer = InferAttributes<Customer>;

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.18.24
+version: 1.18.25
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.18.24",
+  "version": "1.18.25",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -43,19 +43,19 @@
     ]
   },
   "dependencies": {
-    "@abtnode/cron": "^1.16.40",
+    "@abtnode/cron": "^1.16.41",
     "@arcblock/did": "^1.19.15",
     "@arcblock/did-auth-storage-nedb": "^1.7.1",
-    "@arcblock/did-connect": "^2.12.48",
+    "@arcblock/did-connect": "^2.12.52",
     "@arcblock/did-util": "^1.19.15",
     "@arcblock/jwt": "^1.19.15",
-    "@arcblock/ux": "^2.12.48",
+    "@arcblock/ux": "^2.12.52",
     "@arcblock/validator": "^1.19.15",
-    "@blocklet/js-sdk": "^1.16.40",
-    "@blocklet/logger": "^1.16.40",
-    "@blocklet/payment-react": "1.18.24",
-    "@blocklet/sdk": "^1.16.40",
-    "@blocklet/ui-react": "^2.12.48",
+    "@blocklet/js-sdk": "^1.16.41",
+    "@blocklet/logger": "^1.16.41",
+    "@blocklet/payment-react": "1.18.25",
+    "@blocklet/sdk": "^1.16.41",
+    "@blocklet/ui-react": "^2.12.52",
     "@blocklet/uploader": "^0.1.81",
     "@blocklet/xss": "^0.1.30",
     "@mui/icons-material": "^5.16.6",
@@ -119,9 +119,9 @@
     "web3": "^4.16.0"
   },
   "devDependencies": {
-    "@abtnode/types": "^1.16.40",
+    "@abtnode/types": "^1.16.41",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.18.24",
+    "@blocklet/payment-types": "1.18.25",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -167,5 +167,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "6c36b088743e696ce250cda11f8502b3886df0ef"
+  "gitHead": "1665ec667d621a3e607650e486cb0967371b9771"
 }

package/src/pages/customer/index.tsx

@@ -200,7 +200,7 @@ const isCardVisible = (type: string, config: any, data: any, currency: any, meth
     data?.summary?.[summaryKey]?.[currency.id] && data?.summary?.[summaryKey]?.[currency.id] !== '0';
 
   if (type === 'balance') {
-    return method?.type === 'arcblock' && (config.alwaysShow || hasSummaryValue);
+    return method?.type === 'arcblock' || config.alwaysShow || hasSummaryValue;
   }
 
   return config.alwaysShow || hasSummaryValue;

package/src/pages/customer/recharge/account.tsx

@@ -26,12 +26,13 @@ import {
   api,
   formatBNStr,
   formatPrice,
+  formatNumber,
 } from '@blocklet/payment-react';
 import type { TPaymentCurrency, TPaymentMethod } from '@blocklet/payment-types';
 import { joinURL } from 'ufo';
 import { AccountBalanceWalletOutlined, ArrowBackOutlined, ArrowForwardOutlined } from '@mui/icons-material';
 import Empty from '@arcblock/ux/lib/Empty';
-import { BN } from '@ocap/util';
+import { BN, fromUnitToToken } from '@ocap/util';
 import RechargeList from '../../../components/invoice/recharge';
 import { getTokenBalanceLink, goBackOrFallback } from '../../../libs/util';
 import { useSessionContext } from '../../../contexts/session';
@@ -120,14 +121,19 @@ export default function BalanceRechargePage() {
         if (data.recommendedRecharge && data.recommendedRecharge.amount && data.recommendedRecharge.amount !== '0') {
           const baseAmount = data.recommendedRecharge.amount;
           const decimal = data.currency.decimal || 0;
+          const calcCycleAmount = (cycle: number) => {
+            const cycleAmount = fromUnitToToken(new BN(baseAmount).mul(new BN(String(cycle))).toString(), decimal);
+            return Math.ceil(parseFloat(cycleAmount)).toString();
+          };
           setUnitCycle({
-            amount: parseFloat(formatBNStr(baseAmount, decimal, 6, true)).toString(),
+            amount: fromUnitToToken(baseAmount, decimal),
             interval: data.recommendedRecharge.interval as TimeUnit,
             cycle: data.recommendedRecharge.cycle,
           });
+
           setPresetAmounts([
             {
-              amount: Math.ceil(parseFloat(formatBNStr(baseAmount, decimal, 6, true))).toString(),
+              amount: calcCycleAmount(1),
               multiplier: data.recommendedRecharge.cycle,
               label: t('common.estimatedDuration', {
                 duration: formatSmartDuration(1, data.recommendedRecharge.interval as TimeUnit, {
@@ -136,9 +142,7 @@ export default function BalanceRechargePage() {
               }),
             },
             {
-              amount: Math.ceil(
-                parseFloat(formatBNStr(new BN(baseAmount).mul(new BN('4')).toString(), decimal, 6, true))
-              ).toString(),
+              amount: calcCycleAmount(4),
               multiplier: data.recommendedRecharge.cycle * 4,
               label: t('common.estimatedDuration', {
                 duration: formatSmartDuration(4, data.recommendedRecharge.interval as TimeUnit, {
@@ -147,9 +151,7 @@ export default function BalanceRechargePage() {
               }),
             },
             {
-              amount: Math.ceil(
-                parseFloat(formatBNStr(new BN(baseAmount).mul(new BN('8')).toString(), decimal, 6, true))
-              ).toString(),
+              amount: calcCycleAmount(8),
               multiplier: data.recommendedRecharge.cycle * 8,
               label: t('common.estimatedDuration', {
                 duration: formatSmartDuration(8, data.recommendedRecharge.interval as TimeUnit, {
@@ -442,7 +444,7 @@ export default function BalanceRechargePage() {
                             fontWeight: 600,
                             color: amount === presetAmount && !customAmount ? 'primary.main' : 'text.primary',
                           }}>
-                          {presetAmount} {currency.symbol}
+                          {formatNumber(presetAmount)} {currency.symbol}
                         </Typography>
                         {multiplier > 0 && label && (
                           <Typography variant="caption" align="center" color="text.secondary">

package/src/pages/customer/subscription/embed.tsx

@@ -1,6 +1,6 @@
 /* eslint-disable react/no-unstable-nested-components */
 import { useLocaleContext } from '@arcblock/ux/lib/Locale/context';
-import DidAddress from '@arcblock/ux/lib/DID';
+import DID from '@arcblock/ux/lib/DID';
 import {
   Status,
   api,
@@ -63,9 +63,9 @@ const fetchSubscriptionData = (id: string, authToken: string): Promise<TSubscrip
   return api.get(`/api/subscriptions/${id}?authToken=${authToken}`).then((res) => res.data);
 };
 
-const checkHasPastDue = async (subscriptionId: string): Promise<boolean> => {
+const checkHasPastDue = async (subscriptionId: string, authToken: string): Promise<boolean> => {
   try {
-    const res = await api.get(`/api/subscriptions/${subscriptionId}/summary`);
+    const res = await api.get(`/api/subscriptions/${subscriptionId}/summary?authToken=${authToken}`);
     if (!isEmpty(res.data) && Object.keys(res.data).length >= 1) {
       return true;
     }
@@ -126,9 +126,12 @@ export default function SubscriptionEmbed() {
     });
   }, [subscription]);
 
-  const { data: hasPastDue, runAsync: runCheckHasPastDue } = useRequest(() => checkHasPastDue(subscriptionId), {
-    refreshDeps: [subscriptionId],
-  });
+  const { data: hasPastDue, runAsync: runCheckHasPastDue } = useRequest(
+    () => checkHasPastDue(subscriptionId, authToken),
+    {
+      refreshDeps: [subscriptionId, authToken],
+    }
+  );
 
   if (error) {
     return (
@@ -212,11 +215,20 @@ export default function SubscriptionEmbed() {
           logo={getCustomerAvatar(
             subscription.customer.did,
             subscription.customer.updated_at ? new Date(subscription.customer.updated_at).toISOString() : '',
-            48
+            24
           )}
-          name={`${subscription.customer.name} (${subscription.customer.email})`}
-          description={<DidAddress did={subscription.customer.did} responsive={false} compact />}
+          description=""
           className="owner-info-card"
+          name={subscription.customer.name || subscription.customer.email}
+          tooltip={
+            <Stack>
+              <Typography>
+                {subscription.customer.name} ({subscription.customer.email})
+              </Typography>
+              <DID did={subscription.customer.did} />
+            </Stack>
+          }
+          size={24}
         />
       ),
     });
@@ -254,6 +266,9 @@ export default function SubscriptionEmbed() {
                     '.info-row-value': {
                       flex: 'none',
                     },
+                    '.owner-info-card .info-card': {
+                      minWidth: 0,
+                    },
                   }}
                 />
               );