@eth-optimism/actions-sdk 0.5.0 → 0.6.0

package/src/{lend → actions/lend}/core/LendProvider.ts

@@ -1,10 +1,21 @@
 import type { Address } from 'viem'
 import { parseUnits } from 'viem'
 
+import { validateMarketAsset } from '@/actions/lend/utils/markets.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
 import { ACTIONS_SUPPORTED_CHAIN_IDS } from '@/constants/supportedChains.js'
+import {
+  AddressRequiredError,
+  AssetMetadataRequiredError,
+  MarketIdRequiredError,
+  MarketNotAllowedError,
+} from '@/core/error/errors.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { LendProviderConfig } from '@/types/actions.js'
+import type {
+  ApprovalMode,
+  LendProviderConfig,
+  LendSettings,
+} from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type {
   ClosePositionParams,
@@ -16,15 +27,27 @@ import type {
   LendMarketConfig,
   LendMarketId,
   LendMarketPosition,
+  LendOpenPosition,
   LendOpenPositionInternalParams,
   LendOpenPositionParams,
   LendTransaction,
   TransactionData,
 } from '@/types/lend/index.js'
-import { buildErc20ApprovalTx } from '@/utils/approve.js'
-import { validateMarketAsset } from '@/utils/markets.js'
+import {
+  buildErc20ApprovalTx,
+  resolveApprovalMode,
+  resolveErc20ApprovalAmount,
+} from '@/utils/approve.js'
+import { isNativeAsset } from '@/utils/assets.js'
 import { validateChainSupported } from '@/utils/validation.js'
 
+/** Inputs for the base class's ERC-20 lend approval helper. */
+interface BuildLendApprovalParams {
+  position: LendOpenPosition
+  approvalMode: ApprovalMode
+  amountWei: bigint
+}
+
 /**
  * Lending provider abstract class
  * @description Base class for lending provider implementations
@@ -35,6 +58,9 @@ export abstract class LendProvider<
   /** Lending provider configuration */
   protected readonly _config: TConfig
 
+  /** Shared lend settings (defaults applied across all lend providers) */
+  protected readonly _settings: LendSettings
+
   /** Chain manager for blockchain interactions */
   protected readonly chainManager: ChainManager
 
@@ -42,9 +68,15 @@ export abstract class LendProvider<
    * Create a new lending provider
    * @param config - Provider-specific lending configuration
    * @param chainManager - Chain manager for blockchain interactions
+   * @param settings - Shared lend settings applied across all providers
    */
-  protected constructor(config: TConfig, chainManager: ChainManager) {
+  protected constructor(
+    config: TConfig,
+    chainManager: ChainManager,
+    settings?: LendSettings,
+  ) {
     this._config = config
+    this._settings = settings ?? {}
     this.chainManager = chainManager
   }
 
@@ -52,14 +84,6 @@ export abstract class LendProvider<
     return this._config
   }
 
-  /**
-   * Chain IDs supported by the underlying protocol.
-   * @description Each provider implements this to declare the chains its protocol
-   * is deployed on, without any SDK-level or developer-config filtering.
-   * @returns Array of chain IDs the protocol natively supports
-   */
-  abstract protocolSupportedChainIds(): number[]
-
   /**
    * Effective supported chain IDs.
    * @description Intersection of the protocol's supported chains,
@@ -67,12 +91,12 @@ export abstract class LendProvider<
    * All validation in public methods uses this set.
    * @returns Array of chain IDs usable through this provider instance
    */
-  supportedChainIds(): number[] {
+  supportedChainIds(): SupportedChainId[] {
     const configuredChains = this.chainManager.getSupportedChains()
     return this.protocolSupportedChainIds().filter(
-      (id) =>
+      (id): id is SupportedChainId =>
         (ACTIONS_SUPPORTED_CHAIN_IDS as readonly number[]).includes(id) &&
-        (configuredChains as number[]).includes(id),
+        (configuredChains as readonly number[]).includes(id),
     )
   }
 
@@ -86,7 +110,7 @@ export abstract class LendProvider<
    */
   async openPosition(params: LendOpenPositionParams): Promise<LendTransaction> {
     if (!params.walletAddress) {
-      throw new Error('walletAddress is required')
+      throw new AddressRequiredError('walletAddress')
     }
 
     this.validateConfigSupported(params.marketId)
@@ -97,11 +121,36 @@ export abstract class LendProvider<
       params.asset.metadata.decimals,
     )
 
-    return this._openPosition({
+    const position = await this._openPosition({
       ...params,
       amountWei,
       walletAddress: params.walletAddress,
     })
+
+    // Native deposits send ETH inline as msg.value; no approval is needed.
+    // ERC-20 deposits resolve approval mode and build an approve(spender, amount) tx.
+    const approval = isNativeAsset(params.asset)
+      ? undefined
+      : this.buildLendApproval({
+          position,
+          approvalMode: resolveApprovalMode(
+            params.approvalMode,
+            this._config.approvalMode,
+            this._settings.approvalMode,
+          ),
+          amountWei,
+        })
+
+    return {
+      amount: amountWei,
+      assetAddress: position.assetAddress,
+      marketId: params.marketId.address,
+      apy: position.apy,
+      transactionData: {
+        ...(approval ? { approval } : {}),
+        position: position.transaction,
+      },
+    }
   }
 
   /**
@@ -155,13 +204,13 @@ export abstract class LendProvider<
   ): Promise<LendMarketPosition> {
     // For now, require marketId (asset-only and empty params not yet supported)
     if (!marketId) {
-      throw new Error(
-        'marketId is required. Querying all positions or by asset is not yet supported.',
+      throw new MarketIdRequiredError(
+        'Querying all positions or by asset is not yet supported.',
       )
     }
 
     if (asset) {
-      throw new Error(
+      throw new MarketIdRequiredError(
         'Filtering by asset is not yet supported. Please provide only marketId.',
       )
     }
@@ -182,7 +231,7 @@ export abstract class LendProvider<
    */
   async closePosition(params: ClosePositionParams): Promise<LendTransaction> {
     if (!params.walletAddress) {
-      throw new Error('walletAddress is required')
+      throw new AddressRequiredError('walletAddress')
     }
 
     this.validateConfigSupported(params.marketId)
@@ -198,7 +247,7 @@ export abstract class LendProvider<
 
     const assetMetadata = params.asset?.metadata
     if (!assetMetadata) {
-      throw new Error('Asset metadata is required for decimal conversion')
+      throw new AssetMetadataRequiredError('decimal conversion')
     }
 
     // Convert human-readable amount to wei using the asset's decimals
@@ -222,7 +271,7 @@ export abstract class LendProvider<
    * @returns true if chain is supported, false otherwise
    */
   protected isChainSupported(chainId: number): boolean {
-    return this.supportedChainIds().includes(chainId)
+    return (this.supportedChainIds() as readonly number[]).includes(chainId)
   }
 
   /**
@@ -248,10 +297,46 @@ export abstract class LendProvider<
     )
 
     if (!foundMarket) {
+      throw new MarketNotAllowedError({
+        address: marketId.address,
+        chainId: marketId.chainId,
+        reason: 'Market is not in the market allowlist',
+      })
+    }
+  }
+
+  /**
+   * 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 {
+    return buildErc20ApprovalTx(tokenAddress, spender, amount)
+  }
+
+  /**
+   * Build the approval transaction for an ERC-20 lend deposit. Caller is
+   * expected to skip this for native deposits.
+   * @throws if the provider's `_openPosition` result is missing `spender`
+   */
+  private buildLendApproval(params: BuildLendApprovalParams): TransactionData {
+    const { position, approvalMode, amountWei } = params
+    if (!position.spender) {
       throw new Error(
-        `Market ${marketId.address} on chain ${marketId.chainId} is not in the market allowlist`,
+        `LendOpenPosition.spender is required for ERC-20 deposits (assetAddress: ${position.assetAddress})`,
       )
     }
+    return buildErc20ApprovalTx(
+      position.assetAddress,
+      position.spender,
+      resolveErc20ApprovalAmount(approvalMode, amountWei),
+    )
   }
 
   /**
@@ -273,31 +358,30 @@ export abstract class LendProvider<
   }
 
   /**
-   * 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
+   * Abstract methods that must be implemented by providers
    */
-  protected buildApprovalTx(
-    tokenAddress: Address,
-    spender: Address,
-    amount: bigint,
-  ): TransactionData {
-    return buildErc20ApprovalTx(tokenAddress, spender, amount)
-  }
 
   /**
-   * Abstract methods that must be implemented by providers
+   * Chain IDs supported by the underlying protocol.
+   * @description Each provider implements this to declare the chains its protocol
+   * is deployed on, without any SDK-level or developer-config filtering.
+   * @returns Array of chain IDs the protocol natively supports
    */
+  abstract protocolSupportedChainIds(): number[]
 
   /**
-   * Provider implementation of openPosition method
+   * Describe a deposit for opening a lending position. Providers describe
+   * **what** needs to happen (the spender that needs allowance + the deposit
+   * calldata + APY snapshot); the base class owns **how** the approval is
+   * built (amount sized via `approvalMode`, native deposits skipped, etc.).
+   *
+   * Return `spender: undefined` for native-asset deposits where value is sent
+   * inline as `msg.value` and no ERC-20 approval is required.
    * @description Must be implemented by providers
    */
   protected abstract _openPosition(
     params: LendOpenPositionInternalParams,
-  ): Promise<LendTransaction>
+  ): Promise<LendOpenPosition>
 
   /**
    * Provider implementation of getMarket method

package/src/{lend → actions/lend}/core/__tests__/LendProvider.test.ts

@@ -2,8 +2,14 @@ import type { Address } from 'viem'
 import { describe, expect, it } from 'vitest'
 
 import { MockUSDCAsset } from '@/__mocks__/MockAssets.js'
-import { MockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
-import type { LendMarketConfig, LendMarketId } from '@/types/lend/index.js'
+import { MockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
+import { LendProvider } from '@/actions/lend/core/LendProvider.js'
+import type {
+  LendMarketConfig,
+  LendMarketId,
+  LendOpenPositionParams,
+  LendTransaction,
+} from '@/types/lend/index.js'
 import { validateChainSupported } from '@/utils/validation.js'
 
 // Test helper class that exposes protected validation methods as public
@@ -161,12 +167,85 @@ describe('LendProvider', () => {
       })
 
       expect(result.amount).toBe(1000000000n)
-      expect(result.asset).toBe('0x123')
+      expect(result.assetAddress).toBe('0x123')
       expect(result.marketId).toBe('0x1234')
       expect(result.apy).toBe(0.05)
     })
   })
 
+  describe('approvalMode resolution', () => {
+    const mockAsset = {
+      address: {
+        84532: '0x1111111111111111111111111111111111111111' as Address,
+      },
+      metadata: { symbol: 'USDC', name: 'USD Coin', decimals: 6 },
+      type: 'erc20' as const,
+    }
+    const baseParams = {
+      amount: 1000,
+      asset: mockAsset,
+      marketId: {
+        address: '0x2222222222222222222222222222222222222222' as Address,
+        chainId: 84532,
+      } as LendMarketId,
+      walletAddress: '0x3333333333333333333333333333333333333333' as Address,
+    }
+
+    // MockLendProvider replaces `openPosition` with a vi.fn() in its
+    // constructor. To exercise the real base-class flow (which builds the
+    // approval tx around `_openPosition`'s output), call through the prototype.
+    const callBaseOpenPosition = (
+      provider: MockLendProvider,
+      params: LendOpenPositionParams,
+    ): Promise<LendTransaction> =>
+      LendProvider.prototype.openPosition.call(
+        provider,
+        params,
+      ) as Promise<LendTransaction>
+
+    // Last 32 bytes of approve(spender, amount) hold `amount`.
+    const approvalAmountHex = (result: LendTransaction): string =>
+      (result.transactionData.approval?.data ?? '').slice(-64)
+
+    // 1000 USDC at 6 decimals = 1_000_000_000 = 0x3b9aca00
+    const EXACT_AMOUNT_HEX = '3b9aca00'
+    const MAX_UINT256_HEX = 'f'.repeat(64)
+
+    it('defaults to "exact" — approval encodes the required amount', async () => {
+      const provider = new MockLendProvider()
+      const result = await callBaseOpenPosition(provider, baseParams)
+      expect(approvalAmountHex(result).replace(/^0+/, '')).toBe(
+        EXACT_AMOUNT_HEX,
+      )
+    })
+
+    it('honours per-call "max" override — approval uses maxUint256', async () => {
+      const provider = new MockLendProvider()
+      const result = await callBaseOpenPosition(provider, {
+        ...baseParams,
+        approvalMode: 'max',
+      })
+      expect(approvalAmountHex(result)).toBe(MAX_UINT256_HEX)
+    })
+
+    it('honours per-provider config approvalMode default', async () => {
+      const provider = new MockLendProvider({ approvalMode: 'max' })
+      const result = await callBaseOpenPosition(provider, baseParams)
+      expect(approvalAmountHex(result)).toBe(MAX_UINT256_HEX)
+    })
+
+    it('per-call override beats per-provider config', async () => {
+      const provider = new MockLendProvider({ approvalMode: 'max' })
+      const result = await callBaseOpenPosition(provider, {
+        ...baseParams,
+        approvalMode: 'exact',
+      })
+      expect(approvalAmountHex(result).replace(/^0+/, '')).toBe(
+        EXACT_AMOUNT_HEX,
+      )
+    })
+  })
+
   describe('supportedChainIds', () => {
     it('should return array of supported chain IDs', () => {
       const provider = new MockLendProvider()

package/src/actions/lend/index.ts

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

package/src/{lend → actions/lend}/namespaces/BaseLendNamespace.ts

@@ -1,5 +1,8 @@
-import type { AaveLendProvider } from '@/lend/providers/aave/AaveLendProvider.js'
-import type { MorphoLendProvider } from '@/lend/providers/morpho/MorphoLendProvider.js'
+import type { LendProvider } from '@/actions/lend/core/LendProvider.js'
+import { findMarketInAllowlist } from '@/actions/lend/utils/markets.js'
+import { BaseNamespace } from '@/actions/shared/BaseNamespace.js'
+import { ProviderNotConfiguredError } from '@/core/error/errors.js'
+import type { LendProviderConfig } from '@/types/actions.js'
 import type {
   GetLendMarketParams,
   GetLendMarketsParams,
@@ -10,13 +13,16 @@ import type { LendProviders } from '@/types/providers.js'
 
 export type { LendProviders } from '@/types/providers.js'
 
+type ConfiguredLendProvider = LendProvider<LendProviderConfig>
+
 /**
  * Base Lend Namespace
- * @description Shared lending operations for Actions and Wallet namespaces
+ * @description Shared lending operations for Actions and Wallet namespaces.
  */
-export abstract class BaseLendNamespace {
-  constructor(protected readonly providers: LendProviders) {}
-
+export abstract class BaseLendNamespace extends BaseNamespace<
+  ConfiguredLendProvider,
+  LendProviders
+> {
   /**
    * Get all markets across all configured providers
    * @param params - Optional filtering parameters
@@ -39,27 +45,6 @@ export abstract class BaseLendNamespace {
     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
@@ -68,18 +53,16 @@ export abstract class BaseLendNamespace {
    */
   protected getProviderForMarket(
     marketId: LendMarketId,
-  ): MorphoLendProvider | AaveLendProvider {
+  ): ConfiguredLendProvider {
     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
+      if (findMarketInAllowlist(provider.config.marketAllowlist, marketId)) {
+        return provider
+      }
     }
 
-    throw new Error(
-      `No provider configured for market ${marketId.address} on chain ${marketId.chainId}`,
-    )
+    throw new ProviderNotConfiguredError({
+      provider: marketId.address,
+      details: `No provider configured for market on chain ${marketId.chainId}`,
+    })
   }
 }

package/src/{lend → actions/lend}/namespaces/WalletLendNamespace.ts

@@ -1,4 +1,6 @@
+import { BaseLendNamespace } from '@/actions/lend/namespaces/BaseLendNamespace.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { MarketIdRequiredError } from '@/core/error/errors.js'
 import type {
   ClosePositionParams,
   GetPositionParams,
@@ -7,10 +9,10 @@ import type {
   LendTransaction,
   LendTransactionReceipt,
 } from '@/types/lend/index.js'
+import type { LendProviders } from '@/types/providers.js'
+import { executeTransactionBatch } from '@/wallet/core/utils/executeTransactionBatch.js'
 import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
 
-import { BaseLendNamespace, type LendProviders } from './BaseLendNamespace.js'
-
 /**
  * Wallet Lend Namespace
  * @description Full lending operations available on wallet.lend
@@ -27,8 +29,6 @@ export class WalletLendNamespace extends BaseLendNamespace {
    * 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(
@@ -41,19 +41,17 @@ export class WalletLendNamespace extends BaseLendNamespace {
       walletAddress: this.wallet.address,
     })
 
-    return this.executeTransaction(lendTransaction, params.marketId.chainId)
+    return this.dispatch(lendTransaction, params.marketId.chainId)
   }
 
   /**
    * Get position information for this wallet
    * @param params - Position query parameters
-   * @param params.marketId - Market identifier (required)
-   * @param params.asset - Asset filter (not yet supported)
    * @returns Promise resolving to position information
    */
   async getPosition(params: GetPositionParams): Promise<LendMarketPosition> {
     if (!params.marketId) {
-      throw new Error('marketId is required')
+      throw new MarketIdRequiredError()
     }
 
     const provider = this.getProviderForMarket(params.marketId)
@@ -68,8 +66,6 @@ export class WalletLendNamespace extends BaseLendNamespace {
   /**
    * Close a lending position (withdraw from market)
    * @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(
@@ -82,25 +78,22 @@ export class WalletLendNamespace extends BaseLendNamespace {
       walletAddress: this.wallet.address,
     })
 
-    return this.executeTransaction(closeTransaction, params.marketId.chainId)
+    return this.dispatch(closeTransaction, params.marketId.chainId)
   }
 
   /**
-   * Execute a lend transaction with optional approval batching
+   * Send a lend transaction, batching an ERC-20 approval ahead of the
+   * position call when one was provided by the provider. Defers to
+   * `executeTransactionBatch` for the actual 1-vs-N send/sendBatch dispatch.
    */
-  private async executeTransaction(
+  private dispatch(
     transaction: LendTransaction,
     chainId: SupportedChainId,
   ): Promise<LendTransactionReceipt> {
     const { transactionData } = transaction
-
-    if (transactionData.approval) {
-      return this.wallet.sendBatch(
-        [transactionData.approval, transactionData.position],
-        chainId,
-      )
-    }
-
-    return this.wallet.send(transactionData.position, chainId)
+    const txs = transactionData.approval
+      ? [transactionData.approval, transactionData.position]
+      : [transactionData.position]
+    return executeTransactionBatch(this.wallet, txs, chainId)
   }
 }

package/src/{lend → actions/lend}/namespaces/__tests__/ActionsLendNamespace.spec.ts

@@ -2,9 +2,9 @@ import type { Address } from 'viem'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { getRandomAddress } from '@/__mocks__/utils.js'
-import type { MockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
-import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
-import { ActionsLendNamespace } from '@/lend/namespaces/ActionsLendNamespace.js'
+import type { MockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
+import { createMockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
+import { ActionsLendNamespace } from '@/actions/lend/namespaces/ActionsLendNamespace.js'
 
 describe('ActionsLendNamespace', () => {
   let mockProvider: MockLendProvider

package/src/{lend → actions/lend}/namespaces/__tests__/BaseLendNamespace.spec.ts

@@ -2,12 +2,12 @@ import type { Address } from 'viem'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { getRandomAddress } from '@/__mocks__/utils.js'
-import type { MockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import type { MockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
 import {
   createMockLendProvider,
   MockLendProvider as MockLendProviderClass,
-} from '@/lend/__mocks__/MockLendProvider.js'
-import { BaseLendNamespace } from '@/lend/namespaces/BaseLendNamespace.js'
+} from '@/actions/lend/__mocks__/MockLendProvider.js'
+import { BaseLendNamespace } from '@/actions/lend/namespaces/BaseLendNamespace.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 

package/src/{lend → actions/lend}/namespaces/__tests__/WalletLendNamespace.spec.ts

@@ -3,9 +3,9 @@ import type { WaitForUserOperationReceiptReturnType } from 'viem/account-abstrac
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { getRandomAddress } from '@/__mocks__/utils.js'
-import type { MockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
-import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
-import { WalletLendNamespace } from '@/lend/namespaces/WalletLendNamespace.js'
+import type { MockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
+import { createMockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
+import { WalletLendNamespace } from '@/actions/lend/namespaces/WalletLendNamespace.js'
 import type { TransactionData } from '@/types/lend/index.js'
 import { createMock as createSmartWalletMock } from '@/wallet/core/wallets/smart/abstract/__mocks__/SmartWallet.js'
 import type { SmartWallet } from '@/wallet/core/wallets/smart/abstract/SmartWallet.js'
@@ -121,7 +121,7 @@ describe('WalletLendNamespace', () => {
       const marketId = mockMarketId
       const mockTransaction = {
         amount: 1000000000n,
-        asset: mockAsset.address[130],
+        assetAddress: mockAsset.address[130] as Address,
         marketId: marketId.address,
         apy: 0.05,
         transactionData: {
@@ -169,7 +169,7 @@ describe('WalletLendNamespace', () => {
 
       const mockTransaction = {
         amount: 100n,
-        asset: getRandomAddress(),
+        assetAddress: getRandomAddress(),
         marketId: closeParams.marketId.address,
         apy: 0.05,
         transactionData: {
@@ -234,7 +234,7 @@ describe('WalletLendNamespace', () => {
     }
     const mockTransaction = {
       amount: 1000000000n,
-      asset: mockAsset.address[130],
+      assetAddress: mockAsset.address[130] as Address,
       marketId: marketId.address,
       apy: 0.05,
       timestamp: Date.now(),