@eth-optimism/actions-sdk 0.0.4 → 0.2.0

package/src/lend/providers/aave/sdk.ts

@@ -0,0 +1,307 @@
+import { UiPoolDataProvider } from '@aave/contract-helpers'
+import { formatReserves } from '@aave/math-utils'
+import { providers } from 'ethers'
+import type { Address } from 'viem'
+import { base, baseSepolia, optimism, optimismSepolia } from 'viem/chains'
+
+import { WETH } from '@/constants/assets.js'
+import type { SUPPORTED_CHAIN_IDS } from '@/constants/supportedChains.js'
+import { POOL_GET_RESERVE_DATA_ABI } from '@/lend/providers/aave/abis/pool.js'
+import { getPoolAddress } from '@/lend/providers/aave/addresses.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { LendProviderConfig } from '@/types/actions.js'
+import type {
+  ApyBreakdown,
+  LendMarket,
+  LendMarketConfig,
+  LendMarketId,
+} from '@/types/lend/index.js'
+import { getAssetAddress } from '@/utils/assets.js'
+
+/**
+ * UI Pool Data Provider addresses for each chain
+ * @description Contract addresses for UiPoolDataProvider on each supported chain
+ */
+const UI_POOL_DATA_PROVIDER_ADDRESSES: Record<number, Address> = {
+  [optimism.id]: '0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654',
+  [base.id]: '0xd82a47fdebB5bf5329b09441C3DaB4b5df2153Ad',
+  [optimismSepolia.id]: '0x86E2938daE289763D4e09a7e42c5cCcA62Cf9809',
+  [baseSepolia.id]: '0xBc9f5b7E248451CdD7cA54e717a2BFe1F32b566b',
+} as const
+
+/**
+ * Pool Addresses Provider addresses for each chain
+ */
+const POOL_ADDRESSES_PROVIDER: Record<number, Address> = {
+  [optimism.id]: '0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb',
+  [base.id]: '0xe20fCBdBfFC4Dd138cE8b2E6FBb6CB49777ad64D',
+  [optimismSepolia.id]: '0x36616cf17557639614c1cdDb356b1B83fc0B2132',
+  [baseSepolia.id]: '0xE4C23309117Aa30342BFaae6c95c6478e0A4Ad00',
+} as const
+
+/**
+ * Parameters for getReserve function
+ */
+interface GetReserveParams {
+  /** Market identifier (asset address and chainId) */
+  marketId: LendMarketId
+  /** Chain manager instance */
+  chainManager: ChainManager
+  /** Lend configuration containing market allowlist */
+  lendConfig?: LendProviderConfig
+}
+
+/**
+ * Parameters for getReserves function
+ */
+interface GetReservesParams {
+  chainManager: ChainManager
+  lendConfig: LendProviderConfig
+  markets: LendMarketConfig[]
+}
+
+/**
+ * Find market configuration in allowlist
+ * @param marketAllowlist - Array of allowed market configurations
+ * @param marketId - Market identifier to find
+ * @returns Market configuration if found, undefined otherwise
+ */
+function findMarketInAllowlist(
+  marketAllowlist: LendMarketConfig[],
+  marketId: LendMarketId,
+): LendMarketConfig | undefined {
+  return marketAllowlist.find(
+    (config) =>
+      config.address.toLowerCase() === marketId.address.toLowerCase() &&
+      config.chainId === marketId.chainId,
+  )
+}
+
+/**
+ * Calculate APY breakdown from reserve data
+ * @param reserve - Formatted reserve data from Aave
+ * @returns APY breakdown with native APY and rewards
+ */
+export function calculateApyBreakdown(reserve: {
+  formattedReserve?: any
+}): ApyBreakdown {
+  // Get supply APY from formatted reserve data
+  const supplyApy = reserve.formattedReserve?.supplyAPY
+    ? parseFloat(reserve.formattedReserve.supplyAPY)
+    : 0
+
+  // Aave doesn't have vault-style performance fees
+  // Total APY = Supply APY + any rewards (to be added later)
+  return {
+    total: supplyApy,
+    native: supplyApy,
+    totalRewards: 0, // TODO: Fetch from incentives data provider if needed
+    performanceFee: 0, // Aave doesn't have performance fees
+  }
+}
+
+/**
+ * Get detailed reserve (market) information from Aave
+ * @param params - Named parameters object
+ * @returns Promise resolving to detailed market information
+ */
+export async function getReserve(
+  params: GetReserveParams,
+): Promise<LendMarket> {
+  // Find market configuration in allowlist for metadata
+  const marketConfig = params.lendConfig?.marketAllowlist
+    ? findMarketInAllowlist(params.lendConfig.marketAllowlist, params.marketId)
+    : undefined
+
+  if (!marketConfig) {
+    throw new Error(
+      `Market ${params.marketId.address} on chain ${params.marketId.chainId} not found in allowlist`,
+    )
+  }
+
+  const poolAddress = getPoolAddress(params.marketId.chainId)
+  if (!poolAddress) {
+    throw new Error(`Aave V3 not deployed on chain ${params.marketId.chainId}`)
+  }
+
+  const uiPoolDataProviderAddress =
+    UI_POOL_DATA_PROVIDER_ADDRESSES[params.marketId.chainId]
+  const poolAddressesProvider = POOL_ADDRESSES_PROVIDER[params.marketId.chainId]
+
+  if (!uiPoolDataProviderAddress || !poolAddressesProvider) {
+    throw new Error(
+      `UiPoolDataProvider not configured for chain ${params.marketId.chainId}`,
+    )
+  }
+
+  try {
+    // Get viem public client for this chain
+    const publicClient = params.chainManager.getPublicClient(
+      params.marketId.chainId,
+    )
+
+    // Create ethers provider from viem's RPC URL
+    // Aave SDK requires ethers provider, not viem
+    const rpcUrl =
+      publicClient.chain?.rpcUrls.default.http[0] ||
+      publicClient.chain?.rpcUrls.public?.http[0]
+    if (!rpcUrl) {
+      throw new Error(
+        `No RPC URL available for chain ${params.marketId.chainId}`,
+      )
+    }
+    const ethersProvider = new providers.JsonRpcProvider(rpcUrl)
+
+    // Create UiPoolDataProvider instance
+    const uiPoolDataProvider = new UiPoolDataProvider({
+      uiPoolDataProviderAddress,
+      provider: ethersProvider,
+      chainId: params.marketId.chainId,
+    })
+
+    // Fetch reserve data
+    const reservesData = await uiPoolDataProvider.getReservesHumanized({
+      lendingPoolAddressProvider: poolAddressesProvider,
+    })
+
+    // Find the specific reserve for this asset
+    // For native ETH assets, use WETH address since Aave uses WETH internally
+    const assetAddress =
+      marketConfig.asset.type === 'native'
+        ? getAssetAddress(WETH, params.marketId.chainId)
+        : getAssetAddress(marketConfig.asset, params.marketId.chainId)
+
+    const reserve = reservesData.reservesData.find(
+      (r) => r.underlyingAsset.toLowerCase() === assetAddress.toLowerCase(),
+    )
+
+    if (!reserve) {
+      throw new Error(
+        `Reserve not found for asset ${assetAddress} on chain ${params.marketId.chainId}`,
+      )
+    }
+
+    // Format reserves using Aave math-utils
+    const currentTimestamp = Math.floor(Date.now() / 1000)
+    const formattedReserves = formatReserves({
+      reserves: [reserve],
+      currentTimestamp,
+      marketReferenceCurrencyDecimals:
+        reservesData.baseCurrencyData.marketReferenceCurrencyDecimals,
+      marketReferencePriceInUsd:
+        reservesData.baseCurrencyData.marketReferenceCurrencyPriceInUsd,
+    })
+
+    const formattedReserve = formattedReserves[0]
+
+    // Calculate APY breakdown
+    const apy = calculateApyBreakdown({
+      ...reserve,
+      formattedReserve,
+    })
+
+    // Return market information in our standard format
+    return {
+      marketId: params.marketId,
+      name: marketConfig.name,
+      asset: marketConfig.asset,
+      supply: {
+        totalAssets: BigInt(reserve.availableLiquidity),
+        totalShares: BigInt(reserve.totalScaledVariableDebt || '0'),
+      },
+      apy,
+      metadata: {
+        owner: poolAddress, // Use Pool as owner
+        curator: poolAddress, // No curator in Aave
+        fee: 0, // No performance fee in Aave
+        lastUpdate: currentTimestamp,
+      },
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to get reserve info for ${params.marketId.address}: ${
+        error instanceof Error ? error.message : 'Unknown error'
+      }`,
+    )
+  }
+}
+
+/**
+ * Get multiple reserves (markets)
+ * @param params - Parameters including markets to fetch
+ * @returns Promise resolving to array of market information
+ */
+export async function getReserves(
+  params: GetReservesParams,
+): Promise<LendMarket[]> {
+  try {
+    const reservePromises = params.markets.map((marketConfig) => {
+      return getReserve({
+        marketId: {
+          address: marketConfig.address,
+          chainId: marketConfig.chainId,
+        },
+        chainManager: params.chainManager,
+        lendConfig: params.lendConfig,
+      })
+    })
+
+    return await Promise.all(reservePromises)
+  } catch (error) {
+    throw new Error(
+      `Failed to get reserves: ${
+        error instanceof Error ? error.message : 'Unknown error'
+      }`,
+    )
+  }
+}
+
+/**
+ * Get aToken address for a given underlying asset
+ * @param params - Parameters including asset address, chain ID, and chain manager
+ * @returns Promise resolving to aToken address
+ * @description Queries the Aave Pool to get the aToken address for the underlying asset
+ */
+export async function getATokenAddress(params: {
+  underlyingAsset: Address
+  chainId: (typeof SUPPORTED_CHAIN_IDS)[number]
+  chainManager: ChainManager
+}): Promise<Address> {
+  const poolAddress = getPoolAddress(params.chainId)
+  if (!poolAddress) {
+    throw new Error(`Aave V3 not deployed on chain ${params.chainId}`)
+  }
+
+  try {
+    // Get viem public client for this chain
+    const publicClient = params.chainManager.getPublicClient(params.chainId)
+
+    // Query the Pool contract directly for reserve data
+    const reserveData = await publicClient.readContract({
+      address: poolAddress,
+      abi: POOL_GET_RESERVE_DATA_ABI,
+      functionName: 'getReserveData',
+      args: [params.underlyingAsset],
+    })
+
+    // The return is a tuple where index 8 is aTokenAddress
+    const aTokenAddress = reserveData[8]
+
+    if (
+      !aTokenAddress ||
+      aTokenAddress === '0x0000000000000000000000000000000000000000'
+    ) {
+      throw new Error(
+        `No aToken found for asset ${params.underlyingAsset} on chain ${params.chainId}`,
+      )
+    }
+
+    return aTokenAddress
+  } catch (error) {
+    throw new Error(
+      `Failed to get aToken address for ${params.underlyingAsset}: ${
+        error instanceof Error ? error.message : 'Unknown error'
+      }`,
+    )
+  }
+}

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

@@ -1,11 +1,12 @@
 import { ChainId } from '@morpho-org/blue-sdk'
 import { MetaMorphoAction } from '@morpho-org/blue-sdk-viem'
-import { encodeFunctionData, erc20Abi, formatUnits } from 'viem'
+import { 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 { LendProviderConfig } from '@/types/actions.js'
 import type {
   GetLendMarketsParams,
   GetMarketBalanceParams,
@@ -15,7 +16,6 @@ import type {
   LendMarketPosition,
   LendOpenPositionInternalParams,
   LendTransaction,
-  MorphoLendConfig,
 } from '@/types/lend/index.js'
 import { getAssetAddress } from '@/utils/assets.js'
 
@@ -36,19 +36,16 @@ export const SUPPORTED_CHAIN_IDS = [
  * Morpho lending provider implementation
  * @description Lending provider implementation using Morpho protocol
  */
-export class MorphoLendProvider extends LendProvider<MorphoLendConfig> {
+export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
   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
+  constructor(config: LendProviderConfig, chainManager: ChainManager) {
+    super(config, chainManager)
   }
 
   /**
@@ -61,13 +58,11 @@ export class MorphoLendProvider extends LendProvider<MorphoLendConfig> {
     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 asset address for the chain (throws for native assets)
+      const assetAddress = getAssetAddress(
+        params.asset,
+        params.marketId.chainId,
+      )
 
       // Get vault information for APY
       const vaultInfo = await this.getMarket({
@@ -79,36 +74,27 @@ export class MorphoLendProvider extends LendProvider<MorphoLendConfig> {
       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: {
+          approval: this.buildApprovalTx(
+            assetAddress,
+            params.marketId.address,
+            params.amountWei,
+          ),
+          position: {
             to: params.marketId.address,
             data: depositCallData,
             value: 0n,
           },
         },
-        slippage: params.options?.slippage || this._config.defaultSlippage,
       }
-    } catch (error) {
+    } catch {
       throw new Error(
-        `Failed to open position with ${params.amountWei} of ${params.asset.metadata.symbol}: ${
-          error instanceof Error ? error.message : 'Unknown error'
-        }`,
+        `Failed to open position with ${params.amountWei} of ${params.asset.metadata.symbol}`,
       )
     }
   }
@@ -149,20 +135,15 @@ export class MorphoLendProvider extends LendProvider<MorphoLendConfig> {
         marketId: params.marketId.address,
         apy: vaultInfo.apy.total,
         transactionData: {
-          closePosition: {
+          position: {
             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'
-        }`,
-      )
+    } catch {
+      throw new Error('Failed to close position')
     }
   }
 
@@ -247,11 +228,9 @@ export class MorphoLendProvider extends LendProvider<MorphoLendConfig> {
         sharesFormatted,
         marketId: params.marketId,
       }
-    } catch (error) {
+    } catch {
       throw new Error(
-        `Failed to get market balance for ${params.walletAddress} in market ${params.marketId.address}: ${
-          error instanceof Error ? error.message : 'Unknown error'
-        }`,
+        `Failed to get market balance for ${params.walletAddress} in market ${params.marketId.address}`,
       )
     }
   }

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

@@ -1,16 +1,16 @@
 import { fetchAccrualVault } from '@morpho-org/blue-sdk-viem'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { createMockMorphoVault } from '@/lend/providers/morpho/__mocks__/mockVault.js'
-import { MorphoLendProvider } from '@/lend/providers/morpho/MorphoLendProvider.js'
-import type { ChainManager } from '@/services/ChainManager.js'
-import { MockChainManager } from '@/test/MockChainManager.js'
 import {
   MockGauntletUSDCMarket,
   MockReceiverAddress,
   MockWETHMarket,
-} from '@/test/MockMarkets.js'
-import type { MorphoLendConfig } from '@/types/lend/index.js'
+} from '@/lend/__mocks__/MockMarkets.js'
+import { createMockMorphoVault } from '@/lend/providers/morpho/__mocks__/mockVault.js'
+import { MorphoLendProvider } from '@/lend/providers/morpho/MorphoLendProvider.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { LendProviderConfig } from '@/types/actions.js'
 
 // Mock the Morpho SDK modules
 vi.mock('@morpho-org/blue-sdk-viem', () => ({
@@ -36,13 +36,11 @@ vi.mock('@morpho-org/bundler-sdk-viem', () => ({
 
 describe('MorphoLendProvider', () => {
   let provider: MorphoLendProvider
-  let mockConfig: MorphoLendConfig
+  let mockConfig: LendProviderConfig
   let mockChainManager: ChainManager
 
   beforeEach(() => {
     mockConfig = {
-      provider: 'morpho',
-      defaultSlippage: 50,
       marketAllowlist: [MockGauntletUSDCMarket, MockWETHMarket],
     }
 
@@ -55,18 +53,6 @@ describe('MorphoLendProvider', () => {
     it('should initialize with provided config', () => {
       expect(provider).toBeInstanceOf(MorphoLendProvider)
     })
-
-    it('should use default slippage when not provided', () => {
-      const configWithoutSlippage = {
-        ...mockConfig,
-        defaultSlippage: undefined,
-      }
-      const providerWithDefaults = new MorphoLendProvider(
-        configWithoutSlippage,
-        mockChainManager,
-      )
-      expect(providerWithDefaults).toBeInstanceOf(MorphoLendProvider)
-    })
   })
 
   describe('closePosition', () => {
@@ -121,9 +107,7 @@ describe('MorphoLendProvider', () => {
       expect(withdrawTransaction).toHaveProperty('marketId', marketId.address)
       expect(withdrawTransaction).toHaveProperty('apy')
       expect(withdrawTransaction).toHaveProperty('transactionData')
-      expect(withdrawTransaction.transactionData).toHaveProperty(
-        'closePosition',
-      )
+      expect(withdrawTransaction.transactionData).toHaveProperty('position')
       expect(withdrawTransaction.transactionData).not.toHaveProperty('approval')
       expect(typeof withdrawTransaction.apy).toBe('number')
       expect(withdrawTransaction.apy).toBeGreaterThan(0)
@@ -223,7 +207,7 @@ describe('MorphoLendProvider', () => {
       expect(lendTransaction).toHaveProperty('apy')
       expect(lendTransaction).toHaveProperty('transactionData')
       expect(lendTransaction.transactionData).toHaveProperty('approval')
-      expect(lendTransaction.transactionData).toHaveProperty('openPosition')
+      expect(lendTransaction.transactionData).toHaveProperty('position')
       expect(typeof lendTransaction.apy).toBe('number')
       expect(lendTransaction.apy).toBeGreaterThan(0)
     })
@@ -247,38 +231,13 @@ describe('MorphoLendProvider', () => {
           marketId,
           walletAddress: MockReceiverAddress,
         }),
-      ).rejects.toThrow('Market fetch failed')
-    })
-
-    it('should use custom slippage when provided', async () => {
-      const amount = 1000
-      const asset = MockGauntletUSDCMarket.asset
-      const marketId = {
-        address: MockGauntletUSDCMarket.address,
-        chainId: MockGauntletUSDCMarket.chainId,
-      }
-      const customSlippage = 100 // 1%
-
-      const lendTransaction = await provider.openPosition({
-        amount,
-        asset,
-        marketId,
-        walletAddress: MockReceiverAddress,
-        options: {
-          slippage: customSlippage,
-        },
-      })
-
-      expect(lendTransaction).toHaveProperty('amount', BigInt('1000000000'))
+      ).rejects.toThrow('Failed to open position')
     })
   })
 
   describe('market allowlist configuration', () => {
     it('should work without market allowlist', () => {
-      const configWithoutAllowlist: MorphoLendConfig = {
-        provider: 'morpho',
-        defaultSlippage: 50,
-      }
+      const configWithoutAllowlist: LendProviderConfig = {}
 
       const providerWithoutAllowlist = new MorphoLendProvider(
         configWithoutAllowlist,
@@ -289,9 +248,7 @@ describe('MorphoLendProvider', () => {
     })
 
     it('should store market allowlist when provided', () => {
-      const configWithAllowlist: MorphoLendConfig = {
-        provider: 'morpho',
-        defaultSlippage: 50,
+      const configWithAllowlist: LendProviderConfig = {
         marketAllowlist: [MockGauntletUSDCMarket],
       }
 
@@ -307,37 +264,8 @@ describe('MorphoLendProvider', () => {
       expect(allowlist![0].name).toBe(MockGauntletUSDCMarket.name)
     })
 
-    it('should use default slippage from config', () => {
-      const customSlippage = 150
-      const configWithSlippage: MorphoLendConfig = {
-        provider: 'morpho',
-        defaultSlippage: customSlippage,
-      }
-
-      const providerWithSlippage = new MorphoLendProvider(
-        configWithSlippage,
-        mockChainManager,
-      )
-
-      expect(providerWithSlippage.config.defaultSlippage).toBe(customSlippage)
-    })
-
-    it('should use fallback default slippage when not provided', () => {
-      const configWithoutSlippage: MorphoLendConfig = {
-        provider: 'morpho',
-      }
-
-      const providerWithoutSlippage = new MorphoLendProvider(
-        configWithoutSlippage,
-        mockChainManager,
-      )
-
-      expect(providerWithoutSlippage.config.defaultSlippage || 50).toBe(50) // Default fallback
-    })
-
     it('should handle multiple markets in allowlist', () => {
-      const configWithMultipleMarkets: MorphoLendConfig = {
-        provider: 'morpho',
+      const configWithMultipleMarkets: LendProviderConfig = {
         marketAllowlist: [MockGauntletUSDCMarket, MockWETHMarket],
       }