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

package/dist/index.js

@@ -2025,149 +2025,287 @@ function mulDiv(a, b, c) {
 }
 
 //#endregion
-//#region src/swap-vm/instructions/concentrate/concentrate-liquidity-calculator/concentrate-liquidity-calculator.ts
+//#region src/swap-vm/instructions/concentrate/price/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$1 = 10n ** 18n;
+var Price = class Price {
+	constructor(sqrtP, token0, token1) {
+		this.sqrtP = sqrtP;
+		this.token0 = token0;
+		this.token1 = token1;
+		(0, assert.default)(sqrtP > 0n, "sqrt price must be positive");
+		(0, assert.default)(!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) {
+		(0, assert.default)(!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 = (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);
+		}
+		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);
+		}
+		throw new Error("quote token must be one of the two pair tokens");
+	}
+	static fromJSON(input) {
+		const token0 = {
+			address: new __1inch_sdk_core.Address(input.token0.address),
+			decimals: BigInt(input.token0.decimals)
+		};
+		const token1 = {
+			address: new __1inch_sdk_core.Address(input.token1.address),
+			decimals: BigInt(input.token1.decimals)
+		};
+		(0, assert.default)(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) {
+		(0, assert.default)(this.isSamePair(other), "cannot compare prices for different pairs");
+		return this.sqrtP < other.sqrtP;
+	}
+	lte(other) {
+		(0, assert.default)(this.isSamePair(other), "cannot compare prices for different pairs");
+		return this.sqrtP <= other.sqrtP;
+	}
+	gt(other) {
+		(0, assert.default)(this.isSamePair(other), "cannot compare prices for different pairs");
+		return this.sqrtP > other.sqrtP;
+	}
+	gte(other) {
+		(0, assert.default)(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$1;
 	}
-	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 : __1inch_byte_utils.UINT_256_MAX;
-		const availableGt = isFixedLt ? __1inch_byte_utils.UINT_256_MAX : fixedReserve;
-		const { actualLt, actualGt } = computeLiquidityFromAmounts(availableLt, availableGt, sqrtPriceSpot, sqrtPriceMin, sqrtPriceMax);
+	toHuman(quoteToken) {
+		(0, assert.default)(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 = (0, viem.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$1;
+			return numerator * ONE_E18$1 / sqrtP2;
+		}
+		if (quoteToken.equal(this.token1.address)) {
+			const numerator = 10n ** (d0 + d0);
+			return sqrtP2 * numerator / (ONE_E18$1 * ONE_E18$1);
+		}
+		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 __1inch_sdk_core.Address(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;
+		(0, assert.default)(maxPrice.gte(spotPrice), "maxPrice should be >= spotPrice");
+		(0, assert.default)(spotPrice.gte(minPrice), "spotPrice should be >= minPrice");
+		(0, assert.default)(minPrice.lt(maxPrice), "minPrice should be < maxPrice");
+		(0, assert.default)(minPrice.isSamePair(spotPrice), "cannot create price range for different pairs");
+		(0, assert.default)(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;
 	}
-	computeSqrtPriceBounds(scaledPriceBounds) {
-		const { minPriceRaw, maxPriceRaw } = this.computeRawPriceBounds(scaledPriceBounds);
+	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)
+		});
+	}
+	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;
+		(0, assert.default)(reserve0.token.equal(bounds.minPrice.token0.address), "provided reserve for unknown token");
+		(0, assert.default)(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) {
+		(0, assert.default)(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 : __1inch_byte_utils.UINT_256_MAX;
+		const availableGt = isFixedLt ? __1inch_byte_utils.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;
+		(0, assert.default)(reserve0.token.equal(this.token0.address), "provided reserve for unknown token");
+		(0, assert.default)(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()
+		};
 	}
 };
 
@@ -2176,8 +2314,10 @@ var ConcentrateLiquidityCalculator = class ConcentrateLiquidityCalculator {
 var concentrate_exports = {};
 __export(concentrate_exports, {
 	ConcentrateGrowLiquidity2DArgs: () => ConcentrateGrowLiquidity2DArgs,
-	ConcentrateLiquidityCalculator: () => ConcentrateLiquidityCalculator,
 	ONE_E18: () => ONE_E18,
+	Price: () => Price,
+	PriceRange: () => PriceRange,
+	TokenReserve: () => TokenReserve,
 	bigintSqrt: () => bigintSqrt,
 	computeBalances: () => computeBalances,
 	computeLiquidityAndPrice: () => computeLiquidityAndPrice,