@1inch/swap-vm-sdk 0.1.2-rc.6 → 0.1.2

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { decodeAbiParameters, decodeEventLog, encodeAbiParameters, encodeFunctionData, hashTypedData, keccak256 } from "viem";
+import { decodeAbiParameters, decodeEventLog, encodeAbiParameters, encodeFunctionData, formatUnits, hashTypedData, keccak256, parseUnits } from "viem";
 import { Address, Address as Address$1, AddressHalf, HexString, HexString as HexString$1, Interaction, NetworkEnum, NetworkEnum as NetworkEnum$1 } from "@1inch/sdk-core";
 import { BN, BitMask, BytesBuilder, BytesIter, UINT_16_MAX, UINT_24_MAX, UINT_256_MAX, UINT_32_MAX, UINT_40_MAX, UINT_64_MAX, UINT_8_MAX, UINT_96_MAX, add0x, trim0x } from "@1inch/byte-utils";
 import assert from "assert";
@@ -1847,7 +1847,7 @@ var ConcentrateGrowLiquidity2DArgsCoder = class {
 };
 
 //#endregion
-//#region src/swap-vm/instructions/concentrate/bigint-sqrt.ts
+//#region src/swap-vm/instructions/utils/bigint-sqrt.ts
 function bigintSqrt(value) {
 	if (value < 0n) throw new Error("square root of negative numbers is not supported");
 	if (value < 2n) return value;
@@ -1863,7 +1863,7 @@ function bigintSqrt(value) {
 
 //#endregion
 //#region src/swap-vm/instructions/concentrate/concentrate-grow-liquidity-2d-args.ts
-const ONE_E18 = 10n ** 18n;
+const ONE_E18$1 = 10n ** 18n;
 /**
 * Arguments for concentrateGrowLiquidity2D instruction
 * Contract encodes sqrtPriceMin and sqrtPriceMax (2 × uint256, 64 bytes)
@@ -1891,8 +1891,8 @@ var ConcentrateGrowLiquidity2DArgs = class ConcentrateGrowLiquidity2DArgs {
 	* Computes sqrtPrice = sqrt(P * 1e18) so that (sqrtPrice/1e18)^2 = P/1e18.
 	**/
 	static fromRawPrices(rawPriceMin, rawPriceMax) {
-		const sqrtPriceMin = bigintSqrt(rawPriceMin * ONE_E18);
-		const sqrtPriceMax = bigintSqrt(rawPriceMax * ONE_E18);
+		const sqrtPriceMin = bigintSqrt(rawPriceMin * ONE_E18$1);
+		const sqrtPriceMax = bigintSqrt(rawPriceMax * ONE_E18$1);
 		return new ConcentrateGrowLiquidity2DArgs(sqrtPriceMin, sqrtPriceMax);
 	}
 	/**
@@ -1936,8 +1936,8 @@ const ONE = 10n ** 18n;
 */
 function computeLiquidityFromAmounts(availableLt, availableGt, sqrtPspot, sqrtPmin, sqrtPmax) {
 	if (sqrtPmin >= sqrtPmax) throw new Error("sqrtPmax should be greater than sqrtPmin");
-	const lFromLt = sqrtPmax > sqrtPspot ? mulDiv(availableLt, mulDiv(sqrtPmax, sqrtPspot, ONE), sqrtPmax - sqrtPspot) : UINT_256_MAX;
-	const lFromGt = sqrtPspot > sqrtPmin ? mulDiv(availableGt, ONE, sqrtPspot - sqrtPmin) : UINT_256_MAX;
+	const lFromLt = sqrtPmax > sqrtPspot ? mulDiv$1(availableLt, mulDiv$1(sqrtPmax, sqrtPspot, ONE), sqrtPmax - sqrtPspot) : UINT_256_MAX;
+	const lFromGt = sqrtPspot > sqrtPmin ? mulDiv$1(availableGt, ONE, sqrtPspot - sqrtPmin) : UINT_256_MAX;
 	const targetL = lFromLt < lFromGt ? lFromLt : lFromGt;
 	const { bLt: actualLt, bGt: actualGt } = computeBalances(targetL, sqrtPspot, sqrtPmin, sqrtPmax);
 	return {
@@ -1961,8 +1961,8 @@ function computeLiquidityFromAmounts(availableLt, availableGt, sqrtPspot, sqrtPm
 */
 function computeBalances(targetL, sqrtPspot, sqrtPmin, sqrtPmax) {
 	if (sqrtPmin >= sqrtPmax) throw new Error("sqrtPmax should be greater than sqrtPmin");
-	const bLt = sqrtPmax > sqrtPspot ? mulDiv(targetL, sqrtPmax - sqrtPspot, mulDiv(sqrtPmax, sqrtPspot, ONE)) : 0n;
-	const bGt = sqrtPspot > sqrtPmin ? mulDiv(targetL, sqrtPspot - sqrtPmin, ONE) : 0n;
+	const bLt = sqrtPmax > sqrtPspot ? mulDiv$1(targetL, sqrtPmax - sqrtPspot, mulDiv$1(sqrtPmax, sqrtPspot, ONE)) : 0n;
+	const bGt = sqrtPspot > sqrtPmin ? mulDiv$1(targetL, sqrtPspot - sqrtPmin, ONE) : 0n;
 	return {
 		bLt,
 		bGt
@@ -1981,9 +1981,9 @@ function computeBalances(targetL, sqrtPspot, sqrtPmin, sqrtPmax) {
 */
 function computeLiquidityAndPrice(balanceLt, balanceGt, sqrtPriceMin, sqrtPriceMax) {
 	const liquidity = computeL(balanceLt, balanceGt, sqrtPriceMin, sqrtPriceMax);
-	const virtualLt = balanceLt + mulDiv(liquidity, ONE, sqrtPriceMax);
-	const virtualGt = balanceGt + mulDiv(liquidity, sqrtPriceMin, ONE);
-	const sqrtPriceSpot = bigintSqrt(mulDiv(virtualGt, ONE * ONE, virtualLt));
+	const virtualLt = balanceLt + mulDiv$1(liquidity, ONE, sqrtPriceMax);
+	const virtualGt = balanceGt + mulDiv$1(liquidity, sqrtPriceMin, ONE);
+	const sqrtPriceSpot = bigintSqrt(mulDiv$1(virtualGt, ONE * ONE, virtualLt));
 	return {
 		liquidity,
 		sqrtPriceSpot
@@ -1994,161 +1994,299 @@ function computeLiquidityAndPrice(balanceLt, balanceGt, sqrtPriceMin, sqrtPriceM
 * Mirrors XYCConcentrateArgsBuilder._computeL in XYCConcentrate.sol.
 */
 function computeL(bLt, bGt, sqrtPriceMin, sqrtPriceMax) {
-	const alpha = ONE - mulDiv(sqrtPriceMin, ONE, sqrtPriceMax);
-	const beta = mulDiv(bLt, sqrtPriceMin, ONE) + mulDiv(bGt, ONE, sqrtPriceMax);
-	const fourAC = mulDiv(4n * alpha, bLt, ONE) * bGt;
+	const alpha = ONE - mulDiv$1(sqrtPriceMin, ONE, sqrtPriceMax);
+	const beta = mulDiv$1(bLt, sqrtPriceMin, ONE) + mulDiv$1(bGt, ONE, sqrtPriceMax);
+	const fourAC = mulDiv$1(4n * alpha, bLt, ONE) * bGt;
 	const disc = beta * beta + fourAC;
-	return mulDiv(beta + bigintSqrt(disc), ONE, 2n * alpha);
+	return mulDiv$1(beta + bigintSqrt(disc), ONE, 2n * alpha);
 }
-function mulDiv(a, b, c) {
+function mulDiv$1(a, b, c) {
 	if (c === 0n) throw new Error("mulDiv: division by zero");
 	return a * b / c;
 }
 
 //#endregion
-//#region src/swap-vm/instructions/concentrate/concentrate-liquidity-calculator/concentrate-liquidity-calculator.ts
+//#region src/swap-vm/instructions/utils/truncate-human-decimal-string.ts
 /**
-* Calculator for concentrated liquidity: given two tokens and a price range (min, spot, max),
-* computes sqrt prices and token reserves for "max allocation" (use all available balances)
-* or "fixed allocation" (fix one token amount and solve for the other).
+* Round a decimal string to `maxFrac` fractional digits (half-up: if the first dropped digit
+* is `5`–`9`, round the last kept digit up), then strip trailing zeros after the dot.
 *
-* Token ordering follows the pool convention: token0 = lower address, token1 = higher address.
-* Prices are supplied as ScaledPrices with scale 10^(token0Decimals + token1Decimals); they are
-* converted internally to P = token1/token0 in 1e18 and then to sqrt(P * 1e18) for the math.
+* @param s Decimal string as produced by e.g. `formatUnits` (no scientific notation).
+* @param maxFrac Maximum number of digits after `.`; `0` means integer only (round using the
+* first fractional digit).
 */
-var ConcentrateLiquidityCalculator = class ConcentrateLiquidityCalculator {
-	static ONE_E18 = 10n ** 18n;
-	constructor(tokenA, tokenB) {
-		this.tokenA = tokenA;
-		this.tokenB = tokenB;
+function truncateHumanDecimalString(s, maxFrac) {
+	if (maxFrac < 0) throw new Error("maxFrac must be non-negative");
+	const dot = s.indexOf(".");
+	if (dot === -1) return s;
+	const intPartStr = s.slice(0, dot) || "0";
+	const fracFull = s.slice(dot + 1);
+	if (maxFrac === 0) {
+		let intPart = BigInt(intPartStr);
+		const first = fracFull[0];
+		if (first !== void 0 && first >= "5" && first <= "9") intPart += 1n;
+		return intPart.toString();
+	}
+	const fracPadded = (fracFull + "0".repeat(maxFrac)).slice(0, maxFrac);
+	const nextDigit = fracFull.length > maxFrac ? fracFull[maxFrac] : void 0;
+	const roundUp = nextDigit !== void 0 && nextDigit >= "5" && nextDigit <= "9";
+	const scale = 10n ** BigInt(maxFrac);
+	let scaled = BigInt(intPartStr) * scale + BigInt(fracPadded || "0");
+	if (roundUp) scaled += 1n;
+	const intOut = scaled / scale;
+	let fracOut = (scaled % scale).toString().padStart(maxFrac, "0");
+	fracOut = fracOut.replace(/0+$/, "");
+	return fracOut.length > 0 ? `${intOut}.${fracOut}` : intOut.toString();
+}
+
+//#endregion
+//#region src/swap-vm/instructions/concentrate/price/price.ts
+const ONE_E18$2 = 10n ** 18n;
+var Price = class Price {
+	constructor(sqrtP, token0, token1) {
+		this.sqrtP = sqrtP;
+		this.token0 = token0;
+		this.token1 = token1;
+		assert(sqrtP > 0n, "sqrt price must be positive");
+		assert(!token0.address.equal(token1.address), "price tokens should be different");
+	}
+	/**
+	* Fixed-point sqrt price as used on-chain (`sqrt(P * 1e18)`).
+	*/
+	static fromSqrt(price, pair) {
+		const zeroForOne = pair.tokenA.address.lt(pair.tokenB.address);
+		const token0 = zeroForOne ? pair.tokenA : pair.tokenB;
+		const token1 = zeroForOne ? pair.tokenB : pair.tokenA;
+		return new Price(price, token0, token1);
 	}
 	/**
-	* Token with the smaller address (token0 in pool convention; "Lt" in the math).
+	* Human decimal string for **quote per 1 base**`.
 	*/
-	get token0() {
-		return this.tokenA.address.lt(this.tokenB.address) ? this.tokenA : this.tokenB;
+	static fromHuman(price, pair) {
+		assert(!pair.quoteToken.address.equal(pair.baseToken.address), "quote and base must be different tokens");
+		const zeroForOne = pair.quoteToken.address.lt(pair.baseToken.address);
+		const t0 = zeroForOne ? pair.quoteToken : pair.baseToken;
+		const t1 = zeroForOne ? pair.baseToken : pair.quoteToken;
+		const d0 = t0.decimals;
+		const d1 = t1.decimals;
+		const scale = d0 + d1;
+		if (scale > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("decimals sum too large for parseUnits");
+		const scaledRaw = parseUnits(price.trim(), Number(scale));
+		if (pair.quoteToken.address.equal(t0.address)) {
+			const numerator = 10n ** (d1 + d1) * ONE_E18$2;
+			return new Price(bigintSqrt(numerator * ONE_E18$2 / scaledRaw), t0, t1);
+		}
+		if (pair.quoteToken.address.equal(t1.address)) {
+			const denominator = 10n ** (d0 + d0);
+			return new Price(bigintSqrt(scaledRaw * ONE_E18$2 * ONE_E18$2 / denominator), t0, t1);
+		}
+		throw new Error("quote token must be one of the two pair tokens");
+	}
+	static fromJSON(input) {
+		const token0 = {
+			address: new Address$1(input.token0.address),
+			decimals: BigInt(input.token0.decimals)
+		};
+		const token1 = {
+			address: new Address$1(input.token1.address),
+			decimals: BigInt(input.token1.decimals)
+		};
+		assert(token0.address.lt(token1.address), "token0 address must be less than token1 (canonical order)");
+		return new Price(BigInt(input.sqrtP), token0, token1);
+	}
+	equals(other) {
+		return this.sqrtP === other.sqrtP && this.token0.address.equal(other.token0.address) && this.token1.address.equal(other.token1.address) && this.token0.decimals === other.token0.decimals && this.token1.decimals === other.token1.decimals;
+	}
+	lt(other) {
+		assert(this.isSamePair(other), "cannot compare prices for different pairs");
+		return this.sqrtP < other.sqrtP;
+	}
+	lte(other) {
+		assert(this.isSamePair(other), "cannot compare prices for different pairs");
+		return this.sqrtP <= other.sqrtP;
+	}
+	gt(other) {
+		assert(this.isSamePair(other), "cannot compare prices for different pairs");
+		return this.sqrtP > other.sqrtP;
+	}
+	gte(other) {
+		assert(this.isSamePair(other), "cannot compare prices for different pairs");
+		return this.sqrtP >= other.sqrtP;
+	}
+	isSamePair(other) {
+		return this.token0.address.equal(other.token0.address) && this.token1.address.equal(other.token1.address) && this.token0.decimals === other.token0.decimals && this.token1.decimals === other.token1.decimals;
 	}
 	/**
-	* Token with the larger address (token1 in pool convention; "Gt" in the math).
+	* Raw price `P` with 1e18 fixed-point (`(sqrtP^2) / 1e18`), matching typical on-chain use.
 	*/
-	get token1() {
-		return this.tokenA.address.lt(this.tokenB.address) ? this.tokenB : this.tokenA;
+	toRaw() {
+		return this.sqrtP * this.sqrtP / ONE_E18$2;
 	}
-	static new(data) {
-		return new ConcentrateLiquidityCalculator(data.tokenA, data.tokenB);
+	toSqrt() {
+		return this.sqrtP;
 	}
 	/**
-	* Compute reserves when one token amount is fixed: the position uses exactly
-	* `fixedReserve` of `fixedReserveForToken` and the other token amount is derived
-	* to keep the same liquidity L. Returns sqrt prices and token0/token1
-	* reserves (raw amounts).
-	* Due to integer math (floor division, sqrt), the fixed asset amount in the result
-	* may be less than requested by a few wei.
+	* Decimal string for **quote per 1 base** at scale `10^(token0Decimals + token1Decimals)`.
+	* Fractional digits after the dot are **rounded half-up** to {@link PriceToken.decimals} of
+	* the quote token (then trailing zeros are removed).
+	*
+	* @param quoteToken Which token is the quote currency; base is the other token.
 	*/
-	computeFixedAllocation(scaledPrices, fixedReserveForToken, fixedReserve) {
-		const { minPriceRaw, spotPriceRaw, maxPriceRaw } = this.computeRawPrices(scaledPrices);
-		const sqrtPriceMin = bigintSqrt(minPriceRaw * ConcentrateLiquidityCalculator.ONE_E18);
-		const sqrtPriceSpot = bigintSqrt(spotPriceRaw * ConcentrateLiquidityCalculator.ONE_E18);
-		const sqrtPriceMax = bigintSqrt(maxPriceRaw * ConcentrateLiquidityCalculator.ONE_E18);
-		const isFixedLt = fixedReserveForToken.equal(this.token0.address);
-		const availableLt = isFixedLt ? fixedReserve : UINT_256_MAX;
-		const availableGt = isFixedLt ? UINT_256_MAX : fixedReserve;
-		const { actualLt, actualGt } = computeLiquidityFromAmounts(availableLt, availableGt, sqrtPriceSpot, sqrtPriceMin, sqrtPriceMax);
+	toHuman(quoteToken) {
+		assert(quoteToken.equal(this.token0.address) || quoteToken.equal(this.token1.address), "quote token should be one of pair price tokens");
+		const d0 = this.token0.decimals;
+		const d1 = this.token1.decimals;
+		const scale = d0 + d1;
+		const scaled = this.scaledRawAmountForQuote(quoteToken);
+		const quoteDecimals = quoteToken.equal(this.token0.address) ? d0 : d1;
+		const full = formatUnits(scaled, Number(scale));
+		return truncateHumanDecimalString(full, Number(quoteDecimals));
+	}
+	toJSON() {
 		return {
-			sqrtPriceMin,
-			sqrtPriceSpot,
-			sqrtPriceMax,
-			token0Reserve: actualLt,
-			token1Reserve: actualGt
+			sqrtP: this.sqrtP.toString(),
+			token0: {
+				address: this.token0.address.toString(),
+				decimals: this.token0.decimals.toString()
+			},
+			token1: {
+				address: this.token1.address.toString(),
+				decimals: this.token1.decimals.toString()
+			}
 		};
 	}
 	/**
-	* Compute reserves when both token amounts are taken from token info: uses
-	* token0.maxAvailableLiquidity and token1.maxAvailableLiquidity to maximize
-	* L. Returns sqrt prices and the token0/token1 reserves that achieve
-	* that maximum.
+	* Quote per 1 base scaled by `10^(token0Decimals + token1Decimals)`.
+	* Uses `sqrtP^2` in one step so we do not compound truncation from {@link toRaw}.
 	*/
-	computeMaxAllocation(scaledPrices) {
-		const { minPriceRaw, spotPriceRaw, maxPriceRaw } = this.computeRawPrices(scaledPrices);
-		const sqrtPriceMin = bigintSqrt(minPriceRaw * ConcentrateLiquidityCalculator.ONE_E18);
-		const sqrtPriceSpot = bigintSqrt(spotPriceRaw * ConcentrateLiquidityCalculator.ONE_E18);
-		const sqrtPriceMax = bigintSqrt(maxPriceRaw * ConcentrateLiquidityCalculator.ONE_E18);
-		const { actualLt, actualGt } = computeLiquidityFromAmounts(this.token0.maxAvailableLiquidity, this.token1.maxAvailableLiquidity, sqrtPriceSpot, sqrtPriceMin, sqrtPriceMax);
+	scaledRawAmountForQuote(quoteToken) {
+		const d0 = this.token0.decimals;
+		const d1 = this.token1.decimals;
+		const sqrtP2 = this.sqrtP * this.sqrtP;
+		if (quoteToken.equal(this.token0.address)) {
+			const numerator = 10n ** (d1 + d1) * ONE_E18$2;
+			return numerator * ONE_E18$2 / sqrtP2;
+		}
+		if (quoteToken.equal(this.token1.address)) {
+			const numerator = 10n ** (d0 + d0);
+			return sqrtP2 * numerator / (ONE_E18$2 * ONE_E18$2);
+		}
+		throw new Error("quote token must be one of the pair tokens");
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/concentrate/token-reserve/token-reserve.ts
+var TokenReserve = class TokenReserve {
+	constructor(token, reserve) {
+		this.token = token;
+		this.reserve = reserve;
+	}
+	static new(args) {
+		return new TokenReserve(args.token, args.reserve);
+	}
+	static fromJSON(input) {
+		return new TokenReserve(new Address$1(input.token), BigInt(input.reserve));
+	}
+	toJSON() {
 		return {
-			sqrtPriceMin,
-			sqrtPriceSpot,
-			sqrtPriceMax,
-			token0Reserve: actualLt,
-			token1Reserve: actualGt
+			token: this.token.toString(),
+			reserve: this.reserve.toString()
 		};
 	}
-	/**
-	* Implied spot sqrt price from token0/token1 balances and a scaled price range
-	* (same convention as {@link computeMaxAllocation}). Inverse of the allocation math; wraps
-	* {@link computeLiquidityAndPrice} from concentrate-liquidity-math.
-	*
-	* @returns sqrt(P_spot) in 1e18 fixed-point (same as {@link ConcentratedLiquidityInfo.sqrtPriceSpot}).
-	*/
-	computeSpotPrice(token0Balance, token1Balance, scaledPriceBounds) {
-		const { sqrtPriceMin, sqrtPriceMax } = this.computeSqrtPriceBounds(scaledPriceBounds);
-		const { sqrtPriceSpot } = computeLiquidityAndPrice(token0Balance, token1Balance, sqrtPriceMin, sqrtPriceMax);
-		return sqrtPriceSpot;
+};
+
+//#endregion
+//#region src/swap-vm/instructions/concentrate/price-range/price-range.ts
+var PriceRange = class PriceRange {
+	constructor(minPrice, spotPrice, maxPrice) {
+		this.minPrice = minPrice;
+		this.spotPrice = spotPrice;
+		this.maxPrice = maxPrice;
+		assert(maxPrice.gte(spotPrice), "maxPrice should be >= spotPrice");
+		assert(spotPrice.gte(minPrice), "spotPrice should be >= minPrice");
+		assert(minPrice.lt(maxPrice), "minPrice should be < maxPrice");
+		assert(minPrice.isSamePair(spotPrice), "cannot create price range for different pairs");
+		assert(maxPrice.isSamePair(spotPrice), "cannot create price range for different pairs");
 	}
-	/**
-	* Convert user-facing ScaledPrices (scale 10^(token0Decimals+token1Decimals)) into internal
-	* raw prices P = token1/token0 (before sqrt), so that sqrt(P * 1e18) can be
-	* passed to the liquidity math. Handles both quote = token0 and quote = token1.
-	*/
-	computeRawPrices(scaledPrices) {
-		const { minPriceRaw, maxPriceRaw } = this.computeRawPriceBounds(scaledPrices);
-		const token0 = this.token0;
-		const token1 = this.token1;
-		if (scaledPrices.quoteToken.equal(token0.address)) {
-			const numerator = 10n ** (token1.decimals + token1.decimals) * ConcentrateLiquidityCalculator.ONE_E18;
-			return {
-				minPriceRaw,
-				spotPriceRaw: numerator / scaledPrices.spotPriceRaw,
-				maxPriceRaw
-			};
-		}
-		if (scaledPrices.quoteToken.equal(token1.address)) {
-			const denominator = 10n ** (token0.decimals + token0.decimals);
-			return {
-				minPriceRaw,
-				spotPriceRaw: scaledPrices.spotPriceRaw * ConcentrateLiquidityCalculator.ONE_E18 / denominator,
-				maxPriceRaw
-			};
-		}
-		throw new Error("unknown quote token");
+	get token0() {
+		return this.minPrice.token0;
+	}
+	get token1() {
+		return this.minPrice.token1;
+	}
+	static new(range) {
+		const minPrice = range.minPrice.lte(range.spotPrice) ? range.minPrice : range.maxPrice;
+		const maxPrice = range.maxPrice.gte(range.spotPrice) ? range.maxPrice : range.minPrice;
+		return new PriceRange(minPrice, range.spotPrice, maxPrice);
+	}
+	static fromJSON(input) {
+		return PriceRange.new({
+			minPrice: Price.fromJSON(input.minPrice),
+			spotPrice: Price.fromJSON(input.spotPrice),
+			maxPrice: Price.fromJSON(input.maxPrice)
+		});
 	}
-	computeSqrtPriceBounds(scaledPriceBounds) {
-		const { minPriceRaw, maxPriceRaw } = this.computeRawPriceBounds(scaledPriceBounds);
+	static fromPriceBounds(bounds, reserves) {
+		const minPrice = bounds.minPrice.lt(bounds.maxPrice) ? bounds.minPrice : bounds.maxPrice;
+		const maxPrice = bounds.minPrice.lt(bounds.maxPrice) ? bounds.maxPrice : bounds.minPrice;
+		const zeroForOne = reserves.reserveA.token.equal(bounds.minPrice.token0.address);
+		const reserve0 = zeroForOne ? reserves.reserveA : reserves.reserveB;
+		const reserve1 = zeroForOne ? reserves.reserveB : reserves.reserveA;
+		assert(reserve0.token.equal(bounds.minPrice.token0.address), "provided reserve for unknown token");
+		assert(reserve1.token.equal(bounds.minPrice.token1.address), "provided reserve for unknown token");
+		const { sqrtPriceSpot } = computeLiquidityAndPrice(reserve0.reserve, reserve1.reserve, minPrice.toSqrt(), maxPrice.toSqrt());
+		const spotPrice = Price.fromSqrt(sqrtPriceSpot, {
+			tokenA: bounds.minPrice.token0,
+			tokenB: bounds.minPrice.token1
+		});
+		return PriceRange.new({
+			minPrice,
+			spotPrice,
+			maxPrice
+		});
+	}
+	computeFixedAllocation(fixedReserve) {
+		assert(fixedReserve.token.equal(this.token0.address) || fixedReserve.token.equal(this.token1.address), "fixed reserve should be in some pair token");
+		const isFixedLt = fixedReserve.token.equal(this.token0.address);
+		const availableLt = isFixedLt ? fixedReserve.reserve : UINT_256_MAX;
+		const availableGt = isFixedLt ? UINT_256_MAX : fixedReserve.reserve;
+		const { actualLt, actualGt } = computeLiquidityFromAmounts(availableLt, availableGt, this.spotPrice.toSqrt(), this.minPrice.toSqrt(), this.maxPrice.toSqrt());
 		return {
-			sqrtPriceMin: bigintSqrt(minPriceRaw * ConcentrateLiquidityCalculator.ONE_E18),
-			sqrtPriceMax: bigintSqrt(maxPriceRaw * ConcentrateLiquidityCalculator.ONE_E18)
+			reserve0: TokenReserve.new({
+				token: this.token0.address,
+				reserve: actualLt
+			}),
+			reserve1: TokenReserve.new({
+				token: this.token1.address,
+				reserve: actualGt
+			})
 		};
 	}
-	/**
-	* Internal P = token1/token0 (1e18) from scaled min/max only (same mapping as {@link computeRawPrices}).
-	*/
-	computeRawPriceBounds(scaledPriceBounds) {
-		const token0 = this.token0;
-		const token1 = this.token1;
-		if (scaledPriceBounds.quoteToken.equal(token0.address)) {
-			const numerator = 10n ** (token1.decimals + token1.decimals) * ConcentrateLiquidityCalculator.ONE_E18;
-			return {
-				minPriceRaw: numerator / scaledPriceBounds.maxPriceRaw,
-				maxPriceRaw: numerator / scaledPriceBounds.minPriceRaw
-			};
-		}
-		if (scaledPriceBounds.quoteToken.equal(token1.address)) {
-			const denominator = 10n ** (token0.decimals + token0.decimals);
-			return {
-				minPriceRaw: scaledPriceBounds.minPriceRaw * ConcentrateLiquidityCalculator.ONE_E18 / denominator,
-				maxPriceRaw: scaledPriceBounds.maxPriceRaw * ConcentrateLiquidityCalculator.ONE_E18 / denominator
-			};
-		}
-		throw new Error("unknown quote token");
+	computeMaxAllocation(maxAvailableLiquidity) {
+		const zeroForOne = maxAvailableLiquidity.reserveA.token.equal(this.token0.address);
+		const reserve0 = zeroForOne ? maxAvailableLiquidity.reserveA : maxAvailableLiquidity.reserveB;
+		const reserve1 = zeroForOne ? maxAvailableLiquidity.reserveB : maxAvailableLiquidity.reserveA;
+		assert(reserve0.token.equal(this.token0.address), "provided reserve for unknown token");
+		assert(reserve1.token.equal(this.token1.address), "provided reserve for unknown token");
+		const { actualLt, actualGt } = computeLiquidityFromAmounts(reserve0.reserve, reserve1.reserve, this.spotPrice.toSqrt(), this.minPrice.toSqrt(), this.maxPrice.toSqrt());
+		return {
+			reserve0: TokenReserve.new({
+				token: this.token0.address,
+				reserve: actualLt
+			}),
+			reserve1: TokenReserve.new({
+				token: this.token1.address,
+				reserve: actualGt
+			})
+		};
+	}
+	toJSON() {
+		return {
+			minPrice: this.minPrice.toJSON(),
+			spotPrice: this.spotPrice.toJSON(),
+			maxPrice: this.maxPrice.toJSON()
+		};
 	}
 };
 
@@ -2157,8 +2295,10 @@ var ConcentrateLiquidityCalculator = class ConcentrateLiquidityCalculator {
 var concentrate_exports = {};
 __export(concentrate_exports, {
 	ConcentrateGrowLiquidity2DArgs: () => ConcentrateGrowLiquidity2DArgs,
-	ConcentrateLiquidityCalculator: () => ConcentrateLiquidityCalculator,
-	ONE_E18: () => ONE_E18,
+	ONE_E18: () => ONE_E18$1,
+	Price: () => Price,
+	PriceRange: () => PriceRange,
+	TokenReserve: () => TokenReserve,
 	bigintSqrt: () => bigintSqrt,
 	computeBalances: () => computeBalances,
 	computeLiquidityAndPrice: () => computeLiquidityAndPrice,
@@ -3064,11 +3204,188 @@ var PeggedSwapArgs = class PeggedSwapArgs {
 **/
 const peggedSwapGrowPriceRange2D = new Opcode(Symbol("PeggedSwap.peggedSwapGrowPriceRange2D"), PeggedSwapArgs.CODER);
 
+//#endregion
+//#region src/swap-vm/instructions/pegged-swap/pegged-swap-calculator/pegged-swap-calculator.ts
+const MARGINAL_PRICE_ONE$1 = 10n ** 18n;
+var PeggedSwapCalculator = class PeggedSwapCalculator {
+	constructor(tokenA, tokenB) {
+		this.tokenA = tokenA;
+		this.tokenB = tokenB;
+		assert(!tokenA.address.equal(tokenB.address), "tokens must be different");
+	}
+	get tokenLt() {
+		return this.tokenA.address.lt(this.tokenB.address) ? this.tokenA : this.tokenB;
+	}
+	get tokenGt() {
+		return this.tokenA.address.lt(this.tokenB.address) ? this.tokenB : this.tokenA;
+	}
+	static new(args) {
+		return new PeggedSwapCalculator(args.tokenA, args.tokenB);
+	}
+	/**
+	* Initial balances before deployment (`currentReserve = initialReserve`, u = v = 1).
+	* Given spot price and one raw initial reserve, returns the other.
+	*/
+	computeFixedAllocation(spotPrice, fixedReserveForToken, fixedReserve) {
+		assert(fixedReserve > 0n, "fixed reserve must be positive");
+		assert(spotPrice.matchesTokens(this.tokenLt.address, this.tokenGt.address), "spot price must match calculator token pair");
+		const marginalE18 = spotPrice.toGtPerLtE18();
+		if (fixedReserveForToken.equal(this.tokenLt.address)) return {
+			reserveLt: fixedReserve,
+			reserveGt: fixedReserve * marginalE18 / MARGINAL_PRICE_ONE$1
+		};
+		if (fixedReserveForToken.equal(this.tokenGt.address)) return {
+			reserveLt: fixedReserve * MARGINAL_PRICE_ONE$1 / marginalE18,
+			reserveGt: fixedReserve
+		};
+		throw new Error("fixedReserveForToken token must be one of the two pair tokens");
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/pegged-swap/pegged-swap-math/pegged-swap-math.ts
+/** Matches `PeggedSwapMath.ONE` in swap-vm. */
+const PEGGED_SWAP_ONE = 10n ** 27n;
+const MARGINAL_PRICE_ONE = 10n ** 18n;
+/**
+* Spot price tokenGt per tokenLt (raw) in 1e18 fixed-point.
+*
+* P = (Y₀/X₀) · (1/(2√u) + A) / (1/(2√v) + A) · (rateLt/rateGt)
+*
+* where u = x·ONE/X₀, v = y·ONE/Y₀, x/y are rate-adjusted Lt/Gt balances, A = `linearWidth`.
+*/
+function peggedSwapMarginalGtPerLtE18(balanceLtNorm, balanceGtNorm, x0, y0, linearWidth, rateLt, rateGt) {
+	const u = normalizeReserve(balanceLtNorm, x0);
+	const v = normalizeReserve(balanceGtNorm, y0);
+	assert(u !== 0n && v !== 0n, "PeggedSwapMath: reserves cannot be zero");
+	const slopeLt = peggedSwapMarginalWeight(bigintSqrt(u * PEGGED_SWAP_ONE), linearWidth);
+	const slopeGt = peggedSwapMarginalWeight(bigintSqrt(v * PEGGED_SWAP_ONE), linearWidth);
+	return y0 * slopeLt * rateLt * MARGINAL_PRICE_ONE / (x0 * slopeGt * rateGt);
+}
+/**
+* u = x·ONE/X₀, v = y·ONE/Y₀ (x, y are rate-adjusted reserves).
+*/
+function normalizeReserve(currentReserve, initialReserve) {
+	return mulDiv(currentReserve, PEGGED_SWAP_ONE, initialReserve);
+}
+/**
+* Marginal weight `1/(2√u) + A` (Lt side) or `1/(2√v) + A` (Gt side), A = `linearWidth`.
+*/
+function peggedSwapMarginalWeight(sqrtCoord, linearWidth) {
+	return mulDiv(PEGGED_SWAP_ONE, PEGGED_SWAP_ONE, 2n * sqrtCoord) + linearWidth;
+}
+function mulDiv(a, b, c) {
+	if (c === 0n) throw new Error("mulDiv: division by zero");
+	return a * b / c;
+}
+
+//#endregion
+//#region src/swap-vm/instructions/pegged-swap/price/pegged-price.ts
+const ONE_E18 = 10n ** 18n;
+var PeggedPrice = class PeggedPrice {
+	constructor(gtPerLtRaw, tokenLt, tokenGt) {
+		this.gtPerLtRaw = gtPerLtRaw;
+		this.tokenLt = tokenLt;
+		this.tokenGt = tokenGt;
+		assert(gtPerLtRaw > 0n, "price must be positive");
+		assert(tokenLt.address.lt(tokenGt.address), "internal pair order violated");
+	}
+	/**
+	* Spot price from per-token `initialReserve` / `currentReserve` (raw, not rate-scaled) and `linearWidth`.
+	* Use currentReserve = initialReserve to calculate the spot price before the strategy was deployed
+	*/
+	static fromReserves(input) {
+		assert(input.reserveA.currentReserve > 0n && input.reserveB.currentReserve > 0n, "current reserves should be positive");
+		assert(input.reserveA.initialReserve > 0n && input.reserveB.initialReserve > 0n, "initial reserves should be positive");
+		const zeroForOne = input.reserveA.address.lt(input.reserveB.address);
+		const reserveLt = zeroForOne ? input.reserveA : input.reserveB;
+		const reserveGt = zeroForOne ? input.reserveB : input.reserveA;
+		const rateLt = resolveRate(reserveLt.decimals, reserveGt.decimals);
+		const rateGt = resolveRate(reserveGt.decimals, reserveLt.decimals);
+		const initialLtNorm = reserveLt.initialReserve * rateLt;
+		const initialGtNorm = reserveGt.initialReserve * rateGt;
+		const marginalE18 = peggedSwapMarginalGtPerLtE18(reserveLt.currentReserve * rateLt, reserveGt.currentReserve * rateGt, initialLtNorm, initialGtNorm, input.linearWidth, rateLt, rateGt);
+		return PeggedPrice.fromGtPerLtE18(marginalE18, reserveLt, reserveGt);
+	}
+	/**
+	* Human decimal string for **quote per 1 base**.
+	*/
+	static fromHuman(price, pair) {
+		assert(!pair.quoteToken.address.equal(pair.baseToken.address), "quote and base must be different tokens");
+		const quoteToBase = pair.quoteToken.address.lt(pair.baseToken.address);
+		const tokenLt = quoteToBase ? pair.quoteToken : pair.baseToken;
+		const tokenGt = quoteToBase ? pair.baseToken : pair.quoteToken;
+		const parsed = parseUnits(price.trim(), Number(pair.quoteToken.decimals));
+		const ltDecimals = BigInt(tokenLt.decimals);
+		const gtDecimals = BigInt(tokenGt.decimals);
+		const marginalE18 = quoteToBase ? 10n ** (gtDecimals + 18n + ltDecimals) / (parsed * 10n ** gtDecimals) : parsed * ONE_E18 / 10n ** ltDecimals;
+		return PeggedPrice.fromGtPerLtE18(marginalE18, tokenLt, tokenGt);
+	}
+	static fromJSON(input) {
+		const tokenLt = {
+			address: new Address$1(input.tokenLt.address),
+			decimals: Number(input.tokenLt.decimals)
+		};
+		const tokenGt = {
+			address: new Address$1(input.tokenGt.address),
+			decimals: Number(input.tokenGt.decimals)
+		};
+		assert(tokenLt.address.lt(tokenGt.address), "tokenLt address must be less than tokenGt (canonical order)");
+		return new PeggedPrice(BigInt(input.gtPerLtRaw), tokenLt, tokenGt);
+	}
+	static fromGtPerLtE18(marginalGtPerLtE18, tokenLt, tokenGt) {
+		assert(marginalGtPerLtE18 > 0n, "marginal rate must be positive");
+		const scale = BigInt(tokenLt.decimals + tokenGt.decimals);
+		const gtPerLtRaw = marginalGtPerLtE18 * 10n ** scale / ONE_E18;
+		return new PeggedPrice(gtPerLtRaw, tokenLt, tokenGt);
+	}
+	matchesTokens(tokenA, tokenB) {
+		return tokenA.equal(this.tokenLt.address) && tokenB.equal(this.tokenGt.address) || tokenA.equal(this.tokenGt.address) && tokenB.equal(this.tokenLt.address);
+	}
+	equals(other) {
+		return this.gtPerLtRaw === other.gtPerLtRaw && this.tokenLt.address.equal(other.tokenLt.address) && this.tokenGt.address.equal(other.tokenGt.address) && BigInt(this.tokenLt.decimals) === BigInt(other.tokenLt.decimals) && BigInt(this.tokenGt.decimals) === BigInt(other.tokenGt.decimals);
+	}
+	/**
+	* Decimal string for **quote per 1 base**; rounded half-up to quote token decimals.
+	*/
+	toHuman(quoteToken) {
+		assert(quoteToken.equal(this.tokenLt.address) || quoteToken.equal(this.tokenGt.address), "quote token must be one of the pair tokens");
+		const isQuoteLt = quoteToken.equal(this.tokenLt.address);
+		const quoteDecimals = isQuoteLt ? this.tokenLt.decimals : this.tokenGt.decimals;
+		const ltDecimals = BigInt(this.tokenLt.decimals);
+		const gtDecimals = BigInt(this.tokenGt.decimals);
+		const marginalE18 = this.toGtPerLtE18();
+		const scaled = quoteToken.equal(this.tokenGt.address) ? marginalE18 * 10n ** ltDecimals / ONE_E18 : 10n ** (gtDecimals + 18n + ltDecimals) / (marginalE18 * 10n ** gtDecimals);
+		const full = formatUnits(scaled, Number(quoteDecimals));
+		return truncateHumanDecimalString(full, Number(quoteDecimals));
+	}
+	/** Marginal gt-per-lt rate in 1e18 fixed-point. */
+	toGtPerLtE18() {
+		const scale = BigInt(this.tokenLt.decimals + this.tokenGt.decimals);
+		return this.gtPerLtRaw * ONE_E18 / 10n ** scale;
+	}
+	toJSON() {
+		return {
+			gtPerLtRaw: this.gtPerLtRaw.toString(),
+			tokenLt: {
+				address: this.tokenLt.address.toString(),
+				decimals: String(this.tokenLt.decimals)
+			},
+			tokenGt: {
+				address: this.tokenGt.address.toString(),
+				decimals: String(this.tokenGt.decimals)
+			}
+		};
+	}
+};
+
 //#endregion
 //#region src/swap-vm/instructions/pegged-swap/index.ts
 var pegged_swap_exports = {};
 __export(pegged_swap_exports, {
+	PeggedPrice: () => PeggedPrice,
 	PeggedSwapArgs: () => PeggedSwapArgs,
+	PeggedSwapCalculator: () => PeggedSwapCalculator,
 	peggedSwapGrowPriceRange2D: () => peggedSwapGrowPriceRange2D
 });
 
@@ -3174,6 +3491,7 @@ __export(instructions_exports, {
 	aquaInstructions: () => aquaInstructions,
 	balances: () => balances_exports,
 	baseFeeAdjuster: () => base_fee_adjuster_exports,
+	bigintSqrt: () => bigintSqrt,
 	concentrate: () => concentrate_exports,
 	controls: () => controls_exports,
 	decay: () => decay_exports,
@@ -3186,6 +3504,7 @@ __export(instructions_exports, {
 	oraclePriceAdjuster: () => oracle_price_adjuster_exports,
 	peggedSwap: () => pegged_swap_exports,
 	stableSwap: () => pegged_swap_exports,
+	truncateHumanDecimalString: () => truncateHumanDecimalString,
 	twapSwap: () => twap_swap_exports,
 	xycSwap: () => xyc_swap_exports
 });