@eth-optimism/actions-sdk 0.4.0 → 0.5.0

package/src/swap/core/SwapProvider.ts

@@ -3,6 +3,10 @@ import { formatUnits } from 'viem'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
 import { ACTIONS_SUPPORTED_CHAIN_IDS } from '@/constants/supportedChains.js'
+import type {
+  SwapExecuteParamsResolved,
+  SwapQuoteParamsResolved,
+} from '@/ens/types.js'
 import type { ChainManager } from '@/services/ChainManager.js'
 import { UNIVERSAL_ROUTER_MSG_SENDER } from '@/swap/core/markets.js'
 import type { SwapSettings } from '@/types/actions.js'
@@ -16,7 +20,6 @@ import type {
   SwapMarketConfig,
   SwapProviderConfig,
   SwapQuote,
-  SwapQuoteParams,
   SwapTransaction,
   SwapTransactionData,
 } from '@/types/swap/index.js'
@@ -40,6 +43,7 @@ import {
   validateNotBothAmounts,
   validateNotSameAsset,
   validateNotZeroAddress,
+  validateRecipient,
   validateSlippage,
 } from '@/utils/validation.js'
 
@@ -129,14 +133,15 @@ export abstract class SwapProvider<
    * @returns Transaction data ready for wallet execution
    */
   async execute(
-    params: SwapExecuteParams | SwapQuote,
+    params: SwapExecuteParamsResolved | SwapQuote,
   ): Promise<SwapTransaction> {
-    this.validateSwapExecute(params)
-
     if (QUOTE_DISCRIMINATOR in params) {
+      this.validateSwapExecute(params)
       return this.executeFromQuote(params)
     }
 
+    this.validateSwapExecute(params)
+
     // Raw params only
     validateNotBothAmounts(params.amountIn, params.amountOut)
     validateNotZeroAddress(params.walletAddress, 'walletAddress')
@@ -149,7 +154,7 @@ export abstract class SwapProvider<
    * @param params - Quote parameters (assets, amounts, chain, slippage)
    * @returns SwapQuote with pricing, amounts, and pre-encoded calldata
    */
-  async getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+  async getQuote(params: SwapQuoteParamsResolved): Promise<SwapQuote> {
     validateChainSupported(params.chainId, this.supportedChainIds())
     return this._getQuote(params)
   }
@@ -267,7 +272,7 @@ export abstract class SwapProvider<
    * @param params - Raw quote params from the user
    * @returns Resolved slippage, deadline, recipient, amountInRaw, and current timestamp
    */
-  protected resolveQuoteDefaults(params: SwapQuoteParams) {
+  protected resolveQuoteDefaults(params: SwapQuoteParamsResolved) {
     const slippage = params.slippage ?? this.defaultSlippage
     const now = Math.floor(Date.now() / 1000)
     const deadline = params.deadline ?? now + this.quoteExpirationSeconds
@@ -449,13 +454,7 @@ export abstract class SwapProvider<
     validateAmountPositiveIfExists(params.amountIn)
     validateAmountPositiveIfExists(params.amountOut)
     validateSlippage(params.slippage ?? this.defaultSlippage, this.maxSlippage)
-    this.validateRecipient(params)
-  }
-
-  private validateRecipient(params: SwapExecuteParams | SwapQuote): void {
-    if ('recipient' in params && params.recipient) {
-      validateNotZeroAddress(params.recipient, 'recipient')
-    }
+    validateRecipient('recipient' in params ? params.recipient : undefined)
   }
 
   private validateQuoteExpiration(quote: SwapQuote): void {
@@ -467,7 +466,7 @@ export abstract class SwapProvider<
     }
   }
 
-  private resolveParams(params: SwapExecuteParams): ResolvedSwapParams {
+  private resolveParams(params: SwapExecuteParamsResolved): ResolvedSwapParams {
     return {
       amountInRaw: parseAssetAmount(params.assetIn, params.amountIn),
       amountOutRaw: parseAssetAmount(params.assetOut, params.amountOut),
@@ -555,7 +554,9 @@ export abstract class SwapProvider<
     params: ResolvedSwapParams,
   ): Promise<SwapTransaction>
 
-  protected abstract _getQuote(params: SwapQuoteParams): Promise<SwapQuote>
+  protected abstract _getQuote(
+    params: SwapQuoteParamsResolved,
+  ): Promise<SwapQuote>
 
   /**
    * Build provider-specific approval transactions for a swap.

package/src/swap/namespaces/BaseSwapNamespace.ts

@@ -1,4 +1,5 @@
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { SwapQuoteParamsResolved } from '@/ens/types.js'
 import type { SwapProvider } from '@/swap/core/SwapProvider.js'
 import type { SwapProviderName, SwapSettings } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
@@ -11,15 +12,21 @@ import type {
   SwapQuote,
   SwapQuoteParams,
 } from '@/types/swap/index.js'
+import { passthroughResolver, type RecipientResolver } from '@/utils/ens.js'
 
 /**
  * Base swap namespace with shared read-only operations
  */
 export abstract class BaseSwapNamespace {
+  protected readonly resolveRecipient: RecipientResolver
+
   constructor(
     protected readonly providers: SwapProviders,
+    resolveRecipient?: RecipientResolver,
     protected readonly settings?: SwapSettings,
-  ) {}
+  ) {
+    this.resolveRecipient = resolveRecipient ?? passthroughResolver
+  }
 
   /**
    * Get a swap quote with pre-built execution data.
@@ -29,30 +36,31 @@ export abstract class BaseSwapNamespace {
    * @returns The best available SwapQuote
    */
   async getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+    const recipient = await this.resolveRecipient(params.recipient)
+    const resolved: SwapQuoteParamsResolved = { ...params, recipient }
+
     // Explicit provider — skip routing
-    if (params.provider) {
-      const provider = this.resolveProvider(
-        params.provider,
-        params.assetIn,
-        params.assetOut,
-        params.chainId,
-      )
-      return provider.getQuote(params)
+    if (resolved.provider) {
+      return this.resolveProvider(
+        resolved.provider,
+        resolved.assetIn,
+        resolved.assetOut,
+        resolved.chainId,
+      ).getQuote(resolved)
     }
 
     // Price routing — quote all eligible providers, return best
     if (this.settings?.routing === 'price') {
-      return this.getBestQuote(params)
+      return this.getBestQuote(resolved)
     }
 
     // No routing — resolve single provider via fallback logic
-    const provider = this.resolveProvider(
+    return this.resolveProvider(
       undefined,
-      params.assetIn,
-      params.assetOut,
-      params.chainId,
-    )
-    return provider.getQuote(params)
+      resolved.assetIn,
+      resolved.assetOut,
+      resolved.chainId,
+    ).getQuote(resolved)
   }
 
   /**
@@ -61,7 +69,9 @@ export abstract class BaseSwapNamespace {
    * @returns The quote with the highest amountOut
    * @throws If no provider returns a valid quote
    */
-  private async getBestQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+  private async getBestQuote(
+    params: SwapQuoteParamsResolved,
+  ): Promise<SwapQuote> {
     const quotes = await this.fetchAllQuotes(params)
 
     let best: SwapQuote | null = null
@@ -86,7 +96,9 @@ export abstract class BaseSwapNamespace {
    * @param params - Quote parameters
    * @returns Array of successful quotes (may be empty if all providers fail)
    */
-  private async fetchAllQuotes(params: SwapQuoteParams): Promise<SwapQuote[]> {
+  private async fetchAllQuotes(
+    params: SwapQuoteParamsResolved,
+  ): Promise<SwapQuote[]> {
     const eligible = this.getAllProviders().filter((p) =>
       p.isMarketSupported(params.assetIn, params.assetOut, params.chainId),
     )
@@ -116,17 +128,21 @@ export abstract class BaseSwapNamespace {
    * @returns Array of SwapQuotes sorted by amountOut descending (best first)
    */
   async getQuotes(params: SwapQuoteParams): Promise<SwapQuote[]> {
-    if (params.provider) {
-      const provider = this.resolveProvider(
-        params.provider,
-        params.assetIn,
-        params.assetOut,
-        params.chainId,
-      )
-      return [await provider.getQuote(params)]
+    const recipient = await this.resolveRecipient(params.recipient)
+    const resolved: SwapQuoteParamsResolved = { ...params, recipient }
+
+    if (resolved.provider) {
+      return [
+        await this.resolveProvider(
+          resolved.provider,
+          resolved.assetIn,
+          resolved.assetOut,
+          resolved.chainId,
+        ).getQuote(resolved),
+      ]
     }
 
-    const quotes = await this.fetchAllQuotes(params)
+    const quotes = await this.fetchAllQuotes(resolved)
     return quotes.sort((a, b) =>
       a.amountOutRaw > b.amountOutRaw
         ? -1

package/src/swap/namespaces/WalletSwapNamespace.ts

@@ -1,4 +1,5 @@
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { SwapExecuteParamsResolved } from '@/ens/types.js'
 import { QUOTE_DISCRIMINATOR } from '@/swap/core/SwapProvider.js'
 import { BaseSwapNamespace } from '@/swap/namespaces/BaseSwapNamespace.js'
 import type { SwapSettings } from '@/types/actions.js'
@@ -10,6 +11,7 @@ import type {
   SwapTransaction,
   WalletSwapParams,
 } from '@/types/swap/index.js'
+import type { RecipientResolver } from '@/utils/ens.js'
 import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
 
 /**
@@ -20,9 +22,10 @@ export class WalletSwapNamespace extends BaseSwapNamespace {
   constructor(
     providers: SwapProviders,
     private readonly wallet: Wallet,
+    resolveRecipient?: RecipientResolver,
     settings?: SwapSettings,
   ) {
-    super(providers, settings)
+    super(providers, resolveRecipient, settings)
   }
 
   /**
@@ -54,11 +57,16 @@ export class WalletSwapNamespace extends BaseSwapNamespace {
    */
   async execute(params: WalletSwapParams | SwapQuote): Promise<SwapReceipt> {
     // Inject walletAddress — raw params need it for validation,
-    // quotes need it for on-chain allowance checks during approval building
-    const executeParams =
+    // quotes need it for on-chain allowance checks during approval building.
+    // Resolve ENS recipient here so providers only ever receive an Address.
+    const executeParams: SwapExecuteParamsResolved | SwapQuote =
       QUOTE_DISCRIMINATOR in params
         ? { ...params, recipient: this.wallet.address }
-        : { ...params, walletAddress: this.wallet.address }
+        : {
+            ...params,
+            walletAddress: this.wallet.address,
+            recipient: await this.resolveRecipient(params.recipient),
+          }
 
     const provider = this.resolveProvider(
       params.provider,

package/src/swap/namespaces/__tests__/BaseSwapNamespace.spec.ts

@@ -67,6 +67,7 @@ describe('BaseSwapNamespace', () => {
 
       const namespace = new ActionsSwapNamespace(
         { uniswap: cheapProvider, velodrome: expensiveProvider },
+        undefined,
         { routing: 'price' },
       )
 
@@ -94,6 +95,7 @@ describe('BaseSwapNamespace', () => {
 
       const namespace = new ActionsSwapNamespace(
         { uniswap: failingProvider, velodrome: workingProvider },
+        undefined,
         { routing: 'price' },
       )
 
@@ -115,6 +117,7 @@ describe('BaseSwapNamespace', () => {
 
       const namespace = new ActionsSwapNamespace(
         { uniswap: failingProvider },
+        undefined,
         { routing: 'price' },
       )
 
@@ -140,6 +143,7 @@ describe('BaseSwapNamespace', () => {
 
       const namespace = new ActionsSwapNamespace(
         { uniswap: cheapProvider, velodrome: expensiveProvider },
+        undefined,
         { routing: 'price' },
       )
 

package/src/swap/providers/uniswap/UniswapSwapProvider.ts

@@ -2,6 +2,7 @@ import { formatUnits } from 'viem'
 
 import { UNISWAP } from '@/constants/providers.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { SwapQuoteParamsResolved } from '@/ens/types.js'
 import { expandMarkets, findMarket } from '@/swap/core/markets.js'
 import { SwapProvider } from '@/swap/core/SwapProvider.js'
 import {
@@ -27,7 +28,6 @@ import type {
   ResolvedSwapParams,
   SwapMarket,
   SwapQuote,
-  SwapQuoteParams,
   SwapTransaction,
 } from '@/types/swap/index.js'
 import { isNativeAsset, parseAssetAmount } from '@/utils/assets.js'
@@ -84,7 +84,9 @@ export class UniswapSwapProvider extends SwapProvider<UniswapSwapProviderConfig>
     )
   }
 
-  protected async _getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+  protected async _getQuote(
+    params: SwapQuoteParamsResolved,
+  ): Promise<SwapQuote> {
     const { chainId, assetIn, assetOut } = params
     const addresses = getUniswapAddresses(chainId)
     const publicClient = this.chainManager.getPublicClient(chainId)

package/src/swap/providers/velodrome/VelodromeSwapProvider.ts

@@ -2,6 +2,7 @@ import { formatUnits } from 'viem'
 
 import { VELODROME } from '@/constants/providers.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { SwapQuoteParamsResolved } from '@/ens/types.js'
 import { expandMarkets, findMarket } from '@/swap/core/markets.js'
 import { SwapProvider } from '@/swap/core/SwapProvider.js'
 import {
@@ -29,7 +30,6 @@ import type {
   ResolvedSwapParams,
   SwapMarket,
   SwapQuote,
-  SwapQuoteParams,
   SwapTransaction,
 } from '@/types/swap/index.js'
 import { getAssetAddress, isNativeAsset } from '@/utils/assets.js'
@@ -113,7 +113,9 @@ export class VelodromeSwapProvider extends SwapProvider<VelodromeSwapProviderCon
    * @returns SwapQuote with amounts, price, route, and encoded calldata
    * @throws If amountOut is provided (Velodrome only supports exact-input)
    */
-  protected async _getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+  protected async _getQuote(
+    params: SwapQuoteParamsResolved,
+  ): Promise<SwapQuote> {
     const { chainId, assetIn, assetOut } = params
 
     if (params.amountOut !== undefined) {

package/src/swap/providers/velodrome/__tests__/VelodromeSwapProvider.test.ts

@@ -34,6 +34,7 @@ function createMockChainManager(): ChainManager {
 
   return {
     getPublicClient: vi.fn().mockReturnValue(mockPublicClient),
+    tryGetPublicClient: vi.fn().mockReturnValue(undefined),
     getSupportedChains: vi.fn().mockReturnValue([CHAIN_ID]),
   } as unknown as ChainManager
 }

package/src/types/swap/base.ts

@@ -1,6 +1,7 @@
 import type { Address, Hex } from 'viem'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { EnsName } from '@/ens/types.js'
 import type { SwapProviderName } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type { TransactionData } from '@/types/transaction.js'
@@ -88,8 +89,8 @@ export interface WalletSwapParams {
   slippage?: number
   /** Transaction deadline as Unix timestamp. Defaults to now + 1 minute. */
   deadline?: number
-  /** Recipient address. Defaults to wallet address. */
-  recipient?: Address
+  /** Recipient address or ENS name (e.g. "vitalik.eth"). Defaults to wallet address. */
+  recipient?: Address | EnsName
   /** Explicitly select a swap provider. Overrides routing config. */
   provider?: SwapProviderName
 }
@@ -156,8 +157,8 @@ export interface SwapQuoteParams {
   slippage?: number
   /** Transaction deadline as Unix timestamp */
   deadline?: number
-  /** Recipient address */
-  recipient?: Address
+  /** Recipient address or ENS name (e.g. "vitalik.eth"). Defaults to wallet address. */
+  recipient?: Address | EnsName
   /** Explicitly select a swap provider */
   provider?: SwapProviderName
 }

package/src/utils/ens.test.ts

@@ -0,0 +1,104 @@
+import type { Address, PublicClient } from 'viem'
+import { zeroAddress } from 'viem'
+import { describe, expect, it, vi } from 'vitest'
+
+import { resolveAddress } from '@/utils/ens.js'
+
+const REAL_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045' as Address
+const ZERO_ADDRESS = zeroAddress
+
+function mockClient(
+  returnValue: Address | null,
+  rejects = false,
+): PublicClient {
+  const getEnsAddress = rejects
+    ? vi.fn().mockRejectedValue(new Error('network error'))
+    : vi.fn().mockResolvedValue(returnValue)
+  return { getEnsAddress } as unknown as PublicClient
+}
+
+describe('resolveAddress', () => {
+  describe('hex address input', () => {
+    it('returns a valid hex address as-is', async () => {
+      expect(await resolveAddress(REAL_ADDRESS)).toBe(REAL_ADDRESS)
+    })
+
+    it('does not require a mainnet client for hex addresses', async () => {
+      await expect(resolveAddress(REAL_ADDRESS)).resolves.toBe(REAL_ADDRESS)
+    })
+  })
+
+  describe('ENS name input', () => {
+    it('resolves a valid ENS name', async () => {
+      const client = mockClient(REAL_ADDRESS)
+      const result = await resolveAddress('vitalik.eth', client)
+      expect(result).toBe(REAL_ADDRESS)
+      expect(client.getEnsAddress).toHaveBeenCalledWith({ name: 'vitalik.eth' })
+    })
+
+    it('normalises the ENS name before resolving', async () => {
+      const client = mockClient(REAL_ADDRESS)
+      await resolveAddress('Vitalik.ETH', client)
+      expect(client.getEnsAddress).toHaveBeenCalledWith({ name: 'vitalik.eth' })
+    })
+
+    it('throws EnsNotConfiguredError when no mainnet client is provided', async () => {
+      const { EnsNotConfiguredError } = await import('@/ens/errors.js')
+      await expect(resolveAddress('vitalik.eth')).rejects.toThrow(
+        EnsNotConfiguredError,
+      )
+    })
+
+    it('includes chain ID 1 in the error when no mainnet client provided', async () => {
+      await expect(resolveAddress('vitalik.eth')).rejects.toThrow('1')
+    })
+
+    it('throws when ENS name cannot be resolved (returns null)', async () => {
+      const client = mockClient(null)
+      await expect(resolveAddress('unresolvable.eth', client)).rejects.toThrow(
+        '"unresolvable.eth" could not be resolved',
+      )
+    })
+
+    it('throws when ENS name resolves to zero address', async () => {
+      const client = mockClient(ZERO_ADDRESS)
+      await expect(resolveAddress('zero.eth', client)).rejects.toThrow(
+        'zero address',
+      )
+    })
+
+    it('throws with RPC error label on network failure', async () => {
+      const client = mockClient(null, true)
+      await expect(resolveAddress('vitalik.eth', client)).rejects.toThrow(
+        'RPC error',
+      )
+    })
+
+    it('preserves the original cause on RPC failure', async () => {
+      const client = mockClient(null, true)
+      let caught: Error | undefined
+      try {
+        await resolveAddress('vitalik.eth', client)
+      } catch (e) {
+        caught = e as Error
+      }
+      expect(caught?.cause).toBeInstanceOf(Error)
+      expect((caught?.cause as Error).message).toBe('network error')
+    })
+  })
+
+  describe('invalid input', () => {
+    it('throws for ENS-shaped strings that fail normalisation', async () => {
+      // Has a dot so satisfies EnsName, but contains invalid ENS characters
+      await expect(
+        resolveAddress('not!valid.eth', {} as PublicClient),
+      ).rejects.toThrow('Invalid address or ENS name')
+    })
+
+    it('includes the invalid input in the error message', async () => {
+      await expect(
+        resolveAddress('!!bad!!.eth', {} as PublicClient),
+      ).rejects.toThrow('"!!bad!!.eth"')
+    })
+  })
+})

package/src/utils/ens.ts

@@ -0,0 +1,85 @@
+import type { Address, PublicClient } from 'viem'
+import { isAddress, isAddressEqual, zeroAddress } from 'viem'
+import { normalize } from 'viem/ens'
+
+import {
+  EnsNotConfiguredError,
+  EnsResolutionError,
+  EnsRpcError,
+} from '@/ens/errors.js'
+import type { EnsName } from '@/ens/types.js'
+
+export { type EnsName, isEnsName } from '@/ens/types.js'
+
+/** Resolves an ENS name or address to a checksummed hex Address, or returns undefined. */
+export type RecipientResolver = (
+  recipient: Address | EnsName | undefined,
+) => Promise<Address | undefined>
+
+/** Pass-through resolver used when no ENS resolution is configured. Throws on ENS names. */
+export const passthroughResolver: RecipientResolver = (r) => {
+  if (r !== undefined && !isAddress(r, { strict: false })) {
+    throw new Error(`ENS resolution is not configured; received "${r}"`)
+  }
+  return Promise.resolve(r as Address | undefined)
+}
+
+/**
+ * Low-level utility to resolve an ENS name or hex address to a checksummed hex address.
+ * Use this when you manage your own viem PublicClient (e.g. inside providers or scripts).
+ *
+ * If you have an {@link Actions} instance, prefer `actions.ens.getAddress()` instead —
+ * it handles client lookup and fallback automatically from your chain configuration.
+ *
+ * Hex addresses (0x...) are returned as-is after format validation.
+ * ENS names require a mainnet public client for on-chain resolution.
+ * @param input - Hex address (0x...) or ENS name (e.g. "vitalik.eth")
+ * @param mainnetClient - Public client connected to Ethereum mainnet (required for ENS names)
+ * @returns Resolved hex address
+ * @throws {EnsNotConfiguredError} If mainnet client is not provided
+ * @throws {EnsResolutionError} If the name is invalid or cannot be resolved
+ * @throws {EnsRpcError} If the RPC call fails
+ */
+export async function resolveAddress(
+  input: Address | EnsName,
+  mainnetClient?: PublicClient,
+): Promise<Address> {
+  if (isAddress(input, { strict: false })) return input
+
+  if (!mainnetClient) throw new EnsNotConfiguredError()
+
+  const normalized = (() => {
+    try {
+      return normalize(input)
+    } catch (cause) {
+      throw new EnsResolutionError(
+        `Invalid address or ENS name: "${input}"`,
+        input,
+        { cause },
+      )
+    }
+  })()
+
+  const resolved = await mainnetClient
+    .getEnsAddress({ name: normalized })
+    .catch((cause: unknown) => {
+      throw new EnsRpcError(
+        `ENS resolution failed for "${input}": RPC error`,
+        input,
+        { cause },
+      )
+    })
+
+  if (!resolved)
+    throw new EnsResolutionError(
+      `ENS name "${input}" could not be resolved`,
+      input,
+    )
+  if (isAddressEqual(resolved, zeroAddress)) {
+    throw new EnsResolutionError(
+      `ENS name "${input}" resolved to the zero address`,
+      input,
+    )
+  }
+  return resolved
+}

package/src/utils/validation.ts

@@ -1,4 +1,5 @@
 import type { Address } from 'viem'
+import { isAddress } from 'viem'
 
 import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type { Asset } from '@/types/asset.js'
@@ -74,3 +75,13 @@ export function validateAssetOnChain(
     )
   }
 }
+
+/**
+ * Validate that a resolved recipient address is not the zero address.
+ * ENS names are skipped — only resolved `Address` values are checked.
+ */
+export function validateRecipient(recipient: string | undefined): void {
+  if (recipient && isAddress(recipient)) {
+    validateNotZeroAddress(recipient, 'recipient')
+  }
+}

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

@@ -1,6 +1,7 @@
 import type { Address, LocalAccount } from 'viem'
 
 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 { fetchERC20Balance, fetchETHBalance } from '@/services/tokenBalance.js'
@@ -72,9 +73,11 @@ export abstract class Wallet {
       this.lend = new WalletLendNamespace(this.lendProviders, this)
     }
     if (Object.values(this.swapProviders).some(Boolean)) {
+      const ens = new EnsNamespace(this.chainManager)
       this.swap = new WalletSwapNamespace(
         this.swapProviders,
         this,
+        (r) => (r ? ens.getAddress(r) : Promise.resolve(undefined)),
         swapSettings,
       )
     }