@nradko/metric-omm-sdk-v1 0.3.0 → 0.4.2

package/src/router/swap.ts

@@ -1,558 +1,220 @@
 /**
- * MetricAMM SDK - Swapper (v1 periphery) helpers for building and encoding swaps.
+ * MetricAMM SDK - SimpleRouter single-hop swap helpers.
  */
 
-import type { Address, PublicClient, Hex } from "viem";
-import { encodeFunctionData, zeroAddress } from "viem";
-import { MAX_UINT128, POOL_ABI, SWAPPER_ABI } from "../constants.js";
+import type { Address, Hex } from "viem";
+import { encodeFunctionData } from "viem";
+import { defaultPriceLimitX64 } from "../quoter/quotePath.js";
+import { quoteLiveExactInSingle, quoteLiveExactOutSingle } from "../quoter/quote.js";
+import { resolveSwapPath } from "../swap/path.js";
+import { SIMPLE_ROUTER_ABI } from "../constants.js";
 import { EMPTY_EXTENSION_DATA } from "../extensions/types.js";
-import { PriceProviderUiAbi } from "../abis/PriceProviderUi.js";
+import type { PublicClient } from "viem";
 
 const BPS_BASE = 10_000n;
 
-function withExtensionData(args: readonly unknown[]): readonly unknown[] {
-  return args.length >= 8 ? args : [...args, EMPTY_EXTENSION_DATA];
-}
-
-function quoteSwapArgs(params: {
+export type ExactInputSingleParams = {
   pool: Address;
-  recipient: Address;
-  zeroForOne: boolean;
-  amountSpecified: bigint;
-  priceLimitX64: bigint;
-  bidPriceX64: bigint;
-  askPriceX64: bigint;
-  extensionData?: Hex;
-}): readonly [Address, Address, boolean, bigint, bigint, bigint, bigint, Hex] {
-  return [
-    params.pool,
-    params.recipient,
-    params.zeroForOne,
-    params.amountSpecified,
-    params.priceLimitX64,
-    params.bidPriceX64,
-    params.askPriceX64,
-    params.extensionData ?? EMPTY_EXTENSION_DATA,
-  ];
-}
-export interface PreparedSwapTransaction {
-  data: Hex;
-  value?: bigint;
-}
-
-export type SwapExactInputArgs = readonly [
-  Address,
-  Address,
-  boolean,
-  bigint,
-  bigint,
-  bigint,
-  bigint,
-];
-
-export type SwapExactInputParams = {
-  pool: Address;
-  recipient: Address;
+  tokenIn: Address;
+  tokenOut: Address;
   zeroForOne: boolean;
   amountIn: bigint;
-  priceLimitX64: bigint;
-  minAmountOut: bigint;
+  amountOutMinimum: bigint;
+  recipient: Address;
   deadline: bigint;
+  priceLimitX64: bigint;
+  extensionData?: Hex;
 };
 
-export type SwapExactOutputArgs = readonly [
-  Address,
-  Address,
-  boolean,
-  bigint,
-  bigint,
-  bigint,
-  bigint,
-];
-
-export type SwapExactOutputParams = {
+export type ExactOutputSingleParams = {
   pool: Address;
-  recipient: Address;
+  tokenIn: Address;
+  tokenOut: Address;
   zeroForOne: boolean;
   amountOut: bigint;
-  priceLimitX64: bigint;
-  maxAmountIn: bigint;
+  amountInMaximum: bigint;
+  recipient: Address;
   deadline: bigint;
+  priceLimitX64: bigint;
+  extensionData?: Hex;
 };
 
-export interface BuildSwapPrices {
-  bidPriceX64: bigint;
-  askPriceX64: bigint;
-}
-
-/** Shared fields for swap builders that may auto-fetch bid/ask from the pool's price provider. */
-export interface BuildSwapWithFactoryParams {
+export interface BuildExactInputSingleParams {
   publicClient: PublicClient;
-  /** Factory that deployed the pool (required when `prices` is omitted). */
-  factoryAddress?: Address;
   pool: Address;
-  prices?: BuildSwapPrices;
-  extensionData?: Hex;
-}
-
-export interface BuildSwapExactInputParams extends BuildSwapWithFactoryParams {
-  swapperAddress: Address;
+  tokenIn: Address;
+  tokenOut: Address;
   recipient: Address;
-  zeroForOne: boolean;
   amountIn: bigint;
   slippagePercent: number;
   priceLimitX64?: bigint;
   deadline: bigint;
+  extensionData?: Hex;
+  quoterAddress?: Address;
 }
 
-export interface BuildSwapExactOutputParams extends BuildSwapWithFactoryParams {
-  swapperAddress: Address;
+export interface BuildExactOutputSingleParams {
+  publicClient: PublicClient;
+  pool: Address;
+  tokenIn: Address;
+  tokenOut: Address;
   recipient: Address;
-  zeroForOne: boolean;
   amountOut: bigint;
   slippagePercent: number;
   priceLimitX64?: bigint;
   deadline: bigint;
+  extensionData?: Hex;
+  quoterAddress?: Address;
 }
 
-export type QuoteExpectedAmountsForSwapExactInputParams = Omit<
-  BuildSwapExactInputParams,
-  "deadline"
->;
-
-export type QuoteExpectedAmountsForSwapExactOutputParams = Omit<
-  BuildSwapExactOutputParams,
-  "deadline"
->;
-
-function toSlippageBps(slippagePercent: number): bigint {
+export function toSlippageBps(slippagePercent: number): bigint {
   if (!Number.isFinite(slippagePercent) || slippagePercent < 0 || slippagePercent > 100) {
     throw new Error("slippagePercent must be a finite number between 0 and 100");
   }
   return BigInt(Math.round(slippagePercent * 100));
 }
 
-function absBigInt(value: bigint): bigint {
-  return value < 0n ? -value : value;
-}
-
-function ceilDiv(numerator: bigint, denominator: bigint): bigint {
+export function ceilDiv(numerator: bigint, denominator: bigint): bigint {
   if (denominator <= 0n) {
     throw new Error("denominator must be > 0");
   }
   return numerator === 0n ? 0n : (numerator + denominator - 1n) / denominator;
 }
 
-function defaultPriceLimitX64(zeroForOne: boolean): bigint {
-  return zeroForOne ? 0n : MAX_UINT128;
+function withExtensionData(extensionData?: Hex): Hex {
+  return extensionData ?? EMPTY_EXTENSION_DATA;
 }
 
-async function readBidAskFromPoolPriceProvider(
-  publicClient: PublicClient,
-  poolAddress: Address,
-): Promise<{ bidPriceX64: bigint; askPriceX64: bigint }> {
-  const imm = (await publicClient.readContract({
-    address: poolAddress,
-    abi: POOL_ABI,
-    functionName: "getImmutables",
-  })) as { immutablePriceProvider: Address };
-
-  const priceProviderAddress = imm.immutablePriceProvider;
-  if (
-    !priceProviderAddress ||
-    priceProviderAddress === "0x0000000000000000000000000000000000000000"
-  ) {
-    throw new Error(`pool ${poolAddress} has no immutable price provider (getImmutables)`);
-  }
-
-  const [bidPriceX64, askPriceX64] = (await publicClient.readContract({
-    address: priceProviderAddress,
-    abi: PriceProviderUiAbi,
-    functionName: "getBidAndAskPriceUi",
-  })) as [bigint, bigint];
-
-  return { bidPriceX64, askPriceX64 };
+function toExactInputSingleStruct(params: ExactInputSingleParams) {
+  return {
+    pool: params.pool,
+    tokenIn: params.tokenIn,
+    tokenOut: params.tokenOut,
+    zeroForOne: params.zeroForOne,
+    amountIn: params.amountIn,
+    amountOutMinimum: params.amountOutMinimum,
+    recipient: params.recipient,
+    deadline: params.deadline,
+    priceLimitX64: params.priceLimitX64,
+    extensionData: withExtensionData(params.extensionData),
+  };
 }
 
-async function resolveBidAskPrices(params: {
-  publicClient: PublicClient;
-  factoryAddress?: Address;
-  pool: Address;
-  prices?: BuildSwapPrices;
-}): Promise<{ bidPriceX64: bigint; askPriceX64: bigint }> {
-  if (params.prices) {
-    return params.prices;
-  }
-
-  return readBidAskFromPoolPriceProvider(params.publicClient, params.pool);
+function toExactOutputSingleStruct(params: ExactOutputSingleParams) {
+  return {
+    pool: params.pool,
+    tokenIn: params.tokenIn,
+    tokenOut: params.tokenOut,
+    zeroForOne: params.zeroForOne,
+    amountOut: params.amountOut,
+    amountInMaximum: params.amountInMaximum,
+    recipient: params.recipient,
+    deadline: params.deadline,
+    priceLimitX64: params.priceLimitX64,
+    extensionData: withExtensionData(params.extensionData),
+  };
 }
 
-export async function buildArgsForSwapExactInput(
-  params: BuildSwapExactInputParams,
-): Promise<SwapExactInputArgs> {
+export async function buildExactInputSingleParams(
+  params: BuildExactInputSingleParams,
+): Promise<ExactInputSingleParams> {
   const slippageBps = toSlippageBps(params.slippagePercent);
-  const priceLimitX64 = params.priceLimitX64 ?? defaultPriceLimitX64(params.zeroForOne);
-
-  const { bidPriceX64, askPriceX64 } = await resolveBidAskPrices(params);
-
-  const {
-    result: [amount0Delta, amount1Delta],
-  } = (await params.publicClient.simulateContract({
-    address: params.swapperAddress,
-    abi: SWAPPER_ABI,
-    functionName: "quoteSwap",
-    args: quoteSwapArgs({
-      pool: params.pool,
-      recipient: params.recipient,
-      zeroForOne: params.zeroForOne,
-      amountSpecified: params.amountIn,
-      priceLimitX64,
-      bidPriceX64,
-      askPriceX64,
-      extensionData: params.extensionData,
-    }),
-    account: params.recipient,
-  })) as unknown as { result: [bigint, bigint] };
-
-  const amountSwapWillResultIn = params.zeroForOne
-    ? absBigInt(amount1Delta)
-    : absBigInt(amount0Delta);
-
-  const minAmountOut = (amountSwapWillResultIn * (BPS_BASE - slippageBps)) / BPS_BASE;
-
-  return [
-    params.pool,
-    params.recipient,
-    params.zeroForOne,
-    params.amountIn,
+  const { zeroForOnes } = await resolveSwapPath(
+    params.publicClient,
+    params.tokenIn,
+    params.tokenOut,
+    [params.pool],
+    params.extensionData ? [params.extensionData] : undefined,
+  );
+  const zeroForOne = zeroForOnes[0]!;
+  const priceLimitX64 = params.priceLimitX64 ?? defaultPriceLimitX64(zeroForOne);
+
+  const { amountOut } = await quoteLiveExactInSingle({
+    publicClient: params.publicClient,
+    pool: params.pool,
+    tokenIn: params.tokenIn,
+    tokenOut: params.tokenOut,
+    recipient: params.recipient,
+    amountIn: params.amountIn,
     priceLimitX64,
-    minAmountOut,
-    params.deadline,
-  ];
-}
-
-export async function buildArgsAndExpectedAmountsForSwapExactInput(
-  params: BuildSwapExactInputParams,
-): Promise<{
-  args: SwapExactInputArgs;
-  expectedInput: bigint;
-  expectedOutput: bigint;
-}> {
-  const slippageBps = toSlippageBps(params.slippagePercent);
-  const priceLimitX64 = params.priceLimitX64 ?? defaultPriceLimitX64(params.zeroForOne);
-
-  const { bidPriceX64, askPriceX64 } = await resolveBidAskPrices(params);
-
-  const {
-    result: [amount0Delta, amount1Delta],
-  } = (await params.publicClient.simulateContract({
-    address: params.swapperAddress,
-    abi: SWAPPER_ABI,
-    functionName: "quoteSwap",
-    args: quoteSwapArgs({
-      pool: params.pool,
-      recipient: params.recipient,
-      zeroForOne: params.zeroForOne,
-      amountSpecified: params.amountIn,
-      priceLimitX64,
-      bidPriceX64,
-      askPriceX64,
-      extensionData: params.extensionData,
-    }),
-    account: params.recipient,
-  })) as unknown as { result: [bigint, bigint] };
-
-  const expectedOutput = params.zeroForOne ? absBigInt(amount1Delta) : absBigInt(amount0Delta);
-
-  const expectedInput = params.zeroForOne ? absBigInt(amount0Delta) : absBigInt(amount1Delta);
-
-  const minAmountOut = (expectedOutput * (BPS_BASE - slippageBps)) / BPS_BASE;
+    extensionData: params.extensionData,
+    quoterAddress: params.quoterAddress,
+  });
 
-  const args: SwapExactInputArgs = [
-    params.pool,
-    params.recipient,
-    params.zeroForOne,
-    params.amountIn,
-    priceLimitX64,
-    minAmountOut,
-    params.deadline,
-  ];
+  const amountOutMinimum = (amountOut * (BPS_BASE - slippageBps)) / BPS_BASE;
 
   return {
-    args,
-    expectedInput,
-    expectedOutput,
+    pool: params.pool,
+    tokenIn: params.tokenIn,
+    tokenOut: params.tokenOut,
+    zeroForOne,
+    amountIn: params.amountIn,
+    amountOutMinimum,
+    recipient: params.recipient,
+    deadline: params.deadline,
+    priceLimitX64,
+    extensionData: params.extensionData,
   };
 }
 
-export type QuoteSwapParams = BuildSwapWithFactoryParams & {
-  swapperAddress: Address;
-  zeroForOne: boolean;
-  amountSpecified: bigint;
-  priceLimitX64?: bigint;
-  /** Defaults to zero address when omitted. */
-  recipient?: Address;
-};
-
-export type QuoteSwapResult = {
-  amount0Delta: bigint;
-  amount1Delta: bigint;
-  amountIn: bigint;
-  amountOut: bigint;
-};
-
-export async function quoteSwap(params: QuoteSwapParams): Promise<QuoteSwapResult> {
-  const priceLimitX64 = params.priceLimitX64 ?? defaultPriceLimitX64(params.zeroForOne);
-  const { bidPriceX64, askPriceX64 } = await resolveBidAskPrices(params);
-
-  const [amount0Delta, amount1Delta] = (await params.publicClient.readContract({
-    address: params.swapperAddress,
-    abi: SWAPPER_ABI,
-    functionName: "quoteSwap",
-    args: quoteSwapArgs({
-      pool: params.pool,
-      recipient: params.recipient ?? zeroAddress,
-      zeroForOne: params.zeroForOne,
-      amountSpecified: params.amountSpecified,
-      priceLimitX64,
-      bidPriceX64,
-      askPriceX64,
-      extensionData: params.extensionData,
-    }),
-  })) as [bigint, bigint];
-
-  const amountIn = params.zeroForOne ? absBigInt(amount0Delta) : absBigInt(amount1Delta);
-  const amountOut = params.zeroForOne ? absBigInt(amount1Delta) : absBigInt(amount0Delta);
-
-  return { amount0Delta, amount1Delta, amountIn, amountOut };
-}
-
-export async function quoteExpectedAmountsForSwapExactInput(
-  params: QuoteExpectedAmountsForSwapExactInputParams,
-): Promise<{ expectedInput: bigint; expectedOutput: bigint }> {
-  const priceLimitX64 = params.priceLimitX64 ?? defaultPriceLimitX64(params.zeroForOne);
-
-  const { bidPriceX64, askPriceX64 } = await resolveBidAskPrices(params);
-
-  const [amount0Delta, amount1Delta] = (await params.publicClient.readContract({
-    address: params.swapperAddress,
-    abi: SWAPPER_ABI,
-    functionName: "quoteSwap",
-    args: quoteSwapArgs({
-      pool: params.pool,
-      recipient: params.recipient,
-      zeroForOne: params.zeroForOne,
-      amountSpecified: params.amountIn,
-      priceLimitX64,
-      bidPriceX64,
-      askPriceX64,
-      extensionData: params.extensionData,
-    }),
-  })) as [bigint, bigint];
-
-  const expectedOutput = params.zeroForOne ? absBigInt(amount1Delta) : absBigInt(amount0Delta);
-
-  const expectedInput = params.zeroForOne ? absBigInt(amount0Delta) : absBigInt(amount1Delta);
-
-  return { expectedInput, expectedOutput };
-}
-
-export async function buildArgsForSwapExactOutput(
-  params: BuildSwapExactOutputParams,
-): Promise<SwapExactOutputArgs> {
+export async function buildExactOutputSingleParams(
+  params: BuildExactOutputSingleParams,
+): Promise<ExactOutputSingleParams> {
   const slippageBps = toSlippageBps(params.slippagePercent);
-  const priceLimitX64 = params.priceLimitX64 ?? defaultPriceLimitX64(params.zeroForOne);
-
-  const { bidPriceX64, askPriceX64 } = await resolveBidAskPrices(params);
-
-  const {
-    result: [amount0Delta, amount1Delta],
-  } = (await params.publicClient.simulateContract({
-    address: params.swapperAddress,
-    abi: SWAPPER_ABI,
-    functionName: "quoteSwap",
-    args: quoteSwapArgs({
-      pool: params.pool,
-      recipient: params.recipient,
-      zeroForOne: params.zeroForOne,
-      amountSpecified: -params.amountOut,
-      priceLimitX64,
-      bidPriceX64,
-      askPriceX64,
-      extensionData: params.extensionData,
-    }),
-    account: params.recipient,
-  })) as unknown as { result: [bigint, bigint] };
-
-  const quotedAmountIn = params.zeroForOne ? absBigInt(amount0Delta) : absBigInt(amount1Delta);
-
-  const maxAmountIn = ceilDiv(quotedAmountIn * (BPS_BASE + slippageBps), BPS_BASE);
-
-  return [
-    params.pool,
-    params.recipient,
-    params.zeroForOne,
-    params.amountOut,
+  const { zeroForOnes } = await resolveSwapPath(
+    params.publicClient,
+    params.tokenIn,
+    params.tokenOut,
+    [params.pool],
+    params.extensionData ? [params.extensionData] : undefined,
+  );
+  const zeroForOne = zeroForOnes[0]!;
+  const priceLimitX64 = params.priceLimitX64 ?? defaultPriceLimitX64(zeroForOne);
+
+  const { amountIn } = await quoteLiveExactOutSingle({
+    publicClient: params.publicClient,
+    pool: params.pool,
+    tokenIn: params.tokenIn,
+    tokenOut: params.tokenOut,
+    recipient: params.recipient,
+    amountOut: params.amountOut,
     priceLimitX64,
-    maxAmountIn,
-    params.deadline,
-  ];
-}
-
-export async function buildArgsAndExpectedAmountsForSwapExactOutput(
-  params: BuildSwapExactOutputParams,
-): Promise<{
-  args: SwapExactOutputArgs;
-  expectedInput: bigint;
-  expectedOutput: bigint;
-}> {
-  const slippageBps = toSlippageBps(params.slippagePercent);
-  const priceLimitX64 = params.priceLimitX64 ?? defaultPriceLimitX64(params.zeroForOne);
-
-  const { bidPriceX64, askPriceX64 } = await resolveBidAskPrices(params);
-
-  const {
-    result: [amount0Delta, amount1Delta],
-  } = (await params.publicClient.simulateContract({
-    address: params.swapperAddress,
-    abi: SWAPPER_ABI,
-    functionName: "quoteSwap",
-    args: quoteSwapArgs({
-      pool: params.pool,
-      recipient: params.recipient,
-      zeroForOne: params.zeroForOne,
-      amountSpecified: -params.amountOut,
-      priceLimitX64,
-      bidPriceX64,
-      askPriceX64,
-      extensionData: params.extensionData,
-    }),
-    account: params.recipient,
-  })) as unknown as { result: [bigint, bigint] };
-
-  const expectedInput = params.zeroForOne ? absBigInt(amount0Delta) : absBigInt(amount1Delta);
-
-  const expectedOutput = params.zeroForOne ? absBigInt(amount1Delta) : absBigInt(amount0Delta);
-
-  const maxAmountIn = ceilDiv(expectedInput * (BPS_BASE + slippageBps), BPS_BASE);
+    extensionData: params.extensionData,
+    quoterAddress: params.quoterAddress,
+  });
 
-  const args: SwapExactOutputArgs = [
-    params.pool,
-    params.recipient,
-    params.zeroForOne,
-    params.amountOut,
-    priceLimitX64,
-    maxAmountIn,
-    params.deadline,
-  ];
+  const amountInMaximum = ceilDiv(amountIn * (BPS_BASE + slippageBps), BPS_BASE);
 
   return {
-    args,
-    expectedInput,
-    expectedOutput,
+    pool: params.pool,
+    tokenIn: params.tokenIn,
+    tokenOut: params.tokenOut,
+    zeroForOne,
+    amountOut: params.amountOut,
+    amountInMaximum,
+    recipient: params.recipient,
+    deadline: params.deadline,
+    priceLimitX64,
+    extensionData: params.extensionData,
   };
 }
 
-export async function quoteExpectedAmountsForSwapExactOutput(
-  params: QuoteExpectedAmountsForSwapExactOutputParams,
-): Promise<{ expectedInput: bigint; expectedOutput: bigint }> {
-  const priceLimitX64 = params.priceLimitX64 ?? defaultPriceLimitX64(params.zeroForOne);
-
-  const { bidPriceX64, askPriceX64 } = await resolveBidAskPrices(params);
-
-  const [amount0Delta, amount1Delta] = (await params.publicClient.readContract({
-    address: params.swapperAddress,
-    abi: SWAPPER_ABI,
-    functionName: "quoteSwap",
-    args: quoteSwapArgs({
-      pool: params.pool,
-      recipient: params.recipient,
-      zeroForOne: params.zeroForOne,
-      amountSpecified: -params.amountOut,
-      priceLimitX64,
-      bidPriceX64,
-      askPriceX64,
-      extensionData: params.extensionData,
-    }),
-  })) as [bigint, bigint];
-
-  const expectedInput = params.zeroForOne ? absBigInt(amount0Delta) : absBigInt(amount1Delta);
-
-  const expectedOutput = params.zeroForOne ? absBigInt(amount1Delta) : absBigInt(amount0Delta);
-
-  return { expectedInput, expectedOutput };
-}
-
-export function encodeSwapExactInputCalldata(
-  argsOrParams: SwapExactInputArgs | SwapExactInputParams,
-): `0x${string}` {
-  const args = Array.isArray(argsOrParams)
-    ? argsOrParams
-    : ([
-        (argsOrParams as SwapExactInputParams).pool,
-        (argsOrParams as SwapExactInputParams).recipient,
-        (argsOrParams as SwapExactInputParams).zeroForOne,
-        (argsOrParams as SwapExactInputParams).amountIn,
-        (argsOrParams as SwapExactInputParams).priceLimitX64,
-        (argsOrParams as SwapExactInputParams).minAmountOut,
-        (argsOrParams as SwapExactInputParams).deadline,
-      ] as const);
-
+export function encodeExactInputSingleCalldata(params: ExactInputSingleParams): Hex {
   return encodeFunctionData({
-    abi: SWAPPER_ABI,
-    functionName: "swapExactInput",
-    args: withExtensionData(args),
+    abi: SIMPLE_ROUTER_ABI,
+    functionName: "exactInputSingle",
+    args: [toExactInputSingleStruct(params)],
   });
 }
 
-export const prepareSwapExactInputCalldata = encodeSwapExactInputCalldata;
-
-export function encodeSwapExactOutputCalldata(
-  argsOrParams: SwapExactOutputArgs | SwapExactOutputParams,
-): `0x${string}` {
-  const args = Array.isArray(argsOrParams)
-    ? argsOrParams
-    : ([
-        (argsOrParams as SwapExactOutputParams).pool,
-        (argsOrParams as SwapExactOutputParams).recipient,
-        (argsOrParams as SwapExactOutputParams).zeroForOne,
-        (argsOrParams as SwapExactOutputParams).amountOut,
-        (argsOrParams as SwapExactOutputParams).priceLimitX64,
-        (argsOrParams as SwapExactOutputParams).maxAmountIn,
-        (argsOrParams as SwapExactOutputParams).deadline,
-      ] as const);
+export const prepareExactInputSingleCalldata = encodeExactInputSingleCalldata;
 
+export function encodeExactOutputSingleCalldata(params: ExactOutputSingleParams): Hex {
   return encodeFunctionData({
-    abi: SWAPPER_ABI,
-    functionName: "swapExactOutput",
-    args: withExtensionData(args),
+    abi: SIMPLE_ROUTER_ABI,
+    functionName: "exactOutputSingle",
+    args: [toExactOutputSingleStruct(params)],
   });
 }
 
-export const prepareSwapExactOutputCalldata = encodeSwapExactOutputCalldata;
-
-export function encodeSwapExactInputNativeForTokensCalldata(
-  params: SwapExactInputParams,
-): PreparedSwapTransaction {
-  const data = encodeFunctionData({
-    abi: SWAPPER_ABI,
-    functionName: "swapExactInputNativeForTokens",
-    args: withExtensionData([
-      params.pool,
-      params.recipient,
-      params.zeroForOne,
-      params.amountIn,
-      params.priceLimitX64,
-      params.minAmountOut,
-      params.deadline,
-    ]),
-  });
-
-  return {
-    data,
-    value: params.amountIn,
-  };
-}
-
-export const prepareSwapExactInputNativeForTokensCalldata =
-  encodeSwapExactInputNativeForTokensCalldata;
+export const prepareExactOutputSingleCalldata = encodeExactOutputSingleCalldata;