@eth-optimism/actions-sdk 0.5.0 → 0.6.0

package/src/{lend → actions/lend}/providers/aave/AaveLendProvider.ts

@@ -1,10 +1,11 @@
 import type { Address } from 'viem'
 import { encodeFunctionData, erc20Abi, formatUnits } from 'viem'
 
+import { LendProvider } from '@/actions/lend/core/LendProvider.js'
 import { WETH } from '@/constants/assets.js'
-import { LendProvider } from '@/lend/core/LendProvider.js'
+import { ChainNotSupportedError } from '@/core/error/errors.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { LendProviderConfig, LendSettings } from '@/types/actions.js'
 import type {
   GetLendMarketsParams,
   GetMarketBalanceParams,
@@ -12,6 +13,7 @@ import type {
   LendMarket,
   LendMarketId,
   LendMarketPosition,
+  LendOpenPosition,
   LendOpenPositionInternalParams,
   LendTransaction,
 } from '@/types/lend/index.js'
@@ -30,35 +32,38 @@ import { getATokenAddress, getReserve, getReserves } from './sdk.js'
  * @description Lending provider implementation using Aave V3 protocol
  */
 export class AaveLendProvider extends LendProvider<LendProviderConfig> {
-  protocolSupportedChainIds(): number[] {
-    return getSupportedChainIds()
+  constructor(
+    config: LendProviderConfig,
+    chainManager: ChainManager,
+    settings?: LendSettings,
+  ) {
+    super(config, chainManager, settings)
   }
 
-  /**
-   * Create a new Aave lending provider
-   * @param config - Aave lending configuration
-   * @param chainManager - Chain manager for blockchain interactions
-   */
-  constructor(config: LendProviderConfig, chainManager: ChainManager) {
-    super(config, chainManager)
+  protocolSupportedChainIds(): number[] {
+    return getSupportedChainIds()
   }
 
   /**
-   * Open a lending position in an Aave market
-   * @description Opens a lending position by supplying assets to an Aave reserve
-   * @param params - Position opening parameters
-   * @returns Promise resolving to lending transaction details
+   * Describe an Aave deposit. The base class wraps this into a
+   * `LendTransaction` with the appropriate ERC-20 approval based on
+   * `params.approvalMode`. Native-ETH paths return `spender: undefined` since
+   * deposits via the WETHGateway send value as `msg.value` rather than via
+   * `transferFrom`.
+   * @param params - Position opening parameters (amount in wei, walletAddress, approvalMode)
+   * @returns Spender + deposit calldata + APY snapshot
    */
   protected async _openPosition(
     params: LendOpenPositionInternalParams,
-  ): Promise<LendTransaction> {
+  ): Promise<LendOpenPosition> {
     try {
       // Get Pool address for this chain
       const poolAddress = getPoolAddress(params.marketId.chainId)
       if (!poolAddress) {
-        throw new Error(
-          `Aave V3 not deployed on chain ${params.marketId.chainId}`,
-        )
+        throw new ChainNotSupportedError({
+          chainId: params.marketId.chainId,
+          supportedChainIds: this.supportedChainIds(),
+        })
       }
 
       // Get market information for APY
@@ -67,13 +72,10 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
         chainId: params.marketId.chainId,
       })
 
-      // Check if this is a native ETH market
       if (isNativeAsset(params.asset)) {
-        return this._openETHPosition(params, poolAddress, marketInfo)
+        return this._buildETHOpenPosition(params, poolAddress, marketInfo)
       }
-
-      // Standard ERC-20 flow
-      return this._openERC20Position(params, poolAddress, marketInfo)
+      return this._buildERC20OpenPosition(params, poolAddress, marketInfo)
     } catch {
       throw new Error(
         `Failed to open position with ${params.amountWei} of ${params.asset.metadata.symbol}`,
@@ -94,9 +96,10 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
       // Get Pool address for this chain
       const poolAddress = getPoolAddress(params.marketId.chainId)
       if (!poolAddress) {
-        throw new Error(
-          `Aave V3 not deployed on chain ${params.marketId.chainId}`,
-        )
+        throw new ChainNotSupportedError({
+          chainId: params.marketId.chainId,
+          supportedChainIds: this.supportedChainIds(),
+        })
       }
 
       const marketInfo = await this.getMarket({
@@ -162,9 +165,10 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
       const poolAddress = getPoolAddress(params.marketId.chainId)
 
       if (!poolAddress) {
-        throw new Error(
-          `Aave V3 not deployed on chain ${params.marketId.chainId}`,
-        )
+        throw new ChainNotSupportedError({
+          chainId: params.marketId.chainId,
+          supportedChainIds: this.supportedChainIds(),
+        })
       }
 
       // Get the aToken address from Pool.getReserveData
@@ -206,22 +210,22 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
   }
 
   /**
-   * Open position for native ETH using WETHGateway
-   * @description Deposits native ETH via WETHGateway which wraps and deposits in one tx
+   * Describe a native-ETH deposit via Aave's WETHGateway. ETH is sent as
+   * `msg.value` and wrapped to aWETH inline — no ERC-20 approval needed.
    */
-  private async _openETHPosition(
+  private async _buildETHOpenPosition(
     params: LendOpenPositionInternalParams,
     poolAddress: Address,
     marketInfo: LendMarket,
-  ): Promise<LendTransaction> {
+  ): Promise<LendOpenPosition> {
     const gatewayAddress = getWETHGatewayAddress(params.marketId.chainId)
     if (!gatewayAddress) {
-      throw new Error(
-        `WETHGateway not available on chain ${params.marketId.chainId}`,
-      )
+      throw new ChainNotSupportedError({
+        chainId: params.marketId.chainId,
+        supportedChainIds: this.supportedChainIds(),
+      })
     }
 
-    // Generate depositETH transaction
     const depositCallData = encodeFunctionData({
       abi: WETH_GATEWAY_ABI,
       functionName: 'depositETH',
@@ -235,33 +239,28 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
     const wethAddress = getAssetAddress(WETH, params.marketId.chainId)
 
     return {
-      amount: params.amountWei,
-      asset: wethAddress,
-      marketId: params.marketId.address,
-      apy: marketInfo.apy.total,
-      transactionData: {
-        position: {
-          to: gatewayAddress,
-          data: depositCallData,
-          value: params.amountWei, // Send ETH as msg.value
-        },
+      assetAddress: wethAddress,
+      transaction: {
+        to: gatewayAddress,
+        data: depositCallData,
+        value: params.amountWei, // Send ETH as msg.value
       },
+      apy: marketInfo.apy.total,
     }
   }
 
   /**
-   * Open position for standard ERC-20 tokens
-   * @description Standard approve + supply flow for non-WETH assets
+   * Describe a standard ERC-20 deposit. The base class builds the approval to
+   * `poolAddress` based on `params.approvalMode`.
    */
-  private async _openERC20Position(
+  private async _buildERC20OpenPosition(
     params: LendOpenPositionInternalParams,
     poolAddress: Address,
     marketInfo: LendMarket,
-  ): Promise<LendTransaction> {
+  ): Promise<LendOpenPosition> {
     // Get asset address for the chain (throws for native assets)
     const assetAddress = getAssetAddress(params.asset, params.marketId.chainId)
 
-    // Generate supply transaction
     const supplyCallData = encodeFunctionData({
       abi: POOL_ABI,
       functionName: 'supply',
@@ -274,22 +273,14 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
     })
 
     return {
-      amount: params.amountWei,
-      asset: assetAddress,
-      marketId: params.marketId.address,
-      apy: marketInfo.apy.total,
-      transactionData: {
-        approval: this.buildApprovalTx(
-          assetAddress,
-          poolAddress,
-          params.amountWei,
-        ),
-        position: {
-          to: poolAddress,
-          data: supplyCallData,
-          value: 0n,
-        },
+      spender: poolAddress,
+      assetAddress,
+      transaction: {
+        to: poolAddress,
+        data: supplyCallData,
+        value: 0n,
       },
+      apy: marketInfo.apy.total,
     }
   }
 
@@ -304,9 +295,10 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
   ): Promise<LendTransaction> {
     const gatewayAddress = getWETHGatewayAddress(params.marketId.chainId)
     if (!gatewayAddress) {
-      throw new Error(
-        `WETHGateway not available on chain ${params.marketId.chainId}`,
-      )
+      throw new ChainNotSupportedError({
+        chainId: params.marketId.chainId,
+        supportedChainIds: this.supportedChainIds(),
+      })
     }
 
     const wethAddress = getAssetAddress(WETH, params.marketId.chainId)
@@ -331,7 +323,7 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
 
     return {
       amount: params.amount,
-      asset: wethAddress,
+      assetAddress: wethAddress,
       marketId: params.marketId.address,
       apy: marketInfo.apy.total,
       transactionData: {
@@ -376,7 +368,7 @@ export class AaveLendProvider extends LendProvider<LendProviderConfig> {
 
     return {
       amount: params.amount,
-      asset: assetAddress,
+      assetAddress,
       marketId: params.marketId.address,
       apy: marketInfo.apy.total,
       transactionData: {

package/src/{lend → actions/lend}/providers/aave/__tests__/AaveLendProvider.test.ts

@@ -1,19 +1,19 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { MockReceiverAddress } from '@/lend/__mocks__/MockMarkets.js'
+import { MockReceiverAddress } from '@/actions/lend/__mocks__/MockMarkets.js'
 import {
   createMockAaveReserve,
   createMockWETHReserve,
-} from '@/lend/providers/aave/__mocks__/mockReserve.js'
-import { AaveLendProvider } from '@/lend/providers/aave/AaveLendProvider.js'
-import * as aaveSdk from '@/lend/providers/aave/sdk.js'
+} from '@/actions/lend/providers/aave/__mocks__/mockReserve.js'
+import { AaveLendProvider } from '@/actions/lend/providers/aave/AaveLendProvider.js'
+import * as aaveSdk from '@/actions/lend/providers/aave/sdk.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, LendMarketConfig } from '@/types/index.js'
 
 // Mock the Aave SDK modules
-vi.mock('@/lend/providers/aave/sdk.js', () => ({
+vi.mock('@/actions/lend/providers/aave/sdk.js', () => ({
   getReserve: vi.fn(),
   getReserves: vi.fn(),
   getATokenAddress: vi.fn(),
@@ -139,7 +139,7 @@ describe('AaveLendProvider', () => {
 
       expect(lendTransaction).toHaveProperty('amount', BigInt('1000000000'))
       expect(lendTransaction).toHaveProperty(
-        'asset',
+        'assetAddress',
         asset.address[marketId.chainId],
       )
       expect(lendTransaction).toHaveProperty('marketId', marketId.address)
@@ -228,7 +228,7 @@ describe('AaveLendProvider', () => {
 
       expect(withdrawTransaction).toHaveProperty('amount', BigInt('500000000'))
       expect(withdrawTransaction).toHaveProperty(
-        'asset',
+        'assetAddress',
         asset.address[marketId.chainId],
       )
       expect(withdrawTransaction).toHaveProperty('marketId', marketId.address)

package/src/{lend → actions/lend}/providers/aave/sdk.ts

@@ -3,13 +3,17 @@ import { formatReserves } from '@aave/math-utils'
 import { providers } from 'ethers'
 import type { Address } from 'viem'
 
-import { WETH } from '@/constants/assets.js'
-import type { SupportedChainId } from '@/constants/supportedChains.js'
-import { POOL_GET_RESERVE_DATA_ABI } from '@/lend/providers/aave/abis/pool.js'
+import { POOL_GET_RESERVE_DATA_ABI } from '@/actions/lend/providers/aave/abis/pool.js'
 import {
   getAaveAddresses,
   getPoolAddress,
-} from '@/lend/providers/aave/addresses.js'
+} from '@/actions/lend/providers/aave/addresses.js'
+import { WETH } from '@/constants/assets.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import {
+  ChainNotSupportedError,
+  MarketNotAllowedError,
+} from '@/core/error/errors.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import type { LendProviderConfig } from '@/types/actions.js'
 import type {
@@ -95,14 +99,16 @@ export async function getReserve(
     : undefined
 
   if (!marketConfig) {
-    throw new Error(
-      `Market ${params.marketId.address} on chain ${params.marketId.chainId} not found in allowlist`,
-    )
+    throw new MarketNotAllowedError({
+      address: params.marketId.address,
+      chainId: params.marketId.chainId,
+      reason: 'Market not found in allowlist',
+    })
   }
 
   const addresses = getAaveAddresses(params.marketId.chainId)
   if (!addresses) {
-    throw new Error(`Aave V3 not deployed on chain ${params.marketId.chainId}`)
+    throw new ChainNotSupportedError({ chainId: params.marketId.chainId })
   }
 
   const poolAddress = addresses.pool
@@ -244,7 +250,7 @@ export async function getATokenAddress(params: {
 }): Promise<Address> {
   const poolAddress = getPoolAddress(params.chainId)
   if (!poolAddress) {
-    throw new Error(`Aave V3 not deployed on chain ${params.chainId}`)
+    throw new ChainNotSupportedError({ chainId: params.chainId })
   }
 
   try {

package/src/{lend → actions/lend}/providers/morpho/MorphoLendProvider.ts

@@ -1,11 +1,12 @@
 import { MetaMorphoAction } from '@morpho-org/blue-sdk-viem'
-import { erc20Abi, formatUnits } from 'viem'
+import { erc20Abi, erc4626Abi, formatUnits, type PublicClient } from 'viem'
 
-import { LendProvider } from '@/lend/core/LendProvider.js'
-import { getSupportedChainIds as getMorphoSupportedChainIds } from '@/lend/providers/morpho/contracts.js'
-import { getVault, getVaults } from '@/lend/providers/morpho/sdk.js'
+import { LendProvider } from '@/actions/lend/core/LendProvider.js'
+import { getVault, getVaults } from '@/actions/lend/providers/morpho/sdk.js'
+import { findMarketInAllowlist } from '@/actions/lend/utils/markets.js'
+import { getSupportedChainIds as getMorphoSupportedChainIds } from '@/actions/shared/morpho/contracts.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type { LendProviderConfig, LendSettings } from '@/types/actions.js'
 import type {
   GetLendMarketsParams,
   GetMarketBalanceParams,
@@ -13,6 +14,7 @@ import type {
   LendMarket,
   LendMarketId,
   LendMarketPosition,
+  LendOpenPosition,
   LendOpenPositionInternalParams,
   LendTransaction,
 } from '@/types/lend/index.js'
@@ -23,28 +25,28 @@ import { getAssetAddress } from '@/utils/assets.js'
  * @description Lending provider implementation using Morpho protocol
  */
 export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
-  protocolSupportedChainIds(): number[] {
-    return getMorphoSupportedChainIds()
+  constructor(
+    config: LendProviderConfig,
+    chainManager: ChainManager,
+    settings?: LendSettings,
+  ) {
+    super(config, chainManager, settings)
   }
 
-  /**
-   * Create a new Morpho lending provider
-   * @param config - Morpho lending configuration
-   * @param chainManager - Chain manager for blockchain interactions
-   */
-  constructor(config: LendProviderConfig, chainManager: ChainManager) {
-    super(config, chainManager)
+  protocolSupportedChainIds(): number[] {
+    return getMorphoSupportedChainIds()
   }
 
   /**
-   * Open a lending position in a Morpho market
-   * @description Opens a lending position by supplying assets to a Morpho market
-   * @param params - Position opening parameters
-   * @returns Promise resolving to lending transaction details
+   * Describe a Morpho deposit. The base class wraps this into a
+   * `LendTransaction` with the appropriate ERC-20 approval based on
+   * `params.approvalMode`.
+   * @param params - Position opening parameters (amount in wei, walletAddress, approvalMode)
+   * @returns Spender + deposit calldata + APY snapshot
    */
   protected async _openPosition(
     params: LendOpenPositionInternalParams,
-  ): Promise<LendTransaction> {
+  ): Promise<LendOpenPosition> {
     try {
       // Get asset address for the chain (throws for native assets)
       const assetAddress = getAssetAddress(
@@ -58,27 +60,20 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
         chainId: params.marketId.chainId,
       })
 
-      const assets = params.amountWei
-      const receiver = params.walletAddress
-      const depositCallData = MetaMorphoAction.deposit(assets, receiver)
+      const depositCallData = MetaMorphoAction.deposit(
+        params.amountWei,
+        params.walletAddress,
+      )
 
       return {
-        amount: params.amountWei,
-        asset: assetAddress,
-        marketId: params.marketId.address,
-        apy: vaultInfo.apy.total,
-        transactionData: {
-          approval: this.buildApprovalTx(
-            assetAddress,
-            params.marketId.address,
-            params.amountWei,
-          ),
-          position: {
-            to: params.marketId.address,
-            data: depositCallData,
-            value: 0n,
-          },
+        spender: params.marketId.address,
+        assetAddress,
+        transaction: {
+          to: params.marketId.address,
+          data: depositCallData,
+          value: 0n,
         },
+        apy: vaultInfo.apy.total,
       }
     } catch {
       throw new Error(
@@ -119,7 +114,7 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
 
       return {
         amount: params.amount,
-        asset: assetAddress,
+        assetAddress,
         marketId: params.marketId.address,
         apy: vaultInfo.apy.total,
         transactionData: {
@@ -180,6 +175,10 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
       const publicClient = this.chainManager.getPublicClient(
         params.marketId.chainId,
       )
+      const underlyingDecimals = await this.resolveUnderlyingDecimals(
+        publicClient,
+        params.marketId,
+      )
 
       // Get user's market token balance (shares in the vault)
       const shares = await publicClient.readContract({
@@ -192,28 +191,17 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
       // Convert shares to underlying asset balance using convertToAssets
       const balance = await publicClient.readContract({
         address: params.marketId.address,
-        abi: [
-          {
-            name: 'convertToAssets',
-            type: 'function',
-            stateMutability: 'view',
-            inputs: [{ name: 'shares', type: 'uint256' }],
-            outputs: [{ name: '', type: 'uint256' }],
-          },
-        ],
+        abi: erc4626Abi,
         functionName: 'convertToAssets',
         args: [shares],
       })
 
-      // Format the balances (USDC has 6 decimals)
-      const balanceFormatted = formatUnits(balance, 6)
-      const sharesFormatted = formatUnits(shares, 18) // Vault shares typically have 18 decimals
-
       return {
         balance,
-        balanceFormatted,
+        balanceFormatted: formatUnits(balance, underlyingDecimals),
         shares,
-        sharesFormatted,
+        // MetaMorpho vault shares are 18 decimals by contract invariant
+        sharesFormatted: formatUnits(shares, 18),
         marketId: params.marketId,
       }
     } catch {
@@ -222,4 +210,30 @@ export class MorphoLendProvider extends LendProvider<LendProviderConfig> {
       )
     }
   }
+
+  /**
+   * Resolve the underlying asset decimals for a market.
+   * @description Prefers the allowlisted market config (free, no RPC).
+   * Falls back to an on-chain read of the vault's ERC-4626 `asset()` +
+   * ERC-20 `decimals()` when the allowlist is empty or doesn't contain the
+   * market (e.g. a provider configured without an allowlist).
+   */
+  private async resolveUnderlyingDecimals(
+    publicClient: PublicClient,
+    marketId: LendMarketId,
+  ): Promise<number> {
+    const match = findMarketInAllowlist(this._config.marketAllowlist, marketId)
+    if (match) return match.asset.metadata.decimals
+
+    const underlying = await publicClient.readContract({
+      address: marketId.address,
+      abi: erc4626Abi,
+      functionName: 'asset',
+    })
+    return publicClient.readContract({
+      address: underlying,
+      abi: erc20Abi,
+      functionName: 'decimals',
+    })
+  }
 }

package/src/{lend → actions/lend}/providers/morpho/__tests__/MorphoLendProvider.test.ts

@@ -5,9 +5,9 @@ import {
   MockGauntletUSDCMarket,
   MockReceiverAddress,
   MockWETHMarket,
-} from '@/lend/__mocks__/MockMarkets.js'
-import { createMockMorphoVault } from '@/lend/providers/morpho/__mocks__/mockVault.js'
-import { MorphoLendProvider } from '@/lend/providers/morpho/MorphoLendProvider.js'
+} from '@/actions/lend/__mocks__/MockMarkets.js'
+import { createMockMorphoVault } from '@/actions/lend/providers/morpho/__mocks__/mockVault.js'
+import { MorphoLendProvider } from '@/actions/lend/providers/morpho/MorphoLendProvider.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import type { LendProviderConfig } from '@/types/actions.js'
@@ -101,7 +101,7 @@ describe('MorphoLendProvider', () => {
 
       expect(withdrawTransaction).toHaveProperty('amount', BigInt('500000000'))
       expect(withdrawTransaction).toHaveProperty(
-        'asset',
+        'assetAddress',
         asset.address[marketId.chainId],
       )
       expect(withdrawTransaction).toHaveProperty('marketId', marketId.address)
@@ -200,7 +200,7 @@ describe('MorphoLendProvider', () => {
 
       expect(lendTransaction).toHaveProperty('amount', BigInt('1000000000'))
       expect(lendTransaction).toHaveProperty(
-        'asset',
+        'assetAddress',
         asset.address[marketId.chainId],
       )
       expect(lendTransaction).toHaveProperty('marketId', marketId.address)
@@ -235,6 +235,80 @@ describe('MorphoLendProvider', () => {
     })
   })
 
+  describe('getPosition', () => {
+    it('formats balance using the allowlist asset decimals (USDC, 6)', async () => {
+      const client = mockChainManager.getPublicClient(
+        MockGauntletUSDCMarket.chainId,
+      )
+      const shares = 10n ** 18n // 1 share
+      const underlyingBalance = 10n ** 6n // 1 USDC
+      vi.mocked(client.readContract)
+        .mockResolvedValueOnce(shares)
+        .mockResolvedValueOnce(underlyingBalance)
+
+      const position = await provider.getPosition(MockReceiverAddress, {
+        address: MockGauntletUSDCMarket.address,
+        chainId: MockGauntletUSDCMarket.chainId,
+      })
+
+      expect(position.balance).toBe(underlyingBalance)
+      expect(position.balanceFormatted).toBe('1')
+      expect(position.shares).toBe(shares)
+      expect(position.sharesFormatted).toBe('1')
+    })
+
+    it('formats balance using the allowlist asset decimals (WETH, 18)', async () => {
+      const client = mockChainManager.getPublicClient(MockWETHMarket.chainId)
+      const shares = 10n ** 18n
+      const underlyingBalance = 10n ** 18n // 1 WETH
+      vi.mocked(client.readContract)
+        .mockResolvedValueOnce(shares)
+        .mockResolvedValueOnce(underlyingBalance)
+
+      const position = await provider.getPosition(MockReceiverAddress, {
+        address: MockWETHMarket.address,
+        chainId: MockWETHMarket.chainId,
+      })
+
+      expect(position.balance).toBe(underlyingBalance)
+      expect(position.balanceFormatted).toBe('1')
+    })
+
+    it('falls back to on-chain asset() + decimals() when no allowlist match', async () => {
+      const providerWithoutAllowlist = new MorphoLendProvider(
+        {},
+        mockChainManager,
+      )
+      const client = mockChainManager.getPublicClient(
+        MockGauntletUSDCMarket.chainId,
+      )
+      const underlyingAddr = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd'
+      const onchainDecimals = 8 // simulate a non-USDC underlying
+      const shares = 10n ** 18n
+      const underlyingBalance = 10n ** 8n
+      vi.mocked(client.readContract)
+        // resolveUnderlyingDecimals: asset()
+        .mockResolvedValueOnce(underlyingAddr)
+        // resolveUnderlyingDecimals: decimals()
+        .mockResolvedValueOnce(onchainDecimals)
+        // balanceOf
+        .mockResolvedValueOnce(shares)
+        // convertToAssets
+        .mockResolvedValueOnce(underlyingBalance)
+
+      const position = await providerWithoutAllowlist.getPosition(
+        MockReceiverAddress,
+        {
+          address: MockGauntletUSDCMarket.address,
+          chainId: MockGauntletUSDCMarket.chainId,
+        },
+      )
+
+      expect(position.balanceFormatted).toBe('1')
+      expect(position.sharesFormatted).toBe('1')
+    })
+  })
+
   describe('market allowlist configuration', () => {
     it('should work without market allowlist', () => {
       const configWithoutAllowlist: LendProviderConfig = {}

package/src/{lend → actions/lend}/providers/morpho/__tests__/api.test.ts

@@ -2,12 +2,12 @@ import type { Address } from 'viem'
 import { mainnet } from 'viem/chains'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
-import { MORPHO, USDC } from '@/constants/assets.js'
-import { fetchRewards } from '@/lend/providers/morpho/api.js'
+import { fetchRewards } from '@/actions/lend/providers/morpho/api.js'
 import {
   calculateRewardsBreakdown,
   fetchAndCalculateRewards,
-} from '@/lend/providers/morpho/sdk.js'
+} from '@/actions/lend/providers/morpho/sdk.js'
+import { MORPHO, USDC } from '@/constants/assets.js'
 import { externalTest } from '@/utils/test.js'
 
 const CHAIN_ID = mainnet.id