@lombard.finance/sdk 3.7.4 → 4.0.0

package/src/__tests__/real-wallet/btc/btc-stake.real.test.ts

@@ -0,0 +1,70 @@
+import { Env } from '@lombard.finance/sdk-common';
+import type { PrivateKeyAccount, WalletClient } from 'viem';
+import { beforeAll, describe, expect, it } from 'vitest';
+
+import { btcStake } from '../../../chains/btc/actions/stake';
+import { AssetId, Chain } from '../../../core';
+import { createTestConfig as createConfig } from '../../helpers/createTestConfig';
+import { walletClientToProvider } from '../../test-utils/eip1193-adapter';
+import { createTestEvmWallet } from '../../test-utils/evm-wallet';
+
+// Skip if no private key provided
+const runIfConfigured = process.env.TEST_EVM_PRIVATE_KEY ? describe : describe.skip;
+
+runIfConfigured('BTC Stake Real Wallet', () => {
+  let wallet: WalletClient;
+  let account: PrivateKeyAccount;
+
+  beforeAll(async () => {
+    const res = await createTestEvmWallet(
+      process.env.TEST_EVM_PRIVATE_KEY as `0x${string}`,
+      'sepolia'
+    );
+    wallet = res.walletClient;
+    account = res.account;
+  });
+
+  it('should generate deposit address for Sepolia', async () => {
+    const config = createConfig({
+      env: Env.testnet,
+      providers: {
+        evm: () => walletClientToProvider(wallet),
+      },
+    });
+
+    const stake = btcStake(config, {
+      destChain: Chain.SEPOLIA,
+      assetOut: AssetId.LBTC,
+    });
+
+    await stake.prepare({
+      amount: '0.0002', // Min amount
+      recipient: account.address,
+    });
+
+    // Authorize is the unified step:
+    // - If the chain needs fee auth, it signs and stores the fee signature
+    // - Otherwise it signs the destination address
+    if (
+      stake.status === 'needs_fee_authorization' ||
+      stake.status === 'needs_address_confirmation'
+    ) {
+      await stake.authorize();
+    }
+
+    // Now generate the deposit address if ready
+    if (stake.status === 'ready') {
+      const depositAddress = await stake.generateDepositAddress();
+      expect(depositAddress).toBeDefined();
+      expect(depositAddress).toMatch(/^(tb1|2|m|n)/); // Testnet address format
+    } else {
+      // If we can't get to ready status, at least verify we progressed
+      console.log('BTC Stake status:', stake.status);
+      expect([
+        'ready',
+        'needs_address_confirmation',
+        'needs_fee_authorization',
+      ]).toContain(stake.status);
+    }
+  });
+});

package/src/__tests__/real-wallet/evm/evm-stake.real.test.ts

@@ -0,0 +1,47 @@
+import { Env } from '@lombard.finance/sdk-common';
+import type { WalletClient } from 'viem';
+import { beforeAll, describe, expect, it } from 'vitest';
+
+import { evmStake } from '../../../chains/evm/actions/stake';
+import { AssetId, Chain } from '../../../core';
+import { createTestConfig as createConfig } from '../../helpers/createTestConfig';
+import { walletClientToProvider } from '../../test-utils/eip1193-adapter';
+import { createTestEvmWallet } from '../../test-utils/evm-wallet';
+
+const runIfConfigured = process.env.TEST_EVM_PRIVATE_KEY ? describe : describe.skip;
+
+runIfConfigured('EVM Stake Real Wallet', () => {
+  let wallet: WalletClient;
+
+  beforeAll(async () => {
+    // EVM Stake usually happens on Avalanche (BTC.b -> LBTC)
+    const res = await createTestEvmWallet(
+      process.env.TEST_EVM_PRIVATE_KEY as `0x${string}`,
+      'avalanche-fuji'
+    );
+    wallet = res.walletClient;
+  });
+
+  it('should prepare stake transaction', async () => {
+    const config = createConfig({
+      env: Env.testnet,
+      providers: {
+        evm: () => walletClientToProvider(wallet),
+      },
+    });
+
+    const stake = evmStake(config, {
+      assetIn: AssetId.BTCb,
+      assetOut: AssetId.LBTC,
+      sourceChain: Chain.AVALANCHE,
+      destChain: Chain.AVALANCHE,
+    });
+
+    await stake.prepare({
+      amount: '0.0001',
+    });
+
+    expect(stake.status).toBe('needs-approval');
+  });
+});
+

package/src/__tests__/real-wallet/evm/evm-unstake.real.test.ts

@@ -0,0 +1,49 @@
+import { Env } from '@lombard.finance/sdk-common';
+import type { WalletClient } from 'viem';
+import { beforeAll, describe, expect, it } from 'vitest';
+
+import { evmUnstake } from '../../../chains/evm/actions/unstake';
+import { AssetId, Chain } from '../../../core';
+import { createTestConfig as createConfig } from '../../helpers/createTestConfig';
+import { walletClientToProvider } from '../../test-utils/eip1193-adapter';
+import { createTestEvmWallet } from '../../test-utils/evm-wallet';
+
+const runIfConfigured = process.env.TEST_EVM_PRIVATE_KEY ? describe : describe.skip;
+
+runIfConfigured('EVM Unstake Real Wallet', () => {
+  let wallet: WalletClient;
+
+  beforeAll(async () => {
+    const res = await createTestEvmWallet(
+      process.env.TEST_EVM_PRIVATE_KEY as `0x${string}`,
+      'sepolia'
+    );
+    wallet = res.walletClient;
+  });
+
+  it('should prepare unstake transaction', async () => {
+    const config = createConfig({
+      env: Env.testnet,
+      providers: {
+        evm: () => walletClientToProvider(wallet),
+      },
+    });
+
+    const unstake = evmUnstake(config, {
+      assetIn: AssetId.LBTC,
+      assetOut: AssetId.BTC,
+      sourceChain: Chain.SEPOLIA,
+      destChain: Chain.BITCOIN_SIGNET,
+    });
+
+    await unstake.prepare({
+      amount: '0.0001',
+      recipient: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx', // Valid testnet address
+    });
+
+    // Status depends on whether user has LBTC balance and allowance
+    // Without LBTC: might be 'ready' (nothing to approve) or 'needs-approval'
+    // With LBTC: 'needs-approval' then 'ready'
+    expect(['ready', 'needs-approval', 'needs_approval']).toContain(unstake.status);
+  });
+});

package/src/__tests__/real-wallet/non-evm/solana-unstake.real.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect,it } from 'vitest';
+
+/**
+ * Solana Unstake Real Wallet Tests
+ * 
+ * NOTE: These tests are skipped because:
+ * 1. The Solana module requires separate registration via createConfig({ modules: [...] })
+ * 2. The @lombard.finance/sdk-solana package needs to be imported and registered
+ * 
+ * To enable these tests:
+ * 1. Import: import { solanaModule } from '@lombard.finance/sdk-solana'
+ * 2. Register: createConfig({ modules: [solanaModule()] })
+ */
+describe.skip('Solana Unstake Real Wallet', () => {
+  it('should prepare unstake transaction', () => {
+    // Placeholder - requires sdk-solana module registration
+    expect(true).toBe(true);
+  });
+});

package/src/__tests__/real-wallet/non-evm/starknet-unstake.real.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect,it } from 'vitest';
+
+/**
+ * Starknet Unstake Real Wallet Tests
+ * 
+ * NOTE: These tests are skipped because:
+ * 1. The Starknet module requires separate registration via createConfig({ modules: [...] })
+ * 2. The @lombard.finance/sdk-starknet package needs to be imported and registered
+ * 
+ * To enable these tests:
+ * 1. Import: import { starknetModule } from '@lombard.finance/sdk-starknet'
+ * 2. Register: createConfig({ modules: [starknetModule()] })
+ */
+describe.skip('Starknet Unstake Real Wallet', () => {
+  it('should initialize unstake action', () => {
+    // Placeholder - requires sdk-starknet module registration
+    expect(true).toBe(true);
+  });
+});

package/src/__tests__/real-wallet/non-evm/sui-unstake.real.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect,it } from 'vitest';
+
+/**
+ * Sui Unstake Real Wallet Tests
+ * 
+ * NOTE: These tests are skipped because:
+ * 1. The Sui module requires separate registration via createConfig({ modules: [...] })
+ * 2. The @lombard.finance/sdk-sui package needs to be imported and registered
+ * 
+ * To enable these tests:
+ * 1. Import: import { suiModule } from '@lombard.finance/sdk-sui'
+ * 2. Register: createConfig({ modules: [suiModule()] })
+ */
+describe.skip('Sui Unstake Real Wallet', () => {
+  it('should initialize unstake action', () => {
+    // Placeholder - requires sdk-sui module registration
+    expect(true).toBe(true);
+  });
+});

package/src/__tests__/services/ApiService.test.ts

@@ -0,0 +1,62 @@
+import { Env } from '@lombard.finance/sdk-common';
+import { beforeEach,describe, expect, it, vi } from 'vitest';
+
+import { getNetworkFeeSignature } from '../../api-functions/getNetworkFeeSignature/getNetworkFeeSignature';
+import { storeNetworkFeeSignature } from '../../api-functions/storeNetworkFeeSignature/storeNetworkFeeSignature';
+import { ChainId } from '../../common/chains';
+import { ApiService } from '../../services/ApiService';
+
+// Mock dependencies
+vi.mock('../../api-functions/storeNetworkFeeSignature/storeNetworkFeeSignature', () => ({
+  storeNetworkFeeSignature: vi.fn(),
+}));
+vi.mock('../../api-functions/getNetworkFeeSignature/getNetworkFeeSignature', () => ({
+  getNetworkFeeSignature: vi.fn(),
+}));
+
+describe('ApiService', () => {
+  let service: ApiService;
+
+  beforeEach(() => {
+    service = new ApiService(Env.testnet);
+    vi.clearAllMocks();
+  });
+
+  describe('Fee Signatures', () => {
+    it('should store fee signature', async () => {
+      // ApiService.storeFeeSignature expects typedData as a string payload (serialized)
+      const typedData = JSON.stringify({ domain: {} });
+
+      await service.storeFeeSignature({
+        address: '0x123',
+        signature: '0xsig',
+        typedData,
+      });
+
+      expect(storeNetworkFeeSignature).toHaveBeenCalledWith({
+        address: '0x123',
+        signature: '0xsig',
+        typedData,
+        env: Env.testnet,
+      });
+    });
+
+    it('should retrieve fee signature', async () => {
+      vi.mocked(getNetworkFeeSignature).mockResolvedValue({
+        hasSignature: true,
+        signature: '0xsig',
+        expirationDate: '2025-01-01',
+        isDelayed: false,
+      });
+
+      const result = await service.getFeeSignature({
+        address: '0x123',
+        chainId: ChainId.sepolia,
+      });
+
+      expect(result.hasSignature).toBe(true);
+      expect(result.signature).toBe('0xsig');
+    });
+  });
+});
+

package/src/__tests__/services/BtcService.test.ts

@@ -0,0 +1,30 @@
+import { beforeEach,describe, expect, it, vi } from 'vitest';
+
+import { getCurrentBlockHeight } from '../../chains/btc/client/getCurrentBlockHeight';
+import { BtcService } from '../../services/BtcService';
+
+// Mock dependencies
+vi.mock('../../chains/btc/client/getCurrentBlockHeight', () => ({
+  getCurrentBlockHeight: vi.fn(),
+}));
+
+describe('BtcService', () => {
+  let service: BtcService;
+
+  beforeEach(() => {
+    service = new BtcService();
+    vi.clearAllMocks();
+  });
+
+  describe('getCurrentBlockHeight', () => {
+    it('should return block height', async () => {
+      vi.mocked(getCurrentBlockHeight).mockResolvedValue(123456);
+      
+      const height = await service.getCurrentBlockHeight('testnet');
+      
+      expect(height).toBe(123456);
+      expect(getCurrentBlockHeight).toHaveBeenCalledWith('testnet');
+    });
+  });
+});
+

package/src/__tests__/services/EvmService.test.ts

@@ -0,0 +1,39 @@
+import { Env } from '@lombard.finance/sdk-common';
+import BigNumber from 'bignumber.js';
+import { beforeEach,describe, expect, it, vi } from 'vitest';
+
+import { ChainId } from '../../common/chains';
+import { EvmService } from '../../services/EvmService';
+
+// Mock dependencies
+vi.mock('../../contract-functions/getLBTCMintingFee/getLBTCMintingFee', () => ({
+  getMintingFee: vi.fn(),
+}));
+
+import { getMintingFee } from '../../contract-functions/getLBTCMintingFee/getLBTCMintingFee';
+
+describe('EvmService', () => {
+  let service: EvmService;
+
+  beforeEach(() => {
+    service = new EvmService(Env.testnet);
+    vi.clearAllMocks();
+  });
+
+  describe('getMintingFee', () => {
+    it('should return minting fee as BTC decimal string', async () => {
+      vi.mocked(getMintingFee).mockResolvedValue(new BigNumber('0.00001992'));
+      
+      const fee = await service.getMintingFee(ChainId.sepolia);
+      
+      expect(fee).toBe('0.00001992');
+      expect(typeof fee).toBe('string');
+      expect(getMintingFee).toHaveBeenCalledWith({
+        chainId: ChainId.sepolia,
+        env: Env.testnet,
+        token: 'LBTC',
+      });
+    });
+  });
+});
+

package/src/__tests__/setup.ts

@@ -0,0 +1,16 @@
+/**
+ * Test setup file for vitest
+ *
+ * This file runs before each test suite and sets up the testing environment.
+ */
+
+import { afterEach, beforeEach } from 'vitest';
+
+// Global test setup
+beforeEach(() => {
+  // Reset any mocks or state before each test
+});
+
+afterEach(() => {
+  // Cleanup after each test
+});

package/src/__tests__/test-utils/eip1193-adapter.ts

@@ -0,0 +1,48 @@
+import type { EIP1193Provider, WalletClient } from 'viem';
+
+/**
+ * Adapts a viem WalletClient to EIP-1193 Provider interface
+ * This allows using private keys with SDK that expects EIP-1193
+ */
+export function walletClientToProvider(client: WalletClient): EIP1193Provider {
+  return {
+    request: async ({ method, params }: { method: string; params?: unknown[] }) => {
+      switch (method) {
+        case 'eth_accounts':
+        case 'eth_requestAccounts':
+          return client.account ? [client.account.address] : [];
+
+        case 'eth_chainId':
+          return client.chain?.id ? `0x${client.chain.id.toString(16)}` : '0x1';
+
+        case 'eth_sendTransaction': {
+          const [txParams] = params as [Parameters<typeof client.sendTransaction>[0]];
+          return client.sendTransaction(txParams);
+        }
+
+        case 'eth_signTypedData_v4': {
+          const [, typedData] = params as [string, string];
+          const data = JSON.parse(typedData);
+          return client.signTypedData({
+            account: client.account!,
+            ...data,
+          });
+        }
+
+        case 'personal_sign': {
+          const [message] = params as [string, string];
+          return client.signMessage({
+            account: client.account!,
+            message: { raw: message as `0x${string}` },
+          });
+        }
+
+        default:
+          throw new Error(`Method not implemented: ${method}`);
+      }
+    },
+    on: () => {},
+    removeListener: () => {},
+  } as EIP1193Provider;
+}
+

package/src/__tests__/test-utils/evm-wallet.ts

@@ -0,0 +1,38 @@
+import type { Chain, PublicClient, WalletClient } from 'viem';
+import { createPublicClient, createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { avalancheFuji, sepolia } from 'viem/chains';
+
+const CHAIN_MAP = {
+  sepolia,
+  'avalanche-fuji': avalancheFuji,
+};
+
+interface TestEvmWallet {
+  walletClient: WalletClient;
+  publicClient: PublicClient;
+  account: ReturnType<typeof privateKeyToAccount>;
+  chain: Chain;
+}
+
+export async function createTestEvmWallet(
+  privateKey: `0x${string}`,
+  chainName: keyof typeof CHAIN_MAP,
+): Promise<TestEvmWallet> {
+  const chain = CHAIN_MAP[chainName];
+  const account = privateKeyToAccount(privateKey);
+  
+  const walletClient = createWalletClient({
+    account,
+    chain,
+    transport: http(),
+  });
+
+  const publicClient = createPublicClient({
+    chain,
+    transport: http(),
+  });
+
+  return { walletClient, publicClient, account, chain };
+}
+

package/src/__tests__/test-utils/solana-wallet.ts

@@ -0,0 +1,22 @@
+import { Connection, Keypair } from '@solana/web3.js';
+import bs58 from 'bs58';
+
+export async function createTestSolanaWallet(secretKeyBase58: string) {
+  const keypair = Keypair.fromSecretKey(bs58.decode(secretKeyBase58));
+  const connection = new Connection(
+    process.env.SOLANA_DEVNET_RPC || 'https://api.devnet.solana.com',
+    'confirmed',
+  );
+
+  return {
+    keypair,
+    connection,
+    publicKey: keypair.publicKey,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signTransaction: async (tx: any) => {
+      tx.partialSign(keypair);
+      return tx;
+    },
+  };
+}
+

package/src/__tests__/test-utils/starknet-wallet.ts

@@ -0,0 +1,9 @@
+import { Account, RpcProvider } from 'starknet';
+
+const STARKNET_SEPOLIA_RPC = process.env.STARKNET_SEPOLIA_RPC || 'https://starknet-sepolia.public.blastapi.io';
+
+export function createStarknetWallet(address: string, privateKey: string) {
+  const provider = new RpcProvider({ nodeUrl: STARKNET_SEPOLIA_RPC });
+  return new Account(provider, address, privateKey);
+}
+

package/src/__tests__/test-utils/sui-wallet.ts

@@ -0,0 +1,14 @@
+import { decodeSuiPrivateKey } from '@mysten/sui/cryptography';
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+
+export function createSuiWallet(privateKey: string) {
+  // Handle bech32 format (suiprivkey1...) or hex format
+  if (privateKey.startsWith('suiprivkey')) {
+    const { secretKey } = decodeSuiPrivateKey(privateKey);
+    return Ed25519Keypair.fromSecretKey(secretKey);
+  }
+  
+  // Fallback: hex string (with or without 0x)
+  const hex = privateKey.startsWith('0x') ? privateKey.slice(2) : privateKey;
+  return Ed25519Keypair.fromSecretKey(Buffer.from(hex, 'hex'));
+}

package/src/__tests__/test-utils/test-constraints.ts

@@ -0,0 +1,110 @@
+/**
+ * Test Constraints Utilities
+ *
+ * Provides deterministic, rotating inputs to avoid backend state collisions
+ * (e.g., deposit address reuse for the same partner + recipient + chain).
+ *
+ * @module __tests__/test-utils/test-constraints
+ */
+
+import { createHash } from 'node:crypto';
+
+const TEST_PARTNER_IDS = [
+  'test1',
+  'test2',
+  'test3',
+  'test4',
+  'test5',
+  'test6',
+  'test7',
+  'test8',
+  'test9',
+  'test10',
+];
+
+const BTC_TESTNET_RECIPIENTS = [
+  'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx',
+  'tb1qhs9gw5i9r83mmd4sx4d4m6zryudq4c0mns2z2v',
+  'tb1qz2x8f6g5puhm2l6hpr90ks9wq9m5vps0f7x6c6',
+  'tb1q6e5l7h3f4ux8d0wqz7q2j2l7f5tq9sgatxv4z2',
+  'tb1q4u3xv2s7d8e9k0l2m3n4p5r6t7y8u9i0o1p2a3',
+  'tb1qv0k3z5n7c9x2l4j6h8g0f2d4s6a8q9w0e1r2t3',
+  'tb1q3y5u7i9o0p2a4s6d8f0g2h4j6k8l9z0x1c2v3',
+  'tb1qx9c7v5b3n1m0a8s6d4f2g0h9j8k7l6p5o4i3u',
+  'tb1q5t7r9e1w3q5a7s9d1f3g5h7j9k1l3z5x7c9v1',
+  'tb1q2w4e6r8t0y2u4i6o8p0a2s4d6f8g0h2j4k6l8',
+];
+
+const EVM_TEST_RECIPIENTS = [
+  '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+  '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+  '0x00000000219ab540356cBB839Cbe05303d7705Fa',
+  '0x8ba1f109551bD432803012645Ac136ddd64DBA72',
+  '0x0bBb9dDD6E2c3b84fFBEbA07bF737a14aA0f1A1A',
+];
+
+function toNumber(value?: string): number | null {
+  if (!value) {
+    return null;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+/**
+ * Determine a stable run identifier for rotating test inputs.
+ */
+export function getTestRunId(): number {
+  const fromEnv =
+    toNumber(process.env.CI_RUN_ID) ??
+    toNumber(process.env.GITHUB_RUN_ID) ??
+    toNumber(process.env.GITLAB_RUN_ID) ??
+    toNumber(process.env.BUILD_NUMBER);
+
+  if (fromEnv !== null) {
+    return fromEnv;
+  }
+
+  return Number.parseInt(String(Date.now() / 1000), 10);
+}
+
+/**
+ * Compute a deterministic index for a list based on run ID and label.
+ */
+export function getRotatingIndex(length: number, label: string, runId = getTestRunId()): number {
+  if (length <= 0) {
+    return 0;
+  }
+  const hash = createHash('sha256').update(`${label}:${runId}`).digest('hex');
+  const slice = hash.slice(0, 8);
+  const value = Number.parseInt(slice, 16);
+  return value % length;
+}
+
+/**
+ * Get a deterministic partner ID for the current test run.
+ */
+export function getTestPartnerId(runId = getTestRunId()): string {
+  const override = process.env.TEST_PARTNER_ID;
+  if (override) {
+    return override;
+  }
+  const index = getRotatingIndex(TEST_PARTNER_IDS.length, 'partner', runId);
+  return TEST_PARTNER_IDS[index];
+}
+
+/**
+ * Get a deterministic BTC testnet recipient address.
+ */
+export function getTestBtcRecipient(runId = getTestRunId()): string {
+  const index = getRotatingIndex(BTC_TESTNET_RECIPIENTS.length, 'btc', runId);
+  return BTC_TESTNET_RECIPIENTS[index];
+}
+
+/**
+ * Get a deterministic EVM recipient address.
+ */
+export function getTestEvmRecipient(runId = getTestRunId()): string {
+  const index = getRotatingIndex(EVM_TEST_RECIPIENTS.length, 'evm', runId);
+  return EVM_TEST_RECIPIENTS[index];
+}