@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/chains/btc/actions/stakeAndDeploy/BtcStakeAndDeploy.ts

@@ -1,415 +0,0 @@
-/**
- * BTC StakeAndDeploy Action
- *
- * Handles BTC → LBTC → Vault deposit in a single atomic operation.
- * Also known as "Stake and Bake".
- *
- * @module chains/btc/actions/stakeAndDeploy/BtcStakeAndDeploy
- */
-
-import type { z } from 'zod';
-
-import type { ChainId } from '../../../../common/chains';
-import { isValidChain } from '../../../../common/chains';
-import { AssetId, parseChainIdentifier, StepStatus } from '../../../../core';
-import type { BtcCoreContext } from '../../../../shared/context';
-import { LombardError, ValidationErrorCode } from '../../../../shared/errors';
-import type { StakeAndDeployEventMap } 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 {
-  getVaultKey,
-  isAssetOutSupported,
-  isDestChainSupported,
-  isProtocolSupported,
-  isRouteAvailable,
-  stakeAndDeployConfig,
-} from './config';
-import {
-  BtcActionStatus,
-  type BtcStakeAndDeploy as IBtcStakeAndDeploy,
-  type BtcStakeAndDeployParams,
-  type BtcStakeAndDeployPrepareParams,
-} from './types';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Types
-// ═══════════════════════════════════════════════════════════════════════════
-
-interface AuthState {
-  fee?: string;
-  signature?: string;
-  typedData?: string;
-  authorized: boolean;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// BtcStakeAndDeploy Implementation
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * BTC StakeAndDeploy Action
- *
- * Combines staking and vault deployment in a single atomic operation.
- *
- * @example
- * ```typescript
- * const stakeAndDeploy = new BtcStakeAndDeploy(ctx, {
- *   assetOut: AssetId.LBTC,
- *   destChain: Chain.ETHEREUM,
- *   protocol: DeployProtocol.Veda,
- * });
- *
- * await stakeAndDeploy.prepare({ amount: '0.1', recipient: '0x...' });
- * await stakeAndDeploy.authorizeDeposit();
- * const address = await stakeAndDeploy.generateDepositAddress();
- * ```
- */
-export class BtcStakeAndDeploy
-  extends BaseBtcAction<
-    StakeAndDeployEventMap,
-    BtcActionStatus,
-    BtcStakeAndDeployParams
-  >
-  implements IBtcStakeAndDeploy
-{
-  private readonly chainId: ChainId;
-  private readonly authState: AuthState = { authorized: false };
-
-  constructor(ctx: BtcCoreContext, params: BtcStakeAndDeployParams) {
-    super(ctx, params, BtcActionStatus.IDLE);
-
-    // Validate assetOut - StakeAndDeploy should only produce LBTC
-    if (!isAssetOutSupported(params.assetOut)) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_ASSET,
-        `Asset ${params.assetOut} is not supported for stake and deploy. ` +
-          `StakeAndDeploy produces LBTC which is then deployed to a vault.`,
-      );
-    }
-
-    if (!isDestChainSupported(params.destChain)) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_CHAIN,
-        `Destination chain ${params.destChain} is not supported for stake and deploy`,
-      );
-    }
-
-    if (!isProtocolSupported(params.protocol)) {
-      throw new LombardError(
-        ValidationErrorCode.INVALID_PARAMETER,
-        `Protocol ${params.protocol} is not supported for stake and deploy`,
-      );
-    }
-
-    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 stakeAndDeployConfig.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,
-      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 (LBTC by default for StakeAndDeploy)
-   */
-  protected getExpectedToken(): string {
-    return assetIdToToken(this.params.assetOut, Token.LBTC);
-  }
-
-  protected getAuthRequiredMessage(): string {
-    return 'Deposit authorization required. Call authorizeDeposit() first.';
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Public Getters
-  // ─────────────────────────────────────────────────────────────────────────
-
-  /** Get stake and bake fee (available after prepare()) */
-  get fee(): string | undefined {
-    return this.authState.fee;
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Public Methods
-  // ─────────────────────────────────────────────────────────────────────────
-
-  async prepare(params: BtcStakeAndDeployPrepareParams): 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 stake and bake
-      this.authState.fee = await stakeAndDeployConfig.getStakeAndBakeFee(
-        this.ctx,
-        this.chainId,
-        this.params.protocol,
-      );
-
-      // Check for existing deposit address (resume flow)
-      const hasExistingDeposit = await this.resumeFromExistingDeposit(
-        validated.recipient,
-      );
-
-      if (hasExistingDeposit) {
-        // We have a deposit address - check if stake and bake signature is still valid
-        const stored = await stakeAndDeployConfig.restoreStakeAndBakeSignature(
-          this.ctx,
-          this.chainId,
-          validated.recipient,
-        );
-
-        if (stored?.hasSignature) {
-          // Valid signature exists - skip authorization step
-          if (stored.signature) {
-            this.authState.signature = stored.signature;
-          }
-          this.authState.authorized = true;
-          this.updateStatus(BtcActionStatus.ADDRESS_READY);
-          this.emitInitialProgress();
-          return;
-        }
-
-        // Deposit exists but signature expired/missing - need re-authorization
-        this.updateStatus(BtcActionStatus.NEEDS_DEPLOY_AUTHORIZATION);
-        this.emitInitialProgress();
-        return;
-      }
-
-      // No existing deposit - check if there's a valid signature anyway
-      // (signature was created but deposit address not yet generated)
-      const existingSignature =
-        await stakeAndDeployConfig.restoreStakeAndBakeSignature(
-          this.ctx,
-          this.chainId,
-          validated.recipient,
-        );
-
-      if (existingSignature?.hasSignature) {
-        // Valid signature exists - skip to READY state
-        if (existingSignature.signature) {
-          this.authState.signature = existingSignature.signature;
-        }
-        this.authState.authorized = true;
-        this.updateStatus(BtcActionStatus.READY);
-        this.emitInitialProgress();
-        return;
-      }
-
-      // No existing signature - require authorization
-      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 → LBTC stake and bake, use AssetId.BTC to trigger ratio conversion.
-      // The DEFI_REGISTRY maps 'BTC' to { amountStrategy: 'btcToLbtc' } which divides
-      // the BTC amount by BTCTokenRatio to get the correct LBTC amount for the signature.
-      // This is critical because the backend expects the ratio-adjusted amount.
-      //
-      // Note: assetIn is optional but for BtcStakeAndDeploy, the source is always
-      // native BTC since we're receiving deposits on the Bitcoin blockchain.
-      const sourceToken = this.params.assetIn ?? AssetId.BTC;
-
-      const result = await stakeAndDeployConfig.authorizeStakeAndBake(
-        this.ctx,
-        {
-          chainId: this.chainId,
-          recipient,
-          amount: amountSats.toString(),
-          vaultKey: getVaultKey(this.params.protocol),
-          token: sourceToken,
-        },
-      );
-
-      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,
-          issuing: 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,
-            issuing: 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/stakeAndDeploy/config/evm.ts

@@ -1,135 +0,0 @@
-/**
- * EVM Chain Configuration for BTC StakeAndDeploy
- *
- * BTC StakeAndDeploy: BTC → LBTC → DeFi vault (Veda, Silo)
- *
- * Note: StakeAndDeploy is limited to chains that have both LBTC deployed
- * AND Veda/Silo vault support. This is a subset of all LBTC chains.
- *
- * @module chains/btc/actions/stakeAndDeploy/config/evm
- */
-
-import type { EvmService } from '@lombard.finance/sdk-common';
-import type { EIP1193Provider } from 'viem';
-
-import { getUserStakeAndBakeSignature } from '../../../../../api-functions/getUserStakeAndBakeSignature';
-import type { ChainId } from '../../../../../common/chains';
-import { AssetId, Chain, Env, evmChainIdToChain } from '../../../../../core';
-import { LombardError } from '../../../../../shared/errors';
-import { ensureCorrectChain } from '../../../../../shared/evm/switchChain';
-import { evmAddressSchema } from '../../../../../shared/validation';
-import { VEDA_VAULT_STAKE_AND_BAKE_CHAINS } from '../../../../../vaults/lib/config';
-import { getSupportedProtocols } from '../../depositAndDeploy/config';
-import type { StakeAndDeployChainConfig } from './types';
-
-// Convert chain IDs to Chain enum values (CAIP-2 format)
-// Uses VEDA_VAULT_STAKE_AND_BAKE_CHAINS as source of truth
-const STAKE_AND_DEPLOY_DEST_CHAINS = VEDA_VAULT_STAKE_AND_BAKE_CHAINS.map(
-  chainId => evmChainIdToChain(chainId),
-);
-
-/**
- * EVM stake and deploy configuration
- *
- * StakeAndDeploy produces LBTC then deploys to a vault.
- * Limited to chains with Veda/Silo vault support.
- */
-export const evmStakeAndDeployConfig: StakeAndDeployChainConfig = {
-  chainType: 'evm',
-
-  routes: [
-    {
-      sourceChains: [Chain.BITCOIN_MAINNET],
-      envs: [Env.prod],
-    },
-    {
-      sourceChains: [Chain.BITCOIN_SIGNET],
-      envs: [Env.stage, Env.dev, Env.testnet, Env.ibc],
-    },
-  ],
-
-  // StakeAndDeploy requires vault support - uses VEDA_VAULT_STAKE_AND_BAKE_CHAINS as source of truth
-  destChains: STAKE_AND_DEPLOY_DEST_CHAINS,
-
-  // StakeAndDeploy produces LBTC (then deposits to vault)
-  supportedAssetsOut: [AssetId.LBTC],
-
-  supportedProtocols: getSupportedProtocols(AssetId.LBTC),
-
-  addressSchema: evmAddressSchema,
-
-  async getStakeAndBakeFee(ctx, chainId, protocol) {
-    const evm = ctx.capabilities.require('evm') as EvmService;
-    return evm.getStakeAndBakeFee(chainId as ChainId, protocol);
-  },
-
-  async authorizeStakeAndBake(
-    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);
-
-    const result = await evm.signStakeAndBake({
-      value: amount,
-      account: recipient,
-      chainId: chainId as ChainId,
-      provider: provider as EIP1193Provider,
-      vaultKey,
-      token,
-    });
-
-    // Store signature via API
-    await ctx.api.storeStakeAndBakeSignature({
-      signature: result.signature,
-      typedData: result.typedData,
-    });
-
-    return {
-      signature: result.signature,
-      typedData: result.typedData,
-    };
-  },
-
-  async restoreStakeAndBakeSignature(ctx, chainId, recipient) {
-    try {
-      const result = await getUserStakeAndBakeSignature({
-        userDestinationAddress: recipient,
-        chainId: chainId as ChainId,
-        env: ctx.env,
-      });
-
-      // Check if signature exists and hasn't expired
-      if (!result.signature) {
-        return null;
-      }
-
-      // Check expiration - expirationDate is Unix timestamp in seconds
-      // Convert to milliseconds for Date comparison
-      if (result.expirationDate) {
-        const expirationMs = Number(result.expirationDate) * 1000;
-        if (expirationMs < Date.now()) {
-          // Signature has expired
-          return null;
-        }
-      }
-
-      return {
-        hasSignature: true,
-        signature: result.signature,
-        depositAmount: result.depositAmount,
-        expirationDate: result.expirationDate,
-      };
-    } catch {
-      // API error (e.g., signature not found, network error)
-      // Return null to indicate no valid signature exists
-      return null;
-    }
-  },
-};

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

@@ -1,119 +0,0 @@
-/**
- * BTC StakeAndDeploy Chain Configuration Registry
- *
- * BTC StakeAndDeploy: BTC → LBTC → DeFi vault
- * Uses DEFI_REGISTRY as the single source of truth for protocol validation.
- *
- * @module chains/btc/actions/stakeAndDeploy/config
- */
-
-import type { AssetId, Chain, Env } from '../../../../../core';
-import { DEFI_REGISTRY,DefiProtocol } from '../../../../../defi';
-import { Token } from '../../../../../tokens/token-addresses';
-import { evmStakeAndDeployConfig } from './evm';
-
-export type {
-  StakeAndBakeAuthResult,
-  StakeAndDeployChainConfig,
-  StakeAndDeployRouteDefinition,
-} from './types';
-
-/**
- * Config (currently EVM only)
- */
-export const stakeAndDeployConfig = evmStakeAndDeployConfig;
-
-/**
- * Check if destination chain is supported
- */
-export function isDestChainSupported(chain: Chain): boolean {
-  return stakeAndDeployConfig.destChains.includes(chain);
-}
-
-/**
- * Check if assetOut is supported
- * StakeAndDeploy should only produce LBTC
- */
-export function isAssetOutSupported(assetOut: AssetId): boolean {
-  return stakeAndDeployConfig.supportedAssetsOut.includes(assetOut);
-}
-
-/**
- * Check if route is available
- */
-export function isRouteAvailable(
-  sourceChain: Chain | undefined,
-  env: Env,
-): boolean {
-  if (!sourceChain) return true;
-  return stakeAndDeployConfig.routes.some(
-    route =>
-      route.sourceChains.includes(sourceChain) && route.envs.includes(env),
-  );
-}
-
-/**
- * Check if protocol is supported for stake 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 StakeAndDeploy
- * This returns protocols that support LBTC or BTC (for StakeAndDeploy from BTC)
- * 
- * TODO: Update this to match against asset and chain
- */
-export function getSupportedProtocols(assetId: AssetId): DefiProtocol[] {
-  return Object.entries(DEFI_REGISTRY)
-    .filter(([_, tokenMap]) => assetId in tokenMap)
-    .map(([protocol]) => protocol as DefiProtocol);
-}
-
-/**
- * Check if a protocol supports a specific chain for stake and deploy
- */
-export function isProtocolChainSupported(
-  protocol: string,
-  chainId: number,
-  env: Env,
-): boolean {
-  const protocolRegistry = DEFI_REGISTRY[protocol as DefiProtocol];
-  if (!protocolRegistry) return false;
-
-  // Check LBTC token first, then BTC
-  const lbtcRegistry =
-    protocolRegistry[Token.LBTC as keyof typeof protocolRegistry];
-  const btcRegistry = protocolRegistry['BTC' as keyof typeof protocolRegistry];
-
-  const tokenRegistry = lbtcRegistry || btcRegistry;
-  if (!tokenRegistry) return false;
-
-  const envRegistry = tokenRegistry[env];
-  if (!envRegistry) return false;
-
-  return chainId in envRegistry;
-}