@lombard.finance/sdk 3.7.3 → 4.0.0

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

@@ -0,0 +1,253 @@
+/**
+ * BTC Deposit Action Unit Tests
+ *
+ * Tests the BTC → BTC.b deposit flow including:
+ * - Parameter validation
+ * - Status transitions
+ * - Authorization flow
+ * - Deposit address generation
+ *
+ * @module __tests__/unit/btc/BtcDeposit.test.ts
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+
+import type { BtcDepositParams, BtcDepositPrepareParams } from '../../../chains/btc/actions/deposit/types';
+import { AssetId, Chain } from '../../../core';
+import { LombardError, ValidationErrorCode } from '../../../shared/errors';
+
+describe('BtcDeposit Interface', () => {
+  describe('BtcDepositParams', () => {
+    it('should accept valid deposit parameters', () => {
+      const params: BtcDepositParams = {
+        assetOut: AssetId.BTCb,
+        destChain: Chain.AVALANCHE,
+      };
+
+      expect(params.assetOut).toBe(AssetId.BTCb);
+      expect(params.destChain).toBe(Chain.AVALANCHE);
+    });
+
+    it('should require BTCb as output asset', () => {
+      const validParams: BtcDepositParams = {
+        assetOut: AssetId.BTCb,
+        destChain: Chain.AVALANCHE,
+      };
+
+      // BTCb is correct for deposit
+      expect(validParams.assetOut).toBe(AssetId.BTCb);
+    });
+
+    it('should support optional source chain', () => {
+      const params: BtcDepositParams = {
+        assetOut: AssetId.BTCb,
+        destChain: Chain.AVALANCHE,
+        sourceChain: Chain.BITCOIN_MAINNET,
+      };
+
+      expect(params.sourceChain).toBe(Chain.BITCOIN_MAINNET);
+    });
+
+    it('should support Avalanche chains for BTC.b', () => {
+      const mainnetParams: BtcDepositParams = {
+        assetOut: AssetId.BTCb,
+        destChain: Chain.AVALANCHE,
+      };
+
+      const testnetParams: BtcDepositParams = {
+        assetOut: AssetId.BTCb,
+        destChain: Chain.AVALANCHE_FUJI,
+      };
+
+      expect(mainnetParams.destChain).toBe(Chain.AVALANCHE);
+      expect(testnetParams.destChain).toBe(Chain.AVALANCHE_FUJI);
+    });
+  });
+
+  describe('BtcDepositPrepareParams', () => {
+    it('should accept valid prepare parameters', () => {
+      const params: BtcDepositPrepareParams = {
+        amount: '0.1',
+        recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+      };
+
+      expect(params.amount).toBe('0.1');
+      expect(params.recipient).toBeDefined();
+    });
+
+    it('should support optional referral code', () => {
+      const params: BtcDepositPrepareParams = {
+        amount: '0.1',
+        recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+        referralCode: 'REF123',
+      };
+
+      expect(params.referralCode).toBe('REF123');
+    });
+  });
+
+  describe('Status Transitions', () => {
+    it('should define all required status values for deposit', () => {
+      const statuses = [
+        'idle',
+        'needs_fee_authorization',
+        'needs_address_confirmation',
+        'ready',
+        'address_ready',
+      ];
+
+      statuses.forEach(status => {
+        expect(typeof status).toBe('string');
+      });
+    });
+
+    it('should define correct status flow', () => {
+      const statusFlow = {
+        'idle -> prepare': 'needs_fee_authorization or needs_address_confirmation',
+        'needs_fee_authorization -> authorize': 'ready',
+        'needs_address_confirmation -> authorize': 'ready',
+        'ready -> generateDepositAddress': 'address_ready',
+      };
+
+      expect(Object.keys(statusFlow).length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Method Signatures', () => {
+    it('should define prepare method', () => {
+      type PrepareMethod = (params: BtcDepositPrepareParams) => Promise<void>;
+      const testType: PrepareMethod = async () => {};
+      expect(testType).toBeDefined();
+    });
+
+    it('should define authorize method', () => {
+      type AuthorizeMethod = () => Promise<void>;
+      const testType: AuthorizeMethod = async () => {};
+      expect(testType).toBeDefined();
+    });
+
+    it('should define generateDepositAddress method', () => {
+      type GenerateAddressMethod = () => Promise<string>;
+      const testType: GenerateAddressMethod = async () =>
+        'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh';
+      expect(testType).toBeDefined();
+    });
+
+    it('should define execute method', () => {
+      type ExecuteMethod = () => Promise<{ depositAddress: string }>;
+      const testType: ExecuteMethod = async () => ({
+        depositAddress: 'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh',
+      });
+      expect(testType).toBeDefined();
+    });
+
+    it('should define monitorDeposit method', () => {
+      type MonitorMethod = () => Promise<unknown>;
+      const testType: MonitorMethod = async () => undefined;
+      expect(testType).toBeDefined();
+    });
+  });
+
+  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', verifying: 'idle', issuing: 'idle' },
+      });
+
+      expect(handler).toHaveBeenCalledOnce();
+    });
+
+    it('should emit status-change events', () => {
+      const handler = vi.fn((status: string) => {
+        expect(typeof status).toBe('string');
+      });
+
+      handler('ready');
+      expect(handler).toHaveBeenCalledWith('ready');
+    });
+  });
+
+  describe('Public Properties', () => {
+    it('should expose status property', () => {
+      type HasStatus = { readonly status: string };
+      const obj: HasStatus = { status: 'idle' };
+      expect(obj.status).toBe('idle');
+    });
+
+    it('should expose amount property after prepare', () => {
+      type HasAmount = { readonly amount?: string };
+      const obj: HasAmount = { amount: '0.1' };
+      expect(obj.amount).toBe('0.1');
+    });
+
+    it('should expose recipient property after prepare', () => {
+      type HasRecipient = { readonly recipient?: string };
+      const obj: HasRecipient = {
+        recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+      };
+      expect(obj.recipient).toBeDefined();
+    });
+
+    it('should expose depositAddress property after generate', () => {
+      type HasDepositAddress = { readonly depositAddress?: string };
+      const obj: HasDepositAddress = {
+        depositAddress: 'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh',
+      };
+      expect(obj.depositAddress).toBeDefined();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should reject LBTC as output asset', () => {
+      const error = new LombardError(
+        ValidationErrorCode.INVALID_ASSET,
+        `Asset LBTC is not supported for BTC deposits. Use BtcStake instead.`,
+      );
+
+      expect(error.code).toBe(ValidationErrorCode.INVALID_ASSET);
+      expect(error.message).toContain('BtcStake');
+    });
+
+    it('should reject unsupported destination chains', () => {
+      const error = new LombardError(
+        ValidationErrorCode.INVALID_CHAIN,
+        `Destination chain ethereum is not supported for BTC deposits.`,
+      );
+
+      expect(error.code).toBe(ValidationErrorCode.INVALID_CHAIN);
+    });
+
+    it('should handle user rejection during authorization', () => {
+      const error = LombardError.userRejected('deposit authorization');
+      expect(error.message).toContain('deposit authorization');
+    });
+  });
+
+  describe('Fee Authorization', () => {
+    it('should require fee auth for Ethereum mainnet only', () => {
+      // Fee authorization is only required for Ethereum mainnet
+      const feeAuthChains = [Chain.ETHEREUM];
+      const noFeeAuthChains = [Chain.AVALANCHE, Chain.AVALANCHE_FUJI];
+
+      expect(feeAuthChains).toContain(Chain.ETHEREUM);
+      noFeeAuthChains.forEach(chain => {
+        expect(feeAuthChains).not.toContain(chain);
+      });
+    });
+
+    it('should use address confirmation for non-Ethereum chains', () => {
+      // Avalanche uses address confirmation, not fee auth
+      const addressConfirmationChains = [Chain.AVALANCHE, Chain.AVALANCHE_FUJI];
+      
+      addressConfirmationChains.forEach(chain => {
+        expect(chain).not.toBe(Chain.ETHEREUM);
+      });
+    });
+  });
+});
+

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

@@ -0,0 +1,174 @@
+/**
+ * BTC Deposit And Deploy Action Unit Tests
+ *
+ * Tests the BTC → BTC.b → DeFi vault flow including:
+ * - Parameter validation
+ * - Protocol/vault selection
+ * - Silo vault integration
+ *
+ * @module __tests__/unit/btc/BtcDepositAndDeploy.test.ts
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { AssetId, Chain } from '../../../core';
+import { LombardError, ValidationErrorCode } from '../../../shared/errors';
+
+describe('BtcDepositAndDeploy Interface', () => {
+  describe('BtcDepositAndDeployParams', () => {
+    it('should require BTCb as output asset', () => {
+      const params = {
+        assetOut: AssetId.BTCb,
+        destChain: Chain.AVALANCHE,
+        protocol: 'silo',
+        vault: 'BTCb',
+      };
+
+      expect(params.assetOut).toBe(AssetId.BTCb);
+    });
+
+    it('should require Silo protocol for BTC.b', () => {
+      const params = {
+        assetOut: AssetId.BTCb,
+        destChain: Chain.AVALANCHE,
+        protocol: 'silo',
+        vault: 'BTCb',
+      };
+
+      expect(params.protocol).toBe('silo');
+    });
+
+    it('should support Avalanche chains only', () => {
+      const validChains = [Chain.AVALANCHE, Chain.AVALANCHE_FUJI];
+      
+      // Chains are CAIP-2 format (e.g., eip155:43114)
+      validChains.forEach(chain => {
+        expect(chain).toBeDefined();
+        expect(typeof chain).toBe('string');
+      });
+
+      // Verify they are the correct Avalanche chain IDs
+      expect(validChains).toContain(Chain.AVALANCHE);
+      expect(validChains).toContain(Chain.AVALANCHE_FUJI);
+    });
+  });
+
+  describe('BtcDepositAndDeployPrepareParams', () => {
+    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_address_confirmation',
+        '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 authorize method', () => {
+      type AuthorizeMethod = () => Promise<void>;
+      const testType: AuthorizeMethod = async () => {};
+      expect(testType).toBeDefined();
+    });
+
+    it('should define generateDepositAddress method', () => {
+      type GenerateAddressMethod = () => Promise<string>;
+      const testType: GenerateAddressMethod = async () => 'bc1qexample';
+      expect(testType).toBeDefined();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should reject LBTC as output asset', () => {
+      const error = new LombardError(
+        ValidationErrorCode.INVALID_ASSET,
+        `Asset LBTC is not supported for deposit and deploy. Use BtcStakeAndDeploy instead.`,
+      );
+
+      expect(error.code).toBe(ValidationErrorCode.INVALID_ASSET);
+    });
+
+    it('should reject non-Avalanche chains', () => {
+      const error = new LombardError(
+        ValidationErrorCode.INVALID_CHAIN,
+        `Destination chain ethereum is not supported for deposit and deploy.`,
+      );
+
+      expect(error.code).toBe(ValidationErrorCode.INVALID_CHAIN);
+    });
+
+    it('should reject non-Silo protocols for BTC.b', () => {
+      const error = new LombardError(
+        ValidationErrorCode.INVALID_PARAMETER,
+        `Protocol euler is not supported for BTC.b deposit and deploy. Only Silo is supported.`,
+      );
+
+      expect(error.code).toBe(ValidationErrorCode.INVALID_PARAMETER);
+    });
+  });
+
+  describe('Silo Integration', () => {
+    it('should integrate with Silo vault on Avalanche', () => {
+      const siloConfig = {
+        protocol: 'silo',
+        chains: [Chain.AVALANCHE, Chain.AVALANCHE_FUJI],
+        assetIn: AssetId.BTCb,
+      };
+
+      expect(siloConfig.protocol).toBe('silo');
+      expect(siloConfig.assetIn).toBe(AssetId.BTCb);
+    });
+  });
+
+  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: 'silo' };
+      expect(obj.protocol).toBe('silo');
+    });
+
+    it('should expose vault property', () => {
+      type HasVault = { readonly vault: string };
+      const obj: HasVault = { vault: 'BTCb' };
+      expect(obj.vault).toBe('BTCb');
+    });
+  });
+});
+

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

@@ -0,0 +1,143 @@
+/**
+ * BTC Deposit Config Unit Tests
+ *
+ * Tests validation functions for BTC Deposit action.
+ * 
+ * Note: Supported chains are derived dynamically from ASSET_CATALOG.
+ * These tests verify the validation logic works correctly.
+ *
+ * @module __tests__/unit/btc/BtcDepositConfig.test.ts
+ */
+
+import { describe, expect,it } from 'vitest';
+
+import {
+  depositConfig,
+  isAssetOutSupported,
+  isDestChainSupported,
+  isRouteAvailable,
+} from '../../../chains/btc/actions/deposit/config';
+import { AssetId,Chain, Env } from '../../../core';
+
+describe('BTC Deposit Config', () => {
+  describe('isAssetOutSupported', () => {
+    it('should support BTCb for BTC Deposit', () => {
+      expect(isAssetOutSupported(AssetId.BTCb)).toBe(true);
+    });
+
+    it('should NOT support LBTC for BTC Deposit (use BtcStake instead)', () => {
+      // LBTC is produced by BtcStake, not BtcDeposit
+      expect(isAssetOutSupported(AssetId.LBTC)).toBe(false);
+    });
+
+    it('should NOT support BTC as output (it is the input asset)', () => {
+      expect(isAssetOutSupported(AssetId.BTC)).toBe(false);
+    });
+
+    it('should have BTCb as the only supported output asset', () => {
+      expect(depositConfig.supportedAssetsOut).toEqual([AssetId.BTCb]);
+    });
+  });
+
+  describe('isDestChainSupported', () => {
+    it('should support Avalanche for BTC.b deposit', () => {
+      expect(isDestChainSupported(Chain.AVALANCHE)).toBe(true);
+    });
+
+    it('should support Avalanche Fuji (testnet) for BTC.b deposit', () => {
+      expect(isDestChainSupported(Chain.AVALANCHE_FUJI)).toBe(true);
+    });
+
+    it('should have at least one supported destination chain', () => {
+      expect(depositConfig.destChains.length).toBeGreaterThan(0);
+    });
+
+    it('should derive chains from asset catalog', () => {
+      // Verify that destChains array exists and is derived from BTCb deployments
+      expect(Array.isArray(depositConfig.destChains)).toBe(true);
+      // All chains should be EVM chains (strings)
+      depositConfig.destChains.forEach(chain => {
+        expect(typeof chain).toBe('string');
+      });
+    });
+  });
+
+  describe('isRouteAvailable', () => {
+    it('should allow Bitcoin Mainnet source in production', () => {
+      expect(isRouteAvailable(Chain.BITCOIN_MAINNET, Env.prod)).toBe(true);
+    });
+
+    it('should allow Bitcoin Signet source in testnet', () => {
+      expect(isRouteAvailable(Chain.BITCOIN_SIGNET, Env.testnet)).toBe(true);
+    });
+
+    it('should allow Bitcoin Signet source in stage', () => {
+      expect(isRouteAvailable(Chain.BITCOIN_SIGNET, Env.stage)).toBe(true);
+    });
+
+    it('should NOT allow Bitcoin Signet in production', () => {
+      expect(isRouteAvailable(Chain.BITCOIN_SIGNET, Env.prod)).toBe(false);
+    });
+
+    it('should NOT allow Bitcoin Mainnet in testnet', () => {
+      expect(isRouteAvailable(Chain.BITCOIN_MAINNET, Env.testnet)).toBe(false);
+    });
+
+    it('should allow undefined source chain (uses env default)', () => {
+      expect(isRouteAvailable(undefined, Env.testnet)).toBe(true);
+      expect(isRouteAvailable(undefined, Env.prod)).toBe(true);
+    });
+  });
+
+  describe('Validation logic', () => {
+    it('should have consistent asset validation', () => {
+      // Only BTCb should be valid
+      const validAssets = [AssetId.BTCb];
+      const invalidAssets = [AssetId.LBTC, AssetId.BTC];
+
+      validAssets.forEach(asset => {
+        expect(isAssetOutSupported(asset)).toBe(true);
+      });
+
+      invalidAssets.forEach(asset => {
+        expect(isAssetOutSupported(asset)).toBe(false);
+      });
+    });
+
+    it('should validate that Avalanche chains support BTC.b deposit', () => {
+      // Primary chains for BTC.b
+      expect(isDestChainSupported(Chain.AVALANCHE)).toBe(true);
+      expect(isDestChainSupported(Chain.AVALANCHE_FUJI)).toBe(true);
+    });
+
+    it('should enforce environment-specific routes', () => {
+      // Production: Bitcoin Mainnet only
+      expect(isRouteAvailable(Chain.BITCOIN_MAINNET, Env.prod)).toBe(true);
+      expect(isRouteAvailable(Chain.BITCOIN_SIGNET, Env.prod)).toBe(false);
+
+      // Testnet/Stage/Dev: Bitcoin Signet only
+      expect(isRouteAvailable(Chain.BITCOIN_SIGNET, Env.testnet)).toBe(true);
+      expect(isRouteAvailable(Chain.BITCOIN_SIGNET, Env.stage)).toBe(true);
+      expect(isRouteAvailable(Chain.BITCOIN_SIGNET, Env.dev)).toBe(true);
+      expect(isRouteAvailable(Chain.BITCOIN_MAINNET, Env.testnet)).toBe(false);
+    });
+  });
+
+  describe('Fee authorization requirements', () => {
+    it('should require fee authorization for Ethereum mainnet', () => {
+      const feeAuth = depositConfig.getFeeAuthConfig(Chain.ETHEREUM);
+      expect(feeAuth).not.toBeNull();
+    });
+
+    it('should NOT require fee authorization for Avalanche', () => {
+      const feeAuth = depositConfig.getFeeAuthConfig(Chain.AVALANCHE);
+      expect(feeAuth).toBeNull();
+    });
+
+    it('should NOT require fee authorization for Avalanche Fuji', () => {
+      const feeAuth = depositConfig.getFeeAuthConfig(Chain.AVALANCHE_FUJI);
+      expect(feeAuth).toBeNull();
+    });
+  });
+});
+