@eth-optimism/actions-sdk 0.3.0 → 0.4.0

package/src/swap/providers/velodrome/encoding/helpers.ts

@@ -0,0 +1,82 @@
+import type { Address } from 'viem'
+import { formatUnits } from 'viem'
+
+import { WETH } from '@/constants/assets.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { UNIVERSAL_ROUTER_MSG_SENDER } from '@/swap/core/markets.js'
+import type { Asset } from '@/types/asset.js'
+import type { SwapPrice, SwapRoute } from '@/types/swap/index.js'
+import { getAssetAddress, isNativeAsset } from '@/utils/assets.js'
+
+export { UNIVERSAL_ROUTER_MSG_SENDER }
+
+/**
+ * Resolve an asset pair to on-chain token addresses for a given chain.
+ * Native ETH is converted to the WETH predeploy address.
+ * @param assetIn - Input asset
+ * @param assetOut - Output asset
+ * @param chainId - Target chain
+ * @returns Resolved token addresses
+ */
+export function resolveTokens(
+  assetIn: Asset,
+  assetOut: Asset,
+  chainId: SupportedChainId,
+): { tokenIn: Address; tokenOut: Address } {
+  const tokenIn = isNativeAsset(assetIn)
+    ? getWrappedNativeAddress(chainId)
+    : getAssetAddress(assetIn, chainId)
+  const tokenOut = isNativeAsset(assetOut)
+    ? getWrappedNativeAddress(chainId)
+    : getAssetAddress(assetOut, chainId)
+  return { tokenIn, tokenOut }
+}
+
+/**
+ * Get the wrapped native token address for a chain.
+ * Velodrome routers require WETH in Route structs, not address(0).
+ * @param chainId - Target chain
+ * @returns WETH address
+ * @throws If no WETH address configured for the chain
+ */
+export function getWrappedNativeAddress(chainId: SupportedChainId): Address {
+  const addr = WETH.address[chainId]
+  if (!addr || addr === 'native') {
+    throw new Error(`No WETH address configured for chain ${chainId}`)
+  }
+  return addr
+}
+
+/**
+ * Build a SwapPrice from raw quote data.
+ * @param assetIn - Input asset (for decimal conversion)
+ * @param assetOut - Output asset (for decimal conversion)
+ * @param amountInRaw - Input amount as raw bigint
+ * @param amountOutRaw - Output amount as raw bigint
+ * @param route - Swap route information
+ * @returns SwapPrice with human-readable and raw amounts
+ */
+export function buildSwapPrice(
+  assetIn: Asset,
+  assetOut: Asset,
+  amountInRaw: bigint,
+  amountOutRaw: bigint,
+  route: SwapRoute,
+): SwapPrice {
+  const amountIn = parseFloat(
+    formatUnits(amountInRaw, assetIn.metadata.decimals),
+  )
+  const amountOut = parseFloat(
+    formatUnits(amountOutRaw, assetOut.metadata.decimals),
+  )
+  return {
+    price: (amountOut / amountIn).toFixed(6),
+    priceInverse: (amountIn / amountOut).toFixed(6),
+    amountIn,
+    amountOut,
+    amountInRaw,
+    amountOutRaw,
+    priceImpact: 0,
+    route,
+  }
+}

package/src/swap/providers/velodrome/encoding/index.ts

@@ -0,0 +1,7 @@
+export type { PoolQuoteResult } from './poolRouter.js'
+export { encodePoolSwap, fetchPoolQuote } from './poolRouter.js'
+export { buildTokenApproval } from './routers/approval.js'
+export type { EncodeCLSwapParams, GetCLQuoteParams } from './routers/cl.js'
+export { encodeCLSwap, getCLQuote } from './routers/cl.js'
+export type { EncodeSwapParams, GetQuoteParams } from './routers/v2.js'
+export { encodeSwap, getQuote } from './routers/v2.js'

package/src/swap/providers/velodrome/encoding/poolRouter.ts

@@ -0,0 +1,124 @@
+import type { Address, Hex, PublicClient } from 'viem'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { VelodromeChainConfig } from '@/swap/providers/velodrome/config.js'
+import type { ResolvedPoolConfig } from '@/swap/providers/velodrome/types.js'
+import type { Asset } from '@/types/asset.js'
+import type { SwapPrice } from '@/types/swap/index.js'
+
+import { encodeCLSwap, getCLQuote } from './routers/cl.js'
+import { encodeSwap, getQuote } from './routers/v2.js'
+
+/** Internal result from pool-type-specific quoting */
+export interface PoolQuoteResult {
+  internalQuote: SwapPrice
+  providerContext: Record<string, unknown>
+}
+
+/**
+ * Fetch a price quote by routing to the correct pool type (v2 AMM or CL/Slipstream).
+ * @returns Internal quote and provider context for the SwapQuote
+ * @throws If CL pool requested on a chain without CL factory/quoter
+ */
+export async function fetchPoolQuote(
+  poolConfig: ResolvedPoolConfig,
+  params: {
+    assetIn: Asset
+    assetOut: Asset
+    amountInRaw: bigint
+    chainId: SupportedChainId
+    publicClient: PublicClient
+    chain: VelodromeChainConfig
+  },
+): Promise<PoolQuoteResult> {
+  const { assetIn, assetOut, amountInRaw, chainId, publicClient, chain } =
+    params
+
+  if (poolConfig.type === 'cl') {
+    if (!chain.contracts.clPoolFactory || !chain.contracts.clQuoterV2) {
+      throw new Error(`CL pools not supported on chain ${chainId}`)
+    }
+    const internalQuote = await getCLQuote({
+      assetIn,
+      assetOut,
+      amountInRaw,
+      chainId,
+      publicClient,
+      clFactoryAddress: chain.contracts.clPoolFactory,
+      clQuoterAddress: chain.contracts.clQuoterV2,
+      tickSpacing: poolConfig.tickSpacing,
+    })
+    return {
+      internalQuote,
+      providerContext: {
+        tickSpacing: poolConfig.tickSpacing,
+        clFactoryAddress: chain.contracts.clPoolFactory,
+        poolAddress: internalQuote.route.pools[0]?.address,
+      },
+    }
+  }
+
+  const internalQuote = await getQuote({
+    assetIn,
+    assetOut,
+    amountInRaw,
+    chainId,
+    publicClient,
+    routerAddress: chain.contracts.router,
+    routerType: chain.metadata.routerType,
+    stable: poolConfig.stable,
+    factoryAddress: chain.contracts.poolFactory,
+  })
+  return {
+    internalQuote,
+    providerContext: {
+      stable: poolConfig.stable,
+      factoryAddress: chain.contracts.poolFactory,
+      routerType: chain.metadata.routerType,
+    },
+  }
+}
+
+/**
+ * Encode swap calldata by routing to the correct pool type (v2 AMM or CL/Slipstream).
+ * @returns Encoded calldata as hex string
+ */
+export function encodePoolSwap(
+  poolConfig: ResolvedPoolConfig,
+  params: {
+    assetIn: Asset
+    assetOut: Asset
+    amountInRaw: bigint
+    amountOutMinRaw: bigint
+    recipient: Address
+    deadline: number
+    chainId: SupportedChainId
+    chain: VelodromeChainConfig
+  },
+): Hex {
+  if (poolConfig.type === 'cl') {
+    return encodeCLSwap({
+      assetIn: params.assetIn,
+      assetOut: params.assetOut,
+      amountInRaw: params.amountInRaw,
+      amountOutMin: params.amountOutMinRaw,
+      tickSpacing: poolConfig.tickSpacing,
+      recipient: params.recipient,
+      deadline: params.deadline,
+      chainId: params.chainId,
+    })
+  }
+
+  return encodeSwap({
+    assetIn: params.assetIn,
+    assetOut: params.assetOut,
+    amountInRaw: params.amountInRaw,
+    amountOutMin: params.amountOutMinRaw,
+    routerType: params.chain.metadata.routerType,
+    stable: poolConfig.stable,
+    factoryAddress: params.chain.contracts.poolFactory,
+    recipient: params.recipient,
+    deadline: params.deadline,
+    chainId: params.chainId,
+  })
+}

package/src/swap/providers/velodrome/encoding/routers/approval.ts

@@ -0,0 +1,45 @@
+import type { Address, PublicClient } from 'viem'
+import { encodeFunctionData, erc20Abi } from 'viem'
+
+import type { VelodromeRouterType } from '@/swap/providers/velodrome/config.js'
+import type { TransactionData } from '@/types/transaction.js'
+import { buildApprovalTxIfNeeded } from '@/utils/approve.js'
+
+/**
+ * Build a token approval or transfer transaction for swap input.
+ *
+ * Universal Router uses a direct ERC20 transfer instead of approve+transferFrom.
+ * This works because smart wallet batching (4337) bundles the transfer and swap
+ * into a single atomic UserOperation — the router receives tokens before executing
+ * the swap in the same transaction. The caller must already hold the tokens.
+ *
+ * Legacy routers (v2, leaf) use standard approve, approving only the deficit.
+ */
+export async function buildTokenApproval(
+  token: Address,
+  router: Address,
+  routerType: VelodromeRouterType,
+  amount: bigint,
+  owner: Address,
+  publicClient: PublicClient,
+): Promise<TransactionData | undefined> {
+  if (routerType === 'universal') {
+    return {
+      to: token,
+      data: encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'transfer',
+        args: [router, amount],
+      }),
+      value: 0n,
+    }
+  }
+
+  return buildApprovalTxIfNeeded({
+    publicClient,
+    token,
+    owner,
+    spender: router,
+    amount,
+  })
+}

package/src/swap/providers/velodrome/encoding/routers/cl.ts

@@ -0,0 +1,156 @@
+import type { Address, Hex, PublicClient } from 'viem'
+import { encodeAbiParameters, encodeFunctionData, encodePacked } from 'viem'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import {
+  CL_POOL_FACTORY_ABI,
+  CL_QUOTER_ABI,
+  UNIVERSAL_ROUTER_ABI,
+} from '@/swap/providers/velodrome/abis.js'
+import {
+  buildSwapPrice,
+  resolveTokens,
+  UNIVERSAL_ROUTER_MSG_SENDER,
+} from '@/swap/providers/velodrome/encoding/helpers.js'
+import type { Asset } from '@/types/asset.js'
+import type { SwapPrice, SwapRoute } from '@/types/swap/index.js'
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Quoting
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface GetCLQuoteParams {
+  assetIn: Asset
+  assetOut: Asset
+  amountInRaw: bigint
+  chainId: SupportedChainId
+  publicClient: PublicClient
+  clFactoryAddress: Address
+  clQuoterAddress: Address
+  tickSpacing: number
+}
+
+/**
+ * Get a swap quote from a CL/Slipstream pool via QuoterV2.
+ * Verifies the pool exists via the CL factory, then quotes via QuoterV2.
+ * @param params - CL quote parameters
+ * @returns Price quote with amounts and route
+ * @throws If no CL pool exists for the given pair and tickSpacing
+ */
+export async function getCLQuote(params: GetCLQuoteParams): Promise<SwapPrice> {
+  const {
+    assetIn,
+    assetOut,
+    amountInRaw,
+    publicClient,
+    clFactoryAddress,
+    clQuoterAddress,
+    tickSpacing,
+    chainId,
+  } = params
+  const { tokenIn, tokenOut } = resolveTokens(assetIn, assetOut, chainId)
+
+  // Verify the CL pool exists
+  const poolAddress = await publicClient.readContract({
+    address: clFactoryAddress,
+    abi: CL_POOL_FACTORY_ABI,
+    functionName: 'getPool',
+    args: [tokenIn, tokenOut, tickSpacing],
+  })
+
+  if (
+    !poolAddress ||
+    poolAddress === '0x0000000000000000000000000000000000000000'
+  ) {
+    throw new Error(
+      `No CL pool found for ${assetIn.metadata.symbol}/${assetOut.metadata.symbol} (tickSpacing=${tickSpacing})`,
+    )
+  }
+
+  // Quote via QuoterV2.quoteExactInputSingle
+  // sqrtPriceLimitX96 = 0 means no price limit
+  const quoteResult = (await publicClient.readContract({
+    address: clQuoterAddress,
+    abi: CL_QUOTER_ABI,
+    functionName: 'quoteExactInputSingle',
+    args: [
+      {
+        tokenIn,
+        tokenOut,
+        amountIn: amountInRaw,
+        tickSpacing,
+        sqrtPriceLimitX96: 0n,
+      },
+    ],
+  })) as readonly [bigint, bigint, number, bigint]
+
+  const route: SwapRoute = {
+    path: [assetIn, assetOut],
+    pools: [{ address: poolAddress as Address, fee: 0, version: 'v3' }],
+  }
+  return buildSwapPrice(assetIn, assetOut, amountInRaw, quoteResult[0], route)
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Encoding
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface EncodeCLSwapParams {
+  assetIn: Asset
+  assetOut: Asset
+  amountInRaw: bigint
+  amountOutMin: bigint
+  tickSpacing: number
+  recipient: Address
+  deadline: number
+  chainId: SupportedChainId
+}
+
+/** Universal Router V3_SWAP_EXACT_IN command byte */
+const V3_SWAP_EXACT_IN = 0x00
+
+/**
+ * Encode a V3_SWAP_EXACT_IN command for a CL/Slipstream pool on the Universal Router.
+ * Path: encodePacked([tokenIn (20), tickSpacing as int24 (3), tokenOut (20)]) — 43 bytes.
+ * @param params - CL swap encoding parameters
+ * @returns Encoded calldata as hex string
+ */
+export function encodeCLSwap(params: EncodeCLSwapParams): Hex {
+  const { amountInRaw, amountOutMin, tickSpacing, deadline, chainId } = params
+  const { tokenIn, tokenOut } = resolveTokens(
+    params.assetIn,
+    params.assetOut,
+    chainId,
+  )
+
+  const commands = `0x${V3_SWAP_EXACT_IN.toString(16).padStart(2, '0')}` as Hex
+
+  // CL path: [tokenIn (20)] [tickSpacing as int24 (3)] [tokenOut (20)] — 43 bytes
+  const path = encodePacked(
+    ['address', 'int24', 'address'],
+    [tokenIn, tickSpacing, tokenOut],
+  )
+
+  const input = encodeAbiParameters(
+    [
+      { type: 'address' },
+      { type: 'uint256' },
+      { type: 'uint256' },
+      { type: 'bytes' },
+      { type: 'bool' },
+    ],
+    [
+      UNIVERSAL_ROUTER_MSG_SENDER, // recipient = msg.sender (Universal Router sentinel)
+      amountInRaw,
+      amountOutMin,
+      path,
+      false, // payerIsUser — tokens pre-transferred to router
+    ],
+  )
+
+  return encodeFunctionData({
+    abi: UNIVERSAL_ROUTER_ABI,
+    functionName: 'execute',
+    args: [commands, [input], BigInt(deadline)],
+  })
+}

package/src/swap/providers/velodrome/encoding/routers/v2.ts

@@ -0,0 +1,267 @@
+import type { Address, Hex, PublicClient } from 'viem'
+import { encodeAbiParameters, encodeFunctionData, encodePacked } from 'viem'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import {
+  LEAF_ROUTER_ABI,
+  POOL_ABI,
+  POOL_FACTORY_ABI,
+  UNIVERSAL_ROUTER_ABI,
+  V2_ROUTER_ABI,
+} from '@/swap/providers/velodrome/abis.js'
+import type { VelodromeRouterType } from '@/swap/providers/velodrome/config.js'
+import {
+  buildSwapPrice,
+  resolveTokens,
+  UNIVERSAL_ROUTER_MSG_SENDER,
+} from '@/swap/providers/velodrome/encoding/helpers.js'
+import type { Asset } from '@/types/asset.js'
+import type { SwapPrice, SwapRoute } from '@/types/swap/index.js'
+import { isNativeAsset } from '@/utils/assets.js'
+
+/** Universal Router V2_SWAP_EXACT_IN command byte */
+const V2_SWAP_EXACT_IN = 0x08
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Quoting
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface GetQuoteParams {
+  assetIn: Asset
+  assetOut: Asset
+  amountInRaw: bigint
+  chainId: SupportedChainId
+  publicClient: PublicClient
+  routerAddress: Address
+  routerType: VelodromeRouterType
+  stable: boolean
+  factoryAddress: Address
+}
+
+/**
+ * Get a v2 AMM swap quote.
+ * @param params - Quote parameters including router type
+ * @returns Price quote with amounts and route
+ */
+export async function getQuote(params: GetQuoteParams): Promise<SwapPrice> {
+  const { assetIn, assetOut, amountInRaw, chainId } = params
+  const { tokenIn, tokenOut } = resolveTokens(assetIn, assetOut, chainId)
+  const amountOutRaw = await fetchAmountOut(params, tokenIn, tokenOut)
+  const route: SwapRoute = {
+    path: [assetIn, assetOut],
+    pools: [{ address: tokenIn, fee: 0, version: 'v2' }],
+  }
+  return buildSwapPrice(assetIn, assetOut, amountInRaw, amountOutRaw, route)
+}
+
+/**
+ * Fetch the output amount using the appropriate quoting mechanism for the router type.
+ * @param params - Quote parameters
+ * @param tokenIn - Resolved input token address
+ * @param tokenOut - Resolved output token address
+ * @returns Output amount as raw bigint
+ * @throws If router type is unknown
+ */
+async function fetchAmountOut(
+  params: GetQuoteParams,
+  tokenIn: Address,
+  tokenOut: Address,
+): Promise<bigint> {
+  const { routerType } = params
+
+  if (routerType === 'universal') {
+    return fetchAmountOutViaPool(params, tokenIn, tokenOut)
+  }
+  if (routerType === 'v2') {
+    return fetchAmountOutViaRouter(params, V2_ROUTER_ABI, {
+      from: tokenIn,
+      to: tokenOut,
+      stable: params.stable,
+      factory: params.factoryAddress,
+    })
+  }
+  if (routerType === 'leaf') {
+    return fetchAmountOutViaRouter(params, LEAF_ROUTER_ABI, {
+      from: tokenIn,
+      to: tokenOut,
+      stable: params.stable,
+    })
+  }
+  throw new Error(`Unknown router type: ${routerType as string}`)
+}
+
+/** Quote via Pool.getAmountOut (Universal Router path — no router-level quoting available). */
+async function fetchAmountOutViaPool(
+  params: GetQuoteParams,
+  tokenIn: Address,
+  tokenOut: Address,
+): Promise<bigint> {
+  const { publicClient, factoryAddress, stable, assetIn, assetOut } = params
+
+  const poolAddress = await publicClient.readContract({
+    address: factoryAddress,
+    abi: POOL_FACTORY_ABI,
+    functionName: 'getPool',
+    args: [tokenIn, tokenOut, stable],
+  })
+
+  if (
+    !poolAddress ||
+    poolAddress === '0x0000000000000000000000000000000000000000'
+  ) {
+    throw new Error(
+      `No Velodrome pool found for ${assetIn.metadata.symbol}/${assetOut.metadata.symbol} (stable=${stable})`,
+    )
+  }
+
+  return (await publicClient.readContract({
+    address: poolAddress as Address,
+    abi: POOL_ABI,
+    functionName: 'getAmountOut',
+    args: [params.amountInRaw, tokenIn],
+  })) as bigint
+}
+
+/** Quote via Router.getAmountsOut (v2 and leaf router path). */
+async function fetchAmountOutViaRouter(
+  params: GetQuoteParams,
+  abi: typeof V2_ROUTER_ABI | typeof LEAF_ROUTER_ABI,
+  route: { from: Address; to: Address; stable: boolean; factory?: Address },
+): Promise<bigint> {
+  const amounts = await params.publicClient.readContract({
+    address: params.routerAddress,
+    abi,
+    functionName: 'getAmountsOut',
+    args: [params.amountInRaw, [route]],
+  })
+  return (amounts as bigint[])[1]
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Encoding
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface EncodeSwapParams {
+  assetIn: Asset
+  assetOut: Asset
+  amountInRaw: bigint
+  amountOutMin: bigint
+  routerType: VelodromeRouterType
+  stable: boolean
+  factoryAddress: Address
+  recipient: Address
+  deadline: number
+  chainId: SupportedChainId
+}
+
+/**
+ * Encode swap calldata for the appropriate router type.
+ * @param params - Swap encoding parameters
+ * @returns Encoded calldata as hex string
+ * @throws If router type is unknown
+ */
+export function encodeSwap(params: EncodeSwapParams): Hex {
+  const { routerType } = params
+  const { tokenIn, tokenOut } = resolveTokens(
+    params.assetIn,
+    params.assetOut,
+    params.chainId,
+  )
+
+  if (routerType === 'universal') {
+    return encodeUniversalV2Swap(tokenIn, tokenOut, params)
+  }
+  if (routerType === 'v2') {
+    return encodeRouterSwap(tokenIn, tokenOut, params, V2_ROUTER_ABI, {
+      from: tokenIn,
+      to: tokenOut,
+      stable: params.stable,
+      factory: params.factoryAddress,
+    })
+  }
+  if (routerType === 'leaf') {
+    return encodeRouterSwap(tokenIn, tokenOut, params, LEAF_ROUTER_ABI, {
+      from: tokenIn,
+      to: tokenOut,
+      stable: params.stable,
+    })
+  }
+  throw new Error(`Unknown router type: ${routerType as string}`)
+}
+
+/**
+ * Encode a V2_SWAP_EXACT_IN command for the Universal Router.
+ * Route: encodePacked(tokenIn, stable, tokenOut) — 41 bytes per hop.
+ * payerIsUser = false: tokens are pre-transferred to the Router by the smart wallet.
+ */
+function encodeUniversalV2Swap(
+  tokenIn: Address,
+  tokenOut: Address,
+  params: EncodeSwapParams,
+): Hex {
+  const commands = `0x${V2_SWAP_EXACT_IN.toString(16).padStart(2, '0')}` as Hex
+  const routes = encodePacked(
+    ['address', 'bool', 'address'],
+    [tokenIn, params.stable, tokenOut],
+  )
+  const input = encodeAbiParameters(
+    [
+      { type: 'address' },
+      { type: 'uint256' },
+      { type: 'uint256' },
+      { type: 'bytes' },
+      { type: 'bool' },
+      { type: 'bool' },
+    ],
+    [
+      UNIVERSAL_ROUTER_MSG_SENDER, // recipient = msg.sender (Universal Router sentinel)
+      params.amountInRaw,
+      params.amountOutMin,
+      routes,
+      false, // payerIsUser
+      false, // isUni — false for Velodrome/Aerodrome
+    ],
+  )
+  return encodeFunctionData({
+    abi: UNIVERSAL_ROUTER_ABI,
+    functionName: 'execute',
+    args: [commands, [input], BigInt(params.deadline)],
+  })
+}
+
+/**
+ * Encode swap calldata for v2 or leaf routers.
+ * Selects the correct swap function based on whether native ETH is involved.
+ */
+function encodeRouterSwap(
+  tokenIn: Address,
+  tokenOut: Address,
+  params: EncodeSwapParams,
+  abi: typeof V2_ROUTER_ABI | typeof LEAF_ROUTER_ABI,
+  route: { from: Address; to: Address; stable: boolean; factory?: Address },
+): Hex {
+  const { assetIn, assetOut, amountInRaw, amountOutMin, recipient, deadline } =
+    params
+
+  if (isNativeAsset(assetIn)) {
+    return encodeFunctionData({
+      abi,
+      functionName: 'swapExactETHForTokens',
+      args: [amountOutMin, [route], recipient, BigInt(deadline)],
+    })
+  }
+
+  if (isNativeAsset(assetOut)) {
+    return encodeFunctionData({
+      abi,
+      functionName: 'swapExactTokensForETH',
+      args: [amountInRaw, amountOutMin, [route], recipient, BigInt(deadline)],
+    })
+  }
+
+  return encodeFunctionData({
+    abi,
+    functionName: 'swapExactTokensForTokens',
+    args: [amountInRaw, amountOutMin, [route], recipient, BigInt(deadline)],
+  })
+}