@lombard.finance/sdk 3.7.4 → 4.0.0

package/src/__tests__/unit/btc/ExistingSignatureHandling.test.ts

@@ -0,0 +1,301 @@
+/**
+ * Existing Signature Handling Tests
+ *
+ * Tests for Bug #3 (BTC Stake active signature error) and
+ * Bug #7 (Stake & Bake signature check).
+ *
+ * These tests verify the SDK handles existing deposits/signatures gracefully:
+ * 1. Resuming from existing deposit addresses
+ * 2. Handling API errors for duplicate signatures
+ * 3. Proper error messages for users
+ *
+ * @module __tests__/unit/btc/ExistingSignatureHandling.test.ts
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { BaseBtcAction, type StatusConfig, type StepDefinition } from '../../../chains/btc/actions/shared/BaseBtcAction';
+import { PartnerConfiguration } from '../../../client/PartnerConfiguration';
+import { ChainId } from '../../../common/chains';
+import { Chain, Env, StepStatus } from '../../../core';
+import type { BtcCoreContext } from '../../../shared/context';
+import { evmAddressSchema } from '../../../shared/validation';
+
+// Mock context factory
+const createMockContext = (overrides: Partial<BtcCoreContext> = {}): BtcCoreContext => ({
+  env: Env.testnet,
+  btc: {} as BtcCoreContext['btc'],
+  api: {
+    generateDepositAddress: vi.fn().mockResolvedValue('tb1qexampleaddress'),
+    getDepositAddress: vi.fn().mockResolvedValue(null),
+    getFeeSignature: vi.fn(),
+    storeFeeSignature: vi.fn(),
+    getStakeAndBakeSignature: vi.fn(),
+    storeStakeAndBakeSignature: vi.fn(),
+    getDeposits: vi.fn(),
+  } as BtcCoreContext['api'],
+  partner: new PartnerConfiguration({ partnerId: 'test-partner' }),
+  capabilities: {
+    require: vi.fn(),
+    get: vi.fn(),
+    services: new Map(),
+    registerModule: vi.fn(),
+    hasModule: vi.fn().mockReturnValue(true),
+    modules: [],
+    shared: [],
+    config: {},
+    optional: [],
+    createContext: vi.fn(),
+  } as unknown as BtcCoreContext['capabilities'],
+  getProvider: vi.fn().mockResolvedValue({
+    on: vi.fn(),
+    removeListener: vi.fn(),
+    request: vi.fn().mockResolvedValue('0x1'),
+  }),
+  ...overrides,
+});
+
+// Test implementation of BaseBtcAction
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Test mock with generic step definition
+class TestBtcAction extends BaseBtcAction<any, string, { destChain: Chain }> {
+  private chainId: ChainId = ChainId.sepolia;
+
+  constructor(ctx: BtcCoreContext, params: { destChain: Chain }, initialStatus: string = 'idle') {
+    super(ctx, params, initialStatus);
+  }
+
+  protected getAddressSchema() {
+    return evmAddressSchema;
+  }
+
+  protected getStatusConfig(): StatusConfig<string> {
+    return {
+      idle: 'idle',
+      ready: 'ready',
+      addressReady: 'address_ready',
+    };
+  }
+
+  protected getInitialSteps(): StepDefinition {
+    return {
+      created: StepStatus.IDLE,
+      verifying: StepStatus.IDLE,
+    };
+  }
+
+  protected isAuthorized(): boolean {
+    return true;
+  }
+
+  protected getChainId(): ChainId {
+    return this.chainId;
+  }
+
+  protected getDepositAddressParams() {
+    return {
+      address: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+      chainId: this.chainId,
+      signature: '0xsignature',
+      token: 'LBTC',
+      partnerId: 'test-partner',
+    };
+  }
+
+  protected getExpectedToken(): string {
+    return 'LBTC';
+  }
+
+  protected getAuthRequiredMessage(): string {
+    return 'Authorization required';
+  }
+
+  // Expose protected method for testing
+  public async testResumeFromExisting(recipient: string): Promise<boolean> {
+    return this.resumeFromExistingDeposit(recipient);
+  }
+
+  // Expose deposit address for assertions
+  public getDepositAddr(): string | undefined {
+    return this._depositAddress;
+  }
+}
+
+describe('Existing Signature/Deposit Handling (Bug #3 & #7)', () => {
+  let mockCtx: BtcCoreContext;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockCtx = createMockContext();
+  });
+
+  describe('Resume from existing deposit (Bug #3 - partial fix)', () => {
+    it('should resume when existing deposit address found', async () => {
+      // Mock API to return existing deposit address
+      const existingAddress = 'tb1qexistingdeposit';
+      mockCtx.api.getDepositAddress = vi.fn().mockResolvedValue(existingAddress);
+
+      const action = new TestBtcAction(mockCtx, { destChain: Chain.SEPOLIA }, 'idle');
+      const recipient = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0';
+
+      const resumed = await action.testResumeFromExisting(recipient);
+
+      expect(resumed).toBe(true);
+      expect(action.getDepositAddr()).toBe(existingAddress);
+      // Note: resumeFromExistingDeposit no longer updates status
+      // The caller (prepare()) is responsible for setting status after fee auth check
+      expect(action.status).toBe('idle');
+    });
+
+    it('should NOT resume when no existing deposit', async () => {
+      // Mock API to return null (no existing deposit)
+      mockCtx.api.getDepositAddress = vi.fn().mockResolvedValue(null);
+
+      const action = new TestBtcAction(mockCtx, { destChain: Chain.SEPOLIA }, 'idle');
+      const recipient = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0';
+
+      const resumed = await action.testResumeFromExisting(recipient);
+
+      expect(resumed).toBe(false);
+      expect(action.getDepositAddr()).toBeUndefined();
+      expect(action.status).toBe('idle'); // Status unchanged
+    });
+
+    it('should NOT resume when API throws error', async () => {
+      // Mock API to throw (e.g., network error)
+      mockCtx.api.getDepositAddress = vi.fn().mockRejectedValue(new Error('Network error'));
+
+      const action = new TestBtcAction(mockCtx, { destChain: Chain.SEPOLIA }, 'idle');
+      const recipient = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0';
+
+      const resumed = await action.testResumeFromExisting(recipient);
+
+      expect(resumed).toBe(false);
+      expect(action.status).toBe('idle'); // Status unchanged, error swallowed
+    });
+
+    it('should call API with correct parameters', async () => {
+      mockCtx.api.getDepositAddress = vi.fn().mockResolvedValue(null);
+
+      const action = new TestBtcAction(mockCtx, { destChain: Chain.SEPOLIA }, 'idle');
+      const recipient = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0';
+
+      await action.testResumeFromExisting(recipient);
+
+      expect(mockCtx.api.getDepositAddress).toHaveBeenCalledWith({
+        address: recipient,
+        chainId: 11155111, // Sepolia chain ID
+        token: 'LBTC',
+        partnerId: 'test-partner',
+      });
+    });
+  });
+
+  describe('API Error Messages (for user-facing errors)', () => {
+    /**
+     * These tests document expected API error messages that the SDK
+     * should handle gracefully or provide helpful error messages for.
+     */
+
+    it('should identify "active signature" errors', () => {
+      const errorPatterns = [
+        'active signature already exists for this user',
+        'signature already exists',
+        'existing stake found',
+        'pending stake already exists',
+      ];
+
+      // Helper to check if an error message matches expected patterns
+      const isActiveSignatureError = (message: string): boolean => {
+        const normalized = message.toLowerCase();
+        return errorPatterns.some(pattern => normalized.includes(pattern.toLowerCase()));
+      };
+
+      expect(isActiveSignatureError('Active signature already exists for this user')).toBe(true);
+      expect(isActiveSignatureError('Signature already exists for address 0x123')).toBe(true);
+      expect(isActiveSignatureError('Network timeout')).toBe(false);
+      expect(isActiveSignatureError('Invalid address')).toBe(false);
+    });
+
+    it('should provide enhanced error message for duplicate signature errors', () => {
+      // This tests the error enhancement logic that should be implemented
+      // in the SDK Demo or SDK itself
+      
+      const enhanceErrorMessage = (error: Error): string => {
+        const message = error.message.toLowerCase();
+        
+        if (message.includes('active signature') || message.includes('signature already exists')) {
+          return `You already have a pending stake. Please complete the existing flow using your deposit address, or wait for it to expire. You can check your pending stakes in the Deposit Addresses section.`;
+        }
+        
+        if (message.includes('stake and bake signature already exists')) {
+          return `You already have a pending stake-and-deploy signature. Please complete that flow first or wait for expiration.`;
+        }
+        
+        return error.message;
+      };
+
+      const originalError = new Error('Active signature already exists for this user');
+      const enhanced = enhanceErrorMessage(originalError);
+      
+      expect(enhanced).toContain('pending stake');
+      expect(enhanced).toContain('deposit address');
+    });
+  });
+
+  describe('Status transitions during resume', () => {
+    it('should NOT transition status when resuming (caller sets status after fee auth check)', async () => {
+      mockCtx.api.getDepositAddress = vi.fn().mockResolvedValue('tb1qexisting');
+
+      const action = new TestBtcAction(mockCtx, { destChain: Chain.SEPOLIA }, 'idle');
+      const statusHistory: string[] = [];
+      
+      action.on('status-change', (status: string) => {
+        statusHistory.push(status);
+      });
+
+      await action.testResumeFromExisting('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0');
+
+      // resumeFromExistingDeposit no longer emits status changes
+      // The caller (prepare()) sets status after validating fee auth
+      expect(statusHistory).not.toContain('address_ready');
+      expect(statusHistory).toHaveLength(0);
+    });
+
+    it('should NOT change status when no existing deposit', async () => {
+      mockCtx.api.getDepositAddress = vi.fn().mockResolvedValue(null);
+
+      const action = new TestBtcAction(mockCtx, { destChain: Chain.SEPOLIA }, 'idle');
+      const statusHistory: string[] = [];
+      
+      action.on('status-change', (status: string) => {
+        statusHistory.push(status);
+      });
+
+      await action.testResumeFromExisting('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0');
+
+      expect(statusHistory).toEqual([]); // No status changes
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle undefined/null address from API', async () => {
+      mockCtx.api.getDepositAddress = vi.fn().mockResolvedValue(undefined);
+
+      const action = new TestBtcAction(mockCtx, { destChain: Chain.SEPOLIA }, 'idle');
+      const resumed = await action.testResumeFromExisting('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0');
+
+      expect(resumed).toBe(false);
+    });
+
+    it('should handle empty string address from API', async () => {
+      mockCtx.api.getDepositAddress = vi.fn().mockResolvedValue('');
+
+      const action = new TestBtcAction(mockCtx, { destChain: Chain.SEPOLIA }, 'idle');
+      const resumed = await action.testResumeFromExisting('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0');
+
+      // Empty string is falsy, so should not resume
+      expect(resumed).toBe(false);
+    });
+  });
+});
+

package/src/__tests__/unit/btc/StakeAndBakeRatioConversion.test.ts

@@ -0,0 +1,200 @@
+/**
+ * Stake and Bake Ratio Conversion Tests
+ *
+ * Verifies that BtcStakeAndDeploy correctly passes 'BTC' as the token
+ * to trigger the btcToLbtc ratio conversion in signStakeAndBake.
+ *
+ * Bug Reference: APP-1993
+ * Problem: Signature contained raw BTC amount (20000) instead of
+ * ratio-adjusted LBTC amount (19947), causing backend to reject deposit.
+ *
+ * Root Cause: BtcStakeAndDeploy passed `token: AssetId.LBTC` instead of
+ * `token: 'BTC'`, which triggered 'identity' strategy instead of 'btcToLbtc'.
+ *
+ * @module __tests__/unit/btc/StakeAndBakeRatioConversion.test.ts
+ */
+
+import BigNumber from 'bignumber.js';
+import { afterEach,beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { DEFI_REGISTRY,DefiProtocol } from '../../../defi/defi-registry';
+import { Token } from '../../../tokens/token-addresses';
+
+// Mock the exchange ratio API
+vi.mock(
+  '../../../api-functions/getLBTCExchangeRate/get-exchange-ratio',
+  () => ({
+    getExchangeRatio: vi.fn().mockResolvedValue({
+      LBTC: {
+        tokenBTCRatio: new BigNumber('0.99736'),
+        BTCTokenRatio: new BigNumber('1.00265'),
+      },
+    }),
+  }),
+);
+
+describe('Stake and Bake Ratio Conversion', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('DEFI_REGISTRY Configuration', () => {
+    it('should have btcToLbtc strategy for BTC token in Veda protocol', () => {
+      // This ensures that when 'BTC' is passed as token, ratio conversion happens
+      const vedaRegistry = DEFI_REGISTRY[DefiProtocol.Veda];
+      expect(vedaRegistry).toBeDefined();
+
+      const btcStrategy = vedaRegistry['BTC'];
+      expect(btcStrategy).toBeDefined();
+      if (!btcStrategy) return;
+
+      // Check that at least one environment has btcToLbtc strategy
+      const envs = Object.values(btcStrategy);
+      const hasConversion = envs.some(envMap =>
+        envMap ? Object.values(envMap).some(
+          chainConfig => chainConfig?.amountStrategy === 'btcToLbtc',
+        ) : false,
+      );
+
+      expect(hasConversion).toBe(true);
+    });
+
+    it('should have identity strategy for LBTC token in Veda protocol', () => {
+      // This shows that passing LBTC as token does NOT trigger conversion
+      const vedaRegistry = DEFI_REGISTRY[DefiProtocol.Veda];
+      expect(vedaRegistry).toBeDefined();
+
+      const lbtcStrategy = vedaRegistry[Token.LBTC];
+      expect(lbtcStrategy).toBeDefined();
+      if (!lbtcStrategy) return;
+
+      // Check that LBTC uses identity strategy (no conversion)
+      const envs = Object.values(lbtcStrategy);
+      const hasIdentity = envs.some(envMap =>
+        envMap ? Object.values(envMap).some(
+          chainConfig => chainConfig?.amountStrategy === 'identity',
+        ) : false,
+      );
+
+      expect(hasIdentity).toBe(true);
+    });
+
+    it('should have identity strategy for BTCb token in Silo protocol', () => {
+      // BTCb in Silo uses identity - no conversion needed
+      const siloRegistry = DEFI_REGISTRY[DefiProtocol.Silo];
+      expect(siloRegistry).toBeDefined();
+
+      const btcbStrategy = siloRegistry[Token.BTCb];
+      expect(btcbStrategy).toBeDefined();
+      if (!btcbStrategy) return;
+
+      // Check that BTCb uses identity strategy
+      const envs = Object.values(btcbStrategy);
+      const hasIdentity = envs.some(envMap =>
+        envMap ? Object.values(envMap).some(
+          chainConfig => chainConfig?.amountStrategy === 'identity',
+        ) : false,
+      );
+
+      expect(hasIdentity).toBe(true);
+    });
+  });
+
+  describe('Ratio Conversion Logic', () => {
+    it('should calculate correct LBTC amount from BTC using ratio', async () => {
+      // Import the actual function to test the conversion logic
+      const { calculateStakeAndBakeLBTCAmount } = await import(
+        '../../../contract-functions/signStakeAndBake/utils'
+      );
+
+      // Test with example values from the bug report:
+      // User sends 20000 satoshis, ratio is ~1.00265
+      // Expected LBTC amount: 20000 / 1.00265 ≈ 19947
+      const btcAmount = new BigNumber(20000); // satoshis
+      const result = await calculateStakeAndBakeLBTCAmount(btcAmount);
+
+      // The result should be less than the input (due to ratio > 1)
+      expect(result.isLessThan(btcAmount)).toBe(true);
+
+      // With ratio 1.00265, 20000 / 1.00265 ≈ 19947.12
+      // Allow for small precision differences
+      expect(result.toFixed(0)).toBe('19947');
+    });
+
+    it('should return same amount when ratio is 1', async () => {
+      // Reset the mock to return ratio of 1
+      const { getExchangeRatio } = await import(
+        '../../../api-functions/getLBTCExchangeRate/get-exchange-ratio'
+      );
+      vi.mocked(getExchangeRatio).mockResolvedValueOnce({
+        LBTC: {
+          tokenBTCRatio: new BigNumber(1),
+          BTCTokenRatio: new BigNumber(1),
+        },
+      });
+
+      const { calculateStakeAndBakeLBTCAmount } = await import(
+        '../../../contract-functions/signStakeAndBake/utils'
+      );
+
+      const btcAmount = new BigNumber(20000);
+      const result = await calculateStakeAndBakeLBTCAmount(btcAmount);
+
+      expect(result.isEqualTo(btcAmount)).toBe(true);
+    });
+  });
+
+  describe('Token Parameter Selection', () => {
+    it('BtcStakeAndDeploy should use BTC token for authorizeStakeAndBake', () => {
+      /**
+       * This test documents the expected behavior:
+       *
+       * BtcStakeAndDeploy.authorizeDeposit() should call:
+       *   authorizeStakeAndBake({ ..., token: 'BTC' })
+       *
+       * NOT:
+       *   authorizeStakeAndBake({ ..., token: AssetId.LBTC })
+       *
+       * The 'BTC' token triggers 'btcToLbtc' amountStrategy which applies
+       * the ratio conversion before signing.
+       *
+       * This is critical because the backend expects the signature to contain
+       * the ratio-adjusted LBTC amount, not the raw BTC amount.
+       */
+
+      // Verify the registry is configured correctly for this use case
+      const vedaBtcConfig = DEFI_REGISTRY[DefiProtocol.Veda]?.['BTC'];
+      expect(vedaBtcConfig).toBeDefined();
+
+      // The fix ensures BtcStakeAndDeploy passes 'BTC' which hits this config
+      if (!vedaBtcConfig) return;
+      const firstEnv = Object.values(vedaBtcConfig)[0];
+      if (!firstEnv) return;
+      const firstChain = Object.values(firstEnv)[0];
+
+      expect(firstChain?.amountStrategy).toBe('btcToLbtc');
+    });
+
+    it('BtcDepositAndDeploy should use BTCb token (no conversion)', () => {
+      /**
+       * BtcDepositAndDeploy correctly uses Token.BTCb which has 'identity'
+       * strategy - no ratio conversion is needed for BTC.b deposits.
+       *
+       * This is correct because 1 BTC = 1 BTC.b (no exchange rate).
+       */
+      const siloBtcbConfig = DEFI_REGISTRY[DefiProtocol.Silo]?.[Token.BTCb];
+      expect(siloBtcbConfig).toBeDefined();
+      if (!siloBtcbConfig) return;
+
+      const firstEnv = Object.values(siloBtcbConfig)[0];
+      if (!firstEnv) return;
+      const firstChain = Object.values(firstEnv)[0];
+
+      expect(firstChain?.amountStrategy).toBe('identity');
+    });
+  });
+});