@eth-optimism/actions-sdk 0.5.0 → 0.7.0

package/src/wallet/core/providers/__tests__/WalletProvider.spec.ts

@@ -8,8 +8,8 @@ import {
   getMockAuthorizationContext,
 } from '@/__mocks__/MockPrivyClient.js'
 import { getRandomAddress } from '@/__mocks__/utils.js'
+import { createMockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { DefaultSmartWalletProvider } from '@/wallet/core/providers/smart/default/DefaultSmartWalletProvider.js'

package/src/wallet/core/providers/hosted/registry/HostedWalletProviderRegistry.ts

@@ -1,3 +1,4 @@
+import { ProviderNotConfiguredError } from '@/core/error/errors.js'
 import type { HostedProviderFactory } from '@/wallet/core/providers/hosted/types/index.js'
 
 /**
@@ -29,7 +30,7 @@ export abstract class HostedWalletProviderRegistry<
     const factory = this.registry.get(type) as
       | HostedProviderFactory<TType, TInstanceMap[TType], TConfigMap[TType]>
       | undefined
-    if (!factory) throw new Error(`Unknown hosted wallet provider: ${type}`)
+    if (!factory) throw new ProviderNotConfiguredError({ provider: type })
     return factory
   }
 

package/src/wallet/core/providers/hosted/registry/__tests__/HostedWalletProviderRegistry.spec.ts

@@ -84,7 +84,7 @@ describe('HostedWalletProviderRegistry', () => {
     const registry = new TestHostedWalletProviderRegistry()
     // @ts-expect-error: testing runtime error for unknown type
     expect(() => registry.getFactory('unknown')).toThrow(
-      'Unknown hosted wallet provider: unknown',
+      "A 'unknown' provider is not configured",
     )
   })
 })

package/src/wallet/core/providers/smart/default/__tests__/DefaultSmartWalletProvider.spec.ts

@@ -15,8 +15,8 @@ import type {
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { getRandomAddress } from '@/__mocks__/utils.js'
+import { createMockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { DefaultSmartWalletProvider } from '@/wallet/core/providers/smart/default/DefaultSmartWalletProvider.js'

package/src/wallet/core/utils/__tests__/executeTransactionBatch.spec.ts

@@ -0,0 +1,42 @@
+import type { Address } from 'viem'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { TransactionData } from '@/types/transaction.js'
+import { executeTransactionBatch } from '@/wallet/core/utils/executeTransactionBatch.js'
+import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
+
+const CHAIN_ID = 10 as const
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as Address
+const TX_A: TransactionData = { to: ZERO_ADDRESS, data: '0xaa', value: 0n }
+const TX_B: TransactionData = { to: ZERO_ADDRESS, data: '0xbb', value: 0n }
+
+describe('executeTransactionBatch', () => {
+  let wallet: Wallet
+
+  beforeEach(() => {
+    wallet = {
+      send: vi.fn().mockResolvedValue({ kind: 'single' }),
+      sendBatch: vi.fn().mockResolvedValue({ kind: 'batch' }),
+    } as unknown as Wallet
+  })
+
+  it('throws when the transaction list is empty', async () => {
+    await expect(executeTransactionBatch(wallet, [], CHAIN_ID)).rejects.toThrow(
+      /empty/,
+    )
+  })
+
+  it('calls wallet.send for a single transaction', async () => {
+    const result = await executeTransactionBatch(wallet, [TX_A], CHAIN_ID)
+    expect(wallet.send).toHaveBeenCalledWith(TX_A, CHAIN_ID)
+    expect(wallet.sendBatch).not.toHaveBeenCalled()
+    expect(result).toEqual({ kind: 'single' })
+  })
+
+  it('calls wallet.sendBatch for multiple transactions', async () => {
+    const result = await executeTransactionBatch(wallet, [TX_A, TX_B], CHAIN_ID)
+    expect(wallet.sendBatch).toHaveBeenCalledWith([TX_A, TX_B], CHAIN_ID)
+    expect(wallet.send).not.toHaveBeenCalled()
+    expect(result).toEqual({ kind: 'batch' })
+  })
+})

package/src/{core → wallet/core}/utils/__tests__/retryOnStaleRead.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest'
 
-import { retryOnStaleRead } from '@/core/utils/retryOnStaleRead.js'
+import { retryOnStaleRead } from '@/wallet/core/utils/retryOnStaleRead.js'
 
 describe('retryOnStaleRead', () => {
   it('returns immediately when value is fresh', async () => {

package/src/wallet/core/utils/executeTransactionBatch.ts

@@ -0,0 +1,37 @@
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { TransactionData } from '@/types/transaction.js'
+import type {
+  BatchTransactionReturnType,
+  TransactionReturnType,
+} from '@/wallet/core/wallets/abstract/types/index.js'
+import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
+
+/**
+ * Dispatch a list of transactions to a wallet.
+ * @description Single-element → `wallet.send()`; multi-element →
+ * `wallet.sendBatch()`. An empty list is a programming error and throws.
+ *
+ * Shared by every wallet-signing namespace (WalletLendNamespace,
+ * WalletSwapNamespace, WalletBorrowNamespace, …). Implemented as a
+ * module-level helper rather than a base class so namespaces can inherit
+ * from their domain-specific base (BaseLendNamespace etc.) without a
+ * multi-inheritance bind.
+ * @param wallet - The wallet that signs and sends the transactions
+ * @param transactions - Non-empty list of transactions to dispatch
+ * @param chainId - Target chain for the transactions
+ * @returns Receipt(s) from the underlying send / sendBatch call
+ * @throws Error if `transactions` is empty
+ */
+export async function executeTransactionBatch(
+  wallet: Wallet,
+  transactions: readonly TransactionData[],
+  chainId: SupportedChainId,
+): Promise<TransactionReturnType | BatchTransactionReturnType> {
+  if (transactions.length === 0) {
+    throw new Error('executeTransactionBatch: empty transaction list')
+  }
+  if (transactions.length === 1) {
+    return wallet.send(transactions[0], chainId)
+  }
+  return wallet.sendBatch(transactions, chainId)
+}

package/src/wallet/core/wallets/abstract/Wallet.ts

@@ -1,15 +1,16 @@
 import type { Address, LocalAccount } from 'viem'
 
+import { WalletLendNamespace } from '@/actions/lend/namespaces/WalletLendNamespace.js'
+import { WalletSwapNamespace } from '@/actions/swap/namespaces/WalletSwapNamespace.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import { EnsNamespace } from '@/ens/index.js'
-import { WalletLendNamespace } from '@/lend/namespaces/WalletLendNamespace.js'
 import type { ChainManager } from '@/services/ChainManager.js'
+import { EnsNamespace } from '@/services/nameservices/ens/index.js'
 import { fetchERC20Balance, fetchETHBalance } from '@/services/tokenBalance.js'
-import { WalletSwapNamespace } from '@/swap/namespaces/WalletSwapNamespace.js'
 import type { SwapSettings } from '@/types/actions.js'
-import type { Asset, TokenBalance } from '@/types/asset.js'
+import type { Asset, BalanceFetchOptions, TokenBalance } from '@/types/asset.js'
 import type { LendProviders, SwapProviders } from '@/types/providers.js'
 import type { TransactionData } from '@/types/transaction.js'
+import { validateBalanceFetchOptions } from '@/utils/validation.js'
 import type {
   BatchTransactionReturnType,
   TransactionReturnType,
@@ -84,18 +85,31 @@ export abstract class Wallet {
   }
 
   /**
-   * Get asset balances across all supported chains
-   * @description Fetches ETH and ERC20 token balances for this wallet across all supported networks.
-   * Uses the configured supported assets from ActionsConfig.assets if provided.
-   * @returns Promise resolving to array of token balances with chain breakdown
+   * Check whether a wallet namespace (`lend`, `swap`) is configured on this
+   * wallet. Useful for callers that branch on capability instead of catching
+   * a `TypeError` from `wallet.lend!.openPosition(...)` later. Returns `false`
+   * when the namespace is undefined (no providers were registered for it).
+   * @param namespace - Wallet namespace name to probe.
+   * @returns `true` when the namespace is configured.
    */
-  async getBalance(): Promise<TokenBalance[]> {
-    const tokenBalancePromises = this.supportedAssets.map(async (asset) => {
-      return fetchERC20Balance(this.chainManager, this.address, asset)
-    })
-    const ethBalancePromise = fetchETHBalance(this.chainManager, this.address)
+  has(namespace: 'lend' | 'swap'): boolean {
+    return this[namespace] !== undefined
+  }
 
-    return Promise.all([ethBalancePromise, ...tokenBalancePromises])
+  /**
+   * Get asset balances across the requested chains (or all supported chains).
+   * @description Fetches ETH and ERC20 token balances for this wallet. By default queries every chain returned by the SDK's `ChainManager`. Pass `options.chainIds` to restrict the query to a subset of those chains; each id is validated against the configured chains and an `InvalidParamsError` / `ChainNotSupportedError` is thrown for unusable input. Uses the configured supported assets from `ActionsConfig.assets` if provided.
+   * @param options - Optional `chainIds` filter
+   * @returns Promise resolving to array of token balances with chain breakdown
+   */
+  async getBalance(options?: BalanceFetchOptions): Promise<TokenBalance[]> {
+    validateBalanceFetchOptions(options, this.chainManager)
+    return Promise.all([
+      fetchETHBalance(this.chainManager, this.address, options),
+      ...this.supportedAssets.map((asset) =>
+        fetchERC20Balance(this.chainManager, this.address, asset, options),
+      ),
+    ])
   }
 
   /**
@@ -163,7 +177,7 @@ export abstract class Wallet {
    * @returns Promise resolving to the transaction hash
    */
   abstract sendBatch(
-    transactionData: TransactionData[],
+    transactionData: readonly TransactionData[],
     chainId: SupportedChainId,
   ): Promise<BatchTransactionReturnType>
 }

package/src/wallet/core/wallets/abstract/__mocks__/TestWallet.ts

@@ -1,9 +1,9 @@
 import type { Address, LocalAccount, WalletClient } from 'viem'
 
+import type { LendProvider } from '@/actions/lend/core/LendProvider.js'
+import type { SwapProvider } from '@/actions/swap/core/SwapProvider.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import type { LendProvider } from '@/lend/core/LendProvider.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { SwapProvider } from '@/swap/core/SwapProvider.js'
 import type { LendProviderConfig, SwapProviderConfig } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type { TransactionData } from '@/types/lend/index.js'
@@ -44,7 +44,7 @@ export class TestWallet extends Wallet {
   }
 
   async sendBatch(
-    _transactionData: TransactionData[],
+    _transactionData: readonly TransactionData[],
     _chainId: SupportedChainId,
   ): Promise<EOATransactionReceipt[]> {
     return [] as unknown as EOATransactionReceipt[]

package/src/wallet/core/wallets/abstract/__tests__/Wallet.spec.ts

@@ -1,10 +1,14 @@
 import type { LocalAccount } from 'viem'
-import { unichain } from 'viem/chains'
+import { base, optimism, unichain } from 'viem/chains'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { getRandomAddress } from '@/__mocks__/utils.js'
+import type { WalletLendNamespace } from '@/actions/lend/namespaces/WalletLendNamespace.js'
 import { ETH, USDC } from '@/constants/assets.js'
-import type { WalletLendNamespace } from '@/lend/namespaces/WalletLendNamespace.js'
+import {
+  ChainNotSupportedError,
+  InvalidParamsError,
+} from '@/core/error/errors.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { fetchERC20Balance, fetchETHBalance } from '@/services/tokenBalance.js'
@@ -36,7 +40,11 @@ describe('Wallet (base)', () => {
 
     expect(result).toBeTruthy()
     expect(fetchETHBalance).toHaveBeenCalledTimes(1)
-    expect(fetchETHBalance).toHaveBeenCalledWith(chainManager, address)
+    expect(fetchETHBalance).toHaveBeenCalledWith(
+      chainManager,
+      address,
+      undefined,
+    )
     // No supportedAssets configured, so no ERC20 balance fetches
     expect(fetchERC20Balance).toHaveBeenCalledTimes(0)
   })
@@ -67,6 +75,49 @@ describe('Wallet (base)', () => {
     await expect(wallet.getBalance()).rejects.toThrow('rpc error')
   })
 
+  it('getBalance forwards chainIds to fetchers when provided', async () => {
+    const multiCm = new MockChainManager({
+      supportedChains: [optimism.id, base.id, unichain.id],
+    }) as unknown as ChainManager
+    const wallet = new TestWallet(
+      multiCm,
+      address,
+      signer,
+      undefined,
+      undefined,
+      [ETH, USDC],
+    )
+
+    await wallet.getBalance({ chainIds: [base.id] })
+
+    expect(fetchETHBalance).toHaveBeenCalledWith(multiCm, address, {
+      chainIds: [base.id],
+    })
+    expect(fetchERC20Balance).toHaveBeenCalledTimes(2)
+    for (const call of vi.mocked(fetchERC20Balance).mock.calls) {
+      expect(call[3]).toEqual({ chainIds: [base.id] })
+    }
+  })
+
+  it('getBalance throws ChainNotSupportedError for chains outside the manager', async () => {
+    const wallet = new TestWallet(chainManager, address, signer)
+
+    await expect(
+      wallet.getBalance({ chainIds: [base.id] }),
+    ).rejects.toBeInstanceOf(ChainNotSupportedError)
+    expect(fetchETHBalance).not.toHaveBeenCalled()
+    expect(fetchERC20Balance).not.toHaveBeenCalled()
+  })
+
+  it('getBalance throws InvalidParamsError when chainIds is empty', async () => {
+    const wallet = new TestWallet(chainManager, address, signer)
+
+    await expect(wallet.getBalance({ chainIds: [] })).rejects.toBeInstanceOf(
+      InvalidParamsError,
+    )
+    expect(fetchETHBalance).not.toHaveBeenCalled()
+  })
+
   it('has lend namespace available for inheritance', () => {
     const wallet = new TestWallet(chainManager, address, signer)
 
@@ -74,4 +125,19 @@ describe('Wallet (base)', () => {
     expect(wallet.lend).toBeDefined()
     expect(wallet.lend).toEqual({})
   })
+
+  describe('has', () => {
+    it("returns false for a namespace that wasn't configured", () => {
+      const wallet = new TestWallet(chainManager, address, signer)
+      expect(wallet.has('lend')).toBe(false)
+      expect(wallet.has('swap')).toBe(false)
+    })
+
+    it('returns true once a namespace has been attached', () => {
+      const wallet = new TestWallet(chainManager, address, signer)
+      wallet.lend = {} as WalletLendNamespace
+      expect(wallet.has('lend')).toBe(true)
+      expect(wallet.has('swap')).toBe(false)
+    })
+  })
 })

package/src/wallet/core/wallets/eoa/EOAWallet.ts

@@ -5,7 +5,7 @@ import type {
   LocalAccount,
   WalletClient,
 } from 'viem'
-import { createWalletClient } from 'viem'
+import { createWalletClient, nonceManager } from 'viem'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type { TransactionData } from '@/types/lend/index.js'
@@ -23,8 +23,10 @@ export abstract class EOAWallet extends Wallet {
   /**
    * Create a WalletClient for this EOA wallet.
    *
-   * Creates a viem-compatible WalletClient configured with this wallet's account
-   * and the specified chain. Supports fallback transport for multiple RPC URLs.
+   * Attaches viem's default `nonceManager` to the signer so back-to-back
+   * `sendTransaction` calls receive sequential nonces without re-fetching
+   * `eth_getTransactionCount('pending')` per tx. This avoids races on
+   * load-balanced RPCs where pending state lags by one block.
    * @param chainId - The chain ID to create the wallet client for
    * @returns Promise resolving to a WalletClient configured for the specified chain
    */
@@ -39,8 +41,11 @@ export abstract class EOAWallet extends Wallet {
       []
     >
   > {
+    const account: LocalAccount = this.signer.nonceManager
+      ? this.signer
+      : { ...this.signer, nonceManager }
     return createWalletClient({
-      account: this.signer,
+      account,
       chain: this.chainManager.getChain(chainId),
       transport: this.chainManager.getTransportForChain(chainId),
     })
@@ -70,25 +75,25 @@ export abstract class EOAWallet extends Wallet {
   /**
    * Send multiple transactions sequentially from this EOA wallet.
    *
-   * Executes transactions one at a time in order, waiting for 2 confirmations
-   * between each to ensure nonce updates. Returns an array of receipts.
+   * Each transaction is awaited to inclusion (one confirmation) via `send()`
+   * before the next is signed. The `nonceManager` attached in `walletClient()`
+   * keeps nonces in sequence locally, so the wait does not need extra
+   * confirmations to guarantee nonce monotonicity.
+   *
+   * Note: this method assumes a sequencer-ordered chain (e.g. OP-stack L2s).
+   * On chains with deeper reorg risk, consider an additional confirmations
+   * pass at the call site.
    * @param transactionData - Array of transactions to send
    * @param chainId - Chain to send the transactions on
    * @returns Promise resolving to array of transaction receipts (one per transaction)
    */
   async sendBatch(
-    transactionData: TransactionData[],
+    transactionData: readonly TransactionData[],
     chainId: SupportedChainId,
   ): Promise<EOATransactionReceipt[]> {
     const receipts: EOATransactionReceipt[] = []
     for (const tx of transactionData) {
       const receipt = await this.send(tx, chainId)
-      const publicClient = this.chainManager.getPublicClient(chainId)
-      // wait an extra confirmation so give time for nonce to be updated
-      await publicClient.waitForTransactionReceipt({
-        hash: receipt.transactionHash,
-        confirmations: 2,
-      })
       receipts.push(receipt)
     }
     return receipts

package/src/wallet/core/wallets/eoa/__tests__/EOAWallet.spec.ts

@@ -120,10 +120,44 @@ describe('EOAWallet', () => {
 
       expect(createWalletClient).toHaveBeenCalledOnce()
       const callArgs = vi.mocked(createWalletClient).mock.calls[0][0]
-      expect(callArgs.account).toBe(mockLocalAccount)
+      expect(callArgs.account).toMatchObject({
+        address: mockLocalAccount.address,
+      })
       expect(callArgs.chain).toBe(unichain)
       expect(walletClient).toBe(mockWalletClient)
     })
+
+    it('attaches a nonce manager so back-to-back sends get sequential nonces', async () => {
+      await wallet.walletClient(unichain.id)
+
+      const callArgs = vi.mocked(createWalletClient).mock.calls[0][0]
+      const account = callArgs.account as { nonceManager?: unknown }
+      expect(account.nonceManager).toMatchObject({
+        consume: expect.any(Function),
+        increment: expect.any(Function),
+        get: expect.any(Function),
+        reset: expect.any(Function),
+      })
+    })
+
+    it('respects a nonce manager already set on the signer', async () => {
+      const customNonceManager = {
+        consume: vi.fn(),
+        increment: vi.fn(),
+        get: vi.fn(),
+        reset: vi.fn(),
+      }
+      ;(mockLocalAccount as LocalAccount).nonceManager =
+        customNonceManager as unknown as LocalAccount['nonceManager']
+
+      await wallet.walletClient(unichain.id)
+
+      const callArgs = vi.mocked(createWalletClient).mock.calls[0][0]
+      const account = callArgs.account as { nonceManager?: unknown }
+      expect(account.nonceManager).toBe(customNonceManager)
+
+      delete (mockLocalAccount as LocalAccount).nonceManager
+    })
   })
 
   describe('send', () => {
@@ -191,13 +225,12 @@ describe('EOAWallet', () => {
         .mockResolvedValueOnce(mockReceipt2.transactionHash)
         .mockResolvedValueOnce(mockReceipt3.transactionHash)
 
+      // sendBatch performs exactly one inclusion wait per transaction (the
+      // wait inside `send()`). One mock per tx.
       vi.mocked(mockPublicClient.waitForTransactionReceipt)
         .mockResolvedValueOnce(mockReceipt)
-        .mockResolvedValueOnce(mockReceipt)
-        .mockResolvedValueOnce(mockReceipt2)
         .mockResolvedValueOnce(mockReceipt2)
         .mockResolvedValueOnce(mockReceipt3)
-        .mockResolvedValueOnce(mockReceipt3)
     })
 
     it('should send multiple transactions sequentially', async () => {
@@ -226,33 +259,19 @@ describe('EOAWallet', () => {
       )
     })
 
-    it('should wait for extra confirmations after each transaction', async () => {
+    it('waits for exactly one confirmation per transaction', async () => {
       await wallet.sendBatch(
         [mockTransactionData1, mockTransactionData2],
         unichain.id,
       )
 
-      // Should be called twice per transaction:
-      // 1. Initial wait in send()
-      // 2. Extra confirmation wait (confirmations: 2) in sendBatch()
+      // One inclusion wait per tx, via `send()`.
       expect(mockPublicClient.waitForTransactionReceipt).toHaveBeenCalledTimes(
-        4,
+        2,
       )
-
-      // Check that extra confirmation wait was called with confirmations: 2
       expect(
         mockPublicClient.waitForTransactionReceipt,
-      ).toHaveBeenNthCalledWith(2, {
-        hash: mockReceipt.transactionHash,
-        confirmations: 2,
-      })
-
-      expect(
-        mockPublicClient.waitForTransactionReceipt,
-      ).toHaveBeenNthCalledWith(4, {
-        hash: mockReceipt2.transactionHash,
-        confirmations: 2,
-      })
+      ).not.toHaveBeenCalledWith(expect.objectContaining({ confirmations: 2 }))
     })
 
     it('should get public client for each transaction', async () => {
@@ -261,8 +280,8 @@ describe('EOAWallet', () => {
         unichain.id,
       )
 
-      // Called twice per transaction (once in send, once for extra confirmation)
-      expect(mockChainManager.getPublicClient).toHaveBeenCalledTimes(4)
+      // One getPublicClient call per transaction (via send()).
+      expect(mockChainManager.getPublicClient).toHaveBeenCalledTimes(2)
       expect(mockChainManager.getPublicClient).toHaveBeenCalledWith(unichain.id)
     })
 

package/src/wallet/core/wallets/smart/abstract/SmartWallet.ts

@@ -33,7 +33,7 @@ export abstract class SmartWallet extends Wallet {
    * @param chainId
    */
   abstract sendBatch(
-    transactionData: TransactionData[],
+    transactionData: readonly TransactionData[],
     chainId: SupportedChainId,
   ): Promise<WaitForUserOperationReceiptReturnType>
 

package/src/wallet/core/wallets/smart/default/DefaultSmartWallet.ts

@@ -11,13 +11,13 @@ import type { WaitForUserOperationReceiptReturnType } from 'viem/account-abstrac
 import { toCoinbaseSmartAccount } from 'viem/account-abstraction'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import { TransactionConfirmedButRevertedError } from '@/core/error/errors.js'
-import { retryOnStaleRead } from '@/core/utils/retryOnStaleRead.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import type { Asset } from '@/types/asset.js'
 import type { LendProviders, SwapProviders } from '@/types/providers.js'
 import type { TransactionData } from '@/types/transaction.js'
 import { parseAssetAmount } from '@/utils/assets.js'
+import { TransactionConfirmedButRevertedError } from '@/wallet/core/error/errors.js'
+import { retryOnStaleRead } from '@/wallet/core/utils/retryOnStaleRead.js'
 import { SmartWallet } from '@/wallet/core/wallets/smart/abstract/SmartWallet.js'
 import type { Signer } from '@/wallet/core/wallets/smart/abstract/types/index.js'
 import {
@@ -218,7 +218,7 @@ export class DefaultSmartWallet extends SmartWallet {
    * @returns Promise resolving to the transaction hash
    */
   async sendBatch(
-    transactionData: TransactionData[],
+    transactionData: readonly TransactionData[],
     chainId: SupportedChainId,
   ): Promise<WaitForUserOperationReceiptReturnType> {
     const account = await this.getCoinbaseSmartAccount(chainId)

package/src/wallet/core/wallets/smart/default/__tests__/DefaultSmartWallet.spec.ts

@@ -9,7 +9,7 @@ import { baseSepolia, unichain } from 'viem/chains'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { getRandomAddress } from '@/__mocks__/utils.js'
-import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import { createMockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import type { LendProviderConfig } from '@/types/actions.js'

package/src/wallet/node/index.ts

@@ -5,3 +5,4 @@ export type {
   NodeProviderTypes,
 } from '@/wallet/node/providers/hosted/types/index.js'
 export { PrivyWallet } from '@/wallet/node/wallets/hosted/privy/PrivyWallet.js'
+export { LocalWallet } from '@/wallet/node/wallets/local/LocalWallet.js'

package/src/wallet/node/providers/hosted/privy/__tests__/PrivyHostedWalletProvider.spec.ts

@@ -9,7 +9,7 @@ import {
   getMockAuthorizationContext,
 } from '@/__mocks__/MockPrivyClient.js'
 import { getRandomAddress } from '@/__mocks__/utils.js'
-import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import { createMockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'

package/src/wallet/node/providers/hosted/registry/__tests__/NodeHostedWalletProviderRegistry.spec.ts

@@ -98,7 +98,7 @@ describe('NodeHostedWalletProviderRegistry', () => {
     const registry = new NodeHostedWalletProviderRegistry()
     // @ts-expect-error: testing runtime error for unknown type
     expect(() => registry.getFactory('unknown')).toThrow(
-      'Unknown hosted wallet provider: unknown',
+      "A 'unknown' provider is not configured",
     )
   })
 })

package/src/wallet/node/providers/hosted/turnkey/__tests__/TurnkeyHostedWalletProvider.spec.ts

@@ -3,7 +3,7 @@ import type { LocalAccount } from 'viem'
 import { unichain } from 'viem/chains'
 import { describe, expect, it, vi } from 'vitest'
 
-import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
+import { createMockLendProvider } from '@/actions/lend/__mocks__/MockLendProvider.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { TurnkeyHostedWalletProvider } from '@/wallet/node/providers/hosted/turnkey/TurnkeyHostedWalletProvider.js'

package/src/wallet/node/wallets/hosted/privy/__tests__/PrivyWallet.spec.ts

@@ -115,7 +115,10 @@ describe('PrivyWallet', () => {
 
     expect(createWalletClient).toHaveBeenCalledOnce()
     const callArgs = vi.mocked(createWalletClient).mock.calls[0][0]
-    expect(callArgs.account).toBe(mockLocalAccount)
+    expect(callArgs.account).toMatchObject({
+      address: mockLocalAccount.address,
+    })
+    expect(callArgs.account).toHaveProperty('nonceManager')
     expect(callArgs.chain).toBe(mockChainManager.getChain(unichain.id))
     expect(walletClient).toBe(mockWalletClient)
   })

package/src/wallet/node/wallets/hosted/turnkey/__tests__/TurnkeyWallet.spec.ts

@@ -97,7 +97,8 @@ describe('TurnkeyWallet', () => {
 
     expect(createWalletClient).toHaveBeenCalledOnce()
     const args = vi.mocked(createWalletClient).mock.calls[0][0]
-    expect(args.account).toBe(mockLocalAccount)
+    expect(args.account).toMatchObject({ address: mockLocalAccount.address })
+    expect(args.account).toHaveProperty('nonceManager')
     expect(args.chain).toBe(mockChainManager.getChain(unichain.id))
     expect(walletClient).toBe(mockWalletClient)
   })