@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/chains/btc/actions/depositAndDeploy/BtcDepositAndDeploy.ts

@@ -1,366 +0,0 @@
-/**
- * BTC DepositAndDeploy Action
- *
- * Handles BTC → BTC.b → Vault deposit in a single atomic operation.
- * Similar to StakeAndDeploy but produces BTC.b instead of LBTC.
- * Used for protocols like Silo on Avalanche that accept BTC.b.
- *
- * @module chains/btc/actions/depositAndDeploy/BtcDepositAndDeploy
- */
-
-import type { z } from 'zod';
-
-import type { ChainId } from '../../../../common/chains';
-import { isValidChain } from '../../../../common/chains';
-import { Chain, parseChainIdentifier,StepStatus } from '../../../../core';
-import type { BtcCoreContext } from '../../../../shared/context';
-import { LombardError, ValidationErrorCode } from '../../../../shared/errors';
-import type { DepositAndDeployEventMap } from '../../../../shared/events';
-import {
-  monitorDeposit,
-  type MonitorProgress,
-} from '../../../../shared/monitoring';
-import { Token } from '../../../../tokens/token-addresses';
-import { ensureNotSanctionedAddress } from '../../../../utils/ensureNotSanctionedAddress';
-import { toSatoshi } from '../../../../utils/satoshi';
-import {
-  assetIdToToken,
-  BaseBtcAction,
-  type StatusConfig,
-  type StepDefinition,
-} from '../shared';
-import {
-  depositAndDeployConfig,
-  getVaultKey,
-  isAssetOutSupported,
-  isDestChainSupported,
-  isProtocolSupported,
-  isRouteAvailable,
-} from './config';
-import {
-  BtcActionStatus,
-  type BtcDepositAndDeploy as IBtcDepositAndDeploy,
-  type BtcDepositAndDeployParams,
-  type BtcDepositAndDeployPrepareParams,
-} from './types';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Types
-// ═══════════════════════════════════════════════════════════════════════════
-
-interface AuthState {
-  fee?: string;
-  signature?: string;
-  typedData?: string;
-  approvalTxHash?: string;
-  authorized: boolean;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// BtcDepositAndDeploy Implementation
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * BTC DepositAndDeploy Action
- *
- * Combines deposit (BTC → BTC.b) and vault deployment in a single atomic operation.
- *
- * @example
- * ```typescript
- * const depositAndDeploy = new BtcDepositAndDeploy(ctx, {
- *   assetOut: AssetId.BTCb,
- *   destChain: Chain.AVALANCHE,
- *   protocol: DeployProtocol.Silo,
- * });
- *
- * await depositAndDeploy.prepare({ amount: '0.1', recipient: '0x...' });
- * await depositAndDeploy.authorizeDeposit();
- * const address = await depositAndDeploy.generateDepositAddress();
- * ```
- */
-export class BtcDepositAndDeploy
-  extends BaseBtcAction<
-    DepositAndDeployEventMap,
-    BtcActionStatus,
-    BtcDepositAndDeployParams
-  >
-  implements IBtcDepositAndDeploy
-{
-  private readonly chainId: ChainId;
-  private readonly authState: AuthState = { authorized: false };
-
-  constructor(ctx: BtcCoreContext, params: BtcDepositAndDeployParams) {
-    super(ctx, params, BtcActionStatus.IDLE);
-
-    // Validate assetOut - DepositAndDeploy should only produce BTC.b
-    if (!isAssetOutSupported(params.assetOut)) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_ASSET,
-        `Asset ${params.assetOut} is not supported for deposit and deploy. ` +
-          `DepositAndDeploy produces BTC.b which is then deployed to a vault like Silo.`,
-      );
-    }
-
-    if (!isDestChainSupported(params.destChain)) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_CHAIN,
-        `Destination chain ${params.destChain} is not supported for deposit and deploy. ` +
-          `Supported chains: Avalanche, Avalanche Fuji`,
-      );
-    }
-
-    if (!isProtocolSupported(params.protocol)) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_PARAMETER,
-        `Protocol ${params.protocol} is not supported for deposit and deploy. ` +
-          `DepositAndDeploy with BTC.b only supports Silo protocol.`,
-      );
-    }
-
-    const sourceChain = params.sourceChain ?? Chain.BITCOIN_MAINNET;
-    if (!isRouteAvailable(sourceChain, ctx.env)) {
-      throw LombardError.routeNotFound({
-        assetOut: params.assetOut,
-        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 depositAndDeployConfig.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,
-      wrapping: StepStatus.IDLE,
-      depositing: StepStatus.IDLE,
-    };
-  }
-
-  protected isAuthorized(): boolean {
-    return this.authState.authorized;
-  }
-
-  protected getChainId(): ChainId {
-    return this.chainId;
-  }
-
-  protected getDepositAddressParams() {
-    const recipient = this.ensureRecipient();
-    return {
-      address: recipient,
-      chainId: this.chainId,
-      signature: this.authState.signature!,
-      token: this.getExpectedToken(),
-      eip712Data: this.authState.typedData,
-      partnerId: this.ctx.partner.getPartnerId(),
-      referrerCode: this._referralCode,
-    };
-  }
-
-  /**
-   * Get expected token for this action (BTCb by default for DepositAndDeploy)
-   */
-  protected getExpectedToken(): string {
-    return assetIdToToken(this.params.assetOut, Token.BTCb);
-  }
-
-  protected getAuthRequiredMessage(): string {
-    return 'Deposit authorization required. Call authorizeDeposit() first.';
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Public Getters
-  // ─────────────────────────────────────────────────────────────────────────
-
-  /** Get deposit and deploy fee (available after prepare()) */
-  get fee(): string | undefined {
-    return this.authState.fee;
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Public Methods
-  // ─────────────────────────────────────────────────────────────────────────
-
-  async prepare(params: BtcDepositAndDeployPrepareParams): 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 for deposit and deploy (uses config's getVaultKey for validation)
-      this.authState.fee = await depositAndDeployConfig.getDepositAndDeployFee(
-        this.ctx,
-        this.chainId,
-        getVaultKey(this.params.protocol),
-      );
-
-      this.updateStatus(BtcActionStatus.NEEDS_DEPLOY_AUTHORIZATION);
-      this.emitInitialProgress();
-    }, BtcActionStatus.NEEDS_DEPLOY_AUTHORIZATION);
-  }
-
-  async authorizeDeposit(): Promise<void> {
-    this.assertStatus(
-      [BtcActionStatus.NEEDS_DEPLOY_AUTHORIZATION, BtcActionStatus.READY],
-      'authorizeDeposit',
-    );
-
-    if (this.status === BtcActionStatus.READY) return;
-
-    const recipient = this.ensureRecipient();
-    const amount = this.ensureAmount();
-
-    return this.act(async () => {
-      const amountSats = toSatoshi(amount);
-
-      // For BTC → BTC.b deposit and deploy, use the output token (BTCb).
-      // Unlike LBTC which has a variable ratio with BTC, BTC.b is 1:1 with BTC
-      // so no ratio conversion is needed (amountStrategy: 'identity').
-      // Using assetIdToToken ensures we use the correct token for the permit.
-      const outputToken = assetIdToToken(this.params.assetOut, Token.BTCb);
-
-      const result = await depositAndDeployConfig.authorizeDepositAndDeploy(
-        this.ctx,
-        {
-          chainId: this.chainId,
-          recipient,
-          amount: amountSats.toString(),
-          vaultKey: getVaultKey(this.params.protocol),
-          token: outputToken,
-        },
-      );
-
-      this.authState.signature = result.signature;
-      this.authState.typedData = result.typedData;
-      this.authState.authorized = true;
-    }, BtcActionStatus.READY);
-  }
-
-  async generateDepositAddress(): Promise<string> {
-    this.assertStatus(BtcActionStatus.READY, 'generateDepositAddress');
-    this.ensureAuthorized();
-
-    if (this._depositAddress) {
-      return this._depositAddress;
-    }
-
-    return this.act(async () => {
-      const apiParams = this.getDepositAddressParams();
-      const depositAddress =
-        await this.ctx.api.generateDepositAddress(apiParams);
-
-      ensureNotSanctionedAddress(depositAddress);
-      this._depositAddress = depositAddress;
-
-      this.emitProgress({
-        status: BtcActionStatus.ADDRESS_READY,
-        steps: {
-          created: StepStatus.COMPLETE,
-          verifying: StepStatus.IDLE,
-          wrapping: StepStatus.IDLE,
-          depositing: StepStatus.IDLE,
-        },
-        metadata: { depositAddress },
-      });
-
-      return depositAddress;
-    }, BtcActionStatus.ADDRESS_READY);
-  }
-
-  async execute(): Promise<{ depositAddress: string; txHash?: string }> {
-    return this.act(async () => {
-      this.assertStatus(BtcActionStatus.ADDRESS_READY, 'execute');
-
-      if (!this._depositAddress) {
-        await this.generateDepositAddress();
-      }
-
-      const depositAddress = this.ensureDepositAddress();
-      const txHash = await this.trySendBitcoin(depositAddress);
-
-      return txHash ? { depositAddress, txHash } : { depositAddress };
-    });
-  }
-
-  // Custom monitorDeposit with different step names
-  async monitorDeposit(): Promise<MonitorProgress | undefined> {
-    const depositAddress = this._depositAddress;
-    const recipient = this._recipient;
-
-    if (!depositAddress || !recipient) {
-      throw LombardError.missingParameter('depositAddress or recipient');
-    }
-
-    const progress = await monitorDeposit({
-      network: this.bitcoinNetwork,
-      btcService: this.ctx.btc,
-      fetchDeposit: async () => {
-        const deposits = await this.ctx.api.getDeposits(recipient);
-        const ourDeposit = deposits.find(
-          deposit => deposit.depositAddress === depositAddress,
-        );
-
-        if (!ourDeposit) {
-          return undefined;
-        }
-
-        return {
-          blockHeight: ourDeposit.blockHeight,
-          isClaimed: ourDeposit.isClaimed,
-        };
-      },
-      onProgress: p => {
-        this.emitProgress({
-          status: this.status,
-          steps: {
-            created: StepStatus.COMPLETE,
-            verifying: p.hasEnoughConfirmations
-              ? StepStatus.COMPLETE
-              : StepStatus.PENDING,
-            wrapping: p.isClaimed ? StepStatus.COMPLETE : StepStatus.PENDING,
-            depositing: StepStatus.PENDING,
-          },
-          confirmations: p.confirmations,
-          requiredConfirmations: p.requiredConfirmations,
-          metadata: { isClaimed: p.isClaimed },
-        });
-      },
-      onComplete: () => {
-        this.emitCompleted();
-      },
-    });
-
-    return progress;
-  }
-}

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

@@ -1,105 +0,0 @@
-/**
- * EVM Chain Configuration for BTC DepositAndDeploy
- *
- * BTC DepositAndDeploy: BTC → BTC.b → DeFi vault (Silo)
- *
- * Note: DepositAndDeploy is for protocols that accept BTC.b (wrapped BTC)
- * rather than LBTC. Currently, this is Silo on Avalanche.
- *
- * @module chains/btc/actions/depositAndDeploy/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 } from '../../../../../core';
-import { LombardError } from '../../../../../shared/errors';
-import { ensureCorrectChain } from '../../../../../shared/evm/switchChain';
-import { evmAddressSchema } from '../../../../../shared/validation';
-import { getSupportedProtocols } from '../../stakeAndDeploy/config';
-import type { DepositAndDeployChainConfig } from './types';
-
-// DepositAndDeploy requires BTC.b + Silo vault support
-// Currently only Avalanche is supported
-const DEPOSIT_AND_DEPLOY_CHAINS = {
-  mainnet: [Chain.AVALANCHE],
-  testnet: [Chain.AVALANCHE_FUJI],
-};
-
-/**
- * EVM deposit and deploy configuration
- *
- * DepositAndDeploy produces BTC.b then deploys to a vault.
- * Currently limited to Silo on Avalanche.
- */
-export const evmDepositAndDeployConfig: DepositAndDeployChainConfig = {
-  chainType: 'evm',
-
-  routes: [
-    {
-      sourceChains: [Chain.BITCOIN_MAINNET],
-      envs: [Env.prod],
-    },
-    {
-      sourceChains: [Chain.BITCOIN_SIGNET],
-      envs: [Env.stage, Env.dev, Env.testnet, Env.ibc],
-    },
-  ],
-
-  // DepositAndDeploy with BTC.b is available on Avalanche
-  destChains: [
-    ...DEPOSIT_AND_DEPLOY_CHAINS.mainnet,
-    ...DEPOSIT_AND_DEPLOY_CHAINS.testnet,
-  ],
-
-  // DepositAndDeploy produces BTC.b (then deposits to vault)
-  supportedAssetsOut: [AssetId.BTCb],
-
-  supportedProtocols: getSupportedProtocols(AssetId.BTCb),
-
-  addressSchema: evmAddressSchema,
-
-  async getDepositAndDeployFee(ctx, chainId, vaultKey) {
-    const evm = ctx.capabilities.require('evm') as EvmService;
-    // Silo uses the same fee mechanism as stake and bake
-    return evm.getStakeAndBakeFee(chainId as ChainId, vaultKey);
-  },
-
-  async authorizeDepositAndDeploy(
-    ctx,
-    { chainId, recipient, amount, vaultKey, token },
-  ) {
-    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);
-
-    // Silo uses the approve flow (on-chain approval), not permit
-    const result = await evm.signStakeAndBake({
-      value: amount,
-      account: recipient,
-      chainId: chainId as ChainId,
-      provider: provider as EIP1193Provider,
-      vaultKey,
-      token,
-    });
-
-    // Store signature via API (even for approve flow, we need to track it)
-    await ctx.api.storeStakeAndBakeSignature({
-      signature: result.signature,
-      typedData: result.typedData,
-    });
-
-    return {
-      signature: result.signature,
-      typedData: result.typedData,
-      // approvalTxHash may not be present in the result for all flows
-      approvalTxHash: (result as { approvalTxHash?: string }).approvalTxHash,
-    };
-  },
-};

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

@@ -1,111 +0,0 @@
-/**
- * BTC DepositAndDeploy Configuration
- *
- * Exports configuration for BTC → BTC.b → Vault operations.
- * Uses DEFI_REGISTRY as the single source of truth for protocol validation.
- *
- * @module chains/btc/actions/depositAndDeploy/config
- */
-
-import type { AssetId, Chain, Env } from '../../../../../core';
-import { DEFI_REGISTRY,DefiProtocol } from '../../../../../defi';
-import { evmDepositAndDeployConfig } from './evm';
-import type { DepositAndDeployChainConfig } from './types';
-
-export type {
-  DepositAndDeployAuthResult,
-  DepositAndDeployChainConfig,
-  DepositAndDeployRouteDefinition,
-} from './types';
-
-/**
- * The default config for DepositAndDeploy
- * Currently only EVM (Avalanche + Silo) is supported
- */
-export const depositAndDeployConfig: DepositAndDeployChainConfig =
-  evmDepositAndDeployConfig;
-
-/**
- * Check if a destination chain is supported for deposit and deploy
- */
-export function isDestChainSupported(destChain: Chain): boolean {
-  return depositAndDeployConfig.destChains.includes(destChain);
-}
-
-/**
- * Check if assetOut is supported for DepositAndDeploy
- * DepositAndDeploy should only produce BTC.b
- */
-export function isAssetOutSupported(assetOut: AssetId): boolean {
-  return depositAndDeployConfig.supportedAssetsOut.includes(assetOut);
-}
-
-/**
- * Check if a protocol is supported for deposit and deploy
- * Uses DEFI_REGISTRY as the single source of truth
- */
-export function isProtocolSupported(protocol: string): boolean {
-  // Check if protocol exists in DEFI_REGISTRY
-  return protocol in DEFI_REGISTRY;
-}
-
-/**
- * Get the vault key for a protocol
- * Returns the protocol key if valid, throws if not supported
- *
- * @param protocol - Protocol identifier from DefiProtocol
- * @returns The vault key for API calls
- * @throws If protocol is not in DEFI_REGISTRY
- */
-export function getVaultKey(protocol: string): string {
-  if (!isProtocolSupported(protocol)) {
-    const supportedProtocols = Object.keys(DEFI_REGISTRY).join(', ');
-    throw new Error(
-      `Unsupported protocol: ${protocol}. ` +
-        `Supported protocols: ${supportedProtocols}`,
-    );
-  }
-  // Protocol keys in DEFI_REGISTRY match DefiProtocol values
-  return protocol;
-}
-
-/**
- * Get list of supported protocols for DepositAndDeploy
- * This returns protocols that support BTC.b (for DepositAndDeploy)
- */
-export function getSupportedProtocols(assetId: AssetId): DefiProtocol[] {
-  return Object.entries(DEFI_REGISTRY)
-    .filter(([_, tokenMap]) => assetId in tokenMap)
-    .map(([protocol]) => protocol as DefiProtocol);
-}
-/**
- * Check if a route is available for a given source chain and environment
- */
-export function isRouteAvailable(sourceChain: Chain, env: Env): boolean {
-  return depositAndDeployConfig.routes.some(
-    route =>
-      route.sourceChains.includes(sourceChain) && route.envs.includes(env),
-  );
-}
-
-/**
- * Check if a protocol supports a specific chain for deposit and deploy
- */
-export function isProtocolChainSupported(
-  protocol: string,
-  chainId: number,
-  env: Env,
-): boolean {
-  const protocolRegistry = DEFI_REGISTRY[protocol as DefiProtocol];
-  if (!protocolRegistry) return false;
-
-  // Check BTCb token (used by DepositAndDeploy)
-  const btcbRegistry =
-    protocolRegistry['BTCb' as keyof typeof protocolRegistry];
-  if (!btcbRegistry) return false;
-
-  const envRegistry = btcbRegistry[env];
-  if (!envRegistry) return false;
-
-  return chainId in envRegistry;
-}

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

@@ -1,67 +0,0 @@
-/**
- * BTC DepositAndDeploy Chain Configuration Types
- *
- * BTC DepositAndDeploy: BTC → BTC.b → DeFi vault (Silo)
- *
- * @module chains/btc/actions/depositAndDeploy/config/types
- */
-
-import type { z } from 'zod';
-
-import type { AssetId, Chain, DeployProtocol, Env } from '../../../../../core';
-import type { BtcCoreContext } from '../../../../../shared/context';
-
-/**
- * Route definition
- */
-export interface DepositAndDeployRouteDefinition {
-  sourceChains: Chain[];
-  envs: Env[];
-}
-
-/**
- * Authorization result
- */
-export interface DepositAndDeployAuthResult {
-  signature: string;
-  typedData?: string;
-  approvalTxHash?: string;
-}
-
-/**
- * DepositAndDeploy chain configuration
- *
- * DepositAndDeploy produces BTC.b then deploys to a vault (e.g., Silo on Avalanche).
- */
-export interface DepositAndDeployChainConfig {
-  chainType: 'evm';
-  routes: DepositAndDeployRouteDefinition[];
-  destChains: Chain[];
-  /** Supported output assets - DepositAndDeploy produces BTC.b */
-  supportedAssetsOut: AssetId[];
-  supportedProtocols: DeployProtocol[];
-  addressSchema: z.ZodString;
-
-  /**
-   * Get deposit and deploy fee for a protocol
-   */
-  getDepositAndDeployFee: (
-    ctx: BtcCoreContext,
-    chainId: unknown,
-    vaultKey: string,
-  ) => Promise<string>;
-
-  /**
-   * Authorize deposit and deploy (approve flow for BTC.b)
-   */
-  authorizeDepositAndDeploy: (
-    ctx: BtcCoreContext,
-    params: {
-      chainId: unknown;
-      recipient: string;
-      amount: string;
-      vaultKey: string;
-      token: string;
-    },
-  ) => Promise<DepositAndDeployAuthResult>;
-}

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

@@ -1,38 +0,0 @@
-/**
- * BTC DepositAndDeploy Factory Functions
- *
- * Factory functions for creating BTC DepositAndDeploy actions.
- *
- * @module chains/btc/actions/depositAndDeploy/factory
- */
-
-import type { BtcCoreContext } from '../../../../shared/context';
-import { BtcDepositAndDeploy } from './BtcDepositAndDeploy';
-import type { BtcDepositAndDeployParams } from './types';
-
-/**
- * Create a BTC DepositAndDeploy action
- *
- * Convenience factory function for creating BTC → BTC.b → Vault operations.
- *
- * @example
- * ```typescript
- * import { createBtcDepositAndDeploy, Chain, AssetId, DeployProtocol } from '@lombard.finance/sdk';
- *
- * const depositAndDeploy = createBtcDepositAndDeploy(ctx, {
- *   assetOut: AssetId.BTCb,
- *   destChain: Chain.AVALANCHE,
- *   protocol: DeployProtocol.Silo,
- * });
- *
- * await depositAndDeploy.prepare({ amount: '0.1', recipient: '0x...' });
- * await depositAndDeploy.authorizeDeposit();
- * const address = await depositAndDeploy.generateDepositAddress();
- * ```
- */
-export function createBtcDepositAndDeploy(
-  ctx: BtcCoreContext,
-  params: BtcDepositAndDeployParams,
-): BtcDepositAndDeploy {
-  return new BtcDepositAndDeploy(ctx, params);
-}