@lombard.finance/sdk 3.7.4 → 4.0.0

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

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

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

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

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

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

@@ -0,0 +1,114 @@
+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');
+  });
+});
+