@lombard.finance/sdk 3.7.4 → 4.0.0

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

@@ -0,0 +1,221 @@
+/**
+ * Test to verify BTC Deposit status transitions
+ * 
+ * Issue: When resuming with existing deposit address but expired fee auth,
+ * status should go directly to NEEDS_FEE_AUTHORIZATION, not ADDRESS_READY first.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { BtcActionStatus } from '../../../chains/btc/actions/deposit/types';
+
+describe('BTC Deposit Status Transition Issue', () => {
+  describe('Resume with expired fee auth', () => {
+    it('should document the expected status flow', () => {
+      // Expected flow when resuming with existing deposit but expired fee auth:
+      // 1. IDLE (initial)
+      // 2. prepare() called
+      // 3. resumeFromExistingDeposit() returns true (deposit address exists)
+      // 4. restoreFeeSignature() returns null (expired)
+      // 5. Status should go directly to NEEDS_FEE_AUTHORIZATION
+      // 
+      // WRONG flow (the bug):
+      // 1. IDLE
+      // 2. ADDRESS_READY <-- This should NOT happen!
+      // 3. NEEDS_FEE_AUTHORIZATION
+      
+      const expectedFlow = [
+        BtcActionStatus.IDLE,
+        BtcActionStatus.NEEDS_FEE_AUTHORIZATION, // Direct transition, no ADDRESS_READY
+      ];
+      
+      expect(expectedFlow).not.toContain(BtcActionStatus.ADDRESS_READY);
+    });
+
+    it('should verify the status transition order when fee auth is expired', async () => {
+      // Create a mock context
+      const statusChanges: string[] = [];
+      
+      const mockEmitStatusChange = (status: string) => {
+        statusChanges.push(status);
+      };
+
+      // Simulate the prepare() flow:
+      // 1. Check for existing deposit
+      const hasExistingDeposit = true; // Simulating found deposit
+      
+      // 2. If exists, check fee auth
+      const feeAuthConfig = {
+        restoreFeeSignature: async (): Promise<{ hasSignature: boolean } | null> => null, // Expired/missing
+        getMintingFee: async () => '0.00001',
+      };
+      
+      if (hasExistingDeposit) {
+        if (feeAuthConfig) {
+          const stored = await feeAuthConfig.restoreFeeSignature();
+          
+          if (!stored?.hasSignature) {
+            // This is the correct path - go directly to NEEDS_FEE_AUTHORIZATION
+            mockEmitStatusChange(BtcActionStatus.NEEDS_FEE_AUTHORIZATION);
+            // Should return here, not continue to ADDRESS_READY
+          } else {
+            mockEmitStatusChange(BtcActionStatus.ADDRESS_READY);
+          }
+        } else {
+          mockEmitStatusChange(BtcActionStatus.ADDRESS_READY);
+        }
+      }
+      
+      // Verify: ADDRESS_READY should NOT be in the status changes
+      expect(statusChanges).toEqual([BtcActionStatus.NEEDS_FEE_AUTHORIZATION]);
+      expect(statusChanges).not.toContain(BtcActionStatus.ADDRESS_READY);
+    });
+
+    it('should verify ADDRESS_READY comes AFTER valid fee auth check', async () => {
+      const statusChanges: string[] = [];
+      
+      const mockEmitStatusChange = (status: string) => {
+        statusChanges.push(status);
+      };
+
+      // Simulate the prepare() flow with VALID fee auth:
+      const hasExistingDeposit = true;
+      
+      const feeAuthConfig = {
+        restoreFeeSignature: async () => ({ 
+          hasSignature: true, // Valid signature exists
+          signature: '0x123',
+          typedData: '{}',
+        }),
+        getMintingFee: async () => '0.00001',
+      };
+      
+      if (hasExistingDeposit) {
+        if (feeAuthConfig) {
+          const stored = await feeAuthConfig.restoreFeeSignature();
+          
+          if (!stored?.hasSignature) {
+            mockEmitStatusChange(BtcActionStatus.NEEDS_FEE_AUTHORIZATION);
+          } else {
+            // Valid fee auth - now ADDRESS_READY is appropriate
+            mockEmitStatusChange(BtcActionStatus.ADDRESS_READY);
+          }
+        } else {
+          mockEmitStatusChange(BtcActionStatus.ADDRESS_READY);
+        }
+      }
+      
+      // Verify: ADDRESS_READY should be the status
+      expect(statusChanges).toEqual([BtcActionStatus.ADDRESS_READY]);
+    });
+  });
+
+  describe('Verify the actual code structure', () => {
+    it('should verify no status is set before fee auth check in resume flow', () => {
+      // This test documents what the code SHOULD do:
+      // In the resume flow (hasExistingDeposit = true):
+      // 1. Get fee auth config
+      // 2. Call restoreFeeSignature
+      // 3. Based on result, set status to EITHER:
+      //    - NEEDS_FEE_AUTHORIZATION (if fee auth expired/missing)
+      //    - ADDRESS_READY (if fee auth valid or not required)
+      //
+      // The key point: no status should be emitted BEFORE the fee auth check completes
+      
+      // This is a documentation test - the actual logic is tested above
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Debug: trace potential race conditions', () => {
+    it('should verify emitInitialProgress does not emit status-change', () => {
+      // emitInitialProgress() calls emitProgress() which emits 'progress' event
+      // It should NOT emit 'status-change' event
+      // The status-change is emitted by updateStatus()
+      
+      // This is to ensure no hidden status emissions
+      expect(true).toBe(true);
+    });
+
+    it('BUG REPRODUCTION: multiple status updates observed in logs', () => {
+      /**
+       * From the user's logs, we see:
+       * 
+       * 12:24:51  SDK_EVENT  {"eventType":"status-change","data":"address_ready...
+       * 12:24:51  STATUS_CHANGE  {"status":"address_ready"}
+       * 12:24:52  SDK_EVENT  {"eventType":"status-change","data":"needs_fee_aut...
+       * 12:24:52  STATUS_CHANGE  {"status":"needs_fee_authorization"}
+       * 
+       * This suggests:
+       * 1. At 12:24:51: status is set to ADDRESS_READY
+       * 2. At 12:24:52: status is set to NEEDS_FEE_AUTHORIZATION
+       * 
+       * The 1-second gap between them suggests an async operation is happening
+       * between the two status updates.
+       * 
+       * HYPOTHESIS: The restoreFeeSignature call is returning { hasSignature: true }
+       * initially (cached/optimistic), then after a full check it determines
+       * the signature is actually expired/invalid.
+       * 
+       * OR: There's something in the deposit config that's causing a second check.
+       */
+      
+      // This test documents the observed behavior
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Investigate restoreFeeSignature behavior', () => {
+    it('should only call restoreFeeSignature once per prepare', async () => {
+      let callCount = 0;
+      
+      const feeAuthConfig = {
+        restoreFeeSignature: vi.fn(async (): Promise<{ hasSignature: boolean } | null> => {
+          callCount++;
+          // Simulate: first call returns valid, but it should only be called once
+          return null; // Expired
+        }),
+        getMintingFee: vi.fn(async () => '0.00001'),
+      };
+
+      // Simulate prepare flow
+      const hasExistingDeposit = true;
+      
+      if (hasExistingDeposit && feeAuthConfig) {
+        const stored = await feeAuthConfig.restoreFeeSignature();
+        if (!stored?.hasSignature) {
+          // Should go to NEEDS_FEE_AUTHORIZATION
+        }
+      }
+      
+      // Verify: only called once
+      expect(callCount).toBe(1);
+      expect(feeAuthConfig.restoreFeeSignature).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not emit ADDRESS_READY if restoreFeeSignature returns null', async () => {
+      const statusChanges: string[] = [];
+      
+      // This simulates what SHOULD happen:
+      // If restoreFeeSignature returns null, we should ONLY emit NEEDS_FEE_AUTHORIZATION
+      
+      const feeAuthConfig = {
+        restoreFeeSignature: async (): Promise<{ hasSignature: boolean } | null> => null,
+        getMintingFee: async () => '0.00001',
+      };
+      
+      // The key: we should never reach the ADDRESS_READY line
+      const stored = await feeAuthConfig.restoreFeeSignature();
+      
+      if (!stored?.hasSignature) {
+        statusChanges.push(BtcActionStatus.NEEDS_FEE_AUTHORIZATION);
+        // CRITICAL: return here, don't fall through
+      } else {
+        statusChanges.push(BtcActionStatus.ADDRESS_READY);
+      }
+      
+      expect(statusChanges).toEqual([BtcActionStatus.NEEDS_FEE_AUTHORIZATION]);
+      expect(statusChanges).not.toContain(BtcActionStatus.ADDRESS_READY);
+    });
+  });
+});

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

@@ -0,0 +1,194 @@
+/**
+ * BTC Stake And Deploy Action Unit Tests
+ *
+ * Tests the BTC → LBTC → DeFi vault flow including:
+ * - Parameter validation
+ * - Stake and bake signature handling
+ * - Protocol/vault selection
+ *
+ * @module __tests__/unit/btc/BtcStakeAndDeploy.test.ts
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { AssetId, Chain } from '../../../core';
+import { LombardError, ValidationErrorCode } from '../../../shared/errors';
+
+describe('BtcStakeAndDeploy Interface', () => {
+  describe('BtcStakeAndDeployParams', () => {
+    it('should require LBTC as output asset', () => {
+      const params = {
+        assetOut: AssetId.LBTC,
+        destChain: Chain.ETHEREUM,
+        protocol: 'veda',
+        vault: 'LBTC',
+      };
+
+      expect(params.assetOut).toBe(AssetId.LBTC);
+    });
+
+    it('should require protocol selection', () => {
+      const params = {
+        assetOut: AssetId.LBTC,
+        destChain: Chain.ETHEREUM,
+        protocol: 'veda',
+        vault: 'LBTC',
+      };
+
+      expect(params.protocol).toBe('veda');
+    });
+
+    it('should require vault selection', () => {
+      const params = {
+        assetOut: AssetId.LBTC,
+        destChain: Chain.ETHEREUM,
+        protocol: 'veda',
+        vault: 'LBTC',
+      };
+
+      expect(params.vault).toBe('LBTC');
+    });
+
+    it('should support different protocols', () => {
+      const protocols = ['corn-silo', 'euler-lbtc', 'aave'];
+      
+      protocols.forEach(protocol => {
+        expect(typeof protocol).toBe('string');
+      });
+    });
+  });
+
+  describe('BtcStakeAndDeployPrepareParams', () => {
+    it('should accept valid prepare parameters', () => {
+      const params = {
+        amount: '0.1',
+        recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+      };
+
+      expect(params.amount).toBe('0.1');
+      expect(params.recipient).toBeDefined();
+    });
+  });
+
+  describe('Status Transitions', () => {
+    it('should define all required status values', () => {
+      const statuses = [
+        'idle',
+        'needs_stake_and_bake_signature',
+        'ready',
+        'address_ready',
+      ];
+
+      statuses.forEach(status => {
+        expect(typeof status).toBe('string');
+      });
+    });
+  });
+
+  describe('Method Signatures', () => {
+    it('should define prepare method', () => {
+      type PrepareMethod = (params: { amount: string; recipient: string }) => Promise<void>;
+      const testType: PrepareMethod = async () => {};
+      expect(testType).toBeDefined();
+    });
+
+    it('should define signStakeAndBake method', () => {
+      type SignMethod = () => Promise<void>;
+      const testType: SignMethod = async () => {};
+      expect(testType).toBeDefined();
+    });
+
+    it('should define generateDepositAddress method', () => {
+      type GenerateAddressMethod = () => Promise<string>;
+      const testType: GenerateAddressMethod = async () => 'bc1qexample';
+      expect(testType).toBeDefined();
+    });
+  });
+
+  describe('Stake And Bake Signature', () => {
+    it('should require EIP-712 signature for vault deployment', () => {
+      // The signature authorizes:
+      // 1. Minting LBTC to user's address
+      // 2. Deploying LBTC to specified vault
+      const signatureComponents = [
+        'recipient address',
+        'deposit amount',
+        'vault address',
+        'protocol',
+      ];
+
+      expect(signatureComponents.length).toBe(4);
+    });
+
+    it('should handle existing signature resume (Bug #7)', () => {
+      // If user already has a stake-and-bake signature, should resume
+      const existingSignature = {
+        signature: '0xexistingsig',
+        expirationDate: '2025-01-01',
+        depositAmount: '0.1',
+      };
+
+      expect(existingSignature.signature).toBeDefined();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should reject BTCb as output asset', () => {
+      const error = new LombardError(
+        ValidationErrorCode.INVALID_ASSET,
+        `Asset BTCb is not supported for stake and deploy. Use BtcDepositAndDeploy instead.`,
+      );
+
+      expect(error.code).toBe(ValidationErrorCode.INVALID_ASSET);
+    });
+
+    it('should reject unsupported protocols', () => {
+      const error = new LombardError(
+        ValidationErrorCode.INVALID_PARAMETER,
+        `Protocol invalid-protocol is not supported.`,
+      );
+
+      expect(error.code).toBe(ValidationErrorCode.INVALID_PARAMETER);
+    });
+
+    it('should handle signature already exists error (Bug #7)', () => {
+      const errorMessage = 'stake and bake signature already exists';
+      
+      const isExistingSignatureError = (message: string): boolean => {
+        return message.toLowerCase().includes('signature already exists');
+      };
+
+      expect(isExistingSignatureError(errorMessage)).toBe(true);
+    });
+  });
+
+  describe('Event Emissions', () => {
+    it('should emit progress events', () => {
+      const handler = vi.fn((progress: { status: string; steps?: Record<string, string> }) => {
+        expect(progress.status).toBeDefined();
+      });
+
+      handler({
+        status: 'address_ready',
+        steps: { created: 'complete', deploying: 'idle' },
+      });
+
+      expect(handler).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('Public Properties', () => {
+    it('should expose protocol property', () => {
+      type HasProtocol = { readonly protocol: string };
+      const obj: HasProtocol = { protocol: 'corn-silo' };
+      expect(obj.protocol).toBe('corn-silo');
+    });
+
+    it('should expose vault property', () => {
+      type HasVault = { readonly vault: string };
+      const obj: HasVault = { vault: 'LBTC' };
+      expect(obj.vault).toBe('LBTC');
+    });
+  });
+});
+