@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/chains/evm/actions/deploy/EvmDeploy.ts

@@ -1,256 +0,0 @@
-/**
- * EVM Deploy Action
- *
- * Deploys L-Assets to DeFi protocols (Veda, Silo).
- *
- * Protocol availability:
- * - Veda: Ethereum, Base, BSC, Corn (prod only)
- * - Silo: Avalanche (prod only)
- *
- * @module chains/evm/actions/deploy/EvmDeploy
- */
-
-import BigNumber from 'bignumber.js';
-import type { EIP1193Provider } from 'viem';
-import { z } from 'zod';
-
-import { makePublicClient } from '../../../../clients/public-client';
-import { makeWalletClient } from '../../../../clients/wallet-client';
-import { CHAIN_ID_TO_VIEM_CHAIN_MAP, type ChainId } from '../../../../common/chains';
-import type { DeployProtocol } from '../../../../core';
-import { parseChainIdentifier, StepStatus } from '../../../../core';
-import { BaseAction } from '../../../../shared/actions/BaseAction';
-import { EvmOperationStatus } from '../../../../shared/constants/statusConstants';
-import type { EvmCoreContext } from '../../../../shared/context';
-import { LombardError } from '../../../../shared/errors';
-import type { DeployEventMap } from '../../../../shared/events';
-import {
-    evmAmountSchema,
-    validatePrepareParams,
-} from '../../../../shared/validation';
-import { Token } from '../../../../tokens/token-addresses';
-import { getTokenInfo, toBaseDenomination } from '../../../../tokens/tokens';
-import toBigInt from '../../../../utils/numbers';
-import { Vault, VAULTS } from '../../../../vaults/lib/config';
-import { deposit } from '../../../../vaults/lib/ops/deposit';
-import { evmConfig } from './config';
-import type {
-    EvmDeployParams,
-    EvmDeployPrepareParams,
-    IEvmDeploy,
-} from './types';
-
-export class EvmDeploy
-  extends BaseAction<DeployEventMap, EvmOperationStatus>
-  implements IEvmDeploy
-{
-  private _amount?: string;
-  private _protocol?: DeployProtocol;
-  private _needsApproval = false;
-  private _txHash?: string;
-  private _account?: `0x${string}`;
-  private _chainId?: ChainId;
-
-  constructor(
-    private readonly ctx: EvmCoreContext,
-    private readonly params: EvmDeployParams,
-  ) {
-    super(EvmOperationStatus.IDLE);
-  }
-
-  get amount(): string | undefined {
-    return this._amount;
-  }
-
-  get protocol(): DeployProtocol | undefined {
-    return this._protocol;
-  }
-
-  get needsApproval(): boolean {
-    return this._needsApproval;
-  }
-
-  get txHash(): string | undefined {
-    return this._txHash;
-  }
-
-  async prepare(params: EvmDeployPrepareParams): Promise<void> {
-    this.assertStatus(EvmOperationStatus.IDLE, 'prepare');
-
-    return this.act(async () => {
-      const validated = validatePrepareParams(this.prepareSchema, params);
-      this._amount = validated.amount;
-      this._protocol = params.protocol;
-
-      this.validateProtocol(params.protocol);
-
-      // Get provider and account
-      const provider = await this.ctx.getProvider('evm');
-      if (!provider) {
-        throw LombardError.providerMissing(this.params.sourceChain, 'evm');
-      }
-
-      const accounts = await (provider as EIP1193Provider).request({
-        method: 'eth_accounts',
-      });
-      const account = (accounts as string[])[0] as `0x${string}`;
-      if (!account) {
-        throw LombardError.providerMissing(this.params.sourceChain, 'evm');
-      }
-
-      this._account = account;
-      this._chainId = parseChainIdentifier(this.params.sourceChain) as ChainId;
-
-      // Check actual allowance to determine if approval is needed
-      const vault = VAULTS[Vault.Veda];
-      const depositToken = await getTokenInfo(Token.LBTC, this._chainId, this.ctx.env);
-      if (!depositToken) {
-        throw LombardError.invalidParameter('token', 'Could not get LBTC token info');
-      }
-
-      const publicClient = makePublicClient({ chainId: this._chainId });
-      const allowanceRaw = await publicClient.readContract({
-        address: depositToken.address,
-        abi: depositToken.abi,
-        functionName: 'allowance',
-        args: [account, vault.vaultContract.address],
-      });
-
-      const amount = new BigNumber(validated.amount);
-      const amountBase = toBaseDenomination(amount, depositToken.decimals);
-      const allowance = new BigNumber(String(allowanceRaw));
-
-      // Check if approval is needed
-      this._needsApproval = amountBase.isGreaterThan(allowance);
-
-      if (this._needsApproval) {
-        this.emitProgress({
-          status: EvmOperationStatus.NEEDS_APPROVAL,
-          steps: { approval: StepStatus.PENDING, deploying: StepStatus.IDLE },
-        });
-        this.updateStatus(EvmOperationStatus.NEEDS_APPROVAL);
-      } else {
-        this.emitProgress({
-          status: EvmOperationStatus.READY,
-          steps: { approval: StepStatus.COMPLETE, deploying: StepStatus.PENDING },
-        });
-        this.updateStatus(EvmOperationStatus.READY);
-      }
-    });
-  }
-
-  async approve(): Promise<void> {
-    this.assertStatus(EvmOperationStatus.NEEDS_APPROVAL, 'approve');
-
-    return this.act(async () => {
-      if (!this._account || !this._chainId || !this._amount) {
-        throw LombardError.missingParameter('account, chainId, or amount');
-      }
-
-      const provider = await this.ctx.getProvider('evm');
-      if (!provider) {
-        throw LombardError.providerMissing(this.params.sourceChain, 'evm');
-      }
-
-      // Get vault and token info
-      const vault = VAULTS[Vault.Veda];
-      const depositToken = await getTokenInfo(Token.LBTC, this._chainId, this.ctx.env);
-      if (!depositToken) {
-        throw LombardError.invalidParameter('token', 'Could not get LBTC token info');
-      }
-
-      const amount = new BigNumber(this._amount);
-      const amountBase = toBigInt(toBaseDenomination(amount, depositToken.decimals));
-
-      // Execute approval transaction
-      const publicClient = makePublicClient({ chainId: this._chainId });
-      const walletClient = makeWalletClient({
-        provider: provider as EIP1193Provider,
-        chainId: this._chainId,
-      });
-
-      const { request } = await publicClient.simulateContract({
-        account: this._account,
-        chain: CHAIN_ID_TO_VIEM_CHAIN_MAP[this._chainId],
-        address: depositToken.address,
-        abi: depositToken.abi,
-        functionName: 'approve',
-        args: [vault.vaultContract.address, amountBase],
-      });
-
-      await walletClient.writeContract(request);
-
-      this._needsApproval = false;
-      this.emitProgress({
-        status: EvmOperationStatus.READY,
-        steps: { approval: StepStatus.COMPLETE, deploying: StepStatus.PENDING },
-      });
-    }, EvmOperationStatus.READY);
-  }
-
-  async execute(): Promise<{ txHash: string }> {
-    this.assertStatus(EvmOperationStatus.READY, 'execute');
-
-    return this.act(async () => {
-      const provider = await this.ctx.getProvider('evm');
-      if (!provider) {
-        throw LombardError.providerMissing(this.params.sourceChain, 'evm');
-      }
-
-      if (!this._account || !this._chainId) {
-        throw LombardError.missingParameter('account or chainId');
-      }
-
-      // Map protocol to vault key
-      const vaultKey = this._protocol === 'veda' ? Vault.Veda : Vault.Veda;
-
-      this.emitProgress({
-        status: EvmOperationStatus.READY,
-        steps: { approval: StepStatus.COMPLETE, deploying: StepStatus.PENDING },
-      });
-
-      // Execute vault deposit (approval already done, so pass approve: false)
-      const txHash = await deposit({
-        amount: this._amount!,
-        approve: false, // Approval was handled in approve() step
-        token: Token.LBTC,
-        vaultKey,
-        account: this._account,
-        chainId: this._chainId,
-        provider: provider as EIP1193Provider,
-        env: this.ctx.env,
-      });
-
-      this._txHash = txHash;
-
-      this.emitProgress({
-        status: EvmOperationStatus.COMPLETED,
-        steps: { approval: StepStatus.COMPLETE, deploying: StepStatus.COMPLETE },
-      });
-
-      this.emitCompleted();
-
-      return { txHash };
-    }, EvmOperationStatus.COMPLETED);
-  }
-
-  private get prepareSchema() {
-    return z.object({
-      amount: evmAmountSchema,
-      protocol: z.string().min(1, 'Protocol is required'),
-    });
-  }
-
-  private validateProtocol(protocol: DeployProtocol): void {
-    const isSupported = evmConfig.routes.some(
-      route =>
-        route.protocols.includes(protocol) && route.envs.includes(this.ctx.env),
-    );
-    if (!isSupported) {
-      throw LombardError.invalidParameter(
-        'protocol',
-        `Protocol ${protocol} is not supported in ${this.ctx.env} environment`,
-      );
-    }
-  }
-}

package/src/chains/evm/actions/deploy/config/evm.ts

@@ -1,80 +0,0 @@
-/**
- * EVM Chain Configuration for Deploy
- *
- * Handles deploying L-Assets to DeFi protocols.
- *
- * @module chains/evm/actions/deploy/config/evm
- */
-
-import { AssetId, Chain, DeployProtocol, Env } from '../../../../../core';
-import { evmAddressSchema } from '../../../../../shared/validation';
-import type { ChainConfig } from './types';
-
-/**
- * EVM deploy configuration
- *
- * Protocol availability:
- * - Veda: Ethereum, Base, BSC, Corn (prod only)
- * - Silo: Avalanche (prod only)
- */
-export const evmConfig: ChainConfig = {
-  chainType: 'evm',
-
-  routes: [
-    // Veda - Ethereum
-    {
-      asset: AssetId.LBTC,
-      sourceChains: [Chain.ETHEREUM],
-      protocols: [DeployProtocol.Veda],
-      envs: [Env.prod],
-    },
-    // Veda - Base
-    {
-      asset: AssetId.LBTC,
-      sourceChains: [Chain.BASE],
-      protocols: [DeployProtocol.Veda],
-      envs: [Env.prod],
-    },
-    // Veda - BSC
-    {
-      asset: AssetId.LBTC,
-      sourceChains: [Chain.BSC],
-      protocols: [DeployProtocol.Veda],
-      envs: [Env.prod],
-    },
-    // Veda - Corn
-    {
-      asset: AssetId.LBTC,
-      sourceChains: [Chain.CORN],
-      protocols: [DeployProtocol.Veda],
-      envs: [Env.prod],
-    },
-    // Silo - Avalanche
-    {
-      asset: AssetId.LBTC,
-      sourceChains: [Chain.AVALANCHE],
-      protocols: [DeployProtocol.Silo],
-      envs: [Env.prod],
-    },
-  ],
-
-  addressSchema: evmAddressSchema,
-};
-
-/**
- * Check if a deploy route is supported
- */
-export function isDeploySupported(
-  asset: AssetId,
-  chain: Chain,
-  protocol: DeployProtocol,
-  env: Env,
-): boolean {
-  return evmConfig.routes.some(
-    route =>
-      route.asset === asset &&
-      route.sourceChains.includes(chain) &&
-      route.protocols.includes(protocol) &&
-      route.envs.includes(env),
-  );
-}

package/src/chains/evm/actions/deploy/config/index.ts

@@ -1,8 +0,0 @@
-/**
- * EVM Deploy Chain Configurations
- *
- * @module chains/evm/actions/deploy/config
- */
-
-export { evmConfig, isDeploySupported } from './evm';
-export type { ChainConfig, RouteDefinition } from './types';

package/src/chains/evm/actions/deploy/config/types.ts

@@ -1,43 +0,0 @@
-/**
- * EVM Deploy Chain Configuration Types
- *
- * @module chains/evm/actions/deploy/config/types
- */
-
-import type { z } from 'zod';
-
-import type {
-  AssetId,
-  Chain,
-  ChainType,
-  DeployProtocol,
-  Env,
-} from '../../../../../core';
-
-/**
- * Route definition for EVM deploy operations
- */
-export interface RouteDefinition {
-  /** Asset to deploy */
-  asset: AssetId;
-  /** Supported source chains */
-  sourceChains: Chain[];
-  /** Supported DeFi protocols */
-  protocols: DeployProtocol[];
-  /** Supported environments */
-  envs: Env[];
-}
-
-/**
- * Chain-specific configuration for EVM deploy operations
- */
-export interface ChainConfig {
-  /** Chain type identifier */
-  chainType: ChainType;
-
-  /** Supported routes for this chain type */
-  routes: RouteDefinition[];
-
-  /** Address validation Zod schema */
-  addressSchema: z.ZodString;
-}

package/src/chains/evm/actions/deploy/factory.ts

@@ -1,44 +0,0 @@
-/**
- * EVM Deploy Factory Functions
- *
- * @module chains/evm/actions/deploy/factory
- */
-
-import type { LombardConfig } from '../../../../config/types';
-import type { EvmCoreContext } from '../../../../shared/context';
-import { createEvmCoreContext } from '../../../../shared/context';
-import { EvmDeploy } from './EvmDeploy';
-import type { EvmDeployParams } from './types';
-
-/**
- * Create EvmDeploy action from config
- *
- * @internal This factory is for internal use. Use createLombardSDK() instead:
- *
- * @example
- * ```typescript
- * const sdk = await createLombardSDK({ env: Env.prod, providers: { evm: () => window.ethereum } });
- * const deploy = sdk.chain.evm.deploy({
- *   sourceChain: Chain.ETHEREUM,
- *   protocol: DeployProtocol.Veda,
- * });
- * await deploy.prepare({ amount: '0.1' });
- * ```
- */
-export function evmDeploy(
-  config: LombardConfig,
-  params: EvmDeployParams,
-): EvmDeploy {
-  const ctx = createEvmCoreContext(config);
-  return new EvmDeploy(ctx, params);
-}
-
-/**
- * Create EvmDeploy action from context
- */
-export function createEvmDeploy(
-  ctx: EvmCoreContext,
-  params: EvmDeployParams,
-): EvmDeploy {
-  return new EvmDeploy(ctx, params);
-}

package/src/chains/evm/actions/deploy/index.ts

@@ -1,17 +0,0 @@
-/**
- * EVM Deploy Action
- *
- * @module chains/evm/actions/deploy
- */
-
-export type { ChainConfig, RouteDefinition } from './config';
-export { evmConfig, isDeploySupported } from './config';
-export { EvmDeploy } from './EvmDeploy';
-export { createEvmDeploy,evmDeploy } from './factory';
-export {
-  type EvmDeployParams,
-  type EvmDeployPrepareParams,
-  type EvmDeployProgress,
-  EvmDeployStatus,
-  type IEvmDeploy,
-} from './types';

package/src/chains/evm/actions/deploy/types.ts

@@ -1,74 +0,0 @@
-/**
- * EVM Deploy Action Types
- *
- * @module chains/evm/actions/deploy/types
- */
-
-import type {
-  AssetId,
-  Chain,
-  DeployProtocol,
-  StepStatus,
-  StrategyProgress,
-} from '../../../../core';
-import type { MonitorableAction } from '../../../../shared/actions/BaseAction';
-import type { EvmOperationStatus } from '../../../../shared/constants/statusConstants';
-import type { LombardError } from '../../../../shared/errors';
-
-// Re-export status for convenience
-export { EvmOperationStatus as EvmDeployStatus } from '../../../../shared/constants/statusConstants';
-
-/**
- * EVM Deploy parameters
- */
-export interface EvmDeployParams {
-  /** Asset to deploy */
-  asset: AssetId;
-  /** Source chain */
-  sourceChain: Chain;
-  /** Default protocol */
-  protocol: DeployProtocol;
-  /** Recipient address for vault shares */
-  recipient: string;
-  /** Slippage tolerance */
-  slippage?: number;
-}
-
-/**
- * EVM Deploy prepare parameters
- */
-export interface EvmDeployPrepareParams {
-  /** Amount to deploy */
-  amount: string;
-  /** Protocol to deploy to */
-  protocol: DeployProtocol;
-}
-
-/**
- * EVM Deploy progress
- */
-export interface EvmDeployProgress
-  extends StrategyProgress<EvmOperationStatus> {
-  status: EvmOperationStatus;
-  steps: {
-    approval: StepStatus;
-    deploying: StepStatus;
-  };
-  txHash?: string;
-}
-
-/**
- * EVM Deploy interface
- */
-export interface IEvmDeploy extends MonitorableAction {
-  readonly status: EvmOperationStatus;
-  readonly error: LombardError | null;
-  readonly amount?: string;
-  readonly protocol?: DeployProtocol;
-  readonly needsApproval: boolean;
-  readonly txHash?: string;
-
-  prepare(params: EvmDeployPrepareParams): Promise<void>;
-  approve(): Promise<void>;
-  execute(): Promise<{ txHash: string }>;
-}

package/src/chains/evm/actions/deposit/EvmDeposit.ts

@@ -1,159 +0,0 @@
-/**
- * EVM Deposit Action
- *
- * Claims LBTC from a notarized BTC deposit.
- *
- * Flow:
- * 1. BTC is deposited to Lombard's BTC address (via BtcDeposit/BtcStake)
- * 2. Deposit is notarized by the consortium
- * 3. User claims LBTC using setClaimData() + execute()
- *
- * @module chains/evm/actions/deposit/EvmDeposit
- */
-
-import type { EIP1193Provider } from 'viem';
-import { z } from 'zod';
-
-import type { ChainId } from '../../../../common/chains';
-import { claimLBTC } from '../../../../contract-functions';
-import { parseChainIdentifier,StepStatus } from '../../../../core';
-import { BaseAction } from '../../../../shared/actions/BaseAction';
-import type { EvmCoreContext } from '../../../../shared/context';
-import { LombardError } from '../../../../shared/errors';
-import type { DepositEventMap } from '../../../../shared/events';
-import {
-  evmAmountSchema,
-  validatePrepareParams,
-} from '../../../../shared/validation';
-import { evmConfig } from './config';
-import {
-  type EvmDepositParams,
-  type EvmDepositPrepareParams,
-  EvmDepositStatus,
-  type IEvmDeposit,
-} from './types';
-
-export class EvmDeposit
-  extends BaseAction<DepositEventMap, EvmDepositStatus>
-  implements IEvmDeposit
-{
-  private _amount?: string;
-  private _recipient?: string;
-  private _needsApproval = false;
-  private _txHash?: string;
-  private _claimData?: { data: string; proofSignature: string };
-
-  constructor(
-    private readonly ctx: EvmCoreContext,
-    private readonly params: EvmDepositParams,
-  ) {
-    super(EvmDepositStatus.IDLE);
-  }
-
-  get amount(): string | undefined {
-    return this._amount;
-  }
-
-  get recipient(): string | undefined {
-    return this._recipient;
-  }
-
-  get needsApproval(): boolean {
-    return this._needsApproval;
-  }
-
-  get txHash(): string | undefined {
-    return this._txHash;
-  }
-
-  setClaimData(data: string, proofSignature: string): void {
-    this._claimData = { data, proofSignature };
-  }
-
-  async prepare(params: EvmDepositPrepareParams): Promise<void> {
-    this.assertStatus(EvmDepositStatus.IDLE, 'prepare');
-
-    return this.act(async () => {
-      const validated = validatePrepareParams(this.prepareSchema, params, {
-        destChain: this.params.destChain,
-      });
-      this._amount = validated.amount;
-      this._recipient = validated.recipient;
-
-      this._needsApproval = false;
-      this.emitProgress({
-        status: EvmDepositStatus.READY,
-        steps: {
-          approval: StepStatus.COMPLETE,
-          execution: StepStatus.IDLE,
-          bridging: StepStatus.IDLE,
-        },
-      });
-    }, EvmDepositStatus.READY);
-  }
-
-  async approve(): Promise<void> {
-    this.assertStatus(EvmDepositStatus.NEEDS_APPROVAL, 'approve');
-
-    return this.act(async () => {
-      this._needsApproval = false;
-    }, EvmDepositStatus.READY);
-  }
-
-  async execute(): Promise<{ txHash: string }> {
-    this.assertStatus(EvmDepositStatus.READY, 'execute');
-
-    if (!this._claimData) {
-      throw LombardError.missingParameter('claimData');
-    }
-
-    return this.act(async () => {
-      const provider = await this.ctx.getProvider('evm');
-      if (!provider) {
-        throw LombardError.providerMissing(this.params.sourceChain, 'evm');
-      }
-
-      const chainId = parseChainIdentifier(this.params.destChain) as ChainId;
-
-      this.emitProgress({
-        status: EvmDepositStatus.READY,
-        steps: {
-          approval: StepStatus.COMPLETE,
-          execution: StepStatus.PENDING,
-          bridging: StepStatus.IDLE,
-        },
-      });
-
-      const txHash = await claimLBTC({
-        provider: provider as EIP1193Provider,
-        account: this._recipient! as `0x${string}`,
-        data: this._claimData!.data,
-        proofSignature: this._claimData!.proofSignature,
-        chainId,
-        env: this.ctx.env,
-      });
-
-      this._txHash = txHash;
-
-      this.emitProgress({
-        status: EvmDepositStatus.COMPLETED,
-        steps: {
-          approval: StepStatus.COMPLETE,
-          execution: StepStatus.COMPLETE,
-          bridging: StepStatus.IDLE,
-        },
-      });
-
-      this.emitCompleted();
-
-      return { txHash };
-    }, EvmDepositStatus.COMPLETED);
-  }
-
-  private get prepareSchema() {
-    return z.object({
-      amount: evmAmountSchema,
-      recipient: evmConfig.addressSchema,
-    });
-  }
-}