@eth-optimism/actions-sdk 0.0.4 → 0.2.0

package/src/index.ts

@@ -1,5 +1,5 @@
 export type { Actions } from '@/actions.js'
-export { ETH } from '@/constants/assets.js'
+export { ETH, MORPHO, USDC, USDC_DEMO, WETH } from '@/constants/assets.js'
 export type { SupportedChainId } from '@/constants/supportedChains.js'
 export * from '@/core/error/errors.js'
 export { LendProvider, MorphoLendProvider } from '@/lend/index.js'
@@ -12,7 +12,6 @@ export type {
   ActionsConfig,
   ApyBreakdown,
   Asset,
-  BaseLendConfig,
   EOATransactionReceipt,
   LendConfig,
   LendMarket,
@@ -22,9 +21,9 @@ export type {
   LendMarketPosition,
   LendMarketSupply,
   LendOptions,
+  LendProviderConfig,
   LendTransaction,
   LendTransactionReceipt,
-  MorphoLendConfig,
   TokenBalance,
   TransactionData,
   UserOperationTransactionReceipt,

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

@@ -2,6 +2,9 @@ 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 {
   ClosePositionParams,
@@ -9,13 +12,11 @@ import type {
   GetLendMarketsParams,
   GetMarketBalanceParams,
   LendClosePositionParams,
-  LendConfig,
   LendMarket,
   LendMarketId,
   LendMarketPosition,
   LendOpenPositionInternalParams,
   LendOpenPositionParams,
-  LendOptions,
   LendTransaction,
 } from '@/types/lend/index.js'
 
@@ -29,7 +30,7 @@ export interface MockLendProviderConfig {
  * Mock Lend Provider for testing
  * @description Provides a mock implementation of LendProvider following MockChainManager pattern
  */
-export class MockLendProvider extends LendProvider<LendConfig> {
+export class MockLendProvider extends LendProvider<LendProviderConfig> {
   public openPosition: MockedFunction<
     (params: LendOpenPositionParams) => Promise<LendTransaction>
   >
@@ -55,7 +56,6 @@ export class MockLendProvider extends LendProvider<LendConfig> {
       amount: bigint,
       chainId: number,
       marketId?: string,
-      options?: LendOptions,
     ) => Promise<LendTransaction>
   >
 
@@ -71,10 +71,14 @@ export class MockLendProvider extends LendProvider<LendConfig> {
   private mockConfig: MockLendProviderConfig
 
   constructor(
-    config?: LendConfig,
+    config?: LendProviderConfig,
     mockConfig?: Partial<MockLendProviderConfig>,
+    chainManager?: ChainManager,
   ) {
-    super(config || { provider: 'morpho' })
+    super(
+      config || {},
+      chainManager || (new MockChainManager() as unknown as ChainManager),
+    )
 
     this.mockConfig = {
       supportedChains: mockConfig?.supportedChains ?? [84532],
@@ -187,7 +191,7 @@ export class MockLendProvider extends LendProvider<LendConfig> {
     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<LendConfig> {
       params.amount,
       params.marketId.chainId,
       params.marketId.address,
-      params.options,
     )
   }
 
@@ -204,11 +207,10 @@ export class MockLendProvider extends LendProvider<LendConfig> {
     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<LendConfig> {
       asset: assetAddress,
       marketId: marketId.address,
       apy: this.mockConfig.defaultApy,
-      slippage: options?.slippage || this._config.defaultSlippage || 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<LendConfig> {
     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<LendConfig> {
       asset: assetAddress,
       marketId: marketId.address,
       apy: this.mockConfig.defaultApy,
-      slippage: options?.slippage || this._config.defaultSlippage || 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<LendConfig> {
     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 || this._config.defaultSlippage || 50,
       transactionData: {
-        closePosition: {
+        position: {
           to: marketId.address,
           data: '0xb460af94' as Address,
           value: 0n,
@@ -361,18 +360,16 @@ export class MockLendProvider extends LendProvider<LendConfig> {
   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 || this._config.defaultSlippage || 50,
       transactionData: {
-        closePosition: {
+        position: {
           to:
             (marketId as Address) ||
             ('0x1234567890123456789012345678901234567890' as Address),
@@ -390,7 +387,7 @@ export class MockLendProvider extends LendProvider<LendConfig> {
  * @returns MockLendProvider instance
  */
 export function createMockLendProvider(
-  config?: LendConfig,
+  config?: LendProviderConfig,
   mockConfig?: Partial<MockLendProviderConfig>,
 ): MockLendProvider {
   return new MockLendProvider(config, mockConfig)

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,10 +1,11 @@
 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 {
-  BaseLendConfig,
   ClosePositionParams,
   GetLendMarketParams,
   GetLendMarketsParams,
@@ -17,6 +18,7 @@ import type {
   LendOpenPositionInternalParams,
   LendOpenPositionParams,
   LendTransaction,
+  TransactionData,
 } from '@/types/lend/index.js'
 import { validateMarketAsset } from '@/utils/markets.js'
 
@@ -25,11 +27,14 @@ import { validateMarketAsset } from '@/utils/markets.js'
  * @description Base class for lending provider implementations
  */
 export abstract class LendProvider<
-  TConfig extends BaseLendConfig = BaseLendConfig,
+  TConfig extends LendProviderConfig = LendProviderConfig,
 > {
   /** 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 +44,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 {
@@ -237,7 +244,7 @@ export abstract class LendProvider<
     }
 
     const foundMarket = this._config.marketAllowlist.find(
-      (allowedMarket) =>
+      (allowedMarket: LendMarketConfig) =>
         allowedMarket.address.toLowerCase() ===
           marketId.address.toLowerCase() &&
         allowedMarket.chainId === marketId.chainId,
@@ -262,11 +269,37 @@ export abstract class LendProvider<
   ): LendMarketConfig[] {
     let configs = this._config.marketAllowlist || []
     if (chainId !== undefined)
-      configs = configs.filter((m) => m.chainId === chainId)
-    if (asset !== undefined) configs = configs.filter((m) => m.asset === asset)
+      configs = configs.filter((m: LendMarketConfig) => m.chainId === chainId)
+    if (asset !== undefined)
+      configs = configs.filter((m: LendMarketConfig) => m.asset === asset)
     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,13 +1,9 @@
 import type { Address } from 'viem'
 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 { 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
 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,7 @@
-import type { LendProvider } from '@/lend/core/LendProvider.js'
-import type { BaseLendConfig, LendConfig } 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<TConfig extends BaseLendConfig = LendConfig> {
-  constructor(protected readonly provider: LendProvider<TConfig>) {}
-
-  get config(): TConfig {
-    return this.provider.config
-  }
-
-  // Bind to the LendProvider's methods and carry types
-
-  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)
-}
+export class ActionsLendNamespace extends BaseLendNamespace {}