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

package/src/router/swapPath.ts

@@ -0,0 +1,181 @@
+/**
+ * MetricAMM SDK - SimpleRouter multihop swap helpers.
+ */
+import type { Address, Hex, PublicClient } from "viem";
+import { encodeFunctionData } from "viem";
+import { quoteLiveExactIn, quoteLiveExactOut } from "../quoter/quotePath.js";
+import { resolveSwapPath } from "../swap/path.js";
+import { SIMPLE_ROUTER_ABI } from "../constants.js";
+import { ceilDiv, toSlippageBps } from "./swap.js";
+
+const BPS_BASE = 10_000n;
+
+export type ExactInputParams = {
+  tokens: Address[];
+  pools: Address[];
+  extensionDatas: Hex[];
+  zeroForOneBitMap: bigint;
+  amountIn: bigint;
+  amountOutMinimum: bigint;
+  recipient: Address;
+  deadline: bigint;
+};
+
+export type ExactOutputParams = {
+  tokens: Address[];
+  pools: Address[];
+  extensionDatas: Hex[];
+  zeroForOneBitMap: bigint;
+  amountOut: bigint;
+  amountInMaximum: bigint;
+  recipient: Address;
+  deadline: bigint;
+};
+
+export interface BuildExactInputParams {
+  publicClient: PublicClient;
+  tokenIn: Address;
+  tokenOut: Address;
+  pools: readonly Address[];
+  extensionDatas?: readonly Hex[];
+  recipient: Address;
+  amountIn: bigint;
+  slippagePercent: number;
+  deadline: bigint;
+  quoterAddress?: Address;
+}
+
+export interface BuildExactOutputParams {
+  publicClient: PublicClient;
+  tokenIn: Address;
+  tokenOut: Address;
+  pools: readonly Address[];
+  extensionDatas?: readonly Hex[];
+  recipient: Address;
+  amountOut: bigint;
+  slippagePercent: number;
+  deadline: bigint;
+  quoterAddress?: Address;
+}
+
+function toExactInputStruct(params: ExactInputParams) {
+  return {
+    tokens: params.tokens,
+    pools: params.pools,
+    extensionDatas: params.extensionDatas,
+    zeroForOneBitMap: params.zeroForOneBitMap,
+    amountIn: params.amountIn,
+    amountOutMinimum: params.amountOutMinimum,
+    recipient: params.recipient,
+    deadline: params.deadline,
+  };
+}
+
+function toExactOutputStruct(params: ExactOutputParams) {
+  return {
+    tokens: params.tokens,
+    pools: params.pools,
+    extensionDatas: params.extensionDatas,
+    zeroForOneBitMap: params.zeroForOneBitMap,
+    amountOut: params.amountOut,
+    amountInMaximum: params.amountInMaximum,
+    recipient: params.recipient,
+    deadline: params.deadline,
+  };
+}
+
+export async function buildExactInputParams(
+  params: BuildExactInputParams,
+): Promise<ExactInputParams> {
+  const slippageBps = toSlippageBps(params.slippagePercent);
+  const { tokens, extensionDatas, zeroForOneBitMap } = await resolveSwapPath(
+    params.publicClient,
+    params.tokenIn,
+    params.tokenOut,
+    params.pools,
+    params.extensionDatas,
+  );
+
+  const { amountOut } = await quoteLiveExactIn({
+    publicClient: params.publicClient,
+    tokenIn: params.tokenIn,
+    tokenOut: params.tokenOut,
+    pools: params.pools,
+    extensionDatas: params.extensionDatas,
+    recipient: params.recipient,
+    amountIn: params.amountIn,
+    quoterAddress: params.quoterAddress,
+  });
+
+  const amountOutMinimum = (amountOut * (BPS_BASE - slippageBps)) / BPS_BASE;
+
+  return {
+    tokens,
+    pools: [...params.pools],
+    extensionDatas,
+    zeroForOneBitMap,
+    amountIn: params.amountIn,
+    amountOutMinimum,
+    recipient: params.recipient,
+    deadline: params.deadline,
+  };
+}
+
+export async function buildExactOutputParams(
+  params: BuildExactOutputParams,
+): Promise<ExactOutputParams> {
+  const slippageBps = toSlippageBps(params.slippagePercent);
+  const { tokens, extensionDatas, zeroForOneBitMap } = await resolveSwapPath(
+    params.publicClient,
+    params.tokenIn,
+    params.tokenOut,
+    params.pools,
+    params.extensionDatas,
+  );
+
+  const { amountIn } = await quoteLiveExactOut({
+    publicClient: params.publicClient,
+    tokenIn: params.tokenIn,
+    tokenOut: params.tokenOut,
+    pools: params.pools,
+    extensionDatas: params.extensionDatas,
+    recipient: params.recipient,
+    amountOut: params.amountOut,
+    quoterAddress: params.quoterAddress,
+  });
+
+  const amountInMaximum = ceilDiv(amountIn * (BPS_BASE + slippageBps), BPS_BASE);
+
+  return {
+    tokens,
+    pools: [...params.pools],
+    extensionDatas,
+    zeroForOneBitMap,
+    amountOut: params.amountOut,
+    amountInMaximum,
+    recipient: params.recipient,
+    deadline: params.deadline,
+  };
+}
+
+export function encodeExactInputCalldata(params: ExactInputParams): Hex {
+  return encodeFunctionData({
+    abi: SIMPLE_ROUTER_ABI,
+    functionName: "exactInput",
+    args: [toExactInputStruct(params)],
+  });
+}
+
+export const prepareExactInputCalldata = encodeExactInputCalldata;
+
+export function encodeExactOutputCalldata(params: ExactOutputParams): Hex {
+  return encodeFunctionData({
+    abi: SIMPLE_ROUTER_ABI,
+    functionName: "exactOutput",
+    args: [toExactOutputStruct(params)],
+  });
+}
+
+export const prepareExactOutputCalldata = encodeExactOutputCalldata;
+
+export { encodeZeroForOneBitMap } from "../swap/path.js";

package/src/swap/path.ts

@@ -0,0 +1,107 @@
+/**
+ * MetricAMM SDK - swap path helpers shared by router and quoter.
+ */
+
+import type { Address, Hex, PublicClient } from "viem";
+import { getAddress } from "viem";
+import { POOL_ABI } from "../constants.js";
+import { EMPTY_EXTENSION_DATA } from "../extensions/types.js";
+
+function withExtensionData(extensionData?: Hex): Hex {
+  return extensionData ?? EMPTY_EXTENSION_DATA;
+}
+
+export function encodeZeroForOneBitMap(zeroForOneDirections: readonly boolean[]): bigint {
+  let bitmap = 0n;
+  for (let i = 0; i < zeroForOneDirections.length; i++) {
+    if (zeroForOneDirections[i]) {
+      bitmap |= 1n << BigInt(i);
+    }
+  }
+  return bitmap;
+}
+
+async function readPoolTokens(
+  publicClient: PublicClient,
+  pool: Address,
+): Promise<{ token0: Address; token1: Address }> {
+  const imm = (await publicClient.readContract({
+    address: pool,
+    abi: POOL_ABI,
+    functionName: "getImmutables",
+  })) as { token0: Address; token1: Address };
+
+  return { token0: imm.token0, token1: imm.token1 };
+}
+
+function zeroForOneFromTokenIn(tokenIn: Address, token0: Address, token1: Address): boolean {
+  const normalized = getAddress(tokenIn);
+  if (normalized === getAddress(token0)) return true;
+  if (normalized === getAddress(token1)) return false;
+  throw new Error(`tokenIn ${tokenIn} is not a token in pool (${token0}, ${token1})`);
+}
+
+function normalizeExtensionDatas(
+  pools: readonly Address[],
+  extensionDatas?: readonly Hex[],
+): Hex[] {
+  if (!extensionDatas) {
+    return pools.map(() => EMPTY_EXTENSION_DATA);
+  }
+  if (extensionDatas.length !== pools.length) {
+    throw new Error("extensionDatas length must match pools length");
+  }
+  return extensionDatas.map((extensionData) => withExtensionData(extensionData));
+}
+
+export async function resolveSwapPath(
+  publicClient: PublicClient,
+  tokenIn: Address,
+  tokenOut: Address,
+  pools: readonly Address[],
+  extensionDatas?: readonly Hex[],
+): Promise<{
+  tokens: Address[];
+  zeroForOnes: boolean[];
+  extensionDatas: Hex[];
+  zeroForOneBitMap: bigint;
+}> {
+  if (pools.length === 0) {
+    throw new Error("pools must not be empty");
+  }
+
+  const normalizedExtensionDatas = normalizeExtensionDatas(pools, extensionDatas);
+  const tokens: Address[] = [getAddress(tokenIn)];
+  const zeroForOnes: boolean[] = [];
+  let currentToken = getAddress(tokenIn);
+
+  for (const pool of pools) {
+    const { token0, token1 } = await readPoolTokens(publicClient, pool);
+    const zeroForOne = zeroForOneFromTokenIn(currentToken, token0, token1);
+    const nextToken = getAddress(zeroForOne ? token1 : token0);
+    zeroForOnes.push(zeroForOne);
+    tokens.push(nextToken);
+    currentToken = nextToken;
+  }
+
+  if (currentToken !== getAddress(tokenOut)) {
+    throw new Error(`path ends at ${currentToken}, expected ${getAddress(tokenOut)}`);
+  }
+
+  return {
+    tokens,
+    zeroForOnes,
+    extensionDatas: normalizedExtensionDatas,
+    zeroForOneBitMap: encodeZeroForOneBitMap(zeroForOnes),
+  };
+}
+
+export async function resolveZeroForOne(
+  publicClient: PublicClient,
+  pool: Address,
+  tokenIn: Address,
+  tokenOut: Address,
+): Promise<boolean> {
+  const { zeroForOnes } = await resolveSwapPath(publicClient, tokenIn, tokenOut, [pool]);
+  return zeroForOnes[0]!;
+}