@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/chains/btc/BtcActions.ts

@@ -1,192 +0,0 @@
-/**
- * BTC Actions
- *
- * Provides factory methods for Bitcoin operations (stake, stakeAndDeploy, deposit).
- * This is the user-facing API for BTC operations.
- *
- * @example
- * ```typescript
- * import { createLombardSDK, Chain, AssetId, Env } from '@lombard.finance/sdk';
- *
- * const sdk = await createLombardSDK({
- *   env: Env.prod,
- *   providers: { evm: () => window.ethereum },
- * });
- *
- * const stake = sdk.chain.btc.stake({
- *   assetOut: AssetId.LBTC,
- *   destChain: Chain.ETHEREUM,
- * });
- *
- * await stake.prepare({ amount: '0.1', recipient: '0x...' });
- * await stake.authorize();
- * const address = await stake.generateDepositAddress();
- * ```
- *
- * @module chains/btc/BtcActions
- */
-
-import type { LombardConfig } from '../../config/types';
-import type { BtcCoreContext } from '../../shared/context';
-import { createBtcCoreContext } from '../../shared/context';
-import { BtcDeposit } from './actions/deposit/BtcDeposit';
-import type {
-  BtcDeposit as IBtcDeposit,
-  BtcDepositParams,
-} from './actions/deposit/types';
-import { BtcDepositAndDeploy } from './actions/depositAndDeploy/BtcDepositAndDeploy';
-import type {
-  BtcDepositAndDeploy as IBtcDepositAndDeploy,
-  BtcDepositAndDeployParams,
-} from './actions/depositAndDeploy/types';
-import { BtcStake } from './actions/stake/BtcStake';
-import type {
-  BtcStake as IBtcStake,
-  BtcStakeParams,
-} from './actions/stake/types';
-import { BtcStakeAndDeploy } from './actions/stakeAndDeploy/BtcStakeAndDeploy';
-import type {
-  BtcStakeAndDeploy as IBtcStakeAndDeploy,
-  BtcStakeAndDeployParams,
-} from './actions/stakeAndDeploy/types';
-
-/**
- * BTC Actions
- *
- * User-facing class for Bitcoin operations.
- * Created via btcActions(config) factory function.
- */
-export class BtcActions {
-  private readonly ctx: BtcCoreContext;
-
-  constructor(config: LombardConfig) {
-    this.ctx = createBtcCoreContext(config);
-  }
-
-  /**
-   * Stake BTC → LBTC
-   *
-   * Creates a stake operation for converting BTC to LBTC on a destination chain.
-   * Supports all destination chains: EVM, Solana, Sui, and Starknet.
-   *
-   * @param params - Stake parameters
-   * @returns BtcStake instance
-   *
-   * @example
-   * ```typescript
-   * const stake = btc.stake({
-   *   assetOut: AssetId.LBTC,
-   *   destChain: Chain.ETHEREUM,
-   * });
-   *
-   * await stake.prepare({ amount: '0.1', recipient: '0x...' });
-   * await stake.authorize();
-   * const address = await stake.generateDepositAddress();
-   * ```
-   */
-  stake(params: BtcStakeParams): IBtcStake {
-    return new BtcStake(this.ctx, params);
-  }
-
-  /**
-   * Stake and Deploy BTC → LBTC + auto-deploy ("Stake and Bake")
-   *
-   * Creates an atomic operation that:
-   * 1. Converts BTC to LBTC
-   * 2. Automatically deposits LBTC to the specified DeFi vault
-   *
-   * @param params - StakeAndDeploy parameters including protocol/vault
-   * @returns BtcStakeAndDeploy instance
-   *
-   * @example
-   * ```typescript
-   * const action = btc.stakeAndDeploy({
-   *   assetOut: AssetId.LBTC,
-   *   destChain: Chain.ETHEREUM,
-   *   protocol: DeployProtocol.Veda,
-   * });
-   *
-   * await action.prepare({ amount: '0.1', recipient: '0x...' });
-   * await action.authorizeDeposit();
-   * const address = await action.generateDepositAddress();
-   * ```
-   */
-  stakeAndDeploy(params: BtcStakeAndDeployParams): IBtcStakeAndDeploy {
-    return new BtcStakeAndDeploy(this.ctx, params);
-  }
-
-  /**
-   * Deposit BTC for custody (BTC → BTC.b)
-   *
-   * Creates a deposit operation for custodying BTC with BTC.b minting.
-   * This is for custody without staking. For staking (BTC → LBTC), use stake().
-   *
-   * @param params - Deposit parameters
-   * @returns BtcDeposit instance
-   *
-   * @example
-   * ```typescript
-   * const deposit = btc.deposit({
-   *   assetOut: AssetId.BTCb,
-   *   destChain: Chain.AVALANCHE,
-   * });
-   *
-   * await deposit.prepare({ amount: '0.1', recipient: '0x...' });
-   * await deposit.authorizeFee();
-   * const address = await deposit.generateDepositAddress();
-   * ```
-   */
-  deposit(params: BtcDepositParams): IBtcDeposit {
-    return new BtcDeposit(this.ctx, params);
-  }
-
-  /**
-   * Deposit and Deploy BTC → BTC.b + auto-deploy to vault
-   *
-   * Creates an atomic operation that:
-   * 1. Converts BTC to BTC.b (wrapped BTC)
-   * 2. Automatically deposits BTC.b to the specified DeFi vault (e.g., Silo on Avalanche)
-   *
-   * This is similar to stakeAndDeploy but for protocols that accept BTC.b instead of LBTC.
-   *
-   * @param params - DepositAndDeploy parameters including protocol/vault
-   * @returns BtcDepositAndDeploy instance
-   *
-   * @example
-   * ```typescript
-   * const action = btc.depositAndDeploy({
-   *   assetOut: AssetId.BTCb,
-   *   destChain: Chain.AVALANCHE,
-   *   protocol: DeployProtocol.Silo,
-   * });
-   *
-   * await action.prepare({ amount: '0.1', recipient: '0x...' });
-   * await action.authorizeDeposit();
-   * const address = await action.generateDepositAddress();
-   * ```
-   */
-  depositAndDeploy(params: BtcDepositAndDeployParams): IBtcDepositAndDeploy {
-    return new BtcDepositAndDeploy(this.ctx, params);
-  }
-}
-
-/**
- * Create BTC actions from config
- *
- * @internal This factory is for internal use. Use createLombardSDK() instead:
- *
- * @example
- * ```typescript
- * const sdk = await createLombardSDK({ env: Env.prod, providers: { ... } });
- * const stake = sdk.chain.btc.stake({ destChain: Chain.ETHEREUM, assetOut: AssetId.LBTC });
- * const deposit = sdk.chain.btc.deposit({ destChain: Chain.AVALANCHE, assetOut: AssetId.BTCb });
- * const stakeAndDeploy = sdk.chain.btc.stakeAndDeploy({
- *   destChain: Chain.AVALANCHE,
- *   assetOut: AssetId.BTCb,
- *   protocol: DeployProtocol.Silo,
- * });
- * ```
- */
-export function btcActions(config: LombardConfig): BtcActions {
-  return new BtcActions(config);
-}

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

@@ -1,388 +0,0 @@
-/**
- * BTC Deposit Action
- *
- * Handles BTC deposit operations for custody without staking.
- * Currently supports EVM destination chains.
- *
- * Fee authorization is ONLY required for Ethereum mainnet.
- * Other chains use address confirmation signing.
- *
- * @module chains/btc/actions/deposit/BtcDeposit
- */
-
-import type { z } from 'zod';
-
-import type { ChainId } from '../../../../common/chains';
-import { isValidChain } from '../../../../common/chains';
-import { parseChainIdentifier, StepStatus } from '../../../../core';
-import type { BtcCoreContext } from '../../../../shared/context';
-import { LombardError, ValidationErrorCode } from '../../../../shared/errors';
-import type { DepositEventMap } from '../../../../shared/events';
-import type { MonitorProgress } from '../../../../shared/monitoring';
-import { Token } from '../../../../tokens/token-addresses';
-import {
-  assetIdToToken,
-  BaseBtcAction,
-  type StatusConfig,
-  type StepDefinition,
-} from '../shared';
-import {
-  depositConfig,
-  type DepositFeeAuthConfig,
-  isAssetOutSupported,
-  isDestChainSupported,
-  isRouteAvailable,
-} from './config';
-import {
-  BtcActionStatus,
-  type BtcDeposit as IBtcDeposit,
-  type BtcDepositParams,
-  type BtcDepositPrepareParams,
-} from './types';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Types
-// ═══════════════════════════════════════════════════════════════════════════
-
-interface AuthorizationState {
-  signature?: string;
-  typedData?: string;
-  authorized: boolean;
-  /** Minting fee in BTC (e.g., "0.00000032") */
-  mintingFee?: string;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// BtcDeposit Implementation
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * BTC Deposit Action
- *
- * Handles BTC deposit to custody with BTC.b minting on destination chain.
- * This is for custody without staking. For staking (BTC → LBTC), use BtcStake.
- *
- * @example
- * ```typescript
- * const deposit = new BtcDeposit(ctx, {
- *   assetOut: AssetId.BTCb,
- *   destChain: Chain.AVALANCHE,
- * });
- *
- * await deposit.prepare({ amount: '0.1', recipient: '0x...' });
- * await deposit.authorizeFee();
- * const address = await deposit.generateDepositAddress();
- * ```
- */
-export class BtcDeposit
-  extends BaseBtcAction<DepositEventMap, BtcActionStatus, BtcDepositParams>
-  implements IBtcDeposit
-{
-  private readonly chainId: ChainId;
-  private readonly authState: AuthorizationState = { authorized: false };
-
-  /** Fee auth config - null if not required for this destination */
-  private feeAuthConfig: DepositFeeAuthConfig | null = null;
-
-  constructor(ctx: BtcCoreContext, params: BtcDepositParams) {
-    super(ctx, params, BtcActionStatus.IDLE);
-
-    // Validate assetOut - BTC Deposit should only produce BTC.b
-    if (!isAssetOutSupported(params.assetOut)) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_ASSET,
-        `Asset ${params.assetOut} is not supported for BTC deposits. ` +
-          `BTC Deposit produces BTC.b. For LBTC, use BtcStake instead.`,
-      );
-    }
-
-    if (!isDestChainSupported(params.destChain)) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_CHAIN,
-        `Destination chain ${params.destChain} is not supported for BTC deposits. ` +
-          `BTC.b is currently available on Avalanche and Katana.`,
-      );
-    }
-
-    if (!isRouteAvailable(params.sourceChain, ctx.env)) {
-      throw LombardError.routeNotFound({
-        assetOut: params.assetOut,
-        sourceChain: params.sourceChain,
-        destChain: params.destChain,
-        env: ctx.env,
-      });
-    }
-
-    const parsed = parseChainIdentifier(params.destChain);
-    if (typeof parsed !== 'number' || !isValidChain(parsed)) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_CHAIN,
-        `Unsupported EVM chain: ${params.destChain}`,
-      );
-    }
-
-    this.chainId = parsed as ChainId;
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Abstract Method Implementations
-  // ─────────────────────────────────────────────────────────────────────────
-
-  protected getAddressSchema(): z.ZodType<string> {
-    return depositConfig.addressSchema;
-  }
-
-  protected getStatusConfig(): StatusConfig<BtcActionStatus> {
-    return {
-      idle: BtcActionStatus.IDLE,
-      ready: BtcActionStatus.READY,
-      addressReady: BtcActionStatus.ADDRESS_READY,
-    };
-  }
-
-  protected getInitialSteps(): StepDefinition {
-    return {
-      created: StepStatus.IDLE,
-      verifying: StepStatus.IDLE,
-      issuing: StepStatus.IDLE,
-    };
-  }
-
-  protected isAuthorized(): boolean {
-    return this.authState.authorized;
-  }
-
-  protected getChainId(): ChainId {
-    return this.chainId;
-  }
-
-  /**
-   * Get the minting fee for this deposit (in BTC)
-   * Available after prepare() when fee authorization is required
-   */
-  get mintingFee(): string | undefined {
-    return this.authState.mintingFee;
-  }
-
-  protected getDepositAddressParams() {
-    const recipient = this.ensureRecipient();
-    return {
-      address: recipient,
-      chainId: this.chainId,
-      signature: this.authState.signature!, // Must be set before calling
-      token: this.getExpectedToken(),
-      eip712Data: this.authState.typedData,
-      partnerId: this.ctx.partner.getPartnerId(),
-      referrerCode: this._referralCode,
-    };
-  }
-
-  /**
-   * Override to ensure we have a signature before generating deposit address.
-   * 
-   * When fee auth exists on server but signature isn't available locally,
-   * we fall back to signing the destination address.
-   */
-  async generateDepositAddress(): Promise<string> {
-    // If signature isn't available locally, sign the destination address as fallback
-    if (!this.authState.signature) {
-      const result = await depositConfig.signDestination(
-        this.ctx,
-        this.ensureRecipient(),
-        this.chainId,
-      );
-      this.authState.signature = result.signature;
-      this.authState.typedData = result.typedData;
-    }
-
-    return this.generateDepositAddressImpl();
-  }
-
-  /**
-   * Get expected token for this action (BTCb by default for BTC Deposit)
-   */
-  protected getExpectedToken(): string {
-    return assetIdToToken(this.params.assetOut, Token.BTCb);
-  }
-
-  protected getAuthRequiredMessage(): string {
-    return this.feeAuthConfig
-      ? 'Fee authorization required. Call authorizeFee() first.'
-      : 'Address confirmation required. Call confirmAddress() first.';
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Public Methods
-  // ─────────────────────────────────────────────────────────────────────────
-
-  async prepare(params: BtcDepositPrepareParams): Promise<void> {
-    this.assertStatus(BtcActionStatus.IDLE, 'prepare');
-
-    return this.act(async () => {
-      const validated = this.validatePrepareParams(params);
-
-      this._amount = validated.amount;
-      this._recipient = validated.recipient;
-      this._referralCode = validated.referralCode;
-
-      // Get fee auth config for this destination chain (needed for both resume and new flow)
-      this.feeAuthConfig = depositConfig.getFeeAuthConfig(
-        this.params.destChain,
-      );
-
-      // Check for existing deposit address (resume flow)
-      const hasExistingDeposit = await this.resumeFromExistingDeposit(
-        validated.recipient,
-      );
-
-      if (hasExistingDeposit) {
-        // We have a deposit address, but we still need to validate fee authorization
-        // The deposit address might have been created when fee auth was valid,
-        // but the fee auth could have expired since then
-        if (this.feeAuthConfig) {
-          const stored = await this.feeAuthConfig.restoreFeeSignature(
-            this.ctx,
-            this.chainId,
-            validated.recipient,
-          );
-
-          // Check hasSignature flag - the actual signature string may not be returned by API
-          if (!stored?.hasSignature) {
-            // Fee auth is required but expired/missing - need re-authorization
-            // Fetch the minting fee for display purposes
-            this.authState.mintingFee = await this.feeAuthConfig.getMintingFee(
-              this.ctx,
-              this.chainId,
-            );
-            this.updateStatus(BtcActionStatus.NEEDS_FEE_AUTHORIZATION);
-            this.emitInitialProgress();
-            return;
-          }
-
-          // Fee auth is still valid on server - store signature if available
-          if (stored.signature) {
-            this.authState.signature = stored.signature;
-            this.authState.typedData = stored.typedData;
-          }
-          this.authState.authorized = true;
-        }
-
-        // Deposit address exists and fee auth is valid (or not required)
-        // Now we can safely set the status to ADDRESS_READY
-        this.updateStatus(BtcActionStatus.ADDRESS_READY);
-        this.emitInitialProgress();
-        return;
-      }
-
-      // No existing deposit - proceed with normal flow
-      if (this.feeAuthConfig) {
-        // Fee authorization required (Ethereum mainnet only)
-        const stored = await this.feeAuthConfig.restoreFeeSignature(
-          this.ctx,
-          this.chainId,
-          validated.recipient,
-        );
-
-        // Check hasSignature flag - the actual signature string may not be returned by API
-        if (stored?.hasSignature) {
-          // Fee auth already exists on server - store signature if available
-          if (stored.signature) {
-            this.authState.signature = stored.signature;
-            this.authState.typedData = stored.typedData;
-          }
-          this.authState.authorized = true;
-          this.updateStatus(BtcActionStatus.READY);
-          this.emitInitialProgress();
-          return;
-        }
-
-        // Fetch the minting fee for display purposes
-        this.authState.mintingFee = await this.feeAuthConfig.getMintingFee(
-          this.ctx,
-          this.chainId,
-        );
-        this.updateStatus(BtcActionStatus.NEEDS_FEE_AUTHORIZATION);
-      } else {
-        this.updateStatus(BtcActionStatus.NEEDS_ADDRESS_CONFIRMATION);
-      }
-
-      this.emitInitialProgress();
-    });
-  }
-
-  async authorizeFee(): Promise<void> {
-    this.assertStatus(
-      [BtcActionStatus.NEEDS_FEE_AUTHORIZATION, BtcActionStatus.READY],
-      'authorizeFee',
-    );
-
-    if (this.status === BtcActionStatus.READY) return;
-
-    if (!this.feeAuthConfig) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_PARAMETER,
-        'Fee authorization is not required for this destination chain. Use confirmAddress() instead.',
-      );
-    }
-
-    const recipient = this.ensureRecipient();
-
-    // Use the minting fee that was fetched during prepare(), not the deposit amount
-    if (!this.authState.mintingFee) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_STATE,
-        'Minting fee not available. Call prepare() first.',
-      );
-    }
-
-    return this.act(async () => {
-      const result = await this.feeAuthConfig!.authorizeFee(this.ctx, {
-        chainId: this.chainId,
-        recipient,
-        fee: this.authState.mintingFee!,
-      });
-
-      this.authState.signature = result.signature;
-      this.authState.typedData = result.typedData;
-      this.authState.authorized = true;
-    }, BtcActionStatus.READY);
-  }
-
-  async confirmAddress(): Promise<void> {
-    this.assertStatus(
-      [BtcActionStatus.NEEDS_ADDRESS_CONFIRMATION, BtcActionStatus.READY],
-      'confirmAddress',
-    );
-
-    if (this.status === BtcActionStatus.READY) return;
-
-    if (this.feeAuthConfig) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_PARAMETER,
-        'This destination chain requires fee authorization. Use authorizeFee() instead.',
-      );
-    }
-
-    const recipient = this.ensureRecipient();
-
-    return this.act(async () => {
-      const result = await depositConfig.signDestination(
-        this.ctx,
-        recipient,
-        this.chainId,
-      );
-
-      this.authState.signature = result.signature;
-      this.authState.typedData = result.typedData;
-      this.authState.authorized = true;
-    }, BtcActionStatus.READY);
-  }
-
-  async execute(): Promise<{ depositAddress: string; txHash?: string }> {
-    return this.executeImpl();
-  }
-
-  async monitorDeposit(): Promise<MonitorProgress | undefined> {
-    return super.monitorDeposit();
-  }
-}