payment-kit 1.18.20 → 1.18.22

package/api/src/routes/settings.ts

@@ -9,7 +9,7 @@ import { PaymentMethod } from '../store/models/payment-method';
 import { authenticate } from '../libs/security';
 import { Setting } from '../store/models';
 import logger from '../libs/logger';
-import { createListParamSchema, getWhereFromKvQuery } from '../libs/api';
+import { createListParamSchema, getOrder, getWhereFromKvQuery } from '../libs/api';
 
 const router = Router();
 const authAdmin = authenticate<Setting>({ component: true, roles: ['owner', 'admin'] });
@@ -80,7 +80,7 @@ router.get('/donate', async (req, res) => {
 
     const { rows: list, count } = await Setting.findAndCountAll({
       where,
-      order: [['created_at', query.o === 'asc' ? 'ASC' : 'DESC']],
+      order: getOrder(req.query, [['created_at', query.o === 'asc' ? 'ASC' : 'DESC']]),
       offset: (page - 1) * pageSize,
       limit: pageSize,
       distinct: true,
@@ -140,7 +140,7 @@ router.post('/', async (req, res) => {
       const defaultSetting = {
         amount: {
           presets: ['1', '5', '10'],
-          preset: '1',
+          preset: '5',
           minimum: '0.01',
           maximum: '100',
           custom: true,
@@ -154,7 +154,7 @@ router.post('/', async (req, res) => {
           presets: Joi.array()
             .items(Joi.string())
             .when('custom', { is: false, then: Joi.required(), otherwise: Joi.optional() }),
-          preset: Joi.string().optional(),
+          preset: Joi.string().empty('').optional(),
           minimum: Joi.string().when('custom', { is: true, then: Joi.required() }),
           maximum: Joi.string().when('custom', { is: true, then: Joi.required() }),
           custom: Joi.boolean().required(),
@@ -238,7 +238,7 @@ router.put('/:mountLocationOrId', authAdmin, async (req, res) => {
           presets: Joi.array()
             .items(Joi.string())
             .when('custom', { is: false, then: Joi.required(), otherwise: Joi.optional() }),
-          preset: Joi.string().optional(),
+          preset: Joi.string().empty('').optional(),
           minimum: Joi.string().when('custom', { is: true, then: Joi.required() }),
           maximum: Joi.string().when('custom', { is: true, then: Joi.required() }),
           custom: Joi.boolean().required(),

package/api/src/routes/subscription-items.ts

@@ -4,7 +4,7 @@ import Joi from 'joi';
 import pick from 'lodash/pick';
 import type { WhereOptions } from 'sequelize';
 
-import { createListParamSchema, MetadataSchema } from '../libs/api';
+import { createListParamSchema, getOrder, MetadataSchema } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { expandLineItems } from '../libs/session';
 import { formatMetadata } from '../libs/util';
@@ -80,7 +80,7 @@ router.get('/', auth, async (req, res) => {
   try {
     const { rows, count } = await SubscriptionItem.findAndCountAll({
       where,
-      order: [['created_at', 'DESC']],
+      order: getOrder(req.query, [['created_at', 'DESC']]),
       offset: (page - 1) * pageSize,
       limit: pageSize,
       include: [],

package/api/src/routes/subscriptions.ts

@@ -10,7 +10,7 @@ import { literal, Op, OrderItem } from 'sequelize';
 import { BN } from '@ocap/util';
 import { createEvent } from '../libs/audit';
 import { ensureStripeCustomer, ensureStripePrice, ensureStripeSubscription } from '../integrations/stripe/resource';
-import { createListParamSchema, getWhereFromKvQuery, getWhereFromQuery, MetadataSchema } from '../libs/api';
+import { createListParamSchema, getOrder, getWhereFromKvQuery, getWhereFromQuery, MetadataSchema } from '../libs/api';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import { isDelegationSufficientForPayment } from '../libs/payment';
@@ -91,7 +91,6 @@ const schema = createListParamSchema<{
   customer_did?: string;
   activeFirst?: boolean;
   price_id?: string;
-  order?: string | string[] | OrderItem | OrderItem[];
   showTotalCount?: boolean;
 }>({
   status: Joi.string().empty(''),
@@ -99,21 +98,9 @@ const schema = createListParamSchema<{
   customer_did: Joi.string().empty(''),
   activeFirst: Joi.boolean().optional(),
   price_id: Joi.string().empty(''),
-  order: Joi.alternatives()
-    .try(
-      Joi.string(),
-      Joi.array().items(Joi.string()),
-      Joi.array().items(Joi.array().ordered(Joi.string(), Joi.string().valid('ASC', 'DESC').insensitive()))
-    )
-    .optional(),
   showTotalCount: Joi.boolean().optional(),
 });
 
-const parseOrder = (orderStr: string): OrderItem => {
-  const [field, direction] = orderStr.split(':');
-  return [field ?? '', (direction?.toUpperCase() as 'ASC' | 'DESC') || 'ASC'];
-};
-
 router.get('/', authMine, async (req, res) => {
   const { page, pageSize, status, livemode, ...query } = await schema.validateAsync(req.query, {
     stripUnknown: false,
@@ -139,9 +126,7 @@ router.get('/', authMine, async (req, res) => {
       return;
     }
   }
-  if (typeof livemode === 'boolean') {
-    where.livemode = livemode;
-  }
+  where.livemode = typeof livemode === 'boolean' ? livemode : true;
 
   Object.keys(query)
     .filter((x) => x.startsWith('metadata.'))
@@ -150,11 +135,7 @@ router.get('/', authMine, async (req, res) => {
       where[key] = query[key];
     });
 
-  let order: OrderItem[] = [];
-  if (query.order) {
-    const orderItems = Array.isArray(query.order) ? query.order : [query.order];
-    order = orderItems.map((item) => (typeof item === 'string' ? parseOrder(item) : (item as OrderItem)));
-  }
+  const order: OrderItem[] = getOrder(req.query, []);
 
   if (query.activeFirst) {
     order.unshift([
@@ -196,6 +177,7 @@ router.get('/', authMine, async (req, res) => {
       const totalCount = await Subscription.count({
         where: {
           customer_id: where.customer_id,
+          livemode: where.livemode ?? true,
         },
         distinct: true,
       });
@@ -228,7 +210,7 @@ router.get('/search', auth, async (req, res) => {
   // fix here https://github.com/blocklet/payment-kit/issues/394
   const { rows: list, count } = await Subscription.findAndCountAll({
     where,
-    order: [['created_at', o === 'asc' ? 'ASC' : 'DESC']],
+    order: getOrder(req.query, [['created_at', o === 'asc' ? 'ASC' : 'DESC']]),
     offset: (page - 1) * pageSize,
     limit: pageSize,
     distinct: true,
@@ -1901,7 +1883,7 @@ router.get('/:id/recharge', authMine, async (req, res) => {
       },
       offset: (page - 1) * pageSize,
       limit: pageSize,
-      order: [['created_at', 'DESC']],
+      order: getOrder(req.query, [['created_at', 'DESC']]),
       include: [
         { model: PaymentCurrency, as: 'paymentCurrency' },
         { model: PaymentMethod, as: 'paymentMethod' },
@@ -2036,15 +2018,11 @@ router.get('/:id/overdraft-protection', authPortal, async (req, res) => {
   }
 });
 
-const overdraftProtectionSchema = createListParamSchema<{
-  amount: string;
-  enabled: boolean;
-  return_stake: boolean;
-}>({
+const overdraftProtectionSchema = Joi.object({
   amount: Joi.number().empty(0).optional(),
   enabled: Joi.boolean().required(),
   return_stake: Joi.boolean().empty(false).optional(),
-});
+}).unknown(true);
 // 订阅保护
 router.post('/:id/overdraft-protection', authPortal, async (req, res) => {
   try {

package/api/src/routes/usage-records.ts

@@ -5,7 +5,7 @@ import pick from 'lodash/pick';
 import { Op } from 'sequelize';
 
 import { forwardUsageRecordToStripe } from '../integrations/stripe/resource';
-import { createListParamSchema } from '../libs/api';
+import { createListParamSchema, getOrder } from '../libs/api';
 import dayjs from '../libs/dayjs';
 import { authenticate } from '../libs/security';
 import { usageRecordQueue } from '../queues/usage-record';
@@ -163,7 +163,7 @@ router.get('/summary', auth, async (req, res) => {
     const { rows, count } = await Invoice.findAndCountAll({
       where: { subscription_id: item.subscription_id },
       attributes: ['id', 'period_end', 'period_start'],
-      order: [['created_at', 'DESC']],
+      order: getOrder(req.query, [['created_at', 'DESC']]),
       offset: (page - 1) * pageSize,
       limit: pageSize,
     });

package/api/src/routes/webhook-attempts.ts

@@ -2,7 +2,7 @@ import { Router } from 'express';
 import Joi from 'joi';
 import type { WhereOptions } from 'sequelize';
 
-import { createListParamSchema } from '../libs/api';
+import { createListParamSchema, getOrder } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { Event, WebhookAttempt, WebhookEndpoint } from '../store/models';
 import { blocklet } from '../libs/auth';
@@ -35,7 +35,7 @@ router.get('/', auth, async (req, res) => {
   try {
     const { rows: list, count } = await WebhookAttempt.findAndCountAll({
       where,
-      order: [['created_at', 'DESC']],
+      order: getOrder(req.query, [['created_at', 'DESC']]),
       offset: (page - 1) * pageSize,
       limit: pageSize,
       include: [

package/api/src/routes/webhook-endpoints.ts

@@ -3,7 +3,7 @@ import Joi from 'joi';
 import pick from 'lodash/pick';
 import type { WhereOptions } from 'sequelize';
 
-import { createListParamSchema, MetadataSchema } from '../libs/api';
+import { createListParamSchema, getOrder, MetadataSchema } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { formatMetadata } from '../libs/util';
 import { WebhookEndpoint } from '../store/models';
@@ -62,7 +62,7 @@ router.get('/', auth, async (req, res) => {
   try {
     const { rows: list, count } = await WebhookEndpoint.findAndCountAll({
       where,
-      order: [['created_at', 'DESC']],
+      order: getOrder(req.query, [['created_at', 'DESC']]),
       offset: (page - 1) * pageSize,
       limit: pageSize,
       include: [],

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

@@ -282,6 +282,28 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
   public static getInvoicePrefix() {
     return nextInvoicePrefix();
   }
+
+  public static formatAddressFromUser(user: any) {
+    return {
+      country: user.address?.country || '',
+      state: user.address?.province || '',
+      city: user.address?.city || '',
+      line1: user.address?.line1 || '',
+      line2: user.address?.line2 || '',
+      postal_code: user.address?.postalCode || '',
+    };
+  }
+
+  public static formatAddressFromCustomer(customer: Customer) {
+    return {
+      country: customer.address?.country || '',
+      province: customer.address?.state || '',
+      city: customer.address?.city || '',
+      line1: customer.address?.line1 || '',
+      line2: customer.address?.line2 || '',
+      postalCode: customer.address?.postal_code || '',
+    };
+  }
 }
 
 export type TCustomer = InferAttributes<Customer>;

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

@@ -10,6 +10,10 @@ export type ChainType = 'arcblock' | 'bitcoin' | 'stripe' | EVMChainType;
 export type GroupedBN = { [currencyId: string]: string };
 export type GroupedStrList = { [currencyId: string]: string[] };
 
+export type OrderDirection = 'ASC' | 'DESC';
+export type OrderItem = [string, OrderDirection];
+export type OrderInput = string | string[] | OrderItem[];
+
 export type Pagination<T = any> = T & {
   // offset based
   page?: number;
@@ -18,6 +22,7 @@ export type Pagination<T = any> = T & {
   // TODO: cursor based
   starting_after?: string;
   ending_before?: string;
+  order?: OrderInput; // order by field:ASC|DESC or [field:ASC|DESC, ...] or [[field, direction], ...]
 };
 
 export type Searchable<T = any> = Pagination<T> & {

package/api/tests/libs/api.spec.ts

@@ -1,6 +1,7 @@
 import { Op } from 'sequelize';
 
-import { getWhereFromQuery, MetadataSchema } from '../../src/libs/api';
+import { getOrder, getWhereFromQuery, MetadataSchema, normalizeOrder, createListParamSchema } from '../../src/libs/api';
+import type { OrderItem } from '../../src/store/models';
 
 describe('getWhereFromQuery', () => {
   it('should correctly parse > operator', () => {
@@ -224,3 +225,299 @@ describe('MetadataSchema', () => {
     expect(error).toBeUndefined();
   });
 });
+
+describe('normalizeOrder', () => {
+  it('should return default order when input is undefined', () => {
+    const result = normalizeOrder(undefined);
+    expect(result).toEqual([['created_at', 'DESC']]);
+  });
+
+  it('should handle string input', () => {
+    const result = normalizeOrder('name:asc');
+    expect(result).toEqual([
+      ['name', 'ASC'],
+      ['created_at', 'DESC'],
+    ]);
+  });
+
+  it('should handle string array input', () => {
+    const result = normalizeOrder(['name:asc', 'age:desc']);
+    expect(result).toEqual([
+      ['name', 'ASC'],
+      ['age', 'DESC'],
+      ['created_at', 'DESC'],
+    ]);
+  });
+
+  it('should handle tuple array input', () => {
+    const result = normalizeOrder([
+      ['name', 'ASC'],
+      ['age', 'DESC'],
+    ]);
+    expect(result).toEqual([
+      ['name', 'ASC'],
+      ['age', 'DESC'],
+      ['created_at', 'DESC'],
+    ]);
+  });
+
+  it('should merge with default order correctly', () => {
+    const defaultOrder: OrderItem[] = [
+      ['updated_at', 'DESC'],
+      ['created_at', 'ASC'],
+    ];
+    const result = normalizeOrder('name:asc', defaultOrder);
+    expect(result).toEqual([
+      ['name', 'ASC'],
+      ['updated_at', 'DESC'],
+      ['created_at', 'ASC'],
+    ]);
+  });
+
+  it('should not duplicate fields from default order', () => {
+    const defaultOrder: OrderItem[] = [
+      ['name', 'DESC'],
+      ['created_at', 'ASC'],
+    ];
+    const result = normalizeOrder('name:asc', defaultOrder);
+    expect(result).toEqual([
+      ['name', 'ASC'],
+      ['created_at', 'ASC'],
+    ]);
+  });
+});
+
+describe('getOrder', () => {
+  it('should handle query.order parameter', () => {
+    const result = getOrder({ order: 'name:asc' });
+    expect(result).toEqual([
+      ['name', 'ASC'],
+      ['created_at', 'DESC'],
+    ]);
+  });
+
+  it('should handle query.o parameter', () => {
+    const result = getOrder({ o: 'desc' }, [
+      ['name', 'ASC'],
+      ['age', 'ASC'],
+    ]);
+    expect(result).toEqual([
+      ['name', 'DESC'],
+      ['age', 'DESC'],
+    ]);
+  });
+
+  it('should handle query.o parameter without defaultOrder', () => {
+    const result = getOrder({ o: 'asc' });
+    expect(result).toEqual([['created_at', 'ASC']]);
+  });
+
+  it('should prioritize query.order over query.o', () => {
+    const result = getOrder({ order: 'name:asc', o: 'desc' });
+    expect(result).toEqual([
+      ['name', 'ASC'],
+      ['created_at', 'DESC'],
+    ]);
+  });
+
+  it('should return default order when no parameters provided', () => {
+    const result = getOrder({});
+    expect(result).toEqual([['created_at', 'DESC']]);
+  });
+
+  it('should return custom default order when provided', () => {
+    const defaultOrder: OrderItem[] = [
+      ['updated_at', 'DESC'],
+      ['name', 'ASC'],
+    ];
+    const result = getOrder({}, defaultOrder);
+    expect(result).toEqual(defaultOrder);
+  });
+
+  it('should handle complex ordering with array input', () => {
+    const result = getOrder({ order: ['name:asc', 'age:desc'] });
+    expect(result).toEqual([
+      ['name', 'ASC'],
+      ['age', 'DESC'],
+      ['created_at', 'DESC'],
+    ]);
+  });
+
+  it('should handle tuple array input', () => {
+    const result = getOrder({
+      order: [
+        ['name', 'ASC'],
+        ['age', 'DESC'],
+      ],
+    });
+    expect(result).toEqual([
+      ['name', 'ASC'],
+      ['age', 'DESC'],
+      ['created_at', 'DESC'],
+    ]);
+  });
+
+  it('should merge order fields correctly with defaults', () => {
+    const defaultOrder: OrderItem[] = [
+      ['status', 'DESC'],
+      ['created_at', 'DESC'],
+    ];
+    const result = getOrder({ order: 'name:asc' }, defaultOrder);
+    expect(result).toEqual([
+      ['name', 'ASC'],
+      ['status', 'DESC'],
+      ['created_at', 'DESC'],
+    ]);
+  });
+});
+
+describe('createListParamSchema', () => {
+  const schema = createListParamSchema({});
+
+  describe('order validation', () => {
+    // Valid format validation
+    it('should validate valid string order format', () => {
+      const { error } = schema.validate({ order: 'name:asc' });
+      expect(error).toBeUndefined();
+    });
+
+    it('should validate valid array of strings order format', () => {
+      const { error } = schema.validate({ order: ['name:asc', 'age:desc'] });
+      expect(error).toBeUndefined();
+    });
+
+    it('should validate valid tuple array format', () => {
+      const { error } = schema.validate({
+        order: [
+          ['name', 'ASC'],
+          ['age', 'DESC'],
+        ],
+      });
+      expect(error).toBeUndefined();
+    });
+
+    // Invalid format validation
+    it('should reject invalid format with detailed error message', () => {
+      const { error } = schema.validate({ order: 'nameasc' });
+      expect(error).toBeDefined();
+      expect((error as any).details[0].message).toMatch(/Must use ":" to separate field and direction/);
+    });
+
+    // Field name validation
+    it('should reject invalid field characters with detailed error message', () => {
+      const invalidInputs = ['@name:asc', 'field-name:asc', 'field name:asc', ':asc'];
+
+      invalidInputs.forEach((input) => {
+        const { error } = schema.validate({ order: input });
+        expect(error).toBeDefined();
+        expect((error as any).details[0].message).toMatch(
+          /Field name can only contain letters, numbers, dots and underscores/
+        );
+      });
+    });
+
+    // Direction validation
+    it('should reject invalid direction with detailed error message', () => {
+      const invalidDirections = ['name:up', 'name:', 'name:invalid'];
+
+      invalidDirections.forEach((input) => {
+        const { error } = schema.validate({ order: input });
+        expect(error).toBeDefined();
+        expect((error as any).details[0].message).toMatch(/Direction must be either "asc" or "desc"/);
+      });
+    });
+
+    // Array format validation
+    it('should reject invalid array items with detailed error message', () => {
+      const invalidArrays = [['name:up'], ['@name:asc'], ['name:'], ['nameasc']];
+
+      invalidArrays.forEach((input) => {
+        const { error } = schema.validate({ order: input });
+        expect(error).toBeDefined();
+      });
+    });
+
+    // Tuple format validation
+    it('should reject invalid tuple format with detailed error message', () => {
+      const invalidTuples = [[['@name', 'ASC']], [['name', 'UP']], [['name']], [['name', 'ASC', 'extra']]];
+
+      invalidTuples.forEach((input, index) => {
+        const { error } = schema.validate({ order: input });
+        expect(error).toBeDefined();
+
+        if (index === 0) {
+          expect((error as any).details[0].message).toMatch(
+            /Field name can only contain letters, numbers, dots and underscores/
+          );
+        } else if (index === 1) {
+          expect((error as any).details[0].message).toMatch(/Direction must be either "asc" or "desc"/);
+        } else if (index === 2 || index === 3) {
+          // Test for array length validation
+          expect((error as any).details[0].message).toMatch(
+            /Each tuple must contain exactly 2 elements|Each tuple must contain \[field, direction\]/
+          );
+        }
+      });
+    });
+
+    // Case variation validation
+    it('should accept all valid case variations', () => {
+      const validInputs = [
+        'name:asc',
+        'name:ASC',
+        'name:desc',
+        'name:DESC',
+        ['name:asc'],
+        [['name', 'asc']],
+        [['name', 'ASC']],
+        [
+          ['name', 'ASC'],
+          ['age', 'desc'],
+        ],
+      ];
+
+      validInputs.forEach((input) => {
+        const { error } = schema.validate({ order: input });
+        expect(error).toBeUndefined();
+      });
+    });
+
+    // Testing specific error messages for each validation rule
+    it('should validate field name format', () => {
+      const { error } = schema.validate({ order: '@invalid:asc' });
+      expect(error).toBeDefined();
+      expect((error as any).details[0].message).toBe(
+        'Field name can only contain letters, numbers, dots and underscores'
+      );
+    });
+
+    it('should validate separator', () => {
+      const { error } = schema.validate({ order: 'name-asc' });
+      expect(error).toBeDefined();
+      expect((error as any).details[0].message).toBe('Must use ":" to separate field and direction');
+    });
+
+    it('should validate direction', () => {
+      const { error } = schema.validate({ order: 'name:up' });
+      expect(error).toBeDefined();
+      expect((error as any).details[0].message).toBe('Direction must be either "asc" or "desc"');
+    });
+
+    it('should validate tuple format length', () => {
+      const { error } = schema.validate({
+        order: [['name', 'ASC', 'extra']],
+      });
+      expect(error).toBeDefined();
+      expect((error as any).details[0].message).toBe('Each tuple must contain exactly 2 elements');
+    });
+
+    // Object format should not be supported
+    it('should reject object format', () => {
+      const { error } = schema.validate({
+        order: { name: 'asc', age: 'desc' },
+      });
+      expect(error).toBeDefined();
+      expect((error as any).details[0].message).toMatch(/Invalid order format. Must be one of:/);
+    });
+  });
+});

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.20
+version: 1.18.22
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.18.20",
+  "version": "1.18.22",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -46,16 +46,16 @@
     "@abtnode/cron": "^1.16.40",
     "@arcblock/did": "^1.19.15",
     "@arcblock/did-auth-storage-nedb": "^1.7.1",
-    "@arcblock/did-connect": "^2.12.36",
+    "@arcblock/did-connect": "^2.12.43",
     "@arcblock/did-util": "^1.19.15",
     "@arcblock/jwt": "^1.19.15",
-    "@arcblock/ux": "^2.12.36",
+    "@arcblock/ux": "^2.12.43",
     "@arcblock/validator": "^1.19.15",
     "@blocklet/js-sdk": "^1.16.40",
     "@blocklet/logger": "^1.16.40",
-    "@blocklet/payment-react": "1.18.20",
+    "@blocklet/payment-react": "1.18.22",
     "@blocklet/sdk": "^1.16.40",
-    "@blocklet/ui-react": "^2.12.36",
+    "@blocklet/ui-react": "^2.12.43",
     "@blocklet/uploader": "^0.1.79",
     "@blocklet/xss": "^0.1.30",
     "@mui/icons-material": "^5.16.6",
@@ -121,7 +121,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.16.40",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.18.20",
+    "@blocklet/payment-types": "1.18.22",
     "@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.25",
+    "vite-plugin-blocklet": "^0.9.27",
     "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": "f71a0013f704d58e4c04ebfcc5a35480a0942bcc"
+  "gitHead": "844883f56da79c1222fc5aa1b445abb2859e3230"
 }

package/src/components/layout/user.tsx

@@ -3,10 +3,19 @@ import { PaymentProvider } from '@blocklet/payment-react';
 import { UserCenter } from '@blocklet/ui-react';
 import { useEffect } from 'react';
 
+import { useSearchParams } from 'react-router-dom';
 import { useSessionContext } from '../../contexts/session';
 
 export default function UserLayout(props: any) {
   const { session, connectApi, events } = useSessionContext();
+  const [params] = useSearchParams();
+  const embed = params.get('embed') || sessionStorage.getItem('embed');
+
+  useEffect(() => {
+    if (embed) {
+      sessionStorage.setItem('embed', embed);
+    }
+  }, [embed]);
 
   useEffect(() => {
     events.once('logout', () => {
@@ -28,6 +37,7 @@ export default function UserLayout(props: any) {
           currentTab={`${window.blocklet.prefix}customer`}
           userDid={session.user.did}
           hideFooter
+          embed={embed === '1'}
           notLoginContent="undefined">
           {props.children}
         </UserCenter>