@eth-optimism/actions-sdk 0.0.3 → 0.1.0

package/src/lend/providers/aave/sdk.ts

@@ -0,0 +1,369 @@
+import { UiPoolDataProvider } from '@aave/contract-helpers'
+import { formatReserves } from '@aave/math-utils'
+import { providers } from 'ethers'
+import type { Address } from 'viem'
+import { base, baseSepolia, optimism, optimismSepolia } from 'viem/chains'
+
+import type { SUPPORTED_CHAIN_IDS } from '@/constants/supportedChains.js'
+import { getPoolAddress } from '@/lend/providers/aave/addresses.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { LendProviderConfig } from '@/types/actions.js'
+import type {
+  ApyBreakdown,
+  LendMarket,
+  LendMarketConfig,
+  LendMarketId,
+} from '@/types/lend/index.js'
+import { getAssetAddress } from '@/utils/assets.js'
+
+/**
+ * UI Pool Data Provider addresses for each chain
+ * @description Contract addresses for UiPoolDataProvider on each supported chain
+ */
+const UI_POOL_DATA_PROVIDER_ADDRESSES: Record<number, Address> = {
+  [optimism.id]: '0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654',
+  [base.id]: '0xd82a47fdebB5bf5329b09441C3DaB4b5df2153Ad',
+  [optimismSepolia.id]: '0x86E2938daE289763D4e09a7e42c5cCcA62Cf9809',
+  [baseSepolia.id]: '0xBc9f5b7E248451CdD7cA54e717a2BFe1F32b566b',
+} as const
+
+/**
+ * Pool Addresses Provider addresses for each chain
+ */
+const POOL_ADDRESSES_PROVIDER: Record<number, Address> = {
+  [optimism.id]: '0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb',
+  [base.id]: '0xe20fCBdBfFC4Dd138cE8b2E6FBb6CB49777ad64D',
+  [optimismSepolia.id]: '0x36616cf17557639614c1cdDb356b1B83fc0B2132',
+  [baseSepolia.id]: '0xE4C23309117Aa30342BFaae6c95c6478e0A4Ad00',
+} as const
+
+/**
+ * Parameters for getReserve function
+ */
+interface GetReserveParams {
+  /** Market identifier (asset address and chainId) */
+  marketId: LendMarketId
+  /** Chain manager instance */
+  chainManager: ChainManager
+  /** Lend configuration containing market allowlist */
+  lendConfig?: LendProviderConfig
+}
+
+/**
+ * Parameters for getReserves function
+ */
+interface GetReservesParams {
+  chainManager: ChainManager
+  lendConfig: LendProviderConfig
+  markets: LendMarketConfig[]
+}
+
+/**
+ * Find market configuration in allowlist
+ * @param marketAllowlist - Array of allowed market configurations
+ * @param marketId - Market identifier to find
+ * @returns Market configuration if found, undefined otherwise
+ */
+function findMarketInAllowlist(
+  marketAllowlist: LendMarketConfig[],
+  marketId: LendMarketId,
+): LendMarketConfig | undefined {
+  return marketAllowlist.find(
+    (config) =>
+      config.address.toLowerCase() === marketId.address.toLowerCase() &&
+      config.chainId === marketId.chainId,
+  )
+}
+
+/**
+ * Calculate APY breakdown from reserve data
+ * @param reserve - Formatted reserve data from Aave
+ * @returns APY breakdown with native APY and rewards
+ */
+export function calculateApyBreakdown(reserve: {
+  formattedReserve?: any
+}): ApyBreakdown {
+  // Get supply APY from formatted reserve data
+  const supplyApy = reserve.formattedReserve?.supplyAPY
+    ? parseFloat(reserve.formattedReserve.supplyAPY)
+    : 0
+
+  // Aave doesn't have vault-style performance fees
+  // Total APY = Supply APY + any rewards (to be added later)
+  return {
+    total: supplyApy,
+    native: supplyApy,
+    totalRewards: 0, // TODO: Fetch from incentives data provider if needed
+    performanceFee: 0, // Aave doesn't have performance fees
+  }
+}
+
+/**
+ * Get detailed reserve (market) information from Aave
+ * @param params - Named parameters object
+ * @returns Promise resolving to detailed market information
+ */
+export async function getReserve(
+  params: GetReserveParams,
+): Promise<LendMarket> {
+  // Find market configuration in allowlist for metadata
+  const marketConfig = params.lendConfig?.marketAllowlist
+    ? findMarketInAllowlist(params.lendConfig.marketAllowlist, params.marketId)
+    : undefined
+
+  if (!marketConfig) {
+    throw new Error(
+      `Market ${params.marketId.address} on chain ${params.marketId.chainId} not found in allowlist`,
+    )
+  }
+
+  const poolAddress = getPoolAddress(params.marketId.chainId)
+  if (!poolAddress) {
+    throw new Error(`Aave V3 not deployed on chain ${params.marketId.chainId}`)
+  }
+
+  const uiPoolDataProviderAddress =
+    UI_POOL_DATA_PROVIDER_ADDRESSES[params.marketId.chainId]
+  const poolAddressesProvider = POOL_ADDRESSES_PROVIDER[params.marketId.chainId]
+
+  if (!uiPoolDataProviderAddress || !poolAddressesProvider) {
+    throw new Error(
+      `UiPoolDataProvider not configured for chain ${params.marketId.chainId}`,
+    )
+  }
+
+  try {
+    // Get viem public client for this chain
+    const publicClient = params.chainManager.getPublicClient(
+      params.marketId.chainId,
+    )
+
+    // Create ethers provider from viem's RPC URL
+    // Aave SDK requires ethers provider, not viem
+    const rpcUrl =
+      publicClient.chain?.rpcUrls.default.http[0] ||
+      publicClient.chain?.rpcUrls.public?.http[0]
+    if (!rpcUrl) {
+      throw new Error(
+        `No RPC URL available for chain ${params.marketId.chainId}`,
+      )
+    }
+    const ethersProvider = new providers.JsonRpcProvider(rpcUrl)
+
+    // Create UiPoolDataProvider instance
+    const uiPoolDataProvider = new UiPoolDataProvider({
+      uiPoolDataProviderAddress,
+      provider: ethersProvider,
+      chainId: params.marketId.chainId,
+    })
+
+    // Fetch reserve data
+    const reservesData = await uiPoolDataProvider.getReservesHumanized({
+      lendingPoolAddressProvider: poolAddressesProvider,
+    })
+
+    // Find the specific reserve for this asset
+    const assetAddress = getAssetAddress(
+      marketConfig.asset,
+      params.marketId.chainId,
+    )
+
+    const reserve = reservesData.reservesData.find(
+      (r) => r.underlyingAsset.toLowerCase() === assetAddress.toLowerCase(),
+    )
+
+    if (!reserve) {
+      throw new Error(
+        `Reserve not found for asset ${assetAddress} on chain ${params.marketId.chainId}`,
+      )
+    }
+
+    // Format reserves using Aave math-utils
+    const currentTimestamp = Math.floor(Date.now() / 1000)
+    const formattedReserves = formatReserves({
+      reserves: [reserve],
+      currentTimestamp,
+      marketReferenceCurrencyDecimals:
+        reservesData.baseCurrencyData.marketReferenceCurrencyDecimals,
+      marketReferencePriceInUsd:
+        reservesData.baseCurrencyData.marketReferenceCurrencyPriceInUsd,
+    })
+
+    const formattedReserve = formattedReserves[0]
+
+    // Calculate APY breakdown
+    const apy = calculateApyBreakdown({
+      ...reserve,
+      formattedReserve,
+    })
+
+    // Return market information in our standard format
+    return {
+      marketId: params.marketId,
+      name: marketConfig.name,
+      asset: marketConfig.asset,
+      supply: {
+        totalAssets: BigInt(reserve.availableLiquidity),
+        totalShares: BigInt(reserve.totalScaledVariableDebt || '0'),
+      },
+      apy,
+      metadata: {
+        owner: poolAddress, // Use Pool as owner
+        curator: poolAddress, // No curator in Aave
+        fee: 0, // No performance fee in Aave
+        lastUpdate: currentTimestamp,
+      },
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to get reserve info for ${params.marketId.address}: ${
+        error instanceof Error ? error.message : 'Unknown error'
+      }`,
+    )
+  }
+}
+
+/**
+ * Get multiple reserves (markets)
+ * @param params - Parameters including markets to fetch
+ * @returns Promise resolving to array of market information
+ */
+export async function getReserves(
+  params: GetReservesParams,
+): Promise<LendMarket[]> {
+  try {
+    const reservePromises = params.markets.map((marketConfig) => {
+      return getReserve({
+        marketId: {
+          address: marketConfig.address,
+          chainId: marketConfig.chainId,
+        },
+        chainManager: params.chainManager,
+        lendConfig: params.lendConfig,
+      })
+    })
+
+    return await Promise.all(reservePromises)
+  } catch (error) {
+    throw new Error(
+      `Failed to get reserves: ${
+        error instanceof Error ? error.message : 'Unknown error'
+      }`,
+    )
+  }
+}
+
+/**
+ * Aave V3 Pool ABI for getReserveData
+ * @description Minimal ABI for querying reserve data from Aave V3 Pool
+ */
+const POOL_GET_RESERVE_DATA_ABI = [
+  {
+    inputs: [{ name: 'asset', type: 'address', internalType: 'address' }],
+    name: 'getReserveData',
+    outputs: [
+      {
+        components: [
+          { name: 'data', type: 'uint256', internalType: 'uint256' },
+        ],
+        name: 'configuration',
+        type: 'tuple',
+        internalType: 'struct DataTypes.ReserveConfigurationMap',
+      },
+      { name: 'liquidityIndex', type: 'uint128', internalType: 'uint128' },
+      {
+        name: 'currentLiquidityRate',
+        type: 'uint128',
+        internalType: 'uint128',
+      },
+      { name: 'variableBorrowIndex', type: 'uint128', internalType: 'uint128' },
+      {
+        name: 'currentVariableBorrowRate',
+        type: 'uint128',
+        internalType: 'uint128',
+      },
+      {
+        name: 'currentStableBorrowRate',
+        type: 'uint128',
+        internalType: 'uint128',
+      },
+      { name: 'lastUpdateTimestamp', type: 'uint40', internalType: 'uint40' },
+      { name: 'id', type: 'uint16', internalType: 'uint16' },
+      { name: 'aTokenAddress', type: 'address', internalType: 'address' },
+      {
+        name: 'stableDebtTokenAddress',
+        type: 'address',
+        internalType: 'address',
+      },
+      {
+        name: 'variableDebtTokenAddress',
+        type: 'address',
+        internalType: 'address',
+      },
+      {
+        name: 'interestRateStrategyAddress',
+        type: 'address',
+        internalType: 'address',
+      },
+      { name: 'accruedToTreasury', type: 'uint128', internalType: 'uint128' },
+      { name: 'unbacked', type: 'uint128', internalType: 'uint128' },
+      {
+        name: 'isolationModeTotalDebt',
+        type: 'uint128',
+        internalType: 'uint128',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+/**
+ * Get aToken address for a given underlying asset
+ * @param params - Parameters including asset address, chain ID, and chain manager
+ * @returns Promise resolving to aToken address
+ * @description Queries the Aave Pool to get the aToken address for the underlying asset
+ */
+export async function getATokenAddress(params: {
+  underlyingAsset: Address
+  chainId: (typeof SUPPORTED_CHAIN_IDS)[number]
+  chainManager: ChainManager
+}): Promise<Address> {
+  const poolAddress = getPoolAddress(params.chainId)
+  if (!poolAddress) {
+    throw new Error(`Aave V3 not deployed on chain ${params.chainId}`)
+  }
+
+  try {
+    // Get viem public client for this chain
+    const publicClient = params.chainManager.getPublicClient(params.chainId)
+
+    // Query the Pool contract directly for reserve data
+    const reserveData = await publicClient.readContract({
+      address: poolAddress,
+      abi: POOL_GET_RESERVE_DATA_ABI,
+      functionName: 'getReserveData',
+      args: [params.underlyingAsset],
+    })
+
+    // The return is a tuple where index 8 is aTokenAddress
+    const aTokenAddress = reserveData[8]
+
+    if (
+      !aTokenAddress ||
+      aTokenAddress === '0x0000000000000000000000000000000000000000'
+    ) {
+      throw new Error(
+        `No aToken found for asset ${params.underlyingAsset} on chain ${params.chainId}`,
+      )
+    }
+
+    return aTokenAddress
+  } catch (error) {
+    throw new Error(
+      `Failed to get aToken address for ${params.underlyingAsset}: ${
+        error instanceof Error ? error.message : 'Unknown error'
+      }`,
+    )
+  }
+}

package/src/lend/providers/morpho/MorphoLendProvider.ts

@@ -6,6 +6,7 @@ import { SUPPORTED_CHAIN_IDS as ACTIONS_SUPPORTED_CHAIN_IDS } from '@/constants/
 import { LendProvider } from '@/lend/core/LendProvider.js'
 import { getVault, getVaults } from '@/lend/providers/morpho/sdk.js'
 import type { ChainManager } from '@/services/ChainManager.js'
+import type { LendProviderConfig } from '@/types/actions.js'
 import type {
   GetLendMarketsParams,
   GetMarketBalanceParams,
@@ -15,7 +16,6 @@ import type {
   LendMarketPosition,
   LendOpenPositionInternalParams,
   LendTransaction,
-  MorphoLendConfig,
 } from '@/types/lend/index.js'
 import { getAssetAddress } from '@/utils/assets.js'
 
@@ -36,7 +36,7 @@ export const SUPPORTED_CHAIN_IDS = [
  * Morpho lending provider implementation
  * @description Lending provider implementation using Morpho protocol
  */
-export class MorphoLendProvider extends LendProvider<MorphoLendConfig> {
+export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
   protected readonly SUPPORTED_CHAIN_IDS = SUPPORTED_CHAIN_IDS
 
   private chainManager: ChainManager
@@ -46,7 +46,7 @@ export class MorphoLendProvider extends LendProvider<MorphoLendConfig> {
    * @param config - Morpho lending configuration
    * @param chainManager - Chain manager for blockchain interactions
    */
-  constructor(config: MorphoLendConfig, chainManager: ChainManager) {
+  constructor(config: LendProviderConfig, chainManager: ChainManager) {
     super(config)
     this.chainManager = chainManager
   }
@@ -102,7 +102,7 @@ export class MorphoLendProvider extends LendProvider<MorphoLendConfig> {
             value: 0n,
           },
         },
-        slippage: params.options?.slippage || this._config.defaultSlippage,
+        slippage: params.options?.slippage ?? 50,
       }
     } catch (error) {
       throw new Error(
@@ -155,7 +155,7 @@ export class MorphoLendProvider extends LendProvider<MorphoLendConfig> {
             value: 0n,
           },
         },
-        slippage: params.options?.slippage || this._config.defaultSlippage,
+        slippage: params.options?.slippage ?? 50,
       }
     } catch (error) {
       throw new Error(

package/src/lend/providers/morpho/__tests__/MorphoLendProvider.test.ts

@@ -10,7 +10,7 @@ import {
   MockReceiverAddress,
   MockWETHMarket,
 } from '@/test/MockMarkets.js'
-import type { MorphoLendConfig } from '@/types/lend/index.js'
+import type { LendProviderConfig } from '@/types/actions.js'
 
 // Mock the Morpho SDK modules
 vi.mock('@morpho-org/blue-sdk-viem', () => ({
@@ -36,13 +36,11 @@ vi.mock('@morpho-org/bundler-sdk-viem', () => ({
 
 describe('MorphoLendProvider', () => {
   let provider: MorphoLendProvider
-  let mockConfig: MorphoLendConfig
+  let mockConfig: LendProviderConfig
   let mockChainManager: ChainManager
 
   beforeEach(() => {
     mockConfig = {
-      provider: 'morpho',
-      defaultSlippage: 50,
       marketAllowlist: [MockGauntletUSDCMarket, MockWETHMarket],
     }
 
@@ -55,18 +53,6 @@ describe('MorphoLendProvider', () => {
     it('should initialize with provided config', () => {
       expect(provider).toBeInstanceOf(MorphoLendProvider)
     })
-
-    it('should use default slippage when not provided', () => {
-      const configWithoutSlippage = {
-        ...mockConfig,
-        defaultSlippage: undefined,
-      }
-      const providerWithDefaults = new MorphoLendProvider(
-        configWithoutSlippage,
-        mockChainManager,
-      )
-      expect(providerWithDefaults).toBeInstanceOf(MorphoLendProvider)
-    })
   })
 
   describe('closePosition', () => {
@@ -275,10 +261,7 @@ describe('MorphoLendProvider', () => {
 
   describe('market allowlist configuration', () => {
     it('should work without market allowlist', () => {
-      const configWithoutAllowlist: MorphoLendConfig = {
-        provider: 'morpho',
-        defaultSlippage: 50,
-      }
+      const configWithoutAllowlist: LendProviderConfig = {}
 
       const providerWithoutAllowlist = new MorphoLendProvider(
         configWithoutAllowlist,
@@ -289,9 +272,7 @@ describe('MorphoLendProvider', () => {
     })
 
     it('should store market allowlist when provided', () => {
-      const configWithAllowlist: MorphoLendConfig = {
-        provider: 'morpho',
-        defaultSlippage: 50,
+      const configWithAllowlist: LendProviderConfig = {
         marketAllowlist: [MockGauntletUSDCMarket],
       }
 
@@ -307,37 +288,8 @@ describe('MorphoLendProvider', () => {
       expect(allowlist![0].name).toBe(MockGauntletUSDCMarket.name)
     })
 
-    it('should use default slippage from config', () => {
-      const customSlippage = 150
-      const configWithSlippage: MorphoLendConfig = {
-        provider: 'morpho',
-        defaultSlippage: customSlippage,
-      }
-
-      const providerWithSlippage = new MorphoLendProvider(
-        configWithSlippage,
-        mockChainManager,
-      )
-
-      expect(providerWithSlippage.config.defaultSlippage).toBe(customSlippage)
-    })
-
-    it('should use fallback default slippage when not provided', () => {
-      const configWithoutSlippage: MorphoLendConfig = {
-        provider: 'morpho',
-      }
-
-      const providerWithoutSlippage = new MorphoLendProvider(
-        configWithoutSlippage,
-        mockChainManager,
-      )
-
-      expect(providerWithoutSlippage.config.defaultSlippage || 50).toBe(50) // Default fallback
-    })
-
     it('should handle multiple markets in allowlist', () => {
-      const configWithMultipleMarkets: MorphoLendConfig = {
-        provider: 'morpho',
+      const configWithMultipleMarkets: LendProviderConfig = {
         marketAllowlist: [MockGauntletUSDCMarket, MockWETHMarket],
       }
 

package/src/lend/providers/morpho/__tests__/sdk.test.ts

@@ -164,6 +164,7 @@ describe('Vault Utilities', () => {
         usdc_demo: 0,
         morpho: 0,
         eth: 0,
+        weth: 0,
         other: 0,
         totalRewards: 0,
       })

package/src/lend/providers/morpho/sdk.ts

@@ -9,9 +9,9 @@ import {
 } from '@/lend/providers/morpho/api.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { SUPPORTED_TOKENS } from '@/supported/tokens.js'
+import type { LendProviderConfig } from '@/types/actions.js'
 import type {
   ApyBreakdown,
-  LendConfig,
   LendMarket,
   LendMarketConfig,
   LendMarketId,
@@ -139,7 +139,7 @@ interface GetVaultParams {
   /** Chain manager instance */
   chainManager: ChainManager
   /** Lend configuration containing market allowlist */
-  lendConfig?: LendConfig
+  lendConfig?: LendProviderConfig
 }
 
 /**
@@ -178,7 +178,6 @@ export async function getVault(params: GetVaultParams): Promise<LendMarket> {
 
   // Morpho sdk doesn't support base sepolia, so we need to use the mock vault
   if (params.marketId.chainId === 84532) {
-    console.log('Using mock vault for base sepolia')
     return createMockVaultData(params.marketId, marketConfig)
   }
 
@@ -244,7 +243,7 @@ export async function getVault(params: GetVaultParams): Promise<LendMarket> {
 
 interface GetVaultsParams {
   chainManager: ChainManager
-  lendConfig: LendConfig
+  lendConfig: LendProviderConfig
   markets: LendMarketConfig[]
 }
 

package/src/supported/tokens.ts

@@ -1,5 +1,11 @@
 import type { Address } from 'viem'
-import { base, baseSepolia, mainnet, unichain } from 'viem/chains'
+import {
+  base,
+  baseSepolia,
+  mainnet,
+  optimismSepolia,
+  unichain,
+} from 'viem/chains'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type { Asset } from '@/types/asset.js'
@@ -11,6 +17,7 @@ export const SUPPORTED_TOKENS: Asset[] = [
       [unichain.id]: '0x0000000000000000000000000000000000000000',
       [base.id]: '0x0000000000000000000000000000000000000000',
       [baseSepolia.id]: '0x0000000000000000000000000000000000000000',
+      [optimismSepolia.id]: '0x0000000000000000000000000000000000000000',
     },
     metadata: {
       symbol: 'ETH',
@@ -19,6 +26,21 @@ export const SUPPORTED_TOKENS: Asset[] = [
     },
     type: 'native',
   },
+  {
+    address: {
+      [mainnet.id]: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+      [base.id]: '0x4200000000000000000000000000000000000006',
+      [baseSepolia.id]: '0x4200000000000000000000000000000000000006',
+      [optimismSepolia.id]: '0x4200000000000000000000000000000000000006',
+      [unichain.id]: '0x4200000000000000000000000000000000000006',
+    },
+    metadata: {
+      symbol: 'WETH',
+      name: 'Wrapped Ether',
+      decimals: 18,
+    },
+    type: 'erc20',
+  },
   {
     address: {
       [mainnet.id]: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
@@ -38,7 +60,7 @@ export const SUPPORTED_TOKENS: Asset[] = [
     },
     metadata: {
       symbol: 'USDC_DEMO',
-      name: 'USDC Demo',
+      name: 'USDC',
       decimals: 6,
     },
     type: 'erc20',

package/src/test/MockLendProvider.ts

@@ -2,6 +2,7 @@ import type { Address } from 'viem'
 import { type MockedFunction, vi } from 'vitest'
 
 import { LendProvider } from '@/lend/core/LendProvider.js'
+import type { LendProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type {
   ClosePositionParams,
@@ -9,7 +10,6 @@ import type {
   GetLendMarketsParams,
   GetMarketBalanceParams,
   LendClosePositionParams,
-  LendConfig,
   LendMarket,
   LendMarketId,
   LendMarketPosition,
@@ -29,7 +29,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>
   >
@@ -71,10 +71,10 @@ export class MockLendProvider extends LendProvider<LendConfig> {
   private mockConfig: MockLendProviderConfig
 
   constructor(
-    config?: LendConfig,
+    config?: LendProviderConfig,
     mockConfig?: Partial<MockLendProviderConfig>,
   ) {
-    super(config || { provider: 'morpho' })
+    super(config || {})
 
     this.mockConfig = {
       supportedChains: mockConfig?.supportedChains ?? [84532],
@@ -220,7 +220,7 @@ export class MockLendProvider extends LendProvider<LendConfig> {
       asset: assetAddress,
       marketId: marketId.address,
       apy: this.mockConfig.defaultApy,
-      slippage: options?.slippage || this._config.defaultSlippage || 50,
+      slippage: options?.slippage ?? 50,
       transactionData: {
         approval: {
           to: assetAddress,
@@ -253,7 +253,7 @@ export class MockLendProvider extends LendProvider<LendConfig> {
       asset: assetAddress,
       marketId: marketId.address,
       apy: this.mockConfig.defaultApy,
-      slippage: options?.slippage || this._config.defaultSlippage || 50,
+      slippage: options?.slippage ?? 50,
       transactionData: {
         approval: {
           to: assetAddress,
@@ -347,7 +347,7 @@ export class MockLendProvider extends LendProvider<LendConfig> {
       asset: assetAddress,
       marketId: marketId.address,
       apy: 0,
-      slippage: options?.slippage || this._config.defaultSlippage || 50,
+      slippage: options?.slippage ?? 50,
       transactionData: {
         closePosition: {
           to: marketId.address,
@@ -370,7 +370,7 @@ export class MockLendProvider extends LendProvider<LendConfig> {
       asset,
       marketId: marketId || 'mock-market',
       apy: 0,
-      slippage: options?.slippage || this._config.defaultSlippage || 50,
+      slippage: options?.slippage ?? 50,
       transactionData: {
         closePosition: {
           to:
@@ -390,7 +390,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)