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

package/dist/index.js

@@ -1866,7 +1866,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;
@@ -1882,7 +1882,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)
@@ -1910,8 +1910,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);
 	}
 	/**
@@ -1955,8 +1955,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) : __1inch_byte_utils.UINT_256_MAX;
-	const lFromGt = sqrtPspot > sqrtPmin ? mulDiv(availableGt, ONE, sqrtPspot - sqrtPmin) : __1inch_byte_utils.UINT_256_MAX;
+	const lFromLt = sqrtPmax > sqrtPspot ? mulDiv$1(availableLt, mulDiv$1(sqrtPmax, sqrtPspot, ONE), sqrtPmax - sqrtPspot) : __1inch_byte_utils.UINT_256_MAX;
+	const lFromGt = sqrtPspot > sqrtPmin ? mulDiv$1(availableGt, ONE, sqrtPspot - sqrtPmin) : __1inch_byte_utils.UINT_256_MAX;
 	const targetL = lFromLt < lFromGt ? lFromLt : lFromGt;
 	const { bLt: actualLt, bGt: actualGt } = computeBalances(targetL, sqrtPspot, sqrtPmin, sqrtPmax);
 	return {
@@ -1980,8 +1980,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
@@ -2000,9 +2000,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
@@ -2013,19 +2013,19 @@ 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/price/truncate-human-decimal-string.ts
+//#region src/swap-vm/instructions/utils/truncate-human-decimal-string.ts
 /**
 * 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.
@@ -2060,7 +2060,7 @@ function truncateHumanDecimalString(s, maxFrac) {
 
 //#endregion
 //#region src/swap-vm/instructions/concentrate/price/price.ts
-const ONE_E18$1 = 10n ** 18n;
+const ONE_E18$2 = 10n ** 18n;
 var Price = class Price {
 	constructor(sqrtP, token0, token1) {
 		this.sqrtP = sqrtP;
@@ -2092,12 +2092,12 @@ var Price = class Price {
 		if (scale > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("decimals sum too large for parseUnits");
 		const scaledRaw = (0, viem.parseUnits)(price.trim(), Number(scale));
 		if (pair.quoteToken.address.equal(t0.address)) {
-			const numerator = 10n ** (d1 + d1) * ONE_E18$1;
-			return new Price(bigintSqrt(numerator * ONE_E18$1 / scaledRaw), t0, t1);
+			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$1 * ONE_E18$1 / denominator), t0, t1);
+			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");
 	}
@@ -2139,7 +2139,7 @@ var Price = class Price {
 	* Raw price `P` with 1e18 fixed-point (`(sqrtP^2) / 1e18`), matching typical on-chain use.
 	*/
 	toRaw() {
-		return this.sqrtP * this.sqrtP / ONE_E18$1;
+		return this.sqrtP * this.sqrtP / ONE_E18$2;
 	}
 	toSqrt() {
 		return this.sqrtP;
@@ -2183,12 +2183,12 @@ var Price = class Price {
 		const d1 = this.token1.decimals;
 		const sqrtP2 = this.sqrtP * this.sqrtP;
 		if (quoteToken.equal(this.token0.address)) {
-			const numerator = 10n ** (d1 + d1) * ONE_E18$1;
-			return numerator * ONE_E18$1 / sqrtP2;
+			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$1 * ONE_E18$1);
+			return sqrtP2 * numerator / (ONE_E18$2 * ONE_E18$2);
 		}
 		throw new Error("quote token must be one of the pair tokens");
 	}
@@ -2314,7 +2314,7 @@ var PriceRange = class PriceRange {
 var concentrate_exports = {};
 __export(concentrate_exports, {
 	ConcentrateGrowLiquidity2DArgs: () => ConcentrateGrowLiquidity2DArgs,
-	ONE_E18: () => ONE_E18,
+	ONE_E18: () => ONE_E18$1,
 	Price: () => Price,
 	PriceRange: () => PriceRange,
 	TokenReserve: () => TokenReserve,
@@ -3223,11 +3223,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;
+		(0, assert.default)(!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) {
+		(0, assert.default)(fixedReserve > 0n, "fixed reserve must be positive");
+		(0, assert.default)(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);
+	(0, assert.default)(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;
+		(0, assert.default)(gtPerLtRaw > 0n, "price must be positive");
+		(0, assert.default)(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) {
+		(0, assert.default)(input.reserveA.currentReserve > 0n && input.reserveB.currentReserve > 0n, "current reserves should be positive");
+		(0, assert.default)(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) {
+		(0, assert.default)(!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 = (0, viem.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 __1inch_sdk_core.Address(input.tokenLt.address),
+			decimals: Number(input.tokenLt.decimals)
+		};
+		const tokenGt = {
+			address: new __1inch_sdk_core.Address(input.tokenGt.address),
+			decimals: Number(input.tokenGt.decimals)
+		};
+		(0, assert.default)(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) {
+		(0, assert.default)(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) {
+		(0, assert.default)(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 = (0, viem.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
 });
 
@@ -3333,6 +3510,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,
@@ -3345,6 +3523,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
 });

package/dist/index.mjs

@@ -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,19 +1994,19 @@ 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/price/truncate-human-decimal-string.ts
+//#region src/swap-vm/instructions/utils/truncate-human-decimal-string.ts
 /**
 * 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.
@@ -2041,7 +2041,7 @@ function truncateHumanDecimalString(s, maxFrac) {
 
 //#endregion
 //#region src/swap-vm/instructions/concentrate/price/price.ts
-const ONE_E18$1 = 10n ** 18n;
+const ONE_E18$2 = 10n ** 18n;
 var Price = class Price {
 	constructor(sqrtP, token0, token1) {
 		this.sqrtP = sqrtP;
@@ -2073,12 +2073,12 @@ var Price = class Price {
 		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$1;
-			return new Price(bigintSqrt(numerator * ONE_E18$1 / scaledRaw), t0, t1);
+			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$1 * ONE_E18$1 / denominator), t0, t1);
+			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");
 	}
@@ -2120,7 +2120,7 @@ var Price = class Price {
 	* Raw price `P` with 1e18 fixed-point (`(sqrtP^2) / 1e18`), matching typical on-chain use.
 	*/
 	toRaw() {
-		return this.sqrtP * this.sqrtP / ONE_E18$1;
+		return this.sqrtP * this.sqrtP / ONE_E18$2;
 	}
 	toSqrt() {
 		return this.sqrtP;
@@ -2164,12 +2164,12 @@ var Price = class Price {
 		const d1 = this.token1.decimals;
 		const sqrtP2 = this.sqrtP * this.sqrtP;
 		if (quoteToken.equal(this.token0.address)) {
-			const numerator = 10n ** (d1 + d1) * ONE_E18$1;
-			return numerator * ONE_E18$1 / sqrtP2;
+			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$1 * ONE_E18$1);
+			return sqrtP2 * numerator / (ONE_E18$2 * ONE_E18$2);
 		}
 		throw new Error("quote token must be one of the pair tokens");
 	}
@@ -2295,7 +2295,7 @@ var PriceRange = class PriceRange {
 var concentrate_exports = {};
 __export(concentrate_exports, {
 	ConcentrateGrowLiquidity2DArgs: () => ConcentrateGrowLiquidity2DArgs,
-	ONE_E18: () => ONE_E18,
+	ONE_E18: () => ONE_E18$1,
 	Price: () => Price,
 	PriceRange: () => PriceRange,
 	TokenReserve: () => TokenReserve,
@@ -3204,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
 });
 
@@ -3314,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,
@@ -3326,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
 });

package/dist/swap-vm/instructions/concentrate/index.d.mts

@@ -8,4 +8,4 @@ export type { PriceRangeJSON } from './price-range';
 export { TokenReserve } from './token-reserve';
 export type { TokenReserveArgs, TokenReserveJSON } from './token-reserve';
 export type { ConcentrateTokenInfo, ConcentrateLiquidityCalculatorArgs, PriceAllocationRange, PriceBounds, ConcentratedLiquidityInfo, } from './concentrate-liquidity-calculator/types';
-export * from './bigint-sqrt';
+export { bigintSqrt } from '../utils/bigint-sqrt';

package/dist/swap-vm/instructions/concentrate/index.d.ts

@@ -8,4 +8,4 @@ export type { PriceRangeJSON } from './price-range';
 export { TokenReserve } from './token-reserve';
 export type { TokenReserveArgs, TokenReserveJSON } from './token-reserve';
 export type { ConcentrateTokenInfo, ConcentrateLiquidityCalculatorArgs, PriceAllocationRange, PriceBounds, ConcentratedLiquidityInfo, } from './concentrate-liquidity-calculator/types';
-export * from './bigint-sqrt';
+export { bigintSqrt } from '../utils/bigint-sqrt';

package/dist/swap-vm/instructions/concentrate/price/index.d.mts

@@ -1,3 +1,3 @@
 export { Price } from './price';
-export { truncateHumanDecimalString } from './truncate-human-decimal-string';
+export { truncateHumanDecimalString } from '../../utils/truncate-human-decimal-string';
 export type { PriceJSON, PricePair, PriceToken } from './types';

package/dist/swap-vm/instructions/concentrate/price/index.d.ts

@@ -1,3 +1,3 @@
 export { Price } from './price';
-export { truncateHumanDecimalString } from './truncate-human-decimal-string';
+export { truncateHumanDecimalString } from '../../utils/truncate-human-decimal-string';
 export type { PriceJSON, PricePair, PriceToken } from './types';

package/dist/swap-vm/instructions/index.d.mts

@@ -1,6 +1,7 @@
 import type { Opcode } from './opcode';
 import type { IArgsData } from './types';
 export * from './types';
+export { bigintSqrt, truncateHumanDecimalString } from './utils';
 export { EMPTY_OPCODE } from './empty';
 export * as balances from './balances';
 export * as controls from './controls';

package/dist/swap-vm/instructions/index.d.ts

@@ -1,6 +1,7 @@
 import type { Opcode } from './opcode';
 import type { IArgsData } from './types';
 export * from './types';
+export { bigintSqrt, truncateHumanDecimalString } from './utils';
 export { EMPTY_OPCODE } from './empty';
 export * as balances from './balances';
 export * as controls from './controls';

package/dist/swap-vm/instructions/pegged-swap/index.d.mts

@@ -1,3 +1,7 @@
 export * from './opcodes';
 export { PeggedSwapArgs } from './pegged-swap-args';
 export type { PeggedTokenInfo } from './types';
+export { PeggedSwapCalculator } from './pegged-swap-calculator';
+export { PeggedPrice } from './price';
+export type { PeggedInitialBalances, PeggedSwapCalculatorArgs } from './pegged-swap-calculator';
+export type { PeggedPriceJSON, PeggedPricePair, PeggedReservesInput, PeggedTokenRef, PeggedTokenReserve, } from './price';

package/dist/swap-vm/instructions/pegged-swap/index.d.ts

@@ -1,3 +1,7 @@
 export * from './opcodes';
 export { PeggedSwapArgs } from './pegged-swap-args';
 export type { PeggedTokenInfo } from './types';
+export { PeggedSwapCalculator } from './pegged-swap-calculator';
+export { PeggedPrice } from './price';
+export type { PeggedInitialBalances, PeggedSwapCalculatorArgs } from './pegged-swap-calculator';
+export type { PeggedPriceJSON, PeggedPricePair, PeggedReservesInput, PeggedTokenRef, PeggedTokenReserve, } from './price';

package/dist/swap-vm/instructions/pegged-swap/pegged-swap-calculator/index.d.mts

@@ -0,0 +1,2 @@
+export { PeggedSwapCalculator } from './pegged-swap-calculator';
+export type { PeggedInitialBalances, PeggedSwapCalculatorArgs } from './types';

package/dist/swap-vm/instructions/pegged-swap/pegged-swap-calculator/index.d.ts

@@ -0,0 +1,2 @@
+export { PeggedSwapCalculator } from './pegged-swap-calculator';
+export type { PeggedInitialBalances, PeggedSwapCalculatorArgs } from './types';

package/dist/swap-vm/instructions/pegged-swap/pegged-swap-calculator/pegged-swap-calculator.d.mts

@@ -0,0 +1,16 @@
+import type { Address } from '@1inch/sdk-core';
+import type { PeggedInitialBalances, PeggedSwapCalculatorArgs } from './types';
+import type { PeggedPrice, PeggedTokenRef } from '../price';
+export declare class PeggedSwapCalculator {
+    private readonly tokenA;
+    private readonly tokenB;
+    constructor(tokenA: PeggedTokenRef, tokenB: PeggedTokenRef);
+    get tokenLt(): PeggedTokenRef;
+    get tokenGt(): PeggedTokenRef;
+    static new(args: PeggedSwapCalculatorArgs): PeggedSwapCalculator;
+    /**
+     * Initial balances before deployment (`currentReserve = initialReserve`, u = v = 1).
+     * Given spot price and one raw initial reserve, returns the other.
+     */
+    computeFixedAllocation(spotPrice: PeggedPrice, fixedReserveForToken: Address, fixedReserve: bigint): PeggedInitialBalances;
+}

package/dist/swap-vm/instructions/pegged-swap/pegged-swap-calculator/pegged-swap-calculator.d.ts

@@ -0,0 +1,16 @@
+import type { Address } from '@1inch/sdk-core';
+import type { PeggedInitialBalances, PeggedSwapCalculatorArgs } from './types';
+import type { PeggedPrice, PeggedTokenRef } from '../price';
+export declare class PeggedSwapCalculator {
+    private readonly tokenA;
+    private readonly tokenB;
+    constructor(tokenA: PeggedTokenRef, tokenB: PeggedTokenRef);
+    get tokenLt(): PeggedTokenRef;
+    get tokenGt(): PeggedTokenRef;
+    static new(args: PeggedSwapCalculatorArgs): PeggedSwapCalculator;
+    /**
+     * Initial balances before deployment (`currentReserve = initialReserve`, u = v = 1).
+     * Given spot price and one raw initial reserve, returns the other.
+     */
+    computeFixedAllocation(spotPrice: PeggedPrice, fixedReserveForToken: Address, fixedReserve: bigint): PeggedInitialBalances;
+}

package/dist/swap-vm/instructions/pegged-swap/pegged-swap-calculator/types.d.mts

@@ -0,0 +1,9 @@
+import type { PeggedTokenRef } from '../price/types';
+export type PeggedSwapCalculatorArgs = {
+    tokenA: PeggedTokenRef;
+    tokenB: PeggedTokenRef;
+};
+export type PeggedInitialBalances = {
+    reserveLt: bigint;
+    reserveGt: bigint;
+};

package/dist/swap-vm/instructions/pegged-swap/pegged-swap-calculator/types.d.ts

@@ -0,0 +1,9 @@
+import type { PeggedTokenRef } from '../price/types';
+export type PeggedSwapCalculatorArgs = {
+    tokenA: PeggedTokenRef;
+    tokenB: PeggedTokenRef;
+};
+export type PeggedInitialBalances = {
+    reserveLt: bigint;
+    reserveGt: bigint;
+};

package/dist/swap-vm/instructions/pegged-swap/pegged-swap-math/pegged-swap-math.d.mts

@@ -0,0 +1,18 @@
+/** Matches `PeggedSwapMath.ONE` in swap-vm. */
+export declare const PEGGED_SWAP_ONE: bigint;
+/**
+ * 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`.
+ */
+export declare function peggedSwapMarginalGtPerLtE18(balanceLtNorm: bigint, balanceGtNorm: bigint, x0: bigint, y0: bigint, linearWidth: bigint, rateLt: bigint, rateGt: bigint): bigint;
+/**
+ * u = x·ONE/X₀, v = y·ONE/Y₀ (x, y are rate-adjusted reserves).
+ */
+export declare function normalizeReserve(currentReserve: bigint, initialReserve: bigint): bigint;
+/**
+ * Marginal weight `1/(2√u) + A` (Lt side) or `1/(2√v) + A` (Gt side), A = `linearWidth`.
+ */
+export declare function peggedSwapMarginalWeight(sqrtCoord: bigint, linearWidth: bigint): bigint;

package/dist/swap-vm/instructions/pegged-swap/pegged-swap-math/pegged-swap-math.d.ts

@@ -0,0 +1,18 @@
+/** Matches `PeggedSwapMath.ONE` in swap-vm. */
+export declare const PEGGED_SWAP_ONE: bigint;
+/**
+ * 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`.
+ */
+export declare function peggedSwapMarginalGtPerLtE18(balanceLtNorm: bigint, balanceGtNorm: bigint, x0: bigint, y0: bigint, linearWidth: bigint, rateLt: bigint, rateGt: bigint): bigint;
+/**
+ * u = x·ONE/X₀, v = y·ONE/Y₀ (x, y are rate-adjusted reserves).
+ */
+export declare function normalizeReserve(currentReserve: bigint, initialReserve: bigint): bigint;
+/**
+ * Marginal weight `1/(2√u) + A` (Lt side) or `1/(2√v) + A` (Gt side), A = `linearWidth`.
+ */
+export declare function peggedSwapMarginalWeight(sqrtCoord: bigint, linearWidth: bigint): bigint;

package/dist/swap-vm/instructions/pegged-swap/price/index.d.mts

@@ -0,0 +1,2 @@
+export { PeggedPrice } from './pegged-price';
+export type { PeggedPriceJSON, PeggedPricePair, PeggedReservesInput, PeggedTokenRef, PeggedTokenReserve, } from './types';

package/dist/swap-vm/instructions/pegged-swap/price/index.d.ts

@@ -0,0 +1,2 @@
+export { PeggedPrice } from './pegged-price';
+export type { PeggedPriceJSON, PeggedPricePair, PeggedReservesInput, PeggedTokenRef, PeggedTokenReserve, } from './types';

package/dist/swap-vm/instructions/pegged-swap/price/pegged-price.d.mts

@@ -0,0 +1,28 @@
+import { Address } from '@1inch/sdk-core';
+import type { PeggedPriceJSON, PeggedPricePair, PeggedReservesInput, PeggedTokenRef } from './types';
+export declare class PeggedPrice {
+    private readonly gtPerLtRaw;
+    readonly tokenLt: PeggedTokenRef;
+    readonly tokenGt: PeggedTokenRef;
+    private constructor();
+    /**
+     * 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: PeggedReservesInput): PeggedPrice;
+    /**
+     * Human decimal string for **quote per 1 base**.
+     */
+    static fromHuman(price: string, pair: PeggedPricePair): PeggedPrice;
+    static fromJSON(input: PeggedPriceJSON): PeggedPrice;
+    private static fromGtPerLtE18;
+    matchesTokens(tokenA: Address, tokenB: Address): boolean;
+    equals(other: PeggedPrice): boolean;
+    /**
+     * Decimal string for **quote per 1 base**; rounded half-up to quote token decimals.
+     */
+    toHuman(quoteToken: Address): string;
+    /** Marginal gt-per-lt rate in 1e18 fixed-point. */
+    toGtPerLtE18(): bigint;
+    toJSON(): PeggedPriceJSON;
+}

package/dist/swap-vm/instructions/pegged-swap/price/pegged-price.d.ts

@@ -0,0 +1,28 @@
+import { Address } from '@1inch/sdk-core';
+import type { PeggedPriceJSON, PeggedPricePair, PeggedReservesInput, PeggedTokenRef } from './types';
+export declare class PeggedPrice {
+    private readonly gtPerLtRaw;
+    readonly tokenLt: PeggedTokenRef;
+    readonly tokenGt: PeggedTokenRef;
+    private constructor();
+    /**
+     * 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: PeggedReservesInput): PeggedPrice;
+    /**
+     * Human decimal string for **quote per 1 base**.
+     */
+    static fromHuman(price: string, pair: PeggedPricePair): PeggedPrice;
+    static fromJSON(input: PeggedPriceJSON): PeggedPrice;
+    private static fromGtPerLtE18;
+    matchesTokens(tokenA: Address, tokenB: Address): boolean;
+    equals(other: PeggedPrice): boolean;
+    /**
+     * Decimal string for **quote per 1 base**; rounded half-up to quote token decimals.
+     */
+    toHuman(quoteToken: Address): string;
+    /** Marginal gt-per-lt rate in 1e18 fixed-point. */
+    toGtPerLtE18(): bigint;
+    toJSON(): PeggedPriceJSON;
+}

package/dist/swap-vm/instructions/pegged-swap/price/types.d.mts

@@ -0,0 +1,30 @@
+import type { Address } from '@1inch/sdk-core';
+export type PeggedTokenRef = {
+    address: Address;
+    decimals: number;
+};
+export type PeggedPricePair = {
+    quoteToken: PeggedTokenRef;
+    baseToken: PeggedTokenRef;
+};
+export type PeggedTokenReserve = PeggedTokenRef & {
+    initialReserve: bigint;
+    currentReserve: bigint;
+};
+export type PeggedReservesInput = {
+    reserveA: PeggedTokenReserve;
+    reserveB: PeggedTokenReserve;
+    linearWidth: bigint;
+};
+/** Snapshot from `PeggedPrice.prototype.toJSON` (bigints as decimal strings). */
+export type PeggedPriceJSON = {
+    gtPerLtRaw: string;
+    tokenLt: {
+        address: string;
+        decimals: string;
+    };
+    tokenGt: {
+        address: string;
+        decimals: string;
+    };
+};

package/dist/swap-vm/instructions/pegged-swap/price/types.d.ts

@@ -0,0 +1,30 @@
+import type { Address } from '@1inch/sdk-core';
+export type PeggedTokenRef = {
+    address: Address;
+    decimals: number;
+};
+export type PeggedPricePair = {
+    quoteToken: PeggedTokenRef;
+    baseToken: PeggedTokenRef;
+};
+export type PeggedTokenReserve = PeggedTokenRef & {
+    initialReserve: bigint;
+    currentReserve: bigint;
+};
+export type PeggedReservesInput = {
+    reserveA: PeggedTokenReserve;
+    reserveB: PeggedTokenReserve;
+    linearWidth: bigint;
+};
+/** Snapshot from `PeggedPrice.prototype.toJSON` (bigints as decimal strings). */
+export type PeggedPriceJSON = {
+    gtPerLtRaw: string;
+    tokenLt: {
+        address: string;
+        decimals: string;
+    };
+    tokenGt: {
+        address: string;
+        decimals: string;
+    };
+};

package/dist/swap-vm/instructions/utils/index.d.mts

@@ -0,0 +1,2 @@
+export { bigintSqrt } from './bigint-sqrt';
+export { truncateHumanDecimalString } from './truncate-human-decimal-string';

package/dist/swap-vm/instructions/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { bigintSqrt } from './bigint-sqrt';
+export { truncateHumanDecimalString } from './truncate-human-decimal-string';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1inch/swap-vm-sdk",
-  "version": "0.1.2-rc.7",
+  "version": "0.1.3",
   "description": "1inch Swap VM SDK",
   "author": "@1inch",
   "license": "LicenseRef-Degensoft-SwapVM-1.1",
@@ -42,11 +42,11 @@
     "@1inch/sdk-core": "0.1.2"
   },
   "devDependencies": {
-    "@types/node": "^22.13.0",
+    "@types/node": "^22.19.17",
     "dotenv": "17.2.3",
-    "eslint-plugin-license-header": "0.8.0",
+    "eslint-plugin-license-header": "0.9.0",
     "tsdown": "^0.2.17",
-    "typescript": "^5.7.3",
+    "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
   "volta": {