@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/chains/btc/actions/deposit/config/evm.ts

@@ -1,197 +0,0 @@
-/**
- * EVM Chain Configuration for BTC Deposit
- *
- * BTC Deposit: BTC → BTC.b (wrapped BTC without yield)
- * For staking (BTC → LBTC), use BtcStake instead.
- *
- * Supported chains are derived from ASSET_CATALOG - single source of truth.
- *
- * Fee authorization is ONLY required for Ethereum mainnet.
- * Other chains use address confirmation signing.
- *
- * @module chains/btc/actions/deposit/config/evm
- */
-
-import type { EvmService } from '@lombard.finance/sdk-common';
-import type { EIP1193Provider } from 'viem';
-
-import type { ChainId } from '../../../../../common/chains';
-import {
-    AssetId,
-    Chain,
-    Env,
-    getAllAssetChains,
-    isEvmChain,
-} from '../../../../../core';
-import { LombardError } from '../../../../../shared/errors';
-import { ensureCorrectChain } from '../../../../../shared/evm/switchChain';
-import { evmAddressSchema } from '../../../../../shared/validation';
-import { Token } from '../../../../../tokens/token-addresses';
-import { getTokenContractInfo } from '../../../../../tokens/tokens';
-import { toSatoshi } from '../../../../../utils/satoshi';
-import type { DepositChainConfig, DepositFeeAuthConfig } from './types';
-
-/**
- * Chains that require fee authorization (unsubsidized chains).
- * 
- * Ethereum mainnet and Sepolia require EIP-712 network fee signing.
- * Other chains are subsidized by Lombard.
- */
-const UNSUBSIDIZED_CHAINS = [Chain.ETHEREUM, Chain.SEPOLIA] as const;
-
-/**
- * Fee authorization config for unsubsidized chains
- *
- * BTC Deposit produces BTC.b, so we must use Token.BTCb for fee signatures.
- * This ensures the backend can distinguish between LBTC and BTC.b signatures.
- */
-const feeAuthConfig: DepositFeeAuthConfig = {
-  async getMintingFee(ctx, chainId) {
-    const evm = ctx.capabilities.require('evm') as EvmService;
-    // Fetch BTC.b minting fee (not LBTC!)
-    return evm.getMintingFee(chainId as ChainId, Token.BTCb);
-  },
-
-  async restoreFeeSignature(ctx, chainId, address) {
-    // Get BTC.b token address for this chain to distinguish from LBTC signatures
-    const tokenInfo = await getTokenContractInfo(
-      Token.BTCb,
-      chainId as ChainId,
-      ctx.env,
-    );
-
-    const result = await ctx.api.getFeeSignature({
-      address,
-      chainId: chainId as ChainId,
-      tokenAddress: tokenInfo.address,
-    });
-
-    // Check if signature exists on server (API returns has_signature flag)
-    if (!result.hasSignature) {
-      return null;
-    }
-
-    // Check expiration - expirationDate is Unix timestamp in seconds
-    // Convert to milliseconds for Date comparison
-    if (result.expirationDate && new Date(Number(result.expirationDate) * 1000) < new Date()) {
-      return null;
-    }
-
-    // Return hasSignature: true even if actual signature string is not returned by API
-    // The server has the signature stored; we just need to know it's valid
-    return {
-      hasSignature: true,
-      signature: result.signature, // May be undefined - that's OK
-      typedData: result.typedData,
-    };
-  },
-
-  async authorizeFee(ctx, { chainId, recipient, fee }) {
-    const evm = ctx.capabilities.require('evm') as EvmService;
-    const provider = await ctx.getProvider('evm');
-    if (!provider) {
-      throw LombardError.providerMissing(String(chainId), 'evm');
-    }
-
-    // Ensure wallet is on the correct chain before signing
-    await ensureCorrectChain(provider as EIP1193Provider, chainId as ChainId);
-
-    // getMintingFee returns BTC (e.g., "0.00000032"), but signNetworkFee expects satoshis
-    const feeInSatoshis = toSatoshi(fee).toString();
-
-    // Get BTC.b token info for this chain
-    const tokenInfo = await getTokenContractInfo(
-      Token.BTCb,
-      chainId as ChainId,
-      ctx.env,
-    );
-
-    // Sign the network fee with BTC.b token (not LBTC!)
-    const result = await evm.signNetworkFee({
-      fee: feeInSatoshis,
-      account: recipient,
-      chainId: chainId as ChainId,
-      provider: provider as EIP1193Provider,
-      token: Token.BTCb,
-    });
-
-    // Store the signature with token address to distinguish from LBTC signatures
-    await ctx.api.storeFeeSignature({
-      address: recipient,
-      signature: result.signature,
-      typedData: result.typedData,
-      tokenAddress: tokenInfo.address,
-    });
-
-    return {
-      signature: result.signature,
-      typedData: result.typedData,
-    };
-  },
-};
-
-/**
- * EVM deposit configuration
- *
- * BTC Deposit produces BTC.b (wrapped BTC without yield).
- * Supported chains are derived from ASSET_CATALOG[AssetId.BTCb].deployments.
- */
-export const evmDepositConfig: DepositChainConfig = {
-  chainType: 'evm',
-
-  routes: [
-    {
-      sourceChains: [Chain.BITCOIN_MAINNET],
-      envs: [Env.prod],
-    },
-    {
-      sourceChains: [Chain.BITCOIN_SIGNET],
-      envs: [Env.stage, Env.dev, Env.testnet, Env.ibc],
-    },
-  ],
-
-  // Derived from ASSET_CATALOG - all chains where BTC.b is deployed
-  destChains: getAllAssetChains(AssetId.BTCb).filter(chain =>
-    isEvmChain(chain),
-  ),
-
-  // BTC Deposit only produces BTC.b
-  supportedAssetsOut: [AssetId.BTCb],
-
-  addressSchema: evmAddressSchema,
-
-  /**
-   * Get fee auth config - unsubsidized chains require fee authorization
-   * Other chains use address confirmation signing
-   */
-  getFeeAuthConfig(destChain: Chain): DepositFeeAuthConfig | null {
-    return (UNSUBSIDIZED_CHAINS as readonly Chain[]).includes(destChain)
-      ? feeAuthConfig
-      : null;
-  },
-
-  /**
-   * Sign destination address confirmation
-   * Used for non-fee-auth chains (e.g., Avalanche, Katana)
-   */
-  async signDestination(ctx, recipient, chainId) {
-    const evm = ctx.capabilities.require('evm') as EvmService;
-    const provider = await ctx.getProvider('evm');
-    if (!provider) {
-      throw LombardError.providerMissing(String(chainId), 'evm');
-    }
-
-    // Ensure wallet is on the correct chain before signing
-    await ensureCorrectChain(provider as EIP1193Provider, chainId as ChainId);
-
-    const result = await evm.signLbtcDestination({
-      address: recipient,
-      chainId: chainId as ChainId,
-      provider: provider as EIP1193Provider,
-    });
-
-    return {
-      signature: result.signature,
-    };
-  },
-};

package/src/chains/btc/actions/deposit/config/index.ts

@@ -1,53 +0,0 @@
-/**
- * BTC Deposit Chain Configuration Registry
- *
- * BTC Deposit: BTC → BTC.b (wrapped BTC without yield)
- *
- * @module chains/btc/actions/deposit/config
- */
-
-import type { AssetId, Chain, Env } from '../../../../../core';
-import { evmDepositConfig } from './evm';
-
-export type {
-  DepositChainConfig,
-  DepositFeeAuthConfig,
-  DepositRouteDefinition,
-  FeeAuthResult,
-  SignatureResult,
-  StoredFeeSignature,
-} from './types';
-
-/**
- * All deposit configs (currently only EVM)
- */
-export const depositConfig = evmDepositConfig;
-
-/**
- * Check if destination chain is supported
- */
-export function isDestChainSupported(chain: Chain): boolean {
-  return depositConfig.destChains.includes(chain);
-}
-
-/**
- * Check if assetOut is supported for BTC Deposit
- * BTC Deposit should only produce BTC.b
- */
-export function isAssetOutSupported(assetOut: AssetId): boolean {
-  return depositConfig.supportedAssetsOut.includes(assetOut);
-}
-
-/**
- * Check if route is available for given source chain and environment
- */
-export function isRouteAvailable(
-  sourceChain: Chain | undefined,
-  env: Env,
-): boolean {
-  if (!sourceChain) return true;
-  return depositConfig.routes.some(
-    route =>
-      route.sourceChains.includes(sourceChain) && route.envs.includes(env),
-  );
-}

package/src/chains/btc/actions/deposit/config/types.ts

@@ -1,108 +0,0 @@
-/**
- * BTC Deposit Chain Configuration Types
- *
- * @module chains/btc/actions/deposit/config/types
- */
-
-import type { z } from 'zod';
-
-import type { AssetId, Chain, Env } from '../../../../../core';
-import type { BtcCoreContext } from '../../../../../shared/context';
-
-/**
- * Stored fee signature result
- */
-export interface StoredFeeSignature {
-  hasSignature: boolean;
-  signature?: string;
-  typedData?: string;
-}
-
-/**
- * Fee authorization result
- */
-export interface FeeAuthResult {
-  signature: string;
-  typedData?: string;
-}
-
-/**
- * Signature result for address confirmation
- */
-export interface SignatureResult {
-  signature: string;
-  typedData?: string;
-}
-
-/**
- * Route definition for deposit configs
- */
-export interface DepositRouteDefinition {
-  sourceChains: Chain[];
-  envs: Env[];
-}
-
-/**
- * Fee authorization configuration
- *
- * When present, ALL methods are guaranteed to exist.
- * Used for chains that require fee authorization (e.g., Ethereum mainnet).
- */
-export interface DepositFeeAuthConfig {
-  /**
-   * Get the minting fee for this chain (in BTC)
-   * Called in prepare() when fee authorization is needed
-   */
-  getMintingFee: (ctx: BtcCoreContext, chainId: unknown) => Promise<string>;
-
-  /**
-   * Try to restore a stored fee signature (resume flow)
-   */
-  restoreFeeSignature: (
-    ctx: BtcCoreContext,
-    chainId: unknown,
-    address: string,
-  ) => Promise<StoredFeeSignature | null>;
-
-  /**
-   * Authorize fee (EIP-712 signing)
-   */
-  authorizeFee: (
-    ctx: BtcCoreContext,
-    params: { chainId: unknown; recipient: string; fee: string },
-  ) => Promise<FeeAuthResult>;
-}
-
-/**
- * Deposit chain configuration
- *
- * BTC Deposit produces BTC.b (wrapped BTC without yield).
- * Fee authorization is only required for Ethereum mainnet.
- * Other chains use address confirmation signing.
- */
-export interface DepositChainConfig {
-  chainType: 'evm';
-  routes: DepositRouteDefinition[];
-  destChains: Chain[];
-  /** Supported output assets - BTC Deposit should only produce BTC.b */
-  supportedAssetsOut: AssetId[];
-  addressSchema: z.ZodString;
-
-  /**
-   * Get fee authorization config for a destination chain
-   *
-   * Returns DepositFeeAuthConfig if fee auth is required (Ethereum mainnet),
-   * null otherwise (address confirmation will be used instead).
-   */
-  getFeeAuthConfig: (destChain: Chain) => DepositFeeAuthConfig | null;
-
-  /**
-   * Sign destination address confirmation
-   * Used for non-fee-auth chains
-   */
-  signDestination: (
-    ctx: BtcCoreContext,
-    recipient: string,
-    chainId: unknown,
-  ) => Promise<SignatureResult>;
-}

package/src/chains/btc/actions/deposit/factory.ts

@@ -1,53 +0,0 @@
-/**
- * BTC Deposit Factory Functions
- *
- * Provides factory functions for creating BtcDeposit instances.
- * Separates instantiation from the main class.
- *
- * @module chains/btc/actions/deposit/factory
- */
-
-import type { LombardConfig } from '../../../../config/types';
-import type { BtcCoreContext } from '../../../../shared/context';
-import { createBtcCoreContext } from '../../../../shared/context';
-import { BtcDeposit } from './BtcDeposit';
-import type { BtcDepositParams } from './types';
-
-/**
- * Create BtcDeposit action from config
- *
- * @internal This factory is for internal use. Use createLombardSDK() instead:
- *
- * @example
- * ```typescript
- * const sdk = await createLombardSDK({ env: Env.prod, providers: { ... } });
- * const deposit = sdk.chain.btc.deposit({
- *   assetOut: AssetId.BTCb,
- *   destChain: Chain.AVALANCHE,
- * });
- * await deposit.prepare({ amount: '0.1', recipient: '0x...' });
- * ```
- */
-export function btcDeposit(
-  config: LombardConfig,
-  params: BtcDepositParams,
-): BtcDeposit {
-  const ctx = createBtcCoreContext(config);
-  return new BtcDeposit(ctx, params);
-}
-
-/**
- * Create BtcDeposit action from context
- *
- * Use this when you already have a BtcCoreContext (e.g., in BtcActions).
- *
- * @param ctx - BtcCoreContext
- * @param params - Deposit parameters
- * @returns BtcDeposit instance
- */
-export function createBtcDeposit(
-  ctx: BtcCoreContext,
-  params: BtcDepositParams,
-): BtcDeposit {
-  return new BtcDeposit(ctx, params);
-}

package/src/chains/btc/actions/deposit/index.ts

@@ -1,23 +0,0 @@
-/**
- * BTC Deposit Action Exports
- *
- * @module chains/btc/actions/deposit
- */
-
-// Main action class
-export { BtcDeposit } from './BtcDeposit';
-
-// Factory functions
-export { btcDeposit, createBtcDeposit } from './factory';
-
-// Types
-export type {
-  BtcDepositParams,
-  BtcDepositPrepareParams,
-  BtcDepositProgress,
-  BtcDeposit as IBtcDeposit,
-} from './types';
-export { BtcActionStatus } from './types';
-
-// Configuration types (for advanced usage)
-export type { DepositChainConfig, DepositRouteDefinition } from './config';

package/src/chains/btc/actions/deposit/types.ts

@@ -1,120 +0,0 @@
-/**
- * BTC Deposit Action Types
- *
- * Type definitions for BTC deposit operations.
- *
- * @module chains/btc/actions/deposit/types
- */
-
-import type {
-  AssetId,
-  Chain,
-  StepStatus,
-  StrategyProgress,
-} from '../../../../core';
-import type { MonitorableAction } from '../../../../shared/actions/BaseAction';
-import { BtcActionStatus } from '../../../../shared/constants/statusConstants';
-import type { MonitorProgress } from '../../../../shared/monitoring';
-
-// Re-export for convenience (single export statement avoids duplicate identifier)
-export { BtcActionStatus };
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Parameters
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * BTC Deposit parameters
- *
- * Note: BTC Deposit is for custody operations (BTC → BTC.b).
- * For staking operations (BTC → LBTC), use BtcStake instead.
- */
-export interface BtcDepositParams {
-  /** Output asset - should be BTCb for deposit, LBTC for stake */
-  assetOut: AssetId;
-  /** Destination chain for minted asset */
-  destChain: Chain;
-  /** Source Bitcoin network (optional, defaults based on env) */
-  sourceChain?: typeof Chain.BITCOIN_MAINNET | typeof Chain.BITCOIN_SIGNET;
-}
-
-/**
- * Prepare parameters
- */
-export interface BtcDepositPrepareParams {
-  /** Amount of BTC to deposit (human-readable, e.g., "0.1") */
-  amount: string;
-  /** Recipient address on destination chain */
-  recipient: string;
-  /** Optional referral code */
-  referralCode?: string;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Progress
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * BTC Deposit progress
- */
-export interface BtcDepositProgress extends StrategyProgress<BtcActionStatus> {
-  status: BtcActionStatus;
-  steps: {
-    created: StepStatus;
-    verifying: StepStatus;
-    issuing: StepStatus;
-  };
-  confirmations?: number;
-  requiredConfirmations?: number;
-  hasEnoughConfirmations?: boolean;
-  isClaimed?: boolean;
-  depositAddress?: string;
-  metadata?: Record<string, unknown>;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Interface
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * BTC Deposit interface
- */
-export interface BtcDeposit extends MonitorableAction {
-  readonly status: BtcActionStatus;
-  readonly amount?: string;
-  readonly recipient?: string;
-  readonly depositAddress?: string;
-  readonly referralCode?: string;
-
-  /**
-   * Prepare the deposit operation
-   */
-  prepare(params: BtcDepositPrepareParams): Promise<void>;
-
-  /**
-   * Authorize the network fee (Ethereum mainnet only)
-   * For other chains, use confirmAddress() instead.
-   */
-  authorizeFee(): Promise<void>;
-
-  /**
-   * Confirm destination address (non-Ethereum chains)
-   * For Ethereum mainnet, use authorizeFee() instead.
-   */
-  confirmAddress(): Promise<void>;
-
-  /**
-   * Generate BTC deposit address
-   */
-  generateDepositAddress(): Promise<string>;
-
-  /**
-   * Execute the deposit
-   */
-  execute(): Promise<{ depositAddress: string; txHash?: string }>;
-
-  /**
-   * Monitor deposit progress
-   */
-  monitorDeposit?(): Promise<MonitorProgress | undefined>;
-}