@eth-optimism/actions-sdk 0.1.0 → 0.3.0

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

@@ -1,6 +1,7 @@
 import type { Address } from 'viem'
-import { encodeFunctionData, erc20Abi, formatUnits, parseAbi } from 'viem'
+import { encodeFunctionData, erc20Abi, formatUnits } from 'viem'
 
+import { WETH } from '@/constants/assets.js'
 import { LendProvider } from '@/lend/core/LendProvider.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import type { LendProviderConfig } from '@/types/actions.js'
@@ -14,36 +15,15 @@ import type {
   LendOpenPositionInternalParams,
   LendTransaction,
 } from '@/types/lend/index.js'
-import { getAssetAddress } from '@/utils/assets.js'
+import { getAssetAddress, isNativeAsset } from '@/utils/assets.js'
 
+import { POOL_ABI, WETH_GATEWAY_ABI } from './abis/pool.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)',
-])
+import { getATokenAddress, getReserve, getReserves } from './sdk.js'
 
 /**
  * Supported chain IDs for Aave lending
@@ -58,26 +38,13 @@ export const SUPPORTED_CHAIN_IDS = getSupportedChainIds() as readonly number[]
 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()
+    super(config, chainManager)
   }
 
   /**
@@ -104,27 +71,149 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
         chainId: params.marketId.chainId,
       })
 
-      // Check if this is a WETH market
-      if (this.isWETHMarket(params.marketId)) {
-        return this._openWETHPosition(params, poolAddress, marketInfo)
+      // Check if this is a native ETH market
+      if (isNativeAsset(params.asset)) {
+        return this._openETHPosition(params, poolAddress, marketInfo)
       }
 
       // Standard ERC-20 flow
       return this._openERC20Position(params, poolAddress, marketInfo)
-    } 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}`,
       )
     }
   }
 
   /**
-   * Open position for WETH market using WETHGateway
+   * 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 native ETH market
+      if (isNativeAsset(marketInfo.asset)) {
+        return this._closeETHPosition(params, poolAddress, marketInfo)
+      }
+
+      // Standard ERC-20 flow
+      return this._closeERC20Position(params, poolAddress, marketInfo)
+    } catch {
+      throw new Error('Failed to close position')
+    }
+  }
+
+  /**
+   * 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
+      // For native assets, use WETH address since Aave uses WETH internally
+      const assetAddress = isNativeAsset(market.asset)
+        ? getAssetAddress(WETH, params.marketId.chainId)
+        : getAssetAddress(market.asset, params.marketId.chainId)
+
+      const aTokenAddress = await getATokenAddress({
+        underlyingAsset: assetAddress,
+        chainId: params.marketId.chainId,
+        chainManager: this.chainManager,
+      })
+
+      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 {
+      throw new Error(
+        `Failed to get market balance for ${params.walletAddress} in market ${params.marketId.address}`,
+      )
+    }
+  }
+
+  /**
+   * Open position for native ETH using WETHGateway
    * @description Deposits native ETH via WETHGateway which wraps and deposits in one tx
    */
-  private async _openWETHPosition(
+  private async _openETHPosition(
     params: LendOpenPositionInternalParams,
     poolAddress: Address,
     marketInfo: LendMarket,
@@ -147,19 +236,20 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
       ],
     })
 
+    const wethAddress = getAssetAddress(WETH, params.marketId.chainId)
+
     return {
       amount: params.amountWei,
-      asset: WETH_ADDRESS,
+      asset: wethAddress,
       marketId: params.marketId.address,
       apy: marketInfo.apy.total,
       transactionData: {
-        openPosition: {
+        position: {
           to: gatewayAddress,
           data: depositCallData,
           value: params.amountWei, // Send ETH as msg.value
         },
       },
-      slippage: params.options?.slippage ?? 50,
     }
   }
 
@@ -172,18 +262,8 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
     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],
-    })
+    // Get asset address for the chain (throws for native assets)
+    const assetAddress = getAssetAddress(params.asset, params.marketId.chainId)
 
     // Generate supply transaction
     const supplyCallData = encodeFunctionData({
@@ -203,65 +283,25 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
       marketId: params.marketId.address,
       apy: marketInfo.apy.total,
       transactionData: {
-        approval: {
-          to: assetAddress,
-          data: approvalCallData,
-          value: 0n,
-        },
-        openPosition: {
+        approval: this.buildApprovalTx(
+          assetAddress,
+          poolAddress,
+          params.amountWei,
+        ),
+        position: {
           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
+   * Close position for native ETH using WETHGateway
    * @description Withdraws aWETH, unwraps to ETH, and sends to user
    */
-  private async _closeWETHPosition(
+  private async _closeETHPosition(
     params: LendClosePositionParams,
     poolAddress: Address,
     marketInfo: LendMarket,
@@ -273,23 +313,16 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
       )
     }
 
+    const wethAddress = getAssetAddress(WETH, 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,
+      underlyingAsset: wethAddress,
       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
+    // Call withdrawETH on gateway
     const withdrawCallData = encodeFunctionData({
       abi: WETH_GATEWAY_ABI,
       functionName: 'withdrawETH',
@@ -302,22 +335,21 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
 
     return {
       amount: params.amount,
-      asset: WETH_ADDRESS,
+      asset: wethAddress,
       marketId: params.marketId.address,
       apy: marketInfo.apy.total,
       transactionData: {
-        approval: {
-          to: aWETHAddress,
-          data: approvalCallData,
-          value: 0n,
-        },
-        closePosition: {
+        approval: this.buildApprovalTx(
+          aWETHAddress,
+          gatewayAddress,
+          params.amount,
+        ),
+        position: {
           to: gatewayAddress,
           data: withdrawCallData,
           value: 0n,
         },
       },
-      slippage: params.options?.slippage ?? 50,
     }
   }
 
@@ -352,112 +384,12 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
       marketId: params.marketId.address,
       apy: marketInfo.apy.total,
       transactionData: {
-        closePosition: {
+        position: {
           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/__mocks__/mockReserve.ts

@@ -0,0 +1,84 @@
+import type { Address } from 'viem'
+
+import type { LendMarket } from '@/types/lend/index.js'
+
+/**
+ * Creates mock Aave reserve data for testing
+ */
+export function createMockAaveReserve(): LendMarket {
+  return {
+    marketId: {
+      address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address, // USDC on Base
+      chainId: 8453,
+    },
+    name: 'Aave USDC Base',
+    asset: {
+      metadata: {
+        name: 'USD Coin',
+        symbol: 'USDC',
+        decimals: 6,
+      },
+      address: {
+        8453: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address,
+      },
+      type: 'erc20',
+    },
+    supply: {
+      totalAssets: BigInt(10000000e6),
+      totalShares: BigInt(10000000e6),
+    },
+    apy: {
+      total: 0.0325, // 3.25%
+      native: 0.0325,
+      totalRewards: 0,
+      performanceFee: 0,
+    },
+    metadata: {
+      owner: '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5' as Address,
+      curator: '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5' as Address,
+      fee: 0,
+      lastUpdate: Math.floor(Date.now() / 1000),
+    },
+  }
+}
+
+/**
+ * Creates mock ETH reserve data for testing (native asset)
+ * @description Uses type: 'native' to test native ETH handling via WETHGateway
+ */
+export function createMockWETHReserve(): LendMarket {
+  return {
+    marketId: {
+      address: '0x4200000000000000000000000000000000000006' as Address, // WETH on OP Stack
+      chainId: 8453,
+    },
+    name: 'Aave ETH Base',
+    asset: {
+      metadata: {
+        name: 'Ethereum',
+        symbol: 'ETH',
+        decimals: 18,
+      },
+      address: {
+        8453: 'native',
+      },
+      type: 'native',
+    },
+    supply: {
+      totalAssets: BigInt(5000e18),
+      totalShares: BigInt(5000e18),
+    },
+    apy: {
+      total: 0.018, // 1.8%
+      native: 0.018,
+      totalRewards: 0,
+      performanceFee: 0,
+    },
+    metadata: {
+      owner: '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5' as Address,
+      curator: '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5' as Address,
+      fee: 0,
+      lastUpdate: Math.floor(Date.now() / 1000),
+    },
+  }
+}