payment-kit 1.24.3 → 1.25.0

package/api/src/store/migrations/20251220-dynamic-pricing.ts

@@ -0,0 +1,245 @@
+/* eslint-disable no-await-in-loop */
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges, createIndexIfNotExists } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  // Add dynamic pricing fields to prices table
+  await safeApplyColumnChanges(context, {
+    prices: [
+      {
+        name: 'pricing_type',
+        field: {
+          type: DataTypes.ENUM('fixed', 'dynamic'),
+          defaultValue: 'fixed',
+          allowNull: false,
+        },
+      },
+      {
+        name: 'base_currency',
+        field: {
+          type: DataTypes.STRING(8),
+          allowNull: true,
+        },
+      },
+      {
+        name: 'base_amount',
+        field: {
+          type: DataTypes.STRING(32),
+          allowNull: true,
+        },
+      },
+      {
+        name: 'dynamic_pricing_config',
+        field: {
+          type: DataTypes.JSON,
+          allowNull: true,
+        },
+      },
+    ],
+  });
+
+  // Create exchange_rate_providers table
+  const tables = await context.showAllTables();
+  if (!tables.includes('exchange_rate_providers')) {
+    await context.createTable('exchange_rate_providers', {
+      id: {
+        type: DataTypes.STRING(32),
+        primaryKey: true,
+        allowNull: false,
+      },
+      name: {
+        type: DataTypes.STRING(64),
+        allowNull: false,
+        unique: true,
+      },
+      type: {
+        type: DataTypes.STRING(32),
+        allowNull: false,
+        defaultValue: 'token-data',
+      },
+      enabled: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
+      },
+      priority: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 1,
+      },
+      status: {
+        type: DataTypes.ENUM('active', 'degraded', 'paused', 'inactive'),
+        allowNull: false,
+        defaultValue: 'active',
+      },
+      paused_reason: {
+        type: DataTypes.STRING(512),
+        allowNull: true,
+      },
+      config: {
+        type: DataTypes.JSON,
+        allowNull: true,
+      },
+      last_success_at: {
+        type: DataTypes.DATE,
+        allowNull: true,
+      },
+      last_failure_at: {
+        type: DataTypes.DATE,
+        allowNull: true,
+      },
+      failure_count: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+      },
+      created_at: {
+        type: DataTypes.DATE,
+        defaultValue: DataTypes.NOW,
+        allowNull: false,
+      },
+      updated_at: {
+        type: DataTypes.DATE,
+        defaultValue: DataTypes.NOW,
+        allowNull: false,
+      },
+    });
+
+    await createIndexIfNotExists(context, 'exchange_rate_providers', ['name'], 'idx_erp_name', {
+      unique: true,
+    });
+    await createIndexIfNotExists(
+      context,
+      'exchange_rate_providers',
+      ['enabled', 'priority'],
+      'idx_erp_enabled_priority'
+    );
+
+    // Insert default token-data provider
+    await context.bulkInsert('exchange_rate_providers', [
+      {
+        id: `erp_${Date.now()}`,
+        name: 'token-data',
+        type: 'token-data',
+        enabled: true,
+        priority: 1,
+        status: 'active',
+        config: JSON.stringify({ base_url: 'https://token-data.arcblock.io' }),
+        failure_count: 0,
+        created_at: new Date(),
+        updated_at: new Date(),
+      },
+    ]);
+  }
+
+  // Create price_quotes table
+  if (!tables.includes('price_quotes')) {
+    await context.createTable('price_quotes', {
+      id: {
+        type: DataTypes.STRING(32),
+        primaryKey: true,
+        allowNull: false,
+      },
+      price_id: {
+        type: DataTypes.STRING(32),
+        allowNull: false,
+      },
+      session_id: {
+        type: DataTypes.STRING(32),
+        allowNull: true,
+      },
+      invoice_id: {
+        type: DataTypes.STRING(32),
+        allowNull: true,
+      },
+      idempotency_key: {
+        type: DataTypes.STRING(128),
+        allowNull: false,
+        unique: true,
+      },
+      base_currency: {
+        type: DataTypes.STRING(8),
+        allowNull: false,
+        defaultValue: 'USD',
+      },
+      base_amount: {
+        type: DataTypes.STRING(32),
+        allowNull: false,
+      },
+      target_currency_id: {
+        type: DataTypes.STRING(16),
+        allowNull: false,
+      },
+      rate_currency_symbol: {
+        type: DataTypes.STRING(16),
+        allowNull: false,
+      },
+      exchange_rate: {
+        type: DataTypes.STRING(32),
+        allowNull: false,
+      },
+      quoted_amount: {
+        type: DataTypes.STRING(64),
+        allowNull: false,
+      },
+      rate_provider_id: {
+        type: DataTypes.STRING(32),
+        allowNull: false,
+      },
+      rate_provider_name: {
+        type: DataTypes.STRING(64),
+        allowNull: false,
+      },
+      rate_timestamp_ms: {
+        type: DataTypes.BIGINT,
+        allowNull: false,
+      },
+      expires_at: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+      },
+      status: {
+        type: DataTypes.ENUM('active', 'used', 'paid', 'expired', 'cancelled', 'failed'),
+        allowNull: false,
+        defaultValue: 'active',
+      },
+      metadata: {
+        type: DataTypes.JSON,
+        allowNull: true,
+      },
+      created_at: {
+        type: DataTypes.DATE,
+        defaultValue: DataTypes.NOW,
+        allowNull: false,
+      },
+    });
+
+    await createIndexIfNotExists(context, 'price_quotes', ['idempotency_key'], 'idx_pq_idempotency', {
+      unique: true,
+    });
+    await createIndexIfNotExists(
+      context,
+      'price_quotes',
+      ['session_id', 'status', 'expires_at'],
+      'idx_pq_session_status_expires'
+    );
+    await createIndexIfNotExists(context, 'price_quotes', ['invoice_id', 'status'], 'idx_pq_invoice_status');
+    await createIndexIfNotExists(
+      context,
+      'price_quotes',
+      ['rate_currency_symbol', 'created_at'],
+      'idx_pq_currency_created'
+    );
+    await createIndexIfNotExists(context, 'price_quotes', ['created_at'], 'idx_pq_created');
+  }
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('prices', 'pricing_type');
+  await context.removeColumn('prices', 'base_currency');
+  await context.removeColumn('prices', 'base_amount');
+  await context.removeColumn('prices', 'dynamic_pricing_config');
+  await context.dropTable('exchange_rate_providers');
+  await context.dropTable('price_quotes');
+};

package/api/src/store/migrations/20251223-exchange-rate-provider-type.ts

@@ -0,0 +1,28 @@
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  // Add type field to exchange_rate_providers table
+  await safeApplyColumnChanges(context, {
+    exchange_rate_providers: [
+      {
+        name: 'type',
+        field: {
+          type: DataTypes.STRING(32),
+          allowNull: false,
+          defaultValue: 'token-data',
+        },
+      },
+    ],
+  });
+
+  // Update existing provider to have type field
+  await context.sequelize.query(
+    "UPDATE exchange_rate_providers SET type = 'token-data' WHERE type IS NULL OR type = ''"
+  );
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('exchange_rate_providers', 'type');
+};

package/api/src/store/migrations/20260110-add-quote-locked-at.ts

@@ -0,0 +1,23 @@
+import { DataTypes } from 'sequelize';
+
+import logger from '../../libs/logger';
+import { Migration } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  const [results] = await context.sequelize.query('PRAGMA table_info(payment_intents)');
+  const columnInfo = (results as any[]).find((col: any) => col.name === 'quote_locked_at');
+
+  if (columnInfo) {
+    logger.info('quote_locked_at already exists on payment_intents, skipping migration');
+    return;
+  }
+
+  await context.addColumn('payment_intents', 'quote_locked_at', {
+    type: DataTypes.DATE,
+    allowNull: true,
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('payment_intents', 'quote_locked_at');
+};

package/api/src/store/migrations/20260112-add-checkout-session-slippage-percent.ts

@@ -0,0 +1,22 @@
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    checkout_sessions: [
+      {
+        name: 'slippage_percent',
+        field: {
+          type: DataTypes.DECIMAL(5, 2),
+          allowNull: false,
+          defaultValue: 0.5,
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('checkout_sessions', 'slippage_percent');
+};

package/api/src/store/migrations/20260113-add-price-quote-slippage-fields.ts

@@ -0,0 +1,45 @@
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    price_quotes: [
+      {
+        name: 'slippage_percent',
+        field: {
+          type: DataTypes.DECIMAL(5, 2),
+          allowNull: true,
+        },
+      },
+      {
+        name: 'max_payable_token',
+        field: {
+          type: DataTypes.STRING(64),
+          allowNull: true,
+        },
+      },
+      {
+        name: 'min_acceptable_rate',
+        field: {
+          type: DataTypes.STRING(32),
+          allowNull: true,
+        },
+      },
+      {
+        name: 'slippage_derived_at_ms',
+        field: {
+          type: DataTypes.BIGINT,
+          allowNull: true,
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('price_quotes', 'slippage_percent');
+  await context.removeColumn('price_quotes', 'max_payable_token');
+  await context.removeColumn('price_quotes', 'min_acceptable_rate');
+  await context.removeColumn('price_quotes', 'slippage_derived_at_ms');
+};

package/api/src/store/migrations/20260116-subscription-slippage.ts

@@ -0,0 +1,21 @@
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    subscriptions: [
+      {
+        name: 'slippage_config',
+        field: {
+          type: DataTypes.JSON,
+          allowNull: true,
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('subscriptions', 'slippage_config');
+};

package/api/src/store/migrations/20260120-auto-recharge-slippage.ts

@@ -0,0 +1,21 @@
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    auto_recharge_configs: [
+      {
+        name: 'slippage_config',
+        field: {
+          type: DataTypes.JSON,
+          allowNull: true,
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('auto_recharge_configs', 'slippage_config');
+};

package/api/src/store/models/auto-recharge-config.ts

@@ -36,6 +36,14 @@ export class AutoRechargeConfig extends Model<InferAttributes<AutoRechargeConfig
     total_amount: string;
   };
 
+  declare slippage_config?: {
+    mode?: 'percent' | 'rate';
+    percent?: number;
+    min_acceptable_rate?: string;
+    base_currency?: string;
+    updated_at_ms?: number;
+  } | null;
+
   declare metadata?: Record<string, any>;
   declare created_at: CreationOptional<Date>;
   declare updated_at: CreationOptional<Date>;
@@ -121,6 +129,10 @@ export class AutoRechargeConfig extends Model<InferAttributes<AutoRechargeConfig
         total_amount: '0',
       },
     },
+    slippage_config: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
     metadata: {
       type: DataTypes.JSON,
       allowNull: true,

package/api/src/store/models/checkout-session.ts

@@ -83,6 +83,8 @@ export class CheckoutSession extends Model<InferAttributes<CheckoutSession>, Inf
   declare amount_subtotal: string;
   // Total of all items after discounts and taxes are applied.
   declare amount_total: string;
+  // User slippage percent (e.g., 0.5 means 0.5%)
+  declare slippage_percent?: number;
   // Tax and discount details for the computed total amount.
   declare total_details?: {
     amount_discount?: string;
@@ -326,6 +328,11 @@ export class CheckoutSession extends Model<InferAttributes<CheckoutSession>, Inf
       type: DataTypes.STRING(32),
       allowNull: false,
     },
+    slippage_percent: {
+      type: DataTypes.DECIMAL(5, 2),
+      allowNull: false,
+      defaultValue: 0.5,
+    },
     total_details: {
       type: DataTypes.JSON,
       allowNull: false,

package/api/src/store/models/exchange-rate-provider.ts

@@ -0,0 +1,225 @@
+import security from '@blocklet/sdk/lib/security';
+import cloneDeep from 'lodash/cloneDeep';
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model, Op } from 'sequelize';
+import type { LiteralUnion } from 'type-fest';
+
+import { createEvent } from '../../libs/audit';
+import { createIdGenerator } from '../../libs/util';
+
+export const nextExchangeRateProviderId = createIdGenerator('erp', 24);
+
+export class ExchangeRateProvider extends Model<
+  InferAttributes<ExchangeRateProvider>,
+  InferCreationAttributes<ExchangeRateProvider>
+> {
+  declare id: CreationOptional<string>;
+  declare name: string;
+  declare type: CreationOptional<LiteralUnion<'token-data' | 'coingecko' | 'coinmarketcap', string>>;
+  declare enabled: CreationOptional<boolean>;
+  declare priority: CreationOptional<number>;
+  declare status: CreationOptional<LiteralUnion<'active' | 'degraded' | 'paused' | 'inactive', string>>;
+  declare paused_reason: string | null;
+  declare config: Record<string, any> | null;
+  declare last_success_at: Date | null;
+  declare last_failure_at: Date | null;
+  declare failure_count: CreationOptional<number>;
+  declare created_at: CreationOptional<Date>;
+  declare updated_at: CreationOptional<Date>;
+
+  public static initialize(sequelize: any) {
+    this.init(
+      {
+        id: {
+          type: DataTypes.STRING(32),
+          primaryKey: true,
+          allowNull: false,
+          defaultValue: nextExchangeRateProviderId,
+        },
+        name: {
+          type: DataTypes.STRING(64),
+          allowNull: false,
+          unique: true,
+        },
+        type: {
+          type: DataTypes.STRING(32),
+          allowNull: false,
+          defaultValue: 'token-data',
+        },
+        enabled: {
+          type: DataTypes.BOOLEAN,
+          allowNull: false,
+          defaultValue: true,
+        },
+        priority: {
+          type: DataTypes.INTEGER,
+          allowNull: false,
+          defaultValue: 1,
+        },
+        status: {
+          type: DataTypes.ENUM('active', 'degraded', 'paused', 'inactive'),
+          allowNull: false,
+          defaultValue: 'active',
+        },
+        paused_reason: {
+          type: DataTypes.STRING(512),
+          allowNull: true,
+        },
+        config: {
+          type: DataTypes.JSON,
+          allowNull: true,
+        },
+        last_success_at: {
+          type: DataTypes.DATE,
+          allowNull: true,
+        },
+        last_failure_at: {
+          type: DataTypes.DATE,
+          allowNull: true,
+        },
+        failure_count: {
+          type: DataTypes.INTEGER,
+          allowNull: false,
+          defaultValue: 0,
+        },
+        created_at: {
+          type: DataTypes.DATE,
+          defaultValue: DataTypes.NOW,
+          allowNull: false,
+        },
+        updated_at: {
+          type: DataTypes.DATE,
+          defaultValue: DataTypes.NOW,
+          allowNull: false,
+        },
+      },
+      {
+        sequelize,
+        modelName: 'ExchangeRateProvider',
+        tableName: 'exchange_rate_providers',
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        hooks: {
+          afterCreate: (model: ExchangeRateProvider, options) =>
+            createEvent('ExchangeRateProvider', 'exchange_rate_provider.created', model, options).catch(console.error),
+          afterUpdate: (model: ExchangeRateProvider, options) =>
+            createEvent('ExchangeRateProvider', 'exchange_rate_provider.updated', model, options).catch(console.error),
+          afterDestroy: (model: ExchangeRateProvider, options) =>
+            createEvent('ExchangeRateProvider', 'exchange_rate_provider.deleted', model, options).catch(console.error),
+        },
+      }
+    );
+  }
+
+  public static getActiveProviders() {
+    return this.findAll({
+      where: { enabled: true, status: { [Op.ne]: 'paused' } },
+      order: [['priority', 'ASC']],
+    });
+  }
+
+  public async recordSuccess() {
+    await this.update({
+      last_success_at: new Date(),
+      failure_count: 0,
+      status: 'active',
+    });
+  }
+
+  public async recordFailure(reason?: string) {
+    const newFailureCount = this.failure_count + 1;
+    const updates: any = {
+      last_failure_at: new Date(),
+      failure_count: newFailureCount,
+    };
+
+    // Auto-pause after 5 consecutive failures
+    // BUT: Never pause the last remaining provider to prevent total service outage
+    if (newFailureCount >= 5) {
+      // Check if there are other active providers
+      const otherActiveProviders = await ExchangeRateProvider.count({
+        where: {
+          id: { [Op.ne]: this.id },
+          enabled: true,
+          status: { [Op.ne]: 'paused' },
+        },
+      });
+
+      // Only pause if there are other providers available
+      if (otherActiveProviders > 0) {
+        updates.status = 'paused';
+        updates.paused_reason = reason || 'Too many consecutive failures';
+      } else {
+        // Keep as degraded instead of pausing to maintain service availability
+        updates.status = 'degraded';
+        updates.paused_reason = `${reason || 'Multiple failures'} (last provider, not paused to maintain service)`;
+      }
+    } else {
+      updates.status = 'degraded';
+    }
+
+    await this.update(updates);
+  }
+
+  /**
+   * Encrypt sensitive config data (API keys)
+   * Should be called before saving to database
+   */
+  public static encryptConfig(config: Record<string, any> | null): Record<string, any> | null {
+    if (!config) return null;
+
+    const tmp = cloneDeep(config);
+
+    // Encrypt API key if present
+    if (tmp.api_key && typeof tmp.api_key === 'string') {
+      tmp.api_key = security.encrypt(tmp.api_key);
+    }
+
+    return tmp;
+  }
+
+  /**
+   * Decrypt sensitive config data (API keys)
+   * Should be called after reading from database
+   */
+  public static decryptConfig(config: Record<string, any> | null): Record<string, any> | null {
+    if (!config) return null;
+
+    const tmp = cloneDeep(config);
+
+    // Decrypt API key if present
+    if (tmp.api_key && typeof tmp.api_key === 'string') {
+      try {
+        tmp.api_key = security.decrypt(tmp.api_key);
+      } catch (error) {
+        // If decryption fails, the api_key might already be decrypted or invalid
+        // Keep the original value
+      }
+    }
+
+    return tmp;
+  }
+
+  /**
+   * Mask sensitive config data for display
+   * Returns config with API key partially masked
+   */
+  public static maskConfig(config: Record<string, any> | null): Record<string, any> | null {
+    if (!config) return null;
+
+    const tmp = cloneDeep(config);
+
+    // Mask API key if present (show first 4 and last 4 characters)
+    if (tmp.api_key && typeof tmp.api_key === 'string') {
+      const key = tmp.api_key;
+      if (key.length > 8) {
+        tmp.api_key = `${key.substring(0, 4)}${'*'.repeat(key.length - 8)}${key.substring(key.length - 4)}`;
+      } else {
+        tmp.api_key = '*'.repeat(key.length);
+      }
+    }
+
+    return tmp;
+  }
+}
+
+export type TExchangeRateProvider = InferAttributes<ExchangeRateProvider>;