@eth-optimism/actions-sdk 0.3.0 → 0.4.0

package/src/utils/validateAddresses.ts

@@ -0,0 +1,153 @@
+import type { Address } from 'viem'
+import { getAddress } from 'viem'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { AssetsConfig, LendConfig, SwapConfig } from '@/types/actions.js'
+import type { Asset } from '@/types/asset.js'
+import type { LendProviderConfig } from '@/types/lend/index.js'
+import type { SwapProviderConfig } from '@/types/swap/index.js'
+
+type NamedAddresses = Record<string, Address>
+
+/**
+ * Validates all values in an address map.
+ * Values may be a single Address or a record of named addresses.
+ * Collects all failures before throwing a single Error listing every invalid entry.
+ * @returns The original map reference if all addresses are valid.
+ * @throws Error listing all invalid addresses with their chain IDs and key names.
+ */
+export function validateAddressMap<
+  M extends Partial<Record<number, Address | NamedAddresses>>,
+>(map: M): M {
+  const errors: string[] = []
+
+  for (const [chainId, value] of Object.entries(map)) {
+    if (value === undefined) continue
+    if (typeof value === 'string') {
+      try {
+        getAddress(value)
+      } catch {
+        errors.push(`  - [${chainId}]: ${value} (not a valid EVM address)`)
+      }
+    } else {
+      for (const [key, addr] of Object.entries(value as NamedAddresses)) {
+        try {
+          getAddress(addr)
+        } catch {
+          errors.push(
+            `  - ${key}[${chainId}]: ${addr} (not a valid EVM address)`,
+          )
+        }
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Invalid addresses found:\n${errors.join('\n')}`)
+  }
+  return map
+}
+
+/**
+ * Validates a Partial<Record<SupportedChainId, Address | 'native'>> asset address map.
+ * Skips entries where the value is 'native'.
+ * Collects all failures before throwing a single Error.
+ * @throws Error listing all invalid addresses with their chain IDs.
+ */
+export function validateAssetAddresses(
+  map: Partial<Record<SupportedChainId, Address | 'native'>>,
+): void {
+  const errors: string[] = []
+
+  for (const [chainId, value] of Object.entries(map)) {
+    if (value === undefined || value === 'native') continue
+    try {
+      getAddress(value)
+    } catch {
+      errors.push(`  - [${chainId}]: ${value} (not a valid EVM address)`)
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Invalid addresses found:\n${errors.join('\n')}`)
+  }
+}
+
+interface AddressEntry {
+  path: string
+  value: string
+}
+
+function assetAddresses(asset: Asset, path: string): AddressEntry[] {
+  return Object.entries(asset.address)
+    .filter(([, addr]) => addr !== 'native')
+    .map(([chainId, addr]) => ({
+      path: `${path}.address[${chainId}]`,
+      value: addr as string,
+    }))
+}
+
+function lendProviderAddresses(
+  config: LendProviderConfig,
+  providerPath: string,
+): AddressEntry[] {
+  return (['marketAllowlist', 'marketBlocklist'] as const).flatMap((key) =>
+    (config[key] ?? []).flatMap((m, i) => [
+      { path: `${providerPath}.${key}[${i}].address`, value: m.address },
+      ...assetAddresses(m.asset, `${providerPath}.${key}[${i}].asset`),
+    ]),
+  )
+}
+
+function swapProviderAddresses(
+  config: SwapProviderConfig,
+  providerPath: string,
+): AddressEntry[] {
+  return (['marketAllowlist', 'marketBlocklist'] as const).flatMap((key) =>
+    (config[key] ?? []).flatMap((m, i) =>
+      m.assets.flatMap((asset, j) =>
+        assetAddresses(asset, `${providerPath}.${key}[${i}].assets[${j}]`),
+      ),
+    ),
+  )
+}
+
+/**
+ * Validates all developer-supplied addresses in an ActionsConfig.
+ * Iterates all lend and swap providers generically, so new providers are covered automatically.
+ * Collects all failures before throwing a single Error.
+ * @throws Error listing all invalid addresses with their locations and chain IDs.
+ */
+export function validateConfigAddresses(config: {
+  lend?: LendConfig
+  swap?: SwapConfig
+  assets?: AssetsConfig
+}): void {
+  const addresses: AddressEntry[] = [
+    ...Object.entries(config.lend ?? {}).flatMap(([name, cfg]) =>
+      lendProviderAddresses(cfg as LendProviderConfig, `lend.${name}`),
+    ),
+    ...Object.entries(config.swap ?? {}).flatMap(([name, cfg]) =>
+      swapProviderAddresses(cfg as SwapProviderConfig, `swap.${name}`),
+    ),
+    ...(config.assets?.allow ?? []).flatMap((a, i) =>
+      assetAddresses(a, `assets.allow[${i}]`),
+    ),
+    ...(config.assets?.block ?? []).flatMap((a, i) =>
+      assetAddresses(a, `assets.block[${i}]`),
+    ),
+  ]
+
+  const errors = addresses.flatMap(({ path, value }) => {
+    try {
+      getAddress(value)
+      return []
+    } catch {
+      return [`  - ${path}: ${value} (not a valid EVM address)`]
+    }
+  })
+
+  if (errors.length > 0) {
+    throw new Error(`Invalid addresses found:\n${errors.join('\n')}`)
+  }
+}

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

@@ -11,9 +11,21 @@ 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'
 
+/**
+ * Provider factory function for lazy initialization
+ */
+type WalletProviderFactory<
+  THostedProviderType extends string,
+  TToActionsMap extends Record<THostedProviderType, unknown>,
+  H extends HostedWalletProvider<THostedProviderType, TToActionsMap>,
+  S extends SmartWalletProvider,
+> = () => Promise<WalletProvider<THostedProviderType, TToActionsMap, H, S>>
+
 /**
  * Wallet namespace that provides unified wallet operations
- * @description Provides access to wallet functionality through a single provider interface
+ * @description Provides access to wallet functionality through a single provider interface.
+ * Supports lazy initialization — the wallet provider is created on first method call,
+ * enabling tree-shaking of unused wallet provider dependencies.
  */
 export class WalletNamespace<
   THostedProviderType extends string,
@@ -22,32 +34,70 @@ export class WalletNamespace<
     HostedWalletProvider<THostedProviderType, TToActionsMap>,
   S extends SmartWalletProvider = SmartWalletProvider,
 > {
-  private provider: WalletProvider<THostedProviderType, TToActionsMap, H, S>
+  private _provider: WalletProvider<
+    THostedProviderType,
+    TToActionsMap,
+    H,
+    S
+  > | null = null
+  private _providerFactory: WalletProviderFactory<
+    THostedProviderType,
+    TToActionsMap,
+    H,
+    S
+  >
+  private _initPromise: Promise<
+    WalletProvider<THostedProviderType, TToActionsMap, H, S>
+  > | null = null
 
   constructor(
-    provider: WalletProvider<THostedProviderType, TToActionsMap, H, S>,
+    providerOrFactory:
+      | WalletProvider<THostedProviderType, TToActionsMap, H, S>
+      | WalletProviderFactory<THostedProviderType, TToActionsMap, H, S>,
   ) {
-    this.provider = provider
+    if (typeof providerOrFactory === 'function') {
+      this._providerFactory = providerOrFactory
+    } else {
+      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
   }
 
   /**
    * Get direct access to the hosted wallet provider
    * @description Provides direct access to the underlying hosted wallet provider when
-   * advanced functionality beyond the unified interface is needed
-   * @returns The configured hosted wallet provider instance
+   * 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
    */
-  get hostedWalletProvider(): H {
-    return this.provider.hostedWalletProvider
+  async hostedWalletProvider(): Promise<H> {
+    const provider = await this.resolveProvider()
+    return provider.hostedWalletProvider
   }
 
   /**
    * Get direct access to the smart wallet provider
    * @description Provides direct access to the underlying smart wallet provider when
-   * advanced functionality beyond the unified interface is needed
-   * @returns The configured smart wallet provider instance
+   * advanced functionality beyond the unified interface is needed.
+   * Lazily initializes the provider if not yet created.
+   * @returns Promise resolving to the configured smart wallet provider instance
    */
-  get smartWalletProvider(): S {
-    return this.provider.smartWalletProvider
+  async smartWalletProvider(): Promise<S> {
+    const provider = await this.resolveProvider()
+    return provider.smartWalletProvider
   }
 
   /**
@@ -70,7 +120,8 @@ export class WalletNamespace<
   async createSmartWallet(
     params: CreateSmartWalletOptions,
   ): Promise<SmartWalletCreationResult<SmartWallet>> {
-    return this.provider.createSmartWallet(params)
+    const provider = await this.resolveProvider()
+    return provider.createSmartWallet(params)
   }
 
   /**
@@ -85,7 +136,8 @@ export class WalletNamespace<
   async createSigner(
     params: TToActionsMap[THostedProviderType],
   ): Promise<LocalAccount> {
-    return this.provider.createSigner(params)
+    const provider = await this.resolveProvider()
+    return provider.createSigner(params)
   }
 
   /**
@@ -99,7 +151,8 @@ export class WalletNamespace<
   async toActionsWallet(
     params: TToActionsMap[THostedProviderType],
   ): Promise<Wallet> {
-    return this.provider.hostedWalletToActionsWallet(params)
+    const provider = await this.resolveProvider()
+    return provider.hostedWalletToActionsWallet(params)
   }
 
   /**
@@ -118,6 +171,7 @@ export class WalletNamespace<
    * @throws Error if neither walletAddress nor deploymentSigners provided
    */
   async getSmartWallet(params: GetSmartWalletOptions) {
-    return this.provider.getSmartWallet(params)
+    const provider = await this.resolveProvider()
+    return provider.getSmartWallet(params)
   }
 }

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

@@ -38,7 +38,7 @@ describe('WalletNamespace', () => {
   })
 
   describe('hostedWalletProvider', () => {
-    it('should provide access to hosted wallet provider', () => {
+    it('should provide access to hosted wallet provider', async () => {
       const hostedWalletProvider = new PrivyHostedWalletProvider({
         privyClient: mockPrivyClient,
         chainManager: mockChainManager,
@@ -54,12 +54,14 @@ describe('WalletNamespace', () => {
       )
       const walletNamespace = new WalletNamespace(walletProvider)
 
-      expect(walletNamespace.hostedWalletProvider).toBe(hostedWalletProvider)
+      expect(await walletNamespace.hostedWalletProvider()).toBe(
+        hostedWalletProvider,
+      )
     })
   })
 
   describe('smartWalletProvider', () => {
-    it('should provide access to smart wallet provider', () => {
+    it('should provide access to smart wallet provider', async () => {
       const mockPrivyClient = createMockPrivyClient(
         'test-app-id',
         'test-app-secret',
@@ -79,7 +81,9 @@ describe('WalletNamespace', () => {
       )
       const walletNamespace = new WalletNamespace(walletProvider)
 
-      expect(walletNamespace.smartWalletProvider).toBe(smartWalletProvider)
+      expect(await walletNamespace.smartWalletProvider()).toBe(
+        smartWalletProvider,
+      )
     })
   })
 

package/src/wallet/core/providers/hosted/abstract/HostedWalletProvider.ts

@@ -1,10 +1,8 @@
 import type { LocalAccount } from 'viem'
 
-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 { LendProviders, SwapProviders } from '@/types/providers.js'
 import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
 
 /**
@@ -18,24 +16,14 @@ export abstract class HostedWalletProvider<
   TOptionsMap extends Record<TType, unknown>,
 > {
   protected chainManager: ChainManager
-  protected lendProviders: {
-    morpho?: LendProvider<LendProviderConfig>
-    aave?: LendProvider<LendProviderConfig>
-  }
-  protected swapProviders: {
-    uniswap?: SwapProvider<SwapProviderConfig>
-  }
+  protected lendProviders: LendProviders
+  protected swapProviders: SwapProviders
   protected supportedAssets?: Asset[]
 
   protected constructor(
     chainManager: ChainManager,
-    lendProviders?: {
-      morpho?: LendProvider<LendProviderConfig>
-      aave?: LendProvider<LendProviderConfig>
-    },
-    swapProviders?: {
-      uniswap?: SwapProvider<SwapProviderConfig>
-    },
+    lendProviders?: LendProviders,
+    swapProviders?: SwapProviders,
     supportedAssets?: Asset[],
   ) {
     this.chainManager = chainManager

package/src/wallet/core/providers/hosted/types/index.ts

@@ -1,8 +1,7 @@
-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 { SwapSettings } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
+import type { LendProviders, SwapProviders } from '@/types/providers.js'
 import type { HostedWalletProvider } from '@/wallet/core/providers/hosted/abstract/HostedWalletProvider.js'
 
 /**
@@ -13,14 +12,10 @@ import type { HostedWalletProvider } from '@/wallet/core/providers/hosted/abstra
  */
 export interface HostedProviderDeps {
   chainManager: ChainManager
-  lendProviders?: {
-    morpho?: LendProvider<LendProviderConfig>
-    aave?: LendProvider<LendProviderConfig>
-  }
-  swapProviders?: {
-    uniswap?: SwapProvider<SwapProviderConfig>
-  }
+  lendProviders?: LendProviders
+  swapProviders?: SwapProviders
   supportedAssets?: Asset[]
+  swapSettings?: SwapSettings
 }
 
 /**
@@ -56,7 +51,10 @@ export interface HostedProviderFactory<
 > {
   type: TType
   validateOptions(options: unknown): options is TOptions
-  create(deps: HostedProviderDeps, options: TOptions): TInstance
+  create(
+    deps: HostedProviderDeps,
+    options: TOptions,
+  ): TInstance | Promise<TInstance>
 }
 
 /**

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

@@ -2,11 +2,9 @@ import type { Address, Hex, LocalAccount } from 'viem'
 import { keccak256, slice, toHex } from 'viem'
 
 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 { LendProviders, SwapProviders } from '@/types/providers.js'
 import { SmartWalletProvider } from '@/wallet/core/providers/smart/abstract/SmartWalletProvider.js'
 import type { SmartWalletCreationResult } from '@/wallet/core/providers/smart/abstract/types/index.js'
 import type { Signer } from '@/wallet/core/wallets/smart/abstract/types/index.js'
@@ -28,14 +26,9 @@ export class DefaultSmartWalletProvider extends SmartWalletProvider {
   /** Manages supported blockchain networks */
   private chainManager: ChainManager
   /** Providers for lending market operations */
-  private lendProviders: {
-    morpho?: LendProvider<LendProviderConfig>
-    aave?: LendProvider<LendProviderConfig>
-  }
+  private lendProviders: LendProviders
   /** Providers for swap operations */
-  private swapProviders: {
-    uniswap?: SwapProvider<SwapProviderConfig>
-  }
+  private swapProviders: SwapProviders
   /** Supported assets for this wallet provider */
   private supportedAssets?: Asset[]
   /** Optional 16-byte attribution suffix appended to callData */
@@ -51,13 +44,8 @@ export class DefaultSmartWalletProvider extends SmartWalletProvider {
    */
   constructor(
     chainManager: ChainManager,
-    lendProviders?: {
-      morpho?: LendProvider<LendProviderConfig>
-      aave?: LendProvider<LendProviderConfig>
-    },
-    swapProviders?: {
-      uniswap?: SwapProvider<SwapProviderConfig>
-    },
+    lendProviders?: LendProviders,
+    swapProviders?: SwapProviders,
     supportedAssets?: Asset[],
     attributionSuffix?: string,
   ) {

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

@@ -1,15 +1,13 @@
 import type { Address, LocalAccount } from 'viem'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import type { LendProvider } from '@/lend/core/LendProvider.js'
 import { WalletLendNamespace } from '@/lend/namespaces/WalletLendNamespace.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { fetchERC20Balance, fetchETHBalance } from '@/services/tokenBalance.js'
-import { SUPPORTED_TOKENS } from '@/supported/tokens.js'
-import type { SwapProvider } from '@/swap/core/SwapProvider.js'
 import { WalletSwapNamespace } from '@/swap/namespaces/WalletSwapNamespace.js'
-import type { LendProviderConfig, SwapProviderConfig } from '@/types/actions.js'
+import type { SwapSettings } from '@/types/actions.js'
 import type { Asset, TokenBalance } from '@/types/asset.js'
+import type { LendProviders, SwapProviders } from '@/types/providers.js'
 import type { TransactionData } from '@/types/transaction.js'
 import type {
   BatchTransactionReturnType,
@@ -25,16 +23,11 @@ export abstract class Wallet {
   /** Lend namespace with all lending operations */
   lend?: WalletLendNamespace
   /** Providers for lending market operations */
-  protected lendProviders: {
-    morpho?: LendProvider<LendProviderConfig>
-    aave?: LendProvider<LendProviderConfig>
-  }
+  protected lendProviders: LendProviders
   /** Swap namespace with all swap operations */
   swap?: WalletSwapNamespace
   /** Providers for swap operations */
-  protected swapProviders: {
-    uniswap?: SwapProvider<SwapProviderConfig>
-  }
+  protected swapProviders: SwapProviders
   /** Manages supported blockchain networks and RPC clients */
   protected chainManager: ChainManager
   /** List of supported assets for this wallet */
@@ -62,28 +55,28 @@ export abstract class Wallet {
    * @param chainManager - Chain manager for the wallet
    * @param lendProviders - Lend providers for the wallet
    * @param swapProviders - Swap providers for the wallet
-   * @param supportedAssets - List of supported assets (defaults to all SUPPORTED_TOKENS)
+   * @param supportedAssets - List of supported assets (defaults to empty)
    */
   protected constructor(
     chainManager: ChainManager,
-    lendProviders?: {
-      morpho?: LendProvider<LendProviderConfig>
-      aave?: LendProvider<LendProviderConfig>
-    },
-    swapProviders?: {
-      uniswap?: SwapProvider<SwapProviderConfig>
-    },
+    lendProviders?: LendProviders,
+    swapProviders?: SwapProviders,
     supportedAssets?: Asset[],
+    swapSettings?: SwapSettings,
   ) {
     this.chainManager = chainManager
     this.lendProviders = lendProviders || {}
     this.swapProviders = swapProviders || {}
-    this.supportedAssets = supportedAssets || SUPPORTED_TOKENS
+    this.supportedAssets = supportedAssets || []
     if (this.lendProviders.morpho || this.lendProviders.aave) {
       this.lend = new WalletLendNamespace(this.lendProviders, this)
     }
-    if (this.swapProviders.uniswap) {
-      this.swap = new WalletSwapNamespace(this.swapProviders, this)
+    if (Object.values(this.swapProviders).some(Boolean)) {
+      this.swap = new WalletSwapNamespace(
+        this.swapProviders,
+        this,
+        swapSettings,
+      )
     }
   }
 

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

@@ -1,7 +1,11 @@
 import type { Address, LocalAccount, WalletClient } from 'viem'
 
 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'
 import type { EOATransactionReceipt } from '@/wallet/core/wallets/abstract/types/index.js'
 import { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
@@ -14,8 +18,16 @@ export class TestWallet extends Wallet {
     chainManager: ChainManager,
     address: Address,
     signer: LocalAccount,
+    lendProviders?: {
+      morpho?: LendProvider<LendProviderConfig>
+      aave?: LendProvider<LendProviderConfig>
+    },
+    swapProviders?: {
+      uniswap?: SwapProvider<SwapProviderConfig>
+    },
+    supportedAssets?: Asset[],
   ) {
-    super(chainManager)
+    super(chainManager, lendProviders, swapProviders, supportedAssets)
     this.address = address
     this.signer = signer
   }

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

@@ -3,11 +3,11 @@ import { unichain } from 'viem/chains'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { getRandomAddress } from '@/__mocks__/utils.js'
+import { ETH, USDC } from '@/constants/assets.js'
 import type { WalletLendNamespace } from '@/lend/namespaces/WalletLendNamespace.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { fetchERC20Balance, fetchETHBalance } from '@/services/tokenBalance.js'
-import { SUPPORTED_TOKENS } from '@/supported/tokens.js'
 import { TestWallet } from '@/wallet/core/wallets/abstract/__mocks__/TestWallet.js'
 
 vi.mock('@/services/tokenBalance.js', async () => {
@@ -29,7 +29,7 @@ describe('Wallet (base)', () => {
     vi.clearAllMocks()
   })
 
-  it('getBalance fetches ETH and ERC20 balances for all supported tokens', async () => {
+  it('getBalance returns only ETH when no supportedAssets configured', async () => {
     const wallet = new TestWallet(chainManager, address, signer)
 
     const result = await wallet.getBalance()
@@ -37,10 +37,26 @@ describe('Wallet (base)', () => {
     expect(result).toBeTruthy()
     expect(fetchETHBalance).toHaveBeenCalledTimes(1)
     expect(fetchETHBalance).toHaveBeenCalledWith(chainManager, address)
-    // Should call fetchERC20Balance for each token in SUPPORTED_TOKENS
-    expect(fetchERC20Balance).toHaveBeenCalledTimes(
-      Object.keys(SUPPORTED_TOKENS).length,
+    // No supportedAssets configured, so no ERC20 balance fetches
+    expect(fetchERC20Balance).toHaveBeenCalledTimes(0)
+  })
+
+  it('getBalance fetches ERC20 balances for explicitly configured assets', async () => {
+    const wallet = new TestWallet(
+      chainManager,
+      address,
+      signer,
+      undefined,
+      undefined,
+      [ETH, USDC],
     )
+
+    const result = await wallet.getBalance()
+
+    expect(result).toBeTruthy()
+    expect(fetchETHBalance).toHaveBeenCalledTimes(1)
+    // Should call fetchERC20Balance for each configured asset
+    expect(fetchERC20Balance).toHaveBeenCalledTimes(2)
   })
 
   it('getBalance propagates errors from underlying fetchers', async () => {

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

@@ -13,11 +13,9 @@ 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 { 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 { LendProviders, SwapProviders } from '@/types/providers.js'
 import type { TransactionData } from '@/types/transaction.js'
 import { parseAssetAmount } from '@/utils/assets.js'
 import { SmartWallet } from '@/wallet/core/wallets/smart/abstract/SmartWallet.js'
@@ -69,13 +67,8 @@ export class DefaultSmartWallet extends SmartWallet {
     signers: Signer[],
     signer: LocalAccount,
     chainManager: ChainManager,
-    lendProviders?: {
-      morpho?: LendProvider<LendProviderConfig>
-      aave?: LendProvider<LendProviderConfig>
-    },
-    swapProviders?: {
-      uniswap?: SwapProvider<SwapProviderConfig>
-    },
+    lendProviders?: LendProviders,
+    swapProviders?: SwapProviders,
     supportedAssets?: Asset[],
     deploymentAddress?: Address,
     nonce?: bigint,
@@ -122,13 +115,8 @@ export class DefaultSmartWallet extends SmartWallet {
     signer: LocalAccount
     chainManager: ChainManager
     signers?: Signer[]
-    lendProviders?: {
-      morpho?: LendProvider<LendProviderConfig>
-      aave?: LendProvider<LendProviderConfig>
-    }
-    swapProviders?: {
-      uniswap?: SwapProvider<SwapProviderConfig>
-    }
+    lendProviders?: LendProviders
+    swapProviders?: SwapProviders
     supportedAssets?: Asset[]
     deploymentAddress?: Address
     nonce?: bigint

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

@@ -12,7 +12,6 @@ import { getRandomAddress } from '@/__mocks__/utils.js'
 import { createMockLendProvider } from '@/lend/__mocks__/MockLendProvider.js'
 import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import { SUPPORTED_TOKENS } from '@/supported/tokens.js'
 import type { LendProviderConfig } from '@/types/actions.js'
 import type { LendProvider, TransactionData } from '@/types/lend/index.js'
 import {