@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/__tests__/unit/core/chain-parsing.test.ts

@@ -1,257 +0,0 @@
-/**
- * Chain Parsing Tests
- *
- * Tests for parseChainIdentifier function to ensure proper handling of
- * CAIP-2 chain identifiers for all supported chain types.
- *
- * Related Issues:
- * - APP-1976: Solana genesis hash → network name mapping
- * - APP-1977: Sui chain ID validation (full CAIP-2 format)
- * - APP-1978: Starknet network name → hex chain ID mapping
- *
- * @module __tests__/unit/core/chain-parsing.test.ts
- */
-
-import { describe, expect, it } from 'vitest';
-
-import {
-  ChainId,
-  isSolanaChain,
-  isStarknetChainId,
-  isSuiChain,
-  SOLANA_DEVNET_CHAIN,
-  SOLANA_MAINNET_CHAIN,
-  SOLANA_TESTNET_CHAIN,
-  STARKNET_MAINNET_CHAIN,
-  STARKNET_SEPOLIA_CHAIN,
-  SUI_DEVNET_CHAIN,
-  SUI_MAINNET_CHAIN,
-  SUI_TESTNET_CHAIN,
-} from '../../../common/chains';
-import {
-  Chain,
-  parseChainIdentifier,
-} from '../../../core';
-
-describe('parseChainIdentifier', () => {
-  // ═══════════════════════════════════════════════════════════════════════════
-  // EVM Chain Parsing
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('EVM chains (eip155:*)', () => {
-    it('should parse Ethereum mainnet', () => {
-      const result = parseChainIdentifier(Chain.ETHEREUM);
-      expect(result).toBe(ChainId.ethereum);
-    });
-
-    it('should parse Avalanche mainnet', () => {
-      const result = parseChainIdentifier(Chain.AVALANCHE);
-      expect(result).toBe(ChainId.avalanche);
-    });
-
-    it('should parse Base mainnet', () => {
-      const result = parseChainIdentifier(Chain.BASE);
-      expect(result).toBe(ChainId.base);
-    });
-
-    it('should parse Sepolia testnet', () => {
-      const result = parseChainIdentifier(Chain.SEPOLIA);
-      expect(result).toBe(ChainId.sepolia);
-    });
-
-    it('should throw for invalid EVM chain ID', () => {
-      expect(() => {
-        parseChainIdentifier('eip155:99999999' as Chain);
-      }).toThrow('Invalid EVM chain');
-    });
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Solana Chain Parsing (APP-1976)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('Solana chains (solana:*) - APP-1976', () => {
-    /**
-     * APP-1976 FIX:
-     * 
-     * The original bug was that CAIP-2 Solana chains use genesis hash references
-     * (e.g., 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp' for mainnet),
-     * but the Solana SDK expects network names ('solana:mainnet-beta').
-     * 
-     * The fix maps genesis hash references to their corresponding network names.
-     */
-
-    describe('Legacy format (network names)', () => {
-      it('should parse mainnet-beta', () => {
-        const result = parseChainIdentifier(SOLANA_MAINNET_CHAIN as unknown as Chain);
-        expect(result).toBe(SOLANA_MAINNET_CHAIN);
-        expect(isSolanaChain(result)).toBe(true);
-      });
-
-      it('should parse devnet', () => {
-        const result = parseChainIdentifier(SOLANA_DEVNET_CHAIN as unknown as Chain);
-        expect(result).toBe(SOLANA_DEVNET_CHAIN);
-        expect(isSolanaChain(result)).toBe(true);
-      });
-
-      it('should parse testnet', () => {
-        const result = parseChainIdentifier(SOLANA_TESTNET_CHAIN as unknown as Chain);
-        expect(result).toBe(SOLANA_TESTNET_CHAIN);
-        expect(isSolanaChain(result)).toBe(true);
-      });
-    });
-
-    describe('CAIP-2 format (genesis hash references)', () => {
-      it('should map mainnet genesis hash to mainnet-beta', () => {
-        // CAIP-2 mainnet: solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp
-        const result = parseChainIdentifier(
-          'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp' as Chain
-        );
-        expect(result).toBe(SOLANA_MAINNET_CHAIN);
-      });
-
-      it('should map devnet genesis hash to devnet', () => {
-        // CAIP-2 devnet: solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1
-        const result = parseChainIdentifier(
-          'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1' as Chain
-        );
-        expect(result).toBe(SOLANA_DEVNET_CHAIN);
-      });
-
-      it('should map testnet genesis hash to testnet', () => {
-        // CAIP-2 testnet: solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z
-        const result = parseChainIdentifier(
-          'solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z' as Chain
-        );
-        expect(result).toBe(SOLANA_TESTNET_CHAIN);
-      });
-    });
-
-    it('should throw for invalid Solana chain reference', () => {
-      expect(() => {
-        parseChainIdentifier('solana:invalid-reference' as Chain);
-      }).toThrow('Invalid Solana chain');
-    });
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Sui Chain Parsing (APP-1977)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('Sui chains (sui:*) - APP-1977', () => {
-    /**
-     * APP-1977 FIX:
-     * 
-     * The original bug was that isSuiChain was receiving just the network part
-     * (e.g., 'testnet') instead of the full chain ID ('sui:testnet').
-     * 
-     * The fix ensures the full CAIP-2 chain ID is passed to isSuiChain.
-     */
-
-    it('should parse sui:mainnet', () => {
-      const result = parseChainIdentifier(SUI_MAINNET_CHAIN as unknown as Chain);
-      expect(result).toBe(SUI_MAINNET_CHAIN);
-      expect(isSuiChain(result)).toBe(true);
-    });
-
-    it('should parse sui:testnet', () => {
-      const result = parseChainIdentifier(SUI_TESTNET_CHAIN as unknown as Chain);
-      expect(result).toBe(SUI_TESTNET_CHAIN);
-      expect(isSuiChain(result)).toBe(true);
-    });
-
-    it('should parse sui:devnet', () => {
-      const result = parseChainIdentifier(SUI_DEVNET_CHAIN as unknown as Chain);
-      expect(result).toBe(SUI_DEVNET_CHAIN);
-      expect(isSuiChain(result)).toBe(true);
-    });
-
-    it('should throw for invalid Sui chain', () => {
-      expect(() => {
-        parseChainIdentifier('sui:invalid' as Chain);
-      }).toThrow('Invalid Sui chain');
-    });
-
-    describe('isSuiChain validation', () => {
-      it('should return true for valid Sui chains', () => {
-        expect(isSuiChain(SUI_MAINNET_CHAIN)).toBe(true);
-        expect(isSuiChain(SUI_TESTNET_CHAIN)).toBe(true);
-        expect(isSuiChain(SUI_DEVNET_CHAIN)).toBe(true);
-      });
-
-      it('should return false for just network name (the original bug)', () => {
-        // Before the fix, 'testnet' was passed instead of 'sui:testnet'
-        expect(isSuiChain('testnet')).toBe(false);
-        expect(isSuiChain('mainnet')).toBe(false);
-        expect(isSuiChain('devnet')).toBe(false);
-      });
-    });
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Starknet Chain Parsing (APP-1978)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('Starknet chains (starknet:*) - APP-1978', () => {
-    /**
-     * APP-1978 FIX:
-     * 
-     * The original bug was that CAIP-2 uses human-readable network names
-     * (SN_MAIN, SN_SEPOLIA), but Starknet SDK expects hex-encoded chain IDs.
-     * 
-     * The fix maps network names to their corresponding hex chain IDs.
-     */
-
-    it('should parse mainnet (SN_MAIN) to hex chain ID', () => {
-      const result = parseChainIdentifier('starknet:SN_MAIN' as Chain);
-      expect(result).toBe(STARKNET_MAINNET_CHAIN);
-      expect(result).toBe('0x534e5f4d41494e'); // hex of "SN_MAIN"
-      expect(isStarknetChainId(result)).toBe(true);
-    });
-
-    it('should parse sepolia (SN_SEPOLIA) to hex chain ID', () => {
-      const result = parseChainIdentifier('starknet:SN_SEPOLIA' as Chain);
-      expect(result).toBe(STARKNET_SEPOLIA_CHAIN);
-      expect(result).toBe('0x534e5f5345504f4c4941'); // hex of "SN_SEPOLIA"
-      expect(isStarknetChainId(result)).toBe(true);
-    });
-
-    it('should throw for invalid Starknet network', () => {
-      expect(() => {
-        parseChainIdentifier('starknet:invalid' as Chain);
-      }).toThrow('Invalid Starknet chain');
-    });
-
-    describe('isStarknetChainId validation', () => {
-      it('should return true for valid hex chain IDs', () => {
-        expect(isStarknetChainId(STARKNET_MAINNET_CHAIN)).toBe(true);
-        expect(isStarknetChainId(STARKNET_SEPOLIA_CHAIN)).toBe(true);
-      });
-
-      it('should return false for network names (the original bug)', () => {
-        // Network names need to be converted to hex chain IDs
-        expect(isStarknetChainId('SN_MAIN')).toBe(false);
-        expect(isStarknetChainId('SN_SEPOLIA')).toBe(false);
-      });
-    });
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Error Handling
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  describe('Error handling', () => {
-    it('should throw for unknown chain prefix', () => {
-      expect(() => {
-        parseChainIdentifier('unknown:12345' as Chain);
-      }).toThrow('Invalid chain');
-    });
-
-    it('should throw for malformed chain identifier', () => {
-      expect(() => {
-        parseChainIdentifier('not-a-valid-chain' as Chain);
-      }).toThrow('Invalid chain');
-    });
-  });
-});
-

package/src/__tests__/unit/defi/AvailableProtocols.test.ts

@@ -1,100 +0,0 @@
-/**
- * Tests for getAvailableProtocols and getAvailableProtocolsWithMetadata
- *
- * These functions filter DeFi protocols based on environment and asset,
- * using the DEFI_REGISTRY as the source of truth.
- */
-
-import { Env } from '@lombard.finance/sdk-common';
-import { describe, expect, it } from 'vitest';
-
-import { AssetId } from '../../../core/assets';
-import {
-  DefiProtocol,
-  getAvailableProtocols,
-  getAvailableProtocolsWithMetadata,
-} from '../../../defi/defi-registry';
-
-describe('getAvailableProtocols', () => {
-  describe('LBTC protocols', () => {
-    it('should return Veda for LBTC in prod', () => {
-      const protocols = getAvailableProtocols(AssetId.LBTC, Env.prod);
-
-      expect(protocols).toContain(DefiProtocol.Veda);
-      // Silo is only on Avalanche which has no mainnet prod config in DEFI_REGISTRY
-      expect(protocols).not.toContain(DefiProtocol.Silo);
-    });
-
-    it('should return Veda for LBTC in testnet', () => {
-      const protocols = getAvailableProtocols(AssetId.LBTC, Env.testnet);
-
-      expect(protocols).toContain(DefiProtocol.Veda);
-    });
-
-    it('should return Veda for LBTC in stage', () => {
-      const protocols = getAvailableProtocols(AssetId.LBTC, Env.stage);
-
-      expect(protocols).toContain(DefiProtocol.Veda);
-    });
-  });
-
-  describe('BTCb protocols', () => {
-    it('should NOT return Silo for BTCb in prod (Avalanche mainnet not enabled)', () => {
-      const protocols = getAvailableProtocols(AssetId.BTCb, Env.prod);
-
-      // Silo for BTCb is only configured for Env.testnet in DEFI_REGISTRY
-      expect(protocols).not.toContain(DefiProtocol.Silo);
-    });
-
-    it('should return Silo for BTCb in testnet (Avalanche Fuji enabled)', () => {
-      const protocols = getAvailableProtocols(AssetId.BTCb, Env.testnet);
-
-      expect(protocols).toContain(DefiProtocol.Silo);
-    });
-
-    it('should NOT return Silo for BTCb in stage (not configured)', () => {
-      const protocols = getAvailableProtocols(AssetId.BTCb, Env.stage);
-
-      // DEFI_REGISTRY only has Silo BTCb config for testnet, not stage
-      expect(protocols).not.toContain(DefiProtocol.Silo);
-    });
-  });
-
-  describe('unsupported assets', () => {
-    it('should return empty array for unsupported asset', () => {
-      // Using a made-up asset ID that's not in the registry
-      const protocols = getAvailableProtocols('unsupported' as AssetId, Env.prod);
-
-      expect(protocols).toEqual([]);
-    });
-  });
-});
-
-describe('getAvailableProtocolsWithMetadata', () => {
-  it('should return protocol metadata for LBTC in prod', () => {
-    const protocols = getAvailableProtocolsWithMetadata(AssetId.LBTC, Env.prod);
-
-    expect(protocols.length).toBeGreaterThan(0);
-
-    const veda = protocols.find(p => p.value === DefiProtocol.Veda);
-    expect(veda).toBeDefined();
-    expect(veda?.label).toBe('Lombard DeFi Vault');
-    expect(veda?.url).toBe('https://lombard.finance');
-  });
-
-  it('should return Silo metadata for BTCb in testnet', () => {
-    const protocols = getAvailableProtocolsWithMetadata(AssetId.BTCb, Env.testnet);
-
-    const silo = protocols.find(p => p.value === DefiProtocol.Silo);
-    expect(silo).toBeDefined();
-    expect(silo?.label).toBe('Silo Finance Vault');
-    expect(silo?.url).toBe('https://silo.finance');
-  });
-
-  it('should return empty array when no protocols available', () => {
-    // BTCb in prod has no protocols (Silo only on Avalanche, not in prod config)
-    const protocols = getAvailableProtocolsWithMetadata(AssetId.BTCb, Env.prod);
-
-    expect(protocols).toEqual([]);
-  });
-});

package/src/__tests__/unit/defi/DefiRegistry.test.ts

@@ -1,25 +0,0 @@
-import { Env } from '@lombard.finance/sdk-common';
-import { describe, expect,it } from 'vitest';
-
-import { DEFI_REGISTRY, DefiProtocol } from '../../../defi/defi-registry';
-import { Token } from '../../../tokens/token-addresses';
-
-describe('DEFI_REGISTRY', () => {
-  it('should have Veda protocol with LBTC support', () => {
-    expect(DEFI_REGISTRY[DefiProtocol.Veda]).toBeDefined();
-    expect(DEFI_REGISTRY[DefiProtocol.Veda][Token.LBTC]).toBeDefined();
-  });
-
-  it('should have Silo only on testnet for BTCb', () => {
-    // Silo is defined for BTCb
-    const siloBtcb = DEFI_REGISTRY[DefiProtocol.Silo][Token.BTCb];
-    expect(siloBtcb).toBeDefined();
-
-    // Check testnet support
-    expect(siloBtcb?.[Env.testnet]).toBeDefined();
-
-    // Check prod support (should be undefined based on current implementation)
-    expect(siloBtcb?.[Env.prod]).toBeUndefined();
-  });
-});
-

package/src/__tests__/unit/evm/EvmDeploy.test.ts

@@ -1,224 +0,0 @@
-/**
- * EVM Deploy Action Unit Tests
- *
- * Tests the LBTC → DeFi vault deployment flow on EVM chains.
- *
- * @module __tests__/unit/evm/EvmDeploy.test.ts
- */
-
-import { describe, expect, it, vi } from 'vitest';
-
-import { AssetId, Chain } from '../../../core';
-import { LombardError, ValidationErrorCode } from '../../../shared/errors';
-
-describe('EvmDeploy Interface', () => {
-  describe('EvmDeployParams', () => {
-    it('should require LBTC as input asset', () => {
-      const params = {
-        assetIn: AssetId.LBTC,
-        sourceChain: Chain.ETHEREUM,
-        protocol: 'veda',
-        vault: 'LBTC',
-      };
-
-      expect(params.assetIn).toBe(AssetId.LBTC);
-    });
-
-    it('should require protocol selection', () => {
-      const params = {
-        assetIn: AssetId.LBTC,
-        sourceChain: Chain.ETHEREUM,
-        protocol: 'veda',
-        vault: 'LBTC',
-      };
-
-      expect(params.protocol).toBe('veda');
-    });
-
-    it('should require vault selection', () => {
-      const params = {
-        assetIn: AssetId.LBTC,
-        sourceChain: Chain.ETHEREUM,
-        protocol: 'veda',
-        vault: 'LBTC',
-      };
-
-      expect(params.vault).toBe('LBTC');
-    });
-
-    it('should support multiple protocols', () => {
-      const protocols = ['corn-silo', 'euler-lbtc', 'aave', 'morpho', 'pendle'];
-      
-      protocols.forEach(protocol => {
-        expect(typeof protocol).toBe('string');
-      });
-    });
-
-    it('should support multiple chains', () => {
-      const chains = [
-        Chain.ETHEREUM,
-        Chain.BASE,
-        Chain.BSC,
-        Chain.SEPOLIA,
-      ];
-
-      chains.forEach(chain => {
-        expect(typeof chain).toBe('string');
-      });
-    });
-  });
-
-  describe('EvmDeployPrepareParams', () => {
-    it('should accept valid prepare parameters', () => {
-      const params = {
-        amount: '0.1',
-      };
-
-      expect(params.amount).toBe('0.1');
-    });
-
-    it('should support optional recipient', () => {
-      const params = {
-        amount: '0.1',
-        recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
-      };
-
-      expect(params.recipient).toBeDefined();
-    });
-  });
-
-  describe('Status Transitions', () => {
-    it('should define all required status values', () => {
-      const statuses = [
-        'idle',
-        'needs-approval',
-        'ready',
-        'completed',
-      ];
-
-      statuses.forEach(status => {
-        expect(typeof status).toBe('string');
-      });
-    });
-  });
-
-  describe('Method Signatures', () => {
-    it('should define prepare method', () => {
-      type PrepareMethod = (params: { amount: string }) => Promise<void>;
-      const testType: PrepareMethod = async () => {};
-      expect(testType).toBeDefined();
-    });
-
-    it('should define approve method', () => {
-      type ApproveMethod = () => Promise<void>;
-      const testType: ApproveMethod = async () => {};
-      expect(testType).toBeDefined();
-    });
-
-    it('should define execute method', () => {
-      type ExecuteMethod = () => Promise<{ txHash: string }>;
-      const testType: ExecuteMethod = async () => ({ txHash: '0x123' });
-      expect(testType).toBeDefined();
-    });
-  });
-
-  describe('Protocol Integration', () => {
-    it('should support DeFi protocols from registry', () => {
-      const protocolTypes = ['lending', 'yield', 'liquidity'];
-      
-      protocolTypes.forEach(type => {
-        expect(typeof type).toBe('string');
-      });
-    });
-
-    it('should validate vault exists for protocol', () => {
-      const protocol = 'corn-silo';
-      const vault = 'LBTC';
-      
-      expect(protocol).toBeDefined();
-      expect(vault).toBeDefined();
-    });
-  });
-
-  describe('Token Approval', () => {
-    it('should require LBTC approval before deployment', () => {
-      const approvalRequired = true;
-      expect(approvalRequired).toBe(true);
-    });
-
-    it('should approve to vault contract address', () => {
-      const vaultAddress = '0x1234567890abcdef1234567890abcdef12345678';
-      expect(vaultAddress).toMatch(/^0x/);
-    });
-  });
-
-  describe('Error Handling', () => {
-    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 reject unsupported vaults', () => {
-      const error = new LombardError(
-        ValidationErrorCode.INVALID_PARAMETER,
-        `Vault invalid-vault is not available for protocol corn-silo.`,
-      );
-
-      expect(error.code).toBe(ValidationErrorCode.INVALID_PARAMETER);
-    });
-
-    it('should reject chains without protocol support', () => {
-      const error = new LombardError(
-        ValidationErrorCode.INVALID_CHAIN,
-        `Protocol corn-silo is not available on avalanche.`,
-      );
-
-      expect(error.code).toBe(ValidationErrorCode.INVALID_CHAIN);
-    });
-
-    it('should handle insufficient LBTC balance', () => {
-      const error = new LombardError(
-        ValidationErrorCode.INVALID_PARAMETER,
-        `Insufficient LBTC balance for deployment.`,
-      );
-
-      expect(error.message).toContain('Insufficient');
-    });
-  });
-
-  describe('Event Emissions', () => {
-    it('should emit progress events', () => {
-      const handler = vi.fn((progress: { status: string; txHash?: string }) => {
-        expect(progress.status).toBeDefined();
-      });
-
-      handler({ status: 'completed', txHash: '0x123' });
-      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');
-    });
-
-    it('should expose status property', () => {
-      type HasStatus = { readonly status: string };
-      const obj: HasStatus = { status: 'idle' };
-      expect(obj.status).toBe('idle');
-    });
-  });
-});
-