@eth-optimism/actions-sdk 0.0.3 → 0.1.0

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

@@ -3,11 +3,7 @@ import { describe, expect, it } from 'vitest'
 
 import { MockUSDCAsset } from '@/test/MockAssets.js'
 import { MockLendProvider } from '@/test/MockLendProvider.js'
-import type {
-  LendConfig,
-  LendMarketConfig,
-  LendMarketId,
-} from '@/types/lend/index.js'
+import type { LendMarketConfig, LendMarketId } from '@/types/lend/index.js'
 
 // Test helper class that exposes protected validation methods as public
 class TestLendProvider extends MockLendProvider {
@@ -27,33 +23,11 @@ class TestLendProvider extends MockLendProvider {
 describe('LendProvider', () => {
   describe('constructor and configuration', () => {
     it('should initialize with basic config', () => {
-      const config: LendConfig = {
-        provider: 'morpho',
-        defaultSlippage: 100,
-      }
-
-      const provider = new MockLendProvider(config)
+      const provider = new MockLendProvider()
       expect(provider).toBeDefined()
       expect(provider.supportedChainIds()).toContain(84532)
     })
 
-    it('should use default slippage when not provided', () => {
-      const config: LendConfig = { provider: 'morpho' }
-      const provider = new MockLendProvider(config)
-
-      expect(provider.config.defaultSlippage || 50).toBe(50)
-    })
-
-    it('should use custom default slippage when provided', () => {
-      const config: LendConfig = {
-        provider: 'morpho',
-        defaultSlippage: 200,
-      }
-      const provider = new MockLendProvider(config)
-
-      expect(provider.config.defaultSlippage).toBe(200)
-    })
-
     it('should store market allowlist when provided', () => {
       const mockMarket: LendMarketConfig = {
         address: '0x1234' as Address,
@@ -71,19 +45,16 @@ describe('LendProvider', () => {
         lendProvider: 'morpho',
       }
 
-      const config: LendConfig = {
-        provider: 'morpho',
+      const provider = new MockLendProvider({
         marketAllowlist: [mockMarket],
-      }
-
-      const provider = new MockLendProvider(config)
+      })
       expect(provider.config.marketAllowlist).toEqual([mockMarket])
     })
   })
 
   describe('abstract methods implementation', () => {
     it('should implement getMarket method', async () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       const marketId: LendMarketId = {
         address: '0x1234' as Address,
         chainId: 84532,
@@ -96,7 +67,7 @@ describe('LendProvider', () => {
     })
 
     it('should accept LendMarketConfig and extract address/chainId', async () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       const mockMarket: LendMarketConfig = {
         address: '0x5678' as Address,
         chainId: 84532,
@@ -112,7 +83,7 @@ describe('LendProvider', () => {
     })
 
     it('should implement getMarkets method', async () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       const markets = await provider.getMarkets()
 
       expect(Array.isArray(markets)).toBe(true)
@@ -121,7 +92,7 @@ describe('LendProvider', () => {
     })
 
     it('should accept optional filter parameters for getMarkets', async () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       const markets = await provider.getMarkets({ chainId: 84532 })
 
       expect(Array.isArray(markets)).toBe(true)
@@ -129,7 +100,7 @@ describe('LendProvider', () => {
     })
 
     it('should accept asset filtering parameter', async () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       const mockAsset = {
         metadata: { symbol: 'USDC', name: 'USD Coin' },
         address: { 84532: '0x123' as Address },
@@ -140,7 +111,7 @@ describe('LendProvider', () => {
     })
 
     it('should implement getPosition method', async () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       const position = await provider.getPosition('0x5678' as Address, {
         address: '0x1234' as Address,
         chainId: 84532 as const,
@@ -152,7 +123,7 @@ describe('LendProvider', () => {
     })
 
     it('should implement closePosition method', async () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       const result = await provider.closePosition({
         amount: 100,
         marketId: { address: '0x1234' as Address, chainId: 84532 as const },
@@ -165,7 +136,7 @@ describe('LendProvider', () => {
     })
 
     it('should implement withdraw method', async () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       const result = await provider.withdraw(
         '0x0000000000000000000000000000000000000001' as Address,
         500n,
@@ -178,7 +149,7 @@ describe('LendProvider', () => {
     })
 
     it('should implement openPosition method', async () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       const mockAsset = {
         address: { 84532: '0x123' as Address },
         metadata: { symbol: 'USDC', name: 'USD Coin', decimals: 6 },
@@ -201,7 +172,7 @@ describe('LendProvider', () => {
 
   describe('supportedChainIds', () => {
     it('should return array of supported chain IDs', () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       const chainIds = provider.supportedChainIds()
 
       expect(Array.isArray(chainIds)).toBe(true)
@@ -212,7 +183,7 @@ describe('LendProvider', () => {
 
   describe('validation', () => {
     it('should call validation for unsupported chainId', () => {
-      const provider = new TestLendProvider({ provider: 'morpho' })
+      const provider = new TestLendProvider()
 
       expect(() => {
         provider.validateProviderSupported(999)
@@ -233,7 +204,6 @@ describe('LendProvider', () => {
       }
 
       const provider = new TestLendProvider({
-        provider: 'morpho',
         marketAllowlist: [allowedMarket],
       })
 
@@ -253,7 +223,7 @@ describe('LendProvider', () => {
     })
 
     it('should validate chain support correctly', () => {
-      const provider = new TestLendProvider({ provider: 'morpho' })
+      const provider = new TestLendProvider()
 
       expect(provider.isChainSupported(84532)).toBe(true)
       expect(provider.isChainSupported(999)).toBe(false)
@@ -261,16 +231,6 @@ describe('LendProvider', () => {
   })
 
   describe('public getters', () => {
-    it('should provide access to defaultSlippage via getter', () => {
-      const config: LendConfig = {
-        provider: 'morpho',
-        defaultSlippage: 75,
-      }
-      const provider = new MockLendProvider(config)
-
-      expect(provider.config.defaultSlippage).toBe(75)
-    })
-
     it('should provide access to marketAllowlist via getter', () => {
       const mockMarket: LendMarketConfig = {
         address: '0xabc' as Address,
@@ -288,17 +248,15 @@ describe('LendProvider', () => {
         lendProvider: 'morpho',
       }
 
-      const config: LendConfig = {
-        provider: 'morpho',
+      const provider = new MockLendProvider({
         marketAllowlist: [mockMarket],
-      }
-      const provider = new MockLendProvider(config)
+      })
 
       expect(provider.config.marketAllowlist).toEqual([mockMarket])
     })
 
     it('should return undefined for marketAllowlist when not provided', () => {
-      const provider = new MockLendProvider({ provider: 'morpho' })
+      const provider = new MockLendProvider()
       expect(provider.config.marketAllowlist).toBeUndefined()
     })
   })

package/src/lend/index.ts

@@ -1,2 +1,3 @@
 export { LendProvider } from '@/lend/core/LendProvider.js'
+export { AaveLendProvider } from '@/lend/providers/aave/AaveLendProvider.js'
 export { MorphoLendProvider } from '@/lend/providers/morpho/MorphoLendProvider.js'

package/src/lend/namespaces/ActionsLendNamespace.ts

@@ -1,26 +1,90 @@
 import type { LendProvider } from '@/lend/core/LendProvider.js'
-import type { BaseLendConfig, LendConfig } from '@/types/lend/index.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'
 
 /**
  * Actions Lend Namespace
  * @description Read-only lending operations available on actions.lend
  */
-export class ActionsLendNamespace<TConfig extends BaseLendConfig = LendConfig> {
-  constructor(protected readonly provider: LendProvider<TConfig>) {}
+export class ActionsLendNamespace {
+  constructor(
+    protected readonly providers: {
+      morpho?: LendProvider<LendProviderConfig>
+      aave?: LendProvider<LendProviderConfig>
+    },
+  ) {}
 
-  get config(): TConfig {
-    return this.provider.config
+  /**
+   * 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}`,
+    )
   }
 
-  // Bind to the LendProvider's methods and carry types
+  /**
+   * 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>
 
-  getMarkets = (...args: Parameters<LendProvider<TConfig>['getMarkets']>) =>
-    this.provider.getMarkets(...args)
+    const results = await Promise.all(
+      allProviders.map((p) => p.getMarkets(params)),
+    )
 
-  getMarket = (...args: Parameters<LendProvider<TConfig>['getMarket']>) =>
-    this.provider.getMarket(...args)
+    return results.flat()
+  }
 
-  supportedChainIds = (
-    ...args: Parameters<LendProvider<TConfig>['supportedChainIds']>
-  ) => this.provider.supportedChainIds(...args)
+  /**
+   * 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)]
+  }
 }

package/src/lend/namespaces/WalletLendNamespace.ts

@@ -1,8 +1,14 @@
 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 {
-  BaseLendConfig,
   ClosePositionParams,
+  GetLendMarketParams,
+  GetLendMarketsParams,
   GetPositionParams,
+  LendMarket,
+  LendMarketId,
   LendMarketPosition,
   LendOpenPositionParams,
   LendTransactionReceipt,
@@ -13,37 +19,99 @@ import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
  * Wallet Lend Namespace
  * @description Full lending operations available on wallet.lend
  */
-export class WalletLendNamespace<
-  TConfig extends BaseLendConfig = BaseLendConfig,
-> {
+export class WalletLendNamespace {
   constructor(
-    protected readonly provider: LendProvider<TConfig>,
+    protected readonly providers: {
+      morpho?: LendProvider<LendProviderConfig>
+      aave?: LendProvider<LendProviderConfig>
+    },
     private readonly wallet: Wallet,
   ) {}
 
-  get config(): TConfig {
-    return this.provider.config
+  /**
+   * 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}`,
+    )
   }
 
-  // Inherited methods from ActionsLendNamespace
-  getMarkets = (...args: Parameters<LendProvider<TConfig>['getMarkets']>) =>
-    this.provider.getMarkets(...args)
+  /**
+   * 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)),
+    )
 
-  getMarket = (...args: Parameters<LendProvider<TConfig>['getMarket']>) =>
-    this.provider.getMarket(...args)
+    return results.flat()
+  }
 
-  supportedChainIds = (
-    ...args: Parameters<LendProvider<TConfig>['supportedChainIds']>
-  ) => this.provider.supportedChainIds(...args)
+  /**
+   * 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)]
+  }
 
   /**
    * Open a lending position
    * @description Signs and sends a lend transaction from the wallet for the given amount and asset
+   * @param params - Lending position parameters
+   * @param params.marketId - Market identifier to open position in
+   * @param params.amount - Amount to lend
+   * @returns Promise resolving to transaction receipt
    */
   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,
     })
@@ -77,7 +145,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,
@@ -86,13 +160,17 @@ export class WalletLendNamespace<
 
   /**
    * Close a lending position (withdraw from market)
-   * @param closePositionParams - Position closing parameters
-   * @returns Promise resolving to transaction hash
+   * @param params - Position closing parameters
+   * @param params.marketId - Market identifier to close position in
+   * @param params.amount - Amount to withdraw
+   * @returns Promise resolving to transaction receipt
    */
   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,
     })
@@ -104,6 +182,14 @@ export class WalletLendNamespace<
       )
     }
 
+    // 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,
+      )
+    }
+
     if (!transactionData.closePosition) {
       throw new Error('No closePosition transaction data returned')
     }

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

@@ -7,19 +7,36 @@ import type { LendProvider } from '@/types/lend/index.js'
 
 describe('ActionsLendNamespace', () => {
   let mockProvider: LendProvider
+  let mockMarketId: { address: any; 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 as any })
 
     expect(namespace).toBeInstanceOf(ActionsLendNamespace)
   })
 
   it('should delegate getMarkets to provider', async () => {
-    const namespace = new ActionsLendNamespace(mockProvider)
+    const namespace = new ActionsLendNamespace({ morpho: mockProvider as any })
     const spy = vi.spyOn(mockProvider, 'getMarkets')
 
     await namespace.getMarkets()
@@ -28,31 +45,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 as any })
     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 as any })
     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)
-  })
 })