@eth-optimism/actions-sdk 0.0.4 → 0.2.0

package/src/lend/namespaces/BaseLendNamespace.ts

@@ -0,0 +1,89 @@
+import type { LendProvider } from '@/lend/core/LendProvider.js'
+import type { AaveLendProvider } from '@/lend/providers/aave/AaveLendProvider.js'
+import type { MorphoLendProvider } from '@/lend/providers/morpho/MorphoLendProvider.js'
+import type { LendProviderConfig } from '@/types/actions.js'
+import type {
+  GetLendMarketParams,
+  GetLendMarketsParams,
+  LendMarket,
+  LendMarketId,
+} from '@/types/lend/index.js'
+
+export type LendProviders = {
+  morpho?: LendProvider<LendProviderConfig>
+  aave?: LendProvider<LendProviderConfig>
+}
+
+/**
+ * Base Lend Namespace
+ * @description Shared lending operations for Actions and Wallet namespaces
+ */
+export abstract class BaseLendNamespace {
+  constructor(protected readonly providers: LendProviders) {}
+
+  /**
+   * Get all markets across all configured providers
+   * @param params - Optional filtering parameters
+   * @returns Promise resolving to array of markets from all providers
+   */
+  async getMarkets(params: GetLendMarketsParams = {}): Promise<LendMarket[]> {
+    const results = await Promise.all(
+      this.getAllProviders().map((p) => p.getMarkets(params)),
+    )
+    return results.flat()
+  }
+
+  /**
+   * Get a specific market by routing to the correct provider
+   * @param params - Market identifier
+   * @returns Promise resolving to market information
+   */
+  async getMarket(params: GetLendMarketParams): Promise<LendMarket> {
+    const provider = this.getProviderForMarket(params)
+    return provider.getMarket(params)
+  }
+
+  /**
+   * Get supported chain IDs across all providers
+   * @returns Array of unique chain IDs supported by any provider
+   */
+  supportedChainIds(): number[] {
+    const allChains = this.getAllProviders().flatMap((p) =>
+      p.supportedChainIds(),
+    )
+    return [...new Set(allChains)]
+  }
+
+  /**
+   * Get all configured providers
+   * @returns Array of configured providers
+   */
+  protected getAllProviders(): Array<MorphoLendProvider | AaveLendProvider> {
+    return [this.providers.morpho, this.providers.aave].filter(
+      Boolean,
+    ) as Array<MorphoLendProvider | AaveLendProvider>
+  }
+
+  /**
+   * Route a market to the correct provider
+   * @param marketId - Market identifier to route
+   * @returns The provider that handles this market
+   * @throws Error if no provider is found for the market
+   */
+  protected getProviderForMarket(
+    marketId: LendMarketId,
+  ): MorphoLendProvider | AaveLendProvider {
+    for (const provider of this.getAllProviders()) {
+      const market = provider.config.marketAllowlist?.find(
+        (m: LendMarketId) =>
+          m.address.toLowerCase() === marketId.address.toLowerCase() &&
+          m.chainId === marketId.chainId,
+      )
+      if (market) return provider
+    }
+
+    throw new Error(
+      `No provider configured for market ${marketId.address} on chain ${marketId.chainId}`,
+    )
+  }
+}

package/src/lend/namespaces/WalletLendNamespace.ts

@@ -1,41 +1,28 @@
-import type { LendProvider } from '@/lend/core/LendProvider.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type {
-  BaseLendConfig,
   ClosePositionParams,
   GetPositionParams,
   LendMarketPosition,
   LendOpenPositionParams,
+  LendTransaction,
   LendTransactionReceipt,
 } from '@/types/lend/index.js'
 import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
 
+import { BaseLendNamespace, type LendProviders } from './BaseLendNamespace.js'
+
 /**
  * Wallet Lend Namespace
  * @description Full lending operations available on wallet.lend
  */
-export class WalletLendNamespace<
-  TConfig extends BaseLendConfig = BaseLendConfig,
-> {
+export class WalletLendNamespace extends BaseLendNamespace {
   constructor(
-    protected readonly provider: LendProvider<TConfig>,
+    providers: LendProviders,
     private readonly wallet: Wallet,
-  ) {}
-
-  get config(): TConfig {
-    return this.provider.config
+  ) {
+    super(providers)
   }
 
-  // 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
@@ -47,30 +34,14 @@ export class WalletLendNamespace<
   async openPosition(
     params: LendOpenPositionParams,
   ): Promise<LendTransactionReceipt> {
-    const lendTransaction = await this.provider.openPosition({
+    const provider = this.getProviderForMarket(params.marketId)
+
+    const lendTransaction = await 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,
-    )
+    return this.executeTransaction(lendTransaction, params.marketId.chainId)
   }
 
   /**
@@ -81,7 +52,13 @@ export class WalletLendNamespace<
    * @returns Promise resolving to position information
    */
   async getPosition(params: GetPositionParams): Promise<LendMarketPosition> {
-    return this.provider.getPosition(
+    if (!params.marketId) {
+      throw new Error('marketId is required')
+    }
+
+    const provider = this.getProviderForMarket(params.marketId)
+
+    return provider.getPosition(
       this.wallet.address,
       params.marketId,
       params.asset,
@@ -98,25 +75,32 @@ export class WalletLendNamespace<
   async closePosition(
     params: ClosePositionParams,
   ): Promise<LendTransactionReceipt> {
-    const closeTransaction = await this.provider.closePosition({
+    const provider = this.getProviderForMarket(params.marketId)
+
+    const closeTransaction = await provider.closePosition({
       ...params,
       walletAddress: this.wallet.address,
     })
 
-    const { transactionData } = closeTransaction
-    if (!transactionData) {
-      throw new Error(
-        'No transaction data returned from close position provider',
-      )
-    }
+    return this.executeTransaction(closeTransaction, params.marketId.chainId)
+  }
 
-    if (!transactionData.closePosition) {
-      throw new Error('No closePosition transaction data returned')
+  /**
+   * Execute a lend transaction with optional approval batching
+   */
+  private async executeTransaction(
+    transaction: LendTransaction,
+    chainId: SupportedChainId,
+  ): Promise<LendTransactionReceipt> {
+    const { transactionData } = transaction
+
+    if (transactionData.approval) {
+      return this.wallet.sendBatch(
+        [transactionData.approval, transactionData.position],
+        chainId,
+      )
     }
 
-    return await this.wallet.send(
-      transactionData.closePosition,
-      params.marketId.chainId,
-    )
+    return this.wallet.send(transactionData.position, chainId)
   }
 }

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

@@ -1,25 +1,43 @@
+import type { Address } from 'viem'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { getRandomAddress } from '@/__mocks__/utils.js'
+import type { MockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
 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
+  let mockProvider: MockLendProvider
+  let mockMarketId: { address: Address; chainId: 130 }
 
   beforeEach(() => {
-    mockProvider = createMockLendProvider()
+    mockMarketId = { address: getRandomAddress(), chainId: 130 as const }
+
+    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',
+        },
+      ],
+    })
   })
 
   it('should create an instance with a lend provider', () => {
-    const namespace = new ActionsLendNamespace(mockProvider)
+    const namespace = new ActionsLendNamespace({ morpho: mockProvider })
 
     expect(namespace).toBeInstanceOf(ActionsLendNamespace)
   })
 
   it('should delegate getMarkets to provider', async () => {
-    const namespace = new ActionsLendNamespace(mockProvider)
+    const namespace = new ActionsLendNamespace({ morpho: mockProvider })
     const spy = vi.spyOn(mockProvider, 'getMarkets')
 
     await namespace.getMarkets()
@@ -28,31 +46,20 @@ describe('ActionsLendNamespace', () => {
   })
 
   it('should delegate getMarket to provider with correct parameters', async () => {
-    const namespace = new ActionsLendNamespace(mockProvider)
-    const marketId = getRandomAddress()
-    const chainId = 130 as const
+    const namespace = new ActionsLendNamespace({ morpho: mockProvider })
     const spy = vi.spyOn(mockProvider, 'getMarket')
 
-    await namespace.getMarket({ address: marketId, chainId })
+    await namespace.getMarket(mockMarketId)
 
-    expect(spy).toHaveBeenCalledWith({ address: marketId, chainId })
+    expect(spy).toHaveBeenCalledWith(mockMarketId)
   })
 
   it('should delegate supportedChainIds to provider', () => {
-    const namespace = new ActionsLendNamespace(mockProvider)
+    const namespace = new ActionsLendNamespace({ morpho: 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__/BaseLendNamespace.spec.ts

@@ -0,0 +1,137 @@
+import type { Address } from 'viem'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { getRandomAddress } from '@/__mocks__/utils.js'
+import type { MockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import { BaseLendNamespace } from '@/lend/namespaces/BaseLendNamespace.js'
+
+// Concrete implementation for testing
+class TestLendNamespace extends BaseLendNamespace {}
+
+describe('BaseLendNamespace', () => {
+  let mockMorphoProvider: MockLendProvider
+  let mockAaveProvider: MockLendProvider
+  let mockMarketId: { address: Address; chainId: 130 }
+  let aaveMarketId: { address: Address; chainId: 130 }
+
+  beforeEach(() => {
+    mockMarketId = { address: getRandomAddress(), chainId: 130 as const }
+    aaveMarketId = { address: getRandomAddress(), chainId: 130 as const }
+
+    mockMorphoProvider = createMockLendProvider({
+      marketAllowlist: [
+        {
+          address: mockMarketId.address,
+          chainId: mockMarketId.chainId,
+          name: 'Morpho Market',
+          asset: {
+            address: { 130: getRandomAddress() },
+            metadata: { symbol: 'USDC', name: 'USD Coin', decimals: 6 },
+            type: 'erc20' as const,
+          },
+          lendProvider: 'morpho',
+        },
+      ],
+    })
+
+    mockAaveProvider = createMockLendProvider({
+      marketAllowlist: [
+        {
+          address: aaveMarketId.address,
+          chainId: aaveMarketId.chainId,
+          name: 'Aave Market',
+          asset: {
+            address: { 130: getRandomAddress() },
+            metadata: { symbol: 'USDC', name: 'USD Coin', decimals: 6 },
+            type: 'erc20' as const,
+          },
+          lendProvider: 'aave',
+        },
+      ],
+    })
+  })
+
+  describe('getMarkets', () => {
+    it('should aggregate markets from all providers', async () => {
+      const namespace = new TestLendNamespace({
+        morpho: mockMorphoProvider,
+        aave: mockAaveProvider,
+      })
+
+      const markets = await namespace.getMarkets()
+
+      expect(markets).toHaveLength(2)
+    })
+
+    it('should work with single provider', async () => {
+      const namespace = new TestLendNamespace({
+        morpho: mockMorphoProvider,
+      })
+
+      const markets = await namespace.getMarkets()
+
+      expect(markets).toHaveLength(1)
+    })
+  })
+
+  describe('getMarket', () => {
+    it('should route to correct provider based on market', async () => {
+      const namespace = new TestLendNamespace({
+        morpho: mockMorphoProvider,
+        aave: mockAaveProvider,
+      })
+
+      const morphoSpy = vi.spyOn(mockMorphoProvider, 'getMarket')
+      const aaveSpy = vi.spyOn(mockAaveProvider, 'getMarket')
+
+      await namespace.getMarket(mockMarketId)
+
+      expect(morphoSpy).toHaveBeenCalledWith(mockMarketId)
+      expect(aaveSpy).not.toHaveBeenCalled()
+    })
+
+    it('should throw if no provider found for market', async () => {
+      const namespace = new TestLendNamespace({
+        morpho: mockMorphoProvider,
+      })
+
+      const unknownMarket = {
+        address: getRandomAddress(),
+        chainId: 130 as const,
+      }
+
+      await expect(namespace.getMarket(unknownMarket)).rejects.toThrow(
+        'No provider configured for market',
+      )
+    })
+  })
+
+  describe('supportedChainIds', () => {
+    it('should return unique chain IDs from all providers', () => {
+      const namespace = new TestLendNamespace({
+        morpho: mockMorphoProvider,
+        aave: mockAaveProvider,
+      })
+
+      const chainIds = namespace.supportedChainIds()
+
+      expect(chainIds).toContain(1)
+      expect(chainIds).toContain(130)
+      expect(chainIds).toContain(8453)
+      expect(chainIds).toContain(84532)
+    })
+
+    it('should deduplicate chain IDs', () => {
+      const namespace = new TestLendNamespace({
+        morpho: mockMorphoProvider,
+        aave: mockAaveProvider,
+      })
+
+      const chainIds = namespace.supportedChainIds()
+      const uniqueChainIds = [...new Set(chainIds)]
+
+      expect(chainIds).toEqual(uniqueChainIds)
+    })
+  })
+})

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

@@ -1,20 +1,42 @@
+import type { Address } from 'viem'
 import type { WaitForUserOperationReceiptReturnType } from 'viem/account-abstraction'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { getRandomAddress } from '@/__mocks__/utils.js'
+import type { MockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
 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 type { 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 mockProvider: MockLendProvider
   let mockWallet: SmartWallet
+  let mockMarketId: { address: Address; 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 +54,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 },
+      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 },
+      mockWallet,
+    )
     const mockMarkets = [
       {
         marketId: {
@@ -75,32 +103,34 @@ 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 },
+        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],
         marketId: marketId.address,
         apy: 0.05,
         transactionData: {
-          openPosition: {
+          position: {
             to: marketId.address,
             value: 0n,
             data: '0x' as const,
           },
         },
-        slippage: 50,
       }
 
       vi.mocked(mockProvider.openPosition).mockResolvedValue(mockTransaction)
@@ -128,10 +158,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 },
+        mockWallet,
+      )
       const closeParams = {
         amount: 100,
-        marketId: { address: getRandomAddress(), chainId: 130 as const },
+        marketId: mockMarketId,
       }
 
       const mockTransaction = {
@@ -140,7 +173,7 @@ describe('WalletLendNamespace', () => {
         marketId: closeParams.marketId.address,
         apy: 0.05,
         transactionData: {
-          closePosition: {
+          position: {
             to: closeParams.marketId.address,
             value: 0n,
             data: '0x' as const,
@@ -158,7 +191,7 @@ describe('WalletLendNamespace', () => {
         options: undefined,
       })
       expect(mockWallet.send).toHaveBeenCalledWith(
-        mockTransaction.transactionData.closePosition,
+        mockTransaction.transactionData.position,
         130,
       )
       expect(result).toEqual({
@@ -169,26 +202,32 @@ describe('WalletLendNamespace', () => {
   })
 
   it('should store the wallet reference', () => {
-    const namespace = new WalletLendNamespace(mockProvider, mockWallet)
+    const namespace = new WalletLendNamespace(
+      { morpho: 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 namespace = new WalletLendNamespace(
+      { morpho: 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 marketId = mockMarketId
     const approval: TransactionData = {
       to: mockAsset.address[130],
       value: 0n,
       data: '0xapproval' as const,
     }
-    const openPosition: TransactionData = {
+    const position: TransactionData = {
       to: marketId.address,
       value: 0n,
       data: '0xdeposit' as const,
@@ -199,8 +238,7 @@ describe('WalletLendNamespace', () => {
       marketId: marketId.address,
       apy: 0.05,
       timestamp: Date.now(),
-      transactionData: { approval, openPosition },
-      slippage: 50,
+      transactionData: { approval, position },
     }
 
     vi.mocked(mockProvider.openPosition).mockResolvedValue(mockTransaction)
@@ -211,10 +249,7 @@ describe('WalletLendNamespace', () => {
       marketId,
     })
 
-    expect(mockWallet.sendBatch).toHaveBeenCalledWith(
-      [approval, openPosition],
-      130,
-    )
+    expect(mockWallet.sendBatch).toHaveBeenCalledWith([approval, position], 130)
     expect(result).toEqual({
       receipt: { success: true },
       userOpHash: '0xmockbatchhash',