@eth-optimism/actions-sdk 0.5.0 → 0.7.0

package/src/utils/assets.ts

@@ -2,6 +2,10 @@ import type { Address } from 'viem'
 import { parseUnits } from 'viem'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import {
+  AssetNotSupportedOnChainError,
+  NativeAssetAddressError,
+} from '@/core/error/errors.js'
 import type { Asset } from '@/types/asset.js'
 
 /**
@@ -75,14 +79,10 @@ export function getAssetAddress(
 ): Address {
   const address = asset.address[chainId]
   if (!address) {
-    throw new Error(
-      `Asset ${asset.metadata.symbol} is not supported on chain ${chainId}`,
-    )
+    throw new AssetNotSupportedOnChainError(asset.metadata.symbol, chainId)
   }
   if (address === 'native') {
-    throw new Error(
-      `Asset ${asset.metadata.symbol} is a native asset and has no contract address.`,
-    )
+    throw new NativeAssetAddressError(asset.metadata.symbol)
   }
   return address
 }

package/src/utils/lendConfig.ts

@@ -0,0 +1,17 @@
+import type { LendConfig } from '@/types/actions.js'
+import type { LendMarketConfig } from '@/types/lend/base.js'
+import { LEND_PROVIDER_NAMES } from '@/types/providers.js'
+
+/**
+ * Flatten every provider's `marketAllowlist` from a `LendConfig` into a single
+ * list. Returns an empty list when `lend` is undefined or no provider declares
+ * an allowlist.
+ */
+export function getLendMarketAllowlist(
+  lend: LendConfig | undefined,
+): readonly LendMarketConfig[] {
+  if (!lend) return []
+  return LEND_PROVIDER_NAMES.flatMap(
+    (name) => lend[name]?.marketAllowlist ?? [],
+  )
+}

package/src/utils/serializers.ts

@@ -0,0 +1,21 @@
+/**
+ * @description Deep-clones an object, replacing every `bigint` with its
+ * decimal string form. Needed because `JSON.stringify` throws on `bigint`
+ * but Actions SDK return types carry `bigint` amounts, balances, and ids.
+ *
+ * The returned object preserves the input type signature for ergonomics;
+ * `bigint` fields are strings at runtime and callers must treat them as
+ * such. Use only at serialization boundaries (HTTP responses, CLI stdout).
+ * @param obj - Value to clone. Objects, arrays, and primitives are
+ * supported; cycles, `Map`, `Set`, `Date`, and `undefined` follow standard
+ * `JSON.stringify` semantics.
+ * @returns A structurally identical clone with every `bigint` coerced to
+ * its base-10 string representation.
+ */
+export function serializeBigInt<T>(obj: T): T {
+  return JSON.parse(
+    JSON.stringify(obj, (_key, value) =>
+      typeof value === 'bigint' ? value.toString() : value,
+    ),
+  )
+}

package/src/utils/validation.ts

@@ -2,7 +2,19 @@ import type { Address } from 'viem'
 import { isAddress } from 'viem'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import type { Asset } from '@/types/asset.js'
+import {
+  AmountRequiredError,
+  AssetNotSupportedOnChainError,
+  ChainNotSupportedError,
+  ConflictingAmountsError,
+  InvalidAmountError,
+  InvalidParamsError,
+  SameAssetError,
+  SlippageOutOfRangeError,
+  ZeroAddressError,
+} from '@/core/error/errors.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { Asset, BalanceFetchOptions } from '@/types/asset.js'
 import { isAssetSupportedOnChain } from '@/utils/assets.js'
 
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
@@ -12,13 +24,13 @@ export function validateAmountProvided(
   amountOut?: number,
 ): void {
   if (amountIn === undefined && amountOut === undefined) {
-    throw new Error('Either amountIn or amountOut must be provided')
+    throw new AmountRequiredError()
   }
 }
 
 export function validateAmountPositiveIfExists(amount?: number): void {
   if (amount !== undefined && amount <= 0) {
-    throw new Error('Amount must be positive')
+    throw new InvalidAmountError(amount)
   }
 }
 
@@ -27,7 +39,7 @@ export function validateNotBothAmounts(
   amountOut?: number,
 ): void {
   if (amountIn !== undefined && amountOut !== undefined) {
-    throw new Error('Provide either amountIn or amountOut, not both')
+    throw new ConflictingAmountsError()
   }
 }
 
@@ -36,21 +48,19 @@ export function validateNotSameAsset(assetIn: Asset, assetOut: Asset): void {
     assetIn.metadata.symbol.toLowerCase() ===
     assetOut.metadata.symbol.toLowerCase()
   ) {
-    throw new Error('Cannot swap an asset for itself')
+    throw new SameAssetError(assetIn.metadata.symbol)
   }
 }
 
 export function validateNotZeroAddress(address: Address, label: string): void {
   if (address === ZERO_ADDRESS) {
-    throw new Error(`${label} cannot be the zero address`)
+    throw new ZeroAddressError(label, address)
   }
 }
 
 export function validateSlippage(slippage: number, maxSlippage: number): void {
   if (slippage < 0 || slippage > maxSlippage) {
-    throw new Error(
-      `Slippage ${slippage} exceeds allowed range [0, ${maxSlippage * 100}%]`,
-    )
+    throw new SlippageOutOfRangeError(slippage, maxSlippage)
   }
 }
 
@@ -59,20 +69,37 @@ export function validateChainSupported(
   supportedChainIds: readonly number[],
 ): void {
   if (!supportedChainIds.includes(chainId)) {
-    throw new Error(
-      `Chain ${chainId} is not supported. Supported chains: ${supportedChainIds.join(', ')}`,
-    )
+    throw new ChainNotSupportedError({ chainId, supportedChainIds })
   }
 }
 
+/**
+ * Guard for `BalanceFetchOptions` — verifies a caller-supplied `chainIds` filter is non-empty and each id is a member of `chainManager.getSupportedChains()`. No-op when `chainIds` is omitted.
+ * @throws InvalidParamsError when `chainIds` is `[]`.
+ * @throws ChainNotSupportedError when any id is not configured on the manager.
+ */
+export function validateBalanceFetchOptions(
+  options: BalanceFetchOptions | undefined,
+  chainManager: ChainManager,
+): void {
+  if (options?.chainIds === undefined) return
+  if (options.chainIds.length === 0) {
+    throw new InvalidParamsError({
+      param: 'chainIds',
+      expected: 'SupportedChainId[] (non-empty)',
+      received: '[]',
+    })
+  }
+  const supported = chainManager.getSupportedChains()
+  for (const id of options.chainIds) validateChainSupported(id, supported)
+}
+
 export function validateAssetOnChain(
   asset: Asset,
   chainId: SupportedChainId,
 ): void {
   if (!isAssetSupportedOnChain(asset, chainId)) {
-    throw new Error(
-      `Asset ${asset.metadata.symbol} not supported on chain ${chainId}`,
-    )
+    throw new AssetNotSupportedOnChainError(asset.metadata.symbol, chainId)
   }
 }
 

package/src/wallet/core/error/errors.ts

@@ -0,0 +1,30 @@
+import type { TransactionReceipt } from 'viem'
+
+import { ActionsError } from '@/core/error/errors.js'
+
+/**
+ * Error for a transaction that was included on-chain but reverted
+ * @description Thrown when a transaction makes it into a block (i.e. has a
+ * confirmed receipt) yet the EVM execution failed. The full
+ * {@link TransactionReceipt | transaction receipt} is attached for
+ * post-mortem analysis (status, logs, gas usage, etc.).
+ */
+export class TransactionConfirmedButRevertedError extends ActionsError {
+  override name = 'TransactionConfirmedButRevertedError' as const
+  /** Full receipt returned by the node for the reverted transaction */
+  receipt: TransactionReceipt
+
+  /**
+   * Create an instance of TransactionConfirmedButRevertedError
+   * @param message - Human-readable description of the failure
+   * @param receipt - Confirmed transaction receipt indicating a revert
+   */
+  constructor(message: string, receipt: TransactionReceipt) {
+    if (!message || typeof message !== 'string') {
+      throw new Error('"message" must be a nonempty string.')
+    }
+
+    super(message, { metaMessages: [`txHash: ${receipt.transactionHash}`] })
+    this.receipt = receipt
+  }
+}

package/src/wallet/core/namespace/WalletNamespace.ts

@@ -1,5 +1,9 @@
 import type { LocalAccount } from 'viem'
 
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { ActionsContext, SwapSettings } from '@/types/actions.js'
+import type { Asset } from '@/types/asset.js'
+import type { LendProviders, SwapProviders } from '@/types/providers.js'
 import type {
   CreateSmartWalletOptions,
   GetSmartWalletOptions,
@@ -10,6 +14,21 @@ import type { SmartWalletCreationResult } from '@/wallet/core/providers/smart/ab
 import type { WalletProvider } from '@/wallet/core/providers/WalletProvider.js'
 import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
 import type { SmartWallet } from '@/wallet/core/wallets/smart/abstract/SmartWallet.js'
+import { LocalWallet } from '@/wallet/node/wallets/local/LocalWallet.js'
+
+function isLocalAccount(value: unknown): value is LocalAccount {
+  if (typeof value !== 'object' || value === null) {
+    return false
+  }
+  const record = value as Record<string, unknown>
+  return (
+    record.type === 'local' &&
+    typeof record.address === 'string' &&
+    typeof record.signMessage === 'function' &&
+    typeof record.signTransaction === 'function' &&
+    (!('signTypedData' in record) || typeof record.signTypedData === 'function')
+  )
+}
 
 /**
  * Provider factory function for lazy initialization
@@ -21,6 +40,20 @@ type WalletProviderFactory<
   S extends SmartWalletProvider,
 > = () => Promise<WalletProvider<THostedProviderType, TToActionsMap, H, S>>
 
+/**
+ * Adaptive `toActionsWallet` parameter type
+ * @description Evaluates to the hosted provider's options map entry plus
+ * `LocalAccount` when a hosted provider is configured, or to `LocalAccount`
+ * only when no hosted provider is configured (`THostedProviderType` is
+ * `never`).
+ */
+type ToActionsWalletParam<
+  THostedProviderType extends string,
+  TToActionsMap extends Record<THostedProviderType, unknown>,
+> = [THostedProviderType] extends [never]
+  ? LocalAccount
+  : TToActionsMap[THostedProviderType] | LocalAccount
+
 /**
  * Wallet namespace that provides unified wallet operations
  * @description Provides access to wallet functionality through a single provider interface.
@@ -49,11 +82,17 @@ export class WalletNamespace<
   private _initPromise: Promise<
     WalletProvider<THostedProviderType, TToActionsMap, H, S>
   > | null = null
+  private readonly chainManager: ChainManager
+  private readonly lendProviders: LendProviders
+  private readonly swapProviders: SwapProviders
+  private readonly supportedAssets: Asset[]
+  private readonly swapSettings?: SwapSettings
 
   constructor(
     providerOrFactory:
       | WalletProvider<THostedProviderType, TToActionsMap, H, S>
       | WalletProviderFactory<THostedProviderType, TToActionsMap, H, S>,
+    context: ActionsContext,
   ) {
     if (typeof providerOrFactory === 'function') {
       this._providerFactory = providerOrFactory
@@ -61,19 +100,11 @@ export class WalletNamespace<
       this._provider = providerOrFactory
       this._providerFactory = () => Promise.resolve(providerOrFactory)
     }
-  }
-
-  private resolveProvider(): Promise<
-    WalletProvider<THostedProviderType, TToActionsMap, H, S>
-  > {
-    if (this._provider) return Promise.resolve(this._provider)
-    if (!this._initPromise) {
-      this._initPromise = this._providerFactory().then((provider) => {
-        this._provider = provider
-        return provider
-      })
-    }
-    return this._initPromise
+    this.chainManager = context.chainManager
+    this.lendProviders = context.lendProviders
+    this.swapProviders = context.swapProviders
+    this.supportedAssets = context.supportedAssets
+    this.swapSettings = context.swapSettings
   }
 
   /**
@@ -82,9 +113,15 @@ export class WalletNamespace<
    * advanced functionality beyond the unified interface is needed.
    * Lazily initializes the provider if not yet created.
    * @returns Promise resolving to the configured hosted wallet provider instance
+   * @throws Error if no hosted wallet provider is configured
    */
   async hostedWalletProvider(): Promise<H> {
     const provider = await this.resolveProvider()
+    if (!provider.hostedWalletProvider) {
+      throw new Error(
+        'Hosted wallet provider not configured. Please add hostedWalletConfig to ActionsConfig.wallet.',
+      )
+    }
     return provider.hostedWalletProvider
   }
 
@@ -141,18 +178,30 @@ export class WalletNamespace<
   }
 
   /**
-   * Convert a hosted wallet to an Actions wallet
-   * @description Converts a hosted wallet to an Actions wallet instance.
-   * @param params - Parameters for converting a hosted wallet to an Actions wallet
-   * @param params.walletId - Unique identifier for the hosted wallet
-   * @param params.address - Ethereum address of the hosted wallet
+   * Convert a hosted wallet or local account to an Actions wallet
+   * @description Accepts either provider-specific params (for Privy/Turnkey) or a viem
+   * `LocalAccount` directly, depending on configuration. When a hosted wallet provider
+   * is configured, both shapes are accepted; when none is configured, only a
+   * `LocalAccount` is accepted and provider params are a type error.
+   * @param params - Provider params or a viem LocalAccount
    * @returns Promise resolving to the Actions wallet instance
    */
   async toActionsWallet(
-    params: TToActionsMap[THostedProviderType],
+    params: ToActionsWalletParam<THostedProviderType, TToActionsMap>,
   ): Promise<Wallet> {
+    if (isLocalAccount(params)) {
+      return LocalWallet.create({
+        account: params,
+        chainManager: this.chainManager,
+        lendProviders: this.lendProviders,
+        swapProviders: this.swapProviders,
+        supportedAssets: this.supportedAssets,
+      })
+    }
     const provider = await this.resolveProvider()
-    return provider.hostedWalletToActionsWallet(params)
+    return provider.hostedWalletToActionsWallet(
+      params as TToActionsMap[THostedProviderType],
+    )
   }
 
   /**
@@ -174,4 +223,17 @@ export class WalletNamespace<
     const provider = await this.resolveProvider()
     return provider.getSmartWallet(params)
   }
+
+  private resolveProvider(): Promise<
+    WalletProvider<THostedProviderType, TToActionsMap, H, S>
+  > {
+    if (this._provider) return Promise.resolve(this._provider)
+    if (!this._initPromise) {
+      this._initPromise = this._providerFactory().then((provider) => {
+        this._provider = provider
+        return provider
+      })
+    }
+    return this._initPromise
+  }
 }

package/src/wallet/core/namespace/__tests__/WalletNamespace.spec.ts

@@ -1,5 +1,6 @@
 import type { PrivyClient } from '@privy-io/node'
 import { getAddress } from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
 import { unichain } from 'viem/chains'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
@@ -9,8 +10,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 { WalletNamespace } from '@/wallet/core/namespace/WalletNamespace.js'
@@ -52,7 +53,12 @@ describe('WalletNamespace', () => {
         hostedWalletProvider,
         smartWalletProvider,
       )
-      const walletNamespace = new WalletNamespace(walletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
 
       expect(await walletNamespace.hostedWalletProvider()).toBe(
         hostedWalletProvider,
@@ -79,7 +85,12 @@ describe('WalletNamespace', () => {
         hostedWalletProvider,
         smartWalletProvider,
       )
-      const walletNamespace = new WalletNamespace(walletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
 
       expect(await walletNamespace.smartWalletProvider()).toBe(
         smartWalletProvider,
@@ -103,12 +114,17 @@ describe('WalletNamespace', () => {
         smartWalletProvider,
       )
       const createSmartWalletSpy = vi.spyOn(walletProvider, 'createSmartWallet')
-      const walletNamespace = new WalletNamespace(walletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
 
       // Create a hosted wallet to use as signer
       const privyWallet = createMockPrivyWallet()
       const hostedWallet =
-        await walletProvider.hostedWalletProvider.toActionsWallet({
+        await walletProvider.hostedWalletProvider!.toActionsWallet({
           walletId: privyWallet.id,
           address: getAddress(privyWallet.address),
         })
@@ -143,12 +159,17 @@ describe('WalletNamespace', () => {
         hostedWalletProvider,
         smartWalletProvider,
       )
-      const walletNamespace = new WalletNamespace(walletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
 
       // Create a hosted wallet to use as signer
       const privyWallet = createMockPrivyWallet()
       const hostedWallet =
-        await walletProvider.hostedWalletProvider.toActionsWallet({
+        await walletProvider.hostedWalletProvider!.toActionsWallet({
           walletId: privyWallet.id,
           address: getAddress(privyWallet.address),
         })
@@ -228,11 +249,16 @@ describe('WalletNamespace', () => {
         smartWalletProvider,
       )
       const getSmartWalletSpy = vi.spyOn(walletProvider, 'getSmartWallet')
-      const walletNamespace = new WalletNamespace(walletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
 
       const privyWallet = createMockPrivyWallet()
       const hostedWallet =
-        await walletProvider.hostedWalletProvider.toActionsWallet({
+        await walletProvider.hostedWalletProvider!.toActionsWallet({
           walletId: privyWallet.id,
           address: getAddress(privyWallet.address),
         })
@@ -269,11 +295,16 @@ describe('WalletNamespace', () => {
         hostedWalletProvider,
         smartWalletProvider,
       )
-      const walletNamespace = new WalletNamespace(walletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
 
       const privyWallet = createMockPrivyWallet()
       const hostedWallet =
-        await walletProvider.hostedWalletProvider.toActionsWallet({
+        await walletProvider.hostedWalletProvider!.toActionsWallet({
           walletId: privyWallet.id,
           address: getAddress(privyWallet.address),
         })
@@ -305,16 +336,21 @@ describe('WalletNamespace', () => {
         hostedWalletProvider,
         smartWalletProvider,
       )
-      const walletNamespace = new WalletNamespace(walletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
 
       const privyWallet = createMockPrivyWallet()
       const hostedWallet =
-        await walletProvider.hostedWalletProvider.toActionsWallet({
+        await walletProvider.hostedWalletProvider!.toActionsWallet({
           walletId: privyWallet.id,
           address: getAddress(privyWallet.address),
         })
       const toActionsWalletSpy = vi.spyOn(
-        walletProvider.hostedWalletProvider,
+        walletProvider.hostedWalletProvider!,
         'toActionsWallet',
       )
 
@@ -333,6 +369,85 @@ describe('WalletNamespace', () => {
     })
   })
 
+  describe('toActionsWallet with LocalAccount', () => {
+    it('should create a LocalWallet from a viem LocalAccount', async () => {
+      const hostedWalletProvider = new PrivyHostedWalletProvider({
+        privyClient: mockPrivyClient,
+        authorizationContext: getMockAuthorizationContext(),
+        chainManager: mockChainManager,
+      })
+      const smartWalletProvider = new DefaultSmartWalletProvider(
+        mockChainManager,
+        { morpho: mockLendProvider },
+      )
+      const walletProvider = new WalletProvider(
+        hostedWalletProvider,
+        smartWalletProvider,
+      )
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
+
+      const account = privateKeyToAccount(
+        '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+      )
+
+      const wallet = await walletNamespace.toActionsWallet(account)
+
+      expect(wallet.address).toBe(account.address)
+      expect(wallet.signer).toBe(account)
+    })
+
+    it('should expose lend namespace when an Aave provider is configured', async () => {
+      const mockAaveProvider = createMockLendProvider()
+      const smartWalletProvider = new DefaultSmartWalletProvider(
+        mockChainManager,
+        { aave: mockAaveProvider },
+      )
+      const walletProvider = new WalletProvider(undefined, smartWalletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: { aave: mockAaveProvider },
+        swapProviders: {},
+        supportedAssets: [],
+      })
+
+      const account = privateKeyToAccount(
+        '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+      )
+
+      const wallet = await walletNamespace.toActionsWallet(account)
+
+      expect(wallet.lend).toBeDefined()
+    })
+
+    it('should accept a LocalAccount when no hosted wallet provider is configured', async () => {
+      const smartWalletProvider = new DefaultSmartWalletProvider(
+        mockChainManager,
+        { morpho: mockLendProvider },
+      )
+      const walletProvider = new WalletProvider(undefined, smartWalletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
+
+      const account = privateKeyToAccount(
+        '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+      )
+
+      const wallet = await walletNamespace.toActionsWallet(account)
+
+      expect(wallet.address).toBe(account.address)
+      expect(wallet.signer).toBe(account)
+    })
+  })
+
   describe('createSigner', () => {
     it('should delegate to hosted wallet provider createSigner', async () => {
       const hostedWalletProvider = new PrivyHostedWalletProvider({
@@ -349,7 +464,12 @@ describe('WalletNamespace', () => {
         smartWalletProvider,
       )
       const createSignerSpy = vi.spyOn(walletProvider, 'createSigner')
-      const walletNamespace = new WalletNamespace(walletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
 
       const privyWallet = createMockPrivyWallet()
       const params = {
@@ -378,7 +498,12 @@ describe('WalletNamespace', () => {
         hostedWalletProvider,
         smartWalletProvider,
       )
-      const walletNamespace = new WalletNamespace(walletProvider)
+      const walletNamespace = new WalletNamespace(walletProvider, {
+        chainManager: mockChainManager,
+        lendProviders: {},
+        swapProviders: {},
+        supportedAssets: [],
+      })
 
       const privyWallet = createMockPrivyWallet()
       const signer = await walletNamespace.createSigner({

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

@@ -22,10 +22,19 @@ export class WalletProvider<
   S extends SmartWalletProvider = SmartWalletProvider,
 > {
   constructor(
-    public readonly hostedWalletProvider: H,
+    public readonly hostedWalletProvider: H | undefined,
     public readonly smartWalletProvider: S,
   ) {}
 
+  private requireHostedWalletProvider(): H {
+    if (!this.hostedWalletProvider) {
+      throw new Error(
+        'Hosted wallet provider not configured. Please add hostedWalletConfig to ActionsConfig.wallet.',
+      )
+    }
+    return this.hostedWalletProvider
+  }
+
   /**
    * Create a new smart wallet
    * @description Creates a smart wallet and attempts to deploy it across all supported chains.
@@ -52,7 +61,7 @@ export class WalletProvider<
   async hostedWalletToActionsWallet(
     params: TToActionsMap[THostedProviderType],
   ): Promise<Wallet> {
-    return this.hostedWalletProvider.toActionsWallet(params)
+    return this.requireHostedWalletProvider().toActionsWallet(params)
   }
 
   /**
@@ -67,7 +76,7 @@ export class WalletProvider<
   async createSigner(
     params: TToActionsMap[THostedProviderType],
   ): Promise<LocalAccount> {
-    return this.hostedWalletProvider.createSigner(params)
+    return this.requireHostedWalletProvider().createSigner(params)
   }
 
   /**