@eth-optimism/actions-sdk 0.4.0 → 0.6.0

package/src/{swap → actions/swap}/namespaces/BaseSwapNamespace.ts

@@ -1,5 +1,16 @@
+import { BaseNamespace } from '@/actions/shared/BaseNamespace.js'
+import type { SwapProvider } from '@/actions/swap/core/SwapProvider.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import type { SwapProvider } from '@/swap/core/SwapProvider.js'
+import {
+  MarketNotAllowedError,
+  MarketNotFoundError,
+  ProviderNotConfiguredError,
+} from '@/core/error/errors.js'
+import type { SwapQuoteParamsResolved } from '@/services/nameservices/ens/types.js'
+import {
+  passthroughResolver,
+  type RecipientResolver,
+} from '@/services/nameservices/ens/utils.js'
 import type { SwapProviderName, SwapSettings } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type {
@@ -12,14 +23,25 @@ import type {
   SwapQuoteParams,
 } from '@/types/swap/index.js'
 
+type ConfiguredSwapProvider = SwapProvider<SwapProviderConfig>
+
 /**
  * Base swap namespace with shared read-only operations
  */
-export abstract class BaseSwapNamespace {
+export abstract class BaseSwapNamespace extends BaseNamespace<
+  ConfiguredSwapProvider,
+  SwapProviders
+> {
+  protected readonly resolveRecipient: RecipientResolver
+
   constructor(
-    protected readonly providers: SwapProviders,
+    providers: SwapProviders,
+    resolveRecipient?: RecipientResolver,
     protected readonly settings?: SwapSettings,
-  ) {}
+  ) {
+    super(providers)
+    this.resolveRecipient = resolveRecipient ?? passthroughResolver
+  }
 
   /**
    * Get a swap quote with pre-built execution data.
@@ -29,104 +51,56 @@ 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)
-  }
-
-  /**
-   * Fetch quotes from all eligible providers in parallel and return the best.
-   * @param params - Quote parameters
-   * @returns The quote with the highest amountOut
-   * @throws If no provider returns a valid quote
-   */
-  private async getBestQuote(params: SwapQuoteParams): Promise<SwapQuote> {
-    const quotes = await this.fetchAllQuotes(params)
-
-    let best: SwapQuote | null = null
-    for (const quote of quotes) {
-      if (!best || quote.amountOutRaw > best.amountOutRaw) {
-        best = quote
-      }
-    }
-
-    if (!best) {
-      throw new Error(
-        `All providers failed to quote ${params.assetIn.metadata.symbol}/${params.assetOut.metadata.symbol}`,
-      )
-    }
-
-    return best
+      resolved.assetIn,
+      resolved.assetOut,
+      resolved.chainId,
+    ).getQuote(resolved)
   }
 
   /**
-   * Fetch quotes from all eligible providers in parallel.
-   * Providers that don't support the pair or fail to quote are silently skipped.
-   * @param params - Quote parameters
-   * @returns Array of successful quotes (may be empty if all providers fail)
-   */
-  private async fetchAllQuotes(params: SwapQuoteParams): Promise<SwapQuote[]> {
-    const eligible = this.getAllProviders().filter((p) =>
-      p.isMarketSupported(params.assetIn, params.assetOut, params.chainId),
-    )
-
-    if (eligible.length === 0) {
-      throw new Error(
-        `No provider supports ${params.assetIn.metadata.symbol}/${params.assetOut.metadata.symbol} on chain ${params.chainId}`,
-      )
-    }
-
-    const results = await Promise.allSettled(
-      eligible.map((p) => p.getQuote(params)),
-    )
-
-    return results
-      .filter(
-        (r): r is PromiseFulfilledResult<SwapQuote> => r.status === 'fulfilled',
-      )
-      .map((r) => r.value)
-  }
-
-  /**
-   * Fetch quotes from all eligible providers in parallel.
+   * Fetch quotes from all providers with the wallet address as recipient.
    * Unlike getQuote(), returns all successful quotes instead of just the best.
    * If an explicit provider is specified, returns a single-element array from that provider.
    * @param params - Quote parameters (assets, amounts, chain, optional provider)
    * @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
@@ -149,7 +123,7 @@ export abstract class BaseSwapNamespace {
     if (provider) {
       const named = this.providers[provider]
       if (!named) {
-        throw new Error(`Swap provider "${provider}" not configured`)
+        throw new ProviderNotConfiguredError({ provider })
       }
       return named.getMarket(params)
     }
@@ -161,9 +135,10 @@ export abstract class BaseSwapNamespace {
         continue
       }
     }
-    throw new Error(
-      `Market with poolId ${params.poolId} not found on chain ${params.chainId}`,
-    )
+    throw new MarketNotFoundError({
+      chainId: params.chainId,
+      poolId: params.poolId,
+    })
   }
 
   /**
@@ -178,26 +153,6 @@ export abstract class BaseSwapNamespace {
     return results.flat()
   }
 
-  /**
-   * Get all supported chain IDs across all providers
-   */
-  supportedChainIds(): SupportedChainId[] {
-    const chainIds = new Set<SupportedChainId>()
-    for (const provider of this.getAllProviders()) {
-      for (const chainId of provider.supportedChainIds()) {
-        chainIds.add(chainId)
-      }
-    }
-    return Array.from(chainIds)
-  }
-
-  // SwapProviders keys are optional (uniswap?, velodrome?, etc.) so filter out unconfigured ones
-  protected getAllProviders(): Array<SwapProvider<SwapProviderConfig>> {
-    return Object.values(this.providers).filter(
-      (p): p is SwapProvider<SwapProviderConfig> => p !== undefined,
-    )
-  }
-
   /**
    * Resolve which provider handles a request.
    *
@@ -213,17 +168,17 @@ export abstract class BaseSwapNamespace {
     assetIn: Asset,
     assetOut: Asset,
     chainId: SupportedChainId,
-  ): SwapProvider<SwapProviderConfig> {
+  ): ConfiguredSwapProvider {
     const allProviders = this.getAllProviders()
     if (allProviders.length === 0) {
-      throw new Error('No swap provider configured')
+      throw new ProviderNotConfiguredError({ provider: 'swap' })
     }
 
     // 1. Explicit provider param
     if (provider) {
       const named = this.providers[provider]
       if (!named) {
-        throw new Error(`Swap provider "${provider}" not configured`)
+        throw new ProviderNotConfiguredError({ provider })
       }
       return named
     }
@@ -255,4 +210,67 @@ export abstract class BaseSwapNamespace {
 
     return allProviders[0]
   }
+
+  /**
+   * Fetch quotes from all eligible providers in parallel and return the best.
+   * @param params - Quote parameters
+   * @returns The quote with the highest amountOut
+   * @throws If no provider returns a valid quote
+   */
+  private async getBestQuote(
+    params: SwapQuoteParamsResolved,
+  ): Promise<SwapQuote> {
+    const quotes = await this.fetchAllQuotes(params)
+
+    let best: SwapQuote | null = null
+    for (const quote of quotes) {
+      if (!best || quote.amountOutRaw > best.amountOutRaw) {
+        best = quote
+      }
+    }
+
+    if (!best) {
+      throw new MarketNotAllowedError({
+        assetInSymbol: params.assetIn.metadata.symbol,
+        assetOutSymbol: params.assetOut.metadata.symbol,
+        chainId: params.chainId,
+        reason: 'All providers failed to quote this pair',
+      })
+    }
+
+    return best
+  }
+
+  /**
+   * Fetch quotes from all eligible providers in parallel.
+   * Providers that don't support the pair or fail to quote are silently skipped.
+   * @param params - Quote parameters
+   * @returns Array of successful quotes (may be empty if all providers fail)
+   */
+  private async fetchAllQuotes(
+    params: SwapQuoteParamsResolved,
+  ): Promise<SwapQuote[]> {
+    const eligible = this.getAllProviders().filter((p) =>
+      p.isMarketSupported(params.assetIn, params.assetOut, params.chainId),
+    )
+
+    if (eligible.length === 0) {
+      throw new MarketNotAllowedError({
+        assetInSymbol: params.assetIn.metadata.symbol,
+        assetOutSymbol: params.assetOut.metadata.symbol,
+        chainId: params.chainId,
+        reason: 'No configured provider supports this pair on this chain',
+      })
+    }
+
+    const results = await Promise.allSettled(
+      eligible.map((p) => p.getQuote(params)),
+    )
+
+    return results
+      .filter(
+        (r): r is PromiseFulfilledResult<SwapQuote> => r.status === 'fulfilled',
+      )
+      .map((r) => r.value)
+  }
 }

package/src/actions/swap/namespaces/WalletSwapNamespace.ts

@@ -0,0 +1,154 @@
+import { isAddressEqual } from 'viem'
+
+import { QUOTE_DISCRIMINATOR } from '@/actions/swap/core/SwapProvider.js'
+import { BaseSwapNamespace } from '@/actions/swap/namespaces/BaseSwapNamespace.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { SwapExecuteParamsResolved } from '@/services/nameservices/ens/types.js'
+import type { RecipientResolver } from '@/services/nameservices/ens/utils.js'
+import type { SwapSettings } from '@/types/actions.js'
+import type {
+  SwapProviders,
+  SwapQuote,
+  SwapQuoteParams,
+  SwapReceipt,
+  SwapTransaction,
+  WalletSwapParams,
+} from '@/types/swap/index.js'
+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'
+
+/**
+ * Wallet swap namespace with full operations including signing.
+ * Provides getQuote() for pricing and execute() for swapping tokens.
+ */
+export class WalletSwapNamespace extends BaseSwapNamespace {
+  constructor(
+    providers: SwapProviders,
+    private readonly wallet: Wallet,
+    resolveRecipient?: RecipientResolver,
+    settings?: SwapSettings,
+  ) {
+    super(providers, resolveRecipient, settings)
+  }
+
+  /**
+   * Get a swap quote with the wallet address as recipient.
+   * Ensures calldata is encoded for the real wallet, not a placeholder.
+   */
+  override async getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+    return super.getQuote({
+      ...params,
+      recipient: params.recipient ?? this.wallet.address,
+    })
+  }
+
+  /**
+   * Get quotes from all providers with the wallet address as recipient.
+   */
+  override async getQuotes(params: SwapQuoteParams): Promise<SwapQuote[]> {
+    return super.getQuotes({
+      ...params,
+      recipient: params.recipient ?? this.wallet.address,
+    })
+  }
+
+  /**
+   * Execute a token swap.
+   * Accepts either raw params (re-quotes internally) or a pre-built SwapQuote
+   * (skips re-quoting). When a pre-built quote is passed, its recipient must
+   * equal this wallet's address — otherwise the calldata would route output
+   * tokens to a different address (a real risk on Velodrome v2/leaf paths
+   * where the recipient is encoded directly into the swap call). Re-quote via
+   * `wallet.swap.getQuote(...)` to bind the quote to this wallet.
+   * @param params - Swap parameters or a pre-built SwapQuote from getQuote()
+   * @returns Swap receipt with transaction details
+   * @throws If `params` is a SwapQuote whose recipient differs from this wallet
+   */
+  async execute(params: WalletSwapParams | SwapQuote): Promise<SwapReceipt> {
+    const executeParams =
+      QUOTE_DISCRIMINATOR in params
+        ? this.requireQuoteForThisWallet(params)
+        : await this.resolveRawParams(params)
+
+    const provider = this.resolveProvider(
+      params.provider,
+      params.assetIn,
+      params.assetOut,
+      params.chainId,
+    )
+
+    const swapTx = await provider.execute(executeParams)
+    const receipt = await this.dispatch(swapTx, params.chainId)
+    return this.buildReceipt(swapTx, receipt)
+  }
+
+  /**
+   * Validate that a pre-built quote is bound to this wallet. Throws when the
+   * quote's recipient differs from `wallet.address` — silently swapping
+   * recipients would route output tokens to the wrong address on routers that
+   * encode the recipient directly into calldata (e.g. Velodrome v2/leaf).
+   */
+  private requireQuoteForThisWallet(quote: SwapQuote): SwapQuote {
+    if (!isAddressEqual(quote.recipient, this.wallet.address)) {
+      throw new Error(
+        `SwapQuote was generated for a different recipient (${quote.recipient}). ` +
+          `Re-quote via wallet.swap.getQuote(...) so calldata is bound to this wallet (${this.wallet.address}).`,
+      )
+    }
+    return quote
+  }
+
+  /**
+   * Inject `walletAddress` (needed for validation and on-chain allowance
+   * checks) and resolve any ENS recipient so providers only ever receive an
+   * `Address`.
+   */
+  private async resolveRawParams(
+    params: WalletSwapParams,
+  ): Promise<SwapExecuteParamsResolved> {
+    return {
+      ...params,
+      walletAddress: this.wallet.address,
+      recipient: await this.resolveRecipient(
+        params.recipient ?? this.wallet.address,
+      ),
+    }
+  }
+
+  private buildReceipt(
+    swapTx: SwapTransaction,
+    receipt: SwapReceipt['receipt'],
+  ): SwapReceipt {
+    return {
+      receipt,
+      amountIn: swapTx.amountIn,
+      amountOut: swapTx.amountOut,
+      amountInRaw: swapTx.amountInRaw,
+      amountOutRaw: swapTx.amountOutRaw,
+      assetIn: swapTx.assetIn,
+      assetOut: swapTx.assetOut,
+      price: swapTx.price,
+      priceImpact: swapTx.priceImpact,
+    }
+  }
+
+  /**
+   * Send a swap transaction, collecting any token/Permit2 approvals ahead
+   * of the swap call. Defers to `executeTransactionBatch` for the actual
+   * 1-vs-N send/sendBatch dispatch.
+   */
+  private dispatch(
+    swapTx: SwapTransaction,
+    chainId: SupportedChainId,
+  ): Promise<SwapReceipt['receipt']> {
+    const { transactionData } = swapTx
+    const txs: TransactionData[] = []
+    if (transactionData.tokenApproval) txs.push(transactionData.tokenApproval)
+    if (transactionData.permit2Approval) {
+      txs.push(transactionData.permit2Approval)
+    }
+    txs.push(transactionData.swap)
+    return executeTransactionBatch(this.wallet, txs, chainId)
+  }
+}

package/src/{swap → actions/swap}/namespaces/__tests__/BaseSwapNamespace.spec.ts

@@ -1,13 +1,13 @@
 import { describe, expect, it } from 'vitest'
 
-import type { SupportedChainId } from '@/constants/supportedChains.js'
-import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
-import type { ChainManager } from '@/services/ChainManager.js'
 import {
   createMockSwapProvider,
   MockSwapProvider,
-} from '@/swap/__mocks__/MockSwapProvider.js'
-import { ActionsSwapNamespace } from '@/swap/namespaces/ActionsSwapNamespace.js'
+} from '@/actions/swap/__mocks__/MockSwapProvider.js'
+import { ActionsSwapNamespace } from '@/actions/swap/namespaces/ActionsSwapNamespace.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
+import type { ChainManager } from '@/services/ChainManager.js'
 
 describe('BaseSwapNamespace', () => {
   const USDC = {
@@ -50,7 +50,7 @@ describe('BaseSwapNamespace', () => {
           amountIn: 100,
           chainId: 84532 as SupportedChainId,
         }),
-      ).rejects.toThrow('No swap provider configured')
+      ).rejects.toThrow("A 'swap' provider is not configured")
     })
   })
 
@@ -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' },
       )