@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/modules/index.ts

@@ -1,60 +0,0 @@
-/**
- * Module System Exports
- *
- * Modules provide service implementations using the Service-First pattern:
- * - Service interfaces define the contract (in sdk-common)
- * - Service classes implement the interfaces (in services/)
- * - Module factories instantiate services with context
- *
- * Module Types:
- * - SdkModule: Generic module (e.g., apiModule) - for non-chain services
- * - ChainModule: Chain-specific module (e.g., btcModule, evmModule)
- *
- * Service Types:
- * - Internal services: Minimal types, for action DI (not exposed publicly)
- * - Public APIs: Rich types, for user-facing methods (sdk.deposits.*, etc.)
- *
- * @module modules
- */
-
-export { CapabilityRegistry } from './CapabilityRegistry';
-
-// BTC Module (chain-specific)
-export { btcModule, BtcService } from './btcModule';
-
-// EVM Module (chain-specific)
-export type {
-  EvmChainId,
-  FeeAuthorizationResult,
-  StoredFeeSignature,
-} from './evmModule';
-export { evmModule, EvmService } from './evmModule';
-
-// API Module (generic SDK module, not chain-specific)
-export type {
-  DepositInfo,
-  GenerateDepositAddressParams,
-  GetDepositAddressParams,
-} from './apiModule';
-export { apiModule, ApiService } from './apiModule';
-
-// Module types from sdk-common
-export type {
-  // Any module
-  AnyModule,
-  // Chain-specific module type
-  ChainModule,
-  ModuleId,
-  // Helper types
-  RegisterContext,
-  // Generic module type
-  SdkModule,
-  ServiceOf,
-} from '@lombard.finance/sdk-common';
-
-// Service interface types (from sdk-common, aliased for clarity)
-export type {
-  ApiService as IApiService,
-  BtcService as IBtcService,
-  EvmService as IEvmService,
-} from '@lombard.finance/sdk-common';

package/src/referrals/ReferralsClient.ts

@@ -1,34 +0,0 @@
-import { getDepositAddressReferrer } from '../api-functions/getDepositAddressReferrer';
-import type { LombardSDK } from '../client/LombardSDK';
-
-export interface ReferralLookupParams {
-  /** Destination account that previously generated a BTC deposit address */
-  address: string;
-}
-
-export interface ReferralLookupResult {
-  hasDepositAddress: boolean;
-  referrer?: string;
-}
-
-/**
- * Referral helper namespace.
- *
- * Provides read APIs for referral metadata so partners do not need to query
- * Lombard REST endpoints directly.
- */
-export class ReferralsClient {
-  constructor(private readonly sdk: LombardSDK) {}
-
-  /**
-   * Fetch the referrer bound to a previously generated BTC deposit address.
-   */
-  async lookupReferrer({
-    address,
-  }: ReferralLookupParams): Promise<ReferralLookupResult> {
-    return getDepositAddressReferrer({
-      address,
-      env: this.sdk.config.env,
-    });
-  }
-}

package/src/referrals/index.ts

@@ -1 +0,0 @@
-export * from './ReferralsClient';

package/src/services/ApiService.ts

@@ -1,152 +0,0 @@
-/**
- * API Service
- *
- * Provides Lombard backend API operations for internal use by actions.
- * Returns minimal types defined in sdk-common.
- *
- * For public APIs with full types, use the exported functions in api-functions/
- * or the SDK namespace methods.
- *
- * @module services/ApiService
- */
-
-import type { Env } from '@lombard.finance/sdk-common';
-import type {
-  ApiService as IApiService,
-  DepositInfo,
-  FeeSignatureResult,
-  GenerateDepositAddressParams,
-  GetDepositAddressParams,
-  GetFeeSignatureParams,
-  StoreFeeSignatureParams,
-  StoreStakeAndBakeParams,
-} from '@lombard.finance/sdk-common';
-
-import { generateDepositBtcAddress } from '../api-functions/generateDepositBtcAddress/generateDepositBtcAddress';
-import { getDepositBtcAddress } from '../api-functions/getDepositBtcAddress/getDepositBtcAddress';
-import { getDepositsByAddress } from '../api-functions/getDepositsByAddress/getDepositsByAddress';
-import { getNetworkFeeSignature } from '../api-functions/getNetworkFeeSignature/getNetworkFeeSignature';
-import { storeNetworkFeeSignature } from '../api-functions/storeNetworkFeeSignature/storeNetworkFeeSignature';
-import { storeStakeAndBakeSignature } from '../api-functions/storeStakeAndBakeSignature/storeStakeAndBakeSignature';
-import type {
-  ChainId,
-  SolanaChain,
-  StarknetChainId,
-  SuiChain,
-} from '../common/chains';
-import { Token } from '../tokens/token-addresses';
-
-type DestChainId = ChainId | SolanaChain | SuiChain | StarknetChainId;
-
-/**
- * API Service
- *
- * Implementation of the ApiService interface from sdk-common.
- * Wraps low-level API functions for use by actions.
- *
- * @remarks
- * This service returns minimal types (DepositInfo) suitable for internal use.
- * For full deposit details, use getDepositsByAddress() directly.
- */
-export class ApiService implements IApiService {
-  constructor(private readonly env: Env) {}
-
-  /**
-   * Generate a new BTC deposit address
-   */
-  async generateDepositAddress(
-    params: GenerateDepositAddressParams,
-  ): Promise<string> {
-    return generateDepositBtcAddress({
-      address: params.address,
-      chainId: params.chainId as DestChainId,
-      signature: params.signature,
-      token: params.token as Token,
-      eip712Data: params.eip712Data,
-      signatureData: params.signatureData,
-      pubKey: params.pubKey,
-      env: this.env,
-      partnerId: params.partnerId,
-      referrerCode: params.referrerCode,
-    });
-  }
-
-  /**
-   * Get existing deposit address for a recipient
-   */
-  async getDepositAddress(
-    params: GetDepositAddressParams,
-  ): Promise<string | undefined> {
-    try {
-      const address = await getDepositBtcAddress({
-        address: params.address,
-        chainId: params.chainId as DestChainId,
-        token: params.token as Token,
-        env: this.env,
-        partnerId: params.partnerId,
-      });
-      return address || undefined;
-    } catch {
-      // No address found
-      return undefined;
-    }
-  }
-
-  /**
-   * Get deposits for an address
-   */
-  async getDeposits(address: string): Promise<DepositInfo[]> {
-    const deposits = await getDepositsByAddress({
-      address,
-      env: this.env,
-    });
-
-    return deposits.map(d => ({
-      depositAddress: d.depositAddress ?? '',
-      blockHeight: d.blockHeight,
-      isClaimed: d.isClaimed,
-      txid: d.txHash,
-      amount: d.amount?.toString(),
-    }));
-  }
-
-  /**
-   * Store network fee signature
-   */
-  async storeFeeSignature(params: StoreFeeSignatureParams): Promise<void> {
-    await storeNetworkFeeSignature({
-      address: params.address,
-      signature: params.signature,
-      typedData: params.typedData,
-      env: this.env,
-      tokenAddress: params.tokenAddress,
-    });
-  }
-
-  /**
-   * Get stored network fee signature
-   */
-  async getFeeSignature(
-    params: GetFeeSignatureParams,
-  ): Promise<FeeSignatureResult> {
-    return getNetworkFeeSignature({
-      address: params.address,
-      chainId: params.chainId as ChainId,
-      env: this.env,
-      tokenAddress: params.tokenAddress,
-    });
-  }
-
-  /**
-   * Store stake and bake signature
-   */
-  async storeStakeAndBakeSignature(
-    params: StoreStakeAndBakeParams,
-  ): Promise<void> {
-    await storeStakeAndBakeSignature({
-      signature: params.signature,
-      typedData: params.typedData,
-      env: this.env,
-    });
-  }
-}

package/src/services/BtcService.ts

@@ -1,29 +0,0 @@
-/**
- * BTC Service
- *
- * Provides Bitcoin-specific operations via mempool API.
- *
- * @module services/BtcService
- */
-
-import type {
-  BtcNetworkMode,
-  BtcService as IBtcService,
-} from '@lombard.finance/sdk-common';
-
-import { getCurrentBlockHeight } from '../chains/btc/client/getCurrentBlockHeight';
-
-/**
- * BTC Service
- *
- * Implementation of the BtcService interface from sdk-common.
- * Provides Bitcoin blockchain operations.
- */
-export class BtcService implements IBtcService {
-  /**
-   * Get current block height from mempool
-   */
-  async getCurrentBlockHeight(network: BtcNetworkMode): Promise<number> {
-    return getCurrentBlockHeight(network);
-  }
-}

package/src/services/EvmService.ts

@@ -1,127 +0,0 @@
-/**
- * EVM Service
- *
- * Provides EVM-specific operations via contract functions.
- *
- * @module services/EvmService
- */
-
-import type {
-    Env,
-    EvmChainId,
-    EvmProvider,
-    EvmService as IEvmService,
-    SignNetworkFeeParams,
-    SignNetworkFeeResult,
-    SignStakeAndBakeParams,
-} from '@lombard.finance/sdk-common';
-import BigNumber from 'bignumber.js';
-import type { EIP1193Provider } from 'viem';
-
-import type { ChainId } from '../common/chains';
-import { getMintingFee } from '../contract-functions/getLBTCMintingFee/getLBTCMintingFee';
-import { getStakeAndBakeFee } from '../contract-functions/getStakeAndBakeFee/getStakeAndBakeFee';
-import { signLbtcDestinationAddr } from '../contract-functions/signLbtcDestionationAddr/signLbtcDestinationAddr';
-import { signNetworkFee } from '../contract-functions/signNetworkFee/signNetworkFee';
-import { signStakeAndBake } from '../contract-functions/signStakeAndBake/signStakeAndBake';
-import type { DefiProtocol, StakeAndBakeToken } from '../defi/defi-registry';
-import { Token } from '../tokens/token-addresses';
-
-/**
- * EVM Service
- *
- * Implementation of the EvmService interface from sdk-common.
- * Provides EVM contract interactions and fee authorization.
- */
-export class EvmService implements IEvmService {
-  constructor(private readonly env: Env) {}
-
-  /**
-   * Get minting fee for a chain
-   * @param chainId - The chain ID
-   * @param token - Optional token (defaults to LBTC). Use Token.BTCb for BTC.b deposits.
-   */
-  async getMintingFee(chainId: EvmChainId, token?: string): Promise<string> {
-    const fee = await getMintingFee({
-      token: (token as Token) || Token.LBTC,
-      chainId: chainId as ChainId,
-      env: this.env,
-    });
-    return fee.toString();
-  }
-
-  /**
-   * Sign network fee authorization (EIP-712)
-   */
-  async signNetworkFee(
-    params: SignNetworkFeeParams,
-  ): Promise<SignNetworkFeeResult> {
-    const result = await signNetworkFee({
-      fee: new BigNumber(params.fee),
-      account: params.account as `0x${string}`,
-      chainId: params.chainId as ChainId,
-      provider: params.provider as EIP1193Provider,
-      env: this.env,
-      // Pass token for signing - defaults to LBTC for backwards compatibility
-      token: (params.token as Token) ?? Token.LBTC,
-    });
-
-    return {
-      signature: result.signature,
-      typedData: result.typedData,
-    };
-  }
-
-  /**
-   * Get stake and bake fee for a vault
-   */
-  async getStakeAndBakeFee(
-    chainId: EvmChainId,
-    protocol: DefiProtocol,
-  ): Promise<string> {
-    const fee = await getStakeAndBakeFee({
-      chainId: chainId as ChainId,
-      protocol,
-    });
-    return fee.toString();
-  }
-
-  /**
-   * Sign stake and bake authorization
-   */
-  async signStakeAndBake(
-    params: SignStakeAndBakeParams,
-  ): Promise<SignNetworkFeeResult> {
-    const result = await signStakeAndBake({
-      value: new BigNumber(params.value),
-      account: params.account as `0x${string}`,
-      chainId: params.chainId as ChainId,
-      provider: params.provider as EIP1193Provider,
-      env: this.env,
-      vaultKey: params.vaultKey as DefiProtocol,
-      token: params.token as StakeAndBakeToken,
-    });
-
-    return {
-      signature: result.signature,
-      typedData: result.typedData,
-    };
-  }
-
-  /**
-   * Sign LBTC destination address (for non-Ethereum EVM chains)
-   */
-  async signLbtcDestination(params: {
-    chainId: EvmChainId;
-    address: string;
-    provider: EvmProvider;
-  }): Promise<{ signature: string }> {
-    const signature = await signLbtcDestinationAddr({
-      account: params.address as `0x${string}`,
-      chainId: params.chainId as ChainId,
-      provider: params.provider as EIP1193Provider,
-    });
-
-    return { signature };
-  }
-}

package/src/services/index.ts

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

@@ -1,185 +0,0 @@
-/**
- * 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();
-  });
-});