@lombard.finance/sdk 3.7.3 → 4.0.0

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

@@ -0,0 +1,415 @@
+/**
+ * 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

@@ -0,0 +1,135 @@
+/**
+ * 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

@@ -0,0 +1,119 @@
+/**
+ * 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;
+}