@eth-optimism/actions-sdk 0.1.0 → 0.3.0

package/src/lend/namespaces/WalletLendNamespace.ts

@@ -1,101 +1,26 @@
-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 { SupportedChainId } from '@/constants/supportedChains.js'
 import type {
   ClosePositionParams,
-  GetLendMarketParams,
-  GetLendMarketsParams,
   GetPositionParams,
-  LendMarket,
-  LendMarketId,
   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 {
+export class WalletLendNamespace extends BaseLendNamespace {
   constructor(
-    protected readonly providers: {
-      morpho?: LendProvider<LendProviderConfig>
-      aave?: LendProvider<LendProviderConfig>
-    },
+    providers: LendProviders,
     private readonly wallet: Wallet,
-  ) {}
-
-  /**
-   * 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
-   */
-  private getProviderForMarket(
-    marketId: LendMarketId,
-  ): MorphoLendProvider | AaveLendProvider {
-    const allProviders = [this.providers.morpho, this.providers.aave].filter(
-      Boolean,
-    ) as Array<MorphoLendProvider | AaveLendProvider>
-
-    for (const provider of allProviders) {
-      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}`,
-    )
-  }
-
-  /**
-   * 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 allProviders = [this.providers.morpho, this.providers.aave].filter(
-      Boolean,
-    ) as Array<MorphoLendProvider | AaveLendProvider>
-
-    const results = await Promise.all(
-      allProviders.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 allProviders = [this.providers.morpho, this.providers.aave].filter(
-      Boolean,
-    ) as Array<MorphoLendProvider | AaveLendProvider>
-
-    const allChains = allProviders.flatMap((p) => p.supportedChainIds())
-    return [...new Set(allChains)]
+  ) {
+    super(providers)
   }
 
   /**
@@ -116,25 +41,7 @@ export class WalletLendNamespace {
       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)
   }
 
   /**
@@ -175,28 +82,25 @@ export class WalletLendNamespace {
       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 both approval and closePosition are present, batch them
-    if (transactionData.approval && transactionData.closePosition) {
-      return await this.wallet.sendBatch(
-        [transactionData.approval, transactionData.closePosition],
-        params.marketId.chainId,
-      )
-    }
+  /**
+   * Execute a lend transaction with optional approval batching
+   */
+  private async executeTransaction(
+    transaction: LendTransaction,
+    chainId: SupportedChainId,
+  ): Promise<LendTransactionReceipt> {
+    const { transactionData } = transaction
 
-    if (!transactionData.closePosition) {
-      throw new Error('No closePosition transaction data returned')
+    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,13 +1,14 @@
+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 mockMarketId: { address: any; chainId: 130 }
+  let mockProvider: MockLendProvider
+  let mockMarketId: { address: Address; chainId: 130 }
 
   beforeEach(() => {
     mockMarketId = { address: getRandomAddress(), chainId: 130 as const }
@@ -30,13 +31,13 @@ describe('ActionsLendNamespace', () => {
   })
 
   it('should create an instance with a lend provider', () => {
-    const namespace = new ActionsLendNamespace({ morpho: mockProvider as any })
+    const namespace = new ActionsLendNamespace({ morpho: mockProvider })
 
     expect(namespace).toBeInstanceOf(ActionsLendNamespace)
   })
 
   it('should delegate getMarkets to provider', async () => {
-    const namespace = new ActionsLendNamespace({ morpho: mockProvider as any })
+    const namespace = new ActionsLendNamespace({ morpho: mockProvider })
     const spy = vi.spyOn(mockProvider, 'getMarkets')
 
     await namespace.getMarkets()
@@ -45,7 +46,7 @@ describe('ActionsLendNamespace', () => {
   })
 
   it('should delegate getMarket to provider with correct parameters', async () => {
-    const namespace = new ActionsLendNamespace({ morpho: mockProvider as any })
+    const namespace = new ActionsLendNamespace({ morpho: mockProvider })
     const spy = vi.spyOn(mockProvider, 'getMarket')
 
     await namespace.getMarket(mockMarketId)
@@ -54,7 +55,7 @@ describe('ActionsLendNamespace', () => {
   })
 
   it('should delegate supportedChainIds to provider', () => {
-    const namespace = new ActionsLendNamespace({ morpho: mockProvider as any })
+    const namespace = new ActionsLendNamespace({ morpho: mockProvider })
     const spy = vi.spyOn(mockProvider, 'supportedChainIds')
 
     namespace.supportedChainIds()

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,18 +1,20 @@
+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: any; chainId: 130 }
+  let mockMarketId: { address: Address; chainId: 130 }
 
   beforeEach(() => {
     // Create a consistent market ID for all tests
@@ -53,7 +55,7 @@ describe('WalletLendNamespace', () => {
 
   it('should create an instance with a lend provider and wallet', () => {
     const namespace = new WalletLendNamespace(
-      { morpho: mockProvider as any },
+      { morpho: mockProvider },
       mockWallet,
     )
 
@@ -62,7 +64,7 @@ describe('WalletLendNamespace', () => {
 
   it('should inherit read operations from ActionsLendNamespace', async () => {
     const namespace = new WalletLendNamespace(
-      { morpho: mockProvider as any },
+      { morpho: mockProvider },
       mockWallet,
     )
     const mockMarkets = [
@@ -107,7 +109,7 @@ describe('WalletLendNamespace', () => {
   describe('openPosition', () => {
     it('should call provider openPosition with wallet address as receiver', async () => {
       const namespace = new WalletLendNamespace(
-        { morpho: mockProvider as any },
+        { morpho: mockProvider },
         mockWallet,
       )
       const mockAsset = {
@@ -123,13 +125,12 @@ describe('WalletLendNamespace', () => {
         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)
@@ -158,7 +159,7 @@ describe('WalletLendNamespace', () => {
   describe('closePosition', () => {
     it('should call provider closePosition and execute transaction for SmartWallet', async () => {
       const namespace = new WalletLendNamespace(
-        { morpho: mockProvider as any },
+        { morpho: mockProvider },
         mockWallet,
       )
       const closeParams = {
@@ -172,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,
@@ -190,7 +191,7 @@ describe('WalletLendNamespace', () => {
         options: undefined,
       })
       expect(mockWallet.send).toHaveBeenCalledWith(
-        mockTransaction.transactionData.closePosition,
+        mockTransaction.transactionData.position,
         130,
       )
       expect(result).toEqual({
@@ -202,7 +203,7 @@ describe('WalletLendNamespace', () => {
 
   it('should store the wallet reference', () => {
     const namespace = new WalletLendNamespace(
-      { morpho: mockProvider as any },
+      { morpho: mockProvider },
       mockWallet,
     )
 
@@ -212,7 +213,7 @@ describe('WalletLendNamespace', () => {
 
   it('should execute transaction with approval when present', async () => {
     const namespace = new WalletLendNamespace(
-      { morpho: mockProvider as any },
+      { morpho: mockProvider },
       mockWallet,
     )
     const mockAsset = {
@@ -226,7 +227,7 @@ describe('WalletLendNamespace', () => {
       value: 0n,
       data: '0xapproval' as const,
     }
-    const openPosition: TransactionData = {
+    const position: TransactionData = {
       to: marketId.address,
       value: 0n,
       data: '0xdeposit' as const,
@@ -237,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)
@@ -249,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',