@lombard.finance/sdk 4.0.0 → 4.1.2

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

@@ -1,216 +0,0 @@
-/**
- * StakeAndBake Signature Restoration Tests
- *
- * Tests the logic for checking existing stake and bake signatures
- * before prompting the user to sign.
- *
- * Bug #7: Stake & Bake always asks user to sign even if valid signature exists
- *
- * @module __tests__/unit/btc/StakeAndBakeSignatureRestore.test.ts
- */
-
-import { describe, expect, it } from 'vitest';
-
-describe('StakeAndBake Signature Restoration Logic', () => {
-  describe('Expiration Check', () => {
-    it('should reject expired signatures', () => {
-      // Simulate expiration check logic from restoreStakeAndBakeSignature
-      const checkExpiration = (expirationDate: string): boolean => {
-        const expirationMs = Number(expirationDate) * 1000;
-        return expirationMs >= Date.now();
-      };
-
-      // Expired signature (1 hour ago)
-      const expiredTimestamp = String(Math.floor(Date.now() / 1000) - 3600);
-      expect(checkExpiration(expiredTimestamp)).toBe(false);
-
-      // Valid signature (expires in 24 hours)
-      const validTimestamp = String(Math.floor(Date.now() / 1000) + 86400);
-      expect(checkExpiration(validTimestamp)).toBe(true);
-
-      // Valid signature (expires in 1 minute)
-      const almostExpiredTimestamp = String(Math.floor(Date.now() / 1000) + 60);
-      expect(checkExpiration(almostExpiredTimestamp)).toBe(true);
-    });
-
-    it('should handle edge case of exactly now (within tolerance)', () => {
-      // Note: The actual implementation uses `< Date.now()` which means
-      // a signature expiring at the current second is considered expired.
-      // This is the safer behavior to avoid race conditions.
-      const checkExpiration = (expirationDate: string): boolean => {
-        const expirationMs = Number(expirationDate) * 1000;
-        return expirationMs >= Date.now();
-      };
-
-      // Edge case: expires 2 seconds from now (to avoid timing issues in test)
-      const soonTimestamp = String(Math.floor(Date.now() / 1000) + 2);
-      expect(checkExpiration(soonTimestamp)).toBe(true);
-
-      // Edge case: expired 2 seconds ago
-      const justExpiredTimestamp = String(Math.floor(Date.now() / 1000) - 2);
-      expect(checkExpiration(justExpiredTimestamp)).toBe(false);
-    });
-  });
-
-  describe('Signature Restoration Result Handling', () => {
-    interface StakeAndBakeRestoreResult {
-      hasSignature: boolean;
-      signature?: string;
-      depositAmount?: string;
-      expirationDate?: string;
-    }
-
-    const shouldSkipAuthorization = (
-      result: StakeAndBakeRestoreResult | null,
-    ): boolean => {
-      return result?.hasSignature === true;
-    };
-
-    it('should skip authorization when valid signature exists', () => {
-      const validResult: StakeAndBakeRestoreResult = {
-        hasSignature: true,
-        signature: '0xabc123',
-        depositAmount: '20000',
-        expirationDate: String(Math.floor(Date.now() / 1000) + 86400),
-      };
-
-      expect(shouldSkipAuthorization(validResult)).toBe(true);
-    });
-
-    it('should require authorization when result is null', () => {
-      expect(shouldSkipAuthorization(null)).toBe(false);
-    });
-
-    it('should require authorization when hasSignature is false', () => {
-      const noSignatureResult: StakeAndBakeRestoreResult = {
-        hasSignature: false,
-      };
-
-      expect(shouldSkipAuthorization(noSignatureResult)).toBe(false);
-    });
-
-    it('should skip authorization even if signature string is undefined (server has it)', () => {
-      // In some cases, the API may not return the actual signature string
-      // but still indicate that a valid signature exists
-      const hasSignatureNoString: StakeAndBakeRestoreResult = {
-        hasSignature: true,
-        depositAmount: '20000',
-        expirationDate: String(Math.floor(Date.now() / 1000) + 86400),
-      };
-
-      expect(shouldSkipAuthorization(hasSignatureNoString)).toBe(true);
-    });
-  });
-
-  describe('Status Flow Documentation', () => {
-    /**
-     * Documents the expected status transitions for BtcStakeAndDeploy.prepare()
-     *
-     * Scenario 1: No existing deposit, no existing signature
-     * IDLE → prepare() → NEEDS_DEPLOY_AUTHORIZATION
-     *
-     * Scenario 2: No existing deposit, valid signature exists
-     * IDLE → prepare() → READY (skip authorization)
-     *
-     * Scenario 3: Existing deposit, valid signature exists
-     * IDLE → prepare() → ADDRESS_READY (skip authorization)
-     *
-     * Scenario 4: Existing deposit, signature expired/missing
-     * IDLE → prepare() → NEEDS_DEPLOY_AUTHORIZATION (re-auth needed)
-     */
-
-    it('should document scenario 1: fresh start requires authorization', () => {
-      const hasDeposit = false;
-      const hasValidSignature = false;
-
-      const expectedStatus = !hasDeposit && !hasValidSignature
-        ? 'NEEDS_DEPLOY_AUTHORIZATION'
-        : 'READY';
-
-      expect(expectedStatus).toBe('NEEDS_DEPLOY_AUTHORIZATION');
-    });
-
-    it('should document scenario 2: existing signature skips to READY', () => {
-      const _hasDeposit = false; // Not used in this scenario - signature alone determines status
-      const hasValidSignature = true;
-
-      const expectedStatus = hasValidSignature ? 'READY' : 'NEEDS_DEPLOY_AUTHORIZATION';
-
-      expect(expectedStatus).toBe('READY');
-    });
-
-    it('should document scenario 3: existing deposit + signature → ADDRESS_READY', () => {
-      const hasDeposit = true;
-      const hasValidSignature = true;
-
-      const expectedStatus = hasDeposit && hasValidSignature
-        ? 'ADDRESS_READY'
-        : 'NEEDS_DEPLOY_AUTHORIZATION';
-
-      expect(expectedStatus).toBe('ADDRESS_READY');
-    });
-
-    it('should document scenario 4: deposit exists but signature expired → re-auth', () => {
-      const hasDeposit = true;
-      const hasValidSignature = false;
-
-      const expectedStatus = hasDeposit && !hasValidSignature
-        ? 'NEEDS_DEPLOY_AUTHORIZATION'
-        : 'ADDRESS_READY';
-
-      expect(expectedStatus).toBe('NEEDS_DEPLOY_AUTHORIZATION');
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should treat API errors as no-signature-found', async () => {
-      // Simulate the error handling in restoreStakeAndBakeSignature
-      const restoreWithErrorHandling = async (): Promise<null> => {
-        try {
-          throw new Error('Network error');
-        } catch {
-          return null;
-        }
-      };
-
-      const result = await restoreWithErrorHandling();
-      expect(result).toBeNull();
-    });
-  });
-});
-
-describe('getUserStakeAndBakeSignature API Response Parsing', () => {
-  interface ApiResponse {
-    user_destination_address: string;
-    signature: string;
-    expiration_date: string;
-    deposit_amount: string;
-    chain_id: string;
-  }
-
-  const parseApiResponse = (data: ApiResponse) => ({
-    userDestinationAddress: data.user_destination_address,
-    signature: data.signature,
-    expirationDate: data.expiration_date,
-    depositAmount: data.deposit_amount,
-    chainId: data.chain_id,
-  });
-
-  it('should correctly parse snake_case API response to camelCase', () => {
-    const apiResponse: ApiResponse = {
-      user_destination_address: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
-      signature: '0xabc123def456',
-      expiration_date: '1704067200', // Unix timestamp
-      deposit_amount: '20000',
-      chain_id: '1',
-    };
-
-    const parsed = parseApiResponse(apiResponse);
-
-    expect(parsed.userDestinationAddress).toBe('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0');
-    expect(parsed.signature).toBe('0xabc123def456');
-    expect(parsed.expirationDate).toBe('1704067200');
-    expect(parsed.depositAmount).toBe('20000');
-    expect(parsed.chainId).toBe('1');
-  });
-});

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

@@ -1,184 +0,0 @@
-/**
- * Token Parameter Consistency Tests
- *
- * Ensures all BTC actions pass the correct token parameter to their
- * authorization functions, which is critical for:
- * - Correct ratio conversion (BTC → LBTC)
- * - Correct signature storage (token address)
- * - Backend matching signatures to deposits
- *
- * This test file documents the expected token parameter for each action
- * to prevent regressions like APP-1993.
- *
- * @module __tests__/unit/btc/TokenParameterConsistency.test.ts
- */
-
-import { describe, expect, it } from 'vitest';
-
-import { DEFI_REGISTRY,DefiProtocol } from '../../../defi/defi-registry';
-import { Token } from '../../../tokens/token-addresses';
-
-describe('Token Parameter Consistency', () => {
-  /**
-   * This test suite documents and verifies the expected token parameters
-   * for each BTC action type.
-   *
-   * Token Parameter Mapping:
-   * ┌─────────────────────────┬────────────────┬─────────────────────┬─────────────────┐
-   * │ Action                  │ Source → Dest  │ Token Param         │ Amount Strategy │
-   * ├─────────────────────────┼────────────────┼─────────────────────┼─────────────────┤
-   * │ BtcStake                │ BTC → LBTC     │ Token.LBTC          │ N/A (fee only)  │
-   * │ BtcDeposit              │ BTC → BTC.b    │ Token.BTCb          │ N/A (fee only)  │
-   * │ BtcStakeAndDeploy       │ BTC → LBTC     │ 'BTC'               │ btcToLbtc       │
-   * │ BtcDepositAndDeploy     │ BTC → BTC.b    │ Token.BTCb          │ identity        │
-   * └─────────────────────────┴────────────────┴─────────────────────┴─────────────────┘
-   *
-   * Key Insight:
-   * - BtcStake and BtcDeposit use token for fee authorization (signNetworkFee)
-   * - BtcStakeAndDeploy and BtcDepositAndDeploy use token for vault permit (signStakeAndBake)
-   * - Only BtcStakeAndDeploy needs ratio conversion because it creates LBTC from BTC
-   */
-
-  describe('BtcStake Action', () => {
-    it('uses Token.LBTC for network fee authorization', () => {
-      /**
-       * BtcStake authorizes network fee using Token.LBTC.
-       * This is for the fee signature, not the deposit amount.
-       *
-       * Code location: packages/sdk/src/chains/btc/actions/stake/config/evm.ts
-       * Line: token: Token.LBTC
-       */
-      expect(Token.LBTC).toBe('LBTC');
-    });
-  });
-
-  describe('BtcDeposit Action', () => {
-    it('uses Token.BTCb for network fee authorization', () => {
-      /**
-       * BtcDeposit authorizes network fee using Token.BTCb.
-       * This distinguishes BTC.b fee signatures from LBTC fee signatures.
-       *
-       * Code location: packages/sdk/src/chains/btc/actions/deposit/config/evm.ts
-       * Line: token: Token.BTCb
-       */
-      expect(Token.BTCb).toBe('BTC.b');
-    });
-  });
-
-  describe('BtcStakeAndDeploy Action', () => {
-    it('uses "BTC" token for stake and bake permit (triggers ratio conversion)', () => {
-      /**
-       * BtcStakeAndDeploy uses 'BTC' as token parameter to trigger ratio conversion.
-       *
-       * This is CRITICAL because:
-       * 1. User deposits BTC (e.g., 20000 satoshis)
-       * 2. They receive LBTC (e.g., 19947 satoshis after ratio)
-       * 3. The permit signature must contain the LBTC amount (19947)
-       * 4. Backend matches signature by this adjusted amount
-       *
-       * Using 'BTC' hits DEFI_REGISTRY[Veda]['BTC'] which has:
-       *   amountStrategy: 'btcToLbtc' → applies ratio conversion
-       *
-       * Code location: packages/sdk/src/chains/btc/actions/stakeAndDeploy/BtcStakeAndDeploy.ts
-       * Line: token: 'BTC'
-       */
-      const vedaBtcConfig = DEFI_REGISTRY[DefiProtocol.Veda]?.['BTC'];
-      expect(vedaBtcConfig).toBeDefined();
-      if (!vedaBtcConfig) return;
-
-      // Verify btcToLbtc strategy exists in at least one env/chain
-      const hasConversion = Object.values(vedaBtcConfig).some(envMap =>
-        envMap ? Object.values(envMap).some(
-          chainConfig => chainConfig?.amountStrategy === 'btcToLbtc',
-        ) : false,
-      );
-
-      expect(hasConversion).toBe(true);
-    });
-
-    it('should NOT use AssetId.LBTC (would skip ratio conversion)', () => {
-      /**
-       * If BtcStakeAndDeploy used AssetId.LBTC (or Token.LBTC) as token,
-       * it would hit DEFI_REGISTRY[Veda][Token.LBTC] which has:
-       *   amountStrategy: 'identity' → NO ratio conversion
-       *
-       * This was the bug in APP-1993:
-       * - Signature had raw amount (20000)
-       * - Backend expected adjusted amount (19947)
-       * - Result: "signature not found" / deposit not claimed
-       */
-      const vedaLbtcConfig = DEFI_REGISTRY[DefiProtocol.Veda]?.[Token.LBTC];
-      expect(vedaLbtcConfig).toBeDefined();
-      if (!vedaLbtcConfig) return;
-
-      // Verify identity strategy (no conversion) for LBTC token
-      const hasIdentity = Object.values(vedaLbtcConfig).some(envMap =>
-        envMap ? Object.values(envMap).some(
-          chainConfig => chainConfig?.amountStrategy === 'identity',
-        ) : false,
-      );
-
-      expect(hasIdentity).toBe(true);
-    });
-  });
-
-  describe('BtcDepositAndDeploy Action', () => {
-    it('uses Token.BTCb for deposit and deploy permit (no ratio conversion needed)', () => {
-      /**
-       * BtcDepositAndDeploy uses Token.BTCb which has:
-       *   amountStrategy: 'identity' → no conversion
-       *
-       * This is correct because 1 BTC = 1 BTC.b (no exchange rate).
-       *
-       * Code location: packages/sdk/src/chains/btc/actions/depositAndDeploy/BtcDepositAndDeploy.ts
-       * Line: token: Token.BTCb
-       */
-      const siloBtcbConfig = DEFI_REGISTRY[DefiProtocol.Silo]?.[Token.BTCb];
-      expect(siloBtcbConfig).toBeDefined();
-
-      // Verify identity strategy for BTCb
-      const hasIdentity = Object.values(siloBtcbConfig!).some(envMap =>
-        Object.values(envMap!).some(
-          chainConfig => chainConfig?.amountStrategy === 'identity',
-        ),
-      );
-
-      expect(hasIdentity).toBe(true);
-    });
-  });
-
-  describe('Amount Strategy Summary', () => {
-    it('documents all amount strategies in DEFI_REGISTRY', () => {
-      /**
-       * Amount Strategy Reference:
-       *
-       * - 'identity': No conversion, use amount as-is
-       *   → Used for: LBTC permits, BTCb permits
-       *
-       * - 'btcToLbtc': Divide amount by BTCTokenRatio
-       *   → Used for: BTC → LBTC stake and bake
-       *   → Formula: lbtcAmount = btcAmount / ratio
-       *   → Example: 20000 / 1.00265 = 19947
-       */
-
-      const strategies = new Set<string>();
-
-      // Collect all strategies from registry
-      for (const protocolMap of Object.values(DEFI_REGISTRY)) {
-        for (const tokenMap of Object.values(protocolMap)) {
-          for (const envMap of Object.values(tokenMap!)) {
-            for (const chainConfig of Object.values(envMap!)) {
-              if (chainConfig?.amountStrategy) {
-                strategies.add(chainConfig.amountStrategy);
-              }
-            }
-          }
-        }
-      }
-
-      expect(strategies.has('identity')).toBe(true);
-      expect(strategies.has('btcToLbtc')).toBe(true);
-      expect(strategies.size).toBe(2); // Only these two strategies exist
-    });
-  });
-});

package/src/__tests__/unit/btc/btc-deposit-token.test.ts

@@ -1,191 +0,0 @@
-/**
- * BTC Deposit Token Parameter Tests
- *
- * Tests to verify that the correct token (BTCb vs LBTC) is used
- * when generating deposit addresses.
- *
- * Related Issue: APP-1974
- * - BTC.b deposit was incorrectly generating LBTC deposit addresses
- * - The root cause was token parameter not being properly derived from assetOut
- *
- * @module __tests__/unit/btc/btc-deposit-token.test.ts
- */
-
-import { describe, expect, it } from 'vitest';
-
-import { assetIdToToken } from '../../../chains/btc/actions/shared/tokenUtils';
-import { AssetId } from '../../../core';
-import { Token } from '../../../tokens/token-addresses';
-
-describe('BTC Deposit Token Resolution (APP-1974)', () => {
-  // ═══════════════════════════════════════════════════════════════════════════
-  // assetIdToToken
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('assetIdToToken', () => {
-    describe('should map AssetId to correct Token', () => {
-      it('should return Token.BTCb for AssetId.BTCb', () => {
-        const token = assetIdToToken(AssetId.BTCb);
-        expect(token).toBe(Token.BTCb);
-      });
-
-      it('should return Token.LBTC for AssetId.LBTC', () => {
-        const token = assetIdToToken(AssetId.LBTC);
-        expect(token).toBe(Token.LBTC);
-      });
-
-      it('should return default token for unknown AssetId', () => {
-        // Using BTC as an example of an input-only asset
-        const token = assetIdToToken(AssetId.BTC);
-        expect(token).toBe(Token.LBTC); // Default is LBTC
-      });
-
-      it('should use provided default for unknown AssetId', () => {
-        const token = assetIdToToken(AssetId.BTC, Token.BTCb);
-        expect(token).toBe(Token.BTCb);
-      });
-    });
-
-    describe('BTC Deposit specific behavior', () => {
-      /**
-       * APP-1974 Root Cause:
-       * The BtcDeposit.getExpectedToken() method correctly calls
-       * assetIdToToken(this.params.assetOut, Token.BTCb)
-       * 
-       * However, if assetOut is not properly passed (e.g., undefined or wrong value),
-       * it could default to LBTC, causing the wrong deposit address to be generated.
-       */
-
-      it('should return BTCb when assetOut is BTCb (BTC Deposit)', () => {
-        // This simulates what BtcDeposit.getExpectedToken() does
-        const assetOut = AssetId.BTCb;
-        const defaultToken = Token.BTCb;
-        
-        const token = assetIdToToken(assetOut, defaultToken);
-        expect(token).toBe(Token.BTCb);
-      });
-
-      it('should still return BTCb as default even for non-mapped assets in deposit', () => {
-        // BtcDeposit uses Token.BTCb as default
-        const defaultToken = Token.BTCb;
-        
-        // Even if assetOut is somehow invalid, it should fall back to BTCb for deposit
-        const token = assetIdToToken(AssetId.BTC, defaultToken);
-        expect(token).toBe(Token.BTCb);
-      });
-    });
-
-    describe('BTC Stake specific behavior', () => {
-      it('should return LBTC when assetOut is LBTC (BTC Stake)', () => {
-        // This simulates what BtcStake.getExpectedToken() does
-        const assetOut = AssetId.LBTC;
-        const defaultToken = Token.LBTC;
-        
-        const token = assetIdToToken(assetOut, defaultToken);
-        expect(token).toBe(Token.LBTC);
-      });
-    });
-
-    describe('Token/AssetId mapping', () => {
-      /**
-       * Token and AssetId share the same string values for common assets:
-       * - Token.BTCb = 'BTC.b'
-       * - AssetId.BTCb = 'BTC.b'
-       * 
-       * This ensures consistency between API calls and action parameters.
-       */
-
-      it('Token and AssetId values are defined correctly', () => {
-        // Both use 'BTC.b' for BTCb
-        expect(Token.BTCb).toBe('BTC.b');
-        expect(AssetId.BTCb).toBe('BTC.b');
-        
-        // Both use 'LBTC' for LBTC
-        expect(Token.LBTC).toBe('LBTC');
-        expect(AssetId.LBTC).toBe('LBTC');
-      });
-
-      it('assetIdToToken correctly maps AssetId.BTCb to Token.BTCb', () => {
-        const token = assetIdToToken(AssetId.BTCb);
-        expect(token).toBe(Token.BTCb); // 'BTC.b'
-      });
-
-      it('assetIdToToken correctly maps AssetId.LBTC to Token.LBTC', () => {
-        const token = assetIdToToken(AssetId.LBTC);
-        expect(token).toBe(Token.LBTC); // 'LBTC'
-      });
-    });
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Integration with getDepositBtcAddress
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('Token parameter flow', () => {
-    /**
-     * The getDepositBtcAddress function has this signature:
-     * 
-     *   token: tokenParam = Token.LBTC  // Default is LBTC!
-     * 
-     * This means if token is not explicitly passed, it defaults to LBTC.
-     * 
-     * The BtcDeposit and BtcStake actions must always pass the token explicitly.
-     */
-
-    it('should use BTCb token for BTC Deposit actions', () => {
-      // Simulates the full flow from action to API call
-      const actionAssetOut = AssetId.BTCb;
-      const actionDefault = Token.BTCb;
-      
-      // Action calls getExpectedToken() which does this:
-      const tokenForApi = assetIdToToken(actionAssetOut, actionDefault);
-      
-      // This token should be BTCb, not LBTC
-      expect(tokenForApi).toBe(Token.BTCb);
-      expect(tokenForApi).not.toBe(Token.LBTC);
-    });
-
-    it('should use LBTC token for BTC Stake actions', () => {
-      const actionAssetOut = AssetId.LBTC;
-      const actionDefault = Token.LBTC;
-      
-      const tokenForApi = assetIdToToken(actionAssetOut, actionDefault);
-      
-      expect(tokenForApi).toBe(Token.LBTC);
-    });
-
-    it('should never allow BTCb deposit to use LBTC token', () => {
-      // This is the core test for APP-1974
-      // If assetOut is BTCb, the token MUST be BTCb
-      const actionAssetOut = AssetId.BTCb;
-      const tokenForApi = assetIdToToken(actionAssetOut, Token.BTCb);
-      
-      // CRITICAL: This must not be LBTC
-      expect(tokenForApi).not.toBe(Token.LBTC);
-      expect(tokenForApi).toBe(Token.BTCb);
-    });
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Edge Cases
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('Edge cases', () => {
-    it('should handle BTCK token if supported', () => {
-      // BTCK is used in some test environments
-      if ('BTCK' in AssetId) {
-        const assetId = 'BTCK' as AssetId;
-        const token = assetIdToToken(assetId);
-        // Should not throw, returns default
-        expect(token).toBeDefined();
-      }
-    });
-
-    it('should handle undefined-like inputs gracefully', () => {
-      // TypeScript prevents this, but runtime safety is important
-      const token = assetIdToToken(undefined as unknown as AssetId, Token.BTCb);
-      expect(token).toBe(Token.BTCb);
-    });
-  });
-});
-