@eth-optimism/actions-sdk 0.3.0 → 0.5.0

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

@@ -83,8 +83,8 @@ function resolvePoolParams(
 export interface GetQuoteParams {
   assetIn: Asset
   assetOut: Asset
-  amountInWei?: bigint
-  amountOutWei?: bigint
+  amountInRaw?: bigint
+  amountOutRaw?: bigint
   chainId: SupportedChainId
   publicClient: PublicClient
   quoterAddress: Address
@@ -102,8 +102,8 @@ export async function getQuote(params: GetQuoteParams): Promise<SwapPrice> {
   const {
     assetIn,
     assetOut,
-    amountInWei,
-    amountOutWei,
+    amountInRaw,
+    amountOutRaw,
     chainId,
     publicClient,
     quoterAddress,
@@ -120,7 +120,7 @@ export async function getQuote(params: GetQuoteParams): Promise<SwapPrice> {
     tickSpacing,
   )
 
-  const isExactInput = amountInWei !== undefined
+  const isExactInput = amountInRaw !== undefined
 
   // Read pool mid-price and quote in parallel — no extra sequential RPC call
   const [sqrtPriceX96, quoteResult] = await Promise.all([
@@ -134,7 +134,7 @@ export async function getQuote(params: GetQuoteParams): Promise<SwapPrice> {
             {
               poolKey,
               zeroForOne,
-              exactAmount: amountInWei,
+              exactAmount: amountInRaw,
               hookData: '0x' as `0x${string}`,
             },
           ],
@@ -147,15 +147,15 @@ export async function getQuote(params: GetQuoteParams): Promise<SwapPrice> {
             {
               poolKey,
               zeroForOne,
-              exactAmount: amountOutWei!,
+              exactAmount: amountOutRaw!,
               hookData: '0x' as `0x${string}`,
             },
           ],
         }),
   ])
 
-  const amountIn = isExactInput ? amountInWei : quoteResult.result[0]
-  const amountOut = isExactInput ? quoteResult.result[0] : amountOutWei!
+  const amountIn = isExactInput ? amountInRaw : quoteResult.result[0]
+  const amountOut = isExactInput ? quoteResult.result[0] : amountOutRaw!
   const gasEstimate = quoteResult.result[1]
 
   const price = calculatePrice(amountIn, amountOut, assetIn, assetOut)
@@ -183,8 +183,8 @@ export async function getQuote(params: GetQuoteParams): Promise<SwapPrice> {
     priceInverse,
     amountIn: parseFloat(formatUnits(amountIn, assetIn.metadata.decimals)),
     amountOut: parseFloat(formatUnits(amountOut, assetOut.metadata.decimals)),
-    amountInWei: amountIn,
-    amountOutWei: amountOut,
+    amountInRaw: amountIn,
+    amountOutRaw: amountOut,
     priceImpact,
     route,
     gasEstimate,
@@ -192,8 +192,8 @@ export async function getQuote(params: GetQuoteParams): Promise<SwapPrice> {
 }
 
 export interface EncodeSwapParams {
-  amountInWei?: bigint
-  amountOutWei?: bigint
+  amountInRaw?: bigint
+  amountOutRaw?: bigint
   assetIn: Asset
   assetOut: Asset
   slippage: number
@@ -223,7 +223,7 @@ const TAKE_ALL = 0x0f
  */
 export function encodeUniversalRouterSwap(params: EncodeSwapParams): Hex {
   const {
-    amountInWei,
+    amountInRaw,
     assetIn,
     assetOut,
     slippage,
@@ -242,14 +242,14 @@ export function encodeUniversalRouterSwap(params: EncodeSwapParams): Hex {
     tickSpacing,
   )
 
-  const isExactInput = amountInWei !== undefined
+  const isExactInput = amountInRaw !== undefined
 
   let actions: Hex
   let actionParams: Hex[]
 
   if (isExactInput) {
     const minAmountOut =
-      (quote.amountOutWei * BigInt(Math.round((1 - slippage) * 10000))) / 10000n
+      (quote.amountOutRaw * BigInt(Math.round((1 - slippage) * 10000))) / 10000n
 
     actions =
       `0x${[SWAP_EXACT_IN_SINGLE, SETTLE_ALL, TAKE_ALL].map((a) => a.toString(16).padStart(2, '0')).join('')}` as Hex
@@ -259,18 +259,18 @@ export function encodeUniversalRouterSwap(params: EncodeSwapParams): Hex {
         {
           poolKey,
           zeroForOne,
-          amountIn: amountInWei,
+          amountIn: amountInRaw,
           amountOutMinimum: minAmountOut,
           hookData: '0x',
         },
       ]),
-      encodeAbiParameters(CURRENCY_AMOUNT_PARAMS, [tokenIn, amountInWei]),
+      encodeAbiParameters(CURRENCY_AMOUNT_PARAMS, [tokenIn, amountInRaw]),
       encodeAbiParameters(CURRENCY_AMOUNT_PARAMS, [tokenOut, minAmountOut]),
     ]
   } else {
     const maxAmountIn =
-      quote.amountInWei +
-      (quote.amountInWei * BigInt(Math.round(slippage * 10000))) / 10000n
+      quote.amountInRaw +
+      (quote.amountInRaw * BigInt(Math.round(slippage * 10000))) / 10000n
 
     actions =
       `0x${[SWAP_EXACT_OUT_SINGLE, SETTLE_ALL, TAKE_ALL].map((a) => a.toString(16).padStart(2, '0')).join('')}` as Hex
@@ -280,7 +280,7 @@ export function encodeUniversalRouterSwap(params: EncodeSwapParams): Hex {
         {
           poolKey,
           zeroForOne,
-          amountOut: quote.amountOutWei,
+          amountOut: quote.amountOutRaw,
           amountInMaximum: maxAmountIn,
           hookData: '0x',
         },
@@ -288,7 +288,7 @@ export function encodeUniversalRouterSwap(params: EncodeSwapParams): Hex {
       encodeAbiParameters(CURRENCY_AMOUNT_PARAMS, [tokenIn, maxAmountIn]),
       encodeAbiParameters(CURRENCY_AMOUNT_PARAMS, [
         tokenOut,
-        quote.amountOutWei,
+        quote.amountOutRaw,
       ]),
     ]
   }

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

@@ -0,0 +1,84 @@
+import { type Address, encodeAbiParameters, keccak256 } from 'viem'
+
+import { UNISWAP } from '@/constants/providers.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { assetPairs } from '@/swap/core/markets.js'
+import { POOL_KEY_ABI_TYPE } from '@/swap/providers/uniswap/abis.js'
+import type { Asset } from '@/types/asset.js'
+import type { SwapMarket } from '@/types/swap/index.js'
+
+import type { UniswapMarketConfig } from './types.js'
+
+/** Validated Uniswap market config with required fee and tickSpacing */
+export type ValidUniswapConfig = UniswapMarketConfig & {
+  fee: number
+  tickSpacing: number
+}
+
+/**
+ * Filter market allowlist to configs with required fee and tickSpacing.
+ */
+export function getValidMarketConfigs(
+  allowlist?: UniswapMarketConfig[],
+): ValidUniswapConfig[] {
+  return (allowlist ?? []).filter(
+    (f): f is ValidUniswapConfig =>
+      f.fee !== undefined && f.tickSpacing !== undefined,
+  )
+}
+
+/**
+ * Expand a single UniswapMarketConfig into SwapMarket objects for a given chain.
+ * Used as the `toMarkets` callback for shared findMarket/expandMarkets.
+ */
+export function configToMarkets(
+  config: ValidUniswapConfig,
+  chainId: SupportedChainId,
+  asset?: Asset,
+): SwapMarket[] {
+  return assetPairs(config.assets, asset)
+    .map(([a, b]) =>
+      pairToMarket(a, b, chainId, config.fee, config.tickSpacing),
+    )
+    .filter((m): m is SwapMarket => m !== null)
+}
+
+/**
+ * Build a SwapMarket from two assets and V4 pool parameters.
+ * Computes a deterministic poolId from the sorted pool key.
+ * @returns SwapMarket, or null if either asset lacks an address on this chain
+ */
+function pairToMarket(
+  assetA: Asset,
+  assetB: Asset,
+  chainId: SupportedChainId,
+  fee: number,
+  tickSpacing: number,
+): SwapMarket | null {
+  const addrA = assetA.address[chainId]
+  const addrB = assetB.address[chainId]
+  if (!addrA || addrA === 'native' || !addrB || addrB === 'native') return null
+
+  const [currency0, currency1] =
+    addrA.toLowerCase() < addrB.toLowerCase() ? [addrA, addrB] : [addrB, addrA]
+
+  // V4 requires currency0 < currency1 for deterministic pool keys
+  // PoolId = keccak256(abi.encode(PoolKey)) per V4's PoolIdLibrary
+  // @see https://github.com/Uniswap/v4-core/blob/main/src/types/PoolId.sol
+  const poolId = keccak256(
+    encodeAbiParameters(POOL_KEY_ABI_TYPE, [
+      currency0 as Address,
+      currency1 as Address,
+      fee,
+      tickSpacing,
+      '0x0000000000000000000000000000000000000000' as Address,
+    ]),
+  )
+
+  return {
+    marketId: { poolId, chainId },
+    assets: [assetA, assetB],
+    fee,
+    provider: UNISWAP,
+  }
+}

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

@@ -14,11 +14,12 @@ export interface UniswapMarketConfig extends SwapMarketConfig {
 }
 
 /**
- * Uniswap swap provider configuration
+ * Uniswap swap provider configuration.
+ * Provider-level values override the shared SwapGlobalConfig.
  */
 export interface UniswapSwapProviderConfig extends SwapProviderConfig {
   marketAllowlist?: UniswapMarketConfig[]
   marketBlocklist?: UniswapMarketConfig[]
-  /** Permit2 approval expiry in seconds from now. Defaults to 30 days. */
-  permit2ExpirySeconds?: number
+  /** Permit2 sub-approval expiration override in seconds from now. */
+  permit2ExpirationSeconds?: number
 }

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

@@ -0,0 +1,226 @@
+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 {
+  getChainConfig,
+  getSupportedChainIds,
+  getValidMarketConfigs,
+} from '@/swap/providers/velodrome/config.js'
+import {
+  buildTokenApproval,
+  encodePoolSwap,
+  fetchPoolQuote,
+} from '@/swap/providers/velodrome/encoding/index.js'
+import {
+  configToMarkets,
+  resolvePoolConfig,
+} from '@/swap/providers/velodrome/markets.js'
+import type {
+  VelodromeMarketConfig,
+  VelodromeSwapProviderConfig,
+} from '@/swap/providers/velodrome/types.js'
+import type { Asset } from '@/types/asset.js'
+import type {
+  GetSwapMarketParams,
+  GetSwapMarketsParams,
+  ResolvedSwapParams,
+  SwapMarket,
+  SwapQuote,
+  SwapTransaction,
+} from '@/types/swap/index.js'
+import { getAssetAddress, isNativeAsset } from '@/utils/assets.js'
+
+/**
+ * Velodrome/Aerodrome swap provider for OP Stack chains.
+ * Supports v2 AMM pools, CL/Slipstream concentrated liquidity pools,
+ * v2 routers (Optimism, Base), leaf routers (Relay chains), and Universal Router (Base Sepolia).
+ */
+export class VelodromeSwapProvider extends SwapProvider<VelodromeSwapProviderConfig> {
+  /** @returns Chain IDs where Velodrome/Aerodrome contracts are deployed */
+  protocolSupportedChainIds(): SupportedChainId[] {
+    return getSupportedChainIds()
+  }
+
+  /**
+   * Build a swap transaction from raw parameters.
+   * @param params - Resolved swap parameters (amounts as raw bigint, defaults applied)
+   * @returns Transaction data ready for wallet execution
+   * @throws If amountOut is provided (Velodrome only supports exact-input swaps)
+   */
+  protected async _execute(
+    params: ResolvedSwapParams,
+  ): Promise<SwapTransaction> {
+    if (params.amountOutRaw !== undefined) {
+      throw new Error(
+        'Velodrome/Aerodrome does not support exact-output swaps. Provide amountIn instead of amountOut.',
+      )
+    }
+
+    const swapQuote = await this._getQuote({
+      assetIn: params.assetIn,
+      assetOut: params.assetOut,
+      amountIn: params.amountInRaw
+        ? parseFloat(
+            formatUnits(params.amountInRaw, params.assetIn.metadata.decimals),
+          )
+        : undefined,
+      chainId: params.chainId,
+      slippage: params.slippage,
+      deadline: params.deadline,
+      recipient: params.recipient,
+    })
+    return this.buildSwapTransactions(swapQuote)
+  }
+
+  /**
+   * Find a specific market by poolId from the allowlist.
+   * @param params - Pool ID and chain to look up
+   * @returns Matching market
+   * @throws If no matching market found in config
+   */
+  protected async _getMarket(params: GetSwapMarketParams): Promise<SwapMarket> {
+    return findMarket(
+      getValidMarketConfigs(this._config.marketAllowlist),
+      params.chainId,
+      params.poolId,
+      configToMarkets,
+    )
+  }
+
+  /**
+   * Expand the market allowlist into concrete SwapMarket objects.
+   * @param params - Optional filters (chainId, asset)
+   * @returns All configured markets matching the filters
+   */
+  protected async _getMarkets(
+    params: GetSwapMarketsParams,
+  ): Promise<SwapMarket[]> {
+    return expandMarkets({
+      configs: getValidMarketConfigs(this._config.marketAllowlist),
+      filters: params,
+      supportedChainIds: this.supportedChainIds(),
+      toMarkets: configToMarkets,
+    })
+  }
+
+  /**
+   * Get a full swap quote with pricing, slippage bounds, and pre-built execution data.
+   * @param params - Quote parameters (assets, amounts, chain, slippage, deadline)
+   * @returns SwapQuote with amounts, price, route, and encoded calldata
+   * @throws If amountOut is provided (Velodrome only supports exact-input)
+   */
+  protected async _getQuote(
+    params: SwapQuoteParamsResolved,
+  ): Promise<SwapQuote> {
+    const { chainId, assetIn, assetOut } = params
+
+    if (params.amountOut !== undefined) {
+      throw new Error(
+        'Velodrome/Aerodrome does not support exact-output swaps. Provide amountIn instead of amountOut.',
+      )
+    }
+
+    const chain = getChainConfig(chainId)
+    const publicClient = this.chainManager.getPublicClient(chainId)
+    const poolConfig = this.resolveVelodromeMarketConfig(
+      assetIn,
+      assetOut,
+      chainId,
+    )
+    const { slippage, now, deadline, recipient, amountInRaw } =
+      this.resolveQuoteDefaults(params)
+
+    const { internalQuote, providerContext } = await fetchPoolQuote(
+      poolConfig,
+      { assetIn, assetOut, amountInRaw, chainId, publicClient, chain },
+    )
+
+    const { amountOutMinRaw, amountOutMin } = this.computeSlippageBounds(
+      internalQuote.amountOutRaw,
+      slippage,
+      assetOut,
+    )
+
+    const swapCalldata = encodePoolSwap(poolConfig, {
+      assetIn,
+      assetOut,
+      amountInRaw,
+      amountOutMinRaw,
+      recipient,
+      deadline,
+      chainId,
+      chain,
+    })
+
+    return {
+      assetIn,
+      assetOut,
+      chainId,
+      amountIn: internalQuote.amountIn,
+      amountInRaw,
+      amountOut: internalQuote.amountOut,
+      amountOutRaw: internalQuote.amountOutRaw,
+      amountOutMin,
+      amountOutMinRaw,
+      price: internalQuote.amountOut / internalQuote.amountIn,
+      priceInverse: internalQuote.amountIn / internalQuote.amountOut,
+      priceImpact: internalQuote.priceImpact,
+      route: internalQuote.route,
+      execution: {
+        swapCalldata,
+        routerAddress: chain.contracts.router,
+        value: isNativeAsset(assetIn) ? amountInRaw : 0n,
+        providerContext,
+      },
+      provider: VELODROME,
+      slippage,
+      deadline,
+      quotedAt: now,
+      expiresAt: deadline,
+      gasEstimate: internalQuote.gasEstimate,
+      quotedRecipient: recipient,
+    }
+  }
+
+  protected async _buildApprovals(quote: SwapQuote) {
+    const chain = getChainConfig(quote.chainId)
+    const publicClient = this.chainManager.getPublicClient(quote.chainId)
+
+    const tokenApproval = isNativeAsset(quote.assetIn)
+      ? undefined
+      : await buildTokenApproval(
+          getAssetAddress(quote.assetIn, quote.chainId),
+          chain.contracts.router,
+          chain.metadata.routerType,
+          quote.amountInRaw,
+          quote.recipient!,
+          publicClient,
+        )
+
+    return { tokenApproval }
+  }
+
+  /**
+   * Resolve market config to a discriminated pool config.
+   * @throws If pair not in allowlist, or has both/neither stable and tickSpacing
+   */
+  private resolveVelodromeMarketConfig(
+    assetIn: Asset,
+    assetOut: Asset,
+    chainId: SupportedChainId,
+  ) {
+    const config = this.resolveMarketConfig(assetIn, assetOut, chainId) as
+      | VelodromeMarketConfig
+      | undefined
+    if (!config) {
+      throw new Error(
+        `No market config for pair ${assetIn.metadata.symbol}/${assetOut.metadata.symbol}`,
+      )
+    }
+    return resolvePoolConfig(config)
+  }
+}