@eth-optimism/actions-sdk 0.0.0-main-20251009211102

package/src/lend/namespaces/WalletLendNamespace.ts

@@ -0,0 +1,116 @@
+import type { LendProvider } from '@/lend/core/LendProvider.js'
+import type {
+  BaseLendConfig,
+  ClosePositionParams,
+  GetPositionParams,
+  LendMarketPosition,
+  LendOpenPositionParams,
+  LendTransactionReceipt,
+} from '@/types/lend/index.js'
+import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
+
+/**
+ * Wallet Lend Namespace
+ * @description Full lending operations available on wallet.lend
+ */
+export class WalletLendNamespace<
+  TConfig extends BaseLendConfig = BaseLendConfig,
+> {
+  constructor(
+    protected readonly provider: LendProvider<TConfig>,
+    private readonly wallet: Wallet,
+  ) {}
+
+  get config(): TConfig {
+    return this.provider.config
+  }
+
+  // Inherited methods from ActionsLendNamespace
+  getMarkets = (...args: Parameters<LendProvider<TConfig>['getMarkets']>) =>
+    this.provider.getMarkets(...args)
+
+  getMarket = (...args: Parameters<LendProvider<TConfig>['getMarket']>) =>
+    this.provider.getMarket(...args)
+
+  supportedChainIds = (
+    ...args: Parameters<LendProvider<TConfig>['supportedChainIds']>
+  ) => this.provider.supportedChainIds(...args)
+
+  /**
+   * Open a lending position
+   * @description Signs and sends a lend transaction from the wallet for the given amount and asset
+   */
+  async openPosition(
+    params: LendOpenPositionParams,
+  ): Promise<LendTransactionReceipt> {
+    const lendTransaction = await this.provider.openPosition({
+      ...params,
+      walletAddress: this.wallet.address,
+    })
+
+    const { transactionData } = lendTransaction
+    if (!transactionData) {
+      throw new Error('No transaction data returned from lend provider')
+    }
+
+    if (transactionData.approval && transactionData.openPosition) {
+      return await this.wallet.sendBatch(
+        [transactionData.approval, transactionData.openPosition],
+        params.marketId.chainId,
+      )
+    }
+
+    if (!transactionData.openPosition) {
+      throw new Error('No openPosition transaction data returned')
+    }
+    return await this.wallet.send(
+      transactionData.openPosition,
+      params.marketId.chainId,
+    )
+  }
+
+  /**
+   * Get position information for this wallet
+   * @param params - Position query parameters
+   * @param params.marketId - Market identifier (required)
+   * @param params.asset - Asset filter (not yet supported)
+   * @returns Promise resolving to position information
+   */
+  async getPosition(params: GetPositionParams): Promise<LendMarketPosition> {
+    return this.provider.getPosition(
+      this.wallet.address,
+      params.marketId,
+      params.asset,
+    )
+  }
+
+  /**
+   * Close a lending position (withdraw from market)
+   * @param closePositionParams - Position closing parameters
+   * @returns Promise resolving to transaction hash
+   */
+  async closePosition(
+    params: ClosePositionParams,
+  ): Promise<LendTransactionReceipt> {
+    const closeTransaction = await this.provider.closePosition({
+      ...params,
+      walletAddress: this.wallet.address,
+    })
+
+    const { transactionData } = closeTransaction
+    if (!transactionData) {
+      throw new Error(
+        'No transaction data returned from close position provider',
+      )
+    }
+
+    if (!transactionData.closePosition) {
+      throw new Error('No closePosition transaction data returned')
+    }
+
+    return await this.wallet.send(
+      transactionData.closePosition,
+      params.marketId.chainId,
+    )
+  }
+}

package/src/lend/namespaces/__tests__/ActionsLendNamespace.spec.ts

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { ActionsLendNamespace } from '@/lend/namespaces/ActionsLendNamespace.js'
+import { createMockLendProvider } from '@/test/MockLendProvider.js'
+import { getRandomAddress } from '@/test/utils.js'
+import type { LendProvider } from '@/types/lend/index.js'
+
+describe('ActionsLendNamespace', () => {
+  let mockProvider: LendProvider
+
+  beforeEach(() => {
+    mockProvider = createMockLendProvider()
+  })
+
+  it('should create an instance with a lend provider', () => {
+    const namespace = new ActionsLendNamespace(mockProvider)
+
+    expect(namespace).toBeInstanceOf(ActionsLendNamespace)
+  })
+
+  it('should delegate getMarkets to provider', async () => {
+    const namespace = new ActionsLendNamespace(mockProvider)
+    const spy = vi.spyOn(mockProvider, 'getMarkets')
+
+    await namespace.getMarkets()
+
+    expect(spy).toHaveBeenCalledOnce()
+  })
+
+  it('should delegate getMarket to provider with correct parameters', async () => {
+    const namespace = new ActionsLendNamespace(mockProvider)
+    const marketId = getRandomAddress()
+    const chainId = 130 as const
+    const spy = vi.spyOn(mockProvider, 'getMarket')
+
+    await namespace.getMarket({ address: marketId, chainId })
+
+    expect(spy).toHaveBeenCalledWith({ address: marketId, chainId })
+  })
+
+  it('should delegate supportedChainIds to provider', () => {
+    const namespace = new ActionsLendNamespace(mockProvider)
+    const spy = vi.spyOn(mockProvider, 'supportedChainIds')
+
+    namespace.supportedChainIds()
+
+    expect(spy).toHaveBeenCalledOnce()
+  })
+
+  it('should provide access to provider config', () => {
+    const namespace = new ActionsLendNamespace(mockProvider)
+
+    const config = namespace.config
+
+    expect(config).toBeDefined()
+    expect(config.defaultSlippage || 50).toBe(50)
+  })
+})

package/src/lend/namespaces/__tests__/WalletLendNamespace.spec.ts

@@ -0,0 +1,223 @@
+import type { WaitForUserOperationReceiptReturnType } from 'viem/account-abstraction'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { WalletLendNamespace } from '@/lend/namespaces/WalletLendNamespace.js'
+import { createMockLendProvider } from '@/test/MockLendProvider.js'
+import { getRandomAddress } from '@/test/utils.js'
+import type { LendProvider, TransactionData } from '@/types/lend/index.js'
+import { createMock as createSmartWalletMock } from '@/wallet/core/wallets/smart/abstract/__mocks__/SmartWallet.js'
+import type { SmartWallet } from '@/wallet/core/wallets/smart/abstract/SmartWallet.js'
+
+describe('WalletLendNamespace', () => {
+  const mockWalletAddress = getRandomAddress()
+  let mockProvider: LendProvider
+  let mockWallet: SmartWallet
+
+  beforeEach(() => {
+    mockProvider = createMockLendProvider()
+    // Create a mock SmartWallet with send and sendBatch methods
+    mockWallet = createSmartWalletMock({
+      address: mockWalletAddress,
+      sendImpl: async () =>
+        ({
+          receipt: { success: true },
+          userOpHash: '0xmockhash',
+        }) as unknown as WaitForUserOperationReceiptReturnType,
+      sendBatchImpl: async () =>
+        ({
+          receipt: { success: true },
+          userOpHash: '0xmockbatchhash',
+        }) as unknown as WaitForUserOperationReceiptReturnType,
+    }) as unknown as SmartWallet
+  })
+
+  it('should create an instance with a lend provider and wallet', () => {
+    const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+
+    expect(namespace).toBeInstanceOf(WalletLendNamespace)
+  })
+
+  it('should inherit read operations from ActionsLendNamespace', async () => {
+    const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+    const mockMarkets = [
+      {
+        marketId: {
+          chainId: 130 as const,
+          address: getRandomAddress(),
+        },
+        name: 'Test Vault',
+        asset: {
+          address: { 130: getRandomAddress() },
+          metadata: { symbol: 'USDC', name: 'USD Coin', decimals: 6 },
+          type: 'erc20' as const,
+        },
+        supply: {
+          totalAssets: BigInt('1000000'),
+          totalShares: BigInt('1000000'),
+        },
+        apy: {
+          total: 0.05,
+          native: 0.04,
+          totalRewards: 0.01,
+          performanceFee: 0.0,
+        },
+        metadata: {
+          owner: getRandomAddress(),
+          curator: getRandomAddress(),
+          fee: 0.1,
+          lastUpdate: Date.now(),
+        },
+      },
+    ]
+
+    vi.mocked(mockProvider.getMarkets).mockResolvedValue(mockMarkets)
+
+    const result = await namespace.getMarkets()
+
+    expect(mockProvider.getMarkets).toHaveBeenCalled()
+    expect(result).toBe(mockMarkets)
+  })
+
+  describe('openPosition', () => {
+    it('should call provider openPosition with wallet address as receiver', async () => {
+      const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+      const mockAsset = {
+        address: { 130: getRandomAddress() },
+        metadata: { symbol: 'USDC', name: 'USD Coin', decimals: 6 },
+        type: 'erc20' as const,
+      }
+      const amount = 1000
+      const marketId = { address: getRandomAddress(), chainId: 130 as const }
+      const mockTransaction = {
+        amount: 1000000000n,
+        asset: mockAsset.address[130],
+        marketId: marketId.address,
+        apy: 0.05,
+        transactionData: {
+          openPosition: {
+            to: marketId.address,
+            value: 0n,
+            data: '0x' as const,
+          },
+        },
+        slippage: 50,
+      }
+
+      vi.mocked(mockProvider.openPosition).mockResolvedValue(mockTransaction)
+
+      const result = await namespace.openPosition({
+        amount,
+        asset: mockAsset,
+        marketId,
+      })
+
+      expect(result).toEqual({
+        receipt: { success: true },
+        userOpHash: '0xmockhash',
+      })
+
+      expect(mockProvider.openPosition).toHaveBeenCalledWith({
+        amount,
+        asset: mockAsset,
+        marketId,
+        walletAddress: mockWalletAddress,
+        options: undefined,
+      })
+    })
+  })
+
+  describe('closePosition', () => {
+    it('should call provider closePosition and execute transaction for SmartWallet', async () => {
+      const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+      const closeParams = {
+        amount: 100,
+        marketId: { address: getRandomAddress(), chainId: 130 as const },
+      }
+
+      const mockTransaction = {
+        amount: 100n,
+        asset: getRandomAddress(),
+        marketId: closeParams.marketId.address,
+        apy: 0.05,
+        transactionData: {
+          closePosition: {
+            to: closeParams.marketId.address,
+            value: 0n,
+            data: '0x' as const,
+          },
+        },
+      }
+
+      vi.mocked(mockProvider.closePosition).mockResolvedValue(mockTransaction)
+
+      const result = await namespace.closePosition(closeParams)
+
+      expect(mockProvider.closePosition).toHaveBeenCalledWith({
+        ...closeParams,
+        walletAddress: mockWallet.address,
+        options: undefined,
+      })
+      expect(mockWallet.send).toHaveBeenCalledWith(
+        mockTransaction.transactionData.closePosition,
+        130,
+      )
+      expect(result).toEqual({
+        receipt: { success: true },
+        userOpHash: '0xmockhash',
+      })
+    })
+  })
+
+  it('should store the wallet reference', () => {
+    const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+
+    expect(namespace['wallet']).toBe(mockWallet)
+    expect(namespace['wallet'].address).toBe(mockWalletAddress)
+  })
+
+  it('should execute transaction with approval when present', async () => {
+    const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+    const mockAsset = {
+      address: { 130: getRandomAddress() },
+      metadata: { symbol: 'USDC', name: 'USD Coin', decimals: 6 },
+      type: 'erc20' as const,
+    }
+    const marketId = { address: getRandomAddress(), chainId: 130 as const }
+    const approval: TransactionData = {
+      to: mockAsset.address[130],
+      value: 0n,
+      data: '0xapproval' as const,
+    }
+    const openPosition: TransactionData = {
+      to: marketId.address,
+      value: 0n,
+      data: '0xdeposit' as const,
+    }
+    const mockTransaction = {
+      amount: 1000000000n,
+      asset: mockAsset.address[130],
+      marketId: marketId.address,
+      apy: 0.05,
+      timestamp: Date.now(),
+      transactionData: { approval, openPosition },
+      slippage: 50,
+    }
+
+    vi.mocked(mockProvider.openPosition).mockResolvedValue(mockTransaction)
+
+    const result = await namespace.openPosition({
+      amount: 1000,
+      asset: mockAsset,
+      marketId,
+    })
+
+    expect(mockWallet.sendBatch).toHaveBeenCalledWith(
+      [approval, openPosition],
+      130,
+    )
+    expect(result).toEqual({
+      receipt: { success: true },
+      userOpHash: '0xmockbatchhash',
+    })
+  })
+})

package/src/lend/providers/morpho/MorphoLendProvider.ts

@@ -0,0 +1,258 @@
+import { ChainId } from '@morpho-org/blue-sdk'
+import { MetaMorphoAction } from '@morpho-org/blue-sdk-viem'
+import { encodeFunctionData, erc20Abi, formatUnits } from 'viem'
+
+import { SUPPORTED_CHAIN_IDS as ACTIONS_SUPPORTED_CHAIN_IDS } from '@/constants/supportedChains.js'
+import { LendProvider } from '@/lend/core/LendProvider.js'
+import { getVault, getVaults } from '@/lend/providers/morpho/sdk.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type {
+  GetLendMarketsParams,
+  GetMarketBalanceParams,
+  LendClosePositionParams,
+  LendMarket,
+  LendMarketId,
+  LendMarketPosition,
+  LendOpenPositionInternalParams,
+  LendTransaction,
+  MorphoLendConfig,
+} from '@/types/lend/index.js'
+import { getAssetAddress } from '@/utils/assets.js'
+
+/**
+ * Supported chain IDs for Morpho lending
+ * @description Array of chain IDs where Morpho is available
+ */
+export const SUPPORTED_CHAIN_IDS = [
+  ...new Set([
+    ...Object.values(ChainId).filter(
+      (value): value is number => typeof value === 'number',
+    ),
+    ...ACTIONS_SUPPORTED_CHAIN_IDS,
+  ]),
+] as readonly number[]
+
+/**
+ * Morpho lending provider implementation
+ * @description Lending provider implementation using Morpho protocol
+ */
+export class MorphoLendProvider extends LendProvider<MorphoLendConfig> {
+  protected readonly SUPPORTED_CHAIN_IDS = SUPPORTED_CHAIN_IDS
+
+  private chainManager: ChainManager
+
+  /**
+   * Create a new Morpho lending provider
+   * @param config - Morpho lending configuration
+   * @param chainManager - Chain manager for blockchain interactions
+   */
+  constructor(config: MorphoLendConfig, chainManager: ChainManager) {
+    super(config)
+    this.chainManager = chainManager
+  }
+
+  /**
+   * Open a lending position in a Morpho market
+   * @description Opens a lending position by supplying assets to a Morpho market
+   * @param params - Position opening parameters
+   * @returns Promise resolving to lending transaction details
+   */
+  protected async _openPosition(
+    params: LendOpenPositionInternalParams,
+  ): Promise<LendTransaction> {
+    try {
+      // Get asset address for the chain
+      const assetAddress = params.asset.address[params.marketId.chainId]
+      if (!assetAddress) {
+        throw new Error(
+          `Asset not supported on chain ${params.marketId.chainId}`,
+        )
+      }
+
+      // Get vault information for APY
+      const vaultInfo = await this.getMarket({
+        address: params.marketId.address,
+        chainId: params.marketId.chainId,
+      })
+
+      const assets = params.amountWei
+      const receiver = params.walletAddress
+      const depositCallData = MetaMorphoAction.deposit(assets, receiver)
+
+      const approvalCallData = encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'approve',
+        args: [params.marketId.address, params.amountWei],
+      })
+
+      return {
+        amount: params.amountWei,
+        asset: assetAddress,
+        marketId: params.marketId.address,
+        apy: vaultInfo.apy.total,
+        transactionData: {
+          approval: {
+            to: assetAddress,
+            data: approvalCallData,
+            value: 0n,
+          },
+          openPosition: {
+            to: params.marketId.address,
+            data: depositCallData,
+            value: 0n,
+          },
+        },
+        slippage: params.options?.slippage || this._config.defaultSlippage,
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to open position with ${params.amountWei} of ${params.asset.metadata.symbol}: ${
+          error instanceof Error ? error.message : 'Unknown error'
+        }`,
+      )
+    }
+  }
+
+  /**
+   * Close a position in a Morpho market
+   * @description Withdraws assets from a Morpho market
+   * @param params - Position closing operation parameters
+   * @returns Promise resolving to withdrawal transaction details
+   */
+  protected async _closePosition(
+    params: LendClosePositionParams,
+  ): Promise<LendTransaction> {
+    try {
+      const vaultInfo = await this.getMarket({
+        address: params.marketId.address,
+        chainId: params.marketId.chainId,
+      })
+
+      // Get asset address for the market's chain
+      const assetAddress = getAssetAddress(
+        vaultInfo.asset,
+        params.marketId.chainId,
+      )
+
+      const assets = params.amount
+      const receiver = params.walletAddress
+      const owner = params.walletAddress
+      const withdrawCallData = MetaMorphoAction.withdraw(
+        assets,
+        receiver,
+        owner,
+      )
+
+      return {
+        amount: params.amount,
+        asset: assetAddress,
+        marketId: params.marketId.address,
+        apy: vaultInfo.apy.total,
+        transactionData: {
+          closePosition: {
+            to: params.marketId.address,
+            data: withdrawCallData,
+            value: 0n,
+          },
+        },
+        slippage: params.options?.slippage || this._config.defaultSlippage,
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to close position: ${
+          error instanceof Error ? error.message : 'Unknown error'
+        }`,
+      )
+    }
+  }
+
+  /**
+   * Get detailed market information
+   * @param marketId - Market identifier containing address and chainId
+   * @returns Promise resolving to market information
+   */
+  protected async _getMarket(marketId: LendMarketId): Promise<LendMarket> {
+    return getVault({
+      marketId,
+      chainManager: this.chainManager,
+      lendConfig: this._config,
+    })
+  }
+
+  /**
+   * Get list of available lending markets
+   * @param params - Filtering parameters
+   * @returns Promise resolving to array of market information
+   */
+  protected async _getMarkets(
+    params: GetLendMarketsParams,
+  ): Promise<LendMarket[]> {
+    // We will eventually fetch markets externally, filtered by Asset and chainId
+    const _unused = { asset: params.asset, chainId: params.chainId }
+
+    const marketConfigs = params.markets || []
+
+    return getVaults({
+      chainManager: this.chainManager,
+      lendConfig: this._config,
+      markets: marketConfigs,
+    })
+  }
+
+  /**
+   * Get position for a specific wallet address
+   * @param params - Parameters for fetching position
+   * @returns Promise resolving to position information
+   */
+  protected async _getPosition(
+    params: GetMarketBalanceParams,
+  ): Promise<LendMarketPosition> {
+    try {
+      const publicClient = this.chainManager.getPublicClient(
+        params.marketId.chainId,
+      )
+
+      // Get user's market token balance (shares in the vault)
+      const shares = await publicClient.readContract({
+        address: params.marketId.address,
+        abi: erc20Abi,
+        functionName: 'balanceOf',
+        args: [params.walletAddress],
+      })
+
+      // Convert shares to underlying asset balance using convertToAssets
+      const balance = await publicClient.readContract({
+        address: params.marketId.address,
+        abi: [
+          {
+            name: 'convertToAssets',
+            type: 'function',
+            stateMutability: 'view',
+            inputs: [{ name: 'shares', type: 'uint256' }],
+            outputs: [{ name: '', type: 'uint256' }],
+          },
+        ],
+        functionName: 'convertToAssets',
+        args: [shares],
+      })
+
+      // Format the balances (USDC has 6 decimals)
+      const balanceFormatted = formatUnits(balance, 6)
+      const sharesFormatted = formatUnits(shares, 18) // Vault shares typically have 18 decimals
+
+      return {
+        balance,
+        balanceFormatted,
+        shares,
+        sharesFormatted,
+        marketId: params.marketId,
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to get market balance for ${params.walletAddress} in market ${params.marketId.address}: ${
+          error instanceof Error ? error.message : 'Unknown error'
+        }`,
+      )
+    }
+  }
+}

package/src/lend/providers/morpho/__mocks__/mockVault.ts

@@ -0,0 +1,28 @@
+import type { Address } from 'viem'
+
+/**
+ * Creates a mock Morpho vault for testing
+ */
+export function createMockMorphoVault() {
+  return {
+    totalAssets: BigInt(10000000e6),
+    totalSupply: BigInt(10000000e6),
+    fee: BigInt(1e17),
+    owner: '0x5a4E19842e09000a582c20A4f524C26Fb48Dd4D0' as Address,
+    curator: '0x9E33faAE38ff641094fa68c65c2cE600b3410585' as Address,
+    allocations: new Map([
+      [
+        '0',
+        {
+          position: {
+            supplyShares: BigInt(1000000e6),
+            supplyAssets: BigInt(1000000e6),
+            market: {
+              supplyApy: BigInt(3e16),
+            },
+          },
+        },
+      ],
+    ]),
+  }
+}