@eth-optimism/actions-sdk 0.1.0 → 0.3.0

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

@@ -0,0 +1,144 @@
+/**
+ * PoolKey tuple components (shared across V4 ABI definitions)
+ */
+const POOL_KEY_COMPONENTS = [
+  { name: 'currency0', type: 'address' },
+  { name: 'currency1', type: 'address' },
+  { name: 'fee', type: 'uint24' },
+  { name: 'tickSpacing', type: 'int24' },
+  { name: 'hooks', type: 'address' },
+] as const
+
+/**
+ * V4 Quoter ABI (subset for quoting)
+ * @see https://docs.uniswap.org/contracts/v4/reference/periphery/interfaces/IQuoter
+ */
+export const QUOTER_ABI = [
+  {
+    name: 'quoteExactInputSingle',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      {
+        name: 'params',
+        type: 'tuple',
+        components: [
+          { name: 'poolKey', type: 'tuple', components: POOL_KEY_COMPONENTS },
+          { name: 'zeroForOne', type: 'bool' },
+          { name: 'exactAmount', type: 'uint128' },
+          { name: 'hookData', type: 'bytes' },
+        ],
+      },
+    ],
+    outputs: [
+      { name: 'amountOut', type: 'uint256' },
+      { name: 'gasEstimate', type: 'uint256' },
+    ],
+  },
+  {
+    name: 'quoteExactOutputSingle',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      {
+        name: 'params',
+        type: 'tuple',
+        components: [
+          { name: 'poolKey', type: 'tuple', components: POOL_KEY_COMPONENTS },
+          { name: 'zeroForOne', type: 'bool' },
+          { name: 'exactAmount', type: 'uint128' },
+          { name: 'hookData', type: 'bytes' },
+        ],
+      },
+    ],
+    outputs: [
+      { name: 'amountIn', type: 'uint256' },
+      { name: 'gasEstimate', type: 'uint256' },
+    ],
+  },
+] as const
+
+/**
+ * Universal Router ABI (subset for swaps)
+ * @see https://docs.uniswap.org/contracts/v4/reference/periphery/UniversalRouter
+ */
+export const UNIVERSAL_ROUTER_ABI = [
+  {
+    name: 'execute',
+    type: 'function',
+    stateMutability: 'payable',
+    inputs: [
+      { name: 'commands', type: 'bytes' },
+      { name: 'inputs', type: 'bytes[]' },
+      { name: 'deadline', type: 'uint256' },
+    ],
+    outputs: [],
+  },
+] as const
+
+/** ABI type for ExactInputSingleParams */
+export const EXACT_INPUT_SINGLE_PARAMS = [
+  {
+    type: 'tuple',
+    components: [
+      {
+        name: 'poolKey',
+        type: 'tuple',
+        components: [...POOL_KEY_COMPONENTS],
+      },
+      { name: 'zeroForOne', type: 'bool' },
+      { name: 'amountIn', type: 'uint128' },
+      { name: 'amountOutMinimum', type: 'uint128' },
+      { name: 'hookData', type: 'bytes' },
+    ],
+  },
+] as const
+
+/** ABI type for ExactOutputSingleParams */
+export const EXACT_OUTPUT_SINGLE_PARAMS = [
+  {
+    type: 'tuple',
+    components: [
+      {
+        name: 'poolKey',
+        type: 'tuple',
+        components: [...POOL_KEY_COMPONENTS],
+      },
+      { name: 'zeroForOne', type: 'bool' },
+      { name: 'amountOut', type: 'uint128' },
+      { name: 'amountInMaximum', type: 'uint128' },
+      { name: 'hookData', type: 'bytes' },
+    ],
+  },
+] as const
+
+/** ABI type for SETTLE_ALL / TAKE_ALL params */
+export const CURRENCY_AMOUNT_PARAMS = [
+  { type: 'address' },
+  { type: 'uint256' },
+] as const
+
+/**
+ * PoolManager extsload ABI — reads arbitrary storage slots via SLOAD
+ * @see https://docs.uniswap.org/contracts/v4/guides/read-pool-state
+ */
+export const EXTSLOAD_ABI = [
+  {
+    name: 'extsload',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ name: 'slot', type: 'bytes32' }],
+    outputs: [{ type: 'bytes32' }],
+  },
+] as const
+
+/**
+ * PoolKey ABI encoding type for computing PoolId
+ */
+export const POOL_KEY_ABI_TYPE = [
+  { name: 'currency0', type: 'address' },
+  { name: 'currency1', type: 'address' },
+  { name: 'fee', type: 'uint24' },
+  { name: 'tickSpacing', type: 'int24' },
+  { name: 'hooks', type: 'address' },
+] as const

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

@@ -0,0 +1,108 @@
+import type { Address } from 'viem'
+import {
+  base,
+  baseSepolia,
+  mainnet,
+  optimism,
+  sepolia,
+  unichain,
+  unichainSepolia,
+  worldchain,
+} from 'viem/chains'
+
+import { PERMIT2_ADDRESS } from '@/constants/contracts.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+
+/**
+ * Uniswap contract addresses
+ */
+export interface UniswapAddresses {
+  poolManager: Address
+  positionManager: Address
+  universalRouter: Address
+  quoter: Address
+  permit2: Address
+}
+
+/**
+ * Uniswap V4 contract addresses per chain
+ * @see https://docs.uniswap.org/contracts/v4/deployments
+ */
+const UNISWAP_ADDRESSES: Partial<Record<SupportedChainId, UniswapAddresses>> = {
+  [mainnet.id]: {
+    poolManager: '0x000000000004444c5dc75cB358380D2e3dE08A90',
+    positionManager: '0xbd216513d74c8cf14cf4747e6aaa6420ff64ee9e',
+    universalRouter: '0x66a9893cc07d91d95644aedd05d03f95e1dba8af',
+    quoter: '0x52f0e24d1c21c8a0cb1e5a5dd6198556bd9e1203',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [optimism.id]: {
+    poolManager: '0x9a13f98cb987694c9f086b1f5eb990eea8264ec3',
+    positionManager: '0x3c3ea4b57a46241e54610e5f022e5c45859a1017',
+    universalRouter: '0x851116d9223fabed8e56c0e6b8ad0c31d98b3507',
+    quoter: '0x1f3131a13296fb91c90870043742c3cdbff1a8d7',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [base.id]: {
+    poolManager: '0x498581ff718922c3f8e6a244956af099b2652b2b',
+    positionManager: '0x7c5f5a4bbd8fd63184577525326123b519429bdc',
+    universalRouter: '0x6ff5693b99212da76ad316178a184ab56d299b43',
+    quoter: '0x0d5e0f971ed27fbff6c2837bf31316121532048d',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [unichain.id]: {
+    poolManager: '0x1f98400000000000000000000000000000000004',
+    positionManager: '0x4529a01c7a0410167c5740c487a8de60232617bf',
+    universalRouter: '0xef740bf23acae26f6492b10de645d6b98dc8eaf3',
+    quoter: '0x333e3c607b141b18ff6de9f258db6e77fe7491e0',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [worldchain.id]: {
+    poolManager: '0xb1860d529182ac3bc1f51fa2abd56662b7d13f33',
+    positionManager: '0xc585e0f504613b5fbf874f21af14c65260fb41fa',
+    universalRouter: '0x8ac7bee993bb44dab564ea4bc9ea67bf9eb5e743',
+    quoter: '0x55d235b3ff2daf7c3ede0defc9521f1d6fe6c5c0',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [sepolia.id]: {
+    poolManager: '0xE03A1074c86CFeDd5C142C4F04F1a1536e203543',
+    positionManager: '0x429ba70129df741B2Ca2a85BC3A2a3328e5c09b4',
+    universalRouter: '0x3A9D48AB9751398BbFa63ad67599Bb04e4BdF98b',
+    quoter: '0x61b3f2011a92d183c7dbadbda940a7555ccf9227',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [baseSepolia.id]: {
+    poolManager: '0x05E73354cFDd6745C338b50BcFDfA3Aa6fA03408',
+    positionManager: '0x4b2c77d209d3405f41a037ec6c77f7f5b8e2ca80',
+    universalRouter: '0x492e6456d9528771018deb9e87ef7750ef184104',
+    quoter: '0x4a6513c898fe1b2d0e78d3b0e0a4a151589b1cba',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [unichainSepolia.id]: {
+    poolManager: '0x00b036b58a818b1bc34d502d3fe730db729e62ac',
+    positionManager: '0xf969aee60879c54baaed9f3ed26147db216fd664',
+    universalRouter: '0xf70536b3bcc1bd1a972dc186a2cf84cc6da6be5d',
+    quoter: '0x56dcd40a3f2d466f48e7f48bdbe5cc9b92ae4472',
+    permit2: PERMIT2_ADDRESS,
+  },
+}
+
+/**
+ * Get Uniswap contract addresses for a chain
+ */
+export function getUniswapAddresses(
+  chainId: SupportedChainId,
+): UniswapAddresses {
+  const addresses = UNISWAP_ADDRESSES[chainId]
+  if (!addresses) {
+    throw new Error(`Uniswap not supported on chain ${chainId}`)
+  }
+  return addresses
+}
+
+/**
+ * Get supported chain IDs for Uniswap
+ */
+export function getSupportedChainIds(): SupportedChainId[] {
+  return Object.keys(UNISWAP_ADDRESSES).map(Number) as SupportedChainId[]
+}

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

@@ -0,0 +1,406 @@
+import type { Address, Hex, PublicClient } from 'viem'
+import {
+  encodeAbiParameters,
+  encodeFunctionData,
+  formatUnits,
+  keccak256,
+  zeroAddress,
+} from 'viem'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import {
+  CURRENCY_AMOUNT_PARAMS,
+  EXACT_INPUT_SINGLE_PARAMS,
+  EXACT_OUTPUT_SINGLE_PARAMS,
+  EXTSLOAD_ABI,
+  POOL_KEY_ABI_TYPE,
+  QUOTER_ABI,
+  UNIVERSAL_ROUTER_ABI,
+} from '@/swap/providers/uniswap/abis.js'
+import type { Asset } from '@/types/asset.js'
+import type { SwapPrice, SwapRoute } from '@/types/swap/index.js'
+import { getAssetAddress, isNativeAsset } from '@/utils/assets.js'
+
+/**
+ * V4 represents native ETH as address(0) in pool keys and settle/take params,
+ * unlike V3 which required WETH. Named for clarity at call sites.
+ * @see https://github.com/Uniswap/v4-core/blob/main/src/types/Currency.sol
+ */
+const NATIVE_CURRENCY = zeroAddress
+
+/**
+ * Resolved V4 pool parameters
+ */
+interface ResolvedPoolParams {
+  tokenIn: Address
+  tokenOut: Address
+  zeroForOne: boolean
+  poolKey: {
+    currency0: Address
+    currency1: Address
+    fee: number
+    tickSpacing: number
+    hooks: Address
+  }
+}
+
+/**
+ * Resolve token addresses, currency sorting, and pool key for a V4 swap
+ */
+function resolvePoolParams(
+  assetIn: Asset,
+  assetOut: Asset,
+  chainId: SupportedChainId,
+  fee: number,
+  tickSpacing: number,
+): ResolvedPoolParams {
+  const tokenIn = isNativeAsset(assetIn)
+    ? NATIVE_CURRENCY
+    : getAssetAddress(assetIn, chainId)
+
+  const tokenOut = isNativeAsset(assetOut)
+    ? NATIVE_CURRENCY
+    : getAssetAddress(assetOut, chainId)
+
+  // V4 requires sorted tokens: currency0 < currency1
+  const [currency0, currency1] =
+    tokenIn.toLowerCase() < tokenOut.toLowerCase()
+      ? [tokenIn, tokenOut]
+      : [tokenOut, tokenIn]
+  const zeroForOne = tokenIn.toLowerCase() === currency0.toLowerCase()
+
+  const poolKey = {
+    currency0,
+    currency1,
+    fee,
+    tickSpacing,
+    hooks: '0x0000000000000000000000000000000000000000' as Address,
+  }
+
+  return { tokenIn, tokenOut, zeroForOne, poolKey }
+}
+
+export interface GetQuoteParams {
+  assetIn: Asset
+  assetOut: Asset
+  amountInWei?: bigint
+  amountOutWei?: bigint
+  chainId: SupportedChainId
+  publicClient: PublicClient
+  quoterAddress: Address
+  poolManagerAddress: Address
+  /** Fee tier in pips (e.g. 100 = 0.01%) */
+  fee: number
+  /** Tick spacing for the pool */
+  tickSpacing: number
+}
+
+/**
+ * Get a swap quote from the Quoter contract
+ */
+export async function getQuote(params: GetQuoteParams): Promise<SwapPrice> {
+  const {
+    assetIn,
+    assetOut,
+    amountInWei,
+    amountOutWei,
+    chainId,
+    publicClient,
+    quoterAddress,
+    poolManagerAddress,
+    fee,
+    tickSpacing,
+  } = params
+
+  const { tokenIn, zeroForOne, poolKey } = resolvePoolParams(
+    assetIn,
+    assetOut,
+    chainId,
+    fee,
+    tickSpacing,
+  )
+
+  const isExactInput = amountInWei !== undefined
+
+  // Read pool mid-price and quote in parallel — no extra sequential RPC call
+  const [sqrtPriceX96, quoteResult] = await Promise.all([
+    getPoolSqrtPrice({ publicClient, poolManagerAddress, poolKey }),
+    isExactInput
+      ? publicClient.simulateContract({
+          address: quoterAddress,
+          abi: QUOTER_ABI,
+          functionName: 'quoteExactInputSingle',
+          args: [
+            {
+              poolKey,
+              zeroForOne,
+              exactAmount: amountInWei,
+              hookData: '0x' as `0x${string}`,
+            },
+          ],
+        })
+      : publicClient.simulateContract({
+          address: quoterAddress,
+          abi: QUOTER_ABI,
+          functionName: 'quoteExactOutputSingle',
+          args: [
+            {
+              poolKey,
+              zeroForOne,
+              exactAmount: amountOutWei!,
+              hookData: '0x' as `0x${string}`,
+            },
+          ],
+        }),
+  ])
+
+  const amountIn = isExactInput ? amountInWei : quoteResult.result[0]
+  const amountOut = isExactInput ? quoteResult.result[0] : amountOutWei!
+  const gasEstimate = quoteResult.result[1]
+
+  const price = calculatePrice(amountIn, amountOut, assetIn, assetOut)
+  const priceInverse = calculatePrice(amountOut, amountIn, assetOut, assetIn)
+  const priceImpact = calculatePriceImpact({
+    sqrtPriceX96,
+    amountIn,
+    amountOut,
+    zeroForOne,
+  })
+
+  const route: SwapRoute = {
+    path: [assetIn, assetOut],
+    pools: [
+      {
+        address: tokenIn,
+        fee,
+        version: 'v4',
+      },
+    ],
+  }
+
+  return {
+    price,
+    priceInverse,
+    amountIn: parseFloat(formatUnits(amountIn, assetIn.metadata.decimals)),
+    amountOut: parseFloat(formatUnits(amountOut, assetOut.metadata.decimals)),
+    amountInWei: amountIn,
+    amountOutWei: amountOut,
+    priceImpact,
+    route,
+    gasEstimate,
+  }
+}
+
+export interface EncodeSwapParams {
+  amountInWei?: bigint
+  amountOutWei?: bigint
+  assetIn: Asset
+  assetOut: Asset
+  slippage: number
+  deadline: number
+  recipient: Address
+  chainId: SupportedChainId
+  quote: SwapPrice
+  universalRouterAddress: Address
+  /** Fee tier in pips (e.g. 100 = 0.01%) */
+  fee: number
+  /** Tick spacing for the pool */
+  tickSpacing: number
+}
+
+// V4 Universal Router command
+const V4_SWAP = 0x10
+
+// V4 action types
+const SWAP_EXACT_IN_SINGLE = 0x06
+const SWAP_EXACT_OUT_SINGLE = 0x07
+const SETTLE_ALL = 0x0c
+const TAKE_ALL = 0x0f
+
+/**
+ * Encode Universal Router V4 swap calldata
+ * @description Builds calldata for executing a V4 swap through Universal Router
+ */
+export function encodeUniversalRouterSwap(params: EncodeSwapParams): Hex {
+  const {
+    amountInWei,
+    assetIn,
+    assetOut,
+    slippage,
+    deadline,
+    chainId,
+    quote,
+    fee,
+    tickSpacing,
+  } = params
+
+  const { tokenIn, tokenOut, zeroForOne, poolKey } = resolvePoolParams(
+    assetIn,
+    assetOut,
+    chainId,
+    fee,
+    tickSpacing,
+  )
+
+  const isExactInput = amountInWei !== undefined
+
+  let actions: Hex
+  let actionParams: Hex[]
+
+  if (isExactInput) {
+    const minAmountOut =
+      (quote.amountOutWei * 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
+
+    actionParams = [
+      encodeAbiParameters(EXACT_INPUT_SINGLE_PARAMS, [
+        {
+          poolKey,
+          zeroForOne,
+          amountIn: amountInWei,
+          amountOutMinimum: minAmountOut,
+          hookData: '0x',
+        },
+      ]),
+      encodeAbiParameters(CURRENCY_AMOUNT_PARAMS, [tokenIn, amountInWei]),
+      encodeAbiParameters(CURRENCY_AMOUNT_PARAMS, [tokenOut, minAmountOut]),
+    ]
+  } else {
+    const maxAmountIn =
+      quote.amountInWei +
+      (quote.amountInWei * 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
+
+    actionParams = [
+      encodeAbiParameters(EXACT_OUTPUT_SINGLE_PARAMS, [
+        {
+          poolKey,
+          zeroForOne,
+          amountOut: quote.amountOutWei,
+          amountInMaximum: maxAmountIn,
+          hookData: '0x',
+        },
+      ]),
+      encodeAbiParameters(CURRENCY_AMOUNT_PARAMS, [tokenIn, maxAmountIn]),
+      encodeAbiParameters(CURRENCY_AMOUNT_PARAMS, [
+        tokenOut,
+        quote.amountOutWei,
+      ]),
+    ]
+  }
+
+  // Encode V4_SWAP input: abi.encode(bytes actions, bytes[] params)
+  const v4SwapInput = encodeAbiParameters(
+    [{ type: 'bytes' }, { type: 'bytes[]' }],
+    [actions, actionParams],
+  )
+
+  return encodeFunctionData({
+    abi: UNIVERSAL_ROUTER_ABI,
+    functionName: 'execute',
+    args: [
+      `0x${V4_SWAP.toString(16).padStart(2, '0')}` as Hex,
+      [v4SwapInput],
+      BigInt(deadline),
+    ],
+  })
+}
+
+function calculatePrice(
+  amountIn: bigint,
+  amountOut: bigint,
+  assetIn: Asset,
+  assetOut: Asset,
+): string {
+  const inDecimals = assetIn.metadata.decimals
+  const outDecimals = assetOut.metadata.decimals
+
+  const normalizedIn = parseFloat(formatUnits(amountIn, inDecimals))
+  const normalizedOut = parseFloat(formatUnits(amountOut, outDecimals))
+
+  return (normalizedOut / normalizedIn).toFixed(6)
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Price impact via pool mid-price read from PoolManager storage (extsload)
+// Formula mirrors Uniswap SDK's computePriceImpact:
+//   (quotedOutput - actualOutput) / quotedOutput
+// @see https://github.com/Uniswap/sdks/blob/main/sdks/sdk-core/src/utils/computePriceImpact.ts
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** @see https://docs.uniswap.org/contracts/v4/reference/core/libraries/StateLibrary */
+const POOLS_SLOT = 6n
+
+/**
+ * Read sqrtPriceX96 from a V4 pool via PoolManager.extsload (single SLOAD)
+ */
+export async function getPoolSqrtPrice(params: {
+  publicClient: PublicClient
+  poolManagerAddress: Address
+  poolKey: ResolvedPoolParams['poolKey']
+}): Promise<bigint> {
+  const { publicClient, poolManagerAddress, poolKey } = params
+
+  const poolId = keccak256(
+    encodeAbiParameters(POOL_KEY_ABI_TYPE, [
+      poolKey.currency0,
+      poolKey.currency1,
+      poolKey.fee,
+      poolKey.tickSpacing,
+      poolKey.hooks,
+    ]),
+  )
+
+  // pools[poolId].slot0 — slot0 is at offset 0 from the mapping base
+  const slot = keccak256(
+    encodeAbiParameters(
+      [{ type: 'bytes32' }, { type: 'uint256' }],
+      [poolId, POOLS_SLOT],
+    ),
+  )
+
+  const result = await publicClient.readContract({
+    address: poolManagerAddress,
+    abi: EXTSLOAD_ABI,
+    functionName: 'extsload',
+    args: [slot],
+  })
+
+  // sqrtPriceX96 is packed in the lower 160 bits of slot0
+  return BigInt(result) & ((1n << 160n) - 1n)
+}
+
+/**
+ * Price impact as a decimal (0.03 = 3%). Returns 0 if unavailable.
+ */
+export function calculatePriceImpact(params: {
+  sqrtPriceX96: bigint
+  amountIn: bigint
+  amountOut: bigint
+  zeroForOne: boolean
+}): number {
+  const { sqrtPriceX96, amountIn, amountOut, zeroForOne } = params
+
+  if (sqrtPriceX96 === 0n) return 0
+
+  // price(currency0→currency1) = sqrtPriceX96² / 2¹⁹² (raw wei units)
+  const Q192 = 1n << 192n
+  const sqrtPriceSq = sqrtPriceX96 * sqrtPriceX96
+
+  // What you'd receive at mid-price
+  const quotedOutput = zeroForOne
+    ? (amountIn * sqrtPriceSq) / Q192
+    : (amountIn * Q192) / sqrtPriceSq
+
+  if (quotedOutput === 0n) return 0
+
+  const SCALE = 10n ** 18n
+  const impactScaled = ((quotedOutput - amountOut) * SCALE) / quotedOutput
+  const impact = Number(impactScaled) / Number(SCALE)
+
+  return Math.max(0, impact)
+}

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

@@ -0,0 +1,24 @@
+import type {
+  SwapMarketConfig,
+  SwapProviderConfig,
+} from '@/types/swap/index.js'
+
+/**
+ * Uniswap-specific market config with V4 pool parameters
+ */
+export interface UniswapMarketConfig extends SwapMarketConfig {
+  /** Fee tier in pips (e.g. 100 = 0.01%) */
+  fee?: number
+  /** Tick spacing for the pool */
+  tickSpacing?: number
+}
+
+/**
+ * Uniswap swap provider configuration
+ */
+export interface UniswapSwapProviderConfig extends SwapProviderConfig {
+  marketAllowlist?: UniswapMarketConfig[]
+  marketBlocklist?: UniswapMarketConfig[]
+  /** Permit2 approval expiry in seconds from now. Defaults to 30 days. */
+  permit2ExpirySeconds?: number
+}