@eth-optimism/actions-sdk 0.0.3 → 0.1.0

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

@@ -12,9 +12,29 @@ describe('WalletLendNamespace', () => {
   const mockWalletAddress = getRandomAddress()
   let mockProvider: LendProvider
   let mockWallet: SmartWallet
+  let mockMarketId: { address: any; chainId: 130 }
 
   beforeEach(() => {
-    mockProvider = createMockLendProvider()
+    // Create a consistent market ID for all tests
+    mockMarketId = { address: getRandomAddress(), chainId: 130 as const }
+
+    // Create mock provider with the market in its allowlist
+    mockProvider = createMockLendProvider({
+      marketAllowlist: [
+        {
+          address: mockMarketId.address,
+          chainId: mockMarketId.chainId,
+          name: 'Test Market',
+          asset: {
+            address: { 130: getRandomAddress() },
+            metadata: { symbol: 'USDC', name: 'USD Coin', decimals: 6 },
+            type: 'erc20' as const,
+          },
+          lendProvider: 'morpho',
+        },
+      ],
+    })
+
     // Create a mock SmartWallet with send and sendBatch methods
     mockWallet = createSmartWalletMock({
       address: mockWalletAddress,
@@ -32,13 +52,19 @@ describe('WalletLendNamespace', () => {
   })
 
   it('should create an instance with a lend provider and wallet', () => {
-    const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+    const namespace = new WalletLendNamespace(
+      { morpho: mockProvider as any },
+      mockWallet,
+    )
 
     expect(namespace).toBeInstanceOf(WalletLendNamespace)
   })
 
   it('should inherit read operations from ActionsLendNamespace', async () => {
-    const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+    const namespace = new WalletLendNamespace(
+      { morpho: mockProvider as any },
+      mockWallet,
+    )
     const mockMarkets = [
       {
         marketId: {
@@ -75,19 +101,22 @@ describe('WalletLendNamespace', () => {
     const result = await namespace.getMarkets()
 
     expect(mockProvider.getMarkets).toHaveBeenCalled()
-    expect(result).toBe(mockMarkets)
+    expect(result).toStrictEqual(mockMarkets)
   })
 
   describe('openPosition', () => {
     it('should call provider openPosition with wallet address as receiver', async () => {
-      const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+      const namespace = new WalletLendNamespace(
+        { morpho: mockProvider as any },
+        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 marketId = mockMarketId
       const mockTransaction = {
         amount: 1000000000n,
         asset: mockAsset.address[130],
@@ -128,10 +157,13 @@ describe('WalletLendNamespace', () => {
 
   describe('closePosition', () => {
     it('should call provider closePosition and execute transaction for SmartWallet', async () => {
-      const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+      const namespace = new WalletLendNamespace(
+        { morpho: mockProvider as any },
+        mockWallet,
+      )
       const closeParams = {
         amount: 100,
-        marketId: { address: getRandomAddress(), chainId: 130 as const },
+        marketId: mockMarketId,
       }
 
       const mockTransaction = {
@@ -169,20 +201,26 @@ describe('WalletLendNamespace', () => {
   })
 
   it('should store the wallet reference', () => {
-    const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+    const namespace = new WalletLendNamespace(
+      { morpho: mockProvider as any },
+      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 namespace = new WalletLendNamespace(
+      { morpho: mockProvider as any },
+      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 marketId = mockMarketId
     const approval: TransactionData = {
       to: mockAsset.address[130],
       value: 0n,

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

@@ -0,0 +1,463 @@
+import type { Address } from 'viem'
+import { encodeFunctionData, erc20Abi, formatUnits, parseAbi } from 'viem'
+
+import { LendProvider } from '@/lend/core/LendProvider.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { LendProviderConfig } from '@/types/actions.js'
+import type {
+  GetLendMarketsParams,
+  GetMarketBalanceParams,
+  LendClosePositionParams,
+  LendMarket,
+  LendMarketId,
+  LendMarketPosition,
+  LendOpenPositionInternalParams,
+  LendTransaction,
+} from '@/types/lend/index.js'
+import { getAssetAddress } from '@/utils/assets.js'
+
+import {
+  getPoolAddress,
+  getSupportedChainIds,
+  getWETHGatewayAddress,
+} from './addresses.js'
+import { getReserve, getReserves } from './sdk.js'
+
+/**
+ * WETH predeploy address on OP Stack chains
+ * @description WETH is deployed at the same address on all OP Stack chains (Optimism, Base, etc.)
+ */
+const WETH_ADDRESS = '0x4200000000000000000000000000000000000006'
+
+/**
+ * Aave Pool ABI - only the functions we need
+ */
+const POOL_ABI = parseAbi([
+  'function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode)',
+  'function withdraw(address asset, uint256 amount, address to) returns (uint256)',
+])
+
+/**
+ * Aave WETHGateway ABI - for native ETH deposits/withdrawals
+ */
+const WETH_GATEWAY_ABI = parseAbi([
+  'function depositETH(address pool, address onBehalfOf, uint16 referralCode) payable',
+  'function withdrawETH(address pool, uint256 amount, address to)',
+])
+
+/**
+ * Supported chain IDs for Aave lending
+ * @description Array of chain IDs where Aave V3 is available on Optimism Superchain
+ */
+export const SUPPORTED_CHAIN_IDS = getSupportedChainIds() as readonly number[]
+
+/**
+ * Aave lending provider implementation
+ * @description Lending provider implementation using Aave V3 protocol
+ */
+export class AaveLendProvider extends LendProvider<LendProviderConfig> {
+  protected readonly SUPPORTED_CHAIN_IDS = SUPPORTED_CHAIN_IDS
+
+  private chainManager: ChainManager
+
+  /**
+   * Create a new Aave lending provider
+   * @param config - Aave lending configuration
+   * @param chainManager - Chain manager for blockchain interactions
+   */
+  constructor(config: LendProviderConfig, chainManager: ChainManager) {
+    super(config)
+    this.chainManager = chainManager
+  }
+
+  /**
+   * Check if market is a WETH market
+   * @param marketId - Market identifier
+   * @returns true if market is for WETH
+   * @description WETH is a predeploy at the same address on all OP Stack chains
+   */
+  private isWETHMarket(marketId: LendMarketId): boolean {
+    return marketId.address.toLowerCase() === WETH_ADDRESS.toLowerCase()
+  }
+
+  /**
+   * Open a lending position in an Aave market
+   * @description Opens a lending position by supplying assets to an Aave reserve
+   * @param params - Position opening parameters
+   * @returns Promise resolving to lending transaction details
+   */
+  protected async _openPosition(
+    params: LendOpenPositionInternalParams,
+  ): Promise<LendTransaction> {
+    try {
+      // Get Pool address for this chain
+      const poolAddress = getPoolAddress(params.marketId.chainId)
+      if (!poolAddress) {
+        throw new Error(
+          `Aave V3 not deployed on chain ${params.marketId.chainId}`,
+        )
+      }
+
+      // Get market information for APY
+      const marketInfo = await this.getMarket({
+        address: params.marketId.address,
+        chainId: params.marketId.chainId,
+      })
+
+      // Check if this is a WETH market
+      if (this.isWETHMarket(params.marketId)) {
+        return this._openWETHPosition(params, poolAddress, marketInfo)
+      }
+
+      // Standard ERC-20 flow
+      return this._openERC20Position(params, poolAddress, marketInfo)
+    } catch (error) {
+      throw new Error(
+        `Failed to open position with ${params.amountWei} of ${params.asset.metadata.symbol}: ${
+          error instanceof Error ? error.message : 'Unknown error'
+        }`,
+      )
+    }
+  }
+
+  /**
+   * Open position for WETH market using WETHGateway
+   * @description Deposits native ETH via WETHGateway which wraps and deposits in one tx
+   */
+  private async _openWETHPosition(
+    params: LendOpenPositionInternalParams,
+    poolAddress: Address,
+    marketInfo: LendMarket,
+  ): Promise<LendTransaction> {
+    const gatewayAddress = getWETHGatewayAddress(params.marketId.chainId)
+    if (!gatewayAddress) {
+      throw new Error(
+        `WETHGateway not available on chain ${params.marketId.chainId}`,
+      )
+    }
+
+    // Generate depositETH transaction
+    const depositCallData = encodeFunctionData({
+      abi: WETH_GATEWAY_ABI,
+      functionName: 'depositETH',
+      args: [
+        poolAddress, // pool address
+        params.walletAddress, // onBehalfOf (receives aWETH)
+        0, // referralCode (0 = no referral)
+      ],
+    })
+
+    return {
+      amount: params.amountWei,
+      asset: WETH_ADDRESS,
+      marketId: params.marketId.address,
+      apy: marketInfo.apy.total,
+      transactionData: {
+        openPosition: {
+          to: gatewayAddress,
+          data: depositCallData,
+          value: params.amountWei, // Send ETH as msg.value
+        },
+      },
+      slippage: params.options?.slippage ?? 50,
+    }
+  }
+
+  /**
+   * Open position for standard ERC-20 tokens
+   * @description Standard approve + supply flow for non-WETH assets
+   */
+  private async _openERC20Position(
+    params: LendOpenPositionInternalParams,
+    poolAddress: Address,
+    marketInfo: LendMarket,
+  ): Promise<LendTransaction> {
+    // 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}`)
+    }
+
+    // Generate approval transaction
+    const approvalCallData = encodeFunctionData({
+      abi: erc20Abi,
+      functionName: 'approve',
+      args: [poolAddress, params.amountWei],
+    })
+
+    // Generate supply transaction
+    const supplyCallData = encodeFunctionData({
+      abi: POOL_ABI,
+      functionName: 'supply',
+      args: [
+        assetAddress, // asset
+        params.amountWei, // amount
+        params.walletAddress, // onBehalfOf
+        0, // referralCode
+      ],
+    })
+
+    return {
+      amount: params.amountWei,
+      asset: assetAddress,
+      marketId: params.marketId.address,
+      apy: marketInfo.apy.total,
+      transactionData: {
+        approval: {
+          to: assetAddress,
+          data: approvalCallData,
+          value: 0n,
+        },
+        openPosition: {
+          to: poolAddress,
+          data: supplyCallData,
+          value: 0n,
+        },
+      },
+      slippage: params.options?.slippage ?? 50,
+    }
+  }
+
+  /**
+   * Close a position in an Aave market
+   * @description Withdraws assets from an Aave reserve
+   * @param params - Position closing operation parameters
+   * @returns Promise resolving to withdrawal transaction details
+   */
+  protected async _closePosition(
+    params: LendClosePositionParams,
+  ): Promise<LendTransaction> {
+    try {
+      // Get Pool address for this chain
+      const poolAddress = getPoolAddress(params.marketId.chainId)
+      if (!poolAddress) {
+        throw new Error(
+          `Aave V3 not deployed on chain ${params.marketId.chainId}`,
+        )
+      }
+
+      const marketInfo = await this.getMarket({
+        address: params.marketId.address,
+        chainId: params.marketId.chainId,
+      })
+
+      // Check if this is a WETH market
+      if (this.isWETHMarket(params.marketId)) {
+        return this._closeWETHPosition(params, poolAddress, marketInfo)
+      }
+
+      // Standard ERC-20 flow
+      return this._closeERC20Position(params, poolAddress, marketInfo)
+    } catch (error) {
+      throw new Error(
+        `Failed to close position: ${
+          error instanceof Error ? error.message : 'Unknown error'
+        }`,
+      )
+    }
+  }
+
+  /**
+   * Close position for WETH market using WETHGateway
+   * @description Withdraws aWETH, unwraps to ETH, and sends to user
+   */
+  private async _closeWETHPosition(
+    params: LendClosePositionParams,
+    poolAddress: Address,
+    marketInfo: LendMarket,
+  ): Promise<LendTransaction> {
+    const gatewayAddress = getWETHGatewayAddress(params.marketId.chainId)
+    if (!gatewayAddress) {
+      throw new Error(
+        `WETHGateway not available on chain ${params.marketId.chainId}`,
+      )
+    }
+
+    // Get the aToken address for the underlying WETH asset
+    // Note: params.marketId.address is the underlying WETH address, not the aToken
+    const { getATokenAddress } = await import('./sdk.js')
+    const aWETHAddress = await getATokenAddress({
+      underlyingAsset: params.marketId.address,
+      chainId: params.marketId.chainId,
+      chainManager: this.chainManager,
+    })
+
+    // First: User must approve aWETH to WETHGateway
+    const approvalCallData = encodeFunctionData({
+      abi: erc20Abi,
+      functionName: 'approve',
+      args: [gatewayAddress, params.amount],
+    })
+
+    // Second: Call withdrawETH on gateway
+    const withdrawCallData = encodeFunctionData({
+      abi: WETH_GATEWAY_ABI,
+      functionName: 'withdrawETH',
+      args: [
+        poolAddress, // pool
+        params.amount, // amount
+        params.walletAddress, // to (receives native ETH)
+      ],
+    })
+
+    return {
+      amount: params.amount,
+      asset: WETH_ADDRESS,
+      marketId: params.marketId.address,
+      apy: marketInfo.apy.total,
+      transactionData: {
+        approval: {
+          to: aWETHAddress,
+          data: approvalCallData,
+          value: 0n,
+        },
+        closePosition: {
+          to: gatewayAddress,
+          data: withdrawCallData,
+          value: 0n,
+        },
+      },
+      slippage: params.options?.slippage ?? 50,
+    }
+  }
+
+  /**
+   * Close position for standard ERC-20 tokens
+   */
+  private async _closeERC20Position(
+    params: LendClosePositionParams,
+    poolAddress: Address,
+    marketInfo: LendMarket,
+  ): Promise<LendTransaction> {
+    // Get asset address for the market's chain
+    const assetAddress = getAssetAddress(
+      marketInfo.asset,
+      params.marketId.chainId,
+    )
+
+    // Generate withdraw transaction
+    const withdrawCallData = encodeFunctionData({
+      abi: POOL_ABI,
+      functionName: 'withdraw',
+      args: [
+        assetAddress, // asset
+        params.amount, // amount
+        params.walletAddress, // to
+      ],
+    })
+
+    return {
+      amount: params.amount,
+      asset: assetAddress,
+      marketId: params.marketId.address,
+      apy: marketInfo.apy.total,
+      transactionData: {
+        closePosition: {
+          to: poolAddress,
+          data: withdrawCallData,
+          value: 0n,
+        },
+      },
+      slippage: params.options?.slippage ?? 50,
+    }
+  }
+
+  /**
+   * 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 getReserve({
+      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[]> {
+    const marketConfigs = params.markets || []
+
+    return getReserves({
+      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,
+      )
+      const market = await this._getMarket(params.marketId)
+      const poolAddress = getPoolAddress(params.marketId.chainId)
+
+      if (!poolAddress) {
+        throw new Error(
+          `Aave V3 not deployed on chain ${params.marketId.chainId}`,
+        )
+      }
+
+      // Get the aToken address from Pool.getReserveData
+      const assetAddress = getAssetAddress(
+        market.asset,
+        params.marketId.chainId,
+      )
+
+      const reserveData = (await publicClient.readContract({
+        address: poolAddress,
+        abi: parseAbi([
+          'struct ReserveData { uint256 configuration; uint128 liquidityIndex; uint128 currentLiquidityRate; uint128 variableBorrowIndex; uint128 currentVariableBorrowRate; uint128 currentStableBorrowRate; uint40 lastUpdateTimestamp; uint16 id; address aTokenAddress; address stableDebtTokenAddress; address variableDebtTokenAddress; address interestRateStrategyAddress; uint128 accruedToTreasury; uint128 unbacked; uint128 isolationModeTotalDebt; }',
+          'function getReserveData(address asset) view returns (ReserveData)',
+        ]),
+        functionName: 'getReserveData',
+        args: [assetAddress],
+      })) as {
+        aTokenAddress: Address
+      }
+
+      const aTokenAddress = reserveData.aTokenAddress
+
+      const balance = await publicClient.readContract({
+        address: aTokenAddress,
+        abi: erc20Abi,
+        functionName: 'balanceOf',
+        args: [params.walletAddress],
+      })
+
+      const balanceFormatted = formatUnits(
+        balance,
+        market.asset.metadata.decimals,
+      )
+
+      return {
+        balance,
+        balanceFormatted,
+        shares: balance, // In Aave, aTokens are 1:1 with underlying
+        sharesFormatted: balanceFormatted,
+        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/aave/addresses.ts

@@ -0,0 +1,95 @@
+import type { Address } from 'viem'
+import { base, baseSepolia, optimism, optimismSepolia } from 'viem/chains'
+
+/**
+ * Aave V3 Pool addresses for Optimism Superchain networks
+ * @description Hardcoded Pool contract addresses for each supported chain
+ */
+
+/**
+ * Mainnet Pool addresses
+ */
+export const POOL_ADDRESSES_MAINNET: Record<number, Address> = {
+  [optimism.id]: '0x794a61358D6845594F94dc1DB02A252b5b4814aD',
+  [base.id]: '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5',
+} as const
+
+/**
+ * Testnet Pool addresses
+ */
+export const POOL_ADDRESSES_TESTNET: Record<number, Address> = {
+  [optimismSepolia.id]: '0xb50201558b00496a145fe76f7424749556e326d8',
+  [baseSepolia.id]: '0x8bAB6d1b75f19e9eD9fCe8b9BD338844fF79aE27',
+} as const
+
+/**
+ * All Pool addresses (mainnet + testnet)
+ */
+export const POOL_ADDRESSES: Record<number, Address> = {
+  ...POOL_ADDRESSES_MAINNET,
+  ...POOL_ADDRESSES_TESTNET,
+} as const
+
+/**
+ * Get Pool address for a given chain ID
+ * @param chainId - Chain ID
+ * @returns Pool address if supported, undefined otherwise
+ */
+export function getPoolAddress(chainId: number): Address | undefined {
+  return POOL_ADDRESSES[chainId]
+}
+
+/**
+ * Check if a chain ID has Aave V3 deployed
+ * @param chainId - Chain ID to check
+ * @returns true if Aave V3 is deployed on this chain
+ */
+export function isAaveChainSupported(chainId: number): boolean {
+  return chainId in POOL_ADDRESSES
+}
+
+/**
+ * Get all supported chain IDs
+ * @returns Array of chain IDs with Aave V3 deployed
+ */
+export function getSupportedChainIds(): number[] {
+  return Object.keys(POOL_ADDRESSES).map(Number)
+}
+
+/**
+ * Aave V3 WETHGateway addresses for Optimism Superchain networks
+ * @description Gateway contracts that handle native ETH wrapping and depositing
+ */
+
+/**
+ * Mainnet WETHGateway addresses
+ */
+export const WETH_GATEWAY_ADDRESSES_MAINNET: Record<number, Address> = {
+  [optimism.id]: '0x5f2508cAE9923b02316254026CD43d7902866725',
+  [base.id]: '0xa0d9C1E9E48Ca30c8d8C3B5D69FF5dc1f6DFfC24',
+} as const
+
+/**
+ * Testnet WETHGateway addresses
+ */
+export const WETH_GATEWAY_ADDRESSES_TESTNET: Record<number, Address> = {
+  [optimismSepolia.id]: '0x589750BA8aF186cE5B55391B0b7148cAD43a1619',
+  [baseSepolia.id]: '0x0568130e794429D2eEBC4dafE18f25Ff1a1ed8b6',
+} as const
+
+/**
+ * All WETHGateway addresses (mainnet + testnet)
+ */
+export const WETH_GATEWAY_ADDRESSES: Record<number, Address> = {
+  ...WETH_GATEWAY_ADDRESSES_MAINNET,
+  ...WETH_GATEWAY_ADDRESSES_TESTNET,
+} as const
+
+/**
+ * Get WETHGateway address for a given chain ID
+ * @param chainId - Chain ID
+ * @returns WETHGateway address if supported, undefined otherwise
+ */
+export function getWETHGatewayAddress(chainId: number): Address | undefined {
+  return WETH_GATEWAY_ADDRESSES[chainId]
+}