@lombard.finance/sdk 4.0.0 → 4.1.2

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

@@ -1,253 +0,0 @@
-/**
- * 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

@@ -1,174 +0,0 @@
-/**
- * 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

@@ -1,143 +0,0 @@
-/**
- * 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();
-    });
-  });
-});
-