@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/__tests__/unit/evm/EvmUnstakeAllowance.test.ts

@@ -1,69 +0,0 @@
-import { Env } from '@lombard.finance/sdk-common';
-import { beforeEach,describe, expect, it, vi } from 'vitest';
-
-import { EvmUnstake } from '../../../chains/evm/actions/unstake/EvmUnstake';
-import { PartnerConfiguration } from '../../../client/PartnerConfiguration';
-import { AssetId, Chain } from '../../../core';
-import { EvmOperationStatus } from '../../../shared/constants/statusConstants';
-import type { EvmCoreContext } from '../../../shared/context/types';
-
-vi.mock('../../../chains/evm/shared/feeAuth', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../../../chains/evm/shared/feeAuth')>();
-  return {
-    ...actual,
-    checkFeeAuthorization: vi.fn(async () => ({
-      requiresAuth: false,
-      hasValidSignature: false,
-      feeInSatoshis: null,
-      feeFormatted: null,
-      expirationDate: null,
-    })),
-  };
-});
-
-vi.mock('../../../contract-functions/approveToken', () => ({
-  approveToken: vi.fn(),
-  getTokenAllowance: vi.fn(),
-}));
-
-const mockProvider = {
-  request: vi.fn(async ({ method }: { method: string }) => {
-    if (method === 'eth_accounts') {
-      return ['0x0000000000000000000000000000000000000002'];
-    }
-    return [];
-  }),
-};
-
-function createContext(): EvmCoreContext {
-  return {
-    env: Env.prod,
-    partner: new PartnerConfiguration(undefined),
-    getProvider: async () => mockProvider,
-    evm: {} as EvmCoreContext['evm'],
-  };
-}
-
-describe('EvmUnstake allowance handling', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('does not request ERC-20 approval for LBTC → BTC.b', async () => {
-    const { approveToken, getTokenAllowance } = await import('../../../contract-functions/approveToken');
-
-    const ctx = createContext();
-    const unstake = new EvmUnstake(ctx, {
-      assetIn: AssetId.LBTC,
-      assetOut: AssetId.BTCb,
-      sourceChain: Chain.BASE,
-      destChain: Chain.BASE,
-    });
-
-    await unstake.prepare({ amount: '10000', recipient: '0x0000000000000000000000000000000000000002' });
-
-    expect(unstake.status).toBe(EvmOperationStatus.READY);
-    expect(approveToken).not.toHaveBeenCalled();
-    expect(getTokenAllowance).not.toHaveBeenCalled();
-  });
-});

package/src/__tests__/unit/evm/EvmUnstakeConfig.test.ts

@@ -1,203 +0,0 @@
-/**
- * EVM Unstake Config Unit Tests
- *
- * Tests address validation based on assetOut to prevent
- * bugs like #9 (EVM address validation errors when Bitcoin address expected).
- *
- * @module __tests__/unit/evm/EvmUnstakeConfig.test.ts
- */
-
-import { describe, expect,it } from 'vitest';
-
-import {
-  evmToBtcbConfig,
-  evmToBtcConfig,
-} from '../../../chains/evm/actions/unstake/config/evm';
-import { Chain, Env } from '../../../core';
-import {
-  bitcoinAddressSchema,
-  evmAddressSchema,
-} from '../../../shared/validation';
-
-describe('EVM Unstake Config', () => {
-  describe('Address Schema Selection', () => {
-    it('should use Bitcoin address schema when unstaking to BTC', () => {
-      // Bug #9: When assetOut is BTC, recipient should be a Bitcoin address
-      expect(evmToBtcConfig.recipientSchema).toBe(bitcoinAddressSchema);
-    });
-
-    it('should use EVM address schema when unstaking to BTC.b', () => {
-      // When assetOut is BTCb, recipient should be an EVM address
-      expect(evmToBtcbConfig.recipientSchema).toBe(evmAddressSchema);
-    });
-  });
-
-  describe('Bitcoin Address Validation (assetOut = BTC)', () => {
-    const schema = evmToBtcConfig.recipientSchema;
-
-    describe('Valid Bitcoin addresses', () => {
-      it('should accept valid mainnet P2PKH address', () => {
-        expect(() => schema.parse('1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2')).not.toThrow();
-      });
-
-      it('should accept valid mainnet P2SH address', () => {
-        expect(() => schema.parse('3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')).not.toThrow();
-      });
-
-      it('should accept valid mainnet Bech32 address', () => {
-        expect(() => schema.parse('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq')).not.toThrow();
-      });
-
-      it('should accept valid testnet/signet P2PKH address', () => {
-        expect(() => schema.parse('mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn')).not.toThrow();
-      });
-
-      it('should accept valid testnet/signet Bech32 address', () => {
-        // Valid testnet bech32 address from BIP-0173
-        expect(() => schema.parse('tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx')).not.toThrow();
-      });
-
-      it('should accept valid Taproot (bc1p) address', () => {
-        expect(() => schema.parse('bc1pw0sr89hvfgwyhj98gamyewndt5yczw5cdkl7j3eystx2js48gfks2w72ct')).not.toThrow();
-      });
-    });
-
-    describe('Invalid Bitcoin addresses', () => {
-      it('should reject EVM address (Bug #9 scenario)', () => {
-        // This is the exact bug scenario - user entered EVM address
-        // when Bitcoin address was expected
-        expect(() =>
-          schema.parse('0x5991d9dDB5f20774A1e4D0Bf7bb30F1DdBa870fD'),
-        ).toThrow();
-      });
-
-      it('should reject empty string', () => {
-        expect(() => schema.parse('')).toThrow();
-      });
-
-      it('should reject invalid format', () => {
-        expect(() => schema.parse('invalid-address')).toThrow();
-      });
-
-      // Note: Basic regex validation doesn't validate checksum
-      // Full checksum validation would require a Bitcoin library
-    });
-  });
-
-  describe('EVM Address Validation (assetOut = BTCb)', () => {
-    const schema = evmToBtcbConfig.recipientSchema;
-
-    describe('Valid EVM addresses', () => {
-      it('should accept valid checksummed EVM address', () => {
-        expect(() =>
-          schema.parse('0x5991d9dDB5f20774A1e4D0Bf7bb30F1DdBa870fD'),
-        ).not.toThrow();
-      });
-
-      it('should accept valid lowercase EVM address', () => {
-        expect(() =>
-          schema.parse('0x5991d9ddb5f20774a1e4d0bf7bb30f1ddba870fd'),
-        ).not.toThrow();
-      });
-
-      it('should accept zero address', () => {
-        expect(() =>
-          schema.parse('0x0000000000000000000000000000000000000000'),
-        ).not.toThrow();
-      });
-    });
-
-    describe('Invalid EVM addresses', () => {
-      it('should reject Bitcoin address (reverse Bug #9)', () => {
-        // User entered Bitcoin address when EVM address expected
-        expect(() =>
-          schema.parse('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq'),
-        ).toThrow();
-      });
-
-      it('should reject address without 0x prefix', () => {
-        expect(() =>
-          schema.parse('5991d9dDB5f20774A1e4D0Bf7bb30F1DdBa870fD'),
-        ).toThrow();
-      });
-
-      it('should reject address with wrong length', () => {
-        expect(() => schema.parse('0x5991d9dDB5f20774A1e4D0Bf')).toThrow();
-      });
-
-      it('should reject empty string', () => {
-        expect(() => schema.parse('')).toThrow();
-      });
-
-      it('should reject non-hex characters', () => {
-        expect(() =>
-          schema.parse('0xZZZZd9dDB5f20774A1e4D0Bf7bb30F1DdBa870fD'),
-        ).toThrow();
-      });
-    });
-  });
-
-  describe('Route Configuration', () => {
-    describe('EVM to BTC routes', () => {
-      it('should have Sepolia as source chain for testnet', () => {
-        const testnetRoutes = evmToBtcConfig.routes.filter(r =>
-          r.envs.some(e => e === Env.testnet),
-        );
-        const sourceChains = testnetRoutes.flatMap(r => r.sourceChains);
-        // Chain identifiers use CAIP-2 format
-        expect(sourceChains).toContain(Chain.SEPOLIA);
-      });
-
-      it('should have Ethereum as source chain for production', () => {
-        const prodRoutes = evmToBtcConfig.routes.filter(r =>
-          r.envs.includes(Env.prod),
-        );
-        const sourceChains = prodRoutes.flatMap(r => r.sourceChains);
-        expect(sourceChains).toContain(Chain.ETHEREUM);
-      });
-
-      it('should have Bitcoin as destination for cross-chain unstake', () => {
-        // All routes should have Bitcoin as destination
-        evmToBtcConfig.routes.forEach(route => {
-          expect([Chain.BITCOIN_MAINNET, Chain.BITCOIN_SIGNET]).toContain(route.destChain);
-        });
-      });
-    });
-
-    describe('EVM to BTCb routes', () => {
-      it('should have matching destination for same-chain operations', () => {
-        // BTC.b unstake is same-chain (e.g., Avalanche → Avalanche)
-        expect(evmToBtcbConfig.routes.length).toBeGreaterThan(0);
-        
-        // Each route should have source and dest as the same chain
-        evmToBtcbConfig.routes.forEach(route => {
-          route.sourceChains.forEach(source => {
-            expect(source).toBe(route.destChain);
-          });
-        });
-      });
-    });
-  });
-
-  describe('Bug #9: Address type mismatch scenarios', () => {
-    it('should differentiate between BTC and EVM address requirements', () => {
-      // When assetOut is BTC -> Bitcoin address required
-      const btcSchema = evmToBtcConfig.recipientSchema;
-      
-      // When assetOut is BTCb -> EVM address required
-      const btcbSchema = evmToBtcbConfig.recipientSchema;
-
-      const evmAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0';
-      const btcAddress = 'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh';
-
-      // EVM address should be valid for BTCb, invalid for BTC
-      expect(() => btcbSchema.parse(evmAddress)).not.toThrow();
-      expect(() => btcSchema.parse(evmAddress)).toThrow();
-
-      // Bitcoin address should be valid for BTC, invalid for BTCb
-      expect(() => btcSchema.parse(btcAddress)).not.toThrow();
-      expect(() => btcbSchema.parse(btcAddress)).toThrow();
-    });
-  });
-});
-

package/src/__tests__/unit/fee-signature-expiration.test.ts

@@ -1,76 +0,0 @@
-/**
- * Fee Signature Expiration Tests
- *
- * Verifies that Unix timestamp expiration dates are correctly parsed
- * when checking if a stored fee signature is still valid.
- */
-
-import { describe, expect, it } from 'vitest';
-
-describe('Fee Signature Expiration Parsing', () => {
-  /**
-   * Helper to check if a signature is expired
-   * This mirrors the logic in stake/config/evm.ts and deposit/config/evm.ts
-   */
-  function isSignatureExpired(expirationDate: string | undefined): boolean {
-    if (!expirationDate) return false;
-    // expirationDate is a Unix timestamp in seconds, convert to milliseconds
-    return new Date(Number(expirationDate) * 1000) < new Date();
-  }
-
-  describe('Unix timestamp parsing', () => {
-    it('should correctly identify a future timestamp as NOT expired', () => {
-      const futureTimestamp = String(Math.floor(Date.now() / 1000) + 3600);
-      expect(isSignatureExpired(futureTimestamp)).toBe(false);
-    });
-
-    it('should correctly identify a past timestamp as expired', () => {
-      // Jan 1, 2020 00:00:00 UTC - clearly in the past
-      const pastTimestamp = '1577836800';
-      
-      // Verify the timestamp represents the expected date (in UTC)
-      const date = new Date(Number(pastTimestamp) * 1000);
-      expect(date.getUTCFullYear()).toBe(2020);
-      expect(date.getUTCMonth()).toBe(0); // January
-      expect(date.getUTCDate()).toBe(1);
-      
-      // The signature SHOULD be expired
-      expect(isSignatureExpired(pastTimestamp)).toBe(true);
-    });
-
-    it('should handle undefined expiration date as not expired', () => {
-      expect(isSignatureExpired(undefined)).toBe(false);
-    });
-
-    it('should handle empty string as not expired', () => {
-      // Number('') = 0, which converts to Jan 1, 1970 - in the past
-      // But the condition checks if expirationDate exists first
-      // For safety, we treat empty string as "no expiration"
-      expect(isSignatureExpired('')).toBe(false);
-    });
-  });
-
-  describe('Bug fix verification: Unix timestamp vs Date string parsing', () => {
-    it('WRONG: new Date(string) parses incorrectly', () => {
-      const timestamp = '1768491343';
-      
-      // This is the WRONG way - new Date() tries to parse as ISO string
-      const wrongDate = new Date(timestamp);
-      
-      // This returns Invalid Date or a wrong date
-      expect(wrongDate.toString()).toMatch(/Invalid Date|1970/);
-    });
-
-    it('CORRECT: new Date(number * 1000) parses correctly', () => {
-      const timestamp = '1768491343';
-      
-      // This is the CORRECT way - convert to milliseconds
-      const correctDate = new Date(Number(timestamp) * 1000);
-      
-      // This returns the correct date: Jan 15, 2026
-      expect(correctDate.getFullYear()).toBe(2026);
-      expect(correctDate.getMonth()).toBe(0);
-      expect(correctDate.getDate()).toBe(15);
-    });
-  });
-});

package/src/__tests__/unit/modules/CapabilityRegistry.test.ts

@@ -1,55 +0,0 @@
-import { Env } from '@lombard.finance/sdk-common';
-import { beforeEach,describe, expect, it, vi } from 'vitest';
-
-import { LombardConfig } from '../../../config/types';
-import { CapabilityRegistry } from '../../../modules/CapabilityRegistry';
-
-// Mock config
-const mockConfig: LombardConfig = {
-  env: Env.testnet,
-  providers: {},
-  modules: [],
-};
-
-// Mock module
-const mockModule = {
-  id: 'test-module',
-  register: vi.fn().mockReturnValue('service-instance'),
-};
-
-describe('CapabilityRegistry', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should require registered capabilities', () => {
-    const registry = new CapabilityRegistry([mockModule], mockConfig);
-    
-    const service = registry.require('test-module');
-    expect(service).toBe('service-instance');
-    expect(mockModule.register).toHaveBeenCalled();
-  });
-
-  it('should throw for unregistered capabilities', () => {
-    const registry = new CapabilityRegistry([], mockConfig);
-    
-    expect(() => registry.require('test-module')).toThrow(/not registered/);
-  });
-
-  it('should return null for optional missing capabilities', () => {
-    const registry = new CapabilityRegistry([], mockConfig);
-    
-    const service = registry.optional('test-module');
-    expect(service).toBeNull();
-  });
-
-  it('should cache service instances', () => {
-    const registry = new CapabilityRegistry([mockModule], mockConfig);
-    
-    registry.require('test-module');
-    registry.require('test-module');
-    
-    expect(mockModule.register).toHaveBeenCalledTimes(1);
-  });
-});
-

package/src/__tests__/unit/shared/BaseAction.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { BaseAction } from '../../../shared/actions/BaseAction';
-
-// Mock event handler types
-type TestEventMap = {
-  // BaseAction requires handlers to be compatible with EventHandler<unknown[]>
-  // (i.e., handlers must accept unknown[] args). We cast inside tests as needed.
-  'status-change': (...args: unknown[]) => void;
-  loading: (...args: unknown[]) => void;
-  error: (...args: unknown[]) => void;
-  failed: (...args: unknown[]) => void;
-  completed: (...args: unknown[]) => void;
-};
-
-// Concrete implementation for testing
-class TestAction extends BaseAction<TestEventMap, string> {
-  constructor(initialStatus: string = 'idle') {
-    super(initialStatus);
-  }
-
-  // Expose protected methods for testing
-  public testUpdateStatus(status: string) {
-    this.updateStatus(status);
-  }
-
-  public testAssertStatus(expected: string | string[], action: string) {
-    this.assertStatus(expected, action);
-  }
-
-  public async testAct<T>(fn: () => Promise<T>, successStatus?: string) {
-    return this.act(fn, successStatus);
-  }
-}
-
-describe('BaseAction', () => {
-  it('should initialize with correct status', () => {
-    const action = new TestAction('idle');
-    expect(action.status).toBe('idle');
-    expect(action.isLoading).toBe(false);
-    expect(action.error).toBeNull();
-    expect(action.isFailed).toBe(false);
-  });
-
-  describe('act() Pattern', () => {
-    it('should set isLoading=true during operation', async () => {
-      const action = new TestAction();
-      const loadingStates: boolean[] = [];
-      action.on('loading', (...args) => loadingStates.push(args[0] as boolean));
-
-      await action.testAct(async () => {
-        expect(action.isLoading).toBe(true);
-      });
-
-      expect(loadingStates).toEqual([true, false]);
-      expect(action.isLoading).toBe(false);
-    });
-
-    it('should update status on success if provided', async () => {
-      const action = new TestAction('idle');
-      
-      await action.testAct(async () => {
-        // do work
-      }, 'ready');
-
-      expect(action.status).toBe('ready');
-    });
-
-    it('should NOT update status if successStatus not provided', async () => {
-      const action = new TestAction('idle');
-      
-      await action.testAct(async () => {
-        // do work
-      });
-
-      expect(action.status).toBe('idle');
-    });
-
-    it('should preserve status on error (no rollback to FAILED)', async () => {
-      const action = new TestAction('idle');
-      const initialStatus = action.status;
-      const error = new Error('Something went wrong');
-
-      await expect(action.testAct(async () => {
-        throw error;
-      })).rejects.toThrow();
-
-      expect(action.status).toBe(initialStatus); // Status unchanged
-      expect(action.isFailed).toBe(true);        // Error flag set
-      expect(action.error).not.toBeNull();       // Error captured
-    });
-
-    it('should emit error and failed events on failure', async () => {
-      const action = new TestAction();
-      const errorFn = vi.fn();
-      const failedFn = vi.fn();
-      action.on('error', errorFn);
-      action.on('failed', failedFn);
-
-      await expect(action.testAct(async () => {
-        throw new Error('Boom');
-      })).rejects.toThrow('Boom');
-
-      expect(errorFn).toHaveBeenCalled();
-      expect(failedFn).toHaveBeenCalled();
-    });
-  });
-
-  describe('Status assertions', () => {
-    it('should allow allowed statuses', () => {
-      const action = new TestAction('idle');
-      expect(() => action.testAssertStatus('idle', 'test')).not.toThrow();
-      expect(() => action.testAssertStatus(['idle', 'ready'], 'test')).not.toThrow();
-    });
-
-    it('should throw on disallowed statuses', () => {
-      const action = new TestAction('idle');
-      expect(() => action.testAssertStatus('ready', 'test')).toThrow();
-    });
-  });
-});
-

package/src/__tests__/unit/shared/BaseBtcAction.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { z } from 'zod';
-
-import { BaseBtcAction, BaseBtcParams, StatusConfig, StepDefinition } from '../../../chains/btc/actions/shared/BaseBtcAction';
-import { ChainId } from '../../../common/chains';
-import { Chain, StepStatus } from '../../../core';
-import { BtcCoreContext } from '../../../shared/context';
-
-// Mock context
-const mockCtx = {
-  api: {
-    getDepositAddress: vi.fn(),
-    generateDepositAddress: vi.fn(),
-    getDeposits: vi.fn(),
-  },
-  partner: {
-    getPartnerId: vi.fn(),
-  },
-} as unknown as BtcCoreContext;
-
-// Concrete implementation
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Test mock with generic step definition
-class TestBtcAction extends BaseBtcAction<any, string, BaseBtcParams> {
-  protected getAddressSchema() {
-    return z.string().startsWith('0x');
-  }
-  protected getStatusConfig(): StatusConfig<string> {
-    return {
-      idle: 'idle',
-      ready: 'ready',
-      addressReady: 'address_ready',
-    };
-  }
-  protected getInitialSteps(): StepDefinition {
-    return { step1: StepStatus.IDLE };
-  }
-  protected isAuthorized(): boolean {
-    return true;
-  }
-  protected getChainId() {
-    return ChainId.sepolia;
-  }
-  protected getDepositAddressParams() {
-    return {
-      address: '0x123',
-      chainId: ChainId.sepolia,
-      signature: '0xsig',
-      token: 'LBTC',
-    };
-  }
-
-  protected getExpectedToken(): string {
-    return 'LBTC';
-  }
-
-  // Expose for testing
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Test helper accepts any params for validation testing
-  public testValidatePrepareParams(params: any) {
-    return this.validatePrepareParams(params);
-  }
-  public async testResumeFromExistingDeposit(recipient: string) {
-    return this.resumeFromExistingDeposit(recipient);
-  }
-}
-
-describe('BaseBtcAction', () => {
-  const params = { destChain: Chain.SEPOLIA };
-
-  it('should validate prepare params with correct schema', () => {
-    const action = new TestBtcAction(mockCtx, params, 'idle');
-    
-    // Valid params
-    expect(() => action.testValidatePrepareParams({
-      amount: '0.001',
-      recipient: '0x123',
-    })).not.toThrow();
-
-    // Invalid amount (too low)
-    expect(() => action.testValidatePrepareParams({
-      amount: '0.00001', // Below 0.0002 minimum
-      recipient: '0x123',
-    })).toThrow(/at least 0.0002/);
-
-    // Invalid recipient (schema check)
-    expect(() => action.testValidatePrepareParams({
-      amount: '0.001',
-      recipient: 'invalid', // Must start with 0x
-    })).toThrow();
-  });
-
-  it('should resume from existing deposit if found', async () => {
-    vi.mocked(mockCtx.api.getDepositAddress).mockResolvedValue('tb1existing...');
-    
-    const action = new TestBtcAction(mockCtx, params, 'idle');
-    const resumed = await action.testResumeFromExistingDeposit('0x123');
-    
-    expect(resumed).toBe(true);
-    expect(action.depositAddress).toBe('tb1existing...');
-    // resumeFromExistingDeposit does not update status; caller must handle it
-    expect(action.status).toBe('idle');
-  });
-
-  it('should not resume if no existing deposit', async () => {
-    vi.mocked(mockCtx.api.getDepositAddress).mockResolvedValue(undefined as unknown as string); // SDK types might return null/undefined
-    
-    const action = new TestBtcAction(mockCtx, params, 'idle');
-    const resumed = await action.testResumeFromExistingDeposit('0x123');
-    
-    expect(resumed).toBe(false);
-    expect(action.depositAddress).toBeUndefined();
-    expect(action.status).toBe('idle');
-  });
-});
-