payment-kit 1.27.2 → 1.29.0

package/api/src/routes/payment-methods.ts

@@ -6,7 +6,7 @@ import pick from 'lodash/pick';
 import { InferAttributes, Op, WhereOptions } from 'sequelize';
 import cloneDeep from 'lodash/cloneDeep';
 import merge from 'lodash/merge';
-import { Joi } from '@arcblock/validator';
+import Joi from 'joi';
 import { ensureWebhookRegistered, cleanupStripeWebhook, validateStripeKeys } from '../integrations/stripe/setup';
 import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
@@ -183,6 +183,124 @@ router.post('/', auth, async (req, res) => {
     return res.json({ ...method.toJSON(), payment_currencies: [currency.toJSON()] });
   }
 
+  if (raw.type === 'google_play') {
+    if (!raw.settings.google_play?.package_name) {
+      return res.status(400).json({ error: 'google_play package_name is required' });
+    }
+    if (!raw.settings.google_play?.service_account_json) {
+      return res.status(400).json({ error: 'google_play service_account_json is required' });
+    }
+    try {
+      const parsed = JSON.parse(raw.settings.google_play.service_account_json);
+      if (!parsed.client_email || !parsed.private_key) {
+        return res.status(400).json({ error: 'service_account_json missing client_email or private_key' });
+      }
+    } catch {
+      return res.status(400).json({ error: 'service_account_json is not valid JSON' });
+    }
+
+    const exist = await PaymentMethod.findOne({
+      where: { type: 'google_play', livemode: raw.livemode },
+    });
+    if (exist) {
+      return res.status(400).json({ error: 'google_play payment method already exists for this livemode' });
+    }
+
+    raw.settings = pick(PaymentMethod.encryptSettings(raw.settings), ['google_play']) as PaymentMethodSettings;
+    raw.logo = raw.logo || getUrl('/methods/google-play.png');
+    raw.features = { recurring: true, refund: true, dispute: false };
+    raw.confirmation = { type: 'callback' };
+
+    const method = await PaymentMethod.create(raw as TPaymentMethod);
+
+    // Create a default USD currency for the PaymentMethod (mirrors stripe path).
+    const currency = await PaymentCurrency.create({
+      livemode: method.livemode,
+      active: method.active,
+      locked: true,
+      is_base_currency: false,
+      payment_method_id: method.id,
+      type: 'standard',
+      name: 'Dollar',
+      description: 'US Dollar (Google Play)',
+      logo: getUrl('/currencies/dollar.png'),
+      symbol: 'USD',
+      decimal: 2,
+      maximum_precision: 2,
+      minimum_payment_amount: '1',
+      maximum_payment_amount: '100000000000',
+      contract: '',
+      metadata: {},
+    });
+    await method.update({ default_currency_id: currency.id });
+
+    return res.json({ ...method.toJSON(), payment_currencies: [currency.toJSON()] });
+  }
+
+  if (raw.type === 'app_store') {
+    if (!raw.settings.app_store?.bundle_id) {
+      return res.status(400).json({ error: 'app_store bundle_id is required' });
+    }
+    const env = raw.settings.app_store?.environment;
+    if (env !== 'production' && env !== 'sandbox') {
+      return res.status(400).json({ error: 'app_store environment must be production or sandbox' });
+    }
+    // Server API credentials are optional — StoreKit 2 JWS verify doesn't need them.
+    // But if any of the three is set, all three must be set together.
+    const hasAnyServerCred = !!(
+      raw.settings.app_store?.issuer_id ||
+      raw.settings.app_store?.key_id ||
+      raw.settings.app_store?.private_key_pem
+    );
+    if (hasAnyServerCred) {
+      if (
+        !raw.settings.app_store?.issuer_id ||
+        !raw.settings.app_store?.key_id ||
+        !raw.settings.app_store?.private_key_pem
+      ) {
+        return res.status(400).json({
+          error: 'app_store Server API credentials must include all of issuer_id, key_id, private_key_pem',
+        });
+      }
+    }
+
+    const exist = await PaymentMethod.findOne({
+      where: { type: 'app_store', livemode: raw.livemode },
+    });
+    if (exist) {
+      return res.status(400).json({ error: 'app_store payment method already exists for this livemode' });
+    }
+
+    raw.settings = pick(PaymentMethod.encryptSettings(raw.settings), ['app_store']) as PaymentMethodSettings;
+    raw.logo = raw.logo || getUrl('/methods/app-store.png');
+    raw.features = { recurring: true, refund: false, dispute: false };
+    raw.confirmation = { type: 'callback' };
+
+    const method = await PaymentMethod.create(raw as TPaymentMethod);
+
+    const currency = await PaymentCurrency.create({
+      livemode: method.livemode,
+      active: method.active,
+      locked: true,
+      is_base_currency: false,
+      payment_method_id: method.id,
+      type: 'standard',
+      name: 'Dollar',
+      description: 'US Dollar (App Store)',
+      logo: getUrl('/currencies/dollar.png'),
+      symbol: 'USD',
+      decimal: 2,
+      maximum_precision: 2,
+      minimum_payment_amount: '1',
+      maximum_payment_amount: '100000000000',
+      contract: '',
+      metadata: {},
+    });
+    await method.update({ default_currency_id: currency.id });
+
+    return res.json({ ...method.toJSON(), payment_currencies: [currency.toJSON()] });
+  }
+
   // FIXME: support bitcoin payment methods
 
   return res.status(400).json({ error: 'payment method type is not supported' });
@@ -259,6 +377,18 @@ router.get('/types', auth, (_, res) => {
       description: 'Pay with base compatible chains',
       logo: getUrl('/methods/base.png'),
     },
+    {
+      type: 'google_play',
+      name: 'Google Play',
+      description: 'Subscriptions purchased via Google Play in-app billing',
+      logo: getUrl('/methods/google-play.png'),
+    },
+    {
+      type: 'app_store',
+      name: 'App Store',
+      description: 'Subscriptions purchased via Apple App Store StoreKit',
+      logo: getUrl('/methods/app-store.png'),
+    },
   ]);
 });
 

package/api/src/routes/settings.ts

@@ -3,7 +3,7 @@ import pick from 'lodash/pick';
 import { Op, type WhereOptions } from 'sequelize';
 
 import Joi from 'joi';
-import { merge } from 'lodash';
+import merge from 'lodash/merge';
 import { PaymentCurrency } from '../store/models/payment-currency';
 import { PaymentMethod } from '../store/models/payment-method';
 import { authenticate } from '../libs/security';

package/api/src/routes/tax-rates.ts

@@ -77,7 +77,7 @@ router.get('/', auth, async (req, res) => {
             literal(`(
               SELECT COUNT(DISTINCT ii.invoice_id)
               FROM invoice_items AS ii
-              WHERE ii.tax_rate_id = TaxRate.id
+              WHERE ii.tax_rate_id = tax_rates.id
             )`),
             'invoice_count',
           ],

package/api/src/store/migrations/20260526-iap-foundation.ts

@@ -0,0 +1,105 @@
+import { DataTypes } from 'sequelize';
+import { createIndexIfNotExists, safeApplyColumnChanges, type Migration } from '../migrate';
+import models from '../models';
+
+export const up: Migration = async ({ context }) => {
+  // 1. Customer: per-channel UUID for IAP appAccountToken / obfuscatedAccountId mapping (D-004)
+  await safeApplyColumnChanges(context, {
+    customers: [
+      { name: 'app_store_uuid', field: { type: DataTypes.STRING(36), allowNull: true } },
+      { name: 'google_play_uuid', field: { type: DataTypes.STRING(36), allowNull: true } },
+    ],
+  });
+  // SQLite/D1 allows multiple NULLs in UNIQUE columns, so a plain UNIQUE index
+  // is functionally equivalent to a partial one (WHERE col IS NOT NULL).
+  await createIndexIfNotExists(context, 'customers', ['app_store_uuid'], 'idx_customers_app_store_uuid', {
+    unique: true,
+  });
+  await createIndexIfNotExists(context, 'customers', ['google_play_uuid'], 'idx_customers_google_play_uuid', {
+    unique: true,
+  });
+
+  // 2. Subscription: channel + environment (D-005)
+  await safeApplyColumnChanges(context, {
+    subscriptions: [
+      { name: 'channel', field: { type: DataTypes.STRING(20), allowNull: true } },
+      {
+        name: 'environment',
+        field: { type: DataTypes.STRING(20), allowNull: true, defaultValue: 'production' },
+      },
+    ],
+  });
+
+  // 3. Invoice: three-segment amounts for cross-channel accounting (D-001 A)
+  await safeApplyColumnChanges(context, {
+    invoices: [
+      { name: 'gross_amount', field: { type: DataTypes.STRING(32), allowNull: true } },
+      { name: 'platform_fee', field: { type: DataTypes.STRING(32), defaultValue: '0' } },
+      { name: 'net_amount', field: { type: DataTypes.STRING(32), allowNull: true } },
+    ],
+  });
+  // Backfill: existing Stripe / on-chain rows have no platform fee, so gross = net = total
+  await context.sequelize.query(
+    'UPDATE invoices SET gross_amount = total, net_amount = total WHERE gross_amount IS NULL'
+  );
+
+  // 4. Refund: source (merchant_initiated | platform_initiated)
+  await safeApplyColumnChanges(context, {
+    refunds: [
+      {
+        name: 'source',
+        field: { type: DataTypes.STRING(30), allowNull: true, defaultValue: 'merchant_initiated' },
+      },
+    ],
+  });
+
+  // 5. Entitlement tables (D-003 B)
+  await context.createTable('entitlements', models.Entitlement.GENESIS_ATTRIBUTES);
+  await createIndexIfNotExists(context, 'entitlements', ['key'], 'idx_entitlements_key', { unique: true });
+
+  await context.createTable('entitlement_products', models.EntitlementProduct.GENESIS_ATTRIBUTES);
+
+  await context.createTable('entitlement_grants', models.EntitlementGrant.GENESIS_ATTRIBUTES);
+  await createIndexIfNotExists(
+    context,
+    'entitlement_grants',
+    ['customer_id', 'entitlement_id', 'status'],
+    'idx_entitlement_grants_lookup'
+  );
+  await createIndexIfNotExists(
+    context,
+    'entitlement_grants',
+    ['source_subscription_id'],
+    'idx_entitlement_grants_source_sub'
+  );
+
+  // Note: PaymentMethod.type ENUM extension to include 'app_store' / 'google_play'
+  // is intentionally NOT changed at DB level — on D1/SQLite the column is already TEXT
+  // with no CHECK constraint, so any value is accepted. The model-level type union
+  // is updated in models/payment-method.ts when A1/A2 lands.
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeIndex('entitlement_grants', 'idx_entitlement_grants_source_sub');
+  await context.removeIndex('entitlement_grants', 'idx_entitlement_grants_lookup');
+  await context.dropTable('entitlement_grants');
+
+  await context.dropTable('entitlement_products');
+
+  await context.removeIndex('entitlements', 'idx_entitlements_key');
+  await context.dropTable('entitlements');
+
+  await context.removeColumn('refunds', 'source');
+
+  await context.removeColumn('invoices', 'net_amount');
+  await context.removeColumn('invoices', 'platform_fee');
+  await context.removeColumn('invoices', 'gross_amount');
+
+  await context.removeColumn('subscriptions', 'environment');
+  await context.removeColumn('subscriptions', 'channel');
+
+  await context.removeIndex('customers', 'idx_customers_google_play_uuid');
+  await context.removeIndex('customers', 'idx_customers_app_store_uuid');
+  await context.removeColumn('customers', 'google_play_uuid');
+  await context.removeColumn('customers', 'app_store_uuid');
+};

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

@@ -13,9 +13,9 @@ import {
 } from 'sequelize';
 
 import merge from 'lodash/merge';
+import { getLock } from '../../libs/lock';
 import { createEvent } from '../../libs/audit';
 import CustomError from '../../libs/error';
-import { getLock } from '../../libs/lock';
 import { createCodeGenerator, createIdGenerator } from '../../libs/util';
 import type { CustomerAddress, CustomerPreferences, CustomerShipping } from './types';
 
@@ -57,6 +57,10 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
   };
   declare next_invoice_sequence?: number;
 
+  // Per-channel UUID for IAP appAccountToken / obfuscatedAccountId mapping (D-004)
+  declare app_store_uuid?: string;
+  declare google_play_uuid?: string;
+
   // TODO: following fields not supported
   // declare preferred_locales?: string[];
   // declare tax_exempt?: LiteralUnion<'exempt' | 'none' | 'reverse', string>;
@@ -143,6 +147,16 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
       type: DataTypes.NUMBER,
       defaultValue: 1,
     },
+    app_store_uuid: {
+      type: DataTypes.STRING(36),
+      allowNull: true,
+      unique: true,
+    },
+    google_play_uuid: {
+      type: DataTypes.STRING(36),
+      allowNull: true,
+      unique: true,
+    },
     created_at: {
       type: DataTypes.DATE,
       defaultValue: DataTypes.NOW,
@@ -156,6 +170,28 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
   };
 
   public async getInvoiceNumber() {
+    // Optimized path for CF Workers: atomic UPDATE...RETURNING in 1 D1 round trip.
+    // Original lock-based approach: lock.acquire → reload → increment(UPDATE + reload) → release
+    //   = 2 D1 round trips for lock + 3 D1 round trips for data = ~1000ms at ~350ms/RT
+    // Optimized: single UPDATE...RETURNING = 1 D1 round trip = ~350ms
+    //
+    // SQLite serializes writes at the DB level, so the application-level lock is
+    // redundant for both D1 and Blocklet Server's SQLite.
+    const d1 = (globalThis as any).__CF_ENV__?.DB;
+    if (d1) {
+      try {
+        const sql =
+          // eslint-disable-next-line @typescript-eslint/quotes
+          'UPDATE "customers" SET "next_invoice_sequence" = COALESCE("next_invoice_sequence", 1) + 1 WHERE "id" = ? RETURNING "next_invoice_sequence" - 1 as "prev_sequence"';
+        const result = await d1.prepare(sql).bind(this.id).first();
+        const sequence = (result as any)?.prev_sequence ?? 1;
+        return `${this.invoice_prefix}-${padStart(sequence.toString(), 4, '0')}`;
+      } catch (err) {
+        console.warn('[getInvoiceNumber] D1 RETURNING failed, falling back:', (err as any)?.message);
+      }
+    }
+
+    // Blocklet Server path (or D1 fallback): use lock-based approach
     const lock = getLock(`${this.id}-invoice-number`);
     await lock.acquire();
     await this.reload();

package/api/src/store/models/entitlement-grant.ts

@@ -0,0 +1,118 @@
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+import type { LiteralUnion } from 'type-fest';
+
+import { createIdGenerator } from '../../libs/util';
+
+export const nextEntitlementGrantId = createIdGenerator('eg', 24);
+
+// One Subscription (or other source) grants an Entitlement to a Customer.
+// Multiple grants for the same (customer, entitlement) can coexist across channels;
+// the "currently effective" grant is determined by status + active_until.
+// eslint-disable-next-line prettier/prettier
+export class EntitlementGrant extends Model<InferAttributes<EntitlementGrant>, InferCreationAttributes<EntitlementGrant>> {
+  declare id: CreationOptional<string>;
+  declare livemode: boolean;
+
+  declare entitlement_id: string;
+  declare customer_id: string;
+
+  declare source_subscription_id?: string;
+  declare source_channel: LiteralUnion<
+    'stripe' | 'arcblock' | 'ethereum' | 'base' | 'app_store' | 'google_play',
+    string
+  >;
+
+  declare active_from: number;
+  declare active_until: number;
+
+  declare status: LiteralUnion<'active' | 'canceled' | 'expired' | 'voided', string>;
+
+  declare metadata?: Record<string, any>;
+
+  declare created_at: CreationOptional<Date>;
+  declare updated_at: CreationOptional<Date>;
+
+  public static readonly GENESIS_ATTRIBUTES = {
+    id: {
+      type: DataTypes.STRING(30),
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: nextEntitlementGrantId,
+    },
+    livemode: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    entitlement_id: {
+      type: DataTypes.STRING(30),
+      allowNull: false,
+    },
+    customer_id: {
+      type: DataTypes.STRING(18),
+      allowNull: false,
+    },
+    source_subscription_id: {
+      type: DataTypes.STRING(30),
+      allowNull: true,
+    },
+    source_channel: {
+      type: DataTypes.STRING(20),
+      allowNull: false,
+    },
+    active_from: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
+    active_until: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
+    status: {
+      type: DataTypes.STRING(20),
+      allowNull: false,
+      defaultValue: 'active',
+    },
+    metadata: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+  };
+
+  public static initialize(sequelize: any) {
+    this.init(EntitlementGrant.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'EntitlementGrant',
+      tableName: 'entitlement_grants',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    });
+  }
+
+  public static associate(models: any) {
+    this.belongsTo(models.Entitlement, {
+      foreignKey: 'entitlement_id',
+      as: 'entitlement',
+    });
+    this.belongsTo(models.Customer, {
+      foreignKey: 'customer_id',
+      as: 'customer',
+    });
+    this.belongsTo(models.Subscription, {
+      foreignKey: 'source_subscription_id',
+      as: 'subscription',
+    });
+  }
+}
+
+export type TEntitlementGrant = InferAttributes<EntitlementGrant>;

package/api/src/store/models/entitlement-product.ts

@@ -0,0 +1,48 @@
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+
+// Join table: which products unlock which entitlements (many-to-many)
+// eslint-disable-next-line prettier/prettier
+export class EntitlementProduct extends Model<InferAttributes<EntitlementProduct>, InferCreationAttributes<EntitlementProduct>> {
+  declare entitlement_id: string;
+  declare product_id: string;
+  declare created_at: CreationOptional<Date>;
+  declare updated_at: CreationOptional<Date>;
+
+  public static readonly GENESIS_ATTRIBUTES = {
+    entitlement_id: {
+      type: DataTypes.STRING(30),
+      primaryKey: true,
+      allowNull: false,
+    },
+    product_id: {
+      type: DataTypes.STRING(30),
+      primaryKey: true,
+      allowNull: false,
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+  };
+
+  public static initialize(sequelize: any) {
+    this.init(EntitlementProduct.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'EntitlementProduct',
+      tableName: 'entitlement_products',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    });
+  }
+
+  public static associate() {}
+}
+
+export type TEntitlementProduct = InferAttributes<EntitlementProduct>;

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

@@ -0,0 +1,86 @@
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+
+import { createIdGenerator } from '../../libs/util';
+
+export const nextEntitlementId = createIdGenerator('ent', 24);
+
+// eslint-disable-next-line prettier/prettier
+export class Entitlement extends Model<InferAttributes<Entitlement>, InferCreationAttributes<Entitlement>> {
+  declare id: CreationOptional<string>;
+  declare livemode: boolean;
+
+  declare key: string;
+  declare name?: string;
+  declare description?: string;
+
+  declare metadata?: Record<string, any>;
+
+  declare created_at: CreationOptional<Date>;
+  declare updated_at: CreationOptional<Date>;
+
+  public static readonly GENESIS_ATTRIBUTES = {
+    id: {
+      type: DataTypes.STRING(30),
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: nextEntitlementId,
+    },
+    livemode: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    key: {
+      type: DataTypes.STRING(64),
+      allowNull: false,
+      unique: true,
+    },
+    name: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+    },
+    metadata: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+  };
+
+  public static initialize(sequelize: any) {
+    this.init(Entitlement.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'Entitlement',
+      tableName: 'entitlements',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    });
+  }
+
+  public static associate(models: any) {
+    this.belongsToMany(models.Product, {
+      through: models.EntitlementProduct,
+      foreignKey: 'entitlement_id',
+      otherKey: 'product_id',
+      as: 'products',
+    });
+    this.hasMany(models.EntitlementGrant, {
+      foreignKey: 'entitlement_id',
+      as: 'grants',
+    });
+  }
+}
+
+export type TEntitlement = InferAttributes<Entitlement>;

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

@@ -39,6 +39,9 @@ import { PriceQuote } from './price-quote';
 import { ArchiveMetadata } from './archive-metadata';
 import { ArchiveLock } from './archive-lock';
 import { RevenueSnapshot } from './revenue-snapshot';
+import { Entitlement } from './entitlement';
+import { EntitlementGrant } from './entitlement-grant';
+import { EntitlementProduct } from './entitlement-product';
 
 const models = {
   CheckoutSession,
@@ -81,6 +84,9 @@ const models = {
   ArchiveMetadata,
   ArchiveLock,
   RevenueSnapshot,
+  Entitlement,
+  EntitlementGrant,
+  EntitlementProduct,
 };
 
 export function initialize(sequelize: any) {
@@ -137,6 +143,9 @@ export * from './price-quote';
 export * from './archive-metadata';
 export * from './archive-lock';
 export * from './revenue-snapshot';
+export * from './entitlement';
+export * from './entitlement-grant';
+export * from './entitlement-product';
 
 export type TPriceExpanded = TPrice & {
   object: 'price';

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

@@ -84,6 +84,14 @@ export class Invoice extends Model<InferAttributes<Invoice>, InferCreationAttrib
   declare tax: string;
   declare total: string;
 
+  // Three-segment amounts for cross-channel accounting (D-001 A).
+  // gross_amount = what the user actually paid (= total for non-IAP channels).
+  // platform_fee = amount Apple / Google withheld (0 for Stripe / on-chain).
+  // net_amount   = what we actually received (= gross_amount - platform_fee).
+  declare gross_amount?: string;
+  declare platform_fee?: string;
+  declare net_amount?: string;
+
   declare amount_due: string; // total - amount_paid
   declare amount_paid: string;
   declare amount_remaining: string; // amount_due - amount_paid
@@ -250,6 +258,18 @@ export class Invoice extends Model<InferAttributes<Invoice>, InferCreationAttrib
       type: DataTypes.STRING(32),
       allowNull: false,
     },
+    gross_amount: {
+      type: DataTypes.STRING(32),
+      allowNull: true,
+    },
+    platform_fee: {
+      type: DataTypes.STRING(32),
+      defaultValue: '0',
+    },
+    net_amount: {
+      type: DataTypes.STRING(32),
+      allowNull: true,
+    },
     subtotal: {
       type: DataTypes.STRING(32),
       allowNull: false,