@lombard.finance/sdk 3.7.4 → 4.0.0

package/src/core/chains/index.ts

@@ -0,0 +1,39 @@
+/**
+ * Core Chains Module
+ *
+ * Chain identifiers, catalog, and query functions.
+ *
+ * @module core/chains
+ */
+
+// Types and constants
+export type { ChainMetadata, ChainType } from './types';
+export {
+  CAIP2_SEPARATOR,
+  Chain,
+  CHAIN_PREFIXES,
+  chainValueToKey,
+  isChain,
+} from './types';
+
+// Catalog
+export { CHAIN_CATALOG } from './catalog';
+
+// Query functions
+export type { ChainTypeMetadata } from './utils';
+export {
+  evmChainIdToChain,
+  getChainMetadata,
+  getChainName,
+  getChainsByType,
+  getChainType,
+  getChainTypeMetadata,
+  getExplorerAddressUrl,
+  getExplorerTxUrl,
+  getMainnetChains,
+  getTestnetChains,
+  isEvmChain,
+  isMainnet,
+  isTestnet,
+  parseChainIdentifier,
+} from './utils';

package/src/core/chains/types.ts

@@ -0,0 +1,193 @@
+/**
+ * Chain Types
+ *
+ * Type definitions and constants for chains.
+ *
+ * @module core/chains/types
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Chain Prefixes (CAIP-2 namespaces)
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * CAIP-2 namespace prefixes for chain identification.
+ *
+ * Official namespaces (registered with ChainAgnostic):
+ * - EIP155: EVM-compatible chains
+ * - BIP122: Bitcoin and Bitcoin-derived chains (uses genesis block hash as reference)
+ * - SOLANA: Solana blockchain
+ * - STARKNET: Starknet L2
+ *
+ * Unofficial namespaces (not yet registered, used for internal identification):
+ * - SUI: Sui blockchain (proposal pending)
+ * - ZCASH, RIPPLE, DOGECOIN, HYPERLIQUID: Internal use only
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-2
+ * @see https://namespaces.chainagnostic.org
+ */
+export const CHAIN_PREFIXES = {
+  // Official CAIP-2 namespaces
+  BIP122: 'bip122',
+  EIP155: 'eip155',
+  SOLANA: 'solana',
+  STARKNET: 'starknet',
+
+  // Unofficial namespaces (internal use)
+  SUI: 'sui',
+  ZCASH: 'zcash',
+  RIPPLE: 'ripple',
+  DOGECOIN: 'dogecoin',
+  HYPERLIQUID: 'hyperliquid',
+} as const;
+
+/** CAIP-2 separator between namespace and reference */
+export const CAIP2_SEPARATOR = ':' as const;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Chain Constants
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Helper to construct CAIP-2 identifier */
+const caip2 = (prefix: string, reference: string | number) =>
+  `${prefix}${CAIP2_SEPARATOR}${reference}` as const;
+
+/**
+ * Canonical chain identifiers using CAIP-2 format.
+ */
+export const Chain = {
+  // Bitcoin chains (BIP122: first 32 chars of genesis block hash in little-endian)
+  BITCOIN_MAINNET: caip2(
+    CHAIN_PREFIXES.BIP122,
+    '000000000019d6689c085ae165831e93',
+  ),
+  BITCOIN_SIGNET: caip2(
+    CHAIN_PREFIXES.BIP122,
+    '00000008819873e925422c1ff0f99f7c',
+  ),
+
+  // EVM chains (EIP155: numeric chain ID)
+  ETHEREUM: caip2(CHAIN_PREFIXES.EIP155, 1),
+  BASE: caip2(CHAIN_PREFIXES.EIP155, 8453),
+  BASE_SEPOLIA: caip2(CHAIN_PREFIXES.EIP155, 84532),
+  OPTIMISM: caip2(CHAIN_PREFIXES.EIP155, 10),
+  POLYGON: caip2(CHAIN_PREFIXES.EIP155, 137),
+  BSC: caip2(CHAIN_PREFIXES.EIP155, 56),
+  BSC_TESTNET: caip2(CHAIN_PREFIXES.EIP155, 97),
+  AVALANCHE: caip2(CHAIN_PREFIXES.EIP155, 43114),
+  AVALANCHE_FUJI: caip2(CHAIN_PREFIXES.EIP155, 43113),
+  BERACHAIN: caip2(CHAIN_PREFIXES.EIP155, 80094),
+  BERACHAIN_BARTIO: caip2(CHAIN_PREFIXES.EIP155, 80084),
+  BOB: caip2(CHAIN_PREFIXES.EIP155, 60808),
+  CORN: caip2(CHAIN_PREFIXES.EIP155, 21000000),
+  ETHERLINK: caip2(CHAIN_PREFIXES.EIP155, 42793),
+  KATANA: caip2(CHAIN_PREFIXES.EIP155, 747474),
+  KATANA_TATARA: caip2(CHAIN_PREFIXES.EIP155, 129399),
+  MORPH: caip2(CHAIN_PREFIXES.EIP155, 2818),
+  SONIC: caip2(CHAIN_PREFIXES.EIP155, 146),
+  SONIC_TESTNET: caip2(CHAIN_PREFIXES.EIP155, 57054),
+  SONIC_BLAZE_TESTNET: caip2(CHAIN_PREFIXES.EIP155, 57054), // Alias
+  SWELL: caip2(CHAIN_PREFIXES.EIP155, 1923),
+  TAC: caip2(CHAIN_PREFIXES.EIP155, 239),
+  SEPOLIA: caip2(CHAIN_PREFIXES.EIP155, 11155111),
+  HOLESKY: caip2(CHAIN_PREFIXES.EIP155, 17000),
+  MEGAETH: caip2(CHAIN_PREFIXES.EIP155, 4326),
+  MONAD: caip2(CHAIN_PREFIXES.EIP155, 143),
+  STABLE: caip2(CHAIN_PREFIXES.EIP155, 988),
+
+  // Solana chains (first 32 chars of genesis hash)
+  SOLANA_MAINNET: caip2(
+    CHAIN_PREFIXES.SOLANA,
+    '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+  ),
+  SOLANA_DEVNET: caip2(
+    CHAIN_PREFIXES.SOLANA,
+    'EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+  ),
+  SOLANA_TESTNET: caip2(
+    CHAIN_PREFIXES.SOLANA,
+    '4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z',
+  ),
+
+  // Sui chains (unofficial namespace, using cluster names)
+  SUI_MAINNET: caip2(CHAIN_PREFIXES.SUI, 'mainnet'),
+  SUI_TESTNET: caip2(CHAIN_PREFIXES.SUI, 'testnet'),
+  SUI_DEVNET: caip2(CHAIN_PREFIXES.SUI, 'devnet'),
+
+  // Starknet chains (uses network identifiers)
+  STARKNET_MAINNET: caip2(CHAIN_PREFIXES.STARKNET, 'SN_MAIN'),
+  STARKNET_SEPOLIA: caip2(CHAIN_PREFIXES.STARKNET, 'SN_SEPOLIA'),
+
+  // Zcash (unofficial namespace)
+  ZCASH_MAINNET: caip2(CHAIN_PREFIXES.ZCASH, 'mainnet'),
+  ZCASH_TESTNET: caip2(CHAIN_PREFIXES.ZCASH, 'testnet'),
+
+  // Ripple (unofficial namespace)
+  RIPPLE_MAINNET: caip2(CHAIN_PREFIXES.RIPPLE, 'mainnet'),
+  RIPPLE_TESTNET: caip2(CHAIN_PREFIXES.RIPPLE, 'testnet'),
+
+  // Dogecoin (unofficial namespace)
+  DOGECOIN_MAINNET: caip2(CHAIN_PREFIXES.DOGECOIN, 'mainnet'),
+  DOGECOIN_TESTNET: caip2(CHAIN_PREFIXES.DOGECOIN, 'testnet'),
+
+  // Custodial (unofficial namespace)
+  HYPERLIQUID: caip2(CHAIN_PREFIXES.HYPERLIQUID, 'mainnet'),
+} as const;
+
+export type Chain = (typeof Chain)[keyof typeof Chain];
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Metadata Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type ChainType =
+  | 'bitcoin'
+  | 'evm'
+  | 'solana'
+  | 'sui'
+  | 'starknet'
+  | 'zcash'
+  | 'ripple'
+  | 'dogecoin'
+  | 'hyperliquid';
+
+export interface ChainMetadata {
+  /** Human-readable chain name */
+  name: string;
+  /** Chain type/ecosystem */
+  type: ChainType;
+  /** Whether this is a testnet/devnet */
+  isTestnet: boolean;
+  /** Block explorer URL */
+  explorerUrl?: string;
+  /** Native currency symbol */
+  nativeCurrency?: string;
+  /** UI badge variant */
+  badgeVariant:
+    | 'primary'
+    | 'secondary'
+    | 'success'
+    | 'danger'
+    | 'warning'
+    | 'info';
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Type Utilities
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Convert Chain value to its key name */
+export function chainValueToKey(value: string): string {
+  return (
+    Object.keys(Chain).find(
+      key => Chain[key as keyof typeof Chain] === value,
+    ) ?? ''
+  );
+}
+
+/** Type guard to check if a value is a valid Chain */
+export function isChain(value: unknown): value is Chain {
+  return (
+    typeof value === 'string' && Object.values(Chain).includes(value as Chain)
+  );
+}

package/src/core/chains/utils.ts

@@ -0,0 +1,245 @@
+/**
+ * Chain Query Functions
+ *
+ * Utility functions for querying the chain catalog.
+ *
+ * @module core/chains/utils
+ */
+
+import {
+  ChainId,
+  isSolanaChain,
+  isSuiChain,
+  isValidChain,
+  SOLANA_DEVNET_CHAIN,
+  SOLANA_MAINNET_CHAIN,
+  SOLANA_TESTNET_CHAIN,
+  SolanaChain,
+  STARKNET_MAINNET_CHAIN,
+  STARKNET_SEPOLIA_CHAIN,
+  StarknetChainId,
+  SuiChain,
+} from '../../common/chains';
+import { LombardError, ValidationErrorCode } from '../../shared/errors';
+import { CHAIN_CATALOG } from './catalog';
+import {
+  CAIP2_SEPARATOR,
+  Chain,
+  CHAIN_PREFIXES,
+  ChainMetadata,
+  ChainType,
+  isChain,
+} from './types';
+
+/**
+ * Maps CAIP-2 Solana genesis hash references to legacy SolanaChain constants.
+ * 
+ * CAIP-2 uses the first 32 chars of the genesis block hash as the reference,
+ * while the legacy system uses network names like 'mainnet-beta', 'devnet', 'testnet'.
+ * 
+ * Genesis hashes:
+ * - Mainnet: 5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp (full hash starts with 5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc65hiGPAejCtx5...)
+ * - Devnet: EtWTRABZaYq6iMfeYKouRu166VU2xqa1 (full hash starts with EtWTRABZaYq6iMfeYKouRu166VU2xqa1dT5ZqE8CjGWRXc...)
+ * - Testnet: 4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z (full hash starts with 4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zUEzxnuRbtRMp8...)
+ */
+const SOLANA_GENESIS_TO_CHAIN: Record<string, SolanaChain> = {
+  '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': SOLANA_MAINNET_CHAIN,
+  'EtWTRABZaYq6iMfeYKouRu166VU2xqa1': SOLANA_DEVNET_CHAIN,
+  '4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z': SOLANA_TESTNET_CHAIN,
+};
+
+/**
+ * Maps CAIP-2 Starknet network names to Starknet hex chain IDs.
+ *
+ * CAIP-2 uses human-readable network names (SN_MAIN, SN_SEPOLIA) as the reference,
+ * while Starknet SDK expects hex-encoded chain IDs.
+ *
+ * Mapping:
+ * - SN_MAIN → 0x534e5f4d41494e (hex of "SN_MAIN")
+ * - SN_SEPOLIA → 0x534e5f5345504f4c4941 (hex of "SN_SEPOLIA")
+ */
+const STARKNET_NETWORK_TO_CHAIN_ID: Record<string, StarknetChainId> = {
+  SN_MAIN: STARKNET_MAINNET_CHAIN,
+  SN_SEPOLIA: STARKNET_SEPOLIA_CHAIN,
+};
+
+/**
+ * Converts a CAIP-2 Starknet network name to its hex chain ID.
+ *
+ * @param network - The network name from CAIP-2 (e.g., "SN_SEPOLIA")
+ * @returns The Starknet hex chain ID, or undefined if not found
+ */
+function starknetNetworkToChainId(network: string): StarknetChainId | undefined {
+  return STARKNET_NETWORK_TO_CHAIN_ID[network];
+}
+
+/** Get chain metadata */
+export function getChainMetadata(chain: Chain): ChainMetadata {
+  return CHAIN_CATALOG[chain];
+}
+
+/** Get the human-readable name for a chain */
+export function getChainName(chain: Chain): string {
+  return CHAIN_CATALOG[chain].name;
+}
+
+/** Get chain type */
+export function getChainType(chain: Chain): ChainType {
+  return CHAIN_CATALOG[chain].type;
+}
+
+/** Check if a chain is a testnet */
+export function isTestnet(chain: Chain): boolean {
+  return CHAIN_CATALOG[chain].isTestnet;
+}
+
+/** Check if a chain is a mainnet */
+export function isMainnet(chain: Chain): boolean {
+  return !CHAIN_CATALOG[chain].isTestnet;
+}
+
+/** Check if a chain is an EVM chain */
+export function isEvmChain(chain: Chain): boolean {
+  return CHAIN_CATALOG[chain].type === 'evm';
+}
+
+/** Get block explorer URL for an address */
+export function getExplorerAddressUrl(
+  chain: Chain,
+  address: string,
+): string | undefined {
+  const { explorerUrl } = CHAIN_CATALOG[chain];
+  if (!explorerUrl) return undefined;
+  return `${explorerUrl}/address/${address}`;
+}
+
+/** Get block explorer URL for a transaction */
+export function getExplorerTxUrl(
+  chain: Chain,
+  txHash: string,
+): string | undefined {
+  const { explorerUrl } = CHAIN_CATALOG[chain];
+  if (!explorerUrl) return undefined;
+  return `${explorerUrl}/tx/${txHash}`;
+}
+
+/** Get all mainnet chains */
+export function getMainnetChains(): Chain[] {
+  return (Object.keys(CHAIN_CATALOG) as Chain[]).filter(
+    chain => !CHAIN_CATALOG[chain].isTestnet,
+  );
+}
+
+/** Get all testnet chains */
+export function getTestnetChains(): Chain[] {
+  return (Object.keys(CHAIN_CATALOG) as Chain[]).filter(
+    chain => CHAIN_CATALOG[chain].isTestnet,
+  );
+}
+
+/** Get all chains of a specific type */
+export function getChainsByType(type: ChainType): Chain[] {
+  return (Object.keys(CHAIN_CATALOG) as Chain[]).filter(
+    chain => CHAIN_CATALOG[chain].type === type,
+  );
+}
+
+/** Helper to get prefix with separator */
+const withSeparator = (prefix: string) => `${prefix}${CAIP2_SEPARATOR}`;
+
+/** Parse a CAIP-2 chain identifier into its native chain representation */
+export function parseChainIdentifier(
+  chain: Chain,
+): ChainId | SuiChain | SolanaChain | StarknetChainId {
+  const evmPrefix = withSeparator(CHAIN_PREFIXES.EIP155);
+  if (chain.startsWith(evmPrefix)) {
+    const chainId = Number.parseInt(chain.slice(evmPrefix.length), 10);
+    if (isValidChain(chainId)) return chainId;
+    throw new LombardError(
+      ValidationErrorCode.INVALID_CHAIN,
+      `Invalid EVM chain: ${chain}`,
+    );
+  }
+
+  const solanaPrefix = withSeparator(CHAIN_PREFIXES.SOLANA);
+  if (chain.startsWith(solanaPrefix)) {
+    const reference = chain.slice(solanaPrefix.length);
+    
+    // First check if it's already in legacy format (e.g., 'mainnet-beta', 'devnet')
+    const legacyChain = `solana:${reference}`;
+    if (isSolanaChain(legacyChain)) return legacyChain as SolanaChain;
+    
+    // Otherwise, map CAIP-2 genesis hash to legacy format
+    const mappedChain = SOLANA_GENESIS_TO_CHAIN[reference];
+    if (mappedChain) return mappedChain;
+    
+    throw new LombardError(
+      ValidationErrorCode.INVALID_CHAIN,
+      `Invalid Solana chain: ${chain}`,
+    );
+  }
+
+  const suiPrefix = withSeparator(CHAIN_PREFIXES.SUI);
+  if (chain.startsWith(suiPrefix)) {
+    // isSuiChain expects the full chain ID (e.g., 'sui:testnet'), not just the network part
+    if (isSuiChain(chain)) return chain as SuiChain;
+    throw new LombardError(
+      ValidationErrorCode.INVALID_CHAIN,
+      `Invalid Sui chain: ${chain}`,
+    );
+  }
+
+  const starknetPrefix = withSeparator(CHAIN_PREFIXES.STARKNET);
+  if (chain.startsWith(starknetPrefix)) {
+    const network = chain.slice(starknetPrefix.length);
+    // Map CAIP-2 network names to Starknet hex chain IDs
+    const starknetChainId = starknetNetworkToChainId(network);
+    if (starknetChainId) return starknetChainId;
+    throw new LombardError(
+      ValidationErrorCode.INVALID_CHAIN,
+      `Invalid Starknet chain: ${chain}`,
+    );
+  }
+
+  throw new LombardError(
+    ValidationErrorCode.INVALID_CHAIN,
+    `Invalid chain: ${chain}`,
+  );
+}
+
+/**
+ * Convert an EVM ChainId (number) to a Chain (CAIP-2 string).
+ *
+ * @param chainId - Numeric EVM chain ID
+ * @returns CAIP-2 chain identifier
+ *
+ * @example
+ * ```typescript
+ * evmChainIdToChain(1) // "eip155:1" (Ethereum)
+ * evmChainIdToChain(43114) // "eip155:43114" (Avalanche)
+ * ```
+ */
+export function evmChainIdToChain(chainId: ChainId): Chain {
+  return `${CHAIN_PREFIXES.EIP155}${CAIP2_SEPARATOR}${chainId}` as Chain;
+}
+
+/** @deprecated Use getChainMetadata instead */
+export interface ChainTypeMetadata {
+  type: string;
+  label: string;
+  variant: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info';
+}
+
+/** @deprecated Use getChainMetadata instead */
+export function getChainTypeMetadata(chain: Chain | string): ChainTypeMetadata {
+  if (isChain(chain)) {
+    const meta = CHAIN_CATALOG[chain];
+    return {
+      type: meta.type,
+      label: meta.type.toUpperCase(),
+      variant: meta.badgeVariant,
+    };
+  }
+  const prefix = chain.split(':')[0];
+  return { type: prefix, label: prefix.toUpperCase(), variant: 'secondary' };
+}

package/src/core/index.ts

@@ -0,0 +1,72 @@
+/**
+ * Core Module
+ *
+ * Foundational definitions for chains, assets, and common types.
+ *
+ * @module core
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Chain exports
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type { ChainMetadata, ChainType, ChainTypeMetadata } from './chains';
+export {
+  CAIP2_SEPARATOR,
+  Chain,
+  CHAIN_CATALOG,
+  CHAIN_PREFIXES,
+  chainValueToKey,
+  evmChainIdToChain,
+  getChainMetadata,
+  getChainName,
+  getChainsByType,
+  getChainType,
+  getChainTypeMetadata,
+  getExplorerAddressUrl,
+  getExplorerTxUrl,
+  getMainnetChains,
+  getTestnetChains,
+  isChain,
+  isEvmChain,
+  isMainnet,
+  isTestnet,
+  parseChainIdentifier,
+} from './chains';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Asset exports
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type { AssetCatalog, AssetEntry, Deployment } from './assets';
+export {
+  ASSET_CATALOG,
+  AssetId,
+  assetValueToKey,
+  getAllAssetChains,
+  getAssetAddress,
+  getAssetByAddress,
+  getAssetChains,
+  getAssetChainsForEnvs,
+  getAssetDecimals,
+  getAssetDisplayName,
+  getAssetEnvironments,
+  getAssetMetadata,
+  getAssetRouter,
+  getBridgeAdapter,
+  getChainsWithAllAssets,
+  getEvmAssetChains,
+  getEvmChainsWithAllAssets,
+  getPublicMarketMaker,
+  getSupportedAssets,
+  isAssetDeployed,
+  isAssetId,
+  usesAssetRouter,
+} from './assets';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Common types
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type { DeployConfig, RouteParams, StrategyProgress } from './types';
+export { DeployProtocol, Env, StepStatus, StrategyStatus } from './types';

package/src/core/types.ts

@@ -0,0 +1,126 @@
+/**
+ * Core Types
+ *
+ * Common types used across the Lombard SDK.
+ *
+ * @module core/types
+ */
+
+import type { AssetId } from './assets';
+import type { Chain } from './chains';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Strategy Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Common strategy statuses across all operation types
+ */
+export const StrategyStatus = {
+  IDLE: 'idle',
+  PREPARING: 'preparing',
+  READY: 'ready',
+  EXECUTING: 'executing',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+} as const;
+
+export type StrategyStatus =
+  (typeof StrategyStatus)[keyof typeof StrategyStatus];
+
+/**
+ * Step status for progress tracking
+ */
+export const StepStatus = {
+  IDLE: 'idle',
+  PENDING: 'pending',
+  COMPLETE: 'complete',
+  FAILED: 'failed',
+} as const;
+
+export type StepStatus = (typeof StepStatus)[keyof typeof StepStatus];
+
+/**
+ * Progress information for strategy execution
+ */
+export interface StrategyProgress<TStatus extends string> {
+  /** Current strategy status */
+  status: TStatus;
+
+  /** Individual step statuses (keys vary by strategy) */
+  steps: Record<string, StepStatus>;
+
+  /** Optional: Current confirmations for blockchain transactions */
+  confirmations?: number;
+
+  /** Optional: Required confirmations for completion */
+  requiredConfirmations?: number;
+
+  /** Optional: Additional metadata specific to the strategy */
+  metadata?: Record<string, unknown>;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Route Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Route parameters for registry lookups
+ */
+export interface RouteParams {
+  /** Input asset (optional for some operations like deposits) */
+  assetIn?: AssetId;
+
+  /** Output asset */
+  assetOut: AssetId;
+
+  /** Source blockchain (optional for some operations) */
+  sourceChain?: Chain;
+
+  /** Destination blockchain */
+  destChain: Chain;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Deploy Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Deploy protocol identifiers
+ *
+ * Re-exported from defi-registry.ts which is the single source of truth.
+ * Use DefiProtocol.Veda ('veda') or DefiProtocol.Silo ('silo').
+ */
+export {
+  type DefiProtocol,
+  DefiProtocol as DeployProtocol,
+} from '../defi/defi-registry';
+
+/**
+ * Deploy configuration for stake-and-deploy operations
+ */
+export interface DeployConfig {
+  /** Target protocol (use DeployProtocol.Veda or DeployProtocol.Silo) */
+  protocol: string;
+
+  /** Optional: Amount to deploy (partial deployment) */
+  amount?: bigint;
+
+  /** Optional: Slippage tolerance in basis points (e.g., 50 = 0.5%) */
+  slippage?: number;
+
+  /** Optional: Deadline timestamp for the deployment transaction */
+  deadline?: number;
+
+  /** Optional: Protocol-specific options */
+  options?: Record<string, unknown>;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Re-exports
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Re-export Env from sdk-common for convenience
+ */
+export { Env } from '@lombard.finance/sdk-common';