@eth-optimism/actions-sdk 0.1.0 → 0.2.0

package/src/lend/core/__tests__/LendProvider.test.ts

@@ -1,8 +1,8 @@
 import type { Address } from 'viem'
 import { describe, expect, it } from 'vitest'
 
-import { MockUSDCAsset } from '@/test/MockAssets.js'
-import { MockLendProvider } from '@/test/MockLendProvider.js'
+import { MockUSDCAsset } from '@/__mocks__/MockAssets.js'
+import { MockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
 import type { LendMarketConfig, LendMarketId } from '@/types/lend/index.js'
 
 // Test helper class that exposes protected validation methods as public

package/src/lend/namespaces/ActionsLendNamespace.ts

@@ -1,90 +1,7 @@
-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'
+import { BaseLendNamespace } from './BaseLendNamespace.js'
 
 /**
  * Actions Lend Namespace
  * @description Read-only lending operations available on actions.lend
  */
-export class ActionsLendNamespace {
-  constructor(
-    protected readonly providers: {
-      morpho?: LendProvider<LendProviderConfig>
-      aave?: LendProvider<LendProviderConfig>
-    },
-  ) {}
-
-  /**
-   * 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)]
-  }
-}
+export class ActionsLendNamespace extends BaseLendNamespace {}

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,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)
+    })
+  })
+})