@lombard.finance/sdk 3.7.4 → 4.0.0

package/src/services/index.ts

@@ -0,0 +1,43 @@
+/**
+ * Service Classes
+ *
+ * Concrete implementations of service interfaces defined in sdk-common.
+ * These are instantiated by modules and injected into action contexts.
+ *
+ * Naming convention:
+ * - sdk-common: `interface ApiService` (contract)
+ * - sdk: `class ApiService implements IApiService` (implementation)
+ *
+ * Type separation:
+ * - Services return minimal types (for internal use by actions)
+ * - Public APIs return rich types (for external use)
+ *
+ * @module services
+ */
+
+export { ApiService } from './ApiService';
+export { BtcService } from './BtcService';
+export { EvmService } from './EvmService';
+
+// Re-export service interfaces from sdk-common for convenience
+// Use these for typing, use the classes above for instantiation
+export type {
+  BtcNetworkMode,
+  DepositInfo,
+  DestinationChainId,
+  EvmChainId,
+  FeeAuthorizationResult,
+  FeeSignatureResult,
+  GenerateDepositAddressParams,
+  GetDepositAddressParams,
+  GetFeeSignatureParams,
+  ApiService as IApiService,
+  BtcService as IBtcService,
+  EvmService as IEvmService,
+  SignNetworkFeeParams,
+  SignNetworkFeeResult,
+  SignStakeAndBakeParams,
+  StoredFeeSignature,
+  StoreFeeSignatureParams,
+  StoreStakeAndBakeParams,
+} from '@lombard.finance/sdk-common';

package/src/shared/__tests__/errors.test.ts

@@ -0,0 +1,185 @@
+/**
+ * Tests for error handling
+ *
+ * Verifies LombardError class and error code enums.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import {
+  ContractErrorCode,
+  ErrorCode,
+  LombardError,
+  ProviderErrorCode,
+  RegistryErrorCode,
+  ValidationErrorCode,
+} from '../errors';
+
+describe('LombardError', () => {
+  it('should create error with code and message', () => {
+    const error = new LombardError(
+      ErrorCode.UNKNOWN_ERROR,
+      'Something went wrong',
+    );
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error).toBeInstanceOf(LombardError);
+    expect(error.code).toBe(ErrorCode.UNKNOWN_ERROR);
+    expect(error.message).toBe('Something went wrong');
+    expect(error.name).toBe('LombardError');
+  });
+
+  it('should accept metadata', () => {
+    const error = new LombardError(
+      ProviderErrorCode.PROVIDER_MISSING,
+      'Provider not configured',
+      {
+        chain: 'ethereum',
+        requiredProvider: 'evm',
+      },
+    );
+
+    expect(error.metadata).toEqual({
+      chain: 'ethereum',
+      requiredProvider: 'evm',
+    });
+  });
+
+  it('should have proper stack trace', () => {
+    const error = new LombardError(ErrorCode.UNKNOWN_ERROR, 'Test error');
+    expect(error.stack).toBeDefined();
+    expect(error.stack).toContain('LombardError');
+  });
+
+  it('should serialize to JSON with all properties', () => {
+    const error = new LombardError(
+      RegistryErrorCode.ROUTE_NOT_FOUND,
+      'Route not found',
+      {
+        assetIn: 'BTC',
+        assetOut: 'LBTC',
+      },
+    );
+
+    const json = error.toJSON();
+    expect(json).toMatchObject({
+      code: RegistryErrorCode.ROUTE_NOT_FOUND,
+      message: 'Route not found',
+      metadata: {
+        assetIn: 'BTC',
+        assetOut: 'LBTC',
+      },
+    });
+    // Also verify new properties exist
+    expect(json.name).toBe('LombardError');
+    expect(json.sdkVersion).toBeDefined();
+    expect(json.timestamp).toBeDefined();
+  });
+
+  it('should include cause if provided', () => {
+    const cause = new Error('Original error');
+    const error = new LombardError(ErrorCode.UNKNOWN_ERROR, 'Wrapped error', {
+      originalError: cause.message,
+    });
+
+    expect(error.metadata?.originalError).toBe('Original error');
+  });
+});
+
+describe('Error Code Enums', () => {
+  describe('ErrorCode', () => {
+    it('should define general error codes', () => {
+      expect(ErrorCode.UNKNOWN_ERROR).toBe('unknown-error');
+      expect(ErrorCode.INVALID_CONFIGURATION).toBe('invalid-configuration');
+      expect(ErrorCode.OPERATION_TIMEOUT).toBe('operation-timeout');
+      expect(ErrorCode.OPERATION_CANCELLED).toBe('operation-cancelled');
+    });
+  });
+
+  describe('ProviderErrorCode', () => {
+    it('should define provider error codes', () => {
+      expect(ProviderErrorCode.PROVIDER_MISSING).toBe('provider-missing');
+      expect(ProviderErrorCode.PROVIDER_INITIALIZATION_FAILED).toBe(
+        'provider-initialization-failed',
+      );
+      expect(ProviderErrorCode.PROVIDER_CALL_FAILED).toBe(
+        'provider-call-failed',
+      );
+      expect(ProviderErrorCode.SIGNER_MISSING).toBe('signer-missing');
+      expect(ProviderErrorCode.USER_REJECTED).toBe('user-rejected');
+    });
+  });
+
+  describe('RegistryErrorCode', () => {
+    it('should define registry error codes', () => {
+      expect(RegistryErrorCode.ROUTE_NOT_FOUND).toBe('route-not-found');
+      expect(RegistryErrorCode.INVALID_ROUTE_DEFINITION).toBe(
+        'invalid-route-definition',
+      );
+      expect(RegistryErrorCode.UNSUPPORTED_CHAIN).toBe('unsupported-chain');
+      expect(RegistryErrorCode.UNSUPPORTED_ASSET).toBe('unsupported-asset');
+      expect(RegistryErrorCode.INCOMPATIBLE_ROUTE).toBe('incompatible-route');
+    });
+  });
+
+  describe('ValidationErrorCode', () => {
+    it('should define validation error codes', () => {
+      expect(ValidationErrorCode.INVALID_ADDRESS).toBe('invalid-address');
+      expect(ValidationErrorCode.INVALID_AMOUNT).toBe('invalid-amount');
+      expect(ValidationErrorCode.AMOUNT_TOO_SMALL).toBe('amount-too-small');
+      expect(ValidationErrorCode.AMOUNT_TOO_LARGE).toBe('amount-too-large');
+      expect(ValidationErrorCode.INSUFFICIENT_BALANCE).toBe(
+        'insufficient-balance',
+      );
+      expect(ValidationErrorCode.INVALID_PARAMETER).toBe('invalid-parameter');
+    });
+  });
+
+  describe('ContractErrorCode', () => {
+    it('should define contract error codes', () => {
+      expect(ContractErrorCode.CONTRACT_CALL_FAILED).toBe(
+        'contract-call-failed',
+      );
+      expect(ContractErrorCode.TRANSACTION_FAILED).toBe('transaction-failed');
+      expect(ContractErrorCode.TRANSACTION_REVERTED).toBe(
+        'transaction-reverted',
+      );
+      expect(ContractErrorCode.APPROVAL_FAILED).toBe('approval-failed');
+      expect(ContractErrorCode.INSUFFICIENT_ALLOWANCE).toBe(
+        'insufficient-allowance',
+      );
+      expect(ContractErrorCode.GAS_ESTIMATION_FAILED).toBe(
+        'gas-estimation-failed',
+      );
+    });
+  });
+});
+
+describe('Error Factory Functions', () => {
+  it('should create provider errors with factory', () => {
+    const error = LombardError.providerMissing('ethereum', 'evm');
+
+    expect(error.code).toBe(ProviderErrorCode.PROVIDER_MISSING);
+    expect(error.message).toContain('ethereum');
+    expect(error.metadata?.chain).toBe('ethereum');
+  });
+
+  it('should create validation errors with factory', () => {
+    const error = LombardError.invalidAmount('Must be greater than 0');
+
+    expect(error.code).toBe(ValidationErrorCode.INVALID_AMOUNT);
+    expect(error.message).toBe('Must be greater than 0');
+  });
+
+  it('should create registry errors with factory', () => {
+    const error = LombardError.routeNotFound({
+      assetIn: 'BTC',
+      assetOut: 'LBTC',
+      sourceChain: 'bitcoin-mainnet',
+      destChain: 'ethereum',
+    });
+
+    expect(error.code).toBe(RegistryErrorCode.ROUTE_NOT_FOUND);
+    expect(error.metadata).toBeDefined();
+  });
+});

package/src/shared/__tests__/events.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Tests for event type definitions
+ *
+ * These tests verify the structure of event types and event maps.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import type { StrategyProgress } from '../../core/types';
+import { ErrorCode, type LombardError } from '../errors';
+import {
+  BridgeEvent,
+  DeployEvent,
+  DepositEvent,
+  type DepositEventMap,
+  RedeemEvent,
+  UnstakeEvent,
+} from '../events';
+
+describe('Event Types', () => {
+  describe('DepositEvent Enum', () => {
+    it('should define all deposit events', () => {
+      expect(DepositEvent.Progress).toBe('progress');
+      expect(DepositEvent.StatusChange).toBe('status-change');
+      expect(DepositEvent.Completed).toBe('completed');
+      expect(DepositEvent.Failed).toBe('failed');
+      expect(DepositEvent.Error).toBe('error');
+    });
+  });
+
+  describe('RedeemEvent Enum', () => {
+    it('should define all redeem events', () => {
+      expect(RedeemEvent.Progress).toBe('progress');
+      expect(RedeemEvent.StatusChange).toBe('status-change');
+      expect(RedeemEvent.Completed).toBe('completed');
+      expect(RedeemEvent.Failed).toBe('failed');
+      expect(RedeemEvent.Error).toBe('error');
+    });
+  });
+
+  describe('UnstakeEvent Enum', () => {
+    it('should define all unstake events', () => {
+      expect(UnstakeEvent.Progress).toBe('progress');
+      expect(UnstakeEvent.StatusChange).toBe('status-change');
+      expect(UnstakeEvent.Completed).toBe('completed');
+      expect(UnstakeEvent.Failed).toBe('failed');
+      expect(UnstakeEvent.Error).toBe('error');
+    });
+  });
+
+  describe('DeployEvent Enum', () => {
+    it('should define all deploy events', () => {
+      expect(DeployEvent.Progress).toBe('progress');
+      expect(DeployEvent.StatusChange).toBe('status-change');
+      expect(DeployEvent.Completed).toBe('completed');
+      expect(DeployEvent.Failed).toBe('failed');
+      expect(DeployEvent.Error).toBe('error');
+    });
+  });
+
+  describe('BridgeEvent Enum', () => {
+    it('should define all bridge events', () => {
+      expect(BridgeEvent.Progress).toBe('progress');
+      expect(BridgeEvent.StatusChange).toBe('status-change');
+      expect(BridgeEvent.Completed).toBe('completed');
+      expect(BridgeEvent.Failed).toBe('failed');
+      expect(BridgeEvent.Error).toBe('error');
+    });
+  });
+
+  describe('DepositEventMap Type', () => {
+    it('should map events to their handler types', () => {
+      const progressHandler: DepositEventMap[typeof DepositEvent.Progress] = (
+        progress: StrategyProgress<string>,
+      ) => {
+        expect(progress).toBeDefined();
+      };
+
+      const statusHandler: DepositEventMap[typeof DepositEvent.StatusChange] = (
+        status: string,
+      ) => {
+        expect(typeof status).toBe('string');
+      };
+
+      const completedHandler: DepositEventMap[typeof DepositEvent.Completed] =
+        () => {
+          // No params
+        };
+
+      const errorHandler: DepositEventMap[typeof DepositEvent.Error] = (
+        error: LombardError,
+      ) => {
+        expect(error).toBeDefined();
+      };
+
+      // Call handlers to verify they work
+      progressHandler({ status: 'executing', steps: {} });
+      statusHandler('ready');
+      completedHandler();
+      errorHandler({
+        code: ErrorCode.UNKNOWN_ERROR,
+        message: 'Test',
+        name: 'LombardError',
+        sdkVersion: '3.8.0',
+        timestamp: new Date().toISOString(),
+        toJSON: () => ({
+          code: ErrorCode.UNKNOWN_ERROR,
+          message: 'Test',
+          name: 'LombardError',
+        }),
+        toSentryContext: () => ({
+          errorCode: ErrorCode.UNKNOWN_ERROR,
+          errorMessage: 'Test',
+          sdkVersion: '3.8.0',
+          timestamp: new Date().toISOString(),
+        }),
+      } as LombardError);
+    });
+  });
+});

package/src/shared/__tests__/types.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Tests for shared types and enums
+ *
+ * These tests verify the structure and behavior of core SDK types.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import {
+  AssetId,
+  Chain,
+  type RouteParams,
+  StepStatus,
+  type StrategyProgress,
+  StrategyStatus,
+} from '../../core';
+
+describe('Shared Types', () => {
+  describe('AssetId Enum', () => {
+    it('should define core assets', () => {
+      expect(AssetId.BTC).toBe('BTC');
+      expect(AssetId.LBTC).toBe('LBTC');
+      expect(AssetId.BTCb).toBe('BTC.b');
+      expect(AssetId.ETH).toBe('ETH');
+      expect(AssetId.L_ETH).toBe('L-ETH');
+    });
+
+    it('should define V1 assets', () => {
+      expect(AssetId.ZEC).toBe('ZEC');
+      expect(AssetId.L_ZEC).toBe('L-ZEC');
+      expect(AssetId.XRP).toBe('XRP');
+      expect(AssetId.L_XRP).toBe('L-XRP');
+      expect(AssetId.DOGE).toBe('DOGE');
+      expect(AssetId.L_DOGE).toBe('L-DOGE');
+      expect(AssetId.SOL).toBe('SOL');
+      expect(AssetId.L_SOL).toBe('L-SOL');
+    });
+
+    it('should define wrapped assets', () => {
+      expect(AssetId.WBTC).toBe('WBTC');
+    });
+  });
+
+  describe('Chain Enum', () => {
+    it('should define Bitcoin chains', () => {
+      // BIP122 uses first 32 chars of genesis block hash
+      expect(Chain.BITCOIN_MAINNET).toBe(
+        'bip122:000000000019d6689c085ae165831e93',
+      );
+      expect(Chain.BITCOIN_SIGNET).toBe(
+        'bip122:00000008819873e925422c1ff0f99f7c',
+      );
+    });
+
+    it('should define EVM chains', () => {
+      expect(Chain.ETHEREUM).toBe('eip155:1');
+      expect(Chain.BASE).toBe('eip155:8453');
+      expect(Chain.BSC).toBe('eip155:56');
+      expect(Chain.AVALANCHE).toBe('eip155:43114');
+    });
+
+    it('should define other chains', () => {
+      // Solana uses first 32 chars of genesis hash
+      expect(Chain.SOLANA_MAINNET).toBe(
+        'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      );
+      expect(Chain.SOLANA_DEVNET).toBe(
+        'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+      );
+      expect(Chain.SUI_MAINNET).toBe('sui:mainnet');
+      expect(Chain.STARKNET_MAINNET).toBe('starknet:SN_MAIN');
+      expect(Chain.ZCASH_MAINNET).toBe('zcash:mainnet');
+      expect(Chain.ZCASH_TESTNET).toBe('zcash:testnet');
+      expect(Chain.RIPPLE_MAINNET).toBe('ripple:mainnet');
+      expect(Chain.DOGECOIN_MAINNET).toBe('dogecoin:mainnet');
+    });
+  });
+
+  describe('StrategyStatus Enum', () => {
+    it('should define common statuses', () => {
+      expect(StrategyStatus.IDLE).toBe('idle');
+      expect(StrategyStatus.PREPARING).toBe('preparing');
+      expect(StrategyStatus.READY).toBe('ready');
+      expect(StrategyStatus.EXECUTING).toBe('executing');
+      expect(StrategyStatus.COMPLETED).toBe('completed');
+      expect(StrategyStatus.FAILED).toBe('failed');
+    });
+  });
+
+  describe('StepStatus Enum', () => {
+    it('should define step statuses', () => {
+      expect(StepStatus.IDLE).toBe('idle');
+      expect(StepStatus.PENDING).toBe('pending');
+      expect(StepStatus.COMPLETE).toBe('complete');
+      expect(StepStatus.FAILED).toBe('failed');
+    });
+  });
+
+  describe('StrategyProgress Interface', () => {
+    it('should accept valid progress objects', () => {
+      const progress: StrategyProgress<StrategyStatus> = {
+        status: StrategyStatus.EXECUTING,
+        steps: {
+          approval: StepStatus.COMPLETE,
+          execution: StepStatus.PENDING,
+        },
+        metadata: {
+          txHash: '0x123',
+        },
+      };
+
+      expect(progress.status).toBe(StrategyStatus.EXECUTING);
+      expect(progress.steps.approval).toBe(StepStatus.COMPLETE);
+      expect(progress.metadata?.txHash).toBe('0x123');
+    });
+
+    it('should allow confirmations tracking', () => {
+      const progress: StrategyProgress<StrategyStatus> = {
+        status: StrategyStatus.EXECUTING,
+        steps: {},
+        confirmations: 2,
+        requiredConfirmations: 6,
+      };
+
+      expect(progress.confirmations).toBe(2);
+      expect(progress.requiredConfirmations).toBe(6);
+    });
+  });
+
+  describe('RouteParams Interface', () => {
+    it('should accept basic route params', () => {
+      const params: RouteParams = {
+        assetIn: AssetId.BTC,
+        assetOut: AssetId.LBTC,
+        sourceChain: Chain.BITCOIN_MAINNET,
+        destChain: Chain.ETHEREUM,
+      };
+
+      expect(params.assetIn).toBe(AssetId.BTC);
+      expect(params.assetOut).toBe(AssetId.LBTC);
+      expect(params.sourceChain).toBe(Chain.BITCOIN_MAINNET);
+      expect(params.destChain).toBe(Chain.ETHEREUM);
+    });
+
+    it('should allow optional fields', () => {
+      const params: RouteParams = {
+        assetOut: AssetId.LBTC,
+        destChain: Chain.ETHEREUM,
+      };
+
+      expect(params.assetOut).toBe(AssetId.LBTC);
+      expect(params.assetIn).toBeUndefined();
+    });
+  });
+});