@panoptic-eng/sdk 1.0.21 → 1.0.23

package/dist/types-CspUPolV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CspUPolV.d.ts","names":["tickToSqrtPriceX96","tickToPrice","tickToPriceDecimalScaled","sqrtPriceX96ToPriceDecimalScaled","priceToTick","sqrtPriceX96ToTick","formatTick","getPricesAtTick","formatTickRange","formatPriceRange","getTickSpacing","roundToTickSpacing","TickLimitsResult","tickLimits","Address","PublicClient","tickToSqrtPriceX96","BlockMeta","OracleState","Pool","RiskParameters","Utilization","PoolMetadata","GetPoolMetadataParams","getPoolMetadata","Promise","GetPoolParams","getPool","GetUtilizationParams","getUtilization","GetOracleStateParams","getOracleState","GetRiskParametersParams","getRiskParameters","validateBuilderCode","FetchPoolIdParams","FetchPoolIdResult","fetchPoolId","Address","PoolMetadata","BlockMeta","PoolHealthStatus","CollateralTracker","RiskEngine","PoolKey","Pool","Utilization","BlockMeta","SafeMode","OracleState","SafeModeState","RiskParameters","CurrentRates","Address","UniswapV4Addresses","PERMIT2_ADDRESS","UNISWAP_V4_ADDRESSES","Record","getUniswapV4Addresses","Partial","Address","PublicClient","WalletClient","PoolKey","TxOverrides","UniswapV4Addresses","SwapExactInViaRouterParams","Partial","QuoteSwapExactInViaRouterParams","SwapExactInQuote","SwapExactOutViaRouterParams","QuoteSwapExactOutViaRouterParams","SwapExactOutQuote","CheckRouterApprovalParams","RouterApprovalStatus","ApproveErc20ForPermit2Params","ApproveRouterViaPermit2Params"],"sources":["../src/panoptic/v2/formatters/tick.d.ts","../src/panoptic/v2/reads/pool.d.ts","../src/panoptic/v2/types/pool.d.ts","../src/panoptic/v2/types/oracle.d.ts","../src/uniswap/v4/addresses.d.ts","../src/uniswap/v4/router/types.d.ts"],"sourcesContent":null,"mappings":"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"}

package/dist/uniswap/index.d.ts

@@ -1,6 +1,6 @@
-import { PanopticError, PoolKey, SimulationResult, TxReceipt, TxResult } from "../index-DVMjZi1E.js";
-import "../irm-CGykVo3q.js";
-import { ApproveErc20ForPermit2Params, ApproveRouterViaPermit2Params, CheckRouterApprovalParams, PERMIT2_ADDRESS$1 as PERMIT2_ADDRESS, QuoteSwapExactInViaRouterParams, QuoteSwapExactOutViaRouterParams, RouterApprovalStatus, SwapExactInQuote, SwapExactInViaRouterParams, SwapExactOutQuote, SwapExactOutViaRouterParams, UNISWAP_V4_ADDRESSES$1 as UNISWAP_V4_ADDRESSES, UniswapV4Addresses, getUniswapV4Addresses$1 as getUniswapV4Addresses } from "../types-BQejAFnu.js";
+import { PanopticError$1 as PanopticError, SimulationResult } from "../simulation-4SzTI-xf.js";
+import { ApproveErc20ForPermit2Params, ApproveRouterViaPermit2Params, CheckRouterApprovalParams, PERMIT2_ADDRESS$1 as PERMIT2_ADDRESS, PoolKey, QuoteSwapExactInViaRouterParams, QuoteSwapExactOutViaRouterParams, RouterApprovalStatus, SwapExactInQuote, SwapExactInViaRouterParams, SwapExactOutQuote, SwapExactOutViaRouterParams, UNISWAP_V4_ADDRESSES$1 as UNISWAP_V4_ADDRESSES, UniswapV4Addresses, getUniswapV4Addresses$1 as getUniswapV4Addresses } from "../types-CspUPolV.js";
+import { TxReceipt, TxResult } from "../tx-Banz1S18.js";
 import { Address, Hex, PublicClient } from "viem";
 
 //#region src/uniswap/v4/router/encodeSwap.d.ts
@@ -210,6 +210,30 @@ declare function quoteSwapExactInViaRouter(params: QuoteSwapExactInViaRouterPara
  */
 declare function quoteSwapExactOutViaRouter(params: QuoteSwapExactOutViaRouterParams): Promise<SimulationResult<SwapExactOutQuote>>;
 
+//#endregion
+//#region src/uniswap/v4/router/quoteByPoolKey.d.ts
+interface QuoteV4ExactInByPoolKeyParams {
+  client: PublicClient;
+  chainId: bigint;
+  poolKey: PoolKey;
+  zeroForOne: boolean;
+  amountIn: bigint;
+  slippageBps: bigint;
+  blockNumber?: bigint;
+  addresses?: Partial<UniswapV4Addresses>;
+}
+interface V4ExactInQuote {
+  amountOut: bigint;
+  amountOutMinimum: bigint;
+  gasEstimate: bigint;
+}
+/**
+ * Quote an exact-in v4 swap for a specific PoolKey. Returns `null` when the
+ * quote reverts (pool missing / no liquidity) so callers can skip that pool when
+ * ranking venues rather than aborting the cycle.
+ */
+declare function quoteV4ExactInByPoolKey(params: QuoteV4ExactInByPoolKeyParams): Promise<V4ExactInQuote | null>;
+
 //#endregion
 //#region src/uniswap/v4/router/resolvePoolKey.d.ts
 /**
@@ -287,5 +311,98 @@ declare function swapExactOutViaRouter(params: SwapExactOutViaRouterParams): Pro
 declare function swapExactOutViaRouterAndWait(params: SwapExactOutViaRouterParams): Promise<TxReceipt>;
 
 //#endregion
-export { AmountExceedsUint128Error, ApproveErc20ForPermit2Params, ApproveRouterViaPermit2Params, BuildV4ExactOutSwapCalldataArgs, BuildV4SwapCalldataArgs, CheckRouterApprovalParams, InvalidSwapTokenError, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoteSwapExactInViaRouterParams, QuoteSwapExactOutViaRouterParams, QuoterUnavailableError, ResolveSwapRouteParams, ResolvedSwapRoute, RouterApprovalStatus, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, SwapExactInQuote, SwapExactInViaRouterParams, SwapExactOutQuote, SwapExactOutViaRouterParams, TAKE_ALL, UNISWAP_V4_ADDRESSES, UniswapV4Addresses, UnsupportedChainError, V4_SWAP, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, checkRouterApproval, getUniswapV4Addresses, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, resolveSwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactOutViaRouter, swapExactOutViaRouterAndWait };
+//#region src/uniswap/v3/addresses.d.ts
+interface UniswapV3Addresses {
+  /** Uniswap v3 QuoterV2 — `quoteExactInputSingle` (revert/staticcall-based). */
+  quoterV2: Address;
+}
+/**
+ * Verified Uniswap v3 QuoterV2 addresses keyed by chainId. Add a chain only
+ * after verifying against the canonical Uniswap v3 deployment listing.
+ */
+declare const UNISWAP_V3_ADDRESSES: Record<number, UniswapV3Addresses>;
+/**
+ * Resolve Uniswap v3 addresses for a chain, applying optional overrides.
+ *
+ * @throws {UnsupportedChainError} when the chain is not listed and overrides do
+ *   not supply every required address.
+ */
+declare function getUniswapV3Addresses(chainId: number | bigint, overrides?: Partial<UniswapV3Addresses>): UniswapV3Addresses;
+
+//#endregion
+//#region src/uniswap/v3/router/encodeSwap.d.ts
+/** Universal Router command byte for a v3 exact-in swap. */
+declare const V3_SWAP_EXACT_IN = 0;
+/**
+ * Universal Router recipient sentinel: the router maps `address(1)` to
+ * `msg.sender` (the `execute` caller). Uniswap `Constants.MSG_SENDER`.
+ */
+declare const MSG_SENDER: Address;
+/** Arguments for {@link buildV3SwapExecuteCalldata}. */
+interface BuildV3SwapCalldataArgs {
+  /** Input token (funds pulled from the caller via Permit2). */
+  tokenIn: Address;
+  /** Output token. */
+  tokenOut: Address;
+  /** v3 pool fee tier (e.g. 500, 3000). */
+  fee: bigint;
+  /** Exact input amount (uint128). */
+  amountIn: bigint;
+  /** Minimum acceptable output (uint128). */
+  amountOutMinimum: bigint;
+  /**
+   * Absolute deadline (unix seconds) — the `execute(commands, inputs, deadline)`
+   * argument, enforced by the Universal Router.
+   */
+  deadline: bigint;
+}
+/**
+ * Encode the packed v3 single-hop path `tokenIn ++ fee(uint24) ++ tokenOut`.
+ */
+declare function encodeV3Path(tokenIn: Address, fee: bigint, tokenOut: Address): Hex;
+/**
+ * Build the typed `execute(...)` args for an exact-in single-hop v3 swap whose
+ * output is delivered to the `execute` caller (recipient = MSG_SENDER).
+ */
+declare function buildV3SwapExecuteArgs(args: BuildV3SwapCalldataArgs): {
+  args: readonly [Hex, readonly Hex[], bigint];
+  value: bigint;
+};
+/**
+ * Build the `execute(commands, inputs, deadline)` calldata for an exact-in
+ * single-hop v3 swap.
+ */
+declare function buildV3SwapExecuteCalldata(args: BuildV3SwapCalldataArgs): {
+  data: Hex;
+  value: bigint;
+};
+
+//#endregion
+//#region src/uniswap/v3/router/quote.d.ts
+interface QuoteV3ExactInParams {
+  client: PublicClient;
+  chainId: bigint;
+  tokenIn: Address;
+  tokenOut: Address;
+  fee: bigint;
+  amountIn: bigint;
+  /** Slippage tolerance in bps, used to compute `amountOutMinimum`. */
+  slippageBps: bigint;
+  blockNumber?: bigint;
+  addresses?: Partial<UniswapV3Addresses>;
+}
+interface V3ExactInQuote {
+  amountOut: bigint;
+  amountOutMinimum: bigint;
+  gasEstimate: bigint;
+}
+/**
+ * Quote an exact-in v3 swap. Returns `null` when the quote reverts (e.g. the
+ * pool does not exist / has no liquidity) so callers can skip that pool when
+ * ranking venues, rather than aborting the whole cycle.
+ */
+declare function quoteV3ExactIn(params: QuoteV3ExactInParams): Promise<V3ExactInQuote | null>;
+
+//#endregion
+export { AmountExceedsUint128Error, ApproveErc20ForPermit2Params, ApproveRouterViaPermit2Params, BuildV3SwapCalldataArgs, BuildV4ExactOutSwapCalldataArgs, BuildV4SwapCalldataArgs, CheckRouterApprovalParams, InvalidSwapTokenError, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoteSwapExactInViaRouterParams, QuoteSwapExactOutViaRouterParams, QuoteV3ExactInParams, QuoteV4ExactInByPoolKeyParams, QuoterUnavailableError, ResolveSwapRouteParams, ResolvedSwapRoute, RouterApprovalStatus, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, SwapExactInQuote, SwapExactInViaRouterParams, SwapExactOutQuote, SwapExactOutViaRouterParams, TAKE_ALL, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UniswapV3Addresses, UniswapV4Addresses, UnsupportedChainError, V3ExactInQuote, V3_SWAP_EXACT_IN, V4ExactInQuote, V4_SWAP, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, checkRouterApproval, encodeV3Path, getUniswapV3Addresses, getUniswapV4Addresses, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, quoteV3ExactIn, quoteV4ExactInByPoolKey, resolveSwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactOutViaRouter, swapExactOutViaRouterAndWait };
 //# sourceMappingURL=index.d.ts.map

package/dist/uniswap/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["Address","Hex","PoolKey","V4_SWAP","SWAP_EXACT_IN_SINGLE","SETTLE_ALL","TAKE_ALL","TAKE","SWAP_EXACT_OUT_SINGLE","SWEEP","BuildV4SwapCalldataArgs","buildV4SwapExecuteArgs","buildV4SwapExecuteCalldata","BuildV4ExactOutSwapCalldataArgs","buildV4ExactOutSwapExecuteArgs","buildV4ExactOutSwapExecuteCalldata","Address","PanopticError","UnsupportedChainError","Error","InvalidSwapTokenError","AmountExceedsUint128Error","MissingSweepRecipientError","QuoterUnavailableError","TxReceipt","TxResult","ApproveErc20ForPermit2Params","ApproveRouterViaPermit2Params","CheckRouterApprovalParams","RouterApprovalStatus","checkRouterApproval","Promise","approveErc20ForPermit2","approveErc20ForPermit2AndWait","approveRouterViaPermit2","approveRouterViaPermit2AndWait","SimulationResult","QuoteSwapExactInViaRouterParams","QuoteSwapExactOutViaRouterParams","SwapExactInQuote","SwapExactOutQuote","quoteSwapExactInViaRouter","Promise","quoteSwapExactOutViaRouter","Address","PublicClient","PoolKey","ResolvedSwapRoute","ResolveSwapRouteParams","resolveSwapRoute","Promise","TxReceipt","TxResult","SwapExactInViaRouterParams","SwapExactOutViaRouterParams","swapExactInViaRouter","Promise","swapExactInViaRouterAndWait","swapExactOutViaRouter","swapExactOutViaRouterAndWait"],"sources":["../../src/uniswap/v4/router/encodeSwap.d.ts","../../src/uniswap/v4/router/errors.d.ts","../../src/uniswap/v4/router/permit2.d.ts","../../src/uniswap/v4/router/quote.d.ts","../../src/uniswap/v4/router/resolvePoolKey.d.ts","../../src/uniswap/v4/router/swap.d.ts"],"sourcesContent":null,"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["Address","Hex","PoolKey","V4_SWAP","SWAP_EXACT_IN_SINGLE","SETTLE_ALL","TAKE_ALL","TAKE","SWAP_EXACT_OUT_SINGLE","SWEEP","BuildV4SwapCalldataArgs","buildV4SwapExecuteArgs","buildV4SwapExecuteCalldata","BuildV4ExactOutSwapCalldataArgs","buildV4ExactOutSwapExecuteArgs","buildV4ExactOutSwapExecuteCalldata","Address","PanopticError","UnsupportedChainError","Error","InvalidSwapTokenError","AmountExceedsUint128Error","MissingSweepRecipientError","QuoterUnavailableError","TxReceipt","TxResult","ApproveErc20ForPermit2Params","ApproveRouterViaPermit2Params","CheckRouterApprovalParams","RouterApprovalStatus","checkRouterApproval","Promise","approveErc20ForPermit2","approveErc20ForPermit2AndWait","approveRouterViaPermit2","approveRouterViaPermit2AndWait","SimulationResult","QuoteSwapExactInViaRouterParams","QuoteSwapExactOutViaRouterParams","SwapExactInQuote","SwapExactOutQuote","quoteSwapExactInViaRouter","Promise","quoteSwapExactOutViaRouter","PublicClient","PoolKey","UniswapV4Addresses","QuoteV4ExactInByPoolKeyParams","Partial","V4ExactInQuote","quoteV4ExactInByPoolKey","Promise","Address","PublicClient","PoolKey","ResolvedSwapRoute","ResolveSwapRouteParams","resolveSwapRoute","Promise","TxReceipt","TxResult","SwapExactInViaRouterParams","SwapExactOutViaRouterParams","swapExactInViaRouter","Promise","swapExactInViaRouterAndWait","swapExactOutViaRouter","swapExactOutViaRouterAndWait","Address","UniswapV3Addresses","UNISWAP_V3_ADDRESSES","Record","getUniswapV3Addresses","Partial","Address","Hex","V3_SWAP_EXACT_IN","MSG_SENDER","BuildV3SwapCalldataArgs","encodeV3Path","buildV3SwapExecuteArgs","buildV3SwapExecuteCalldata","Address","PublicClient","UniswapV3Addresses","QuoteV3ExactInParams","Partial","V3ExactInQuote","quoteV3ExactIn","Promise"],"sources":["../../src/uniswap/v4/router/encodeSwap.d.ts","../../src/uniswap/v4/router/errors.d.ts","../../src/uniswap/v4/router/permit2.d.ts","../../src/uniswap/v4/router/quote.d.ts","../../src/uniswap/v4/router/quoteByPoolKey.d.ts","../../src/uniswap/v4/router/resolvePoolKey.d.ts","../../src/uniswap/v4/router/swap.d.ts","../../src/uniswap/v3/addresses.d.ts","../../src/uniswap/v3/router/encodeSwap.d.ts","../../src/uniswap/v3/router/quote.d.ts"],"sourcesContent":null,"mappings":"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"}

package/dist/uniswap/index.js

@@ -1,5 +1,229 @@
-import "../position-BK4a-Yyu.js";
-import "../writes-DymnVbiE.js";
-import { 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 } from "../router-CMrp245w.js";
+import { PanopticError } from "../position-CsIEneku.js";
+import "../writes-BnO9zj-Z.js";
+import { 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, quoteV4ExactInByPoolKey, resolveSwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactOutViaRouter, swapExactOutViaRouterAndWait, universalRouterAbi } from "../router-BM10ZWY5.js";
+import { BaseError, ContractFunctionRevertedError, encodeAbiParameters, encodeFunctionData, encodePacked, zeroAddress } from "viem";
 
-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 };
+//#region src/uniswap/v3/addresses.ts
+/**
+* Verified Uniswap v3 QuoterV2 addresses keyed by chainId. Add a chain only
+* after verifying against the canonical Uniswap v3 deployment listing.
+*/
+const UNISWAP_V3_ADDRESSES = { 1: { quoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e" } };
+/**
+* Resolve Uniswap v3 addresses for a chain, applying optional overrides.
+*
+* @throws {UnsupportedChainError} when the chain is not listed and overrides do
+*   not supply every required address.
+*/
+function getUniswapV3Addresses(chainId, overrides) {
+	const id = Number(chainId);
+	const base = UNISWAP_V3_ADDRESSES[id];
+	const merged = {
+		...base,
+		...overrides
+	};
+	if (!merged.quoterV2) throw new UnsupportedChainError(BigInt(id));
+	return merged;
+}
+
+//#endregion
+//#region src/uniswap/v3/router/encodeSwap.ts
+/** Universal Router command byte for a v3 exact-in swap. */
+const V3_SWAP_EXACT_IN = 0;
+/**
+* Universal Router recipient sentinel: the router maps `address(1)` to
+* `msg.sender` (the `execute` caller). Uniswap `Constants.MSG_SENDER`.
+*/
+const MSG_SENDER = "0x0000000000000000000000000000000000000001";
+const UINT128_MAX$1 = (1n << 128n) - 1n;
+const v3ExactInInputAbi = [
+	{
+		name: "recipient",
+		type: "address"
+	},
+	{
+		name: "amountIn",
+		type: "uint256"
+	},
+	{
+		name: "amountOutMinimum",
+		type: "uint256"
+	},
+	{
+		name: "path",
+		type: "bytes"
+	},
+	{
+		name: "payerIsUser",
+		type: "bool"
+	}
+];
+function assertUint128(amount) {
+	if (amount < 0n || amount > UINT128_MAX$1) throw new AmountExceedsUint128Error(amount);
+}
+/**
+* Encode the packed v3 single-hop path `tokenIn ++ fee(uint24) ++ tokenOut`.
+*/
+function encodeV3Path(tokenIn, fee, tokenOut) {
+	if (fee < 0n || fee > 0xffffffn) throw new PanopticError(`v3 fee ${fee} exceeds uint24`);
+	return encodePacked([
+		"address",
+		"uint24",
+		"address"
+	], [
+		tokenIn,
+		Number(fee),
+		tokenOut
+	]);
+}
+/**
+* Build the typed `execute(...)` args for an exact-in single-hop v3 swap whose
+* output is delivered to the `execute` caller (recipient = MSG_SENDER).
+*/
+function buildV3SwapExecuteArgs(args) {
+	const { tokenIn, tokenOut, fee, amountIn, amountOutMinimum, deadline } = args;
+	if (tokenIn === zeroAddress || tokenOut === zeroAddress) throw new PanopticError("native ETH is not supported by the v3 exact-in router builder");
+	assertUint128(amountIn);
+	assertUint128(amountOutMinimum);
+	const path = encodeV3Path(tokenIn, fee, tokenOut);
+	const input = encodeAbiParameters(v3ExactInInputAbi, [
+		MSG_SENDER,
+		amountIn,
+		amountOutMinimum,
+		path,
+		true
+	]);
+	const commands = encodePacked(["uint8"], [V3_SWAP_EXACT_IN]);
+	return {
+		args: [
+			commands,
+			[input],
+			deadline
+		],
+		value: 0n
+	};
+}
+/**
+* Build the `execute(commands, inputs, deadline)` calldata for an exact-in
+* single-hop v3 swap.
+*/
+function buildV3SwapExecuteCalldata(args) {
+	const { args: executeArgs, value } = buildV3SwapExecuteArgs(args);
+	const data = encodeFunctionData({
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args: executeArgs
+	});
+	return {
+		data,
+		value
+	};
+}
+
+//#endregion
+//#region src/uniswap/v3/abis/quoterV2.ts
+/**
+* Minimal Uniswap v3 QuoterV2 ABI (`quoteExactInputSingle`).
+*
+* QuoterV2 is revert/staticcall-based (nonpayable but intended for `eth_call` /
+* `simulateContract`), so it must be simulated, not read.
+* @module uniswap/v3/abis/quoterV2
+*/
+const quoterV2Abi = [{
+	type: "function",
+	name: "quoteExactInputSingle",
+	stateMutability: "nonpayable",
+	inputs: [{
+		name: "params",
+		type: "tuple",
+		components: [
+			{
+				name: "tokenIn",
+				type: "address"
+			},
+			{
+				name: "tokenOut",
+				type: "address"
+			},
+			{
+				name: "amountIn",
+				type: "uint256"
+			},
+			{
+				name: "fee",
+				type: "uint24"
+			},
+			{
+				name: "sqrtPriceLimitX96",
+				type: "uint160"
+			}
+		]
+	}],
+	outputs: [
+		{
+			name: "amountOut",
+			type: "uint256"
+		},
+		{
+			name: "sqrtPriceX96After",
+			type: "uint160"
+		},
+		{
+			name: "initializedTicksCrossed",
+			type: "uint32"
+		},
+		{
+			name: "gasEstimate",
+			type: "uint256"
+		}
+	]
+}];
+
+//#endregion
+//#region src/uniswap/v3/router/quote.ts
+const BPS_DENOMINATOR = 10000n;
+const UINT128_MAX = (1n << 128n) - 1n;
+/**
+* Quote an exact-in v3 swap. Returns `null` when the quote reverts (e.g. the
+* pool does not exist / has no liquidity) so callers can skip that pool when
+* ranking venues, rather than aborting the whole cycle.
+*/
+async function quoteV3ExactIn(params) {
+	const { client, chainId, tokenIn, tokenOut, fee, amountIn, slippageBps, blockNumber } = params;
+	if (amountIn < 0n || amountIn > UINT128_MAX) throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`);
+	if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR) throw new PanopticError(`invalid slippageBps ${slippageBps}, must be 0..10000`);
+	const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses);
+	try {
+		const { result } = await client.simulateContract({
+			address: quoterV2,
+			abi: quoterV2Abi,
+			functionName: "quoteExactInputSingle",
+			blockNumber,
+			args: [{
+				tokenIn,
+				tokenOut,
+				amountIn,
+				fee: Number(fee),
+				sqrtPriceLimitX96: 0n
+			}]
+		});
+		const [amountOut, , , gasEstimate] = result;
+		const amountOutMinimum = amountOut * (BPS_DENOMINATOR - slippageBps) / BPS_DENOMINATOR;
+		return {
+			amountOut,
+			amountOutMinimum,
+			gasEstimate
+		};
+	} catch (err) {
+		if (isRevert(err)) return null;
+		throw err;
+	}
+}
+/** True only for genuine contract reverts (missing pool / no liquidity). */
+function isRevert(err) {
+	return err instanceof BaseError && err.walk((e) => e instanceof ContractFunctionRevertedError) instanceof ContractFunctionRevertedError;
+}
+
+//#endregion
+export { AmountExceedsUint128Error, InvalidSwapTokenError, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoterUnavailableError, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, TAKE_ALL, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UnsupportedChainError, V3_SWAP_EXACT_IN, V4_SWAP, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, checkRouterApproval, encodeV3Path, getUniswapV3Addresses, getUniswapV4Addresses, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, quoteV3ExactIn, quoteV4ExactInByPoolKey, resolveSwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactOutViaRouter, swapExactOutViaRouterAndWait };
+//# sourceMappingURL=index.js.map

package/dist/uniswap/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["UNISWAP_V3_ADDRESSES: Record<number, UniswapV3Addresses>","chainId: number | bigint","overrides?: Partial<UniswapV3Addresses>","MSG_SENDER: Address","UINT128_MAX","amount: bigint","tokenIn: Address","fee: bigint","tokenOut: Address","args: BuildV3SwapCalldataArgs","params: QuoteV3ExactInParams","err: unknown"],"sources":["../../src/uniswap/v3/addresses.ts","../../src/uniswap/v3/router/encodeSwap.ts","../../src/uniswap/v3/abis/quoterV2.ts","../../src/uniswap/v3/router/quote.ts"],"sourcesContent":["/**\n * Per-chain Uniswap v3 addresses needed for spot quoting via the Universal\n * Router. The Universal Router itself is shared with v4 (see\n * `uniswap/v4/addresses`); only the v3 QuoterV2 is specific to v3.\n *\n * v1 supports mainnet only; other chains throw {@link UnsupportedChainError}\n * unless the address is supplied via overrides (fork tests / new chains).\n *\n * @module uniswap/v3/addresses\n */\n\nimport type { Address } from 'viem'\n\nimport { UnsupportedChainError } from '../v4/router/errors'\n\nexport interface UniswapV3Addresses {\n  /** Uniswap v3 QuoterV2 — `quoteExactInputSingle` (revert/staticcall-based). */\n  quoterV2: Address\n}\n\n/**\n * Verified Uniswap v3 QuoterV2 addresses keyed by chainId. Add a chain only\n * after verifying against the canonical Uniswap v3 deployment listing.\n */\nexport const UNISWAP_V3_ADDRESSES: Record<number, UniswapV3Addresses> = {\n  // Ethereum mainnet\n  1: { quoterV2: '0x61fFE014bA17989E743c5F6cB21bF9697530B21e' },\n}\n\n/**\n * Resolve Uniswap v3 addresses for a chain, applying optional overrides.\n *\n * @throws {UnsupportedChainError} when the chain is not listed and overrides do\n *   not supply every required address.\n */\nexport function getUniswapV3Addresses(\n  chainId: number | bigint,\n  overrides?: Partial<UniswapV3Addresses>,\n): UniswapV3Addresses {\n  const id = Number(chainId)\n  const base = UNISWAP_V3_ADDRESSES[id]\n  const merged = { ...base, ...overrides }\n  if (!merged.quoterV2) {\n    throw new UnsupportedChainError(BigInt(id))\n  }\n  return merged as UniswapV3Addresses\n}\n","/**\n * Pure calldata builder for an exact-in single-hop swap through a Uniswap **v3**\n * pool via the Universal Router.\n *\n * Opcodes verified against `@uniswap/universal-router` `Commands.sol`:\n * - Universal Router command `V3_SWAP_EXACT_IN = 0x00`.\n *\n * The v3 command input is (unlike the v4 action list) a single flat tuple:\n *   `(address recipient, uint256 amountIn, uint256 amountOutMinimum,\n *     bytes path, bool payerIsUser)`\n * where:\n * - `recipient` is an EXPLICIT field. We encode the Universal Router sentinel\n *   `MSG_SENDER = address(1)`, which the router maps to the `execute` caller —\n *   so the output is delivered to the caller (e.g. a Safe) with no literal\n *   address in the calldata to redirect.\n * - `path` is `abi.encodePacked(tokenIn, fee (uint24), tokenOut)` for a single\n *   hop (43 bytes). The direction lives in the path ordering, not a bool.\n * - `payerIsUser = true`: the router pulls `tokenIn` from the caller via Permit2.\n *\n * ERC20-only: native ETH is intentionally unsupported here (the native paths\n * need WRAP/UNWRAP/SWEEP commands with explicit recipients).\n *\n * @module uniswap/v3/router/encodeSwap\n */\n\nimport type { Address, Hex } from 'viem'\nimport { encodeAbiParameters, encodeFunctionData, encodePacked, zeroAddress } from 'viem'\n\nimport { PanopticError } from '../../../panoptic/v2/errors'\nimport { universalRouterAbi } from '../../v4/abis/universalRouter'\nimport { AmountExceedsUint128Error } from '../../v4/router/errors'\n\n/** Universal Router command byte for a v3 exact-in swap. */\nexport const V3_SWAP_EXACT_IN = 0x00\n\n/**\n * Universal Router recipient sentinel: the router maps `address(1)` to\n * `msg.sender` (the `execute` caller). Uniswap `Constants.MSG_SENDER`.\n */\nexport const MSG_SENDER: Address = '0x0000000000000000000000000000000000000001'\n\nconst UINT128_MAX = (1n << 128n) - 1n\n\nconst v3ExactInInputAbi = [\n  { name: 'recipient', type: 'address' },\n  { name: 'amountIn', type: 'uint256' },\n  { name: 'amountOutMinimum', type: 'uint256' },\n  { name: 'path', type: 'bytes' },\n  { name: 'payerIsUser', type: 'bool' },\n] as const\n\nfunction assertUint128(amount: bigint): void {\n  if (amount < 0n || amount > UINT128_MAX) {\n    throw new AmountExceedsUint128Error(amount)\n  }\n}\n\n/** Arguments for {@link buildV3SwapExecuteCalldata}. */\nexport interface BuildV3SwapCalldataArgs {\n  /** Input token (funds pulled from the caller via Permit2). */\n  tokenIn: Address\n  /** Output token. */\n  tokenOut: Address\n  /** v3 pool fee tier (e.g. 500, 3000). */\n  fee: bigint\n  /** Exact input amount (uint128). */\n  amountIn: bigint\n  /** Minimum acceptable output (uint128). */\n  amountOutMinimum: bigint\n  /**\n   * Absolute deadline (unix seconds) — the `execute(commands, inputs, deadline)`\n   * argument, enforced by the Universal Router.\n   */\n  deadline: bigint\n}\n\n/**\n * Encode the packed v3 single-hop path `tokenIn ++ fee(uint24) ++ tokenOut`.\n */\nexport function encodeV3Path(tokenIn: Address, fee: bigint, tokenOut: Address): Hex {\n  if (fee < 0n || fee > 0xffffffn) {\n    throw new PanopticError(`v3 fee ${fee} exceeds uint24`)\n  }\n  return encodePacked(['address', 'uint24', 'address'], [tokenIn, Number(fee), tokenOut])\n}\n\n/**\n * Build the typed `execute(...)` args for an exact-in single-hop v3 swap whose\n * output is delivered to the `execute` caller (recipient = MSG_SENDER).\n */\nexport function buildV3SwapExecuteArgs(args: BuildV3SwapCalldataArgs): {\n  args: readonly [Hex, readonly Hex[], bigint]\n  value: bigint\n} {\n  const { tokenIn, tokenOut, fee, amountIn, amountOutMinimum, deadline } = args\n\n  if (tokenIn === zeroAddress || tokenOut === zeroAddress) {\n    throw new PanopticError('native ETH is not supported by the v3 exact-in router builder')\n  }\n  assertUint128(amountIn)\n  assertUint128(amountOutMinimum)\n\n  const path = encodeV3Path(tokenIn, fee, tokenOut)\n  const input = encodeAbiParameters(v3ExactInInputAbi, [\n    MSG_SENDER,\n    amountIn,\n    amountOutMinimum,\n    path,\n    true, // payerIsUser: pull tokenIn from the caller via Permit2\n  ])\n\n  const commands = encodePacked(['uint8'], [V3_SWAP_EXACT_IN])\n  return { args: [commands, [input], deadline] as const, value: 0n }\n}\n\n/**\n * Build the `execute(commands, inputs, deadline)` calldata for an exact-in\n * single-hop v3 swap.\n */\nexport function buildV3SwapExecuteCalldata(args: BuildV3SwapCalldataArgs): {\n  data: Hex\n  value: bigint\n} {\n  const { args: executeArgs, value } = buildV3SwapExecuteArgs(args)\n  const data = encodeFunctionData({\n    abi: universalRouterAbi,\n    functionName: 'execute',\n    args: executeArgs,\n  })\n  return { data, value }\n}\n","/**\n * Minimal Uniswap v3 QuoterV2 ABI (`quoteExactInputSingle`).\n *\n * QuoterV2 is revert/staticcall-based (nonpayable but intended for `eth_call` /\n * `simulateContract`), so it must be simulated, not read.\n * @module uniswap/v3/abis/quoterV2\n */\n\nexport const quoterV2Abi = [\n  {\n    type: 'function',\n    name: 'quoteExactInputSingle',\n    stateMutability: 'nonpayable',\n    inputs: [\n      {\n        name: 'params',\n        type: 'tuple',\n        components: [\n          { name: 'tokenIn', type: 'address' },\n          { name: 'tokenOut', type: 'address' },\n          { name: 'amountIn', type: 'uint256' },\n          { name: 'fee', type: 'uint24' },\n          { name: 'sqrtPriceLimitX96', type: 'uint160' },\n        ],\n      },\n    ],\n    outputs: [\n      { name: 'amountOut', type: 'uint256' },\n      { name: 'sqrtPriceX96After', type: 'uint160' },\n      { name: 'initializedTicksCrossed', type: 'uint32' },\n      { name: 'gasEstimate', type: 'uint256' },\n    ],\n  },\n] as const\n","/**\n * Quote an exact-in single-hop swap against a Uniswap v3 pool via QuoterV2.\n * @module uniswap/v3/router/quote\n */\n\nimport type { Address, PublicClient } from 'viem'\nimport { BaseError, ContractFunctionRevertedError } from 'viem'\n\nimport { PanopticError } from '../../../panoptic/v2/errors'\nimport { quoterV2Abi } from '../abis/quoterV2'\nimport { type UniswapV3Addresses, getUniswapV3Addresses } from '../addresses'\n\nconst BPS_DENOMINATOR = 10_000n\nconst UINT128_MAX = (1n << 128n) - 1n\n\nexport interface QuoteV3ExactInParams {\n  client: PublicClient\n  chainId: bigint\n  tokenIn: Address\n  tokenOut: Address\n  fee: bigint\n  amountIn: bigint\n  /** Slippage tolerance in bps, used to compute `amountOutMinimum`. */\n  slippageBps: bigint\n  blockNumber?: bigint\n  addresses?: Partial<UniswapV3Addresses>\n}\n\nexport interface V3ExactInQuote {\n  amountOut: bigint\n  amountOutMinimum: bigint\n  gasEstimate: bigint\n}\n\n/**\n * Quote an exact-in v3 swap. Returns `null` when the quote reverts (e.g. the\n * pool does not exist / has no liquidity) so callers can skip that pool when\n * ranking venues, rather than aborting the whole cycle.\n */\nexport async function quoteV3ExactIn(params: QuoteV3ExactInParams): Promise<V3ExactInQuote | null> {\n  const { client, chainId, tokenIn, tokenOut, fee, amountIn, slippageBps, blockNumber } = params\n  if (amountIn < 0n || amountIn > UINT128_MAX) {\n    throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`)\n  }\n  if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR) {\n    throw new PanopticError(`invalid slippageBps ${slippageBps}, must be 0..10000`)\n  }\n\n  const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses)\n\n  try {\n    const { result } = await client.simulateContract({\n      address: quoterV2,\n      abi: quoterV2Abi,\n      functionName: 'quoteExactInputSingle',\n      blockNumber,\n      args: [{ tokenIn, tokenOut, amountIn, fee: Number(fee), sqrtPriceLimitX96: 0n }],\n    })\n    const [amountOut, , , gasEstimate] = result\n    const amountOutMinimum = (amountOut * (BPS_DENOMINATOR - slippageBps)) / BPS_DENOMINATOR\n    return { amountOut, amountOutMinimum, gasEstimate }\n  } catch (err) {\n    if (isRevert(err)) return null\n    // Transport/RPC/timeout errors are NOT \"no liquidity\" — rethrow so routing\n    // doesn't silently treat an unreachable node as an empty pool.\n    throw err\n  }\n}\n\n/** True only for genuine contract reverts (missing pool / no liquidity). */\nfunction isRevert(err: unknown): boolean {\n  return (\n    err instanceof BaseError &&\n    err.walk((e) => e instanceof ContractFunctionRevertedError) instanceof\n      ContractFunctionRevertedError\n  )\n}\n"],"mappings":"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"}

package/dist/{writes-DymnVbiE.js → writes-BnO9zj-Z.js}

@@ -1,5 +1,5 @@
-import { BatchValidationError, DEFAULT_VEGOID, InputListFailError, InvalidTickLimitsError, InvalidTokenIdParameterError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LoanSlotExhaustedError, MaxRetriesExceededError, MissingPositionIdsError, NoLoanPositionsError, OracleRateLimitedError, PanopticError$1 as PanopticError, ProviderLagError, REORG_DEPTH, SCHEMA_VERSION, STORAGE_PREFIX, STRIKE_CONVERSION_FACTOR, SafeModeError, StaleDataError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, UnhealthyPoolError, calculatePositionGreeks, collateralTrackerV2Abi, createTxResult, decodeLeftRightUnsigned, getBlockMeta, getPool$1 as getPool, getPoolMetadata$1 as getPoolMetadata, getPositions, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticPoolV2Abi, parsePanopticError, submitWrite, tickLimits$1 as tickLimits } from "./position-BK4a-Yyu.js";
-import { decodeFunctionData, decodeFunctionResult, encodeFunctionData, erc20Abi, toFunctionSelector } from "viem";
+import { BatchValidationError, DEFAULT_VEGOID, InputListFailError, InvalidTickLimitsError, InvalidTokenIdParameterError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LoanSlotExhaustedError, MaxRetriesExceededError, MissingPositionIdsError, NoLoanPositionsError, OracleRateLimitedError, PanopticError, ProviderLagError, REORG_DEPTH, SCHEMA_VERSION, STORAGE_PREFIX, STRIKE_CONVERSION_FACTOR, SafeModeError, StaleDataError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, UnhealthyPoolError, calculatePositionGreeks, collateralTrackerV2Abi, createTxResult, decodeLeftRightUnsigned, getBlockMeta, getPool, getPoolMetadata, getPositions, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticPoolV2Abi, parsePanopticError, submitWrite, tickLimits } from "./position-CsIEneku.js";
+import { decodeFunctionData, decodeFunctionResult, encodeFunctionData, erc20Abi, getAddress, parseAbi, toFunctionSelector } from "viem";
 
 //#region src/panoptic/v2/writes/broadcaster.ts
 /**
@@ -610,6 +610,7 @@ const jsonSerializer = {
 //#endregion
 //#region src/panoptic/v2/sync/snapshotRecovery.ts
 const LOG_SCAN_WINDOW = 10000n;
+const rolesExecutionAbi = parseAbi(["function execTransactionWithRole(address to, uint256 value, bytes data, uint8 operation, bytes32 roleKey, bool shouldRevert)"]);
 /**
 * Recover position snapshot from the last dispatch transaction.
 * This is the primary recovery method - it finds the most recent dispatch()
@@ -841,6 +842,30 @@ async function recoverSnapshotFromEvents(params) {
 function isSnapshotCandidateEvent(event) {
 	return event.transactionHash !== null && event.blockNumber !== null && event.logIndex !== null;
 }
+function decodeSnapshotTransaction(params) {
+	const { account, pool, rolesContext } = params;
+	let dispatchInput = params.input;
+	let dispatchSender = params.from;
+	if (rolesContext) {
+		if (params.to === null || getAddress(params.to) !== getAddress(rolesContext.modifier) || getAddress(params.from) !== getAddress(rolesContext.member)) return null;
+		try {
+			const decodedRoleCall = decodeFunctionData({
+				abi: rolesExecutionAbi,
+				data: params.input
+			});
+			const [target, value, data, operation, roleKey, shouldRevert] = decodedRoleCall.args;
+			if (!pool || getAddress(target) !== getAddress(pool) || value !== 0n || operation !== 0 || roleKey.toLowerCase() !== rolesContext.roleKey.toLowerCase() || !shouldRevert) return null;
+			dispatchInput = data;
+			if (!account) return null;
+			dispatchSender = account;
+		} catch {
+			return null;
+		}
+	} else if (pool && (params.to === null || getAddress(params.to) !== getAddress(pool))) return null;
+	const candidates = decodeAllDispatchCalldata(dispatchInput);
+	if (candidates.length === 0) return null;
+	return account ? selectDispatchForAccount(candidates, account, dispatchSender) : candidates[candidates.length - 1];
+}
 /**
 * Recover position snapshot from a specific dispatch transaction hash.
 *
@@ -864,13 +889,17 @@ function isSnapshotCandidateEvent(event) {
 * ```
 */
 async function recoverSnapshotFromTx(params) {
-	const { client, transactionHash, account, pool } = params;
+	const { client, transactionHash, account, pool, rolesContext } = params;
 	const tx = await client.getTransaction({ hash: transactionHash });
 	if (tx.blockNumber == null) return null;
-	if (pool && tx.to?.toLowerCase() !== pool.toLowerCase()) return null;
-	const candidates = decodeAllDispatchCalldata(tx.input);
-	if (candidates.length === 0) return null;
-	const decoded = account ? selectDispatchForAccount(candidates, account, tx.from) : candidates[candidates.length - 1];
+	const decoded = decodeSnapshotTransaction({
+		input: tx.input,
+		from: tx.from,
+		to: tx.to,
+		account,
+		pool,
+		rolesContext
+	});
 	if (!decoded) return null;
 	const blockNumber = tx.blockNumber;
 	const block = await client.getBlock({ blockNumber });
@@ -1065,14 +1094,15 @@ async function clearTrackedPositions(params) {
 * @returns Array of currently open position token IDs, or null if no snapshot was found
 */
 async function getOpenPositionIds(params) {
-	const { client, chainId, poolAddress, account, storage, lastDispatchTxHash, fromBlock } = params;
+	const { client, chainId, poolAddress, account, storage, lastDispatchTxHash, fromBlock, toBlock, rolesContext } = params;
 	let snapshot = null;
 	if (lastDispatchTxHash) try {
 		snapshot = await recoverSnapshotFromTx({
 			client,
 			transactionHash: lastDispatchTxHash,
 			account,
-			pool: poolAddress
+			pool: poolAddress,
+			rolesContext
 		});
 	} catch {
 		snapshot = null;
@@ -1081,7 +1111,8 @@ async function getOpenPositionIds(params) {
 		client,
 		poolAddress,
 		account,
-		fromBlock
+		fromBlock,
+		toBlock
 	});
 	if (!snapshot) return null;
 	if (storage) {
@@ -4483,4 +4514,4 @@ async function smartRepayAndWait(params) {
 
 //#endregion
 export { addLegToTokenId, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildOpenPositionCalldata, buildUniqueLoan, calculateResyncBlock, cancelTransaction, checkApproval, clearCheckpoint, clearTrackedPositions, closePosition, closePositionAndWait, countLegs, createFileStorage, createMemoryStorage, createNonceManager, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeg, decodePoolId, decodeTickSpacing as decodeTickSpacing$1, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, detectReorg, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodeV4PoolId, executeBatchDispatch, executeBatchDispatchAndWait, forceExercise, forceExerciseAndWait, getAssetIndex, getClosedPositionsKey, getOpenPositionIds, getPendingPositionsKey, getPoolMetaKey, getPoolPrefix, getPositionMetaKey, getPositionsKey, getSchemaVersionKey, getSyncCheckpointKey, getTrackedChunksKey, getTrackedPositionIds, hasLoanOrCredit, hasLongLeg, isCredit, isCreditLeg, isGasError, isInputListFailError, isLoan, isLoanLeg, isNonceError, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, jsonSerializer, liquidate, liquidateAndWait, loadCheckpoint, mint, mintAndWait, openPosition, openPositionAndWait, pokeOracle, pokeOracleAndWait, previewBorrow, previewUnwrap, previewWrap, publicBroadcaster, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, repay, repayAndWait, resolveTokenIndex, rollPosition, rollPositionAndWait, saveCheckpoint, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, simulateOpenPosition, simulateWithTokenFlow, smartRepay, smartRepayAndWait, speedUpTransaction, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, validateBatch, validatePoolId, verifyBlockContinuity, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
-//# sourceMappingURL=writes-DymnVbiE.js.map
+//# sourceMappingURL=writes-BnO9zj-Z.js.map