@panoptic-eng/sdk 1.0.5 → 1.0.6

package/dist/router-gzYGM1OO.js

@@ -0,0 +1,1012 @@
+import { PanopticError$1 as PanopticError, getBlockMeta, getPool$1 as getPool, submitWrite } from "./position-FxaZi608.js";
+import { encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, isAddressEqual, maxUint256, zeroAddress } from "viem";
+
+//#region src/uniswap/v4/router/errors.ts
+/**
+* The chain has no configured Uniswap v4 addresses and none were supplied via
+* overrides.
+*/
+var UnsupportedChainError = class extends PanopticError {
+	name = "UnsupportedChainError";
+	constructor(chainId, cause) {
+		super(`Uniswap v4 router not configured for chain ${chainId}`, cause);
+		this.chainId = chainId;
+	}
+};
+/**
+* `tokenIn` is neither `currency0` nor `currency1` of the resolved pool.
+*/
+var InvalidSwapTokenError = class extends PanopticError {
+	name = "InvalidSwapTokenError";
+	constructor(token, currency0, currency1, cause) {
+		super(`Token ${token} is not part of the pool (currency0=${currency0}, currency1=${currency1})`, cause);
+		this.token = token;
+		this.currency0 = currency0;
+		this.currency1 = currency1;
+	}
+};
+/**
+* An amount exceeds the uint128 range required by the v4 swap encoding.
+*/
+var AmountExceedsUint128Error = class extends PanopticError {
+	name = "AmountExceedsUint128Error";
+	constructor(amount, cause) {
+		super(`Amount ${amount} exceeds uint128 maximum`, cause);
+		this.amount = amount;
+	}
+};
+/**
+* A native-ETH swap needs a trailing Universal Router SWEEP to deliver the ETH
+* output (or refund the input overpay), but no `recipient` was supplied.
+*/
+var MissingSweepRecipientError = class extends PanopticError {
+	name = "MissingSweepRecipientError";
+	constructor(cause) {
+		super("A recipient is required to sweep native ETH back to the user", cause);
+	}
+};
+/**
+* The V4Quoter is not available for the chain (no fallback in v1).
+*/
+var QuoterUnavailableError = class extends PanopticError {
+	name = "QuoterUnavailableError";
+	constructor(chainId, cause) {
+		super(`V4Quoter unavailable for chain ${chainId}`, cause);
+		this.chainId = chainId;
+	}
+};
+
+//#endregion
+//#region src/uniswap/v4/addresses.ts
+/**
+* Canonical Permit2, identical across all chains.
+*/
+const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/**
+* Verified Uniswap v4 deployment addresses keyed by chainId.
+*
+* Sourced from the official Uniswap v4 deployments. Add a chain here only after
+* verifying each address against the canonical Uniswap deployment listing —
+* Universal Router in particular is NOT the same address across chains.
+*/
+const UNISWAP_V4_ADDRESSES = { 1: {
+	universalRouter: "0x66a9893cC07D91D95644AEDD05D03f95e1dBA8Af",
+	v4Quoter: "0x52F0E24D1c21C8A0cB1e5a5dD6198556BD9E1203",
+	poolManager: "0x000000000004444c5dc75cB358380D2e3dE08A90",
+	permit2: PERMIT2_ADDRESS
+} };
+/**
+* Resolve the Uniswap v4 addresses for a chain, applying optional overrides.
+*
+* @param chainId - Target chain ID.
+* @param overrides - Partial override of any address (e.g. for fork tests).
+* @returns Fully-resolved {@link UniswapV4Addresses}.
+* @throws {UnsupportedChainError} when the chain is not listed and the
+*   overrides do not supply every required address.
+*/
+function getUniswapV4Addresses(chainId, overrides) {
+	const base = UNISWAP_V4_ADDRESSES[Number(chainId)];
+	const merged = {
+		...base,
+		...overrides,
+		permit2: overrides?.permit2 ?? base?.permit2 ?? PERMIT2_ADDRESS
+	};
+	if (merged.universalRouter === void 0 || merged.v4Quoter === void 0 || merged.poolManager === void 0 || merged.permit2 === void 0) throw new UnsupportedChainError(chainId);
+	return merged;
+}
+
+//#endregion
+//#region src/uniswap/v4/abis/universalRouter.ts
+/**
+* Minimal Universal Router ABI (only the `execute` overload we use).
+* @module uniswap/v4/abis/universalRouter
+*/
+const universalRouterAbi = [{
+	type: "function",
+	name: "execute",
+	stateMutability: "payable",
+	inputs: [
+		{
+			name: "commands",
+			type: "bytes"
+		},
+		{
+			name: "inputs",
+			type: "bytes[]"
+		},
+		{
+			name: "deadline",
+			type: "uint256"
+		}
+	],
+	outputs: []
+}];
+
+//#endregion
+//#region src/uniswap/v4/router/encodeSwap.ts
+/** Universal Router command byte for a v4 swap. */
+const V4_SWAP = 16;
+/** v4 action: exact-in single-hop swap. */
+const SWAP_EXACT_IN_SINGLE = 6;
+/** v4 action: pay all of the input currency owed. */
+const SETTLE_ALL = 12;
+/** v4 action: take all of the output currency owed. */
+const TAKE_ALL = 15;
+/** v4 action: take an output currency to an explicit recipient. */
+const TAKE = 14;
+/** v4 action: exact-out single-hop swap. */
+const SWAP_EXACT_OUT_SINGLE = 8;
+/** Universal Router command: sweep the router's token balance to a recipient. */
+const SWEEP = 4;
+/** v4 sentinel: take the full positive currency delta (used with TAKE). */
+const OPEN_DELTA = 0n;
+const UINT128_MAX$1 = (1n << 128n) - 1n;
+const poolKeyComponents = [
+	{
+		name: "currency0",
+		type: "address"
+	},
+	{
+		name: "currency1",
+		type: "address"
+	},
+	{
+		name: "fee",
+		type: "uint24"
+	},
+	{
+		name: "tickSpacing",
+		type: "int24"
+	},
+	{
+		name: "hooks",
+		type: "address"
+	}
+];
+const exactInputSingleParamsAbi = [{
+	type: "tuple",
+	components: [
+		{
+			name: "poolKey",
+			type: "tuple",
+			components: poolKeyComponents
+		},
+		{
+			name: "zeroForOne",
+			type: "bool"
+		},
+		{
+			name: "amountIn",
+			type: "uint128"
+		},
+		{
+			name: "amountOutMinimum",
+			type: "uint128"
+		},
+		{
+			name: "hookData",
+			type: "bytes"
+		}
+	]
+}];
+const exactOutputSingleParamsAbi = [{
+	type: "tuple",
+	components: [
+		{
+			name: "poolKey",
+			type: "tuple",
+			components: poolKeyComponents
+		},
+		{
+			name: "zeroForOne",
+			type: "bool"
+		},
+		{
+			name: "amountOut",
+			type: "uint128"
+		},
+		{
+			name: "amountInMaximum",
+			type: "uint128"
+		},
+		{
+			name: "hookData",
+			type: "bytes"
+		}
+	]
+}];
+const currencyAmountAbi = [{
+	name: "currency",
+	type: "address"
+}, {
+	name: "amount",
+	type: "uint256"
+}];
+const takeToRecipientAbi = [
+	{
+		name: "currency",
+		type: "address"
+	},
+	{
+		name: "recipient",
+		type: "address"
+	},
+	{
+		name: "amount",
+		type: "uint256"
+	}
+];
+const sweepParamsAbi = [
+	{
+		name: "token",
+		type: "address"
+	},
+	{
+		name: "recipient",
+		type: "address"
+	},
+	{
+		name: "amountMin",
+		type: "uint256"
+	}
+];
+function assertUint128(amount) {
+	if (amount < 0n || amount > UINT128_MAX$1) throw new AmountExceedsUint128Error(amount);
+}
+/**
+* Encode the input for a Universal Router `SWEEP` command that forwards the
+* router's full native-ETH balance (above `amountMin = 0`) to `recipient`.
+*/
+function encodeEthSweepInput(recipient) {
+	return encodeAbiParameters(sweepParamsAbi, [
+		zeroAddress,
+		recipient,
+		0n
+	]);
+}
+/**
+* Build the output-take v4 action byte + param.
+*
+* Native-ETH output is taken with the explicit-recipient `TAKE` action so the
+* router forwards the ETH straight to `recipient` (the implicit-`msgSender`
+* `TAKE_ALL` leaves native ETH held by the router). ERC20 output uses
+* `TAKE_ALL`, which already credits the caller.
+*
+* @param nativeAmount - TAKE amount for native-ETH output: `OPEN_DELTA` (0) to
+*   take the full credit (exact-in, protected by the swap's min) or the exact
+*   output (exact-out).
+* @param erc20Amount - TAKE_ALL min/amount for ERC20 output: `amountOutMinimum`
+*   (exact-in) or the exact output (exact-out).
+*/
+function buildOutputTake(tokenOut, recipient, nativeAmount, erc20Amount) {
+	if (tokenOut === zeroAddress) {
+		if (recipient === void 0) throw new MissingSweepRecipientError();
+		return {
+			action: TAKE,
+			param: encodeAbiParameters(takeToRecipientAbi, [
+				zeroAddress,
+				recipient,
+				nativeAmount
+			])
+		};
+	}
+	return {
+		action: TAKE_ALL,
+		param: encodeAbiParameters(currencyAmountAbi, [tokenOut, erc20Amount])
+	};
+}
+/**
+* Build the typed `execute(...)` args + msg.value for an exact-in single-hop v4
+* swap. Use this when submitting via viem (`writeContract` / `submitWrite`).
+*
+* When `tokenOut` is native ETH the explicit-recipient `TAKE` action forwards
+* the bought ETH to `recipient` (no trailing SWEEP is needed for exact-in).
+*
+* @returns `args` ready to spread into `execute` and the ETH `value` to send
+*   (= `amountIn` for native-ETH input, otherwise `0n`).
+*/
+function buildV4SwapExecuteArgs(args) {
+	const { poolKey, zeroForOne, amountIn, amountOutMinimum, tokenIn, tokenOut, deadline, recipient, hookData = "0x" } = args;
+	assertUint128(amountIn);
+	assertUint128(amountOutMinimum);
+	const swapParam = encodeAbiParameters(exactInputSingleParamsAbi, [{
+		poolKey: {
+			currency0: poolKey.currency0,
+			currency1: poolKey.currency1,
+			fee: Number(poolKey.fee),
+			tickSpacing: Number(poolKey.tickSpacing),
+			hooks: poolKey.hooks
+		},
+		zeroForOne,
+		amountIn,
+		amountOutMinimum,
+		hookData
+	}]);
+	const settleParam = encodeAbiParameters(currencyAmountAbi, [tokenIn, amountIn]);
+	const take = buildOutputTake(tokenOut, recipient, OPEN_DELTA, amountOutMinimum);
+	const actions = encodePacked([
+		"uint8",
+		"uint8",
+		"uint8"
+	], [
+		SWAP_EXACT_IN_SINGLE,
+		SETTLE_ALL,
+		take.action
+	]);
+	const v4Input = encodeAbiParameters([{
+		name: "actions",
+		type: "bytes"
+	}, {
+		name: "params",
+		type: "bytes[]"
+	}], [actions, [
+		swapParam,
+		settleParam,
+		take.param
+	]]);
+	const commands = encodePacked(["uint8"], [V4_SWAP]);
+	const value = tokenIn === zeroAddress ? amountIn : 0n;
+	return {
+		args: [
+			commands,
+			[v4Input],
+			deadline
+		],
+		value
+	};
+}
+/**
+* Build the `execute(commands, inputs, deadline)` calldata + msg.value for an
+* exact-in single-hop v4 swap.
+*
+* @returns The encoded calldata and the ETH `value` to send.
+*/
+function buildV4SwapExecuteCalldata(args) {
+	const { args: executeArgs, value } = buildV4SwapExecuteArgs(args);
+	const data = encodeFunctionData({
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args: executeArgs
+	});
+	return {
+		data,
+		value
+	};
+}
+/**
+* Build the typed `execute(...)` args + msg.value for an exact-out single-hop v4
+* swap. Use this when submitting via viem (`writeContract` / `submitWrite`).
+*
+* For native-ETH input, `value` is `amountInMaximum` (an overpay) and a trailing
+* `SWEEP` action refunds the unused ETH to `recipient`. For ERC20 input, Permit2
+* pulls only the settled amount, so no SWEEP is appended and `value` is `0n`.
+*
+* @returns `args` ready to spread into `execute` and the ETH `value` to send.
+*/
+function buildV4ExactOutSwapExecuteArgs(args) {
+	const { poolKey, zeroForOne, amountOut, amountInMaximum, tokenIn, tokenOut, deadline, recipient, hookData = "0x" } = args;
+	assertUint128(amountOut);
+	assertUint128(amountInMaximum);
+	const swapParam = encodeAbiParameters(exactOutputSingleParamsAbi, [{
+		poolKey: {
+			currency0: poolKey.currency0,
+			currency1: poolKey.currency1,
+			fee: Number(poolKey.fee),
+			tickSpacing: Number(poolKey.tickSpacing),
+			hooks: poolKey.hooks
+		},
+		zeroForOne,
+		amountOut,
+		amountInMaximum,
+		hookData
+	}]);
+	const settleParam = encodeAbiParameters(currencyAmountAbi, [tokenIn, amountInMaximum]);
+	const take = buildOutputTake(tokenOut, recipient, amountOut, amountOut);
+	const actions = encodePacked([
+		"uint8",
+		"uint8",
+		"uint8"
+	], [
+		SWAP_EXACT_OUT_SINGLE,
+		SETTLE_ALL,
+		take.action
+	]);
+	const v4Input = encodeAbiParameters([{
+		name: "actions",
+		type: "bytes"
+	}, {
+		name: "params",
+		type: "bytes[]"
+	}], [actions, [
+		swapParam,
+		settleParam,
+		take.param
+	]]);
+	const isNativeIn = tokenIn === zeroAddress;
+	const commandList = [V4_SWAP];
+	const inputs = [v4Input];
+	if (isNativeIn) {
+		commandList.push(SWEEP);
+		inputs.push(encodeEthSweepInput(recipient));
+	}
+	const commands = encodePacked(commandList.map(() => "uint8"), commandList);
+	const value = isNativeIn ? amountInMaximum : 0n;
+	return {
+		args: [
+			commands,
+			inputs,
+			deadline
+		],
+		value
+	};
+}
+/**
+* Build the `execute(commands, inputs, deadline)` calldata + msg.value for an
+* exact-out single-hop v4 swap.
+*
+* @returns The encoded calldata and the ETH `value` to send.
+*/
+function buildV4ExactOutSwapExecuteCalldata(args) {
+	const { args: executeArgs, value } = buildV4ExactOutSwapExecuteArgs(args);
+	const data = encodeFunctionData({
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args: executeArgs
+	});
+	return {
+		data,
+		value
+	};
+}
+
+//#endregion
+//#region src/uniswap/v4/abis/permit2.ts
+/**
+* Minimal Permit2 ABI (`IAllowanceTransfer` subset: `approve` + `allowance`).
+* @module uniswap/v4/abis/permit2
+*/
+const permit2Abi = [{
+	type: "function",
+	name: "approve",
+	stateMutability: "nonpayable",
+	inputs: [
+		{
+			name: "token",
+			type: "address"
+		},
+		{
+			name: "spender",
+			type: "address"
+		},
+		{
+			name: "amount",
+			type: "uint160"
+		},
+		{
+			name: "expiration",
+			type: "uint48"
+		}
+	],
+	outputs: []
+}, {
+	type: "function",
+	name: "allowance",
+	stateMutability: "view",
+	inputs: [
+		{
+			name: "user",
+			type: "address"
+		},
+		{
+			name: "token",
+			type: "address"
+		},
+		{
+			name: "spender",
+			type: "address"
+		}
+	],
+	outputs: [
+		{
+			name: "amount",
+			type: "uint160"
+		},
+		{
+			name: "expiration",
+			type: "uint48"
+		},
+		{
+			name: "nonce",
+			type: "uint48"
+		}
+	]
+}];
+
+//#endregion
+//#region src/uniswap/v4/router/permit2.ts
+/** uint160 max — the largest Permit2 allowance amount. */
+const UINT160_MAX = (1n << 160n) - 1n;
+/** Default Permit2 allowance expiration window (30 days). */
+const DEFAULT_EXPIRATION_SECONDS = 2592000n;
+/** uint48 max — the largest Permit2 expiration. */
+const UINT48_MAX = (1n << 48n) - 1n;
+/**
+* Check whether the ERC20 → Permit2 → Universal Router allowance chain is
+* sufficient for an exact-in swap of `amount`.
+*/
+async function checkRouterApproval(params) {
+	const { client, chainId, tokenIn, owner, amount, addresses } = params;
+	const { permit2, universalRouter } = getUniswapV4Addresses(chainId, addresses);
+	const [erc20Allowance, permit2Allowance, blockMeta] = await Promise.all([
+		client.readContract({
+			address: tokenIn,
+			abi: erc20Abi,
+			functionName: "allowance",
+			args: [owner, permit2]
+		}),
+		client.readContract({
+			address: permit2,
+			abi: permit2Abi,
+			functionName: "allowance",
+			args: [
+				owner,
+				tokenIn,
+				universalRouter
+			]
+		}),
+		getBlockMeta({ client })
+	]);
+	const [permit2Amount, permit2Expiration] = permit2Allowance;
+	const needsErc20Approval = erc20Allowance < amount;
+	const needsPermit2Approval = permit2Amount < amount || BigInt(permit2Expiration) <= blockMeta.blockTimestamp;
+	return {
+		needsErc20Approval,
+		needsPermit2Approval,
+		erc20Allowance,
+		permit2Amount,
+		permit2Expiration: BigInt(permit2Expiration)
+	};
+}
+/**
+* Step 1: approve the ERC20 token to Permit2 (defaults to unlimited).
+*/
+async function approveErc20ForPermit2(params) {
+	const { client, walletClient, account, chainId, tokenIn, amount = maxUint256, txOverrides, addresses } = params;
+	const { permit2 } = getUniswapV4Addresses(chainId, addresses);
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: tokenIn,
+		abi: erc20Abi,
+		functionName: "approve",
+		args: [permit2, amount],
+		txOverrides
+	});
+}
+/**
+* Step 1 (and wait): approve the ERC20 token to Permit2.
+*/
+async function approveErc20ForPermit2AndWait(params) {
+	const result = await approveErc20ForPermit2(params);
+	return result.wait();
+}
+/**
+* Step 2: approve the Universal Router as a Permit2 spender for the token.
+*/
+async function approveRouterViaPermit2(params) {
+	const { client, walletClient, account, chainId, tokenIn, amount = UINT160_MAX, expiration, txOverrides, addresses } = params;
+	const { permit2, universalRouter } = getUniswapV4Addresses(chainId, addresses);
+	const resolvedExpiration = expiration ?? (await getBlockMeta({ client })).blockTimestamp + DEFAULT_EXPIRATION_SECONDS;
+	const cappedExpiration = resolvedExpiration > UINT48_MAX ? UINT48_MAX : resolvedExpiration;
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: permit2,
+		abi: permit2Abi,
+		functionName: "approve",
+		args: [
+			tokenIn,
+			universalRouter,
+			amount,
+			cappedExpiration
+		],
+		txOverrides
+	});
+}
+/**
+* Step 2 (and wait): approve the Universal Router via Permit2.
+*/
+async function approveRouterViaPermit2AndWait(params) {
+	const result = await approveRouterViaPermit2(params);
+	return result.wait();
+}
+
+//#endregion
+//#region src/uniswap/v4/abis/v4Quoter.ts
+/**
+* Minimal V4Quoter ABI (`quoteExactInputSingle`, `quoteExactOutputSingle`).
+*
+* Note: neither function is `view` — they mutate state internally and are
+* intended to be called via `eth_call` / viem `simulateContract`, never
+* `readContract`.
+*
+* @module uniswap/v4/abis/v4Quoter
+*/
+const quoteExactSingleParams = {
+	name: "params",
+	type: "tuple",
+	components: [
+		{
+			name: "poolKey",
+			type: "tuple",
+			components: [
+				{
+					name: "currency0",
+					type: "address"
+				},
+				{
+					name: "currency1",
+					type: "address"
+				},
+				{
+					name: "fee",
+					type: "uint24"
+				},
+				{
+					name: "tickSpacing",
+					type: "int24"
+				},
+				{
+					name: "hooks",
+					type: "address"
+				}
+			]
+		},
+		{
+			name: "zeroForOne",
+			type: "bool"
+		},
+		{
+			name: "exactAmount",
+			type: "uint128"
+		},
+		{
+			name: "hookData",
+			type: "bytes"
+		}
+	]
+};
+const v4QuoterAbi = [{
+	type: "function",
+	name: "quoteExactInputSingle",
+	stateMutability: "nonpayable",
+	inputs: [quoteExactSingleParams],
+	outputs: [{
+		name: "amountOut",
+		type: "uint256"
+	}, {
+		name: "gasEstimate",
+		type: "uint256"
+	}]
+}, {
+	type: "function",
+	name: "quoteExactOutputSingle",
+	stateMutability: "nonpayable",
+	inputs: [quoteExactSingleParams],
+	outputs: [{
+		name: "amountIn",
+		type: "uint256"
+	}, {
+		name: "gasEstimate",
+		type: "uint256"
+	}]
+}];
+
+//#endregion
+//#region src/uniswap/v4/router/resolvePoolKey.ts
+/**
+* Resolve the PoolKey, swap direction, and output token metadata for a swap.
+*
+* @throws {InvalidSwapTokenError} when `tokenIn` is not part of the pool.
+*/
+async function resolveSwapRoute(params) {
+	const { client, poolAddress, chainId, tokenIn, blockNumber } = params;
+	const pool = await getPool({
+		client,
+		poolAddress,
+		chainId,
+		blockNumber
+	});
+	const { poolKey } = pool;
+	const isCurrency0 = isAddressEqual(tokenIn, poolKey.currency0);
+	const isCurrency1 = isAddressEqual(tokenIn, poolKey.currency1);
+	if (!isCurrency0 && !isCurrency1) throw new InvalidSwapTokenError(tokenIn, poolKey.currency0, poolKey.currency1);
+	const zeroForOne = isCurrency0;
+	const tokenOut = zeroForOne ? poolKey.currency1 : poolKey.currency0;
+	const outTracker = zeroForOne ? pool.collateralTracker1 : pool.collateralTracker0;
+	return {
+		poolKey,
+		zeroForOne,
+		tokenOut,
+		tokenOutDecimals: outTracker.decimals,
+		tokenOutSymbol: outTracker.symbol
+	};
+}
+
+//#endregion
+//#region src/uniswap/v4/router/quote.ts
+const BPS_DENOMINATOR = 10000n;
+const UINT128_MAX = (1n << 128n) - 1n;
+/** Reject out-of-range slippage so the min/max amount math can't underflow/overflow. */
+function assertSlippageBps(slippageBps) {
+	if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR) throw new PanopticError(`invalid slippageBps ${slippageBps}, must be 0..10000`);
+}
+const FALLBACK_META = {
+	blockNumber: 0n,
+	blockTimestamp: 0n,
+	blockHash: "0x0"
+};
+/**
+* Quote an exact-in spot swap against the underlying Uniswap v4 pool.
+*
+* Uses the V4Quoter `quoteExactInputSingle` via `eth_call` (the quoter is
+* state-mutating / revert-based, so it must be simulated, not read). Returns a
+* `SimulationResult` so failures carry a structured error rather than throwing.
+*/
+async function quoteSwapExactInViaRouter(params) {
+	const { client, poolAddress, chainId, tokenIn, amountIn, slippageBps, blockNumber, addresses } = params;
+	try {
+		if (amountIn < 0n || amountIn > UINT128_MAX) throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`);
+		assertSlippageBps(slippageBps);
+		const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+		const metaPromise = getBlockMeta({
+			client,
+			blockNumber: targetBlockNumber
+		});
+		const { v4Quoter } = getUniswapV4Addresses(chainId, addresses);
+		if (v4Quoter === zeroAddress) throw new QuoterUnavailableError(chainId);
+		const route = await resolveSwapRoute({
+			client,
+			poolAddress,
+			chainId,
+			tokenIn,
+			blockNumber: targetBlockNumber
+		});
+		const { result } = await client.simulateContract({
+			address: v4Quoter,
+			abi: v4QuoterAbi,
+			functionName: "quoteExactInputSingle",
+			blockNumber: targetBlockNumber,
+			args: [{
+				poolKey: {
+					currency0: route.poolKey.currency0,
+					currency1: route.poolKey.currency1,
+					fee: Number(route.poolKey.fee),
+					tickSpacing: Number(route.poolKey.tickSpacing),
+					hooks: route.poolKey.hooks
+				},
+				zeroForOne: route.zeroForOne,
+				exactAmount: amountIn,
+				hookData: "0x"
+			}]
+		});
+		const [amountOut, gasEstimate] = result;
+		const amountOutMinimum = amountOut * (BPS_DENOMINATOR - slippageBps) / BPS_DENOMINATOR;
+		const _meta = await metaPromise;
+		return {
+			success: true,
+			data: {
+				amountOut,
+				amountOutMinimum,
+				zeroForOne: route.zeroForOne,
+				tokenOut: route.tokenOut,
+				poolKey: route.poolKey,
+				gasEstimate
+			},
+			gasEstimate,
+			_meta
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof PanopticError ? error : new PanopticError(error instanceof Error ? error.message : "Quote failed", error instanceof Error ? error : void 0),
+			_meta: FALLBACK_META
+		};
+	}
+}
+/**
+* Quote an exact-out spot swap against the underlying Uniswap v4 pool.
+*
+* Uses the V4Quoter `quoteExactOutputSingle` via `eth_call` (the quoter is
+* state-mutating / revert-based, so it must be simulated, not read). Returns a
+* `SimulationResult` so failures carry a structured error rather than throwing.
+*/
+async function quoteSwapExactOutViaRouter(params) {
+	const { client, poolAddress, chainId, tokenIn, amountOut, slippageBps, blockNumber, addresses } = params;
+	try {
+		if (amountOut < 0n || amountOut > UINT128_MAX) throw new PanopticError(`amountOut ${amountOut} exceeds uint128 maximum`);
+		assertSlippageBps(slippageBps);
+		const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+		const metaPromise = getBlockMeta({
+			client,
+			blockNumber: targetBlockNumber
+		});
+		const { v4Quoter } = getUniswapV4Addresses(chainId, addresses);
+		if (v4Quoter === zeroAddress) throw new QuoterUnavailableError(chainId);
+		const route = await resolveSwapRoute({
+			client,
+			poolAddress,
+			chainId,
+			tokenIn,
+			blockNumber: targetBlockNumber
+		});
+		const { result } = await client.simulateContract({
+			address: v4Quoter,
+			abi: v4QuoterAbi,
+			functionName: "quoteExactOutputSingle",
+			blockNumber: targetBlockNumber,
+			args: [{
+				poolKey: {
+					currency0: route.poolKey.currency0,
+					currency1: route.poolKey.currency1,
+					fee: Number(route.poolKey.fee),
+					tickSpacing: Number(route.poolKey.tickSpacing),
+					hooks: route.poolKey.hooks
+				},
+				zeroForOne: route.zeroForOne,
+				exactAmount: amountOut,
+				hookData: "0x"
+			}]
+		});
+		const [amountIn, gasEstimate] = result;
+		const amountInMaximum = (amountIn * (BPS_DENOMINATOR + slippageBps) + BPS_DENOMINATOR - 1n) / BPS_DENOMINATOR;
+		const _meta = await metaPromise;
+		return {
+			success: true,
+			data: {
+				amountIn,
+				amountInMaximum,
+				zeroForOne: route.zeroForOne,
+				tokenOut: route.tokenOut,
+				poolKey: route.poolKey,
+				gasEstimate
+			},
+			gasEstimate,
+			_meta
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof PanopticError ? error : new PanopticError(error instanceof Error ? error.message : "Quote failed", error instanceof Error ? error : void 0),
+			_meta: FALLBACK_META
+		};
+	}
+}
+
+//#endregion
+//#region src/uniswap/v4/router/swap.ts
+/** Default swap deadline window (30 minutes) when no deadline is provided. */
+const DEFAULT_DEADLINE_SECONDS = 1800n;
+/**
+* Execute an exact-in spot swap via the Universal Router.
+*
+* @param params - Swap parameters.
+* @returns TxResult with hash + wait().
+*
+* @example
+* ```typescript
+* const result = await swapExactInViaRouter({
+*   client, walletClient, account, poolAddress,
+*   chainId: 1n,
+*   tokenIn: ZERO_ADDRESS,        // native ETH
+*   amountIn: 10n ** 17n,         // 0.1 ETH
+*   slippageBps: 50n,             // 0.5%
+* })
+* await result.wait()
+* ```
+*/
+async function swapExactInViaRouter(params) {
+	const { client, walletClient, account, poolAddress, chainId, tokenIn, amountIn, slippageBps, deadline, recipient, txOverrides, addresses } = params;
+	if (recipient !== void 0 && !isAddressEqual(recipient, account)) throw new PanopticError("Custom recipient is not supported yet; output goes to the sender");
+	const resolved = getUniswapV4Addresses(chainId, addresses);
+	const quote = await quoteSwapExactInViaRouter({
+		client,
+		poolAddress,
+		chainId,
+		tokenIn,
+		amountIn,
+		slippageBps,
+		addresses
+	});
+	if (!quote.success) throw quote.error;
+	const resolvedDeadline = deadline ?? (await getBlockMeta({ client })).blockTimestamp + DEFAULT_DEADLINE_SECONDS;
+	const { args, value } = buildV4SwapExecuteArgs({
+		poolKey: quote.data.poolKey,
+		zeroForOne: quote.data.zeroForOne,
+		amountIn,
+		amountOutMinimum: quote.data.amountOutMinimum,
+		tokenIn,
+		tokenOut: quote.data.tokenOut,
+		deadline: resolvedDeadline,
+		recipient: account
+	});
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: resolved.universalRouter,
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args,
+		value,
+		txOverrides
+	});
+}
+/**
+* Execute an exact-in swap via the Universal Router and wait for confirmation.
+*/
+async function swapExactInViaRouterAndWait(params) {
+	const result = await swapExactInViaRouter(params);
+	return result.wait();
+}
+/**
+* Execute an exact-out spot swap via the Universal Router.
+*
+* The caller specifies the exact `amountOut` to receive; the input (pay) amount
+* is quoted and capped at `amountInMaximum`. For native-ETH input the router is
+* funded with `amountInMaximum` and the unused surplus is swept back to the
+* sender.
+*
+* @param params - Swap parameters.
+* @returns TxResult with hash + wait().
+*/
+async function swapExactOutViaRouter(params) {
+	const { client, walletClient, account, poolAddress, chainId, tokenIn, amountOut, slippageBps, deadline, recipient, txOverrides, addresses } = params;
+	if (recipient !== void 0 && !isAddressEqual(recipient, account)) throw new PanopticError("Custom recipient is not supported yet; output goes to the sender");
+	const resolved = getUniswapV4Addresses(chainId, addresses);
+	const quote = await quoteSwapExactOutViaRouter({
+		client,
+		poolAddress,
+		chainId,
+		tokenIn,
+		amountOut,
+		slippageBps,
+		addresses
+	});
+	if (!quote.success) throw quote.error;
+	const resolvedDeadline = deadline ?? (await getBlockMeta({ client })).blockTimestamp + DEFAULT_DEADLINE_SECONDS;
+	const { args, value } = buildV4ExactOutSwapExecuteArgs({
+		poolKey: quote.data.poolKey,
+		zeroForOne: quote.data.zeroForOne,
+		amountOut,
+		amountInMaximum: quote.data.amountInMaximum,
+		tokenIn,
+		tokenOut: quote.data.tokenOut,
+		deadline: resolvedDeadline,
+		recipient: account
+	});
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: resolved.universalRouter,
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args,
+		value,
+		txOverrides
+	});
+}
+/**
+* Execute an exact-out swap via the Universal Router and wait for confirmation.
+*/
+async function swapExactOutViaRouterAndWait(params) {
+	const result = await swapExactOutViaRouter(params);
+	return result.wait();
+}
+
+//#endregion
+export { AmountExceedsUint128Error, InvalidSwapTokenError, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoterUnavailableError, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, TAKE_ALL, UNISWAP_V4_ADDRESSES, UnsupportedChainError, V4_SWAP, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, checkRouterApproval, getUniswapV4Addresses, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, resolveSwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactOutViaRouter, swapExactOutViaRouterAndWait };
+//# sourceMappingURL=router-gzYGM1OO.js.map