@lombard.finance/sdk 3.7.4 → 4.0.0

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

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

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

@@ -0,0 +1,25 @@
+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

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