@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/utils/err.ts

@@ -1,83 +0,0 @@
-import { Env } from '@lombard.finance/sdk-common';
-import { AxiosError } from 'axios';
-
-import { ChainId } from '../common/chains';
-import { Token } from '../tokens/token-addresses';
-
-/**
- * Retrieves the error message from the given error object.
- *
- * @param error - The error object.
- * @returns The error message as a string.
- */
-export function getErrorMessage(error: unknown): string {
-  if (typeof error === 'string') {
-    return error;
-  }
-
-  const hasDataMessage = (err: unknown): err is { data: { message: string } } =>
-    Boolean(
-      err &&
-        typeof err === 'object' &&
-        'data' in err &&
-        err.data &&
-        typeof err.data === 'object' &&
-        'message' in err.data &&
-        err?.data?.message &&
-        typeof err.data.message === 'string',
-    );
-
-  if (hasDataMessage(error)) {
-    return error.data.message;
-  }
-
-  if (error instanceof Error) {
-    return getAxiosErrorMessage(error as AxiosError);
-  }
-
-  return getErrorMessageFromObject(error);
-}
-
-function getAxiosErrorMessage(error: AxiosError): string {
-  if (error.response) {
-    return (error.response.data as { message: string }).message;
-  }
-
-  return error.message;
-}
-
-function getErrorMessageFromObject(error: unknown): string {
-  if (
-    error &&
-    typeof error === 'object' &&
-    'message' in error &&
-    typeof error.message === 'string'
-  ) {
-    return error.message;
-  }
-
-  return 'Unknown error';
-}
-
-export class TokenContractAddressNotFoundError extends Error {
-  constructor(
-    public readonly token: Token,
-    public readonly chainId: ChainId,
-    env?: Env,
-  ) {
-    const message = `Could not determine the ${token} contract address for given chain id: ${chainId} (env: ${env || 'undefined'})`;
-    super(message);
-  }
-}
-
-export class UnsupportedTokenFlow extends Error {
-  constructor(
-    public readonly tokenIn: Token,
-    public readonly tokenOut: Token | string,
-    public readonly chainId: ChainId,
-    env?: Env,
-  ) {
-    const message = `The flow of ${tokenIn} to ${tokenOut} on ${chainId} (env: ${env || 'undefined'}) is not supported`;
-    super(message);
-  }
-}

package/src/utils/evmAccount.ts

@@ -1,47 +0,0 @@
-import type { Address } from 'viem';
-
-import type { EvmProvider } from '../config/providers';
-
-export class WalletError extends Error {
-  constructor(message: string, options?: ErrorOptions) {
-    super(message, options);
-    this.name = 'WalletError';
-  }
-}
-
-/**
- * Retrieve the active EVM account from an EIP-1193 provider.
- *
- * Attempts a silent `eth_accounts` call first, then falls back to
- * `eth_requestAccounts` to prompt the wallet if necessary.
- */
-export async function getActiveEvmAccount(
-  provider: EvmProvider,
-): Promise<Address> {
-  try {
-    const accounts = (await provider.request({
-      method: 'eth_accounts',
-    })) as string[] | undefined;
-
-    const account =
-      accounts?.[0] ??
-      (
-        (await provider.request({
-          method: 'eth_requestAccounts',
-        })) as string[] | undefined
-      )?.[0];
-
-    if (!account) {
-      throw new WalletError('Wallet not connected');
-    }
-
-    return account as Address;
-  } catch (error) {
-    if (error instanceof WalletError) {
-      throw error;
-    }
-    throw new WalletError('Failed to retrieve wallet account', {
-      cause: error as Error,
-    });
-  }
-}

package/src/utils/gas.ts

@@ -1,36 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { PublicClient } from 'viem';
-
-export const estimateGasFees = async (
-  publicClient: PublicClient,
-  callData: Parameters<PublicClient['estimateContractGas']>[0],
-  overwriteMaxPriorityFeePerGas?: bigint,
-) => {
-  const fees = await publicClient.estimateFeesPerGas();
-
-  const multiplier = BigNumber(String(fees.maxFeePerGas)).dividedBy(
-    String(fees.maxPriorityFeePerGas),
-  );
-
-  const maxPriorityFeePerGas = overwriteMaxPriorityFeePerGas
-    ? overwriteMaxPriorityFeePerGas
-    : fees.maxPriorityFeePerGas;
-
-  const maxFeePerGas = overwriteMaxPriorityFeePerGas
-    ? BigInt(
-        BigNumber(String(maxPriorityFeePerGas))
-          .multipliedBy(multiplier)
-          .toFixed(0),
-      )
-    : fees.maxFeePerGas;
-
-  const gas = await publicClient.estimateContractGas(callData);
-
-  const gasEstimationData = {
-    gas,
-    maxFeePerGas,
-    maxPriorityFeePerGas,
-  };
-
-  return gasEstimationData;
-};

package/src/utils/hex.ts

@@ -1,9 +0,0 @@
-import { Hex } from 'viem';
-
-export function isHex(input: string): input is Hex {
-  return input.startsWith('0x');
-}
-
-export function ensureHex(input: string): Hex {
-  return isHex(input) ? input : `0x${input}`;
-}

package/src/utils/http.ts

@@ -1,224 +0,0 @@
-/**
- * HTTP Request Utilities
- *
- * Centralized HTTP request wrapper that:
- * - Adds SDK version headers to all requests
- * - Supports optional logging via Logger interface
- * - Tracks request duration for performance monitoring
- * - Provides consistent error handling
- *
- * @module utils/http
- */
-
-import axios, { type AxiosRequestConfig, type AxiosResponse } from 'axios';
-
-import type { Logger } from '../shared/context/types';
-import { SDK_RUNTIME, SDK_VERSION } from '../version';
-
-/**
- * HTTP request options
- */
-export interface HttpRequestOptions {
-  /** Request URL (full URL or path if baseURL provided) */
-  url: string;
-
-  /** HTTP method (defaults to GET) */
-  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-
-  /** Base URL for the request */
-  baseURL?: string;
-
-  /** Query parameters */
-  params?: Record<string, unknown>;
-
-  /** Request body (for POST/PUT/PATCH) */
-  body?: unknown;
-
-  /** Additional headers */
-  headers?: Record<string, string>;
-
-  /** Optional logger for request/response logging */
-  logger?: Logger;
-
-  /** Request timeout in milliseconds (default: 30000) */
-  timeout?: number;
-}
-
-/**
- * HTTP response with timing information
- */
-export interface HttpResponse<T> {
-  /** Response data */
-  data: T;
-
-  /** HTTP status code */
-  status: number;
-
-  /** Request duration in milliseconds */
-  duration: number;
-
-  /** Response headers */
-  headers: Record<string, string>;
-}
-
-/**
- * SDK headers added to all requests
- *
- * These headers help with:
- * - Backend analytics (tracking SDK version usage)
- * - Debugging (correlating errors with SDK version)
- * - Support (identifying client environment)
- */
-export function getSdkHeaders(): Record<string, string> {
-  return {
-    'X-SDK-Version': SDK_VERSION,
-    'X-SDK-Runtime': SDK_RUNTIME,
-  };
-}
-
-/**
- * Make an HTTP request with SDK headers and optional logging
- *
- * @param options - Request options
- * @returns Promise resolving to response with timing data
- *
- * @example
- * ```typescript
- * // Simple GET request
- * const { data, duration } = await httpRequest({
- *   url: 'https://api.lombard.finance/deposits',
- *   params: { address: '0x...' },
- * });
- *
- * // With logging
- * const { data } = await httpRequest({
- *   url: '/api/v1/points',
- *   baseURL: 'https://mainnet.prod.lombard.finance',
- *   logger: myLogger,
- * });
- * ```
- */
-export async function httpRequest<T = unknown>(
-  options: HttpRequestOptions,
-): Promise<HttpResponse<T>> {
-  const {
-    url,
-    method = 'GET',
-    baseURL,
-    params,
-    body,
-    headers = {},
-    logger,
-    timeout = 30000,
-  } = options;
-
-  const startTime = performance.now();
-
-  // Merge SDK headers with custom headers
-  const mergedHeaders = {
-    ...getSdkHeaders(),
-    'Content-Type': 'application/json',
-    ...headers,
-  };
-
-  const config: AxiosRequestConfig = {
-    url,
-    method,
-    baseURL,
-    params,
-    data: body,
-    headers: mergedHeaders,
-    timeout,
-  };
-
-  // Log request if logger provided
-  if (logger) {
-    logger.debug('HTTP Request', {
-      method,
-      url: baseURL ? `${baseURL}${url}` : url,
-      params,
-      hasBody: !!body,
-    });
-  }
-
-  try {
-    const response: AxiosResponse<T> = await axios(config);
-    const duration = performance.now() - startTime;
-
-    // Log successful response
-    if (logger) {
-      logger.debug('HTTP Response', {
-        method,
-        url: baseURL ? `${baseURL}${url}` : url,
-        status: response.status,
-        duration: Math.round(duration),
-      });
-    }
-
-    return {
-      data: response.data,
-      status: response.status,
-      duration,
-      headers: response.headers as Record<string, string>,
-    };
-  } catch (error) {
-    const duration = performance.now() - startTime;
-
-    // Log error
-    if (logger) {
-      const axiosError = axios.isAxiosError(error) ? error : null;
-      logger.error('HTTP Error', {
-        method,
-        url: baseURL ? `${baseURL}${url}` : url,
-        status: axiosError?.response?.status,
-        duration: Math.round(duration),
-        message: axiosError?.message || String(error),
-      });
-    }
-
-    throw error;
-  }
-}
-
-/**
- * Convenience method for GET requests
- */
-export async function httpGet<T = unknown>(
-  url: string,
-  options: Omit<HttpRequestOptions, 'url' | 'method' | 'body'> = {},
-): Promise<HttpResponse<T>> {
-  return httpRequest<T>({ ...options, url, method: 'GET' });
-}
-
-/**
- * Convenience method for POST requests
- */
-export async function httpPost<T = unknown>(
-  url: string,
-  body?: unknown,
-  options: Omit<HttpRequestOptions, 'url' | 'method' | 'body'> = {},
-): Promise<HttpResponse<T>> {
-  return httpRequest<T>({ ...options, url, method: 'POST', body });
-}
-
-/**
- * Convenience method for PUT requests
- */
-export async function httpPut<T = unknown>(
-  url: string,
-  body?: unknown,
-  options: Omit<HttpRequestOptions, 'url' | 'method' | 'body'> = {},
-): Promise<HttpResponse<T>> {
-  return httpRequest<T>({ ...options, url, method: 'PUT', body });
-}
-
-/**
- * Convenience method for DELETE requests
- */
-export async function httpDelete<T = unknown>(
-  url: string,
-  options: Omit<HttpRequestOptions, 'url' | 'method' | 'body'> = {},
-): Promise<HttpResponse<T>> {
-  return httpRequest<T>({ ...options, url, method: 'DELETE' });
-}
-

package/src/utils/numbers.ts

@@ -1,37 +0,0 @@
-import BigNumber from 'bignumber.js';
-
-export const ZERO = BigNumber(0);
-export const ONE = BigNumber(1);
-
-/**
- * Converts an integer value to BigInt.
- *
- * IMPORTANT: Input must already be in base units (satoshis, wei, etc).
- * - For BTC amounts: use `toSatoshi(btcAmount)` first
- * - For token amounts: use `toBaseDenomination(amount, decimals)` first
- *
- * @param input - Integer value in base units
- * @returns BigInt representation
- * @throws Error if input is not an integer
- *
- * @example
- * // ✅ Correct usage
- * toBigInt(toSatoshi("0.001")); // Convert BTC to satoshis first
- * toBigInt(toBaseDenomination("1.5", 18)); // Convert tokens to base units first
- * toBigInt(1000); // Already in base units
- *
- * // ❌ Wrong - will throw
- * toBigInt(0.001); // Decimal BTC amount
- */
-export default function toBigInt(input: BigNumber.Value): bigint {
-  const bn = BigNumber(input);
-
-  if (!bn.isInteger()) {
-    throw new Error(
-      `toBigInt received non-integer value "${input}". ` +
-        `Convert to base units first: use toSatoshi() for BTC or toBaseDenomination() for tokens.`,
-    );
-  }
-
-  return BigInt(bn.toFixed(0));
-}

package/src/utils/pagination.ts

@@ -1,70 +0,0 @@
-import axios from 'axios';
-
-/* -------------------------------------------------------------------------- */
-/*                                   Types                                    */
-/* -------------------------------------------------------------------------- */
-
-type FetchAllPaginatedParameters<T> = {
-  /** The API endpoint. */
-  endpoint: string | URL;
-  /** Function to extract items array from API response. */
-  extractItems: (data: unknown) => T[];
-  /** The additional query parameters. */
-  query?: Record<string, string | undefined>;
-  /** The page size, default: 1000 */
-  pageSize?: number;
-  /** The maximum amount of expected records. */
-  maxRecords?: number;
-};
-
-/* -------------------------------------------------------------------------- */
-/*                                  Helpers                                   */
-/* -------------------------------------------------------------------------- */
-
-/**
- * Generic helper to fetch all paginated items from an API endpoint.
- * Automatically handles `limit`, `offset` and the `has_more` flag.
- * If `has_more` is missing, pagination stops.
- *
- * @template T - Type of individual item
- * @param {FetchAllPaginatedParameters<T>} params - Parameters for fetching all items
-
- *
- * @returns {Promise<T[]>} - All items fetched across pages
- */
-export async function fetchAllPaginated<T>({
-  endpoint,
-  extractItems,
-  query = {},
-  pageSize = 1_000,
-  maxRecords,
-}: FetchAllPaginatedParameters<T>): Promise<T[]> {
-  let allItems: T[] = [];
-  let offset = 0;
-  let hasMore = true;
-
-  while (hasMore) {
-    const url = new URL(endpoint);
-
-    url.searchParams.set('limit', pageSize.toString());
-    url.searchParams.set('offset', offset.toString());
-    for (const [key, value] of Object.entries(query)) {
-      if (value !== undefined) url.searchParams.set(key, String(value));
-    }
-
-    const { data } = await axios.get(url.toString());
-    const items = extractItems(data);
-
-    allItems = allItems.concat(items);
-    offset += items.length;
-
-    if (maxRecords && allItems.length >= maxRecords) {
-      allItems = allItems.slice(0, maxRecords);
-      break;
-    }
-
-    hasMore = items.length > 0 && (data.has_more ?? false);
-  }
-
-  return allItems;
-}

package/src/utils/satoshi.ts

@@ -1,41 +0,0 @@
-import BigNumber from 'bignumber.js';
-
-export const BTC_DECIMALS = 8;
-export const SATOSHI_SCALE = BigNumber(10).pow(BTC_DECIMALS);
-
-/**
- * Converts Satoshi to BTC
- * @param amount - Satoshi amount (integer)
- * @returns BTC amount (decimal, e.g., 0.00001992)
- */
-export function fromSatoshi(amount: BigNumber.Value): BigNumber {
-  return BigNumber(amount).dividedBy(SATOSHI_SCALE);
-}
-
-/**
- * Converts BTC to Satoshi
- *
- * @param amount - BTC amount (decimal, e.g., 0.00001992)
- * @returns Satoshi amount (integer, e.g., 1992)
- */
-export function toSatoshi(amount: BigNumber.Value): BigNumber {
-  return BigNumber(amount)
-    .multipliedBy(SATOSHI_SCALE)
-    .decimalPlaces(0, BigNumber.ROUND_HALF_UP);
-}
-
-/**
- * Converts BTC amount to BigInt satoshis
- *
- * Use this when you need to pass a BTC amount to a function expecting BigInt.
- *
- * @param btcAmount - BTC amount (decimal, e.g., "0.00001992")
- * @returns BigInt satoshi amount (e.g., 1992n)
- *
- * @example
- * const fee = "0.00001992"; // from getLBTCMintingFee
- * const feeSatoshis = toSatoshiBigInt(fee); // 1992n
- */
-export function toSatoshiBigInt(btcAmount: BigNumber.Value): bigint {
-  return BigInt(toSatoshi(btcAmount).toFixed(0));
-}

package/src/utils/time.ts

@@ -1,12 +0,0 @@
-export const SECOND = 1000;
-export const MINUTE = 60 * SECOND;
-export const HOUR = 60 * MINUTE;
-export const DAY = 24 * HOUR;
-
-export function now() {
-  return Date.now();
-}
-
-export function toUnix(ms: number) {
-  return Math.round(ms / 1000);
-}