@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/client/createConfig.ts

@@ -1,90 +0,0 @@
-import type { AnyModule, ProviderKey } from '@lombard.finance/sdk-common';
-
-import type { CreateConfigOptions, LombardConfig } from '../config/types';
-import { validateAndApplyDefaults } from '../config/validation';
-import { apiModule } from '../modules/apiModule';
-import { btcModule } from '../modules/btcModule';
-import { evmModule } from '../modules/evmModule';
-import { LombardError } from '../shared/errors';
-import { createConsoleLogger } from '../utils/consoleLogger';
-
-function mergeModules(provided: readonly AnyModule[] | undefined): AnyModule[] {
-  const modules = new Map<string, AnyModule>();
-  const builtIns: AnyModule[] = [btcModule(), evmModule(), apiModule()];
-  for (const mod of builtIns) {
-    modules.set(mod.id, mod);
-  }
-  if (provided) {
-    for (const mod of provided) {
-      modules.set(mod.id, mod);
-    }
-  }
-  return Array.from(modules.values());
-}
-
-function ensureProviders(
-  modules: readonly AnyModule[],
-  config: Pick<LombardConfig, 'providers'>,
-): void {
-  for (const mod of modules) {
-    for (const key of mod.requiresProviders ?? []) {
-      if (!hasProvider(config, key)) {
-        throw LombardError.providerMissing(key, key);
-      }
-    }
-  }
-}
-
-function hasProvider(
-  config: Pick<LombardConfig, 'providers'>,
-  key: ProviderKey,
-): boolean {
-  return Boolean(config.providers?.[key]);
-}
-
-/**
- * Create SDK configuration
- *
- * This is a **synchronous** function that validates options and returns
- * a configuration object. The config can be exported from a module and
- * passed around as a plain object.
- *
- * The asset catalog is NOT fetched here - it's fetched asynchronously
- * when createLombardSDK() is called. This keeps config creation simple
- * and predictable.
- *
- * @param options - Configuration options
- * @returns Validated SDK configuration
- *
- * @example
- * ```typescript
- * // lib/lombard.ts - Config is sync, can be exported directly
- * export const config = createConfig({
- *   env: Env.prod,
- *   providers: { evm: () => window.ethereum },
- * });
- *
- * // Usage - SDK creation is async
- * import { config } from './lib/lombard';
- * const sdk = await createLombardSDK(config);
- * ```
- */
-export function createConfig(options: CreateConfigOptions): LombardConfig {
-  const normalized = validateAndApplyDefaults(options);
-  const modules = mergeModules(
-    options.modules as readonly AnyModule[] | undefined,
-  );
-  ensureProviders(modules, normalized);
-
-  // Resolve logger: explicit logger > debug mode > undefined
-  let logger = options.logger;
-  if (!logger && options.debug) {
-    logger = createConsoleLogger({ level: 'debug' });
-  }
-
-  return {
-    ...normalized,
-    modules,
-    logger,
-  };
-}

package/src/client/createLombardSDK.ts

@@ -1,130 +0,0 @@
-/**
- * Async factory for creating LombardSDK instances
- *
- * This is the primary entry point for the Lombard SDK.
- * It fetches the asset catalog asynchronously and initializes the SDK.
- */
-
-import type { Env } from '@lombard.finance/sdk-common';
-
-import type {
-    CreateConfigOptions,
-    LombardConfig,
-    ResolvedLombardConfig,
-} from '../config/types';
-import { ASSET_CATALOG } from '../core/assets/catalog';
-import type { AssetCatalog } from '../core/assets/types';
-import { createConfig } from './createConfig';
-import { LombardSDK } from './LombardSDK';
-
-/**
- * Module-level catalog cache
- *
- * Caches the catalog promise per environment to avoid redundant fetches.
- * Multiple calls to createLombardSDK() with the same env will share
- * the same catalog fetch.
- *
- * @internal
- */
-const catalogCache = new Map<Env, Promise<AssetCatalog>>();
-
-/**
- * Fetch asset catalog with caching
- *
- * Currently returns bundled catalog immediately.
- * Future: Will fetch from remote S3/CDN with bundled fallback.
- *
- * The catalog is cached per environment - subsequent calls with the
- * same env return the same promise, avoiding duplicate fetches.
- *
- * @internal
- */
-function fetchCatalogCached(env: Env): Promise<AssetCatalog> {
-  if (!catalogCache.has(env)) {
-    // TODO (APP-1834): Implement remote catalog fetching
-    // When backend is ready:
-    // 1. Fetch from CDN: https://cdn.lombard.finance/catalog/{env}.json
-    // 2. Fallback to ASSET_CATALOG on network failure
-    // 3. Cache-Control headers will define CDN TTL
-    //
-    // For now, return bundled catalog immediately (wrapped in Promise)
-    catalogCache.set(env, Promise.resolve(ASSET_CATALOG));
-  }
-  return catalogCache.get(env)!;
-}
-
-/**
- * Create a LombardSDK instance
- *
- * This is an async factory that:
- * 1. Validates configuration (sync)
- * 2. Fetches the asset catalog (async, cached per env)
- * 3. Initializes the SDK with all chain actions
- *
- * The catalog is cached at the module level - multiple SDK instances
- * with the same environment share the same catalog fetch.
- *
- * @param options - SDK configuration options or pre-made LombardConfig
- * @returns Promise resolving to LombardSDK instance
- *
- * @example
- * ```typescript
- * // Option 1: Direct creation (recommended for simple cases)
- * const sdk = await createLombardSDK({
- *   env: Env.prod,
- *   providers: {
- *     evm: () => window.ethereum,
- *     bitcoin: () => bitcoinProvider,
- *   },
- * });
- *
- * // Option 2: Separate config (recommended for shared config)
- * // lib/lombard.ts
- * export const config = createConfig({
- *   env: Env.prod,
- *   providers: { evm: () => window.ethereum },
- * });
- *
- * // app.ts
- * import { config } from './lib/lombard';
- * const sdk = await createLombardSDK(config);
- *
- * // Use the SDK
- * const stake = sdk.chain.btc.stake({
- *   destChain: Chain.ETHEREUM,
- *   assetOut: AssetId.LBTC,
- * });
- * ```
- */
-export async function createLombardSDK<E extends Env = Env>(
-  options: (CreateConfigOptions & { env: E }) | LombardConfig,
-): Promise<LombardSDK<E>> {
-  // If already a LombardConfig (validated), use it
-  // Otherwise, create config (sync validation)
-  const config: LombardConfig =
-    'modules' in options && Array.isArray(options.modules)
-      ? (options as LombardConfig)
-      : createConfig(options as CreateConfigOptions & { env: E });
-
-  // Fetch catalog (async, cached per env)
-  const catalog = await fetchCatalogCached(config.env);
-
-  // Create resolved config with catalog
-  const resolvedConfig: ResolvedLombardConfig = {
-    ...config,
-    catalog,
-  };
-
-  return new LombardSDK<E>(resolvedConfig);
-}
-
-/**
- * Clear the catalog cache
- *
- * Useful for testing or forcing a fresh catalog fetch.
- *
- * @internal
- */
-export function clearCatalogCache(): void {
-  catalogCache.clear();
-}

package/src/clients/evm-signer-adapter.ts

@@ -1,313 +0,0 @@
-import {
-  Address,
-  createWalletClient,
-  Hex,
-  http,
-  isHex,
-  LocalAccount,
-  TransactionSerializable,
-  WalletClient,
-} from 'viem';
-
-import { CHAIN_ID_TO_VIEM_CHAIN_MAP, ChainId } from '../common/chains';
-
-/**
- * EVM transaction request structure compatible with unified bridge signers.
- * This matches the shape expected by bridge-unified's EvmSigner interface.
- */
-export interface EvmTransactionRequest {
-  /** Sender address */
-  from: Address;
-  /** Recipient address */
-  to?: Address;
-  /** Transaction data (calldata) */
-  data?: Hex;
-  /** Value to send in wei */
-  value?: bigint;
-  /** Gas limit */
-  gas?: bigint;
-  /** Maximum fee per gas (EIP-1559) */
-  maxFeePerGas?: bigint;
-  /** Maximum priority fee per gas (EIP-1559) */
-  maxPriorityFeePerGas?: bigint;
-  /** Chain ID in hex format (e.g., "0x1" for Ethereum mainnet) */
-  chainId?: string;
-  /** Transaction nonce */
-  nonce?: number;
-}
-
-/**
- * Callback function to dispatch a signed transaction.
- * This is called by the signer after signing to broadcast the transaction.
- *
- * @param serializedTx - The signed, serialized transaction (0x-prefixed hex string)
- * @returns Promise resolving to the transaction hash
- */
-export type DispatchCallback = (serializedTx: Hex) => Promise<Hex>;
-
-/**
- * Signer interface compatible with unified bridge's EvmSigner.
- * Handles transaction signing and optionally broadcasting.
- *
- * @remarks
- * The `sign` method receives a transaction request and a dispatch callback.
- * The signer should:
- * 1. Sign the transaction
- * 2. Call the dispatch callback with the signed transaction
- * 3. Return the transaction hash
- */
-export interface SignerAdapter {
-  /**
-   * Signs a transaction and dispatches it via the provided callback.
-   *
-   * @param tx - The transaction request to sign
-   * @param dispatch - Callback to broadcast the signed transaction
-   * @returns Promise resolving to the transaction hash
-   *
-   * @example
-   * ```ts
-   * const txHash = await signer.sign(
-   *   { from, to, data, value },
-   *   (signedTx) => publicClient.sendRawTransaction({ serializedTransaction: signedTx })
-   * );
-   * ```
-   */
-  sign: (tx: EvmTransactionRequest, dispatch: DispatchCallback) => Promise<Hex>;
-}
-
-/**
- * Error thrown when transaction validation or signing fails.
- */
-export class SignerError extends Error {
-  constructor(
-    public readonly code: string,
-    message: string,
-    public readonly context?: Record<string, unknown>,
-  ) {
-    super(message);
-    this.name = 'SignerError';
-  }
-}
-
-/**
- * Validates an EVM transaction request.
- * Throws SignerError if validation fails.
- *
- * @param tx - Transaction request to validate
- * @throws {SignerError} If required fields are missing or invalid
- */
-export function validateTransactionRequest(
-  tx: EvmTransactionRequest,
-  operation = 'transaction',
-): void {
-  if (!tx.from) {
-    throw new SignerError(
-      'MISSING_FROM_ADDRESS',
-      `Missing 'from' address for ${operation}`,
-      { transaction: tx, operation },
-    );
-  }
-
-  if (!tx.to) {
-    throw new SignerError(
-      'MISSING_TO_ADDRESS',
-      `Missing 'to' address for ${operation}`,
-      { transaction: tx, operation },
-    );
-  }
-
-  if (tx.data !== undefined && !isHex(tx.data)) {
-    throw new SignerError(
-      'INVALID_DATA',
-      `Transaction data must be valid hex string for ${operation}`,
-      { transaction: tx, operation, data: tx.data },
-    );
-  }
-
-  if (tx.chainId && !/^0x[0-9a-fA-F]+$/.test(tx.chainId)) {
-    throw new SignerError(
-      'INVALID_CHAIN_ID',
-      `Chain ID must be a hex string (e.g., "0x1") for ${operation}`,
-      { transaction: tx, operation, chainId: tx.chainId },
-    );
-  }
-}
-
-/**
- * Creates a Viem LocalAccount from a SignerAdapter.
- * This allows the unified bridge's EvmSigner to be used as a standard Viem account.
- *
- * @param signer - The SignerAdapter to wrap
- * @param address - The account address
- * @param chainId - The chain ID
- * @returns A Viem LocalAccount that delegates signing to the SignerAdapter
- *
- * @remarks
- * This adapter enables the SDK to use a unified-bridge EvmSigner with Viem's
- * standard wallet client, eliminating the need for separate code paths.
- *
- * The adapter:
- * - Validates transaction requests before signing
- * - Converts between Viem and EvmSigner transaction formats
- * - Provides proper error context for debugging
- *
- * @example
- * ```ts
- * const account = createAccountFromSigner(
- *   bridgeEvmSigner,
- *   '0x1234...',
- *   ChainId.ethereum
- * );
- *
- * const walletClient = createWalletClient({
- *   account,
- *   chain: mainnet,
- *   transport: http(),
- * });
- *
- * // Now walletClient.writeContract works with the EvmSigner!
- * ```
- */
-export function createAccountFromSigner(
-  signer: SignerAdapter,
-  address: Address,
-  chainId: ChainId,
-): LocalAccount {
-  const chain = CHAIN_ID_TO_VIEM_CHAIN_MAP[chainId];
-
-  if (!chain) {
-    throw new SignerError(
-      'UNSUPPORTED_CHAIN',
-      `Chain ID ${chainId} is not supported`,
-      { chainId, availableChains: Object.keys(CHAIN_ID_TO_VIEM_CHAIN_MAP) },
-    );
-  }
-
-  /**
-   * Custom account implementation that delegates to SignerAdapter
-   */
-  const customAccount: LocalAccount = {
-    address,
-    type: 'local' as const,
-    publicKey:
-      '0x0000000000000000000000000000000000000000000000000000000000000000' as Hex,
-    source: 'custom' as const,
-
-    /**
-     * Signs a transaction using the SignerAdapter.
-     * This is called by Viem's wallet client when executing transactions.
-     */
-    async signTransaction(transaction: TransactionSerializable): Promise<Hex> {
-      // Convert Viem transaction to EvmTransactionRequest format
-      const evmTx: EvmTransactionRequest = {
-        from: address,
-        to: transaction.to ?? undefined,
-        data: transaction.data,
-        value: transaction.value,
-        gas: transaction.gas,
-        maxFeePerGas: transaction.maxFeePerGas,
-        maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
-        chainId: transaction.chainId
-          ? `0x${transaction.chainId.toString(16)}`
-          : `0x${chain.id.toString(16)}`,
-        nonce: transaction.nonce,
-      };
-
-      // Validate before signing
-      validateTransactionRequest(evmTx, 'signTransaction');
-
-      // Sign and return the serialized signed transaction
-      // The dispatch callback here just returns what was passed (identity function)
-      // because we want the signed transaction, not to broadcast it yet
-      let signedTx: Hex | undefined;
-
-      await signer.sign(evmTx, async serialized => {
-        signedTx = serialized;
-        // Return a dummy hash - the actual broadcasting happens via walletClient
-        return serialized;
-      });
-
-      if (!signedTx) {
-        throw new SignerError(
-          'SIGNING_FAILED',
-          'Signer did not return a signed transaction',
-          { transaction: evmTx },
-        );
-      }
-
-      // Ensure we return a Hex type (not null)
-      return signedTx as Hex;
-    },
-
-    /**
-     * Signs a message (EIP-191).
-     * Not implemented as it's not needed for contract transactions.
-     */
-    async signMessage(): Promise<Hex> {
-      throw new SignerError(
-        'NOT_IMPLEMENTED',
-        'Message signing is not supported by this adapter',
-        { method: 'signMessage' },
-      );
-    },
-
-    /**
-     * Signs typed data (EIP-712).
-     * Not implemented as it's not needed for contract transactions.
-     */
-    async signTypedData(): Promise<Hex> {
-      throw new SignerError(
-        'NOT_IMPLEMENTED',
-        'Typed data signing is not supported by this adapter',
-        { method: 'signTypedData' },
-      );
-    },
-  };
-
-  return customAccount;
-}
-
-/**
- * Creates a Viem wallet client from a SignerAdapter.
- * This is a convenience wrapper around createAccountFromSigner.
- *
- * @param signer - The SignerAdapter to use
- * @param address - The account address
- * @param chainId - The chain ID
- * @returns A Viem wallet client configured with the SignerAdapter
- *
- * @example
- * ```ts
- * const walletClient = createWalletClientFromSigner(
- *   bridgeEvmSigner,
- *   '0x1234...',
- *   ChainId.ethereum
- * );
- *
- * // Use like any Viem wallet client
- * await walletClient.writeContract({ ... });
- * ```
- */
-export function createWalletClientFromSigner(
-  signer: SignerAdapter,
-  address: Address,
-  chainId: ChainId,
-): WalletClient {
-  const chain = CHAIN_ID_TO_VIEM_CHAIN_MAP[chainId];
-
-  if (!chain) {
-    throw new SignerError(
-      'UNSUPPORTED_CHAIN',
-      `Chain ID ${chainId} is not supported`,
-      { chainId },
-    );
-  }
-
-  const account = createAccountFromSigner(signer, address, chainId);
-
-  return createWalletClient({
-    account,
-    chain,
-    transport: http(), // Uses default RPC
-  });
-}

package/src/clients/public-client.ts

@@ -1,49 +0,0 @@
-import { Env } from '@lombard.finance/sdk-common';
-import { Chain, createPublicClient, http, PublicClient } from 'viem';
-
-import {
-  CHAIN_ID_TO_VIEM_CHAIN_MAP,
-  ChainId,
-  getChain,
-} from '../common/chains';
-import { determineEnv } from '../utils/env';
-import { getRpcUrlConfig } from './rpc-url-config';
-
-type MakePublicClientParameters = {
-  chainId: ChainId;
-  rpcUrl?: string;
-  env?: Env;
-};
-
-/**
- * Creates the public (read-only) client for specified `chainId`.
- * @param chainId - The chain id
- * @param rpcUrl - The overridden RPC url for specified chain id.
- * @returns The public client instance
- */
-export function makePublicClient({
-  chainId,
-  rpcUrl,
-  env,
-}: MakePublicClientParameters): PublicClient {
-  const override = rpcUrl ? { [chainId]: rpcUrl } : undefined;
-
-  const environment = env || determineEnv(chainId);
-  const rpcUrlConfig = getRpcUrlConfig(environment);
-
-  const rpcUrls = { ...rpcUrlConfig, ...override };
-
-  let chain: Chain | undefined = CHAIN_ID_TO_VIEM_CHAIN_MAP[chainId];
-  if (!chain) {
-    chain = getChain(chainId);
-  }
-
-  const transport = http(rpcUrls[chainId]);
-
-  const publicClient = createPublicClient({
-    chain,
-    transport,
-  });
-
-  return publicClient as PublicClient<typeof transport>;
-}

package/src/clients/rpc-url-config.ts

@@ -1,64 +0,0 @@
-import { Env } from '@lombard.finance/sdk-common';
-
-import { getApiConfig } from '../common/api-config';
-import { ChainId } from '../common/chains';
-
-export type TRpcUrlConfig = Record<number, string>;
-
-export const RPC_URL = 'https://bff.prod.lombard-fi.com/multi-rpc/proxy';
-
-export const rpcUrlConfig: TRpcUrlConfig = {
-  [ChainId.ethereum]: `${RPC_URL}/eth`,
-  [ChainId.base]: `${RPC_URL}/base`,
-  // [ChainId.binanceSmartChain]: 'https://bsc-dataseed.bnbchain.org',
-  [ChainId.binanceSmartChain]: `${RPC_URL}/bsc`,
-  [ChainId.corn]: `${RPC_URL}/corn_maizenet`,
-  [ChainId.katana]: `${RPC_URL}/katana`,
-  [ChainId.megaeth]:
-    'https://alpha.megaeth.com/rpc?user=lombard+v1&token=1763427229-%2Bx6HFUDu9OhJwV%2FTCFOL0xTt%2FPJRAXPeirIcuytvnes%3D',
-  [ChainId.sonic]: `${RPC_URL}/sonic_mainnet`,
-  [ChainId.stable]:
-    'https://partners-rpc.stable.xyz/lombard.075830647a2c30190712a9d102011ffe5a2a01d24ff3405f711d6ea8aca10baf', // TODO: Update with the correct RPC URL once the stable network is live
-  [ChainId.tac]: `${RPC_URL}/tac`,
-  [ChainId.monad]: `${RPC_URL}/monad_mainnet`,
-  // Testnets:
-  [ChainId.baseSepoliaTestnet]: `${RPC_URL}/base_sepolia`,
-  [ChainId.binanceSmartChainTestnet]:
-    'https://bsc-testnet-dataseed.bnbchain.org',
-  [ChainId.holesky]: `${RPC_URL}/eth_holesky`,
-  [ChainId.katanaTatara]: `${RPC_URL}/katana_tatara`,
-  [ChainId.sepolia]: `${RPC_URL}/eth_sepolia`,
-  // Use direct Sonic Labs RPC for testnet (proxy returns 403)
-  [ChainId.sonicBlazeTestnet]: 'https://rpc.blaze.soniclabs.com',
-};
-
-export function getRpcUrlConfig(env: Env) {
-  const { bffApiUrl: baseUrl } = getApiConfig(env);
-
-  const proxy = `${baseUrl}/multi-rpc/proxy`;
-
-  return {
-    [ChainId.ethereum]: `${proxy}/eth`,
-    [ChainId.base]: `${proxy}/base`,
-    [ChainId.binanceSmartChain]: 'https://bsc-dataseed.bnbchain.org',
-    [ChainId.corn]: `${proxy}/corn_maizenet`,
-    [ChainId.katana]: `${proxy}/katana`,
-    [ChainId.monad]: `${proxy}/monad_mainnet`,
-    [ChainId.megaeth]:
-      'https://alpha.megaeth.com/rpc?user=lombard+v1&token=1763427229-%2Bx6HFUDu9OhJwV%2FTCFOL0xTt%2FPJRAXPeirIcuytvnes%3D',
-    [ChainId.sonic]: `${proxy}/sonic_mainnet`,
-    [ChainId.tac]: `${proxy}/tac`,
-
-    // Testnets:
-    [ChainId.baseSepoliaTestnet]: `${proxy}/base_sepolia`,
-    [ChainId.binanceSmartChainTestnet]:
-      'https://bsc-testnet-dataseed.bnbchain.org',
-    [ChainId.holesky]: `${proxy}/eth_holesky`,
-    [ChainId.katanaTatara]: `${proxy}/katana_tatara`,
-    [ChainId.sepolia]: `${proxy}/eth_sepolia`,
-    // Use direct Sonic Labs RPC for testnet (proxy returns 403)
-    [ChainId.sonicBlazeTestnet]: 'https://rpc.blaze.soniclabs.com',
-    [ChainId.stable]:
-      'https://partners-rpc.stable.xyz/lombard.075830647a2c30190712a9d102011ffe5a2a01d24ff3405f711d6ea8aca10baf',
-  } as TRpcUrlConfig;
-}

package/src/clients/wallet-client.ts

@@ -1,34 +0,0 @@
-import {
-  createWalletClient,
-  custom,
-  EIP1193Provider,
-  WalletClient,
-} from 'viem';
-
-import { CHAIN_ID_TO_VIEM_CHAIN_MAP, ChainId } from '../common/chains';
-
-type MakeClientParameters = {
-  provider: EIP1193Provider;
-  chainId: ChainId;
-};
-
-/**
- * Creates the client for specified `chainId`.
- * @param chainId - The chain id
- * @param rpcUrl - The overridden RPC url for specified chain id.
- * @returns The public client instance
- */
-export function makeWalletClient({
-  provider,
-  chainId,
-}: MakeClientParameters): WalletClient {
-  const chain = CHAIN_ID_TO_VIEM_CHAIN_MAP[chainId];
-  const transport = custom(provider);
-
-  const client = createWalletClient({
-    chain,
-    transport,
-  });
-
-  return client as WalletClient<typeof transport>;
-}