payment-kit 1.18.24 → 1.18.26

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/customers.ts

@@ -24,6 +24,7 @@ import {
 } from '../store/models';
 import { getSubscriptionPaymentAddress, calculateRecommendedRechargeAmount } from '../libs/subscription';
 import { expandLineItems } from '../libs/session';
+import { handleNotificationPreferenceChange } from '../queues/notification';
 
 const router = Router();
 const auth = authenticate<Customer>({ component: true, roles: ['owner', 'admin'] });
@@ -181,6 +182,9 @@ router.get('/:id/overdue/invoices', sessionMiddleware(), async (req, res) => {
     if (!doc) {
       return res.status(404).json({ error: 'Customer not found' });
     }
+    if (doc.did !== req.user.did && !['admin', 'owner'].includes(req.user?.role)) {
+      return res.status(403).json({ error: 'You are not allowed to access this customer invoices' });
+    }
     const { rows: invoices, count } = await Invoice.findAndCountAll({
       where: {
         customer_id: doc.id,
@@ -367,6 +371,63 @@ router.get('/:id/summary', auth, async (req, res) => {
   }
 });
 
+const updatePreferenceSchema = Joi.object({
+  notification: Joi.object({
+    frequency: Joi.string().valid('default', 'daily', 'weekly', 'monthly').required(),
+    schedule: Joi.object({
+      time: Joi.string().pattern(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/),
+      date: Joi.alternatives().conditional('..frequency', {
+        switch: [
+          { is: 'weekly', then: Joi.number().min(0).max(6).required() },
+          { is: 'monthly', then: Joi.number().min(1).max(31).required() },
+          { is: Joi.valid('daily', 'default'), then: Joi.number().optional() },
+        ],
+      }),
+    }).when('frequency', {
+      is: 'default',
+      then: Joi.optional(),
+      otherwise: Joi.required(),
+    }),
+  }).optional(),
+}).unknown(false);
+
+router.put('/preference', sessionMiddleware(), async (req, res) => {
+  try {
+    if (!req.user) {
+      return res.status(403).json({ error: 'Unauthorized' });
+    }
+
+    const doc = await Customer.findByPkOrDid(req.user.did as string);
+    if (!doc) {
+      return res.status(404).json({ error: 'Customer not found' });
+    }
+
+    const { error, value } = updatePreferenceSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ error: error.message });
+    }
+
+    // Get old preference before update
+    const oldPreference = doc.preference?.notification;
+
+    await doc.update({ preference: value });
+
+    // Handle notification queue updates if notification preference changed
+    if (
+      oldPreference?.frequency !== value.notification?.frequency ||
+      oldPreference?.schedule?.time !== value.notification?.schedule?.time ||
+      oldPreference?.schedule?.date !== value.notification?.schedule?.date
+    ) {
+      await handleNotificationPreferenceChange(doc.id, value.notification);
+    }
+
+    return res.json(doc);
+  } catch (err) {
+    logger.error('Failed to update customer preference', err);
+    return res.status(400).json({ error: `Failed to update preference: ${err.message}` });
+  }
+});
+
 const updateCustomerSchema = Joi.object({
   metadata: MetadataSchema,
   name: Joi.string().min(2).max(30).empty(''),

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/routes/subscriptions.ts

@@ -1906,7 +1906,7 @@ router.get('/:id/overdue/invoices', authPortal, async (req, res) => {
       return res.status(404).json({ error: 'Subscription not found' });
     }
     // @ts-ignore
-    if (subscription.customer?.did !== req.user?.did) {
+    if (subscription.customer?.did !== req.user?.did && !['admin', 'owner'].includes(req.user?.role)) {
       return res.status(403).json({ error: 'You are not allowed to access this subscription' });
     }
     const { rows: invoices, count } = await Invoice.findAndCountAll({

package/api/src/store/migrations/20250328-notification-preference.ts

@@ -0,0 +1,29 @@
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    customers: [
+      {
+        name: 'preference',
+        field: {
+          type: DataTypes.JSON,
+          defaultValue: JSON.stringify({
+            notification: {
+              frequency: 'monthly',
+              schedule: {
+                time: '10:00',
+                date: 1,
+              },
+            },
+          }),
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('customers', 'preference');
+};

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

@@ -12,11 +12,12 @@ import {
   Op,
 } from 'sequelize';
 
+import merge from 'lodash/merge';
 import { createEvent } from '../../libs/audit';
 import CustomError from '../../libs/error';
 import { getLock } from '../../libs/lock';
 import { createCodeGenerator, createIdGenerator } from '../../libs/util';
-import type { CustomerAddress, CustomerShipping } from './types';
+import type { CustomerAddress, CustomerPreferences, CustomerShipping } from './types';
 
 export const nextCustomerId = createIdGenerator('cus', 14);
 export const nextInvoicePrefix = createCodeGenerator('', 8);
@@ -64,6 +65,7 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
   declare created_at: CreationOptional<Date>;
   declare updated_at: CreationOptional<Date>;
   declare last_sync_at?: number;
+  declare preference?: CustomerPreferences;
 
   public static readonly GENESIS_ATTRIBUTES = {
     id: {
@@ -233,6 +235,19 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
           type: DataTypes.INTEGER,
           allowNull: true,
         },
+        preference: {
+          type: DataTypes.JSON,
+          allowNull: true,
+          defaultValue: {
+            notification: {
+              frequency: 'monthly',
+              schedule: {
+                time: '10:00',
+                date: 1,
+              },
+            },
+          },
+        },
       },
       {
         sequelize,
@@ -304,6 +319,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/api/src/store/models/types.ts

@@ -442,7 +442,7 @@ export type PricingTableItem = {
   // Enables user redeemable promotion codes.
   allow_promotion_codes: boolean;
 
-  // Configuration for collecting the customer’s billing address.
+  // Configuration for collecting the customer's billing address.
   billing_address_collection?: LiteralUnion<'auto' | 'required', string>;
 
   is_highlight: boolean;
@@ -704,3 +704,19 @@ export type EventType = LiteralUnion<
 export type StripeRefundReason = 'duplicate' | 'fraudulent' | 'requested_by_customer';
 
 export type SettingType = LiteralUnion<'donate', string>;
+
+export type NotificationFrequency = 'default' | 'daily' | 'weekly' | 'monthly';
+export type NotificationSchedule = {
+  time: string; // HH:mm 格式
+  date?: number; // weekly: 0-6, monthly: 1-31
+};
+
+export type NotificationSettings = {
+  frequency: NotificationFrequency;
+  schedule?: NotificationSchedule;
+};
+
+export type CustomerPreferences = {
+  notification?: NotificationSettings;
+  // support more preferences
+};

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.26
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.18.24",
+  "version": "1.18.26",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -43,30 +43,30 @@
     ]
   },
   "dependencies": {
-    "@abtnode/cron": "^1.16.40",
-    "@arcblock/did": "^1.19.15",
+    "@abtnode/cron": "^1.16.41",
+    "@arcblock/did": "^1.19.19",
     "@arcblock/did-auth-storage-nedb": "^1.7.1",
-    "@arcblock/did-connect": "^2.12.48",
-    "@arcblock/did-util": "^1.19.15",
-    "@arcblock/jwt": "^1.19.15",
-    "@arcblock/ux": "^2.12.48",
-    "@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/uploader": "^0.1.81",
-    "@blocklet/xss": "^0.1.30",
+    "@arcblock/did-connect": "^2.12.60",
+    "@arcblock/did-util": "^1.19.19",
+    "@arcblock/jwt": "^1.19.19",
+    "@arcblock/ux": "^2.12.60",
+    "@arcblock/validator": "^1.19.19",
+    "@blocklet/js-sdk": "^1.16.41",
+    "@blocklet/logger": "^1.16.41",
+    "@blocklet/payment-react": "1.18.26",
+    "@blocklet/sdk": "^1.16.41",
+    "@blocklet/ui-react": "^2.12.60",
+    "@blocklet/uploader": "^0.1.82",
+    "@blocklet/xss": "^0.1.31",
     "@mui/icons-material": "^5.16.6",
     "@mui/lab": "^5.0.0-alpha.173",
     "@mui/material": "^5.16.6",
     "@mui/system": "^5.16.6",
-    "@ocap/asset": "^1.19.15",
-    "@ocap/client": "^1.19.15",
-    "@ocap/mcrypto": "^1.19.15",
-    "@ocap/util": "^1.19.15",
-    "@ocap/wallet": "^1.19.15",
+    "@ocap/asset": "^1.19.19",
+    "@ocap/client": "^1.19.19",
+    "@ocap/mcrypto": "^1.19.19",
+    "@ocap/util": "^1.19.19",
+    "@ocap/wallet": "^1.19.19",
     "@stripe/react-stripe-js": "^2.7.3",
     "@stripe/stripe-js": "^2.4.0",
     "ahooks": "^3.8.0",
@@ -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.26",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -151,7 +151,7 @@
     "vite": "^5.3.5",
     "vite-node": "^2.0.4",
     "vite-plugin-babel-import": "^2.0.5",
-    "vite-plugin-blocklet": "^0.9.29",
+    "vite-plugin-blocklet": "^0.9.31",
     "vite-plugin-node-polyfills": "^0.21.0",
     "vite-plugin-svgr": "^4.2.0",
     "vite-tsconfig-paths": "^4.3.2",
@@ -167,5 +167,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "6c36b088743e696ce250cda11f8502b3886df0ef"
+  "gitHead": "7f95dbeba13242d2b7e77ac3f4e69a7f764ed213"
 }

package/src/components/customer/form.tsx

@@ -1,14 +1,29 @@
 import 'react-international-phone/style.css';
 
 import { useLocaleContext } from '@arcblock/ux/lib/Locale/context';
-import { FormInput, PhoneInput, CountrySelect, validatePhoneNumber } from '@blocklet/payment-react';
+import {
+  FormInput,
+  PhoneInput,
+  CountrySelect,
+  validatePhoneNumber,
+  getPhoneUtil,
+  validatePostalCode,
+} from '@blocklet/payment-react';
 import { FormLabel, Stack } from '@mui/material';
-import { Controller, useFormContext } from 'react-hook-form';
+import { Controller, useFormContext, useWatch } from 'react-hook-form';
 import isEmail from 'validator/es/lib/isEmail';
+import { useMount } from 'ahooks';
 
 export default function CustomerForm() {
   const { t } = useLocaleContext();
   const { control } = useFormContext();
+  useMount(() => {
+    getPhoneUtil().catch((err) => {
+      console.error('Failed to preload phone validator:', err);
+    });
+  });
+
+  const country = useWatch({ control, name: 'address.country' });
 
   return (
     <Stack
@@ -148,6 +163,10 @@ export default function CustomerForm() {
             value: 20,
             message: t('common.maxLength', { len: 20 }),
           },
+          validate: (x: string) => {
+            const isValid = validatePostalCode(x, country);
+            return isValid ? true : t('payment.checkout.invalid');
+          },
         }}
       />
     </Stack>