@lombard.finance/sdk 3.7.4 → 4.0.0

package/src/__tests__/AssetNamespace.spec.ts

@@ -0,0 +1,234 @@
+/**
+ * AssetNamespace Tests
+ *
+ * Tests the new namespaced asset API
+ */
+
+import { Env } from '@lombard.finance/sdk-common';
+import { describe, expect, it } from 'vitest';
+
+import { LombardSDK } from '../client/LombardSDK';
+import { AssetId, Chain } from '../core';
+import { createTestConfig } from './helpers/createTestConfig';
+
+describe('AssetNamespace', () => {
+  describe('SDK Integration', () => {
+    it('should be accessible via sdk.assets', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      expect(sdk.assets).toBeDefined();
+    });
+
+    it('should respect SDK environment', () => {
+      const prodSdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const testnetSdk = new LombardSDK(createTestConfig({ env: Env.testnet }));
+
+      const prodAddress = prodSdk.assets.getAddress(
+        AssetId.LBTC,
+        Chain.ETHEREUM,
+      );
+      const testnetAddress = testnetSdk.assets.getAddress(
+        AssetId.LBTC,
+        Chain.SEPOLIA,
+      );
+
+      expect(prodAddress).toBe('0x8236a87084f8b84306f72007f36f2618a5634494');
+      expect(testnetAddress).toBe('0xc47e4b3124597fdf8dd07843d4a7052f2ee80c30');
+    });
+  });
+
+  describe('getConfig', () => {
+    it('should return config with specific type inference', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      expect(sdk.assets.getAddress(AssetId.LBTC, Chain.ETHEREUM)).toBe(
+        '0x8236a87084f8b84306f72007f36f2618a5634494',
+      );
+      expect(sdk.assets.getDecimals(AssetId.LBTC)).toBe(8);
+      // EVM chains don't use asset router - only Starknet does
+      expect(sdk.assets.usesAssetRouter(AssetId.LBTC, Chain.ETHEREUM)).toBe(
+        false,
+      );
+    });
+
+    it('should return undefined for non-deployed asset', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      expect(
+        sdk.assets.getAddress(AssetId.LBTC, Chain.SEPOLIA),
+      ).toBeUndefined();
+    });
+  });
+
+  describe('getAddress', () => {
+    it('should return token address', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const address = sdk.assets.getAddress(AssetId.LBTC, Chain.ETHEREUM);
+
+      expect(address).toBe('0x8236a87084f8b84306f72007f36f2618a5634494');
+    });
+
+    it('should return undefined for non-deployed asset', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const address = sdk.assets.getAddress(AssetId.LBTC, Chain.SEPOLIA);
+
+      expect(address).toBeUndefined();
+    });
+  });
+
+  describe('getDecimals', () => {
+    it('should return token decimals', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      expect(sdk.assets.getDecimals(AssetId.LBTC)).toBe(8);
+    });
+
+    it('should return 8 for non-deployed asset (default)', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      expect(sdk.assets.getDecimals(AssetId.LBTC)).toBe(8);
+    });
+  });
+
+  describe('usesAssetRouter', () => {
+    it('should return true for LBTC on Starknet (has asset router)', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const usesRouter = sdk.assets.usesAssetRouter(
+        AssetId.LBTC,
+        Chain.STARKNET_MAINNET,
+      );
+
+      expect(usesRouter).toBe(true);
+    });
+
+    it('should return false for LBTC on Ethereum (no asset router)', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const usesRouter = sdk.assets.usesAssetRouter(
+        AssetId.LBTC,
+        Chain.ETHEREUM,
+      );
+
+      expect(usesRouter).toBe(false);
+    });
+  });
+
+  describe('getAssetRouter', () => {
+    it('should return asset router for Starknet mainnet', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const router = sdk.assets.getAssetRouter(
+        AssetId.LBTC,
+        Chain.STARKNET_MAINNET,
+      );
+
+      expect(router).toBe(
+        '0x05b1886d0f844ab930fc0ee066f1655a873437f15a5d2c41ee3e884fd5299976',
+      );
+    });
+
+    it('should return undefined for EVM chains', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const router = sdk.assets.getAssetRouter(AssetId.LBTC, Chain.ETHEREUM);
+
+      expect(router).toBeUndefined();
+    });
+  });
+
+  describe('getBridgeAdapter', () => {
+    it('should return bridge adapter for BTCb on Avalanche Fuji', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.dev }));
+      const adapter = sdk.assets.getBridgeAdapter(
+        AssetId.BTCb,
+        Chain.AVALANCHE_FUJI,
+      );
+
+      expect(adapter).toBe('0x0A65C37d07c32E5eA8ea40495b7f249cdE26935e');
+    });
+
+    it('should return undefined for assets without bridge adapter', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const adapter = sdk.assets.getBridgeAdapter(AssetId.LBTC, Chain.ETHEREUM);
+
+      expect(adapter).toBeUndefined();
+    });
+  });
+
+  describe('getByAddress', () => {
+    it('should find asset by address (reverse lookup)', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const asset = sdk.assets.getByAddress(
+        '0x8236a87084f8b84306f72007f36f2618a5634494',
+        Chain.ETHEREUM,
+      );
+
+      expect(asset).toBe(AssetId.LBTC);
+    });
+
+    it('should return undefined for unknown address', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const asset = sdk.assets.getByAddress('0x1234567890', Chain.ETHEREUM);
+
+      expect(asset).toBeUndefined();
+    });
+  });
+
+  describe('isDeployed', () => {
+    it('should return true for deployed asset', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const deployed = sdk.assets.isDeployed(AssetId.LBTC, Chain.ETHEREUM);
+
+      expect(deployed).toBe(true);
+    });
+
+    it('should return false for non-deployed asset', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const deployed = sdk.assets.isDeployed(AssetId.LBTC, Chain.SEPOLIA);
+
+      expect(deployed).toBe(false);
+    });
+  });
+
+  describe('getChains', () => {
+    it('should return all chains where LBTC is deployed in prod', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const chains = sdk.assets.getChains(AssetId.LBTC);
+
+      expect(chains).toContain(Chain.ETHEREUM);
+      expect(chains).toContain(Chain.BASE);
+      expect(chains).toContain(Chain.BSC);
+      expect(chains).toContain(Chain.SOLANA_MAINNET);
+      expect(chains.length).toBeGreaterThan(5);
+    });
+  });
+
+  describe('getEnvironments', () => {
+    it('should return all environments where LBTC is deployed on Ethereum', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const envs = sdk.assets.getEnvironments(AssetId.LBTC, Chain.ETHEREUM);
+
+      expect(envs).toContain(Env.prod);
+      expect(envs.length).toBe(1); // Only prod on Ethereum mainnet
+    });
+
+    it('should return multiple environments for Sepolia', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const envs = sdk.assets.getEnvironments(AssetId.LBTC, Chain.SEPOLIA);
+
+      expect(envs).toContain(Env.testnet);
+      expect(envs).toContain(Env.stage);
+      expect(envs).toContain(Env.dev);
+    });
+  });
+
+  describe('registry', () => {
+    it('should provide direct registry access', () => {
+      const sdk = new LombardSDK(createTestConfig({ env: Env.prod }));
+      const catalog = sdk.assets.getCatalog();
+
+      // Catalog structure: { version, assets: { [AssetId]: AssetEntry } }
+      expect(catalog.version).toBeDefined();
+      expect(catalog.assets).toBeDefined();
+      expect(Object.keys(catalog.assets)).toContain(AssetId.LBTC);
+
+      const asset = catalog.assets[AssetId.LBTC];
+      expect(asset).toBeDefined();
+      expect(asset?.decimals).toBe(8);
+      expect(asset?.deployments).toBeDefined();
+      expect(asset?.deployments.length).toBeGreaterThan(0);
+    });
+  });
+});

package/src/__tests__/helpers/createTestConfig.ts

@@ -0,0 +1,90 @@
+/**
+ * Test Configuration Helper
+ *
+ * Provides a synchronous config creation for tests.
+ * Uses bundled catalog directly to avoid async in test setup.
+ *
+ * @module __tests__/helpers/createTestConfig
+ */
+
+import type { AnyModule, ProviderKey } from '@lombard.finance/sdk-common';
+
+import type {
+  CreateConfigOptions,
+  ResolvedLombardConfig,
+} from '../../config/types';
+import { ASSET_CATALOG } from '../../core/assets/catalog';
+import { apiModule } from '../../modules/apiModule';
+import { btcModule } from '../../modules/btcModule';
+import { evmModule } from '../../modules/evmModule';
+import { LombardError } from '../../shared/errors';
+
+function mergeModules(provided: readonly AnyModule[] | undefined): AnyModule[] {
+  const modules = new Map<string, AnyModule>();
+  const builtIns: AnyModule[] = [btcModule(), evmModule(), apiModule()];
+  for (const mod of builtIns) {
+    modules.set(mod.id, mod);
+  }
+  if (provided) {
+    for (const mod of provided) {
+      modules.set(mod.id, mod);
+    }
+  }
+  return Array.from(modules.values());
+}
+
+function hasProvider(
+  config: Pick<ResolvedLombardConfig, 'providers'>,
+  key: ProviderKey,
+): boolean {
+  return Boolean(config.providers?.[key]);
+}
+
+function ensureProviders(
+  modules: readonly AnyModule[],
+  config: Pick<ResolvedLombardConfig, 'providers'>,
+): void {
+  for (const mod of modules) {
+    for (const key of mod.requiresProviders ?? []) {
+      if (!hasProvider(config, key)) {
+        throw LombardError.providerMissing(key, key);
+      }
+    }
+  }
+}
+
+/**
+ * Create SDK config synchronously for tests
+ *
+ * This creates a ResolvedLombardConfig with the bundled catalog directly.
+ * Only use this in tests - production code should use createLombardSDK().
+ *
+ * @param options - Configuration options
+ * @returns ResolvedLombardConfig with bundled catalog
+ */
+export function createTestConfig(
+  options: CreateConfigOptions,
+): ResolvedLombardConfig {
+  if (!options.env) {
+    throw LombardError.missingParameter('env');
+  }
+
+  const modules = mergeModules(
+    options.modules as readonly AnyModule[] | undefined,
+  );
+
+  const config: ResolvedLombardConfig = {
+    env: options.env,
+    providers: options.providers || {},
+    modules,
+    catalog: ASSET_CATALOG,
+  };
+
+  if (options.partner) {
+    config.partner = options.partner;
+  }
+
+  ensureProviders(modules, config);
+
+  return config;
+}

package/src/__tests__/integration/automint-fee.integration.test.ts

@@ -0,0 +1,74 @@
+/**
+ * Automint Fee Contract Read Verification
+ *
+ * Validates that automint fees are non-zero where expected using read-only
+ * contract calls (no signing or funds required).
+ *
+ * @module __tests__/integration/automint-fee.integration.test.ts
+ */
+
+import { Env } from '@lombard.finance/sdk-common';
+import BigNumber from 'bignumber.js';
+import { describe, expect, it } from 'vitest';
+
+import { ChainId } from '../../common/chains';
+import { getMintingFee } from '../../contract-functions/getLBTCMintingFee/getLBTCMintingFee';
+import { Token,TOKEN_ADDRESSES } from '../../tokens/token-addresses';
+
+const RUN_CONTRACT_CHECKS = process.env.ENABLE_CONTRACT_CHECKS === 'true';
+const runIfEnabled = RUN_CONTRACT_CHECKS ? describe : describe.skip;
+
+const TIMEOUT = 90_000;
+
+function expectNonZeroFee(fee: BigNumber, label: string) {
+  expect(fee.isGreaterThan(0), `${label} should be > 0 BTC`).toBe(true);
+}
+
+function hasTokenAddress(token: Token, chainId: ChainId, env: Env): boolean {
+  const entry = TOKEN_ADDRESSES[token]?.[env]?.[chainId];
+  return Boolean(entry);
+}
+
+runIfEnabled('Automint Fee Contract Reads', () => {
+  it(
+    'returns non-zero LBTC minting fee on Sepolia stage and Ethereum prod',
+    async () => {
+      if (hasTokenAddress(Token.LBTC, ChainId.sepolia, Env.stage)) {
+        const sepoliaStageFee = await getMintingFee({
+          token: Token.LBTC,
+          chainId: ChainId.sepolia,
+          env: Env.stage,
+        });
+        expectNonZeroFee(sepoliaStageFee, 'Sepolia (stage) LBTC');
+      }
+
+      if (hasTokenAddress(Token.LBTC, ChainId.ethereum, Env.prod)) {
+        const ethereumProdFee = await getMintingFee({
+          token: Token.LBTC,
+          chainId: ChainId.ethereum,
+          env: Env.prod,
+        });
+        expectNonZeroFee(ethereumProdFee, 'Ethereum (prod) LBTC');
+      }
+    },
+    TIMEOUT,
+  );
+
+  it(
+    'returns non-zero BTC.b minting fee on Sepolia stage when configured',
+    async () => {
+      if (!hasTokenAddress(Token.BTCb, ChainId.sepolia, Env.stage)) {
+        return;
+      }
+
+      const sepoliaStageFee = await getMintingFee({
+        token: Token.BTCb,
+        chainId: ChainId.sepolia,
+        env: Env.stage,
+      });
+
+      expectNonZeroFee(sepoliaStageFee, 'Sepolia (stage) BTC.b');
+    },
+    TIMEOUT,
+  );
+});

package/src/__tests__/integration/btc-deposit.integration.test.ts

@@ -0,0 +1,109 @@
+/**
+ * BTC Deposit Integration Tests
+ *
+ * Tests BTC Deposit action with mocked API responses.
+ *
+ * @module __tests__/integration/btc-deposit.integration.test.ts
+ */
+
+import { Env } from '@lombard.finance/sdk-common';
+import { beforeEach,describe, expect, it, vi } from 'vitest';
+
+import { btcDeposit } from '../../chains/btc/actions/deposit';
+import { AssetId, Chain } from '../../index';
+import { createTestConfig as createConfig } from '../helpers/createTestConfig';
+
+// Mock EIP1193 Provider
+const createMockProvider = () => ({
+  // EIP-1193 event methods required by the EvmProvider type
+  on: vi.fn(),
+  removeListener: vi.fn(),
+  request: vi.fn().mockImplementation(async ({ method }) => {
+    switch (method) {
+      case 'eth_chainId':
+        return '0xa869'; // Avalanche Fuji
+      case 'eth_accounts':
+        return ['0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'];
+      case 'personal_sign':
+      case 'eth_signTypedData_v4':
+        return '0xmocksignature';
+      default:
+        return null;
+    }
+  }),
+});
+
+describe('BTC Deposit Integration', () => {
+  let mockProvider: ReturnType<typeof createMockProvider>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockProvider = createMockProvider();
+  });
+
+  describe('Action Creation', () => {
+    it('should create BTC deposit action for Avalanche Fuji', () => {
+      const config = createConfig({
+        env: Env.testnet,
+        providers: { evm: () => mockProvider },
+      });
+
+      const deposit = btcDeposit(config, {
+        assetOut: AssetId.BTCb,
+        destChain: Chain.AVALANCHE_FUJI,
+      });
+
+      expect(deposit).toBeDefined();
+      expect(deposit.status).toBe('idle');
+    });
+
+    it('should reject LBTC as output asset', () => {
+      const config = createConfig({
+        env: Env.testnet,
+        providers: { evm: () => mockProvider },
+      });
+
+      expect(() => {
+        btcDeposit(config, {
+          assetOut: AssetId.LBTC,
+          destChain: Chain.AVALANCHE_FUJI,
+        });
+      }).toThrow(/not supported for BTC deposits/);
+    });
+  });
+
+  describe('Status Transitions', () => {
+    it('should start in idle status', () => {
+      const config = createConfig({
+        env: Env.testnet,
+        providers: { evm: () => mockProvider },
+      });
+
+      const deposit = btcDeposit(config, {
+        assetOut: AssetId.BTCb,
+        destChain: Chain.AVALANCHE_FUJI,
+      });
+
+      expect(deposit.status).toBe('idle');
+      expect(deposit.isLoading).toBe(false);
+      expect(deposit.error).toBeNull();
+    });
+  });
+
+  describe('Property Access', () => {
+    it('should expose action params', () => {
+      const config = createConfig({
+        env: Env.testnet,
+        providers: { evm: () => mockProvider },
+      });
+
+      const deposit = btcDeposit(config, {
+        assetOut: AssetId.BTCb,
+        destChain: Chain.AVALANCHE_FUJI,
+      });
+
+      expect(deposit.status).toBe('idle');
+    });
+  });
+});
+

package/src/__tests__/integration/btc-stake-and-deploy.integration.test.ts

@@ -0,0 +1,96 @@
+/**
+ * BTC Stake And Deploy Integration Tests
+ *
+ * Tests BTC Stake And Deploy action with mocked API responses.
+ *
+ * @module __tests__/integration/btc-stake-and-deploy.integration.test.ts
+ */
+
+import { Env } from '@lombard.finance/sdk-common';
+import { beforeEach,describe, expect, it, vi } from 'vitest';
+
+import { btcStakeAndDeploy } from '../../chains/btc/actions/stakeAndDeploy';
+import { AssetId, Chain } from '../../index';
+import { createTestConfig as createConfig } from '../helpers/createTestConfig';
+
+// Mock EIP1193 Provider
+const createMockProvider = () => ({
+  // EIP-1193 event methods required by the EvmProvider type
+  on: vi.fn(),
+  removeListener: vi.fn(),
+  request: vi.fn().mockImplementation(async ({ method }) => {
+    switch (method) {
+      case 'eth_chainId':
+        return '0x1'; // Ethereum mainnet
+      case 'eth_accounts':
+        return ['0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'];
+      case 'personal_sign':
+      case 'eth_signTypedData_v4':
+        return '0xmocksignature';
+      default:
+        return null;
+    }
+  }),
+});
+
+describe('BTC Stake And Deploy Integration', () => {
+  let mockProvider: ReturnType<typeof createMockProvider>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockProvider = createMockProvider();
+  });
+
+  describe('Action Creation', () => {
+    it('should create stake and deploy action for Ethereum', () => {
+      const config = createConfig({
+        env: Env.prod,
+        providers: { evm: () => mockProvider },
+      });
+
+      const stakeAndDeploy = btcStakeAndDeploy(config, {
+        assetOut: AssetId.LBTC,
+        destChain: Chain.ETHEREUM,
+        protocol: 'veda',  // Use Veda protocol from DefiRegistry
+      });
+
+      expect(stakeAndDeploy).toBeDefined();
+      expect(stakeAndDeploy.status).toBe('idle');
+    });
+
+    it('should reject BTCb as output asset', () => {
+      const config = createConfig({
+        env: Env.prod,
+        providers: { evm: () => mockProvider },
+      });
+
+      expect(() => {
+        btcStakeAndDeploy(config, {
+          assetOut: AssetId.BTCb,
+          destChain: Chain.ETHEREUM,
+          protocol: 'veda',  // Use Veda protocol from DefiRegistry
+        });
+      }).toThrow(/not supported/);
+    });
+  });
+
+  describe('Status Transitions', () => {
+    it('should start in idle status', () => {
+      const config = createConfig({
+        env: Env.prod,
+        providers: { evm: () => mockProvider },
+      });
+
+      const stakeAndDeploy = btcStakeAndDeploy(config, {
+        assetOut: AssetId.LBTC,
+        destChain: Chain.ETHEREUM,
+        protocol: 'veda',  // Use Veda protocol from DefiRegistry
+      });
+
+      expect(stakeAndDeploy.status).toBe('idle');
+      expect(stakeAndDeploy.isLoading).toBe(false);
+      expect(stakeAndDeploy.error).toBeNull();
+    });
+  });
+});
+