@eth-optimism/actions-sdk 0.1.0 → 0.3.0

package/src/{test → lend/__mocks__}/MockLendProvider.ts

@@ -2,6 +2,8 @@ import type { Address } from 'viem'
 import { type MockedFunction, vi } from 'vitest'
 
 import { LendProvider } from '@/lend/core/LendProvider.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 } from '@/types/asset.js'
 import type {
@@ -15,7 +17,6 @@ import type {
   LendMarketPosition,
   LendOpenPositionInternalParams,
   LendOpenPositionParams,
-  LendOptions,
   LendTransaction,
 } from '@/types/lend/index.js'
 
@@ -55,7 +56,6 @@ export class MockLendProvider extends LendProvider<LendProviderConfig> {
       amount: bigint,
       chainId: number,
       marketId?: string,
-      options?: LendOptions,
     ) => Promise<LendTransaction>
   >
 
@@ -73,8 +73,12 @@ export class MockLendProvider extends LendProvider<LendProviderConfig> {
   constructor(
     config?: LendProviderConfig,
     mockConfig?: Partial<MockLendProviderConfig>,
+    chainManager?: ChainManager,
   ) {
-    super(config || {})
+    super(
+      config || {},
+      chainManager || (new MockChainManager() as unknown as ChainManager),
+    )
 
     this.mockConfig = {
       supportedChains: mockConfig?.supportedChains ?? [84532],
@@ -187,7 +191,7 @@ export class MockLendProvider extends LendProvider<LendProviderConfig> {
     params: LendClosePositionParams,
   ): Promise<LendTransaction> {
     const assetAddress = params.asset?.address[params.marketId.chainId]
-    if (!assetAddress) {
+    if (!assetAddress || assetAddress === 'native') {
       throw new Error(`Asset not supported on chain ${params.marketId.chainId}`)
     }
 
@@ -196,7 +200,6 @@ export class MockLendProvider extends LendProvider<LendProviderConfig> {
       params.amount,
       params.marketId.chainId,
       params.marketId.address,
-      params.options,
     )
   }
 
@@ -204,11 +207,10 @@ export class MockLendProvider extends LendProvider<LendProviderConfig> {
     amount,
     asset,
     marketId,
-    options,
   }: LendOpenPositionParams): Promise<LendTransaction> {
     // Get asset address for the chain
     const assetAddress = asset.address[marketId.chainId]
-    if (!assetAddress) {
+    if (!assetAddress || assetAddress === 'native') {
       throw new Error(`Asset not supported on chain ${marketId.chainId}`)
     }
 
@@ -220,14 +222,13 @@ export class MockLendProvider extends LendProvider<LendProviderConfig> {
       asset: assetAddress,
       marketId: marketId.address,
       apy: this.mockConfig.defaultApy,
-      slippage: options?.slippage ?? 50,
       transactionData: {
         approval: {
           to: assetAddress,
           data: '0x095ea7b3' as Address,
           value: 0n,
         },
-        openPosition: {
+        position: {
           to: marketId.address,
           data: '0x6e553f65' as Address,
           value: 0n,
@@ -240,11 +241,10 @@ export class MockLendProvider extends LendProvider<LendProviderConfig> {
     amountWei,
     asset,
     marketId,
-    options,
   }: LendOpenPositionInternalParams): Promise<LendTransaction> {
     // Get asset address for the chain
     const assetAddress = asset.address[marketId.chainId]
-    if (!assetAddress) {
+    if (!assetAddress || assetAddress === 'native') {
       throw new Error(`Asset not supported on chain ${marketId.chainId}`)
     }
 
@@ -253,14 +253,13 @@ export class MockLendProvider extends LendProvider<LendProviderConfig> {
       asset: assetAddress,
       marketId: marketId.address,
       apy: this.mockConfig.defaultApy,
-      slippage: options?.slippage ?? 50,
       transactionData: {
         approval: {
           to: assetAddress,
           data: '0x095ea7b3' as Address,
           value: 0n,
         },
-        openPosition: {
+        position: {
           to: marketId.address,
           data: '0x6e553f65' as Address,
           value: 0n,
@@ -335,21 +334,21 @@ export class MockLendProvider extends LendProvider<LendProviderConfig> {
     amount,
     asset,
     marketId,
-    options,
   }: ClosePositionParams): Promise<LendTransaction> {
     // If asset provided, use its address for the chain; otherwise use a mock asset
-    const assetAddress =
-      asset?.address[marketId.chainId] ||
-      ('0x1234567890123456789012345678901234567890' as Address)
+    const rawAddress = asset?.address[marketId.chainId]
+    const assetAddress: Address =
+      rawAddress && rawAddress !== 'native'
+        ? rawAddress
+        : ('0x1234567890123456789012345678901234567890' as Address)
 
     return {
       amount: BigInt(amount),
       asset: assetAddress,
       marketId: marketId.address,
       apy: 0,
-      slippage: options?.slippage ?? 50,
       transactionData: {
-        closePosition: {
+        position: {
           to: marketId.address,
           data: '0xb460af94' as Address,
           value: 0n,
@@ -361,18 +360,16 @@ export class MockLendProvider extends LendProvider<LendProviderConfig> {
   private async createMockWithdraw(
     asset: Address,
     amount: bigint,
-    chainId: number,
+    _chainId: number,
     marketId?: string,
-    options?: LendOptions,
   ): Promise<LendTransaction> {
     return {
       amount,
       asset,
       marketId: marketId || 'mock-market',
       apy: 0,
-      slippage: options?.slippage ?? 50,
       transactionData: {
-        closePosition: {
+        position: {
           to:
             (marketId as Address) ||
             ('0x1234567890123456789012345678901234567890' as Address),

package/src/{test → lend/__mocks__}/MockMarkets.ts

@@ -1,6 +1,6 @@
 import type { Address } from 'viem'
 
-import { MockUSDCAsset, MockWETHAsset } from '@/test/MockAssets.js'
+import { MockUSDCAsset, MockWETHAsset } from '@/__mocks__/MockAssets.js'
 import type { LendMarketConfig } from '@/types/lend/index.js'
 
 /**

package/src/lend/__mocks__/mockLendTransaction.ts

@@ -3,14 +3,14 @@ import type { Address } from 'viem'
 import type { LendTransaction, TransactionData } from '@/types/lend/index.js'
 
 /**
- * Creates a mock lend transaction for testing openPosition
+ * Creates a mock lend transaction for testing
  */
-export function createMockOpenTransaction(params: {
+export function createMockLendTransaction(params: {
   amount: bigint
   asset: Address
   marketId: Address
   approval?: TransactionData
-  openPosition?: TransactionData
+  position: TransactionData
 }): LendTransaction {
   return {
     amount: params.amount,
@@ -19,29 +19,7 @@ export function createMockOpenTransaction(params: {
     apy: 0.05,
     transactionData: {
       approval: params.approval,
-      openPosition: params.openPosition,
+      position: params.position,
     },
-    slippage: 50,
-  }
-}
-
-/**
- * Creates a mock lend transaction for testing closePosition
- */
-export function createMockCloseTransaction(params: {
-  amount: bigint
-  asset: Address
-  marketId: Address
-  closePosition: TransactionData
-}): LendTransaction {
-  return {
-    amount: params.amount,
-    asset: params.asset,
-    marketId: params.marketId,
-    apy: 0.05,
-    transactionData: {
-      closePosition: params.closePosition,
-    },
-    slippage: 50,
   }
 }

package/src/lend/core/LendProvider.ts

@@ -1,7 +1,8 @@
 import type { Address } from 'viem'
-import { parseUnits } from 'viem'
+import { encodeFunctionData, erc20Abi, parseUnits } from 'viem'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { ChainManager } from '@/services/ChainManager.js'
 import type { LendProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type {
@@ -17,8 +18,10 @@ import type {
   LendOpenPositionInternalParams,
   LendOpenPositionParams,
   LendTransaction,
+  TransactionData,
 } from '@/types/lend/index.js'
 import { validateMarketAsset } from '@/utils/markets.js'
+import { validateChainSupported } from '@/utils/validation.js'
 
 /**
  * Lending provider abstract class
@@ -30,6 +33,9 @@ export abstract class LendProvider<
   /** Lending provider configuration */
   protected readonly _config: TConfig
 
+  /** Chain manager for blockchain interactions */
+  protected readonly chainManager: ChainManager
+
   /**
    * Supported chain IDs
    * @description Array of chain IDs that this provider supports
@@ -39,9 +45,11 @@ export abstract class LendProvider<
   /**
    * Create a new lending provider
    * @param config - Provider-specific lending configuration
+   * @param chainManager - Chain manager for blockchain interactions
    */
-  protected constructor(config: TConfig) {
+  protected constructor(config: TConfig, chainManager: ChainManager) {
     this._config = config
+    this.chainManager = chainManager
   }
 
   public get config(): TConfig {
@@ -70,7 +78,7 @@ export abstract class LendProvider<
       throw new Error('walletAddress is required')
     }
 
-    this.validateProviderSupported(params.marketId.chainId)
+    validateChainSupported(params.marketId.chainId, this.SUPPORTED_CHAIN_IDS)
     this.validateConfigSupported(params.marketId)
 
     // Convert human-readable amount to wei using the asset's decimals
@@ -98,7 +106,7 @@ export abstract class LendProvider<
       chainId: params.chainId,
     }
 
-    this.validateProviderSupported(params.chainId)
+    validateChainSupported(params.chainId, this.SUPPORTED_CHAIN_IDS)
     this.validateConfigSupported(marketId)
     return this._getMarket(marketId)
   }
@@ -110,7 +118,7 @@ export abstract class LendProvider<
    */
   async getMarkets(params: GetLendMarketsParams = {}): Promise<LendMarket[]> {
     if (params.chainId !== undefined)
-      this.validateProviderSupported(params.chainId)
+      validateChainSupported(params.chainId, this.SUPPORTED_CHAIN_IDS)
 
     const filteredMarkets = this.filterMarketConfigs(
       params.chainId,
@@ -149,7 +157,7 @@ export abstract class LendProvider<
       )
     }
 
-    this.validateProviderSupported(marketId.chainId)
+    validateChainSupported(marketId.chainId, this.SUPPORTED_CHAIN_IDS)
     this.validateConfigSupported(marketId)
 
     return this._getPosition({ marketId, walletAddress })
@@ -169,7 +177,7 @@ export abstract class LendProvider<
       throw new Error('walletAddress is required')
     }
 
-    this.validateProviderSupported(params.marketId.chainId)
+    validateChainSupported(params.marketId.chainId, this.SUPPORTED_CHAIN_IDS)
     this.validateConfigSupported(params.marketId)
 
     const market = await this.getMarket({
@@ -210,19 +218,6 @@ export abstract class LendProvider<
     return this.SUPPORTED_CHAIN_IDS.includes(chainId)
   }
 
-  /**
-   * Validate that a chainId is supported for lending operations
-   * @param chainId - Chain ID to validate
-   * @throws Error if chain is not supported
-   */
-  protected validateProviderSupported(chainId: number): void {
-    if (!this.isChainSupported(chainId)) {
-      throw new Error(
-        `Chain ${chainId} is not supported. Supported chains: ${this.SUPPORTED_CHAIN_IDS.join(', ')}`,
-      )
-    }
-  }
-
   /**
    * Validate that a market is in the config's market allowlist
    * @param marketId - Market identifier containing address and chainId
@@ -268,6 +263,31 @@ export abstract class LendProvider<
     return configs
   }
 
+  /**
+   * Build an ERC20 approval transaction
+   * @param tokenAddress - Address of the token to approve
+   * @param spender - Address to approve spending for
+   * @param amount - Amount to approve
+   * @returns Transaction data for the approval
+   */
+  protected buildApprovalTx(
+    tokenAddress: Address,
+    spender: Address,
+    amount: bigint,
+  ): TransactionData {
+    const approvalCallData = encodeFunctionData({
+      abi: erc20Abi,
+      functionName: 'approve',
+      args: [spender, amount],
+    })
+
+    return {
+      to: tokenAddress,
+      data: approvalCallData,
+      value: 0n,
+    }
+  }
+
   /**
    * Abstract methods that must be implemented by providers
    */

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

@@ -1,16 +1,13 @@
 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'
+import { validateChainSupported } from '@/utils/validation.js'
 
 // Test helper class that exposes protected validation methods as public
 class TestLendProvider extends MockLendProvider {
-  public validateProviderSupported(chainId: number): void {
-    return super.validateProviderSupported(chainId)
-  }
-
   public validateConfigSupported(marketId: LendMarketId): void {
     return super.validateConfigSupported(marketId)
   }
@@ -186,7 +183,7 @@ describe('LendProvider', () => {
       const provider = new TestLendProvider()
 
       expect(() => {
-        provider.validateProviderSupported(999)
+        validateChainSupported(999, provider.supportedChainIds())
       }).toThrow('Chain 999 is not supported')
     })
 

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