payment-kit 1.24.4 → 1.25.1

package/api/tests/routes/exchange-rate-providers.spec.ts

@@ -0,0 +1,215 @@
+import { describe, it, expect } from '@jest/globals';
+
+/**
+ * Unit tests for exchange-rate-providers routes
+ * Focus: DELETE endpoint and test-connection endpoint
+ *
+ * Note: These are logic tests, not full integration tests with database
+ */
+
+describe('Exchange Rate Providers Routes', () => {
+  describe('DELETE endpoint logic', () => {
+    /**
+     * TC-D03: Cannot delete in-use provider
+     */
+    it('should prevent deletion of in-use provider', () => {
+      // Mock scenario
+      const targetProviderId = 'provider-1';
+      const activeProviderId = 'provider-1'; // Same as target
+
+      // Logic from DELETE endpoint
+      const isInUse = targetProviderId === activeProviderId;
+
+      expect(isInUse).toBe(true);
+      // In actual endpoint: return 400 with error message
+    });
+
+    /**
+     * TC-D02: Allow deletion of non-active provider
+     */
+    it('should allow deletion of non-active provider', () => {
+      const targetProviderId: string = 'provider-2';
+      const activeProviderId: string = 'provider-1'; // Different
+
+      const isInUse = targetProviderId === activeProviderId;
+
+      expect(isInUse).toBe(false);
+      // In actual endpoint: proceed with deletion
+    });
+
+    /**
+     * TC-D04: Cannot delete last enabled provider
+     */
+    it('should prevent deletion of last enabled provider', () => {
+      // Mock scenario: target is enabled, no other enabled providers
+      const otherEnabledCount = 0;
+      const providerEnabled = true;
+      const providerStatus: string = 'active';
+
+      const isLastEnabled = otherEnabledCount === 0 && providerEnabled && providerStatus !== 'paused';
+
+      expect(isLastEnabled).toBe(true);
+      // In actual endpoint: return 400 with error message
+    });
+
+    /**
+     * TC-D05: Allow deletion when multiple enabled providers exist
+     */
+    it('should allow deletion when other enabled providers exist', () => {
+      const otherEnabledCount: number = 2; // Other enabled providers available
+      const providerEnabled = true;
+      const providerStatus: string = 'active';
+
+      const isLastEnabled = otherEnabledCount === 0 && providerEnabled && providerStatus !== 'paused';
+
+      expect(isLastEnabled).toBe(false);
+      // In actual endpoint: proceed with deletion
+    });
+
+    /**
+     * TC-D09: Allow deletion of paused provider
+     */
+    it('should allow deletion of paused provider even if no other enabled', () => {
+      const otherEnabledCount = 0;
+      const providerEnabled = true;
+      const providerStatus = 'paused';
+
+      const isLastEnabled = otherEnabledCount === 0 && providerEnabled && providerStatus !== 'paused';
+
+      expect(isLastEnabled).toBe(false);
+      // Paused providers don't count as "active", safe to delete
+    });
+  });
+
+  describe('Active provider selection logic', () => {
+    /**
+     * Verify the logic for determining active provider matches frontend
+     */
+    it('should select lowest priority enabled provider', () => {
+      const allProviders = [
+        { id: 'p1', priority: 2, enabled: true, status: 'active' },
+        { id: 'p2', priority: 1, enabled: true, status: 'active' },
+        { id: 'p3', priority: 3, enabled: false, status: 'active' },
+      ];
+
+      // Logic from DELETE endpoint
+      const activeProviders = allProviders
+        .filter((p) => p.enabled && p.status !== 'paused')
+        .sort((a, b) => a.priority - b.priority);
+
+      const activeProviderId = activeProviders[0]?.id || null;
+
+      expect(activeProviderId).toBe('p2'); // Lowest priority among enabled
+    });
+
+    it('should exclude paused providers from active selection', () => {
+      const allProviders = [
+        { id: 'p1', priority: 1, enabled: true, status: 'paused' },
+        { id: 'p2', priority: 2, enabled: true, status: 'active' },
+      ];
+
+      const activeProviders = allProviders
+        .filter((p) => p.enabled && p.status !== 'paused')
+        .sort((a, b) => a.priority - b.priority);
+
+      const activeProviderId = activeProviders[0]?.id || null;
+
+      expect(activeProviderId).toBe('p2'); // p1 is paused, so p2 is active
+    });
+
+    it('should return null when no active providers', () => {
+      const allProviders = [
+        { id: 'p1', priority: 1, enabled: false, status: 'active' },
+        { id: 'p2', priority: 2, enabled: true, status: 'paused' },
+      ];
+
+      const activeProviders = allProviders
+        .filter((p) => p.enabled && p.status !== 'paused')
+        .sort((a, b) => a.priority - b.priority);
+
+      const activeProviderId = activeProviders[0]?.id || null;
+
+      expect(activeProviderId).toBeNull();
+    });
+  });
+
+  describe('Test connection endpoint validation', () => {
+    /**
+     * TC-T07: Invalid provider type
+     */
+    it('should reject invalid provider types', () => {
+      const allowedTypes = ['token-data', 'coingecko', 'coinmarketcap'];
+      const testType = 'invalid-type';
+
+      const isValid = allowedTypes.includes(testType);
+
+      expect(isValid).toBe(false);
+      // In actual endpoint: return 400
+    });
+
+    /**
+     * TC-T01: Valid provider types
+     */
+    it('should accept valid provider types', () => {
+      const allowedTypes = ['token-data', 'coingecko', 'coinmarketcap'];
+
+      expect(allowedTypes.includes('token-data')).toBe(true);
+      expect(allowedTypes.includes('coingecko')).toBe(true);
+      expect(allowedTypes.includes('coinmarketcap')).toBe(true);
+    });
+
+    /**
+     * Test symbol selection
+     */
+    it('should use ETH as test symbol', () => {
+      const testSymbol = 'ETH';
+
+      expect(testSymbol).toBe('ETH');
+      // ETH is most common and stable token for testing
+    });
+  });
+
+  describe('Safety constraint scenarios', () => {
+    /**
+     * INT-02: Full delete protection workflow
+     */
+    it('should handle delete protection workflow correctly', () => {
+      // Scenario: 2 providers, A (priority 1), B (priority 2)
+      const providers = [
+        { id: 'A', priority: 1, enabled: true, status: 'active' },
+        { id: 'B', priority: 2, enabled: true, status: 'active' },
+      ];
+
+      // Provider A is in-use
+      const activeProviders = providers
+        .filter((p) => p.enabled && p.status !== 'paused')
+        .sort((a, b) => a.priority - b.priority);
+      let activeProviderId = activeProviders[0]?.id;
+
+      expect(activeProviderId).toBe('A');
+
+      // Try to delete A - should be blocked
+      const canDeleteA = activeProviderId !== 'A';
+      expect(canDeleteA).toBe(false);
+
+      // Disable A
+      providers[0]!.enabled = false;
+
+      // Now B should become active
+      const updatedActiveProviders = providers
+        .filter((p) => p.enabled && p.status !== 'paused')
+        .sort((a, b) => a.priority - b.priority);
+      activeProviderId = updatedActiveProviders[0]?.id;
+
+      expect(activeProviderId).toBe('B');
+
+      // Now A can be deleted (not in-use, not last enabled since B exists)
+      const canDeleteANow = activeProviderId !== 'A';
+      const otherEnabledCount: number = 1; // B is enabled
+      const aIsLastEnabled = otherEnabledCount === 0 && !providers[0]!.enabled;
+
+      expect(canDeleteANow).toBe(true);
+      expect(aIsLastEnabled).toBe(false);
+    });
+  });
+});

package/api/tests/routes/subscription-slippage.spec.ts

@@ -0,0 +1,254 @@
+/**
+ * Unit tests for subscription slippage routes
+ * Focus: PUT /:id/slippage endpoint validation logic
+ *
+ * Note: These are logic tests, not full integration tests with database
+ */
+
+describe('Subscription Slippage Routes', () => {
+  describe('normalizePercent validation', () => {
+    const normalizePercent = (value: any) => {
+      const normalized = typeof value === 'string' ? Number(value) : value;
+      if (!Number.isFinite(normalized) || normalized < 0) {
+        return null;
+      }
+      return normalized;
+    };
+
+    it('should accept valid positive number', () => {
+      expect(normalizePercent(0.5)).toBe(0.5);
+      expect(normalizePercent(1)).toBe(1);
+      expect(normalizePercent(5)).toBe(5);
+      expect(normalizePercent(100)).toBe(100);
+    });
+
+    it('should accept zero', () => {
+      expect(normalizePercent(0)).toBe(0);
+    });
+
+    it('should accept string numbers', () => {
+      expect(normalizePercent('0.5')).toBe(0.5);
+      expect(normalizePercent('1')).toBe(1);
+      expect(normalizePercent('0')).toBe(0);
+    });
+
+    it('should reject negative numbers', () => {
+      expect(normalizePercent(-1)).toBeNull();
+      expect(normalizePercent(-0.5)).toBeNull();
+      expect(normalizePercent('-1')).toBeNull();
+    });
+
+    it('should reject invalid values', () => {
+      expect(normalizePercent(NaN)).toBeNull();
+      expect(normalizePercent(Infinity)).toBeNull();
+      expect(normalizePercent(-Infinity)).toBeNull();
+      expect(normalizePercent('abc')).toBeNull();
+      expect(normalizePercent(null)).toBeNull();
+      expect(normalizePercent(undefined)).toBeNull();
+    });
+  });
+
+  describe('calcMinRateFromPercent', () => {
+    const calcMinRateFromPercent = (percent: number, currentRate: string): string => {
+      const rateNum = Number(currentRate);
+      if (!Number.isFinite(rateNum) || rateNum <= 0) {
+        return '0';
+      }
+      // min_acceptable_rate = current_rate / (1 + percent/100)
+      const minRate = rateNum / (1 + percent / 100);
+      return minRate.toFixed(8);
+    };
+
+    it('should calculate min rate correctly with 0.5% slippage', () => {
+      // If current rate is 100 and slippage is 0.5%, min rate = 100 / 1.005 = 99.502...
+      const result = calcMinRateFromPercent(0.5, '100');
+      expect(Number(result)).toBeCloseTo(99.5024876, 5);
+    });
+
+    it('should calculate min rate correctly with 1% slippage', () => {
+      // If current rate is 100 and slippage is 1%, min rate = 100 / 1.01 = 99.0099...
+      const result = calcMinRateFromPercent(1, '100');
+      expect(Number(result)).toBeCloseTo(99.00990099, 5);
+    });
+
+    it('should calculate min rate correctly with 5% slippage', () => {
+      // If current rate is 100 and slippage is 5%, min rate = 100 / 1.05 = 95.238...
+      const result = calcMinRateFromPercent(5, '100');
+      expect(Number(result)).toBeCloseTo(95.23809524, 5);
+    });
+
+    it('should handle zero percent (no slippage)', () => {
+      // If slippage is 0%, min rate equals current rate
+      const result = calcMinRateFromPercent(0, '100');
+      expect(Number(result)).toBe(100);
+    });
+
+    it('should return 0 for invalid rate', () => {
+      expect(calcMinRateFromPercent(0.5, '0')).toBe('0');
+      expect(calcMinRateFromPercent(0.5, '-100')).toBe('0');
+      expect(calcMinRateFromPercent(0.5, 'abc')).toBe('0');
+    });
+  });
+
+  describe('slippage config validation', () => {
+    describe('percent mode', () => {
+      it('should accept valid percent config', () => {
+        const rawConfig = {
+          mode: 'percent',
+          percent: 0.5,
+          base_currency: 'USD',
+        };
+
+        expect(rawConfig.mode).toBe('percent');
+        expect(rawConfig.percent).toBe(0.5);
+        expect(rawConfig.base_currency).toBe('USD');
+      });
+
+      it('should reject config with negative percent', () => {
+        const rawConfig = {
+          mode: 'percent',
+          percent: -1,
+        };
+
+        const normalizePercent = (value: any) => {
+          const normalized = typeof value === 'string' ? Number(value) : value;
+          if (!Number.isFinite(normalized) || normalized < 0) {
+            return null;
+          }
+          return normalized;
+        };
+
+        expect(normalizePercent(rawConfig.percent)).toBeNull();
+      });
+
+      it('should accept config with pre-calculated min_acceptable_rate', () => {
+        const rawConfig = {
+          mode: 'percent',
+          percent: 0.5,
+          min_acceptable_rate: '99.5024876',
+          base_currency: 'USD',
+        };
+
+        expect(rawConfig.min_acceptable_rate).toBe('99.5024876');
+      });
+    });
+
+    describe('rate mode', () => {
+      it('should require min_acceptable_rate for rate mode', () => {
+        const rawConfig: { mode: string; percent: number; min_acceptable_rate?: string } = {
+          mode: 'rate',
+          percent: 0,
+          // missing min_acceptable_rate
+        };
+
+        const minRate = rawConfig.min_acceptable_rate ?? (rawConfig as any).minAcceptableRate;
+        expect(minRate === undefined || minRate === null || minRate === '').toBe(true);
+      });
+
+      it('should accept valid rate config', () => {
+        const rawConfig = {
+          mode: 'rate',
+          percent: 0.5,
+          min_acceptable_rate: '95.5',
+          base_currency: 'USD',
+        };
+
+        expect(rawConfig.mode).toBe('rate');
+        expect(rawConfig.min_acceptable_rate).toBe('95.5');
+      });
+    });
+
+    describe('legacy slippage_percent support', () => {
+      it('should accept simple slippage_percent', () => {
+        const reqBody = {
+          slippage_percent: 0.5,
+        };
+
+        const normalizePercent = (value: any) => {
+          const normalized = typeof value === 'string' ? Number(value) : value;
+          if (!Number.isFinite(normalized) || normalized < 0) {
+            return null;
+          }
+          return normalized;
+        };
+
+        expect(normalizePercent(reqBody.slippage_percent)).toBe(0.5);
+      });
+
+      it('should reject invalid slippage_percent', () => {
+        const reqBody = {
+          slippage_percent: 'invalid',
+        };
+
+        const normalizePercent = (value: any) => {
+          const normalized = typeof value === 'string' ? Number(value) : value;
+          if (!Number.isFinite(normalized) || normalized < 0) {
+            return null;
+          }
+          return normalized;
+        };
+
+        expect(normalizePercent(reqBody.slippage_percent)).toBeNull();
+      });
+    });
+  });
+
+  describe('config building', () => {
+    it('should build percent mode config with timestamp', () => {
+      const now = Date.now();
+      const config = {
+        mode: 'percent',
+        percent: 0.5,
+        base_currency: 'USD',
+        min_acceptable_rate: '99.5',
+        updated_at_ms: now,
+      };
+
+      expect(config.mode).toBe('percent');
+      expect(config.percent).toBe(0.5);
+      expect(config.updated_at_ms).toBe(now);
+    });
+
+    it('should build rate mode config with all fields', () => {
+      const now = Date.now();
+      const config = {
+        mode: 'rate',
+        percent: 0,
+        min_acceptable_rate: '95.0',
+        base_currency: 'USD',
+        rate_at_config_time: '100.0',
+        updated_at_ms: now,
+      };
+
+      expect(config.mode).toBe('rate');
+      expect(config.min_acceptable_rate).toBe('95.0');
+      expect(config.rate_at_config_time).toBe('100.0');
+    });
+  });
+
+  describe('error scenarios', () => {
+    it('should return error when no config provided', () => {
+      const rawConfig = null;
+      const slippagePercent = undefined;
+
+      const hasConfig = rawConfig && typeof rawConfig === 'object';
+      const hasPercent = slippagePercent !== undefined && slippagePercent !== null;
+
+      expect(hasConfig || hasPercent).toBe(false);
+      // In actual endpoint: return 400 with error 'slippage config is required'
+    });
+
+    it('should return error for rate mode without min_acceptable_rate', () => {
+      const rawConfig: { mode: string; percent: number; min_acceptable_rate?: string } = {
+        mode: 'rate',
+        percent: 0,
+      };
+
+      const minRate = rawConfig.min_acceptable_rate ?? (rawConfig as any).minAcceptableRate;
+      const isInvalid = minRate === undefined || minRate === null || minRate === '';
+
+      expect(isInvalid).toBe(true);
+      // In actual endpoint: return 400 with error 'min_acceptable_rate is required for rate mode'
+    });
+  });
+});

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.24.4",
+  "version": "1.25.1",
   "scripts": {
     "dev": "blocklet dev --open",
     "prelint": "npm run types",
@@ -59,9 +59,9 @@
     "@blocklet/error": "^0.3.5",
     "@blocklet/js-sdk": "^1.17.8-beta-20260104-120132-cb5b1914",
     "@blocklet/logger": "^1.17.8-beta-20260104-120132-cb5b1914",
-    "@blocklet/payment-broker-client": "1.24.4",
-    "@blocklet/payment-react": "1.24.4",
-    "@blocklet/payment-vendor": "1.24.4",
+    "@blocklet/payment-broker-client": "1.25.1",
+    "@blocklet/payment-react": "1.25.1",
+    "@blocklet/payment-vendor": "1.25.1",
     "@blocklet/sdk": "^1.17.8-beta-20260104-120132-cb5b1914",
     "@blocklet/ui-react": "^3.4.7",
     "@blocklet/uploader": "^0.3.19",
@@ -79,6 +79,7 @@
     "@stripe/stripe-js": "^2.4.0",
     "ahooks": "^3.8.5",
     "axios": "^1.10.0",
+    "bignumber.js": "^9.3.1",
     "body-parser": "^1.20.3",
     "cls-hooked": "^4.2.2",
     "cookie-parser": "^1.4.7",
@@ -131,7 +132,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.17.8-beta-20260104-120132-cb5b1914",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.24.4",
+    "@blocklet/payment-types": "1.25.1",
     "@types/cookie-parser": "^1.4.9",
     "@types/cors": "^2.8.19",
     "@types/debug": "^4.1.12",
@@ -178,5 +179,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "d4a5f67e657cafa8862912bb8de38a3d56a7919d"
+  "gitHead": "87555132c62024e5c677fd0a39df0d90be06a543"
 }

package/src/components/customer/credit-overview.tsx

@@ -79,6 +79,20 @@ export default function CreditOverview({ customerId, settings, mode = 'portal' }
     }
   }, [searchParams]);
 
+  // Handle auto-recharge action from notification deep link
+  useEffect(() => {
+    const action = searchParams.get('action');
+    const currencyId = searchParams.get('currencyId');
+    if (action === 'auto-recharge' && currencyId) {
+      setAutoRecharge({ currencyId, open: true });
+      // Clean up query params after opening modal
+      const newParams = new URLSearchParams(searchParams);
+      newParams.delete('action');
+      newParams.delete('currencyId');
+      setSearchParams(newParams, { replace: true });
+    }
+  }, [searchParams, setSearchParams]);
+
   const creditCurrencies = useMemo(() => {
     return (
       settings?.paymentMethods

package/src/components/discount/discount-info.tsx

@@ -66,11 +66,17 @@ export default function DiscountInfo({ discountStats = null }: DiscountInfoProps
     return t(`admin.coupon.couponTermsDuration.${coupon.duration}`);
   };
 
-  // Format total savings
+  // Format total savings with proper decimal precision
   const totalSavingsEntries = Object.entries(discountStats.total_savings);
   const savingsText =
     totalSavingsEntries.length > 0
-      ? totalSavingsEntries.map(([, savings]) => savings.formattedAmount).join(', ')
+      ? totalSavingsEntries
+          .map(([, savings]) => {
+            // Use formatAmount to properly format with decimal precision
+            const formatted = formatAmount(savings.amount, savings.currency?.decimal || 18);
+            return `${formatted} ${savings.currency?.symbol || ''}`;
+          })
+          .join(', ')
       : '--';
 
   // Get validity period