payment-kit 1.24.4 → 1.25.1

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

@@ -0,0 +1,109 @@
+import {
+  buildSlippageSnapshot,
+  DEFAULT_SLIPPAGE_PERCENT,
+  isRateBelowMinAcceptableRate,
+  normalizeSlippageConfigFromMetadata,
+  resolveSlippagePercent,
+} from '../../src/libs/slippage';
+
+describe('libs/slippage', () => {
+  describe('normalizeSlippageConfigFromMetadata', () => {
+    it('returns null when no slippage metadata is present', () => {
+      expect(normalizeSlippageConfigFromMetadata(null)).toBeNull();
+      expect(normalizeSlippageConfigFromMetadata(undefined)).toBeNull();
+      expect(normalizeSlippageConfigFromMetadata({})).toBeNull();
+    });
+
+    it('normalizes percent mode with fallback percent', () => {
+      const result = normalizeSlippageConfigFromMetadata({
+        slippage: {
+          mode: 'percent',
+          percent: 'invalid',
+        },
+      });
+
+      expect(result).not.toBeNull();
+      expect(result?.mode).toBe('percent');
+      expect(result?.percent).toBe(DEFAULT_SLIPPAGE_PERCENT);
+    });
+
+    it('preserves rate mode config fields', () => {
+      const result = normalizeSlippageConfigFromMetadata({
+        slippage: {
+          mode: 'rate',
+          percent: '1.25',
+          min_acceptable_rate: '0.9',
+          base_currency: 'USD',
+          updated_at_ms: 123,
+        },
+      });
+
+      expect(result).toEqual({
+        mode: 'rate',
+        percent: 1.25,
+        min_acceptable_rate: '0.9',
+        base_currency: 'USD',
+        updated_at_ms: 123,
+      });
+    });
+  });
+
+  describe('resolveSlippagePercent', () => {
+    it('prefers quote slippage percent over session metadata', () => {
+      const quote = { slippage_percent: 2 };
+      const session = { metadata: { slippage: { percent: 0.5 } }, slippage_percent: 1 };
+
+      expect(resolveSlippagePercent(quote, session)).toBe(2);
+    });
+
+    it('falls back to session metadata when quote is missing', () => {
+      const quote = { metadata: {} };
+      const session = { metadata: { slippage: { percent: 1.1 } } };
+
+      expect(resolveSlippagePercent(quote, session)).toBe(1.1);
+    });
+
+    it('falls back to default when values are invalid', () => {
+      const quote = { slippage_percent: -1 };
+
+      expect(resolveSlippagePercent(quote, undefined)).toBe(DEFAULT_SLIPPAGE_PERCENT);
+    });
+  });
+
+  describe('buildSlippageSnapshot', () => {
+    it('derives max_payable_token and min_acceptable_rate from percent', () => {
+      const snapshot = buildSlippageSnapshot({
+        quote: {
+          quoted_amount: '1000',
+          exchange_rate: '100',
+          slippage_percent: 25,
+        },
+        checkoutSession: { metadata: {} },
+        nowMs: 456,
+      });
+
+      expect(snapshot).toEqual({
+        percent: 25,
+        max_payable_token: '1250',
+        min_acceptable_rate: '80',
+        derived_at_ms: 456,
+      });
+    });
+  });
+
+  describe('isRateBelowMinAcceptableRate', () => {
+    it('returns true when current rate is below min acceptable rate', () => {
+      expect(isRateBelowMinAcceptableRate('0.9', '1')).toBe(true);
+    });
+
+    it('returns false when current rate is above or equal to min acceptable rate', () => {
+      expect(isRateBelowMinAcceptableRate('1', '1')).toBe(false);
+      expect(isRateBelowMinAcceptableRate('1.1', '1')).toBe(false);
+    });
+
+    it('returns false for invalid inputs', () => {
+      expect(isRateBelowMinAcceptableRate('abc', '1')).toBe(false);
+      expect(isRateBelowMinAcceptableRate('1', 'xyz')).toBe(false);
+    });
+  });
+});

package/api/tests/libs/token-data-provider.spec.ts

@@ -0,0 +1,267 @@
+import axios from 'axios';
+import { TokenDataProvider } from '../../src/libs/exchange-rate/token-data-provider';
+
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+// Mock the token-address-mapping module
+jest.mock('../../src/libs/exchange-rate/token-address-mapping', () => ({
+  getTokenInfo: jest.fn((symbol: string) => {
+    const symbolUpper = symbol.toUpperCase();
+    const mapping: Record<string, any> = {
+      ABT: {
+        symbol: 'ABT',
+        address: '0xB98d4C97425d9908E66E53A6fDf673ACcA0BE986',
+        name: 'ArcBlock Token',
+        decimals: 18,
+      },
+      ETH: {
+        symbol: 'ETH',
+        address: '0x0000000000000000000000000000000000000000',
+        name: 'Ethereum',
+        decimals: 18,
+      },
+    };
+    return mapping[symbolUpper];
+  }),
+}));
+
+describe('TokenDataProvider', () => {
+  let provider: TokenDataProvider;
+
+  beforeEach(() => {
+    provider = new TokenDataProvider();
+    jest.clearAllMocks();
+  });
+
+  describe('fetch', () => {
+    it('should fetch exchange rate successfully', async () => {
+      const mockResponse = {
+        data: {
+          data: [
+            {
+              symbol: 'ABT',
+              name: 'ArcBlock Token',
+              price: {
+                USD: 0.15,
+              },
+              updatedAt: '2024-01-01T00:00:00Z',
+            },
+          ],
+          total: 1,
+          page: 1,
+          size: 10,
+        },
+      };
+
+      mockedAxios.get.mockResolvedValue(mockResponse);
+
+      const result = await provider.fetch('ABT');
+
+      expect(result.rate).toBe('0.15');
+      expect(result.timestamp_ms).toBeGreaterThan(0);
+      expect(result.metadata?.source).toBe('token-data');
+      expect(mockedAxios.get).toHaveBeenCalledWith(
+        'https://token-data.arcblock.io/api/token-price-by-address',
+        expect.objectContaining({
+          params: {
+            addresses: '0xb98d4c97425d9908e66e53a6fdf673acca0be986',
+          },
+          timeout: 10000,
+        })
+      );
+    });
+
+    it('should handle alternative response format with symbol endpoint', async () => {
+      // ETH has zero address, so it should use symbol endpoint
+      const mockResponse = {
+        data: {
+          data: [
+            {
+              symbol: 'ETH',
+              name: 'Ethereum',
+              price: {
+                USD: 2000.5,
+              },
+              updatedAt: '2024-01-01T00:00:00Z',
+            },
+          ],
+          total: 1,
+          page: 1,
+          size: 10,
+        },
+      };
+
+      mockedAxios.get.mockResolvedValue(mockResponse);
+
+      const result = await provider.fetch('ETH');
+
+      expect(result.rate).toBe('2000.5');
+      expect(result.timestamp_ms).toBeGreaterThan(0);
+      expect(mockedAxios.get).toHaveBeenCalledWith(
+        'https://token-data.arcblock.io/api/token-price-by-symbol',
+        expect.objectContaining({
+          params: {
+            symbols: 'ETH',
+          },
+        })
+      );
+    });
+
+    it('should throw error for invalid price', async () => {
+      const mockResponse = {
+        data: {
+          data: [
+            {
+              symbol: 'ABT',
+              price: {
+                USD: -1,
+              },
+            },
+          ],
+        },
+      };
+
+      mockedAxios.get.mockResolvedValue(mockResponse);
+
+      await expect(provider.fetch('ABT')).rejects.toThrow('Invalid price value');
+    });
+
+    it('should throw error for missing USD price', async () => {
+      const mockResponse = {
+        data: {
+          data: [
+            {
+              symbol: 'ABT',
+              price: {},
+            },
+          ],
+        },
+      };
+
+      mockedAxios.get.mockResolvedValue(mockResponse);
+
+      await expect(provider.fetch('ABT')).rejects.toThrow('No valid USD price found');
+    });
+
+    it('should throw error for zero price', async () => {
+      const mockResponse = {
+        data: {
+          data: [
+            {
+              symbol: 'ABT',
+              price: {
+                USD: 0,
+              },
+            },
+          ],
+        },
+      };
+
+      mockedAxios.get.mockResolvedValue(mockResponse);
+
+      // Zero is falsy, so it gets caught by the !usdPrice check first
+      await expect(provider.fetch('ABT')).rejects.toThrow('No valid USD price found');
+    });
+
+    it('should throw error for empty data array', async () => {
+      const mockResponse = {
+        data: {
+          data: [],
+          total: 0,
+        },
+      };
+
+      mockedAxios.get.mockResolvedValue(mockResponse);
+
+      await expect(provider.fetch('ABT')).rejects.toThrow('No token data found for ABT');
+    });
+
+    it('should throw SymbolNotSupportedError for unknown token', async () => {
+      // Re-mock getTokenInfo to return undefined for UNKNOWN
+      const { getTokenInfo } = jest.requireMock('../../src/libs/exchange-rate/token-address-mapping');
+      getTokenInfo.mockReturnValueOnce(undefined);
+
+      await expect(provider.fetch('UNKNOWN')).rejects.toThrow('Symbol UNKNOWN is not supported by token-data');
+    });
+
+    it('should handle 500 server error', async () => {
+      mockedAxios.get.mockRejectedValue({
+        response: { status: 500 },
+      });
+
+      await expect(provider.fetch('ABT')).rejects.toThrow('token-data server error: 500');
+    });
+
+    it('should handle timeout error', async () => {
+      mockedAxios.get.mockRejectedValue({
+        code: 'ECONNABORTED',
+        message: 'timeout',
+      });
+
+      await expect(provider.fetch('ABT')).rejects.toThrow('token-data request timeout after 10000ms');
+    });
+
+    it('should handle connection error', async () => {
+      mockedAxios.get.mockRejectedValue({
+        code: 'ECONNREFUSED',
+        message: 'Connection refused',
+      });
+
+      await expect(provider.fetch('ABT')).rejects.toThrow('Cannot connect to token-data');
+    });
+
+    it('should use custom base URL from config', async () => {
+      const customProvider = new TokenDataProvider({
+        base_url: 'https://custom.example.com',
+      });
+
+      const mockResponse = {
+        data: {
+          data: [
+            {
+              symbol: 'ABT',
+              price: {
+                USD: 0.15,
+              },
+            },
+          ],
+        },
+      };
+
+      mockedAxios.get.mockResolvedValue(mockResponse);
+
+      await customProvider.fetch('ABT');
+
+      expect(mockedAxios.get).toHaveBeenCalledWith(
+        'https://custom.example.com/api/token-price-by-address',
+        expect.anything()
+      );
+    });
+
+    it('should convert symbol to uppercase in token lookup', async () => {
+      const mockResponse = {
+        data: {
+          data: [
+            {
+              symbol: 'ABT',
+              price: {
+                USD: 0.15,
+              },
+            },
+          ],
+        },
+      };
+
+      mockedAxios.get.mockResolvedValue(mockResponse);
+
+      await provider.fetch('abt');
+
+      // The getTokenInfo mock is called with 'abt', but it handles uppercase internally
+      expect(mockedAxios.get).toHaveBeenCalledWith(
+        expect.stringContaining('token-price-by-address'),
+        expect.anything()
+      );
+    });
+  });
+});

package/api/tests/models/exchange-rate-provider.spec.ts

@@ -0,0 +1,121 @@
+import { ExchangeRateProvider } from '../../src/store/models/exchange-rate-provider';
+
+describe('ExchangeRateProvider Model', () => {
+  describe('recordSuccess logic', () => {
+    it('should reset failure count and update status to ok', () => {
+      // Test the logic for recordSuccess
+      const updates = {
+        last_success_at: expect.any(Date),
+        failure_count: 0,
+        status: 'ok',
+      };
+
+      expect(updates.failure_count).toBe(0);
+      expect(updates.status).toBe('ok');
+    });
+  });
+
+  describe('recordFailure logic', () => {
+    it('should increment failure count and set status to degraded', () => {
+      const currentFailureCount = 0;
+      const newFailureCount = currentFailureCount + 1;
+
+      const updates: any = {
+        last_failure_at: new Date(),
+        failure_count: newFailureCount,
+      };
+
+      // Auto-pause after 5 consecutive failures
+      if (newFailureCount >= 5) {
+        updates.status = 'paused';
+        updates.paused_reason = 'Test error';
+      } else {
+        updates.status = 'degraded';
+      }
+
+      expect(updates.failure_count).toBe(1);
+      expect(updates.status).toBe('degraded');
+    });
+
+    it('should set status to paused after 5 consecutive failures', () => {
+      const currentFailureCount = 4;
+      const newFailureCount = currentFailureCount + 1;
+      const reason = 'Test error';
+
+      const updates: any = {
+        last_failure_at: new Date(),
+        failure_count: newFailureCount,
+      };
+
+      if (newFailureCount >= 5) {
+        updates.status = 'paused';
+        updates.paused_reason = reason || 'Too many consecutive failures';
+      } else {
+        updates.status = 'degraded';
+      }
+
+      expect(updates.failure_count).toBe(5);
+      expect(updates.status).toBe('paused');
+      expect(updates.paused_reason).toBe('Test error');
+    });
+
+    it('should use default reason if none provided', () => {
+      const currentFailureCount = 4;
+      const newFailureCount = currentFailureCount + 1;
+      const reason = undefined;
+
+      const updates: any = {
+        last_failure_at: new Date(),
+        failure_count: newFailureCount,
+      };
+
+      if (newFailureCount >= 5) {
+        updates.status = 'paused';
+        updates.paused_reason = reason || 'Too many consecutive failures';
+      } else {
+        updates.status = 'degraded';
+      }
+
+      expect(updates.paused_reason).toBe('Too many consecutive failures');
+    });
+
+    it('should not pause before reaching 5 failures', () => {
+      const currentFailureCount = 3;
+      const newFailureCount = currentFailureCount + 1;
+
+      const updates: any = {
+        last_failure_at: new Date(),
+        failure_count: newFailureCount,
+      };
+
+      if (newFailureCount >= 5) {
+        updates.status = 'paused';
+        updates.paused_reason = 'Test error';
+      } else {
+        updates.status = 'degraded';
+      }
+
+      expect(updates.failure_count).toBe(4);
+      expect(updates.status).toBe('degraded');
+    });
+  });
+
+  describe('Status values', () => {
+    it('should have valid status enum values', () => {
+      const validStatuses = ['ok', 'degraded', 'paused', 'down'];
+
+      validStatuses.forEach((status) => {
+        expect(validStatuses).toContain(status);
+      });
+    });
+  });
+
+  describe('Provider priority', () => {
+    it('should support priority ordering', () => {
+      const provider1 = { priority: 1 } as ExchangeRateProvider;
+      const provider2 = { priority: 2 } as ExchangeRateProvider;
+
+      expect(provider1.priority).toBeLessThan(provider2.priority);
+    });
+  });
+});

package/api/tests/models/price-dynamic.spec.ts

@@ -0,0 +1,100 @@
+import { Price } from '../../src/store/models/price';
+
+describe('Price Model - Dynamic Pricing', () => {
+  describe('formatBeforeSave - Dynamic Pricing Validation', () => {
+    it('should validate dynamic pricing requires base_currency and base_amount', () => {
+      const price = {
+        pricing_type: 'dynamic' as const,
+        // Missing base_currency and base_amount
+      };
+
+      expect(() => Price.formatBeforeSave(price)).toThrow(
+        'base_currency and base_amount are required for dynamic pricing'
+      );
+    });
+
+    it('should validate only USD is supported as base_currency', () => {
+      const price = {
+        pricing_type: 'dynamic' as const,
+        base_currency: 'EUR',
+        base_amount: '100',
+      };
+
+      expect(() => Price.formatBeforeSave(price)).toThrow('Only USD is supported as base_currency');
+    });
+
+    it('should accept valid dynamic pricing with USD', () => {
+      const price = {
+        pricing_type: 'dynamic' as const,
+        base_currency: 'USD',
+        base_amount: '100',
+      };
+
+      const result = Price.formatBeforeSave(price);
+
+      expect(result.pricing_type).toBe('dynamic');
+      expect(result.base_currency).toBe('USD');
+      expect(result.base_amount).toBe('100');
+    });
+
+    it('should set default lock_duration if not provided', () => {
+      const price = {
+        pricing_type: 'dynamic' as const,
+        base_currency: 'USD',
+        base_amount: '100',
+      };
+
+      const result = Price.formatBeforeSave(price);
+
+      expect(result.dynamic_pricing_config).toEqual({ lock_duration: 30 });
+    });
+
+    it('should preserve custom lock_duration if provided', () => {
+      const price = {
+        pricing_type: 'dynamic' as const,
+        base_currency: 'USD',
+        base_amount: '100',
+        dynamic_pricing_config: { lock_duration: 600 },
+      };
+
+      const result = Price.formatBeforeSave(price);
+
+      expect(result.dynamic_pricing_config).toEqual({ lock_duration: 600 });
+    });
+
+    it('should clear dynamic pricing fields for fixed prices', () => {
+      const price = {
+        pricing_type: 'fixed' as const,
+        base_currency: 'USD',
+        base_amount: '100',
+        dynamic_pricing_config: { lock_duration: 300 },
+      };
+
+      const result = Price.formatBeforeSave(price);
+
+      expect(result.pricing_type).toBe('fixed');
+      expect(result.base_currency).toBeNull();
+      expect(result.base_amount).toBeNull();
+      expect(result.dynamic_pricing_config).toBeNull();
+    });
+
+    it('should not modify other price properties', () => {
+      const price = {
+        pricing_type: 'dynamic' as const,
+        base_currency: 'USD',
+        base_amount: '100',
+        type: 'one_time' as const,
+        billing_scheme: 'per_unit' as const,
+        unit_amount: '500',
+        metadata: { key: 'value' },
+      };
+
+      const result = Price.formatBeforeSave(price);
+
+      expect(result.type).toBe('one_time');
+      expect(result.billing_scheme).toBe('per_unit');
+      expect(result.unit_amount).toBe('500');
+      expect(result.metadata).toEqual({ key: 'value' });
+    });
+  });
+});

package/api/tests/models/price-quote.spec.ts

@@ -0,0 +1,112 @@
+// import { PriceQuote } from '../../src/store/models/price-quote';
+
+describe('PriceQuote Model', () => {
+  describe('isExpired logic', () => {
+    it('should return true if quote is expired', () => {
+      const now = Math.floor(Date.now() / 1000);
+      const expiresAt = now - 100; // Expired 100 seconds ago
+
+      // Test the logic directly
+      const isExpired = expiresAt < Math.floor(Date.now() / 1000);
+      expect(isExpired).toBe(true);
+    });
+
+    it('should return false if quote is not expired', () => {
+      const now = Math.floor(Date.now() / 1000);
+      const expiresAt = now + 100; // Expires in 100 seconds
+
+      // Test the logic directly
+      const isExpired = expiresAt < Math.floor(Date.now() / 1000);
+      expect(isExpired).toBe(false);
+    });
+
+    it('should handle edge case at expiration time', () => {
+      const now = Math.floor(Date.now() / 1000);
+      const expiresAt = now;
+
+      // At expiration time, should be considered expired
+      const isExpired = expiresAt < Math.floor(Date.now() / 1000);
+      expect(typeof isExpired).toBe('boolean');
+    });
+  });
+
+  describe('isActive logic', () => {
+    it('should return true if status is active and not expired', () => {
+      const now = Math.floor(Date.now() / 1000);
+      const status = 'active';
+      const expiresAt = now + 100;
+
+      const isActive = status === 'active' && expiresAt >= Math.floor(Date.now() / 1000);
+      expect(isActive).toBe(true);
+    });
+
+    it('should return false if status is not active', () => {
+      const now = Math.floor(Date.now() / 1000);
+      const status: string = 'used';
+      const expiresAt = now + 100;
+
+      const isActive = status === 'active' && expiresAt >= Math.floor(Date.now() / 1000);
+      expect(isActive).toBe(false);
+    });
+
+    it('should return false if quote is expired even if status is active', () => {
+      const now = Math.floor(Date.now() / 1000);
+      const status = 'active';
+      const expiresAt = now - 100;
+
+      const isActive = status === 'active' && expiresAt >= Math.floor(Date.now() / 1000);
+      expect(isActive).toBe(false);
+    });
+  });
+
+  describe('Quote Status Transitions', () => {
+    it('should have valid quote status values', () => {
+      const validStatuses = ['active', 'used', 'paid', 'expired', 'cancelled', 'failed'];
+
+      validStatuses.forEach((status) => {
+        expect(validStatuses).toContain(status);
+      });
+    });
+  });
+
+  describe('Quote Metadata Structure', () => {
+    it('should have correct metadata structure', () => {
+      const metadata = {
+        calculation: {
+          token_amount_raw: '100.123456789',
+          unit_amount_raw: '100123456789000000000',
+        },
+        rounding: {
+          mode: 'ceil',
+          token_decimals: 18,
+        },
+        risk: {
+          anomaly_detected: false,
+          deviation_percent: 2.3,
+          degraded: false,
+          degraded_reason: null,
+        },
+        context: {
+          quantity: 1,
+          base_amount_per_unit: '10',
+        },
+      };
+
+      expect(metadata.calculation).toBeDefined();
+      expect(metadata.rounding).toBeDefined();
+      expect(metadata.risk).toBeDefined();
+      expect(metadata.context).toBeDefined();
+    });
+  });
+
+  describe('Quote Expiration Calculation', () => {
+    it('should correctly calculate expiration timestamp', () => {
+      const now = Math.floor(Date.now() / 1000);
+      const lockDuration = 300; // 5 minutes
+      const expiresAt = now + lockDuration;
+
+      expect(expiresAt).toBeGreaterThan(now);
+      expect(expiresAt - now).toBe(lockDuration);
+    });
+  });
+});