@lombard.finance/sdk 3.7.4 → 4.0.0

package/src/__tests__/unit/catalog/AssetCatalog.test.ts

@@ -0,0 +1,293 @@
+/**
+ * Asset Catalog Tests
+ *
+ * Tests to verify the ASSET_CATALOG has correct chain configurations.
+ *
+ * Related Issues:
+ * - APP-1971: Fuji should be available for LBTC staking
+ * - APP-1975: Holesky should NOT be available (deprecated)
+ * - APP-1980: Berachain Bartio should NOT be available (not implemented)
+ * - APP-1983: Base Sepolia should be available for BTC Stake
+ *
+ * @module __tests__/unit/catalog/AssetCatalog.test.ts
+ */
+
+import { Env } from '@lombard.finance/sdk-common';
+import { describe, expect, it } from 'vitest';
+
+import { featureConfig } from '../../../common/feature-config';
+import { ASSET_CATALOG, AssetId, Chain, getAssetChains } from '../../../core';
+
+describe('Asset Catalog', () => {
+  // ═══════════════════════════════════════════════════════════════════════════
+  // LBTC Deployments
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('LBTC deployments', () => {
+    describe('Testnet environment', () => {
+      it('should include Avalanche Fuji (APP-1971)', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.testnet);
+        expect(chains).toContain(Chain.AVALANCHE_FUJI);
+      });
+
+      it('should include Base Sepolia (APP-1983)', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.testnet);
+        expect(chains).toContain(Chain.BASE_SEPOLIA);
+      });
+
+      it('should include Sepolia', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.testnet);
+        expect(chains).toContain(Chain.SEPOLIA);
+      });
+
+      it('should NOT include Holesky (APP-1975 - deprecated)', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.testnet);
+        // Holesky was removed from testnet
+        expect(chains).not.toContain(Chain.HOLESKY);
+      });
+
+      it('should NOT include Berachain Bartio (APP-1980 - not implemented)', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.testnet);
+        expect(chains).not.toContain(Chain.BERACHAIN_BARTIO);
+      });
+
+      it('should NOT include Sonic (APP-2009)', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.testnet);
+        expect(chains).not.toContain(Chain.SONIC);
+      });
+    });
+
+    describe('Stage environment', () => {
+      it('should NOT include Avalanche Fuji (stage uses testnet only)', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.stage);
+        expect(chains).not.toContain(Chain.AVALANCHE_FUJI);
+      });
+
+      it('should include Base Sepolia', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.stage);
+        expect(chains).toContain(Chain.BASE_SEPOLIA);
+      });
+
+      it('should NOT include Holesky', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.stage);
+        expect(chains).not.toContain(Chain.HOLESKY);
+      });
+
+      it('should NOT include Berachain Bartio', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.stage);
+        expect(chains).not.toContain(Chain.BERACHAIN_BARTIO);
+      });
+
+      it('should NOT include Sonic (APP-2009)', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.stage);
+        expect(chains).not.toContain(Chain.SONIC);
+      });
+    });
+
+    describe('Production environment', () => {
+      it('should include Ethereum mainnet', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.prod);
+        expect(chains).toContain(Chain.ETHEREUM);
+      });
+
+      it('should include Base', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.prod);
+        expect(chains).toContain(Chain.BASE);
+      });
+
+      it('should include Stable (APP-1970)', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.prod);
+        expect(chains).toContain(Chain.STABLE);
+      });
+
+      it('should include Monad when enabled (APP-1970)', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.prod);
+        if (featureConfig.isMonadEnabled) {
+          expect(chains).toContain(Chain.MONAD);
+        } else {
+          expect(chains).not.toContain(Chain.MONAD);
+        }
+      });
+
+      it('should NOT include any testnet chains', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.prod);
+        expect(chains).not.toContain(Chain.SEPOLIA);
+        expect(chains).not.toContain(Chain.HOLESKY);
+        expect(chains).not.toContain(Chain.BASE_SEPOLIA);
+        expect(chains).not.toContain(Chain.AVALANCHE_FUJI);
+      });
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // BTC.b Deployments
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('BTC.b deployments', () => {
+    it('should include Avalanche mainnet in production', () => {
+      const chains = getAssetChains(AssetId.BTCb, Env.prod);
+      expect(chains).toContain(Chain.AVALANCHE);
+    });
+
+    it('should include Stable in production (APP-1970)', () => {
+      const chains = getAssetChains(AssetId.BTCb, Env.prod);
+      expect(chains).toContain(Chain.STABLE);
+    });
+
+    it('should include Monad when enabled (APP-1970)', () => {
+      const chains = getAssetChains(AssetId.BTCb, Env.prod);
+      if (featureConfig.isMonadEnabled) {
+        expect(chains).toContain(Chain.MONAD);
+      } else {
+        expect(chains).not.toContain(Chain.MONAD);
+      }
+    });
+
+    it('should include Avalanche Fuji in testnet', () => {
+      const chains = getAssetChains(AssetId.BTCb, Env.testnet);
+      expect(chains).toContain(Chain.AVALANCHE_FUJI);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Catalog Structure
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('Catalog structure', () => {
+    it('should have a version string', () => {
+      expect(ASSET_CATALOG.version).toBeDefined();
+      expect(typeof ASSET_CATALOG.version).toBe('string');
+    });
+
+    it('should have LBTC asset defined', () => {
+      expect(ASSET_CATALOG.assets[AssetId.LBTC]).toBeDefined();
+    });
+
+    it('should have BTCb asset defined', () => {
+      expect(ASSET_CATALOG.assets[AssetId.BTCb]).toBeDefined();
+    });
+
+    it('should have correct decimals for LBTC', () => {
+      expect(ASSET_CATALOG.assets[AssetId.LBTC]?.decimals).toBe(8);
+    });
+
+    it('should have correct decimals for BTC.b', () => {
+      expect(ASSET_CATALOG.assets[AssetId.BTCb]?.decimals).toBe(8);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Regression Prevention
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('Regression prevention', () => {
+    it('testnet LBTC should have at least 3 chains', () => {
+      const chains = getAssetChains(AssetId.LBTC, Env.testnet);
+      expect(chains.length).toBeGreaterThanOrEqual(3);
+    });
+
+    it('stage LBTC should have at least 3 chains', () => {
+      const chains = getAssetChains(AssetId.LBTC, Env.stage);
+      expect(chains.length).toBeGreaterThanOrEqual(3);
+    });
+
+    it('production LBTC should have multiple chains', () => {
+      const chains = getAssetChains(AssetId.LBTC, Env.prod);
+      expect(chains.length).toBeGreaterThan(1);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // APP-1991: Unstaking chains should include Solana, Sui, and Fuji
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('Unstaking chains availability (APP-1991)', () => {
+    describe('Testnet environment', () => {
+      it('should include Solana Testnet for LBTC unstaking', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.testnet);
+        expect(chains).toContain(Chain.SOLANA_TESTNET);
+      });
+
+      it('should include Sui Testnet for LBTC unstaking', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.testnet);
+        expect(chains).toContain(Chain.SUI_TESTNET);
+      });
+
+      it('should include Avalanche Fuji for LBTC unstaking', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.testnet);
+        expect(chains).toContain(Chain.AVALANCHE_FUJI);
+      });
+    });
+
+    describe('Stage environment', () => {
+      it('should include Solana Devnet for LBTC unstaking', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.stage);
+        expect(chains).toContain(Chain.SOLANA_DEVNET);
+      });
+
+      it('should include Sui Testnet for LBTC unstaking', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.stage);
+        expect(chains).toContain(Chain.SUI_TESTNET);
+      });
+
+      it('should NOT include Avalanche Fuji for LBTC unstaking', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.stage);
+        expect(chains).not.toContain(Chain.AVALANCHE_FUJI);
+      });
+    });
+
+    describe('Production environment', () => {
+      it('should include Solana Mainnet for LBTC unstaking', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.prod);
+        expect(chains).toContain(Chain.SOLANA_MAINNET);
+      });
+
+      it('should include Sui Mainnet for LBTC unstaking', () => {
+        const chains = getAssetChains(AssetId.LBTC, Env.prod);
+        expect(chains).toContain(Chain.SUI_MAINNET);
+      });
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // APP-1970: LBTC prod should include Monad and Stable networks
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('Monad and Stable networks (APP-1970)', () => {
+    it('should include Monad in LBTC production', () => {
+      const chains = getAssetChains(AssetId.LBTC, Env.prod);
+      expect(chains).toContain(Chain.MONAD);
+    });
+
+    it('should include Stable in LBTC production', () => {
+      const chains = getAssetChains(AssetId.LBTC, Env.prod);
+      expect(chains).toContain(Chain.STABLE);
+    });
+
+    it('should include Monad in BTC.b production', () => {
+      const chains = getAssetChains(AssetId.BTCb, Env.prod);
+      expect(chains).toContain(Chain.MONAD);
+    });
+
+    it('should include Stable in BTC.b production', () => {
+      const chains = getAssetChains(AssetId.BTCb, Env.prod);
+      expect(chains).toContain(Chain.STABLE);
+    });
+  });
+});
+
+describe('Asset Catalog Resolution', () => {
+  it.skip('should fallback to bundled catalog on API failure', async () => {
+    // Implementation pending: Asset Catalog is not yet implemented in SDK.
+    // This test serves as a placeholder for when loadAssetCatalog is available.
+    /*
+    vi.spyOn(global, 'fetch').mockRejectedValue(new Error('API Down'));
+    
+    const catalog = await loadAssetCatalog({ env: Env.prod });
+    
+    expect(catalog).toBeDefined();
+    expect(catalog.version).toBe(BUNDLED_CATALOG.version);
+    */
+  });
+});
+

package/src/__tests__/unit/config/ChainConfig.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect,it } from 'vitest';
+
+import { getChainConfig } from '../../../chains/btc/actions/stake/config';
+import { Chain } from '../../../core';
+
+describe('ChainConfig', () => {
+  it('should return EVM config for EVM chain type', () => {
+    const config = getChainConfig('evm');
+    expect(config).toBeDefined();
+    expect(config?.chainType).toBe('evm');
+    expect(config?.destChains).toContain(Chain.ETHEREUM);
+  });
+
+  it('should return Solana config for Solana chain type', () => {
+    const config = getChainConfig('solana');
+    expect(config).toBeDefined();
+    expect(config?.chainType).toBe('solana');
+  });
+
+  it('should return undefined for invalid chain type', () => {
+    // @ts-expect-error Testing invalid input
+    const config = getChainConfig('invalid');
+    expect(config).toBeUndefined();
+  });
+
+  describe('Address Validation', () => {
+    it('should validate EVM addresses', () => {
+      const config = getChainConfig('evm');
+      const validAddr = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0';
+      const invalidAddr = 'invalid';
+
+      expect(() => config?.addressSchema.parse(validAddr)).not.toThrow();
+      expect(() => config?.addressSchema.parse(invalidAddr)).toThrow();
+    });
+
+    it('should validate Solana addresses', () => {
+      const config = getChainConfig('solana');
+      // A valid base58 address
+      const validAddr = '5U3bH5b6XtG99aV6ce2ifLkLXLkHeHuAy46sDjr9Gf3C'; 
+      const invalidAddr = 'invalid';
+
+      expect(() => config?.addressSchema.parse(validAddr)).not.toThrow();
+      expect(() => config?.addressSchema.parse(invalidAddr)).toThrow();
+    });
+  });
+});
+

package/src/__tests__/unit/config/FeeAuthConfig.test.ts

@@ -0,0 +1,76 @@
+import { Env } from '@lombard.finance/sdk-common';
+import { describe, expect, it, vi } from 'vitest';
+
+import { getChainConfig } from '../../../chains/btc/actions/stake/config';
+import { ChainId } from '../../../common/chains';
+import { Chain } from '../../../core';
+import { EvmService } from '../../../services/EvmService';
+import { BtcCoreContext } from '../../../shared/context';
+
+// Mock context
+const mockEvm = {
+  signNetworkFee: vi.fn().mockResolvedValue({
+    signature: '0xsig',
+    typedData: {},
+  }),
+  getMintingFee: vi.fn().mockResolvedValue('0.00001992'),
+} as unknown as EvmService;
+
+const mockCtx = {
+  capabilities: {
+    require: (id: string) => {
+      if (id === 'evm') return mockEvm;
+      throw new Error(`Capability ${id} not found`);
+    },
+  },
+  api: {
+    getFeeSignature: vi.fn().mockResolvedValue({}),
+    storeFeeSignature: vi.fn(),
+  },
+  getProvider: vi.fn().mockResolvedValue({
+    request: vi.fn().mockResolvedValue('0x1'), // Mock chainId response
+  }),
+  // Use prod env to match ChainId.ethereum (LBTC contract exists on mainnet in prod)
+  env: Env.prod,
+} as unknown as BtcCoreContext;
+
+describe('FeeAuthConfig', () => {
+  const evmConfig = getChainConfig('evm');
+
+  it('should return FeeAuthConfig for Ethereum mainnet', () => {
+    const feeAuth = evmConfig?.getFeeAuthConfig(Chain.ETHEREUM);
+    
+    expect(feeAuth).not.toBeNull();
+    expect(feeAuth?.getMintingFee).toBeDefined();
+    expect(feeAuth?.authorizeFee).toBeDefined();
+  });
+
+  it('should return null FeeAuthConfig for non-Ethereum EVM chains', () => {
+    const feeAuth = evmConfig?.getFeeAuthConfig(Chain.BASE);
+    
+    expect(feeAuth).toBeNull();
+  });
+
+  describe('authorizeFee', () => {
+    it('should convert fee to satoshis before signing', async () => {
+      const feeAuth = evmConfig?.getFeeAuthConfig(Chain.ETHEREUM);
+      expect(feeAuth).toBeDefined();
+
+      if (!feeAuth) return;
+
+      await feeAuth.authorizeFee(mockCtx, {
+        chainId: ChainId.ethereum,
+        recipient: '0x123',
+        fee: '0.00001992', // BTC decimal
+      });
+
+      // Check if signNetworkFee was called with satoshis (1992)
+      expect(mockEvm.signNetworkFee).toHaveBeenCalledWith(
+        expect.objectContaining({
+          fee: '1992', // Converted to satoshis
+        }),
+      );
+    });
+  });
+});
+

package/src/__tests__/unit/contract-functions/getLBTCMintingFee.test.ts

@@ -0,0 +1,128 @@
+/**
+ * LBTC Minting Fee Tests
+ *
+ * Tests to verify the fee fetching logic works correctly.
+ * 
+ * The minting fee (also called "network fee" or "auto-mint fee") is the amount
+ * in satoshis that is deducted from the minted LBTC to compensate Lombard for
+ * paying the EVM gas costs during the auto-mint process.
+ *
+ * Fee Structure:
+ * - Non-subsidized chains (Ethereum, Sepolia): Have non-zero fees
+ * - Subsidized chains (Base, BSC): Have 0 fees (Lombard absorbs gas costs)
+ *
+ * The fee is read from the on-chain AssetRouter.maxMintCommission() function.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { Token } from '../../../tokens/token-addresses';
+import { fromSatoshi, toSatoshi } from '../../../utils/satoshi';
+
+describe('Minting Fee Logic', () => {
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Satoshi Conversion Tests
+  // These are the underlying conversion functions used by getMintingFee
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('fromSatoshi conversion', () => {
+    it('should convert 0 satoshis to 0 BTC', () => {
+      const btc = fromSatoshi('0');
+      expect(btc.toNumber()).toBe(0);
+      expect(btc.toString()).toBe('0');
+    });
+
+    it('should convert 38 satoshis to 0.00000038 BTC', () => {
+      // This is the actual Ethereum mainnet fee
+      const btc = fromSatoshi('38');
+      expect(btc.toNumber()).toBeCloseTo(0.00000038, 10);
+    });
+
+    it('should convert 1992 satoshis to 0.00001992 BTC', () => {
+      // Example fee value
+      const btc = fromSatoshi('1992');
+      expect(btc.toNumber()).toBeCloseTo(0.00001992, 10);
+    });
+
+    it('should convert 100000000 satoshis to 1 BTC', () => {
+      const btc = fromSatoshi('100000000');
+      expect(btc.toNumber()).toBe(1);
+    });
+  });
+
+  describe('toSatoshi conversion', () => {
+    it('should convert 0 BTC to 0 satoshis', () => {
+      const sats = toSatoshi('0');
+      expect(sats.toNumber()).toBe(0);
+    });
+
+    it('should convert 0.00000038 BTC to 38 satoshis', () => {
+      const sats = toSatoshi('0.00000038');
+      expect(sats.toNumber()).toBe(38);
+    });
+
+    it('should convert 1 BTC to 100000000 satoshis', () => {
+      const sats = toSatoshi('1');
+      expect(sats.toNumber()).toBe(100000000);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Token Support
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('Supported tokens', () => {
+    it('should have LBTC token defined', () => {
+      expect(Token.LBTC).toBe('LBTC');
+    });
+
+    it('should have BTCb token defined', () => {
+      expect(Token.BTCb).toBe('BTC.b');
+    });
+
+    it('should have BTCK token defined', () => {
+      expect(Token.BTCK).toBe('BTCK');
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Fee Behavior Documentation
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('Expected fee behavior (documentation)', () => {
+    /**
+     * The minting fee is the auto-mint commission in satoshis.
+     * 
+     * When a user deposits BTC, Lombard automatically mints LBTC to their address.
+     * The fee compensates Lombard for paying the EVM gas costs.
+     *
+     * Non-subsidized chains (Ethereum, Sepolia): Have fees configured on-chain
+     * Subsidized chains (Base, BSC): Lombard absorbs gas costs, fee = 0
+     */
+
+    it('should document fee structure', () => {
+      // Ethereum mainnet always has a fee (unsubsidized)
+      const ethereumMainnetFee = 36; // satoshis
+      expect(ethereumMainnetFee).toBeGreaterThan(0);
+
+      // Sepolia (stage) has fee configured
+      const sepoliaStageFee = 1433; // satoshis
+      expect(sepoliaStageFee).toBeGreaterThan(0);
+
+      // Base is subsidized by design
+      const baseFee = 0;
+      expect(baseFee).toBe(0);
+    });
+
+    it('should document which chains are subsidized vs non-subsidized', () => {
+      // Subsidized chains (fee = 0 by design, Lombard pays gas)
+      const subsidizedChains = ['Base', 'BSC'];
+
+      // Non-subsidized chains (fee charged to user in LBTC)
+      const nonSubsidizedChains = ['Ethereum Mainnet', 'Sepolia'];
+
+      expect(subsidizedChains.length).toBeGreaterThan(0);
+      expect(nonSubsidizedChains.length).toBeGreaterThan(0);
+    });
+  });
+});