@lombard.finance/sdk 4.0.0 → 4.1.2

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

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

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

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

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