@eth-optimism/actions-sdk 0.0.4 → 0.2.0

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

@@ -0,0 +1,419 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { MockReceiverAddress } from '@/lend/__mocks__/MockMarkets.js'
+import {
+  createMockAaveReserve,
+  createMockWETHReserve,
+} from '@/lend/providers/aave/__mocks__/mockReserve.js'
+import { AaveLendProvider } from '@/lend/providers/aave/AaveLendProvider.js'
+import * as aaveSdk from '@/lend/providers/aave/sdk.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { LendProviderConfig } from '@/types/actions.js'
+import type { Asset, LendMarketConfig } from '@/types/index.js'
+
+// Mock the Aave SDK modules
+vi.mock('@/lend/providers/aave/sdk.js', () => ({
+  getReserve: vi.fn(),
+  getReserves: vi.fn(),
+  getATokenAddress: vi.fn(),
+}))
+
+// Mock assets for Aave tests (using Base chain ID 8453)
+const MockAaveUSDCAsset: Asset = {
+  address: {
+    8453: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+  },
+  metadata: {
+    decimals: 6,
+    name: 'USD Coin',
+    symbol: 'USDC',
+  },
+  type: 'erc20',
+}
+
+const MockAaveETHAsset: Asset = {
+  address: {
+    8453: 'native',
+  },
+  metadata: {
+    decimals: 18,
+    name: 'Ethereum',
+    symbol: 'ETH',
+  },
+  type: 'native',
+}
+
+// Mock market configurations for Aave
+const MockAaveUSDCMarket: LendMarketConfig = {
+  address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+  chainId: 8453, // Base
+  name: 'Aave USDC Base',
+  asset: MockAaveUSDCAsset,
+  lendProvider: 'aave',
+}
+
+const MockAaveETHMarket: LendMarketConfig = {
+  address: '0x4200000000000000000000000000000000000006', // WETH predeploy (market uses WETH internally)
+  chainId: 8453,
+  name: 'Aave ETH Base',
+  asset: MockAaveETHAsset,
+  lendProvider: 'aave',
+}
+
+describe('AaveLendProvider', () => {
+  let provider: AaveLendProvider
+  let mockConfig: LendProviderConfig
+  let mockChainManager: ChainManager
+
+  beforeEach(() => {
+    mockConfig = {
+      marketAllowlist: [MockAaveUSDCMarket, MockAaveETHMarket],
+    }
+
+    mockChainManager = new MockChainManager({
+      supportedChains: [8453],
+    }) as unknown as ChainManager
+
+    provider = new AaveLendProvider(mockConfig, mockChainManager)
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('constructor', () => {
+    it('should initialize with provided config', () => {
+      expect(provider).toBeInstanceOf(AaveLendProvider)
+    })
+  })
+
+  describe('supportedChainIds', () => {
+    it('should return array of supported chain IDs', () => {
+      const chainIds = provider.supportedChainIds()
+
+      expect(chainIds).toHaveLength(4)
+      expect(chainIds).toContain(10) // Optimism
+      expect(chainIds).toContain(8453) // Base
+      expect(chainIds).toContain(11155420) // Optimism Sepolia
+      expect(chainIds).toContain(84532) // Base Sepolia
+    })
+
+    it('should return unique chain IDs', () => {
+      const chainIds = provider.supportedChainIds()
+      const uniqueIds = [...new Set(chainIds)]
+
+      expect(chainIds.length).toBe(uniqueIds.length)
+    })
+  })
+
+  describe('openPosition', () => {
+    beforeEach(() => {
+      const mockReserve = createMockAaveReserve()
+      vi.mocked(aaveSdk.getReserve).mockResolvedValue(mockReserve)
+    })
+
+    it('should successfully create a lending transaction for ERC20', async () => {
+      const amount = 1000
+      const asset = MockAaveUSDCAsset
+      const marketId = {
+        address: MockAaveUSDCMarket.address,
+        chainId: MockAaveUSDCMarket.chainId,
+      }
+
+      const lendTransaction = await provider.openPosition({
+        amount,
+        asset,
+        marketId,
+        walletAddress: MockReceiverAddress,
+      })
+
+      expect(lendTransaction).toHaveProperty('amount', BigInt('1000000000'))
+      expect(lendTransaction).toHaveProperty(
+        'asset',
+        asset.address[marketId.chainId],
+      )
+      expect(lendTransaction).toHaveProperty('marketId', marketId.address)
+      expect(lendTransaction).toHaveProperty('apy')
+      expect(lendTransaction).toHaveProperty('transactionData')
+      expect(lendTransaction.transactionData).toHaveProperty('approval')
+      expect(lendTransaction.transactionData).toHaveProperty('position')
+      expect(typeof lendTransaction.apy).toBe('number')
+      expect(lendTransaction.apy).toBeGreaterThan(0)
+    })
+
+    it('should create native ETH deposit without approval', async () => {
+      const mockETHReserve = createMockWETHReserve()
+      vi.mocked(aaveSdk.getReserve).mockResolvedValue(mockETHReserve)
+
+      const amount = 1
+      const asset = MockAaveETHAsset
+      const marketId = {
+        address: MockAaveETHMarket.address,
+        chainId: MockAaveETHMarket.chainId,
+      }
+
+      const lendTransaction = await provider.openPosition({
+        amount,
+        asset,
+        marketId,
+        walletAddress: MockReceiverAddress,
+      })
+
+      expect(lendTransaction).toHaveProperty(
+        'amount',
+        BigInt('1000000000000000000'),
+      )
+      expect(lendTransaction.transactionData).not.toHaveProperty('approval')
+      expect(lendTransaction.transactionData).toHaveProperty('position')
+      // Native ETH deposits send ETH as msg.value via WETHGateway
+      expect(lendTransaction.transactionData.position.value).toBe(
+        BigInt('1000000000000000000'),
+      )
+    })
+
+    it('should handle lending errors', async () => {
+      vi.mocked(aaveSdk.getReserve).mockRejectedValueOnce(
+        new Error('Market fetch failed'),
+      )
+
+      const asset = MockAaveUSDCAsset
+      const amount = 1000
+      const marketId = {
+        address: MockAaveUSDCMarket.address,
+        chainId: MockAaveUSDCMarket.chainId,
+      }
+
+      await expect(
+        provider.openPosition({
+          amount,
+          asset,
+          marketId,
+          walletAddress: MockReceiverAddress,
+        }),
+      ).rejects.toThrow('Failed to open position')
+    })
+  })
+
+  describe('closePosition', () => {
+    beforeEach(() => {
+      const mockReserve = createMockAaveReserve()
+      vi.mocked(aaveSdk.getReserve).mockResolvedValue(mockReserve)
+    })
+
+    it('should successfully create a withdrawal transaction for ERC20', async () => {
+      const amount = 500
+      const asset = MockAaveUSDCAsset
+      const marketId = {
+        address: MockAaveUSDCMarket.address,
+        chainId: MockAaveUSDCMarket.chainId,
+      }
+      const walletAddress = MockReceiverAddress
+
+      const withdrawTransaction = await provider.closePosition({
+        amount,
+        asset,
+        marketId,
+        walletAddress,
+      })
+
+      expect(withdrawTransaction).toHaveProperty('amount', BigInt('500000000'))
+      expect(withdrawTransaction).toHaveProperty(
+        'asset',
+        asset.address[marketId.chainId],
+      )
+      expect(withdrawTransaction).toHaveProperty('marketId', marketId.address)
+      expect(withdrawTransaction).toHaveProperty('apy')
+      expect(withdrawTransaction).toHaveProperty('transactionData')
+      expect(withdrawTransaction.transactionData).toHaveProperty('position')
+      expect(withdrawTransaction.transactionData).not.toHaveProperty('approval')
+      expect(typeof withdrawTransaction.apy).toBe('number')
+      expect(withdrawTransaction.apy).toBeGreaterThan(0)
+    })
+
+    it('should create native ETH withdrawal with approval', async () => {
+      const mockETHReserve = createMockWETHReserve()
+      vi.mocked(aaveSdk.getReserve).mockResolvedValue(mockETHReserve)
+      vi.mocked(aaveSdk.getATokenAddress).mockResolvedValue(
+        '0xD4a0e0b9149BCee3C920d2E00b5dE09138fd8bb7',
+      )
+
+      const amount = 1
+      const asset = MockAaveETHAsset
+      const marketId = {
+        address: MockAaveETHMarket.address,
+        chainId: MockAaveETHMarket.chainId,
+      }
+
+      const withdrawTransaction = await provider.closePosition({
+        amount,
+        asset,
+        marketId,
+        walletAddress: MockReceiverAddress,
+      })
+
+      expect(withdrawTransaction).toHaveProperty(
+        'amount',
+        BigInt('1000000000000000000'),
+      )
+      // Native ETH withdrawals require approving aWETH to WETHGateway
+      expect(withdrawTransaction.transactionData).toHaveProperty('approval')
+      expect(withdrawTransaction.transactionData).toHaveProperty('position')
+    })
+
+    it('should handle withdrawal errors', async () => {
+      vi.mocked(aaveSdk.getReserve).mockRejectedValueOnce(
+        new Error('Market fetch failed'),
+      )
+
+      const amount = 500
+      const asset = MockAaveUSDCAsset
+      const marketId = {
+        address: MockAaveUSDCMarket.address,
+        chainId: MockAaveUSDCMarket.chainId,
+      }
+      const walletAddress = MockReceiverAddress
+
+      await expect(
+        provider.closePosition({
+          amount,
+          asset,
+          marketId,
+          walletAddress,
+        }),
+      ).rejects.toThrow('Market fetch failed')
+    })
+  })
+
+  describe('market allowlist configuration', () => {
+    it('should work without market allowlist', () => {
+      const configWithoutAllowlist: LendProviderConfig = {}
+
+      const providerWithoutAllowlist = new AaveLendProvider(
+        configWithoutAllowlist,
+        mockChainManager,
+      )
+
+      expect(providerWithoutAllowlist.config.marketAllowlist).toBeUndefined()
+    })
+
+    it('should store market allowlist when provided', () => {
+      const configWithAllowlist: LendProviderConfig = {
+        marketAllowlist: [MockAaveUSDCMarket],
+      }
+
+      const providerWithAllowlist = new AaveLendProvider(
+        configWithAllowlist,
+        mockChainManager,
+      )
+
+      const allowlist = providerWithAllowlist.config.marketAllowlist
+      expect(allowlist).toBeDefined()
+      expect(allowlist).toHaveLength(1)
+      expect(allowlist![0].address).toBe(MockAaveUSDCMarket.address)
+      expect(allowlist![0].name).toBe(MockAaveUSDCMarket.name)
+    })
+
+    it('should handle multiple markets in allowlist', () => {
+      const configWithMultipleMarkets: LendProviderConfig = {
+        marketAllowlist: [MockAaveUSDCMarket, MockAaveETHMarket],
+      }
+
+      const providerInstance = new AaveLendProvider(
+        configWithMultipleMarkets,
+        mockChainManager,
+      )
+
+      const allowlist = providerInstance.config.marketAllowlist
+      expect(allowlist).toBeDefined()
+      expect(allowlist).toHaveLength(2)
+      expect(allowlist![0].name).toBe(MockAaveUSDCMarket.name)
+      expect(allowlist![1].name).toBe(MockAaveETHMarket.name)
+    })
+  })
+
+  describe('ETH/WETH market configuration', () => {
+    it('should detect native asset type for ETH market', () => {
+      // Market is configured with ETH (type: native) but uses WETH address internally
+      expect(MockAaveETHMarket.asset.type).toBe('native')
+      expect(MockAaveETHMarket.asset.address[8453]).toBe('native')
+      // Market address points to WETH for Aave's internal operations
+      expect(MockAaveETHMarket.address).toBe(
+        '0x4200000000000000000000000000000000000006',
+      )
+    })
+
+    it('should use WETHGateway for ETH deposits when asset type is native', async () => {
+      const mockETHReserve = createMockWETHReserve()
+      vi.mocked(aaveSdk.getReserve).mockResolvedValue(mockETHReserve)
+
+      const lendTransaction = await provider.openPosition({
+        amount: 1,
+        asset: MockAaveETHAsset,
+        marketId: {
+          address: MockAaveETHMarket.address,
+          chainId: MockAaveETHMarket.chainId,
+        },
+        walletAddress: MockReceiverAddress,
+      })
+
+      // Native ETH deposits should have msg.value set (WETHGateway flow)
+      expect(lendTransaction.transactionData.position.value).toBe(
+        BigInt('1000000000000000000'),
+      )
+      // Should not require approval for native ETH
+      expect(lendTransaction.transactionData.approval).toBeUndefined()
+    })
+
+    it('should allow developer to configure ETH market without knowing about WETH internals', () => {
+      // Developer configures market with ETH asset
+      // SDK handles WETH internally via WETHGateway
+      const marketConfig: LendMarketConfig = {
+        address: '0x4200000000000000000000000000000000000006', // WETH address
+        chainId: 8453,
+        name: 'Aave ETH',
+        asset: MockAaveETHAsset, // Uses ETH (native) asset
+        lendProvider: 'aave',
+      }
+
+      // Verify the market uses native asset
+      expect(marketConfig.asset.type).toBe('native')
+      // Developer doesn't need to create a separate WETH asset
+    })
+  })
+
+  describe('unsupported chain handling', () => {
+    it('should throw error for unsupported chain', async () => {
+      // Use type assertion to test runtime behavior with unsupported chain
+      const unsupportedChainId = 999999 as 8453
+      const unsupportedMarket: LendMarketConfig = {
+        address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+        chainId: unsupportedChainId,
+        name: 'Unsupported Market',
+        asset: MockAaveUSDCAsset,
+        lendProvider: 'aave',
+      }
+
+      const configWithUnsupported: LendProviderConfig = {
+        marketAllowlist: [unsupportedMarket],
+      }
+
+      const providerWithUnsupported = new AaveLendProvider(
+        configWithUnsupported,
+        mockChainManager,
+      )
+
+      await expect(
+        providerWithUnsupported.openPosition({
+          amount: 100,
+          asset: MockAaveUSDCAsset,
+          marketId: {
+            address: unsupportedMarket.address,
+            chainId: unsupportedMarket.chainId,
+          },
+          walletAddress: MockReceiverAddress,
+        }),
+      ).rejects.toThrow('not supported')
+    })
+  })
+})

package/src/lend/providers/aave/abis/pool.ts

@@ -0,0 +1,81 @@
+import { parseAbi } from 'viem'
+
+/**
+ * Aave Pool ABI - supply and withdraw functions
+ */
+export 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 Pool ABI - getReserveData for fetching reserve info including aToken addresses
+ */
+export const POOL_GET_RESERVE_DATA_ABI = [
+  {
+    inputs: [{ name: 'asset', type: 'address', internalType: 'address' }],
+    name: 'getReserveData',
+    outputs: [
+      {
+        components: [
+          { name: 'data', type: 'uint256', internalType: 'uint256' },
+        ],
+        name: 'configuration',
+        type: 'tuple',
+        internalType: 'struct DataTypes.ReserveConfigurationMap',
+      },
+      { name: 'liquidityIndex', type: 'uint128', internalType: 'uint128' },
+      {
+        name: 'currentLiquidityRate',
+        type: 'uint128',
+        internalType: 'uint128',
+      },
+      { name: 'variableBorrowIndex', type: 'uint128', internalType: 'uint128' },
+      {
+        name: 'currentVariableBorrowRate',
+        type: 'uint128',
+        internalType: 'uint128',
+      },
+      {
+        name: 'currentStableBorrowRate',
+        type: 'uint128',
+        internalType: 'uint128',
+      },
+      { name: 'lastUpdateTimestamp', type: 'uint40', internalType: 'uint40' },
+      { name: 'id', type: 'uint16', internalType: 'uint16' },
+      { name: 'aTokenAddress', type: 'address', internalType: 'address' },
+      {
+        name: 'stableDebtTokenAddress',
+        type: 'address',
+        internalType: 'address',
+      },
+      {
+        name: 'variableDebtTokenAddress',
+        type: 'address',
+        internalType: 'address',
+      },
+      {
+        name: 'interestRateStrategyAddress',
+        type: 'address',
+        internalType: 'address',
+      },
+      { name: 'accruedToTreasury', type: 'uint128', internalType: 'uint128' },
+      { name: 'unbacked', type: 'uint128', internalType: 'uint128' },
+      {
+        name: 'isolationModeTotalDebt',
+        type: 'uint128',
+        internalType: 'uint128',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+/**
+ * Aave WETHGateway ABI - for native ETH deposits/withdrawals
+ */
+export const WETH_GATEWAY_ABI = parseAbi([
+  'function depositETH(address pool, address onBehalfOf, uint16 referralCode) payable',
+  'function withdrawETH(address pool, uint256 amount, address to)',
+])

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]
+}