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

package/README.md

@@ -523,18 +523,18 @@ The SDK includes pre-configured contract addresses of `AquaSwapVMRouter` for the
 
 | Network | Chain ID | Address |
 |---------|----------|---------|
-| Ethereum | 1 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://etherscan.io/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| BNB Chain | 56 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://bscscan.com/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| Polygon | 137 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://polygonscan.com/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| Arbitrum | 42161 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://arbiscan.io/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| Avalanche | 43114 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](http://snowscan.xyz/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| Gnosis | 100 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://gnosisscan.io/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| Coinbase Base | 8453 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://basescan.org/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| Optimism | 10 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://optimistic.etherscan.io/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| zkSync Era | 324 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://era.zksync.network/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| Linea | 59144 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://lineascan.build/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| Unichain | 1301 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://uniscan.xyz/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
-| Sonic | 146 | [0x8fdd04dbf6111437b44bbca99c28882434e0958f](https://sonicscan.org/address/0x8fdd04dbf6111437b44bbca99c28882434e0958f) |
+| Ethereum | 1 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://etherscan.io/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| BNB Chain | 56 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://bscscan.com/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| Polygon | 137 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://polygonscan.com/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| Arbitrum | 42161 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://arbiscan.io/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| Avalanche | 43114 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](http://snowscan.xyz/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| Gnosis | 100 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://gnosisscan.io/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| Coinbase Base | 8453 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://basescan.org/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| Optimism | 10 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://optimistic.etherscan.io/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| zkSync Era | 324 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://era.zksync.network/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| Linea | 59144 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://lineascan.build/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| Unichain | 1301 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://uniscan.xyz/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
+| Sonic | 146 | [0xdfd05fe230bfe7b212878414270c72c8345506fa](https://sonicscan.org/address/0xdfd05fe230bfe7b212878414270c72c8345506fa) |
 
 Access addresses using:
 

package/dist/index.d.mts

@@ -1,4 +1,5 @@
 export * from './swap-vm-contract';
 export * from './swap-vm';
 export * as ABI from './abi';
-export { Address, HexString, NetworkEnum, CallInfo } from '@1inch/sdk-core';
+export { Address, HexString, NetworkEnum } from '@1inch/sdk-core';
+export type { CallInfo } from '@1inch/sdk-core';

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './swap-vm-contract';
 export * from './swap-vm';
 export * as ABI from './abi';
-export { Address, HexString, NetworkEnum, CallInfo } from '@1inch/sdk-core';
+export { Address, HexString, NetworkEnum } from '@1inch/sdk-core';
+export type { CallInfo } from '@1inch/sdk-core';

package/dist/index.js

@@ -725,18 +725,18 @@ var SwapVMContract = class SwapVMContract {
 * @see "../swap-vm/programs/aqua-program-builder"
 */
 const AQUA_SWAP_VM_CONTRACT_ADDRESSES = {
-	[__1inch_sdk_core.NetworkEnum.ETHEREUM]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.BINANCE]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.POLYGON]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.ARBITRUM]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.AVALANCHE]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.GNOSIS]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.COINBASE]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.OPTIMISM]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.ZKSYNC]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.LINEA]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.UNICHAIN]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[__1inch_sdk_core.NetworkEnum.SONIC]: new __1inch_sdk_core.Address("0x8fdd04dbf6111437b44bbca99c28882434e0958f")
+	[__1inch_sdk_core.NetworkEnum.ETHEREUM]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.BINANCE]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.POLYGON]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.ARBITRUM]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.AVALANCHE]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.GNOSIS]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.COINBASE]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.OPTIMISM]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.ZKSYNC]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.LINEA]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.UNICHAIN]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[__1inch_sdk_core.NetworkEnum.SONIC]: new __1inch_sdk_core.Address("0xdfd05fe230bfe7b212878414270c72c8345506fa")
 };
 
 //#endregion
@@ -1142,8 +1142,8 @@ var TakerTraits = class TakerTraits {
 		let flags = new __1inch_byte_utils.BN(0n);
 		flags = flags.setBit(TakerTraits.IS_EXACT_IN_BIT_FLAG, this.exactIn);
 		flags = flags.setBit(TakerTraits.SHOULD_UNWRAP_BIT_FLAG, this.shouldUnwrap);
-		flags = flags.setBit(TakerTraits.HAS_PRE_TRANSFER_IN_CALLBACK_BIT_FLAG, !this.preTransferInCallbackData.isEmpty());
-		flags = flags.setBit(TakerTraits.HAS_PRE_TRANSFER_OUT_CALLBACK_BIT_FLAG, !this.preTransferOutCallbackData.isEmpty());
+		flags = flags.setBit(TakerTraits.HAS_PRE_TRANSFER_IN_CALLBACK_BIT_FLAG, this.preTransferInCallbackEnabled || !this.preTransferInCallbackData.isEmpty());
+		flags = flags.setBit(TakerTraits.HAS_PRE_TRANSFER_OUT_CALLBACK_BIT_FLAG, this.preTransferOutCallbackEnabled || !this.preTransferOutCallbackData.isEmpty());
 		flags = flags.setBit(TakerTraits.IS_STRICT_THRESHOLD_BIT_FLAG, this.strictThreshold);
 		flags = flags.setBit(TakerTraits.IS_FIRST_TRANSFER_FROM_TAKER_BIT_FLAG, this.firstTransferFromTaker);
 		flags = flags.setBit(TakerTraits.USE_TRANSFER_FROM_AND_AQUA_PUSH_FLAG, this.useTransferFromAndAquaPush);
@@ -2024,11 +2024,159 @@ function mulDiv(a, b, c) {
 	return a * b / c;
 }
 
+//#endregion
+//#region src/swap-vm/instructions/concentrate/concentrate-liquidity-calculator/concentrate-liquidity-calculator.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).
+*
+* 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.
+*/
+var ConcentrateLiquidityCalculator = class ConcentrateLiquidityCalculator {
+	static ONE_E18 = 10n ** 18n;
+	constructor(tokenA, tokenB) {
+		this.tokenA = tokenA;
+		this.tokenB = tokenB;
+	}
+	/**
+	* Token with the smaller address (token0 in pool convention; "Lt" in the math).
+	*/
+	get token0() {
+		return this.tokenA.address.lt(this.tokenB.address) ? this.tokenA : this.tokenB;
+	}
+	/**
+	* Token with the larger address (token1 in pool convention; "Gt" in the math).
+	*/
+	get token1() {
+		return this.tokenA.address.lt(this.tokenB.address) ? this.tokenB : this.tokenA;
+	}
+	static new(data) {
+		return new ConcentrateLiquidityCalculator(data.tokenA, data.tokenB);
+	}
+	/**
+	* 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.
+	*/
+	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);
+		return {
+			sqrtPriceMin,
+			sqrtPriceSpot,
+			sqrtPriceMax,
+			token0Reserve: actualLt,
+			token1Reserve: actualGt
+		};
+	}
+	/**
+	* 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.
+	*/
+	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);
+		return {
+			sqrtPriceMin,
+			sqrtPriceSpot,
+			sqrtPriceMax,
+			token0Reserve: actualLt,
+			token1Reserve: actualGt
+		};
+	}
+	/**
+	* 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;
+	}
+	/**
+	* 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");
+	}
+	computeSqrtPriceBounds(scaledPriceBounds) {
+		const { minPriceRaw, maxPriceRaw } = this.computeRawPriceBounds(scaledPriceBounds);
+		return {
+			sqrtPriceMin: bigintSqrt(minPriceRaw * ConcentrateLiquidityCalculator.ONE_E18),
+			sqrtPriceMax: bigintSqrt(maxPriceRaw * ConcentrateLiquidityCalculator.ONE_E18)
+		};
+	}
+	/**
+	* 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");
+	}
+};
+
 //#endregion
 //#region src/swap-vm/instructions/concentrate/index.ts
 var concentrate_exports = {};
 __export(concentrate_exports, {
 	ConcentrateGrowLiquidity2DArgs: () => ConcentrateGrowLiquidity2DArgs,
+	ConcentrateLiquidityCalculator: () => ConcentrateLiquidityCalculator,
 	ONE_E18: () => ONE_E18,
 	bigintSqrt: () => bigintSqrt,
 	computeBalances: () => computeBalances,
@@ -4082,12 +4230,6 @@ exports.AquaAMMStrategy = AquaAMMStrategy;
 exports.AquaPeggedAmmStrategy = AquaPeggedAmmStrategy;
 exports.AquaProgramBuilder = AquaProgramBuilder;
 exports.AquaXYCAmmStrategy = AquaXYCAmmStrategy;
-Object.defineProperty(exports, 'CallInfo', {
-  enumerable: true,
-  get: function () {
-    return __1inch_sdk_core.CallInfo;
-  }
-});
 Object.defineProperty(exports, 'HexString', {
   enumerable: true,
   get: function () {

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { decodeAbiParameters, decodeEventLog, encodeAbiParameters, encodeFunctionData, hashTypedData, keccak256 } from "viem";
-import { Address, Address as Address$1, AddressHalf, CallInfo, HexString, HexString as HexString$1, Interaction, NetworkEnum, NetworkEnum as NetworkEnum$1 } from "@1inch/sdk-core";
+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";
 import { UINT_64_MAX as UINT_64_MAX$1 } from "@1inch/byte-utils/dist/constants";
@@ -706,18 +706,18 @@ var SwapVMContract = class SwapVMContract {
 * @see "../swap-vm/programs/aqua-program-builder"
 */
 const AQUA_SWAP_VM_CONTRACT_ADDRESSES = {
-	[NetworkEnum$1.ETHEREUM]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.BINANCE]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.POLYGON]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.ARBITRUM]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.AVALANCHE]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.GNOSIS]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.COINBASE]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.OPTIMISM]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.ZKSYNC]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.LINEA]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.UNICHAIN]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f"),
-	[NetworkEnum$1.SONIC]: new Address$1("0x8fdd04dbf6111437b44bbca99c28882434e0958f")
+	[NetworkEnum$1.ETHEREUM]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.BINANCE]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.POLYGON]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.ARBITRUM]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.AVALANCHE]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.GNOSIS]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.COINBASE]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.OPTIMISM]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.ZKSYNC]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.LINEA]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.UNICHAIN]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa"),
+	[NetworkEnum$1.SONIC]: new Address$1("0xdfd05fe230bfe7b212878414270c72c8345506fa")
 };
 
 //#endregion
@@ -1123,8 +1123,8 @@ var TakerTraits = class TakerTraits {
 		let flags = new BN(0n);
 		flags = flags.setBit(TakerTraits.IS_EXACT_IN_BIT_FLAG, this.exactIn);
 		flags = flags.setBit(TakerTraits.SHOULD_UNWRAP_BIT_FLAG, this.shouldUnwrap);
-		flags = flags.setBit(TakerTraits.HAS_PRE_TRANSFER_IN_CALLBACK_BIT_FLAG, !this.preTransferInCallbackData.isEmpty());
-		flags = flags.setBit(TakerTraits.HAS_PRE_TRANSFER_OUT_CALLBACK_BIT_FLAG, !this.preTransferOutCallbackData.isEmpty());
+		flags = flags.setBit(TakerTraits.HAS_PRE_TRANSFER_IN_CALLBACK_BIT_FLAG, this.preTransferInCallbackEnabled || !this.preTransferInCallbackData.isEmpty());
+		flags = flags.setBit(TakerTraits.HAS_PRE_TRANSFER_OUT_CALLBACK_BIT_FLAG, this.preTransferOutCallbackEnabled || !this.preTransferOutCallbackData.isEmpty());
 		flags = flags.setBit(TakerTraits.IS_STRICT_THRESHOLD_BIT_FLAG, this.strictThreshold);
 		flags = flags.setBit(TakerTraits.IS_FIRST_TRANSFER_FROM_TAKER_BIT_FLAG, this.firstTransferFromTaker);
 		flags = flags.setBit(TakerTraits.USE_TRANSFER_FROM_AND_AQUA_PUSH_FLAG, this.useTransferFromAndAquaPush);
@@ -2005,11 +2005,159 @@ function mulDiv(a, b, c) {
 	return a * b / c;
 }
 
+//#endregion
+//#region src/swap-vm/instructions/concentrate/concentrate-liquidity-calculator/concentrate-liquidity-calculator.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).
+*
+* 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.
+*/
+var ConcentrateLiquidityCalculator = class ConcentrateLiquidityCalculator {
+	static ONE_E18 = 10n ** 18n;
+	constructor(tokenA, tokenB) {
+		this.tokenA = tokenA;
+		this.tokenB = tokenB;
+	}
+	/**
+	* Token with the smaller address (token0 in pool convention; "Lt" in the math).
+	*/
+	get token0() {
+		return this.tokenA.address.lt(this.tokenB.address) ? this.tokenA : this.tokenB;
+	}
+	/**
+	* Token with the larger address (token1 in pool convention; "Gt" in the math).
+	*/
+	get token1() {
+		return this.tokenA.address.lt(this.tokenB.address) ? this.tokenB : this.tokenA;
+	}
+	static new(data) {
+		return new ConcentrateLiquidityCalculator(data.tokenA, data.tokenB);
+	}
+	/**
+	* 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.
+	*/
+	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);
+		return {
+			sqrtPriceMin,
+			sqrtPriceSpot,
+			sqrtPriceMax,
+			token0Reserve: actualLt,
+			token1Reserve: actualGt
+		};
+	}
+	/**
+	* 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.
+	*/
+	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);
+		return {
+			sqrtPriceMin,
+			sqrtPriceSpot,
+			sqrtPriceMax,
+			token0Reserve: actualLt,
+			token1Reserve: actualGt
+		};
+	}
+	/**
+	* 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;
+	}
+	/**
+	* 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");
+	}
+	computeSqrtPriceBounds(scaledPriceBounds) {
+		const { minPriceRaw, maxPriceRaw } = this.computeRawPriceBounds(scaledPriceBounds);
+		return {
+			sqrtPriceMin: bigintSqrt(minPriceRaw * ConcentrateLiquidityCalculator.ONE_E18),
+			sqrtPriceMax: bigintSqrt(maxPriceRaw * ConcentrateLiquidityCalculator.ONE_E18)
+		};
+	}
+	/**
+	* 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");
+	}
+};
+
 //#endregion
 //#region src/swap-vm/instructions/concentrate/index.ts
 var concentrate_exports = {};
 __export(concentrate_exports, {
 	ConcentrateGrowLiquidity2DArgs: () => ConcentrateGrowLiquidity2DArgs,
+	ConcentrateLiquidityCalculator: () => ConcentrateLiquidityCalculator,
 	ONE_E18: () => ONE_E18,
 	bigintSqrt: () => bigintSqrt,
 	computeBalances: () => computeBalances,
@@ -4046,4 +4194,4 @@ var abi_exports = {};
 __export(abi_exports, { SWAP_VM_ABI: () => SWAP_VM_ABI });
 
 //#endregion
-export { abi_exports as ABI, AQUA_SWAP_VM_CONTRACT_ADDRESSES, Address, AquaAMMStrategy, AquaPeggedAmmStrategy, AquaProgramBuilder, AquaXYCAmmStrategy, CallInfo, HexString, MakerTraits, NetworkEnum, Order, ProgramBuilder, RegularProgramBuilder, SwapVMContract, SwapVmProgram, SwappedEvent, TakerTraits, instructions_exports as instructions };
+export { abi_exports as ABI, AQUA_SWAP_VM_CONTRACT_ADDRESSES, Address, AquaAMMStrategy, AquaPeggedAmmStrategy, AquaProgramBuilder, AquaXYCAmmStrategy, HexString, MakerTraits, NetworkEnum, Order, ProgramBuilder, RegularProgramBuilder, SwapVMContract, SwapVmProgram, SwappedEvent, TakerTraits, instructions_exports as instructions };

package/dist/swap-vm/instructions/concentrate/concentrate-liquidity-calculator/concentrate-liquidity-calculator.d.mts

@@ -0,0 +1,61 @@
+import type { Address } from '@1inch/sdk-core';
+import type { ConcentratedLiquidityInfo, ConcentrateLiquidityCalculatorArgs, ConcentrateTokenInfo, ScaledPriceBounds, ScaledPrices } from './types';
+/**
+ * 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).
+ *
+ * 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.
+ */
+export declare class ConcentrateLiquidityCalculator {
+    private readonly tokenA;
+    private readonly tokenB;
+    static readonly ONE_E18: bigint;
+    constructor(tokenA: ConcentrateTokenInfo, tokenB: ConcentrateTokenInfo);
+    /**
+     * Token with the smaller address (token0 in pool convention; "Lt" in the math).
+     */
+    get token0(): ConcentrateTokenInfo;
+    /**
+     * Token with the larger address (token1 in pool convention; "Gt" in the math).
+     */
+    get token1(): ConcentrateTokenInfo;
+    static new(data: ConcentrateLiquidityCalculatorArgs): ConcentrateLiquidityCalculator;
+    /**
+     * 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.
+     */
+    computeFixedAllocation(scaledPrices: ScaledPrices, fixedReserveForToken: Address, fixedReserve: bigint): ConcentratedLiquidityInfo;
+    /**
+     * 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.
+     */
+    computeMaxAllocation(scaledPrices: ScaledPrices): ConcentratedLiquidityInfo;
+    /**
+     * 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: bigint, token1Balance: bigint, scaledPriceBounds: ScaledPriceBounds): bigint;
+    /**
+     * 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.
+     */
+    private computeRawPrices;
+    private computeSqrtPriceBounds;
+    /**
+     * Internal P = token1/token0 (1e18) from scaled min/max only (same mapping as {@link computeRawPrices}).
+     */
+    private computeRawPriceBounds;
+}

package/dist/swap-vm/instructions/concentrate/concentrate-liquidity-calculator/concentrate-liquidity-calculator.d.ts

@@ -0,0 +1,61 @@
+import type { Address } from '@1inch/sdk-core';
+import type { ConcentratedLiquidityInfo, ConcentrateLiquidityCalculatorArgs, ConcentrateTokenInfo, ScaledPriceBounds, ScaledPrices } from './types';
+/**
+ * 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).
+ *
+ * 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.
+ */
+export declare class ConcentrateLiquidityCalculator {
+    private readonly tokenA;
+    private readonly tokenB;
+    static readonly ONE_E18: bigint;
+    constructor(tokenA: ConcentrateTokenInfo, tokenB: ConcentrateTokenInfo);
+    /**
+     * Token with the smaller address (token0 in pool convention; "Lt" in the math).
+     */
+    get token0(): ConcentrateTokenInfo;
+    /**
+     * Token with the larger address (token1 in pool convention; "Gt" in the math).
+     */
+    get token1(): ConcentrateTokenInfo;
+    static new(data: ConcentrateLiquidityCalculatorArgs): ConcentrateLiquidityCalculator;
+    /**
+     * 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.
+     */
+    computeFixedAllocation(scaledPrices: ScaledPrices, fixedReserveForToken: Address, fixedReserve: bigint): ConcentratedLiquidityInfo;
+    /**
+     * 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.
+     */
+    computeMaxAllocation(scaledPrices: ScaledPrices): ConcentratedLiquidityInfo;
+    /**
+     * 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: bigint, token1Balance: bigint, scaledPriceBounds: ScaledPriceBounds): bigint;
+    /**
+     * 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.
+     */
+    private computeRawPrices;
+    private computeSqrtPriceBounds;
+    /**
+     * Internal P = token1/token0 (1e18) from scaled min/max only (same mapping as {@link computeRawPrices}).
+     */
+    private computeRawPriceBounds;
+}

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

@@ -18,6 +18,11 @@ export type ScaledPrices = {
     spotPriceRaw: bigint;
     maxPriceRaw: bigint;
 };
+/**
+ * Price range only (no spot): same scaling and quote convention as {@link ScaledPrices}.
+ * Used when deriving spot from balances and bounds.
+ */
+export type ScaledPriceBounds = Pick<ScaledPrices, 'quoteToken' | 'minPriceRaw' | 'maxPriceRaw'>;
 /**
  * Result of allocation: sqrt prices and the token0/token1 reserves
  * (raw amounts) to use for the concentrated liquidity position.

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

@@ -18,6 +18,11 @@ export type ScaledPrices = {
     spotPriceRaw: bigint;
     maxPriceRaw: bigint;
 };
+/**
+ * Price range only (no spot): same scaling and quote convention as {@link ScaledPrices}.
+ * Used when deriving spot from balances and bounds.
+ */
+export type ScaledPriceBounds = Pick<ScaledPrices, 'quoteToken' | 'minPriceRaw' | 'maxPriceRaw'>;
 /**
  * Result of allocation: sqrt prices and the token0/token1 reserves
  * (raw amounts) to use for the concentrated liquidity position.

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

@@ -1,5 +1,6 @@
 export * from './opcodes';
 export { ConcentrateGrowLiquidity2DArgs, ONE_E18 } from './concentrate-grow-liquidity-2d-args';
 export { computeLiquidityFromAmounts, computeBalances, computeLiquidityAndPrice, } from './concentrate-liquidity-math/concentrate-liquidity-math';
-export type { ConcentrateTokenInfo, ScaledPrices, ConcentratedLiquidityInfo, } from './concentrate-liquidity-calculator/types';
+export { ConcentrateLiquidityCalculator } from './concentrate-liquidity-calculator/concentrate-liquidity-calculator';
+export type { ConcentrateTokenInfo, ConcentrateLiquidityCalculatorArgs, ScaledPriceBounds, ScaledPrices, ConcentratedLiquidityInfo, } from './concentrate-liquidity-calculator/types';
 export * from './bigint-sqrt';

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

@@ -1,5 +1,6 @@
 export * from './opcodes';
 export { ConcentrateGrowLiquidity2DArgs, ONE_E18 } from './concentrate-grow-liquidity-2d-args';
 export { computeLiquidityFromAmounts, computeBalances, computeLiquidityAndPrice, } from './concentrate-liquidity-math/concentrate-liquidity-math';
-export type { ConcentrateTokenInfo, ScaledPrices, ConcentratedLiquidityInfo, } from './concentrate-liquidity-calculator/types';
+export { ConcentrateLiquidityCalculator } from './concentrate-liquidity-calculator/concentrate-liquidity-calculator';
+export type { ConcentrateTokenInfo, ConcentrateLiquidityCalculatorArgs, ScaledPriceBounds, ScaledPrices, ConcentratedLiquidityInfo, } from './concentrate-liquidity-calculator/types';
 export * from './bigint-sqrt';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1inch/swap-vm-sdk",
-  "version": "0.1.2-rc.3",
+  "version": "0.1.2-rc.5",
   "description": "1inch Swap VM SDK",
   "author": "@1inch",
   "license": "LicenseRef-Degensoft-SwapVM-1.1",