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

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { decodeAbiParameters, decodeEventLog, encodeAbiParameters, encodeFunctio
 import { Address, Address as Address$1, AddressHalf, CallInfo, 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 assert$1 from "node:assert";
+import { UINT_64_MAX as UINT_64_MAX$1 } from "@1inch/byte-utils/dist/constants";
 
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
@@ -329,6 +329,11 @@ const SWAP_VM_ABI = [
 				name: "amount",
 				type: "uint256",
 				internalType: "uint256"
+			},
+			{
+				name: "amountNetPulled",
+				type: "uint256",
+				internalType: "uint256"
 			}
 		]
 	},
@@ -396,6 +401,89 @@ const SWAP_VM_ABI = [
 			internalType: "uint256"
 		}]
 	},
+	{
+		type: "error",
+		name: "DeadlineReached",
+		inputs: [{
+			name: "taker",
+			type: "address",
+			internalType: "address"
+		}, {
+			name: "deadline",
+			type: "uint256",
+			internalType: "uint256"
+		}]
+	},
+	{
+		type: "error",
+		name: "TakerTokenBalanceIsZero",
+		inputs: [{
+			name: "taker",
+			type: "address",
+			internalType: "address"
+		}, {
+			name: "token",
+			type: "address",
+			internalType: "address"
+		}]
+	},
+	{
+		type: "error",
+		name: "TakerTokenBalanceIsLessThanRequired",
+		inputs: [
+			{
+				name: "taker",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "token",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "balance",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "minAmount",
+				type: "uint256",
+				internalType: "uint256"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "TakerTokenBalanceSupplyShareIsLessThanRequired",
+		inputs: [
+			{
+				name: "taker",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "token",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "balance",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "totalSupply",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "minShareE18",
+				type: "uint256",
+				internalType: "uint256"
+			}
+		]
+	},
 	{
 		type: "error",
 		name: "SafeTransferFromFailed",
@@ -497,6 +585,11 @@ const SWAP_VM_ABI = [
 			internalType: "uint256"
 		}]
 	},
+	{
+		type: "error",
+		name: "TakerTraitsDeadlineExpired",
+		inputs: []
+	},
 	{
 		type: "error",
 		name: "UnexpectedLock",
@@ -842,7 +935,7 @@ var MakerTraits = class MakerTraits {
 		traits = traits.setMask(MakerTraits.CUSTOM_RECEIVER_MASK, BigInt(this.customReceiver?.toString() || 0n));
 		const { data, offsets } = MakerTraits.HOOKS.reduce((acc, hookName, i) => {
 			const hook = this[hookName];
-			const hasTarget = this.hasTargetForHook(hookName);
+			const hasTarget = this.hasTargetForHook(hookName, maker);
 			const encoded = hook && hasTarget ? hook.encode() : hook?.data || HexString$1.EMPTY;
 			acc.sum += BigInt(encoded.bytesCount());
 			acc.offsets += acc.sum << 16n * BigInt(i);
@@ -889,7 +982,7 @@ var TakerTraits = class TakerTraits {
 	static IS_STRICT_THRESHOLD_BIT_FLAG = 4n;
 	static IS_FIRST_TRANSFER_FROM_TAKER_BIT_FLAG = 5n;
 	static USE_TRANSFER_FROM_AND_AQUA_PUSH_FLAG = 6n;
-	constructor(exactIn, shouldUnwrap, preTransferInCallbackEnabled, preTransferOutCallbackEnabled, strictThreshold, firstTransferFromTaker, useTransferFromAndAquaPush, threshold = 0n, customReceiver = Address$1.ZERO_ADDRESS, preTransferInHookData = HexString$1.EMPTY, postTransferInHookData = HexString$1.EMPTY, preTransferOutHookData = HexString$1.EMPTY, postTransferOutHookData = HexString$1.EMPTY, preTransferInCallbackData = HexString$1.EMPTY, preTransferOutCallbackData = HexString$1.EMPTY, instructionsArgs = HexString$1.EMPTY, signature = HexString$1.EMPTY) {
+	constructor(exactIn, shouldUnwrap, preTransferInCallbackEnabled, preTransferOutCallbackEnabled, strictThreshold, firstTransferFromTaker, useTransferFromAndAquaPush, threshold = 0n, customReceiver = Address$1.ZERO_ADDRESS, deadline$1 = 0n, preTransferInHookData = HexString$1.EMPTY, postTransferInHookData = HexString$1.EMPTY, preTransferOutHookData = HexString$1.EMPTY, postTransferOutHookData = HexString$1.EMPTY, preTransferInCallbackData = HexString$1.EMPTY, preTransferOutCallbackData = HexString$1.EMPTY, instructionsArgs = HexString$1.EMPTY, signature = HexString$1.EMPTY) {
 		this.exactIn = exactIn;
 		this.shouldUnwrap = shouldUnwrap;
 		this.preTransferInCallbackEnabled = preTransferInCallbackEnabled;
@@ -899,6 +992,7 @@ var TakerTraits = class TakerTraits {
 		this.useTransferFromAndAquaPush = useTransferFromAndAquaPush;
 		this.threshold = threshold;
 		this.customReceiver = customReceiver;
+		this.deadline = deadline$1;
 		this.preTransferInHookData = preTransferInHookData;
 		this.postTransferInHookData = postTransferInHookData;
 		this.preTransferOutHookData = preTransferOutHookData;
@@ -913,7 +1007,7 @@ var TakerTraits = class TakerTraits {
 	* Provides default values for unspecified fields.
 	*/
 	static new(data = {}) {
-		return new TakerTraits(data.exactIn ?? true, data.shouldUnwrap ?? false, data.preTransferInCallbackEnabled ?? false, data.preTransferOutCallbackEnabled ?? false, data.strictThreshold ?? false, data.firstTransferFromTaker ?? false, data.useTransferFromAndAquaPush ?? true, data.threshold, data.customReceiver, data.preTransferInHookData, data.postTransferInHookData, data.preTransferOutHookData, data.postTransferOutHookData, data.preTransferInCallbackData, data.preTransferOutCallbackData, data.instructionsArgs, data.signature);
+		return new TakerTraits(data.exactIn ?? true, data.shouldUnwrap ?? false, data.preTransferInCallbackEnabled ?? false, data.preTransferOutCallbackEnabled ?? false, data.strictThreshold ?? false, data.firstTransferFromTaker ?? false, data.useTransferFromAndAquaPush ?? true, data.threshold, data.customReceiver, data.deadline, data.preTransferInHookData, data.postTransferInHookData, data.preTransferOutHookData, data.postTransferOutHookData, data.preTransferInCallbackData, data.preTransferOutCallbackData, data.instructionsArgs, data.signature);
 	}
 	/**
 	* Creates a default TakerTraits instance with standard settings.
@@ -933,6 +1027,7 @@ var TakerTraits = class TakerTraits {
 			firstTransferFromTaker: false,
 			useTransferFromAndAquaPush: true,
 			threshold: 0n,
+			deadline: 0n,
 			customReceiver: Address$1.ZERO_ADDRESS,
 			preTransferInHookData: HexString$1.EMPTY,
 			postTransferInHookData: HexString$1.EMPTY,
@@ -947,16 +1042,16 @@ var TakerTraits = class TakerTraits {
 	/**
 	* Decodes a packed TakerTraits from a hex string.
 	* The packed format consists of:
-	* - 18 bytes: 9 uint16 offsets for data sections
+	* - 20 bytes: 10 uint16 offsets for data sections
 	* - 2 bytes: uint16 flags
-	* - Variable: data sections (threshold, to, hook data, callback data, etc.)
+	* - Variable: data sections (threshold, to, deadline, hook data, callback data, etc.)
 	* - Variable: signature
 	*/
 	static decode(packed) {
 		const iter = BytesIter.BigInt(packed.toString());
-		const offsets = Array.from({ length: 9 }, () => Number(iter.nextUint16())).reverse();
+		const offsets = Array.from({ length: 10 }, () => Number(iter.nextUint16())).reverse();
 		const flags = new BN(iter.nextUint16());
-		const dataStr = trim0x(packed.toString()).slice(40);
+		const dataStr = trim0x(packed.toString()).slice(44);
 		const sections = [];
 		offsets.forEach((offset, i) => {
 			const start = i === 0 ? 0 : offsets[i - 1];
@@ -964,7 +1059,7 @@ var TakerTraits = class TakerTraits {
 		});
 		const lastOffset = offsets[offsets.length - 1];
 		const signature = dataStr.length > lastOffset * 2 ? dataStr.slice(lastOffset * 2) : "";
-		const [threshold, to, preTransferInHookData, postTransferInHookData, preTransferOutHookData, postTransferOutHookData, preTransferInCallbackData, preTransferOutCallbackData, instructionsArgs] = sections;
+		const [threshold, to, deadline$1, preTransferInHookData, postTransferInHookData, preTransferOutHookData, postTransferOutHookData, preTransferInCallbackData, preTransferOutCallbackData, instructionsArgs] = sections;
 		return TakerTraits.new({
 			exactIn: Boolean(flags.getBit(TakerTraits.IS_EXACT_IN_BIT_FLAG)),
 			shouldUnwrap: Boolean(flags.getBit(TakerTraits.SHOULD_UNWRAP_BIT_FLAG)),
@@ -975,6 +1070,7 @@ var TakerTraits = class TakerTraits {
 			useTransferFromAndAquaPush: Boolean(flags.getBit(TakerTraits.USE_TRANSFER_FROM_AND_AQUA_PUSH_FLAG)),
 			threshold: threshold ? BigInt(add0x(threshold)) : 0n,
 			customReceiver: to ? new Address$1(add0x(to)) : Address$1.ZERO_ADDRESS,
+			deadline: deadline$1 ? BigInt(add0x(deadline$1)) : 0n,
 			preTransferInHookData: preTransferInHookData ? new HexString$1(add0x(preTransferInHookData)) : HexString$1.EMPTY,
 			postTransferInHookData: postTransferInHookData ? new HexString$1(add0x(postTransferInHookData)) : HexString$1.EMPTY,
 			preTransferOutHookData: preTransferOutHookData ? new HexString$1(add0x(preTransferOutHookData)) : HexString$1.EMPTY,
@@ -1003,6 +1099,7 @@ var TakerTraits = class TakerTraits {
 		const dataFields = [
 			this.threshold > 0n ? new HexString$1("0x" + this.threshold.toString(16).padStart(64, "0")) : HexString$1.EMPTY,
 			!this.customReceiver.isZero() ? new HexString$1(this.customReceiver.toString()) : HexString$1.EMPTY,
+			this.deadline > 0n ? new HexString$1("0x" + this.deadline.toString(16).padStart(10, "0")) : HexString$1.EMPTY,
 			this.preTransferInHookData,
 			this.postTransferInHookData,
 			this.preTransferOutHookData,
@@ -1272,7 +1369,7 @@ var JumpArgs = class JumpArgs {
 	static CODER = new JumpArgsCoder();
 	constructor(nextPC) {
 		this.nextPC = nextPC;
-		assert$1(nextPC <= UINT_16_MAX$1 && nextPC >= 0n, `Invalid nextPC value: ${nextPC}. Must be between 0 and 65535`);
+		assert(nextPC <= UINT_16_MAX$1 && nextPC >= 0n, `Invalid nextPC value: ${nextPC}. Must be between 0 and 65535`);
 	}
 	/**
 	* Decodes hex data into JumpArgs instance
@@ -1417,7 +1514,7 @@ var OnlyTakerTokenBalanceGteArgs = class OnlyTakerTokenBalanceGteArgs {
 	constructor(token, minAmount) {
 		this.token = token;
 		this.minAmount = minAmount;
-		assert$1(minAmount >= 0n, "minAmount must be non-negative");
+		assert(minAmount >= 0n, "minAmount must be non-negative");
 	}
 	/**
 	* Decodes hex data into OnlyTakerTokenBalanceGteArgs instance
@@ -1453,7 +1550,7 @@ var OnlyTakerTokenSupplyShareGteArgsCoder = class {
 
 //#endregion
 //#region src/swap-vm/instructions/controls/only-taker-token-supply-share-gte-args.ts
-const UINT_64_MAX$1 = 0xffffffffffffffffn;
+const UINT_64_MAX$2 = 0xffffffffffffffffn;
 /**
 * Arguments for checking if taker holds at least specified share of token's total supply
 * @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Controls.sol#L10
@@ -1463,7 +1560,7 @@ var OnlyTakerTokenSupplyShareGteArgs = class OnlyTakerTokenSupplyShareGteArgs {
 	constructor(token, minShareE18) {
 		this.token = token;
 		this.minShareE18 = minShareE18;
-		assert$1(minShareE18 >= 0n && minShareE18 <= UINT_64_MAX$1, `Invalid minShareE18 value: ${minShareE18}. Must be a valid uint64`);
+		assert(minShareE18 >= 0n && minShareE18 <= UINT_64_MAX$2, `Invalid minShareE18 value: ${minShareE18}. Must be a valid uint64`);
 	}
 	/**
 	* Decodes hex data into OnlyTakerTokenSupplyShareGteArgs instance
@@ -1504,7 +1601,7 @@ var SaltArgs = class SaltArgs {
 	static CODER = new SaltArgsCoder();
 	constructor(salt$1) {
 		this.salt = salt$1;
-		assert$1(salt$1 >= 0n && salt$1 <= UINT_64_MAX, `Invalid salt value: ${salt$1}. Must be a valid uint64`);
+		assert(salt$1 >= 0n && salt$1 <= UINT_64_MAX, `Invalid salt value: ${salt$1}. Must be a valid uint64`);
 	}
 	/**
 	* Decodes hex data into SaltArgs instance
@@ -1594,7 +1691,7 @@ var InvalidateBit1DArgs = class InvalidateBit1DArgs {
 	static CODER = new InvalidateBit1DArgsCoder();
 	constructor(bitIndex) {
 		this.bitIndex = bitIndex;
-		assert$1(bitIndex >= 0n && bitIndex <= UINT_32_MAX, `Invalid bitIndex value: ${bitIndex}. Must be a valid uint32`);
+		assert(bitIndex >= 0n && bitIndex <= UINT_32_MAX, `Invalid bitIndex value: ${bitIndex}. Must be a valid uint32`);
 	}
 	/**
 	* Decodes hex data into InvalidateBit1DArgs instance
@@ -1732,100 +1829,71 @@ __export(xyc_swap_exports, {
 	xycSwapXD: () => xycSwapXD
 });
 
-//#endregion
-//#region src/swap-vm/instructions/concentrate/concentrate-grow-liquidity-xd-args-coder.ts
-var ConcentrateGrowLiquidityXDArgsCoder = class {
-	encode(args) {
-		const builder = new BytesBuilder();
-		builder.addUint16(BigInt(args.tokenDeltas.length));
-		for (const { tokenHalf } of args.tokenDeltas) builder.addBytes(tokenHalf.toString());
-		for (const { delta } of args.tokenDeltas) builder.addUint256(delta);
-		return new HexString$1(builder.asHex());
-	}
-	decode(data) {
-		const iter = BytesIter.HexString(data.toString());
-		const tokenCount = Number(iter.nextUint16());
-		const tokenHalves = [];
-		for (let i = 0; i < tokenCount; i++) {
-			const bytes = iter.nextBytes(10);
-			tokenHalves.push(AddressHalf.fromHex(bytes));
-		}
-		const tokenDeltas = [];
-		for (let i = 0; i < tokenCount; i++) tokenDeltas.push({
-			tokenHalf: tokenHalves[i],
-			delta: BigInt(iter.nextUint256())
-		});
-		return new ConcentrateGrowLiquidityXDArgs(tokenDeltas);
-	}
-};
-
-//#endregion
-//#region src/swap-vm/instructions/concentrate/concentrate-grow-liquidity-xd-args.ts
-/**
-* Arguments for concentrateGrowLiquidityXD instruction with multiple token deltas
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/XYCConcentrate.sol#L139
-**/
-var ConcentrateGrowLiquidityXDArgs = class ConcentrateGrowLiquidityXDArgs {
-	static CODER = new ConcentrateGrowLiquidityXDArgsCoder();
-	constructor(tokenDeltas) {
-		this.tokenDeltas = tokenDeltas;
-		tokenDeltas.forEach((td, index) => {
-			assert$1(td.delta >= 0n && td.delta <= UINT_256_MAX, `Invalid delta at index ${index}: ${td.delta}. Must be >= 0 and <= UINT_256_MAX`);
-		});
-	}
-	/**
-	* Decodes hex data into ConcentrateGrowLiquidityXDArgs instance
-	**/
-	static decode(data) {
-		return ConcentrateGrowLiquidityXDArgs.CODER.decode(data);
-	}
-	toJSON() {
-		return { tokenDeltas: this.tokenDeltas.map(({ tokenHalf, delta }) => ({
-			token: tokenHalf.toString(),
-			delta: delta.toString()
-		})) };
-	}
-};
-
 //#endregion
 //#region src/swap-vm/instructions/concentrate/concentrate-grow-liquidity-2d-args-coder.ts
 var ConcentrateGrowLiquidity2DArgsCoder = class {
 	encode(args) {
 		const builder = new BytesBuilder();
-		builder.addUint256(args.deltaLt);
-		builder.addUint256(args.deltaGt);
+		builder.addUint256(args.sqrtPriceMin);
+		builder.addUint256(args.sqrtPriceMax);
 		return new HexString$1(builder.asHex());
 	}
 	decode(data) {
 		const iter = BytesIter.BigInt(data.toString());
-		const deltaLt = iter.nextUint256();
-		const deltaGt = iter.nextUint256();
-		return new ConcentrateGrowLiquidity2DArgs(deltaLt, deltaGt);
+		const sqrtPriceMin = iter.nextUint256();
+		const sqrtPriceMax = iter.nextUint256();
+		return new ConcentrateGrowLiquidity2DArgs(sqrtPriceMin, sqrtPriceMax);
 	}
 };
 
+//#endregion
+//#region src/swap-vm/instructions/concentrate/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;
+	if (value <= 9007199254740991n) return BigInt(Math.floor(Math.sqrt(Number(value))));
+	let x0 = value;
+	let x1 = value / x0 + x0 >> 1n;
+	while (x1 < x0) {
+		x0 = x1;
+		x1 = value / x0 + x0 >> 1n;
+	}
+	return x0;
+}
+
 //#endregion
 //#region src/swap-vm/instructions/concentrate/concentrate-grow-liquidity-2d-args.ts
+const ONE_E18 = 10n ** 18n;
 /**
-* Arguments for concentrateGrowLiquidity2D instruction with two deltas
+* Arguments for concentrateGrowLiquidity2D instruction
+* Contract encodes sqrtPriceMin and sqrtPriceMax (2 × uint256, 64 bytes)
+* P = tokenGt/tokenLt; sqrt(P) in 1e18 fixed-point
 * @see https://github.com/1inch/swap-vm/blob/main/src/instructions/XYCConcentrate.sol#L172
 **/
 var ConcentrateGrowLiquidity2DArgs = class ConcentrateGrowLiquidity2DArgs {
 	static CODER = new ConcentrateGrowLiquidity2DArgsCoder();
-	constructor(deltaLt, deltaGt) {
-		this.deltaLt = deltaLt;
-		this.deltaGt = deltaGt;
-		assert$1(deltaLt >= 0n && deltaLt <= UINT_256_MAX, `Invalid deltaLt: ${deltaLt}. Must be >= 0 and <= UINT_256_MAX`);
-		assert$1(deltaGt >= 0n && deltaGt <= UINT_256_MAX, `Invalid deltaGt: ${deltaGt}. Must be >= 0 and <= UINT_256_MAX`);
+	constructor(sqrtPriceMin, sqrtPriceMax) {
+		this.sqrtPriceMin = sqrtPriceMin;
+		this.sqrtPriceMax = sqrtPriceMax;
+		assert(sqrtPriceMin > 0n && sqrtPriceMin <= UINT_256_MAX, `Invalid sqrtPriceMin: ${sqrtPriceMin}. Must be > 0 and <= UINT_256_MAX`);
+		assert(sqrtPriceMax > 0n && sqrtPriceMax <= UINT_256_MAX, `Invalid sqrtPriceMax: ${sqrtPriceMax}. Must be > 0 and <= UINT_256_MAX`);
+		assert(sqrtPriceMin < sqrtPriceMax, `Invalid bounds: sqrtPriceMin (${sqrtPriceMin}) must be < sqrtPriceMax (${sqrtPriceMax})`);
 	}
 	/**
-	* Helper to create args from token addresses and deltas (handles ordering)
+	* Build args from sqrt prices (1e18 fixed-point).
+	* sqrtPriceMin/Max = sqrt(P) where P = tokenGt/tokenLt.
 	**/
-	static fromTokenDeltas(tokenA, tokenB, deltaA, deltaB) {
-		const tokenABigInt = BigInt(tokenA.toString());
-		const tokenBBigInt = BigInt(tokenB.toString());
-		const [deltaLt, deltaGt] = tokenABigInt < tokenBBigInt ? [deltaA, deltaB] : [deltaB, deltaA];
-		return new ConcentrateGrowLiquidity2DArgs(deltaLt, deltaGt);
+	static fromSqrtPrices(sqrtPriceMin, sqrtPriceMax) {
+		return new ConcentrateGrowLiquidity2DArgs(sqrtPriceMin, sqrtPriceMax);
+	}
+	/**
+	* Build args from raw prices P_min, P_max (1e18 fixed-point).
+	* 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);
+		return new ConcentrateGrowLiquidity2DArgs(sqrtPriceMin, sqrtPriceMax);
 	}
 	/**
 	* Decodes hex data into ConcentrateGrowLiquidity2DArgs instance
@@ -1835,8 +1903,8 @@ var ConcentrateGrowLiquidity2DArgs = class ConcentrateGrowLiquidity2DArgs {
 	}
 	toJSON() {
 		return {
-			deltaLt: this.deltaLt.toString(),
-			deltaGt: this.deltaGt.toString()
+			sqrtPriceMin: this.sqrtPriceMin.toString(),
+			sqrtPriceMax: this.sqrtPriceMax.toString()
 		};
 	}
 };
@@ -1844,36 +1912,97 @@ var ConcentrateGrowLiquidity2DArgs = class ConcentrateGrowLiquidity2DArgs {
 //#endregion
 //#region src/swap-vm/instructions/concentrate/opcodes.ts
 /**
-* Concentrates liquidity within price bounds for multiple tokens
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/XYCConcentrate.sol#L139
-**/
-const concentrateGrowLiquidityXD = new Opcode(Symbol("XYCConcentrate.concentrateGrowLiquidityXD"), ConcentrateGrowLiquidityXDArgs.CODER);
-/**
 * Concentrates liquidity within price bounds for two tokens
 * @see https://github.com/1inch/swap-vm/blob/main/src/instructions/XYCConcentrate.sol#L172
 **/
 const concentrateGrowLiquidity2D = new Opcode(Symbol("XYCConcentrate.concentrateGrowLiquidity2D"), ConcentrateGrowLiquidity2DArgs.CODER);
 
 //#endregion
-//#region src/swap-vm/instructions/concentrate/utils.ts
-const TEN_POW_18 = 10n ** 18n;
-function computeDeltas(balanceA, balanceB, price, priceMin, priceMax) {
-	const sqrtMin = sqrt(price * TEN_POW_18 / priceMin);
-	const sqrtMax = sqrt(priceMax * TEN_POW_18 / price);
+//#region src/swap-vm/instructions/concentrate/concentrate-liquidity-math/concentrate-liquidity-math.ts
+const ONE = 10n ** 18n;
+/**
+* Compute max achievable L from available token amounts at a given spot price.
+* Takes the minimum of L implied by each token, then returns the resulting
+* targetL and the actual amounts (actualLt, actualGt) needed.
+*
+* Mirrors XYCConcentrateArgsBuilder.computeLiquidityFromAmounts in XYCConcentrate.sol.
+*
+* @param availableLt Available amount of token with lower address
+* @param availableGt Available amount of token with higher address
+* @param sqrtPspot sqrt(P_spot) in 1e18 fixed-point
+* @param sqrtPmin sqrt(P_min) in 1e18 fixed-point
+* @param sqrtPmax sqrt(P_max) in 1e18 fixed-point
+* @returns { targetL, actualLt, actualGt } max L and amounts actually needed (<= available)
+*/
+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 targetL = lFromLt < lFromGt ? lFromLt : lFromGt;
+	const { bLt: actualLt, bGt: actualGt } = computeBalances(targetL, sqrtPspot, sqrtPmin, sqrtPmax);
 	return {
-		deltaA: price == priceMin ? 0n : balanceA * TEN_POW_18 / (sqrtMin - TEN_POW_18),
-		deltaB: price == priceMax ? 0n : balanceB * TEN_POW_18 / (sqrtMax - TEN_POW_18)
+		targetL,
+		actualLt,
+		actualGt
 	};
 }
-function sqrt(value) {
-	if (value < 0n) throw "square root of negative numbers is not supported";
-	if (value < 2n) return value;
-	function newtonIteration(n, x0) {
-		const x1 = n / x0 + x0 >> 1n;
-		if (x0 === x1 || x0 === x1 - 1n) return x0;
-		return newtonIteration(n, x1);
-	}
-	return newtonIteration(value, 1n);
+/**
+* Compute the initial balances for given L, P_spot, P_min, P_max:
+*   bLt = L * (sqrtPmax - sqrtPspot) / (sqrtPmax * sqrtPspot / ONE)
+*   bGt = L * (sqrtPspot - sqrtPmin)
+*
+* Mirrors XYCConcentrateArgsBuilder.computeBalances in XYCConcentrate.sol.
+*
+* @param targetL Liquidity L (1e18 scale implied by ONE)
+* @param sqrtPspot sqrt(P_spot) in 1e18 fixed-point
+* @param sqrtPmin sqrt(P_min) in 1e18 fixed-point
+* @param sqrtPmax sqrt(P_max) in 1e18 fixed-point
+* @returns { bLt, bGt } amounts of tokenLt and tokenGt for the given L and prices
+*/
+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;
+	return {
+		bLt,
+		bGt
+	};
+}
+/**
+* Compute the implied spot price and liquidity from real balances and price bounds.
+*
+* Mirrors XYCConcentrateArgsBuilder.computeLiquidityAndPrice in XYCConcentrate.sol.
+*
+* @param balanceLt Real balance of the token with lower address
+* @param balanceGt Real balance of the token with higher address
+* @param sqrtPriceMin sqrt(P_min) in 1e18 fixed-point
+* @param sqrtPriceMax sqrt(P_max) in 1e18 fixed-point
+* @returns { liquidity, sqrtPriceSpot } L and implied sqrt(P_spot) in 1e18 fixed-point
+*/
+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));
+	return {
+		liquidity,
+		sqrtPriceSpot
+	};
+}
+/**
+* Compute L from real balances and price bounds.
+* 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 disc = beta * beta + fourAC;
+	return mulDiv(beta + bigintSqrt(disc), ONE, 2n * alpha);
+}
+function mulDiv(a, b, c) {
+	if (c === 0n) throw new Error("mulDiv: division by zero");
+	return a * b / c;
 }
 
 //#endregion
@@ -1881,10 +2010,12 @@ function sqrt(value) {
 var concentrate_exports = {};
 __export(concentrate_exports, {
 	ConcentrateGrowLiquidity2DArgs: () => ConcentrateGrowLiquidity2DArgs,
-	ConcentrateGrowLiquidityXDArgs: () => ConcentrateGrowLiquidityXDArgs,
-	computeDeltas: () => computeDeltas,
-	concentrateGrowLiquidity2D: () => concentrateGrowLiquidity2D,
-	concentrateGrowLiquidityXD: () => concentrateGrowLiquidityXD
+	ONE_E18: () => ONE_E18,
+	bigintSqrt: () => bigintSqrt,
+	computeBalances: () => computeBalances,
+	computeLiquidityAndPrice: () => computeLiquidityAndPrice,
+	computeLiquidityFromAmounts: () => computeLiquidityFromAmounts,
+	concentrateGrowLiquidity2D: () => concentrateGrowLiquidity2D
 });
 
 //#endregion
@@ -1912,7 +2043,7 @@ var DecayXDArgs = class DecayXDArgs {
 	static CODER = new DecayXDArgsCoder();
 	constructor(decayPeriod) {
 		this.decayPeriod = decayPeriod;
-		assert$1(decayPeriod >= 0n && decayPeriod <= UINT_16_MAX, `Invalid decayPeriod value: ${decayPeriod}. Must be a valid uint16`);
+		assert(decayPeriod >= 0n && decayPeriod <= UINT_16_MAX, `Invalid decayPeriod value: ${decayPeriod}. Must be a valid uint16`);
 	}
 	/**
 	* Decodes hex data into DecayXDArgs instance
@@ -2035,8 +2166,8 @@ var MinRateArgs = class MinRateArgs {
 	constructor(rateLt, rateGt) {
 		this.rateLt = rateLt;
 		this.rateGt = rateGt;
-		assert$1(rateLt >= 0n && rateLt <= UINT_64_MAX, `Invalid rateLt: ${rateLt}. Must be a valid uint64`);
-		assert$1(rateGt >= 0n && rateGt <= UINT_64_MAX, `Invalid rateGt: ${rateGt}. Must be a valid uint64`);
+		assert(rateLt >= 0n && rateLt <= UINT_64_MAX, `Invalid rateLt: ${rateLt}. Must be a valid uint64`);
+		assert(rateGt >= 0n && rateGt <= UINT_64_MAX, `Invalid rateGt: ${rateGt}. Must be a valid uint64`);
 	}
 	static fromTokens(tokenA, tokenB, rateA, rateB) {
 		if (BigInt(tokenA.toString()) < BigInt(tokenB.toString())) return new MinRateArgs(rateA, rateB);
@@ -2085,14 +2216,14 @@ var DutchAuctionArgsCoder = class {
 		const builder = new BytesBuilder();
 		builder.addUint40(args.startTime);
 		builder.addUint16(args.duration);
-		builder.addUint32(args.decayFactor);
+		builder.addUint64(args.decayFactor);
 		return new HexString$1(add0x(builder.asHex()));
 	}
 	decode(data) {
 		const iter = BytesIter.BigInt(data.toString());
 		const startTime = iter.nextUint40();
 		const duration = iter.nextUint16();
-		const decayFactor = iter.nextUint32();
+		const decayFactor = iter.nextUint64();
 		return new DutchAuctionArgs(startTime, duration, decayFactor);
 	}
 };
@@ -2110,7 +2241,6 @@ var DutchAuctionArgsCoder = class {
 * - Only works for 1=>0 swaps (token1 to token0)
 *
 * The decay factor determines the price reduction rate:
-* - 1.0e18 = no decay (constant price)
 * - 0.999e18 = 0.1% decay per second
 * - 0.99e18 = 1% decay per second
 * - 0.9e18 = 10% decay per second
@@ -2129,16 +2259,16 @@ var DutchAuctionArgs = class DutchAuctionArgs {
 	/**
 	* startTime - auction start time (uint40)
 	* duration - auction duration in seconds (uint16)
-	* decayFactor - price decay per second, 1e18 = no decay (uint32)
+	* decayFactor - price decay per second, 1e18 = no decay (uint64)
 	**/
 	constructor(startTime, duration, decayFactor) {
 		this.startTime = startTime;
 		this.duration = duration;
 		this.decayFactor = decayFactor;
-		assert$1(startTime >= 0n && startTime <= UINT_40_MAX, `Invalid startTime: ${startTime}. Must be a valid uint40`);
-		assert$1(duration >= 0n && duration <= UINT_16_MAX, `Invalid duration: ${duration}. Must be a valid uint16`);
-		assert$1(decayFactor >= 0n && decayFactor <= UINT_32_MAX, `Invalid decayFactor: ${decayFactor}. Must be a valid uint32`);
-		assert$1(decayFactor < 1e18, `Decay factor should be less than 1e18: ${decayFactor}`);
+		assert(startTime >= 0n && startTime <= UINT_40_MAX, `Invalid startTime: ${startTime}. Must be a valid uint40`);
+		assert(duration >= 0n && duration <= UINT_16_MAX, `Invalid duration: ${duration}. Must be a valid uint16`);
+		assert(decayFactor >= 0n && decayFactor <= UINT_64_MAX$1, `Invalid decayFactor: ${decayFactor}. Must be a valid uint64`);
+		assert(decayFactor < 1e18, `Decay factor should be less than 1e18: ${decayFactor}`);
 	}
 	/**
 	* Decodes hex data into DutchAuctionArgs instance
@@ -2177,99 +2307,6 @@ __export(dutch_auction_exports, {
 	dutchAuctionBalanceOut1D: () => dutchAuctionBalanceOut1D
 });
 
-//#endregion
-//#region src/swap-vm/instructions/oracle-price-adjuster/oracle-price-adjuster-args-coder.ts
-var OraclePriceAdjusterArgsCoder = class {
-	encode(args) {
-		const builder = new BytesBuilder();
-		builder.addUint64(args.maxPriceDecay);
-		builder.addUint16(args.maxStaleness);
-		builder.addUint8(args.oracleDecimals);
-		builder.addAddress(args.oracleAddress.toString());
-		return new HexString$1(builder.asHex());
-	}
-	decode(data) {
-		const iter = BytesIter.HexString(data.toString());
-		const maxPriceDecay = iter.nextUint64();
-		const maxStaleness = iter.nextUint16();
-		const oracleDecimals = iter.nextUint8();
-		const oracleAddress = new Address$1(iter.nextAddress());
-		return new OraclePriceAdjusterArgs(BigInt(maxPriceDecay), BigInt(maxStaleness), BigInt(oracleDecimals), oracleAddress);
-	}
-};
-
-//#endregion
-//#region src/swap-vm/instructions/oracle-price-adjuster/oracle-price-adjuster-args.ts
-/**
-* @notice Oracle Price Adjuster instruction for dynamic price adjustment based on Chainlink price feeds
-* @dev Adjusts swap prices to match Chainlink oracle prices within safe bounds:
-* - Works only for 1=>0 swaps (token1 to token0), compatible with LimitSwap and other swap instructions
-* - Fetches current market price from a Chainlink oracle (AggregatorV3Interface)
-* - Adjusts the swap price towards the oracle price within maxPriceDecay limits
-* - Ensures the adjustment is always favorable for the taker
-* - Handles different decimal places from Chainlink oracles (e.g., 8 decimals for USD prices)
-*
-* This creates adaptive orders that automatically track market prices while maintaining
-* safety bounds to prevent excessive slippage or manipulation.
-*
-* Example usage:
-* 1. LimitSwap sets base price: 1 ETH for 3000 USDC
-* 2. OraclePriceAdjuster with Chainlink ETH/USD oracle: 1 ETH = 3100 USD, maxPriceDecay=0.95e18 (5% max)
-* 3. exactIn: Taker gets more ETH (up to 5% improvement)
-* 4. exactOut: Taker pays less USDC (up to 5% discount)
-*
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/OraclePriceAdjuster.sol#L84
-*/
-var OraclePriceAdjusterArgs = class OraclePriceAdjusterArgs {
-	static CODER = new OraclePriceAdjusterArgsCoder();
-	/**
-	* maxPriceDecay - maximum price decay coefficient (uint64)
-	* maxStaleness - maximum allowed oracle data staleness in seconds (uint16
-	* oracleDecimals - decimals used by the oracle (uint8)
-	* oracleAddress - address of the Chainlink price oracle contract
-	**/
-	constructor(maxPriceDecay, maxStaleness, oracleDecimals, oracleAddress) {
-		this.maxPriceDecay = maxPriceDecay;
-		this.maxStaleness = maxStaleness;
-		this.oracleDecimals = oracleDecimals;
-		this.oracleAddress = oracleAddress;
-		assert$1(maxPriceDecay >= 0n && maxPriceDecay <= UINT_64_MAX, `Invalid maxPriceDecay: ${maxPriceDecay}. Must be a valid uint64`);
-		assert$1(maxPriceDecay < 1e18, `Max price decay should be less than 1e18: ${maxPriceDecay}`);
-		assert$1(maxStaleness >= 0n && maxStaleness <= UINT_16_MAX, `Invalid maxStaleness: ${maxStaleness}. Must be a valid uint16`);
-		assert$1(oracleDecimals >= 0n && oracleDecimals <= UINT_8_MAX, `Invalid oracleDecimals: ${oracleDecimals}. Must be a valid uint8`);
-	}
-	/**
-	* Decodes hex data into OraclePriceAdjusterArgs instance
-	**/
-	static decode(data) {
-		return OraclePriceAdjusterArgs.CODER.decode(data);
-	}
-	toJSON() {
-		return {
-			maxPriceDecay: this.maxPriceDecay.toString(),
-			maxStaleness: this.maxStaleness.toString(),
-			oracleDecimals: this.oracleDecimals.toString(),
-			oracleAddress: this.oracleAddress.toString()
-		};
-	}
-};
-
-//#endregion
-//#region src/swap-vm/instructions/oracle-price-adjuster/opcodes.ts
-/**
-* Adjusts swap prices based on Chainlink oracle feeds
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/OraclePriceAdjuster.sol#L84
-**/
-const oraclePriceAdjuster1D = new Opcode(Symbol("OraclePriceAdjuster.oraclePriceAdjuster1D"), OraclePriceAdjusterArgs.CODER);
-
-//#endregion
-//#region src/swap-vm/instructions/oracle-price-adjuster/index.ts
-var oracle_price_adjuster_exports = {};
-__export(oracle_price_adjuster_exports, {
-	OraclePriceAdjusterArgs: () => OraclePriceAdjusterArgs,
-	oraclePriceAdjuster1D: () => oraclePriceAdjuster1D
-});
-
 //#endregion
 //#region src/swap-vm/instructions/base-fee-adjuster/base-fee-adjuster-args-coder.ts
 var BaseFeeAdjusterArgsCoder = class {
@@ -2325,10 +2362,10 @@ var BaseFeeAdjusterArgs = class BaseFeeAdjusterArgs {
 		this.ethToToken1Price = ethToToken1Price;
 		this.gasAmount = gasAmount;
 		this.maxPriceDecay = maxPriceDecay;
-		assert$1(baseGasPrice >= 0n && baseGasPrice <= UINT_64_MAX, `Invalid baseGasPrice: ${baseGasPrice}. Must be a valid uint64`);
-		assert$1(ethToToken1Price >= 0n && ethToToken1Price <= UINT_96_MAX, `Invalid ethToToken1Price: ${ethToToken1Price}. Must be a valid uint96`);
-		assert$1(gasAmount >= 0n && gasAmount <= UINT_24_MAX, `Invalid gasAmount: ${gasAmount}. Must be a valid uint24`);
-		assert$1(maxPriceDecay >= 0n && maxPriceDecay <= UINT_64_MAX, `Invalid maxPriceDecay: ${maxPriceDecay}. Must be a valid uint64`);
+		assert(baseGasPrice >= 0n && baseGasPrice <= UINT_64_MAX, `Invalid baseGasPrice: ${baseGasPrice}. Must be a valid uint64`);
+		assert(ethToToken1Price >= 0n && ethToToken1Price <= UINT_96_MAX, `Invalid ethToToken1Price: ${ethToToken1Price}. Must be a valid uint96`);
+		assert(gasAmount >= 0n && gasAmount <= UINT_24_MAX, `Invalid gasAmount: ${gasAmount}. Must be a valid uint24`);
+		assert(maxPriceDecay >= 0n && maxPriceDecay <= UINT_64_MAX, `Invalid maxPriceDecay: ${maxPriceDecay}. Must be a valid uint64`);
 	}
 	/**
 	* Decodes hex data into BaseFeeAdjusterArgs instance
@@ -2452,12 +2489,12 @@ var TWAPSwapArgs = class TWAPSwapArgs {
 		this.duration = duration;
 		this.priceBumpAfterIlliquidity = priceBumpAfterIlliquidity;
 		this.minTradeAmountOut = minTradeAmountOut;
-		assert$1(balanceIn >= 0n && balanceIn <= UINT_256_MAX, `Invalid balanceIn: ${balanceIn}. Must be >= 0 and <= UINT_256_MAX`);
-		assert$1(balanceOut >= 0n && balanceOut <= UINT_256_MAX, `Invalid balanceOut: ${balanceOut}. Must be >= 0 and <= UINT_256_MAX`);
-		assert$1(startTime >= 0n && startTime <= UINT_256_MAX, `Invalid startTime: ${startTime}. Must be >= 0 and <= UINT_256_MAX`);
-		assert$1(duration >= 0n && duration <= UINT_256_MAX, `Invalid duration: ${duration}. Must be >= 0 and <= UINT_256_MAX`);
-		assert$1(priceBumpAfterIlliquidity >= 0n && priceBumpAfterIlliquidity <= UINT_256_MAX, `Invalid priceBumpAfterIlliquidity: ${priceBumpAfterIlliquidity}. Must be >= 0 and <= UINT_256_MAX`);
-		assert$1(minTradeAmountOut >= 0n && minTradeAmountOut <= UINT_256_MAX, `Invalid minTradeAmountOut: ${minTradeAmountOut}. Must be >= 0 and <= UINT_256_MAX`);
+		assert(balanceIn >= 0n && balanceIn <= UINT_256_MAX, `Invalid balanceIn: ${balanceIn}. Must be >= 0 and <= UINT_256_MAX`);
+		assert(balanceOut >= 0n && balanceOut <= UINT_256_MAX, `Invalid balanceOut: ${balanceOut}. Must be >= 0 and <= UINT_256_MAX`);
+		assert(startTime >= 0n && startTime <= UINT_256_MAX, `Invalid startTime: ${startTime}. Must be >= 0 and <= UINT_256_MAX`);
+		assert(duration >= 0n && duration <= UINT_256_MAX, `Invalid duration: ${duration}. Must be >= 0 and <= UINT_256_MAX`);
+		assert(priceBumpAfterIlliquidity >= 0n && priceBumpAfterIlliquidity <= UINT_256_MAX, `Invalid priceBumpAfterIlliquidity: ${priceBumpAfterIlliquidity}. Must be >= 0 and <= UINT_256_MAX`);
+		assert(minTradeAmountOut >= 0n && minTradeAmountOut <= UINT_256_MAX, `Invalid minTradeAmountOut: ${minTradeAmountOut}. Must be >= 0 and <= UINT_256_MAX`);
 	}
 	/**
 	* Decodes hex data into TWAPSwapArgs instance
@@ -2494,7 +2531,7 @@ __export(twap_swap_exports, {
 });
 
 //#endregion
-//#region src/swap-vm/instructions/fee/flat-fee-args-coder.ts
+//#region src/swap-vm/instructions/fee/flat-fee/flat-fee-args-coder.ts
 var FlatFeeArgsCoder = class {
 	encode(args) {
 		const builder = new BytesBuilder();
@@ -2509,18 +2546,18 @@ var FlatFeeArgsCoder = class {
 };
 
 //#endregion
-//#region src/swap-vm/instructions/fee/flat-fee-args.ts
+//#region src/swap-vm/instructions/fee/flat-fee/flat-fee-args.ts
 const FEE_100_PERCENT$1 = 1e9;
 /**
-* Arguments for flat fee instructions (flatFeeXD, flatFeeAmountInXD, flatFeeAmountOutXD, progressiveFeeXD)
+* Arguments for flat fee instructions (flatFeeAmountInXD)
 * @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L66
 **/
 var FlatFeeArgs = class FlatFeeArgs {
 	static CODER = new FlatFeeArgsCoder();
 	constructor(fee) {
 		this.fee = fee;
-		assert$1(fee >= 0n && fee <= UINT_32_MAX, `Invalid fee: ${fee}. Must be a valid uint32`);
-		assert$1(fee <= BigInt(FEE_100_PERCENT$1), `Fee out of range: ${fee}. Must be <= ${FEE_100_PERCENT$1}`);
+		assert(fee >= 0n && fee <= UINT_32_MAX, `Invalid fee: ${fee}. Must be a valid uint32`);
+		assert(fee <= BigInt(FEE_100_PERCENT$1), `Fee out of range: ${fee}. Must be <= ${FEE_100_PERCENT$1}`);
 	}
 	/**
 	* Decodes hex data into FlatFeeArgs instance
@@ -2551,7 +2588,7 @@ var FlatFeeArgs = class FlatFeeArgs {
 };
 
 //#endregion
-//#region src/swap-vm/instructions/fee/protocol-fee-args-coder.ts
+//#region src/swap-vm/instructions/fee/protocol-fee/protocol-fee-args-coder.ts
 var ProtocolFeeArgsCoder = class {
 	encode(args) {
 		const builder = new BytesBuilder();
@@ -2568,11 +2605,11 @@ var ProtocolFeeArgsCoder = class {
 };
 
 //#endregion
-//#region src/swap-vm/instructions/fee/protocol-fee-args.ts
+//#region src/swap-vm/instructions/fee/protocol-fee/protocol-fee-args.ts
 const FEE_100_PERCENT = 1e9;
 /**
-* Arguments for protocol fee instructions (protocolFeeAmountOutXD, aquaProtocolFeeAmountOutXD)
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L102
+* Arguments for protocol fee instructions (protocolFeeAmountInXD, aquaProtocolFeeAmountInXD)
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L101
 **/
 var ProtocolFeeArgs = class ProtocolFeeArgs {
 	static CODER = new ProtocolFeeArgsCoder();
@@ -2583,8 +2620,8 @@ var ProtocolFeeArgs = class ProtocolFeeArgs {
 	constructor(fee, to) {
 		this.fee = fee;
 		this.to = to;
-		assert$1(fee >= 0n && fee <= UINT_32_MAX, `Invalid fee: ${fee}. Must be a valid uint32`);
-		assert$1(fee <= BigInt(FEE_100_PERCENT), `Fee out of range: ${fee}. Must be <= ${FEE_100_PERCENT}`);
+		assert(fee >= 0n && fee <= UINT_32_MAX, `Invalid fee: ${fee}. Must be a valid uint32`);
+		assert(fee <= BigInt(FEE_100_PERCENT), `Fee out of range: ${fee}. Must be <= ${FEE_100_PERCENT}`);
 	}
 	/**
 	* Decodes hex data into ProtocolFeeArgs instance
@@ -2619,50 +2656,110 @@ var ProtocolFeeArgs = class ProtocolFeeArgs {
 	}
 };
 
+//#endregion
+//#region src/swap-vm/instructions/fee/dynamic-protocol-fee/dynamic-protocol-fee-args-coder.ts
+var DynamicProtocolFeeArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addAddress(args.feeProvider.toString());
+		return new HexString$1(builder.asHex());
+	}
+	decode(data) {
+		const iter = BytesIter.HexString(data.toString());
+		const feeProvider = new Address$1(iter.nextAddress());
+		return new DynamicProtocolFeeArgs(feeProvider);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/fee/dynamic-protocol-fee/dynamic-protocol-fee-args.ts
+/**
+* Arguments for dynamic protocol fee instructions (dynamicProtocolFeeAmountInXD, aquaDynamicProtocolFeeAmountInXD).
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol
+**/
+var DynamicProtocolFeeArgs = class DynamicProtocolFeeArgs {
+	static CODER = new DynamicProtocolFeeArgsCoder();
+	constructor(feeProvider) {
+		this.feeProvider = feeProvider;
+		assert(!feeProvider.isZero(), "Invalid feeProvider. Must be non zero address");
+	}
+	static decode(data) {
+		return DynamicProtocolFeeArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return { feeProvider: this.feeProvider.toString() };
+	}
+};
+
 //#endregion
 //#region src/swap-vm/instructions/fee/opcodes.ts
 /**
 * Applies fee to amountIn
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L66
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L72
 **/
 const flatFeeAmountInXD = new Opcode(Symbol("Fee.flatFeeAmountInXD"), FlatFeeArgs.CODER);
 /**
+* Protocol fee on amountIn (feeBps + to). Fee transferred from maker to recipient.
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L101
+**/
+const protocolFeeAmountInXD = new Opcode(Symbol("Fee.protocolFeeAmountInXD"), ProtocolFeeArgs.CODER);
+/**
+* Protocol fee on amountIn for Aqua (feeBps + to). Pulls from maker's Aqua balance.
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L121
+**/
+const aquaProtocolFeeAmountInXD = new Opcode(Symbol("Fee.aquaProtocolFeeAmountInXD"), ProtocolFeeArgs.CODER);
+/**
+* Dynamic protocol fee: args = feeProvider address (20 bytes).
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L148
+**/
+const dynamicProtocolFeeAmountInXD = new Opcode(Symbol("Fee.dynamicProtocolFeeAmountInXD"), DynamicProtocolFeeArgs.CODER);
+/**
+* Dynamic protocol fee for Aqua: args = feeProvider address (20 bytes).
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L197
+**/
+const aquaDynamicProtocolFeeAmountInXD = new Opcode(Symbol("Fee.aquaDynamicProtocolFeeAmountInXD"), DynamicProtocolFeeArgs.CODER);
+/**
 * Applies fee to amountOut
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L72
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/FeeExperimental.sol#L40
 **/
-const flatFeeAmountOutXD = new Opcode(Symbol("Fee.flatFeeAmountOutXD"), FlatFeeArgs.CODER);
+const flatFeeAmountOutXD = new Opcode(Symbol("FeeExperimental.flatFeeAmountOutXD"), FlatFeeArgs.CODER);
 /**
 * Applies progressive fee to amountIn
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L78
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/FeeExperimental.sol#L46
 **/
-const progressiveFeeInXD = new Opcode(Symbol("Fee.progressiveFeeInXD"), FlatFeeArgs.CODER);
+const progressiveFeeInXD = new Opcode(Symbol("FeeExperimental.progressiveFeeInXD"), FlatFeeArgs.CODER);
 /**
 * Applies progressive fee to amountOut
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L106
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/FeeExperimental.sol#L74
 **/
-const progressiveFeeOutXD = new Opcode(Symbol("Fee.progressiveFeeOutXD"), FlatFeeArgs.CODER);
+const progressiveFeeOutXD = new Opcode(Symbol("FeeExperimental.progressiveFeeOutXD"), FlatFeeArgs.CODER);
 /**
-* Applies protocol fee to amountOut with direct transfer
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L102
+* Protocol fee on amountOut (feeBps + to). Fee transferred from maker to recipient.
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/FeeExperimental.sol#L107
 **/
-const protocolFeeAmountOutXD = new Opcode(Symbol("Fee.protocolFeeAmountOutXD"), ProtocolFeeArgs.CODER);
+const protocolFeeAmountOutXD = new Opcode(Symbol("FeeExperimental.protocolFeeAmountOutXD"), ProtocolFeeArgs.CODER);
 /**
-* Applies protocol fee to amountOut through Aqua protocol
-* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L110
+* Protocol fee on amountOut (feeBps + to) for Aqua (feeBps + to). Pulls from maker's Aqua balance.
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/FeeExperimental.sol#L122
 **/
-const aquaProtocolFeeAmountOutXD = new Opcode(Symbol("Fee.aquaProtocolFeeAmountOutXD"), ProtocolFeeArgs.CODER);
+const aquaProtocolFeeAmountOutXD = new Opcode(Symbol("FeeExperimental.aquaProtocolFeeAmountOutXD"), ProtocolFeeArgs.CODER);
 
 //#endregion
 //#region src/swap-vm/instructions/fee/index.ts
 var fee_exports = {};
 __export(fee_exports, {
+	DynamicProtocolFeeArgs: () => DynamicProtocolFeeArgs,
 	FlatFeeArgs: () => FlatFeeArgs,
 	ProtocolFeeArgs: () => ProtocolFeeArgs,
+	aquaDynamicProtocolFeeAmountInXD: () => aquaDynamicProtocolFeeAmountInXD,
+	aquaProtocolFeeAmountInXD: () => aquaProtocolFeeAmountInXD,
 	aquaProtocolFeeAmountOutXD: () => aquaProtocolFeeAmountOutXD,
+	dynamicProtocolFeeAmountInXD: () => dynamicProtocolFeeAmountInXD,
 	flatFeeAmountInXD: () => flatFeeAmountInXD,
 	flatFeeAmountOutXD: () => flatFeeAmountOutXD,
 	progressiveFeeInXD: () => progressiveFeeInXD,
 	progressiveFeeOutXD: () => progressiveFeeOutXD,
+	protocolFeeAmountInXD: () => protocolFeeAmountInXD,
 	protocolFeeAmountOutXD: () => protocolFeeAmountOutXD
 });
 
@@ -2730,82 +2827,194 @@ __export(extruction_exports, {
 });
 
 //#endregion
-//#region src/swap-vm/instructions/stable-swap/stable-swap-2d-args-coder.ts
-var StableSwap2DArgsCoder = class {
+//#region src/swap-vm/instructions/pegged-swap/pegged-swap-args-coder.ts
+var PeggedSwapArgsCoder = class {
 	encode(args) {
 		const builder = new BytesBuilder();
-		builder.addUint32(args.fee);
-		builder.addUint32(args.A);
+		builder.addUint256(args.x0);
+		builder.addUint256(args.y0);
+		builder.addUint256(args.linearWidth);
 		builder.addUint256(args.rateLt);
 		builder.addUint256(args.rateGt);
-		return new HexString$1(add0x(builder.asHex()));
+		return new HexString$1(builder.asHex());
 	}
 	decode(data) {
 		const iter = BytesIter.BigInt(data.toString());
-		const fee = iter.nextUint32();
-		const A = iter.nextUint32();
-		const rateLt = iter.nextUint256();
-		const rateGt = iter.nextUint256();
-		return new StableSwap2DArgs(fee, A, rateLt, rateGt);
+		const x0 = BigInt(iter.nextUint256());
+		const y0 = BigInt(iter.nextUint256());
+		const linearWidth = BigInt(iter.nextUint256());
+		const rateLt = BigInt(iter.nextUint256());
+		const rateGt = BigInt(iter.nextUint256());
+		return new PeggedSwapArgs(x0, y0, linearWidth, rateLt, rateGt);
 	}
 };
 
 //#endregion
-//#region src/swap-vm/instructions/stable-swap/stable-swap-2d-args.ts
+//#region src/swap-vm/instructions/pegged-swap/rate-resolver.ts
+function resolveRate(tokenADecimals, tokenBDecimals) {
+	if (tokenADecimals === tokenBDecimals) return 1n;
+	if (tokenADecimals > tokenBDecimals) return 1n;
+	return 10n ** BigInt(tokenBDecimals - tokenADecimals);
+}
+
+//#endregion
+//#region src/swap-vm/instructions/pegged-swap/pegged-swap-args.ts
 /**
-* Arguments for stableSwap2D instruction for stablecoin optimized swaps
+* Arguments for PeggedSwap._peggedSwapGrowPriceRange2D.
+* 5 × uint256: x0, y0, linearWidth, rateLt, rateGt (160 bytes).
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/PeggedSwap.sol
 **/
-var StableSwap2DArgs = class StableSwap2DArgs {
-	static CODER = new StableSwap2DArgsCoder();
-	/**
-	* fee - swap fee in 1e10 (uint32)
-	* A - amplification coefficient (uint32)
-	* rateLt - rate for token with lower address (uint256)
-	* rateGt - rate for token with higher address (uint256)
-	**/
-	constructor(fee, A, rateLt, rateGt) {
-		this.fee = fee;
-		this.A = A;
+var PeggedSwapArgs = class PeggedSwapArgs {
+	static CODER = new PeggedSwapArgsCoder();
+	/**
+	* x0 - Initial X reserve (normalization factor) = initial_balance_X * rateLt (or rateGt)
+	* y0 - Initial Y reserve (normalization factor) = initial_balance_Y * rateGt (or rateLt)
+	* linearWidth - Linear component coefficient A scaled by 1e27 (e.g., 0.8e27 for A=0.8)
+	* rateLt - Rate multiplier for token with LOWER address
+	* rateGt - Rate multiplier for token with GREATER address
+	* > For equal decimals (e.g., both 18): rateLt = rateGt = 1
+	* > For 18 vs 6 decimals: rate18 = 1, rate6 = 1e12 (to scale up to common precision)
+	**/
+	constructor(x0, y0, linearWidth, rateLt, rateGt) {
+		this.x0 = x0;
+		this.y0 = y0;
+		this.linearWidth = linearWidth;
 		this.rateLt = rateLt;
 		this.rateGt = rateGt;
-		assert$1(fee >= 0n && fee <= UINT_32_MAX, `Invalid fee: ${fee}`);
-		assert$1(A >= 0n && A <= UINT_32_MAX, `Invalid A: ${A}`);
-		assert$1(rateLt > 0n && rateLt <= UINT_256_MAX, `Invalid rateLt: ${rateLt}. Must be positive and <= UINT_256_MAX`);
-		assert$1(rateGt > 0n && rateGt <= UINT_256_MAX, `Invalid rateGt: ${rateGt}. Must be positive and <= UINT_256_MAX`);
+		assert(x0 > 0n && y0 > 0n, "Reserves cannot be zero");
+		assert(x0 <= UINT_256_MAX, `Invalid x0: ${x0}`);
+		assert(y0 <= UINT_256_MAX, `Invalid y0: ${y0}`);
+		assert(linearWidth <= 2n * 10n ** 27n, `Invalid linearWidth: ${linearWidth}`);
+		assert(rateLt > 0n && rateLt <= UINT_256_MAX, `Invalid rateLt: ${rateLt}. Must be positive and <= UINT_256_MAX`);
+		assert(rateGt > 0n && rateGt <= UINT_256_MAX, `Invalid rateGt: ${rateGt}. Must be positive and <= UINT_256_MAX`);
+	}
+	static fromTokens(tokenA, tokenB, linearWidth) {
+		const tokenARate = resolveRate(tokenA.decimals, tokenB.decimals);
+		const tokenBRate = resolveRate(tokenB.decimals, tokenA.decimals);
+		if (BigInt(tokenA.address.toString()) < BigInt(tokenB.address.toString())) return new PeggedSwapArgs(tokenA.reserve * tokenARate, tokenB.reserve * tokenBRate, linearWidth, tokenARate, tokenBRate);
+		return new PeggedSwapArgs(tokenB.reserve * tokenBRate, tokenA.reserve * tokenARate, linearWidth, tokenBRate, tokenARate);
+	}
+	static decode(data) {
+		return PeggedSwapArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			x0: this.x0.toString(),
+			y0: this.y0.toString(),
+			linearWidth: this.linearWidth.toString(),
+			rateLt: this.rateLt.toString(),
+			rateGt: this.rateGt.toString()
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/pegged-swap/opcodes.ts
+/**
+* PeggedSwap - Square-root linear swap curve for pegged assets
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/PeggedSwap.sol
+**/
+const peggedSwapGrowPriceRange2D = new Opcode(Symbol("PeggedSwap.peggedSwapGrowPriceRange2D"), PeggedSwapArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/pegged-swap/index.ts
+var pegged_swap_exports = {};
+__export(pegged_swap_exports, {
+	PeggedSwapArgs: () => PeggedSwapArgs,
+	peggedSwapGrowPriceRange2D: () => peggedSwapGrowPriceRange2D
+});
+
+//#endregion
+//#region src/swap-vm/instructions/oracle-price-adjuster/oracle-price-adjuster-args-coder.ts
+var OraclePriceAdjusterArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint64(args.maxPriceDecay);
+		builder.addUint16(args.maxStaleness);
+		builder.addUint8(args.oracleDecimals);
+		builder.addAddress(args.oracleAddress.toString());
+		return new HexString$1(builder.asHex());
 	}
-	static fromTokens(fee, a, tokenA, tokenB, rateA, rateB) {
-		if (BigInt(tokenA.toString()) < BigInt(tokenB.toString())) return new StableSwap2DArgs(fee, a, rateA, rateB);
-		return new StableSwap2DArgs(fee, a, rateB, rateA);
+	decode(data) {
+		const iter = BytesIter.HexString(data.toString());
+		const maxPriceDecay = iter.nextUint64();
+		const maxStaleness = iter.nextUint16();
+		const oracleDecimals = iter.nextUint8();
+		const oracleAddress = new Address$1(iter.nextAddress());
+		return new OraclePriceAdjusterArgs(BigInt(maxPriceDecay), BigInt(maxStaleness), BigInt(oracleDecimals), oracleAddress);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/oracle-price-adjuster/oracle-price-adjuster-args.ts
+/**
+* @notice Oracle Price Adjuster instruction for dynamic price adjustment based on Chainlink price feeds
+* @dev Adjusts swap prices to match Chainlink oracle prices within safe bounds:
+* - Works only for 1=>0 swaps (token1 to token0), compatible with LimitSwap and other swap instructions
+* - Fetches current market price from a Chainlink oracle (AggregatorV3Interface)
+* - Adjusts the swap price towards the oracle price within maxPriceDecay limits
+* - Ensures the adjustment is always favorable for the taker
+* - Handles different decimal places from Chainlink oracles (e.g., 8 decimals for USD prices)
+*
+* This creates adaptive orders that automatically track market prices while maintaining
+* safety bounds to prevent excessive slippage or manipulation.
+*
+* Example usage:
+* 1. LimitSwap sets base price: 1 ETH for 3000 USDC
+* 2. OraclePriceAdjuster with Chainlink ETH/USD oracle: 1 ETH = 3100 USD, maxPriceDecay=0.95e18 (5% max)
+* 3. exactIn: Taker gets more ETH (up to 5% improvement)
+* 4. exactOut: Taker pays less USDC (up to 5% discount)
+*
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/OraclePriceAdjuster.sol#L84
+*/
+var OraclePriceAdjusterArgs = class OraclePriceAdjusterArgs {
+	static CODER = new OraclePriceAdjusterArgsCoder();
+	/**
+	* maxPriceDecay - maximum price decay coefficient (uint64)
+	* maxStaleness - maximum allowed oracle data staleness in seconds (uint16
+	* oracleDecimals - decimals used by the oracle (uint8)
+	* oracleAddress - address of the Chainlink price oracle contract
+	**/
+	constructor(maxPriceDecay, maxStaleness, oracleDecimals, oracleAddress) {
+		this.maxPriceDecay = maxPriceDecay;
+		this.maxStaleness = maxStaleness;
+		this.oracleDecimals = oracleDecimals;
+		this.oracleAddress = oracleAddress;
+		assert(maxPriceDecay >= 0n && maxPriceDecay <= UINT_64_MAX, `Invalid maxPriceDecay: ${maxPriceDecay}. Must be a valid uint64`);
+		assert(maxPriceDecay < 1e18, `Max price decay should be less than 1e18: ${maxPriceDecay}`);
+		assert(maxStaleness >= 0n && maxStaleness <= UINT_16_MAX, `Invalid maxStaleness: ${maxStaleness}. Must be a valid uint16`);
+		assert(oracleDecimals >= 0n && oracleDecimals <= UINT_8_MAX, `Invalid oracleDecimals: ${oracleDecimals}. Must be a valid uint8`);
 	}
 	/**
-	* Decodes hex data into StableSwap2DArgs instance
+	* Decodes hex data into OraclePriceAdjusterArgs instance
 	**/
 	static decode(data) {
-		return StableSwap2DArgs.CODER.decode(data);
+		return OraclePriceAdjusterArgs.CODER.decode(data);
 	}
 	toJSON() {
 		return {
-			fee: this.fee.toString(),
-			A: this.A.toString(),
-			rateLt: this.rateLt.toString(),
-			rateGt: this.rateGt.toString()
+			maxPriceDecay: this.maxPriceDecay.toString(),
+			maxStaleness: this.maxStaleness.toString(),
+			oracleDecimals: this.oracleDecimals.toString(),
+			oracleAddress: this.oracleAddress.toString()
 		};
 	}
 };
 
 //#endregion
-//#region src/swap-vm/instructions/stable-swap/opcodes.ts
+//#region src/swap-vm/instructions/oracle-price-adjuster/opcodes.ts
 /**
-* Stablecoin optimized swap using StableSwap algorithm (Curve-style)
+* Adjusts swap prices based on Chainlink oracle feeds
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/OraclePriceAdjuster.sol#L84
 **/
-const stableSwap2D = new Opcode(Symbol("StableSwap.stableSwap2D"), StableSwap2DArgs.CODER);
+const oraclePriceAdjuster1D = new Opcode(Symbol("OraclePriceAdjuster.oraclePriceAdjuster1D"), OraclePriceAdjusterArgs.CODER);
 
 //#endregion
-//#region src/swap-vm/instructions/stable-swap/index.ts
-var stable_swap_exports = {};
-__export(stable_swap_exports, {
-	StableSwap2DArgs: () => StableSwap2DArgs,
-	stableSwap2D: () => stableSwap2D
+//#region src/swap-vm/instructions/oracle-price-adjuster/index.ts
+var oracle_price_adjuster_exports = {};
+__export(oracle_price_adjuster_exports, {
+	OraclePriceAdjusterArgs: () => OraclePriceAdjusterArgs,
+	oraclePriceAdjuster1D: () => oraclePriceAdjuster1D
 });
 
 //#endregion
@@ -2827,7 +3036,8 @@ __export(instructions_exports, {
 	limitSwap: () => limit_swap_exports,
 	minRate: () => min_rate_exports,
 	oraclePriceAdjuster: () => oracle_price_adjuster_exports,
-	stableSwap: () => stable_swap_exports,
+	peggedSwap: () => pegged_swap_exports,
+	stableSwap: () => pegged_swap_exports,
 	twapSwap: () => twap_swap_exports,
 	xycSwap: () => xyc_swap_exports
 });
@@ -2859,7 +3069,6 @@ const _allInstructions = [
 	invalidateTokenIn1D,
 	invalidateTokenOut1D,
 	xycSwapXD,
-	concentrateGrowLiquidityXD,
 	concentrateGrowLiquidity2D,
 	decayXD,
 	limitSwap1D,
@@ -2868,7 +3077,6 @@ const _allInstructions = [
 	adjustMinRate1D,
 	dutchAuctionBalanceIn1D,
 	dutchAuctionBalanceOut1D,
-	oraclePriceAdjuster1D,
 	baseFeeAdjuster1D,
 	twap,
 	extruction,
@@ -2878,7 +3086,12 @@ const _allInstructions = [
 	progressiveFeeInXD,
 	progressiveFeeOutXD,
 	protocolFeeAmountOutXD,
-	aquaProtocolFeeAmountOutXD
+	aquaProtocolFeeAmountOutXD,
+	peggedSwapGrowPriceRange2D,
+	protocolFeeAmountInXD,
+	aquaProtocolFeeAmountInXD,
+	dynamicProtocolFeeAmountInXD,
+	aquaDynamicProtocolFeeAmountInXD
 ];
 /**
 * Aqua opcodes array - matching AquaSwapVM contract (29 opcodes)
@@ -2903,16 +3116,21 @@ const aquaInstructions = [
 	onlyTakerTokenBalanceGte,
 	onlyTakerTokenSupplyShareGte,
 	xycSwapXD,
-	concentrateGrowLiquidityXD,
 	concentrateGrowLiquidity2D,
 	decayXD,
 	salt,
 	flatFeeAmountInXD,
-	flatFeeAmountOutXD,
-	progressiveFeeInXD,
-	progressiveFeeOutXD,
-	protocolFeeAmountOutXD,
-	aquaProtocolFeeAmountOutXD
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	protocolFeeAmountInXD,
+	aquaProtocolFeeAmountInXD,
+	dynamicProtocolFeeAmountInXD,
+	aquaDynamicProtocolFeeAmountInXD,
+	peggedSwapGrowPriceRange2D,
+	extruction
 ];
 
 //#endregion
@@ -3214,17 +3432,17 @@ var RegularProgramBuilder = class RegularProgramBuilder extends ProgramBuilder {
 		return this;
 	}
 	/**
-	* Concentrates liquidity within price bounds for multiple tokens
+	* Concentrates liquidity within price bounds for two tokens
 	**/
-	concentrateGrowLiquidityXD(data) {
-		super.add(concentrateGrowLiquidityXD.createIx(new ConcentrateGrowLiquidityXDArgs(data.tokenDeltas)));
+	concentrateGrowLiquidity2D(data) {
+		super.add(concentrateGrowLiquidity2D.createIx(new ConcentrateGrowLiquidity2DArgs(data.sqrtPriceMin, data.sqrtPriceMax)));
 		return this;
 	}
 	/**
-	* Concentrates liquidity within price bounds for two tokens
+	* Square-root linear swap curve for pegged assets
 	**/
-	concentrateGrowLiquidity2D(data) {
-		super.add(concentrateGrowLiquidity2D.createIx(new ConcentrateGrowLiquidity2DArgs(data.deltaLt, data.deltaGt)));
+	peggedSwapGrowPriceRange2D(data) {
+		super.add(peggedSwapGrowPriceRange2D.createIx(new PeggedSwapArgs(data.x0, data.y0, data.linearWidth, data.rateLt, data.rateGt)));
 		return this;
 	}
 	/**
@@ -3277,13 +3495,6 @@ var RegularProgramBuilder = class RegularProgramBuilder extends ProgramBuilder {
 		return this;
 	}
 	/**
-	* Adjusts swap prices based on Chainlink oracle feeds
-	**/
-	oraclePriceAdjuster1D(data) {
-		super.add(oraclePriceAdjuster1D.createIx(new OraclePriceAdjusterArgs(data.maxPriceDecay, data.maxStaleness, data.oracleDecimals, data.oracleAddress)));
-		return this;
-	}
-	/**
 	* Adjusts swap prices based on network gas costs
 	**/
 	baseFeeAdjuster1D(data) {
@@ -3333,6 +3544,13 @@ var RegularProgramBuilder = class RegularProgramBuilder extends ProgramBuilder {
 		return this;
 	}
 	/**
+	* Applies protocol fee to amountIn with direct transfer
+	**/
+	protocolFeeAmountInXD(data) {
+		super.add(protocolFeeAmountInXD.createIx(new ProtocolFeeArgs(data.fee, data.to)));
+		return this;
+	}
+	/**
 	* Applies protocol fee to amountOut with direct transfer
 	**/
 	protocolFeeAmountOutXD(data) {
@@ -3340,6 +3558,13 @@ var RegularProgramBuilder = class RegularProgramBuilder extends ProgramBuilder {
 		return this;
 	}
 	/**
+	* Applies protocol fee to amountIn through Aqua protocol
+	**/
+	aquaProtocolFeeAmountInXD(data) {
+		super.add(aquaProtocolFeeAmountInXD.createIx(new ProtocolFeeArgs(data.fee, data.to)));
+		return this;
+	}
+	/**
 	* Applies protocol fee to amountOut through Aqua protocol
 	**/
 	aquaProtocolFeeAmountOutXD(data) {
@@ -3347,6 +3572,20 @@ var RegularProgramBuilder = class RegularProgramBuilder extends ProgramBuilder {
 		return this;
 	}
 	/**
+	* Applies protocol fee, fetched from external contract, to amountIn with direct transfer
+	**/
+	dynamicProtocolFeeAmountInXD(data) {
+		super.add(dynamicProtocolFeeAmountInXD.createIx(new DynamicProtocolFeeArgs(data.feeProvider)));
+		return this;
+	}
+	/**
+	* Applies protocol fee, fetched from external contract, to amountIn through Aqua protocol
+	**/
+	aquaDynamicProtocolFeeAmountInXD(data) {
+		super.add(aquaDynamicProtocolFeeAmountInXD.createIx(new DynamicProtocolFeeArgs(data.feeProvider)));
+		return this;
+	}
+	/**
 	* DEBUG: Prints current swap registers (amounts and tokens)
 	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
 	*/
@@ -3482,17 +3721,17 @@ var AquaProgramBuilder = class AquaProgramBuilder extends ProgramBuilder {
 		return this;
 	}
 	/**
-	* Concentrates liquidity within price bounds for multiple tokens
+	* Concentrates liquidity within price bounds for two tokens
 	**/
-	concentrateGrowLiquidityXD(data) {
-		super.add(concentrateGrowLiquidityXD.createIx(new ConcentrateGrowLiquidityXDArgs(data.tokenDeltas)));
+	concentrateGrowLiquidity2D(data) {
+		super.add(concentrateGrowLiquidity2D.createIx(new ConcentrateGrowLiquidity2DArgs(data.sqrtPriceMin, data.sqrtPriceMax)));
 		return this;
 	}
 	/**
-	* Concentrates liquidity within price bounds for two tokens
+	* Square-root linear swap curve for pegged assets
 	**/
-	concentrateGrowLiquidity2D(data) {
-		super.add(concentrateGrowLiquidity2D.createIx(new ConcentrateGrowLiquidity2DArgs(data.deltaLt, data.deltaGt)));
+	peggedSwapGrowPriceRange2D(data) {
+		super.add(peggedSwapGrowPriceRange2D.createIx(new PeggedSwapArgs(data.x0, data.y0, data.linearWidth, data.rateLt, data.rateGt)));
 		return this;
 	}
 	/**
@@ -3510,38 +3749,31 @@ var AquaProgramBuilder = class AquaProgramBuilder extends ProgramBuilder {
 		return this;
 	}
 	/**
-	* Applies fee to amountOut
-	**/
-	flatFeeAmountOutXD(data) {
-		super.add(flatFeeAmountOutXD.createIx(new FlatFeeArgs(data.fee)));
-		return this;
-	}
-	/**
-	* Applies progressive fee to amountIn
+	* Applies protocol fee to amountIn with direct transfer
 	**/
-	progressiveFeeInXD(data) {
-		super.add(progressiveFeeInXD.createIx(new FlatFeeArgs(data.fee)));
+	protocolFeeAmountInXD(data) {
+		super.add(protocolFeeAmountInXD.createIx(new ProtocolFeeArgs(data.fee, data.to)));
 		return this;
 	}
 	/**
-	* Applies progressive fee to amountOut
+	* Applies protocol fee to amountIn through Aqua protocol
 	**/
-	progressiveFeeOutXD(data) {
-		super.add(progressiveFeeOutXD.createIx(new FlatFeeArgs(data.fee)));
+	aquaProtocolFeeAmountInXD(data) {
+		super.add(aquaProtocolFeeAmountInXD.createIx(new ProtocolFeeArgs(data.fee, data.to)));
 		return this;
 	}
 	/**
-	* Applies protocol fee to amountOut with direct transfer
+	* Applies protocol fee, fetched from external contract, to amountIn with direct transfer
 	**/
-	protocolFeeAmountOutXD(data) {
-		super.add(protocolFeeAmountOutXD.createIx(new ProtocolFeeArgs(data.fee, data.to)));
+	dynamicProtocolFeeAmountInXD(data) {
+		super.add(dynamicProtocolFeeAmountInXD.createIx(new DynamicProtocolFeeArgs(data.feeProvider)));
 		return this;
 	}
 	/**
-	* Applies protocol fee to amountOut through Aqua protocol
+	* Applies protocol fee, fetched from external contract, to amountIn through Aqua protocol
 	**/
-	aquaProtocolFeeAmountOutXD(data) {
-		super.add(aquaProtocolFeeAmountOutXD.createIx(new ProtocolFeeArgs(data.fee, data.to)));
+	aquaDynamicProtocolFeeAmountInXD(data) {
+		super.add(aquaDynamicProtocolFeeAmountInXD.createIx(new DynamicProtocolFeeArgs(data.feeProvider)));
 		return this;
 	}
 	/**
@@ -3704,23 +3936,12 @@ var Order = class Order {
 
 //#endregion
 //#region src/swap-vm/strategies/aqua-amm-strategy.ts
-/**
-* Aqua AMM Strategy builder that mirrors AquaAMM.sol
-* @see https://github.com/1inch/swap-vm/blob/main/src/strategies/AquaAMM.sol
-*/
-var AquaAMMStrategy = class AquaAMMStrategy {
+var AquaAMMStrategy = class {
 	feeBpsIn;
-	deltas;
 	decayPeriod;
 	protocolFee;
 	salt;
-	constructor(tokenA, tokenB) {
-		this.tokenA = tokenA;
-		this.tokenB = tokenB;
-	}
-	static new(tokens) {
-		return new AquaAMMStrategy(tokens.tokenA, tokens.tokenB);
-	}
+	constructor() {}
 	withProtocolFee(bps, receiver) {
 		this.protocolFee = {
 			bps,
@@ -3728,13 +3949,6 @@ var AquaAMMStrategy = class AquaAMMStrategy {
 		};
 		return this;
 	}
-	withDeltas(a, b) {
-		this.deltas = {
-			a,
-			b
-		};
-		return this;
-	}
 	withDecayPeriod(decayPeriod) {
 		this.decayPeriod = decayPeriod;
 		return this;
@@ -3747,22 +3961,80 @@ var AquaAMMStrategy = class AquaAMMStrategy {
 		this.salt = salt$1;
 		return this;
 	}
+};
+
+//#endregion
+//#region src/swap-vm/strategies/aqua-xyc-amm-strategy.ts
+var AquaXYCAmmStrategy = class AquaXYCAmmStrategy extends AquaAMMStrategy {
+	constructor(xycConcentrateArgs) {
+		super();
+		this.xycConcentrateArgs = xycConcentrateArgs;
+	}
+	static new() {
+		return new AquaXYCAmmStrategy();
+	}
+	static newConcentrate(prices) {
+		if ("rawPriceMin" in prices && "rawPriceMax" in prices) {
+			const args = ConcentrateGrowLiquidity2DArgs.fromRawPrices(prices.rawPriceMin, prices.rawPriceMax);
+			return new AquaXYCAmmStrategy(args);
+		}
+		if ("sqrtPriceMin" in prices && "sqrtPriceMax" in prices) {
+			const args = ConcentrateGrowLiquidity2DArgs.fromSqrtPrices(prices.sqrtPriceMin, prices.sqrtPriceMax);
+			return new AquaXYCAmmStrategy(args);
+		}
+		throw new Error("unknown parameters for newXYCConcentrate");
+	}
 	build() {
 		const builder = new AquaProgramBuilder();
-		if (this.deltas) {
-			const data = ConcentrateGrowLiquidity2DArgs.fromTokenDeltas(this.tokenA, this.tokenB, this.deltas.a, this.deltas.b);
-			builder.add(concentrateGrowLiquidity2D.createIx(data));
+		if (this.protocolFee) {
+			const data = ProtocolFeeArgs.fromBps(this.protocolFee.bps, this.protocolFee.receiver);
+			builder.add(aquaProtocolFeeAmountInXD.createIx(data));
 		}
+		if (this.xycConcentrateArgs) builder.add(concentrateGrowLiquidity2D.createIx(this.xycConcentrateArgs));
 		if (this.decayPeriod) builder.decayXD({ decayPeriod: this.decayPeriod });
 		if (this.feeBpsIn) {
 			const data = FlatFeeArgs.fromBps(this.feeBpsIn);
 			builder.add(flatFeeAmountInXD.createIx(data));
 		}
+		builder.xycSwapXD();
+		if (this.salt) builder.salt({ salt: this.salt });
+		return builder.build();
+	}
+};
+
+//#endregion
+//#region src/swap-vm/strategies/aqua-pegged-amm-strategy.ts
+var AquaPeggedAmmStrategy = class AquaPeggedAmmStrategy extends AquaAMMStrategy {
+	constructor(tokenA, tokenB, linearWidth) {
+		super();
+		this.tokenA = tokenA;
+		this.tokenB = tokenB;
+		this.linearWidth = linearWidth;
+	}
+	static new(data) {
+		return new AquaPeggedAmmStrategy(data.tokenA, data.tokenB, data.linearWidth);
+	}
+	build() {
+		const builder = new AquaProgramBuilder();
 		if (this.protocolFee) {
 			const data = ProtocolFeeArgs.fromBps(this.protocolFee.bps, this.protocolFee.receiver);
-			builder.add(aquaProtocolFeeAmountOutXD.createIx(data));
+			builder.add(aquaProtocolFeeAmountInXD.createIx(data));
 		}
-		builder.xycSwapXD();
+		if (this.decayPeriod) builder.decayXD({ decayPeriod: this.decayPeriod });
+		if (this.feeBpsIn) {
+			const data = FlatFeeArgs.fromBps(this.feeBpsIn);
+			builder.add(flatFeeAmountInXD.createIx(data));
+		}
+		const peggedArgs = PeggedSwapArgs.fromTokens({
+			address: this.tokenA.address,
+			decimals: this.tokenA.decimals,
+			reserve: this.tokenA.reserve
+		}, {
+			address: this.tokenB.address,
+			decimals: this.tokenB.decimals,
+			reserve: this.tokenB.reserve
+		}, this.linearWidth);
+		builder.peggedSwapGrowPriceRange2D(peggedArgs);
 		if (this.salt) builder.salt({ salt: this.salt });
 		return builder.build();
 	}
@@ -3774,4 +4046,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, AquaProgramBuilder, 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, CallInfo, HexString, MakerTraits, NetworkEnum, Order, ProgramBuilder, RegularProgramBuilder, SwapVMContract, SwapVmProgram, SwappedEvent, TakerTraits, instructions_exports as instructions };