@1inch/swap-vm-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3777 @@
+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 { 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";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+
+//#endregion
+//#region src/abi/SwapVM.abi.ts
+const SWAP_VM_ABI = [
+	{
+		type: "function",
+		name: "AQUA",
+		inputs: [],
+		outputs: [{
+			name: "",
+			type: "address",
+			internalType: "contract IAqua"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "ORDER_TYPEHASH",
+		inputs: [],
+		outputs: [{
+			name: "",
+			type: "bytes32",
+			internalType: "bytes32"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "asView",
+		inputs: [],
+		outputs: [{
+			name: "",
+			type: "address",
+			internalType: "contract ISwapVM"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "eip712Domain",
+		inputs: [],
+		outputs: [
+			{
+				name: "fields",
+				type: "bytes1",
+				internalType: "bytes1"
+			},
+			{
+				name: "name",
+				type: "string",
+				internalType: "string"
+			},
+			{
+				name: "version",
+				type: "string",
+				internalType: "string"
+			},
+			{
+				name: "chainId",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "verifyingContract",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "salt",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "extensions",
+				type: "uint256[]",
+				internalType: "uint256[]"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "hash",
+		inputs: [{
+			name: "order",
+			type: "tuple",
+			internalType: "struct ISwapVM.Order",
+			components: [
+				{
+					name: "maker",
+					type: "address",
+					internalType: "address"
+				},
+				{
+					name: "traits",
+					type: "uint256",
+					internalType: "MakerTraits"
+				},
+				{
+					name: "data",
+					type: "bytes",
+					internalType: "bytes"
+				}
+			]
+		}],
+		outputs: [{
+			name: "",
+			type: "bytes32",
+			internalType: "bytes32"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "quote",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct ISwapVM.Order",
+				components: [
+					{
+						name: "maker",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "traits",
+						type: "uint256",
+						internalType: "MakerTraits"
+					},
+					{
+						name: "data",
+						type: "bytes",
+						internalType: "bytes"
+					}
+				]
+			},
+			{
+				name: "tokenIn",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "tokenOut",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "amount",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "takerTraitsAndData",
+				type: "bytes",
+				internalType: "bytes"
+			}
+		],
+		outputs: [
+			{
+				name: "amountIn",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "amountOut",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "orderHash",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "swap",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct ISwapVM.Order",
+				components: [
+					{
+						name: "maker",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "traits",
+						type: "uint256",
+						internalType: "MakerTraits"
+					},
+					{
+						name: "data",
+						type: "bytes",
+						internalType: "bytes"
+					}
+				]
+			},
+			{
+				name: "tokenIn",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "tokenOut",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "amount",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "takerTraitsAndData",
+				type: "bytes",
+				internalType: "bytes"
+			}
+		],
+		outputs: [
+			{
+				name: "amountIn",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "amountOut",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "orderHash",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "event",
+		name: "EIP712DomainChanged",
+		inputs: [],
+		anonymous: false
+	},
+	{
+		type: "event",
+		name: "Swapped",
+		inputs: [
+			{
+				name: "orderHash",
+				type: "bytes32",
+				indexed: false,
+				internalType: "bytes32"
+			},
+			{
+				name: "maker",
+				type: "address",
+				indexed: false,
+				internalType: "address"
+			},
+			{
+				name: "taker",
+				type: "address",
+				indexed: false,
+				internalType: "address"
+			},
+			{
+				name: "tokenIn",
+				type: "address",
+				indexed: false,
+				internalType: "address"
+			},
+			{
+				name: "tokenOut",
+				type: "address",
+				indexed: false,
+				internalType: "address"
+			},
+			{
+				name: "amountIn",
+				type: "uint256",
+				indexed: false,
+				internalType: "uint256"
+			},
+			{
+				name: "amountOut",
+				type: "uint256",
+				indexed: false,
+				internalType: "uint256"
+			}
+		],
+		anonymous: false
+	},
+	{
+		type: "error",
+		name: "AquaBalanceInsufficientAfterTakerPush",
+		inputs: [
+			{
+				name: "balance",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "preBalance",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "amount",
+				type: "uint256",
+				internalType: "uint256"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "BadSignature",
+		inputs: [
+			{
+				name: "maker",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "orderHash",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "signature",
+				type: "bytes",
+				internalType: "bytes"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "ForceApproveFailed",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "InvalidShortString",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "MakerTraitsCustomReceiverIsIncompatibleWithAqua",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "MakerTraitsTokenInAndTokenOutMustBeDifferent",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "MakerTraitsUnwrapIsIncompatibleWithAqua",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "MakerTraitsZeroAmountInNotAllowed",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "RunLoopExcessiveCall",
+		inputs: [{
+			name: "pc",
+			type: "uint256",
+			internalType: "uint256"
+		}, {
+			name: "programLength",
+			type: "uint256",
+			internalType: "uint256"
+		}]
+	},
+	{
+		type: "error",
+		name: "SafeTransferFromFailed",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "StringTooLong",
+		inputs: [{
+			name: "str",
+			type: "string",
+			internalType: "string"
+		}]
+	},
+	{
+		type: "error",
+		name: "TakerTraitsAmountOutMustBeGreaterThanZero",
+		inputs: [{
+			name: "amountOut",
+			type: "uint256",
+			internalType: "uint256"
+		}]
+	},
+	{
+		type: "error",
+		name: "TakerTraitsExceedingMaxInputAmount",
+		inputs: [{
+			name: "amountIn",
+			type: "uint256",
+			internalType: "uint256"
+		}, {
+			name: "amountInMax",
+			type: "uint256",
+			internalType: "uint256"
+		}]
+	},
+	{
+		type: "error",
+		name: "TakerTraitsInsufficientMinOutputAmount",
+		inputs: [{
+			name: "amountOut",
+			type: "uint256",
+			internalType: "uint256"
+		}, {
+			name: "amountOutMin",
+			type: "uint256",
+			internalType: "uint256"
+		}]
+	},
+	{
+		type: "error",
+		name: "TakerTraitsNonExactThresholdAmountIn",
+		inputs: [{
+			name: "amountIn",
+			type: "uint256",
+			internalType: "uint256"
+		}, {
+			name: "amountThreshold",
+			type: "uint256",
+			internalType: "uint256"
+		}]
+	},
+	{
+		type: "error",
+		name: "TakerTraitsNonExactThresholdAmountOut",
+		inputs: [{
+			name: "amountOut",
+			type: "uint256",
+			internalType: "uint256"
+		}, {
+			name: "amountThreshold",
+			type: "uint256",
+			internalType: "uint256"
+		}]
+	},
+	{
+		type: "error",
+		name: "TakerTraitsTakerAmountInMismatch",
+		inputs: [{
+			name: "takerAmount",
+			type: "uint256",
+			internalType: "uint256"
+		}, {
+			name: "computedAmount",
+			type: "uint256",
+			internalType: "uint256"
+		}]
+	},
+	{
+		type: "error",
+		name: "TakerTraitsTakerAmountOutMismatch",
+		inputs: [{
+			name: "takerAmount",
+			type: "uint256",
+			internalType: "uint256"
+		}, {
+			name: "computedAmount",
+			type: "uint256",
+			internalType: "uint256"
+		}]
+	},
+	{
+		type: "error",
+		name: "UnexpectedLock",
+		inputs: []
+	}
+];
+
+//#endregion
+//#region src/swap-vm-contract/swap-vm-contract.ts
+/**
+* SwapVM contract encoding/decoding utilities
+*/
+var SwapVMContract = class SwapVMContract {
+	constructor(address) {
+		this.address = address;
+	}
+	/**
+	* Encode quote function call data
+	* @see https://github.com/1inch/swap-vm/blob/main/src/SwapVM.sol#L84
+	*/
+	static encodeQuoteCallData(args) {
+		const result = encodeFunctionData({
+			abi: SWAP_VM_ABI,
+			functionName: "quote",
+			args: [
+				args.order.build(),
+				args.tokenIn.toString(),
+				args.tokenOut.toString(),
+				args.amount,
+				args.takerTraits.encode().toString()
+			]
+		});
+		return new HexString$1(result);
+	}
+	/**
+	* Encode `hashOrder` function call data
+	* @see https://github.com/1inch/swap-vm/blob/main/src/SwapVM.sol#L70
+	*/
+	static encodeHashOrderCallData(order) {
+		const result = encodeFunctionData({
+			abi: SWAP_VM_ABI,
+			functionName: "hash",
+			args: [order.build()]
+		});
+		return new HexString$1(result);
+	}
+	/**
+	* Encode swap function call data
+	* @see https://github.com/1inch/swap-vm/blob/main/src/SwapVM.sol#L124
+	*/
+	static encodeSwapCallData(args) {
+		const result = encodeFunctionData({
+			abi: SWAP_VM_ABI,
+			functionName: "swap",
+			args: [
+				args.order.build(),
+				args.tokenIn.toString(),
+				args.tokenOut.toString(),
+				args.amount,
+				args.takerTraits.encode().toString()
+			]
+		});
+		return new HexString$1(result);
+	}
+	/**
+	* Build quote transaction
+	*/
+	static buildQuoteTx(contractAddress, args) {
+		return {
+			to: contractAddress.toString(),
+			data: this.encodeQuoteCallData(args).toString(),
+			value: 0n
+		};
+	}
+	/**
+	* Build swap transaction
+	*/
+	static buildSwapTx(contractAddress, args) {
+		return {
+			to: contractAddress.toString(),
+			data: this.encodeSwapCallData(args).toString(),
+			value: 0n
+		};
+	}
+	static buildHashOrderTx(contractAddress, order) {
+		return {
+			to: contractAddress.toString(),
+			data: this.encodeHashOrderCallData(order).toString(),
+			value: 0n
+		};
+	}
+	swap(args) {
+		return SwapVMContract.buildSwapTx(this.address, args);
+	}
+	quote(args) {
+		return SwapVMContract.buildQuoteTx(this.address, args);
+	}
+	hashOrder(order) {
+		return SwapVMContract.buildHashOrderTx(this.address, order);
+	}
+};
+
+//#endregion
+//#region src/swap-vm-contract/constants.ts
+/**
+* AquaSwapVMRouter contract addresses by chain ID
+* These addresses supports only AQUA instructions set
+*
+* Deployed with next params
+* - name    = `AquaSwapVMRouter`
+* - version = `1.0.0`
+*
+* @see https://github.com/1inch/swap-vm/blob/8cc4c467374959af9efdb6e2b67d32d3c1083e1e/src/routers/AquaSwapVMRouter.sol#L11
+* @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")
+};
+
+//#endregion
+//#region src/swap-vm-contract/events/swapped-event.ts
+var SwappedEvent = class SwappedEvent {
+	static TOPIC = new HexString$1("0x54bc5c027d15d7aa8ae083f994ab4411d2f223291672ecd3a344f3d92dcaf8b2");
+	constructor(orderHash, maker, taker, tokenIn, tokenOut, amountIn, amountOut) {
+		this.orderHash = orderHash;
+		this.maker = maker;
+		this.taker = taker;
+		this.tokenIn = tokenIn;
+		this.tokenOut = tokenOut;
+		this.amountIn = amountIn;
+		this.amountOut = amountOut;
+	}
+	static new(data) {
+		return new SwappedEvent(data.orderHash, data.maker, data.taker, data.tokenIn, data.tokenOut, data.amountIn, data.amountOut);
+	}
+	/**
+	* Creates a SwappedEvent
+	* @throws Error if the log data is invalid or doesn't match the expected event structure
+	*/
+	static fromLog(log) {
+		const decoded = decodeEventLog({
+			abi: SWAP_VM_ABI,
+			data: log.data,
+			topics: log.topics,
+			eventName: "Swapped"
+		});
+		const { orderHash, maker, taker, tokenIn, tokenOut, amountIn, amountOut } = decoded.args;
+		return new SwappedEvent(new HexString$1(orderHash), new Address$1(maker), new Address$1(taker), new Address$1(tokenIn), new Address$1(tokenOut), amountIn, amountOut);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/maker-traits.ts
+/**
+* Maker-side order configuration packed into a single `uint256` and an optional hooks data blob.
+*
+* This class mirrors the on-chain `MakerTraits` bit layout and encoding used by the SwapVM
+* contracts. It is responsible for:
+*
+* - maker preferences (unwrap WETH, allow zero amount in, Aqua vs signature)
+* - selecting an optional custom receiver
+* - wiring pre/post transfer hooks and their optional targets/payloads
+*
+* The ABI-level representation is:
+* - `traits`  – a `uint256` where:
+*   - high bits 245–255 store boolean flags
+*   - bits 160–223 store cumulative offsets for hook data slices (4 × `uint16`)
+*   - bits   0–159 store the receiver address (0 means "maker")
+* - `hooksData` – concatenation of hook payloads in the order:
+*   `preTransferIn`, `postTransferIn`, `preTransferOut`, `postTransferOut`
+*/
+var MakerTraits = class MakerTraits {
+	static HOOKS = [
+		"preTransferInHook",
+		"postTransferInHook",
+		"preTransferOutHook",
+		"postTransferOutHook"
+	];
+	static SHOULD_UNWRAP_BIT_FLAG = 255n;
+	static USE_AQUA_INSTEAD_OF_SIGNATURE_BIT_FLAG = 254n;
+	static ALLOW_ZERO_AMOUNT_IN = 253n;
+	static HAS_PRE_TRANSFER_IN_HOOK_BIT_FLAG = 252n;
+	static HAS_POST_TRANSFER_IN_HOOK_BIT_FLAG = 251n;
+	static HAS_PRE_TRANSFER_OUT_HOOK_BIT_FLAG = 250n;
+	static HAS_POST_TRANSFER_OUT_HOOK_BIT_FLAG = 249n;
+	static PRE_TRANSFER_IN_HOOK_HAS_TARGET = 248n;
+	static POST_TRANSFER_IN_HOOK_HAS_TARGET = 247n;
+	static PRE_TRANSFER_OUT_HOOK_HAS_TARGET = 246n;
+	static POST_TRANSFER_OUT_HOOK_HAS_TARGET = 245n;
+	static CUSTOM_RECEIVER_MASK = new BitMask(0n, 160n);
+	static HOOKS_DATA_OFFSETS_MASK = new BitMask(160n, 224n);
+	constructor(shouldUnwrap, useAquaInsteadOfSignature, allowZeroAmountIn, customReceiver, preTransferInHook, postTransferInHook, preTransferOutHook, postTransferOutHook) {
+		this.shouldUnwrap = shouldUnwrap;
+		this.useAquaInsteadOfSignature = useAquaInsteadOfSignature;
+		this.allowZeroAmountIn = allowZeroAmountIn;
+		this.customReceiver = customReceiver;
+		this.preTransferInHook = preTransferInHook;
+		this.postTransferInHook = postTransferInHook;
+		this.preTransferOutHook = preTransferOutHook;
+		this.postTransferOutHook = postTransferOutHook;
+	}
+	/**
+	* Construct traits from a plain data object.
+	*/
+	static new(data) {
+		return new MakerTraits(data.shouldUnwrap, data.useAquaInsteadOfSignature, data.allowZeroAmountIn, data.customReceiver, data.preTransferInHook, data.postTransferInHook, data.preTransferOutHook, data.postTransferOutHook);
+	}
+	/**
+	* Create traits with library defaults that match the on-chain SwapVM expectations:
+	* - `useAquaInsteadOfSignature` = `true`
+	* - `shouldUnwrap`             = `false`
+	* - `allowZeroAmountIn`        = `false`
+	* - no receiver or hooks configured.
+	*/
+	static default() {
+		return MakerTraits.new({
+			useAquaInsteadOfSignature: true,
+			allowZeroAmountIn: false,
+			shouldUnwrap: false
+		});
+	}
+	/**
+	* Decode ABI-level representation into a `MakerTraits` instance.
+	*
+	* @param traits    Packed `uint256` bitfield as produced by {@link encode}.
+	* @param hooksData Concatenated hooks payloads in the format expected by SwapVM
+	*                  contracts (may be `HexString.EMPTY` when no hooks are present).
+	*
+	* Both arguments are typically obtained from contract storage / ABI and must
+	* follow the bit layout described in the class-level documentation.
+	*/
+	static decode(traits, hooksData = HexString$1.EMPTY) {
+		const traitsBN = new BN(traits);
+		const shouldUnwrap = traitsBN.getBit(MakerTraits.SHOULD_UNWRAP_BIT_FLAG);
+		const useAquaInsteadOfSignature = traitsBN.getBit(MakerTraits.USE_AQUA_INSTEAD_OF_SIGNATURE_BIT_FLAG);
+		const allowZeroAmountIn = traitsBN.getBit(MakerTraits.ALLOW_ZERO_AMOUNT_IN);
+		const customReceiver = Address$1.fromBigInt(traitsBN.getMask(MakerTraits.CUSTOM_RECEIVER_MASK).value);
+		const hooksDataOffsets = traitsBN.getMask(MakerTraits.HOOKS_DATA_OFFSETS_MASK).value;
+		const hasPreTransferInHook = Boolean(traitsBN.getBit(MakerTraits.HAS_PRE_TRANSFER_IN_HOOK_BIT_FLAG));
+		const hasPreTransferInHookTarget = Boolean(traitsBN.getBit(MakerTraits.PRE_TRANSFER_IN_HOOK_HAS_TARGET));
+		const preTransferInHook = parseHook(hooksData, hasPreTransferInHook, hasPreTransferInHookTarget, hooksDataOffsets, 0);
+		const hasPostTransferInHook = Boolean(traitsBN.getBit(MakerTraits.HAS_POST_TRANSFER_IN_HOOK_BIT_FLAG));
+		const hasPostTransferInHookTarget = Boolean(traitsBN.getBit(MakerTraits.POST_TRANSFER_IN_HOOK_HAS_TARGET));
+		const postTransferInHook = parseHook(hooksData, hasPostTransferInHook, hasPostTransferInHookTarget, hooksDataOffsets, 1);
+		const hasPreTransferOutHook = Boolean(traitsBN.getBit(MakerTraits.HAS_PRE_TRANSFER_OUT_HOOK_BIT_FLAG));
+		const hasPreTransferOutHookTarget = Boolean(traitsBN.getBit(MakerTraits.PRE_TRANSFER_OUT_HOOK_HAS_TARGET));
+		const preTransferOutHook = parseHook(hooksData, hasPreTransferOutHook, hasPreTransferOutHookTarget, hooksDataOffsets, 2);
+		const hasPostTransferOutHook = Boolean(traitsBN.getBit(MakerTraits.HAS_POST_TRANSFER_OUT_HOOK_BIT_FLAG));
+		const hasPostTransferOutHookTarget = Boolean(traitsBN.getBit(MakerTraits.POST_TRANSFER_OUT_HOOK_HAS_TARGET));
+		const postTransferOutHook = parseHook(hooksData, hasPostTransferOutHook, hasPostTransferOutHookTarget, hooksDataOffsets, 3);
+		return MakerTraits.new({
+			useAquaInsteadOfSignature: Boolean(useAquaInsteadOfSignature),
+			allowZeroAmountIn: Boolean(allowZeroAmountIn),
+			shouldUnwrap: Boolean(shouldUnwrap),
+			customReceiver: customReceiver.isZero() ? void 0 : customReceiver,
+			preTransferInHook,
+			postTransferInHook,
+			preTransferOutHook,
+			postTransferOutHook
+		});
+	}
+	static hooksDataEndsAtByte(traits) {
+		const bn = new BN(traits);
+		const offsets = bn.getMask(MakerTraits.HOOKS_DATA_OFFSETS_MASK).value;
+		const dataEndAt = Number(offsets >> 16n * BigInt(MakerTraits.HOOKS.length - 1) & 0xffffn);
+		return dataEndAt;
+	}
+	/**
+	* Mutate the traits instance in-place with a partial update and return it.
+	*
+	* This is primarily used for fluent-style construction in tests and examples, e.g.:
+	*
+	* `MakerTraits.default().with({ shouldUnwrap: true })`
+	*
+	* Only fields present in `data` are updated; flags, receiver, and hooks can be
+	* changed independently.
+	*/
+	with(data) {
+		Object.assign(this, data);
+		return this;
+	}
+	/**
+	* Encode traits into the ABI format expected by SwapVM contracts.
+	*
+	* @param maker - Maker address for this order. This parameter is required only
+	*                for gas/size optimisation; if omitted, any non-zero hook `target`
+	*                is treated as an explicit target.
+	*
+	* @returns An object containing:
+	*   - `traits`    - Packed `uint256` bitfield with flags, receiver and offsets
+	*   - `hooksData` - Concatenation of hook segments for all configured hooks
+	*
+	* ## Bit Layout of `traits` (uint256)
+	*
+	* ```
+	* 255                                                          0
+	* +------------+----------------------------+------------------+
+	* | Flags      | Hook Offsets (4×uint16)    | Receiver Address |
+	* | [255-245]  | [223-160]                  | [159-0]          |
+	* +------------+----------------------------+------------------+
+	* ```
+	*
+	* ## Flags (by bit index)
+	*
+	* | Bit | Flag Name                                |
+	* |-----|------------------------------------------|
+	* | 255 | SHOULD_UNWRAP_BIT_FLAG                   |
+	* | 254 | USE_AQUA_INSTEAD_OF_SIGNATURE_BIT_FLAG   |
+	* | 253 | ALLOW_ZERO_AMOUNT_IN                     |
+	* | 252 | HAS_PRE_TRANSFER_IN_HOOK_BIT_FLAG        |
+	* | 251 | HAS_POST_TRANSFER_IN_HOOK_BIT_FLAG       |
+	* | 250 | HAS_PRE_TRANSFER_OUT_HOOK_BIT_FLAG       |
+	* | 249 | HAS_POST_TRANSFER_OUT_HOOK_BIT_FLAG      |
+	* | 248 | PRE_TRANSFER_IN_HOOK_HAS_TARGET          |
+	* | 247 | POST_TRANSFER_IN_HOOK_HAS_TARGET         |
+	* | 246 | PRE_TRANSFER_OUT_HOOK_HAS_TARGET         |
+	* | 245 | POST_TRANSFER_OUT_HOOK_HAS_TARGET        |
+	*/
+	encode(maker) {
+		let traits = new BN(0n);
+		traits = traits.setBit(MakerTraits.SHOULD_UNWRAP_BIT_FLAG, this.shouldUnwrap);
+		traits = traits.setBit(MakerTraits.USE_AQUA_INSTEAD_OF_SIGNATURE_BIT_FLAG, this.useAquaInsteadOfSignature);
+		traits = traits.setBit(MakerTraits.ALLOW_ZERO_AMOUNT_IN, this.allowZeroAmountIn);
+		traits = traits.setBit(MakerTraits.HAS_PRE_TRANSFER_IN_HOOK_BIT_FLAG, this.preTransferInHook !== void 0);
+		traits = traits.setBit(MakerTraits.HAS_POST_TRANSFER_IN_HOOK_BIT_FLAG, this.postTransferInHook !== void 0);
+		traits = traits.setBit(MakerTraits.HAS_PRE_TRANSFER_OUT_HOOK_BIT_FLAG, this.preTransferOutHook !== void 0);
+		traits = traits.setBit(MakerTraits.HAS_POST_TRANSFER_OUT_HOOK_BIT_FLAG, this.postTransferOutHook !== void 0);
+		traits = traits.setBit(MakerTraits.PRE_TRANSFER_IN_HOOK_HAS_TARGET, this.hasTargetForHook("preTransferInHook", maker));
+		traits = traits.setBit(MakerTraits.POST_TRANSFER_IN_HOOK_HAS_TARGET, this.hasTargetForHook("postTransferInHook", maker));
+		traits = traits.setBit(MakerTraits.PRE_TRANSFER_OUT_HOOK_HAS_TARGET, this.hasTargetForHook("preTransferOutHook", maker));
+		traits = traits.setBit(MakerTraits.POST_TRANSFER_OUT_HOOK_HAS_TARGET, this.hasTargetForHook("postTransferOutHook", maker));
+		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 encoded = hook && hasTarget ? hook.encode() : hook?.data || HexString$1.EMPTY;
+			acc.sum += BigInt(encoded.bytesCount());
+			acc.offsets += acc.sum << 16n * BigInt(i);
+			acc.data = acc.data.concat(encoded);
+			return acc;
+		}, {
+			data: HexString$1.EMPTY,
+			offsets: 0n,
+			sum: 0n
+		});
+		traits = traits.setMask(MakerTraits.HOOKS_DATA_OFFSETS_MASK, offsets);
+		return {
+			traits: traits.value,
+			hooksData: data
+		};
+	}
+	hasTargetForHook(hookName, maker = Address$1.ZERO_ADDRESS) {
+		const hook = this[hookName];
+		if (!hook) return false;
+		return !(hook.target.isZero() || hook.target.equal(maker));
+	}
+};
+function parseHook(fullHookData, hasHook, hasHookTarget, offsets, idx) {
+	if (!hasHook) return void 0;
+	const startDataIdx = idx === 0 ? 0 : Number(offsets >> 16n * BigInt(idx - 1) & 0xffffn);
+	const endDataIdx = Number(offsets >> 16n * BigInt(idx) & 0xffffn);
+	const hookData = fullHookData.sliceBytes(startDataIdx, endDataIdx);
+	if (!hasHookTarget) return new Interaction(Address$1.ZERO_ADDRESS, hookData);
+	return Interaction.decode(hookData);
+}
+
+//#endregion
+//#region src/swap-vm/taker-traits.ts
+/**
+* TakerTraits encodes taker-specific parameters and flags for swap execution.
+* It defines how the taker wants the swap to be executed, including thresholds,
+* callbacks, hooks, and other execution parameters.
+*/
+var TakerTraits = class TakerTraits {
+	static IS_EXACT_IN_BIT_FLAG = 0n;
+	static SHOULD_UNWRAP_BIT_FLAG = 1n;
+	static HAS_PRE_TRANSFER_IN_CALLBACK_BIT_FLAG = 2n;
+	static HAS_PRE_TRANSFER_OUT_CALLBACK_BIT_FLAG = 3n;
+	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) {
+		this.exactIn = exactIn;
+		this.shouldUnwrap = shouldUnwrap;
+		this.preTransferInCallbackEnabled = preTransferInCallbackEnabled;
+		this.preTransferOutCallbackEnabled = preTransferOutCallbackEnabled;
+		this.strictThreshold = strictThreshold;
+		this.firstTransferFromTaker = firstTransferFromTaker;
+		this.useTransferFromAndAquaPush = useTransferFromAndAquaPush;
+		this.threshold = threshold;
+		this.customReceiver = customReceiver;
+		this.preTransferInHookData = preTransferInHookData;
+		this.postTransferInHookData = postTransferInHookData;
+		this.preTransferOutHookData = preTransferOutHookData;
+		this.postTransferOutHookData = postTransferOutHookData;
+		this.preTransferInCallbackData = preTransferInCallbackData;
+		this.preTransferOutCallbackData = preTransferOutCallbackData;
+		this.instructionsArgs = instructionsArgs;
+		this.signature = signature;
+	}
+	/**
+	* Creates a new TakerTraits instance with the specified data.
+	* 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);
+	}
+	/**
+	* Creates a default TakerTraits instance with standard settings.
+	* - exactIn mode
+	* - No unwrapping
+	* - No callbacks
+	* - No custom receiver
+	* - transferFromAndAquaPush enabled
+	*/
+	static default() {
+		return TakerTraits.new({
+			exactIn: true,
+			shouldUnwrap: false,
+			preTransferInCallbackEnabled: false,
+			preTransferOutCallbackEnabled: false,
+			strictThreshold: false,
+			firstTransferFromTaker: false,
+			useTransferFromAndAquaPush: true,
+			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
+		});
+	}
+	/**
+	* Decodes a packed TakerTraits from a hex string.
+	* The packed format consists of:
+	* - 18 bytes: 9 uint16 offsets for data sections
+	* - 2 bytes: uint16 flags
+	* - Variable: data sections (threshold, to, 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 flags = new BN(iter.nextUint16());
+		const dataStr = trim0x(packed.toString()).slice(40);
+		const sections = [];
+		offsets.forEach((offset, i) => {
+			const start = i === 0 ? 0 : offsets[i - 1];
+			sections.push(offset > start ? dataStr.slice(start * 2, offset * 2) : "");
+		});
+		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;
+		return TakerTraits.new({
+			exactIn: Boolean(flags.getBit(TakerTraits.IS_EXACT_IN_BIT_FLAG)),
+			shouldUnwrap: Boolean(flags.getBit(TakerTraits.SHOULD_UNWRAP_BIT_FLAG)),
+			preTransferInCallbackEnabled: Boolean(flags.getBit(TakerTraits.HAS_PRE_TRANSFER_IN_CALLBACK_BIT_FLAG)),
+			preTransferOutCallbackEnabled: Boolean(flags.getBit(TakerTraits.HAS_PRE_TRANSFER_OUT_CALLBACK_BIT_FLAG)),
+			strictThreshold: Boolean(flags.getBit(TakerTraits.IS_STRICT_THRESHOLD_BIT_FLAG)),
+			firstTransferFromTaker: Boolean(flags.getBit(TakerTraits.IS_FIRST_TRANSFER_FROM_TAKER_BIT_FLAG)),
+			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,
+			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,
+			postTransferOutHookData: postTransferOutHookData ? new HexString$1(add0x(postTransferOutHookData)) : HexString$1.EMPTY,
+			preTransferInCallbackData: preTransferInCallbackData ? new HexString$1(add0x(preTransferInCallbackData)) : HexString$1.EMPTY,
+			preTransferOutCallbackData: preTransferOutCallbackData ? new HexString$1(add0x(preTransferOutCallbackData)) : HexString$1.EMPTY,
+			instructionsArgs: instructionsArgs ? new HexString$1(add0x(instructionsArgs)) : HexString$1.EMPTY,
+			signature: signature ? new HexString$1(add0x(signature)) : HexString$1.EMPTY
+		});
+	}
+	/**
+	* Creates a new instance with updated fields.
+	* Useful for creating modified versions of existing TakerTraits.
+	*/
+	with(data) {
+		Object.assign(this, data);
+		return this;
+	}
+	/**
+	* Encodes the TakerTraits into a packed hex string format.
+	* The encoding includes offsets, flags, data sections, and signature.
+	* Callback flags are automatically set based on callback data presence.
+	*/
+	encode() {
+		const builder = new BytesBuilder();
+		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.preTransferInHookData,
+			this.postTransferInHookData,
+			this.preTransferOutHookData,
+			this.postTransferOutHookData,
+			this.preTransferInCallbackData,
+			this.preTransferOutCallbackData,
+			this.instructionsArgs
+		];
+		const { offsets, data } = dataFields.reduce((acc, field) => {
+			const length = field.bytesCount();
+			acc.sum += length;
+			acc.offsets.push(acc.sum);
+			acc.data.push(field.toString().slice(2));
+			return acc;
+		}, {
+			sum: 0,
+			offsets: [],
+			data: []
+		});
+		offsets.reverse().forEach((offset) => builder.addUint16(BigInt(offset)));
+		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.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);
+		builder.addUint16(flags.value);
+		const allData = data.join("") + this.signature.toString().slice(2);
+		if (allData) builder.addBytes("0x" + allData);
+		return new HexString$1(builder.asHex());
+	}
+	/**
+	* Validates the swap amounts against the threshold settings.
+	* @param amountIn - The input amount of the swap
+	* @param amountOut - The output amount of the swap
+	* @throws Error if the amounts don't meet the threshold requirements
+	*/
+	validate(amountIn, amountOut) {
+		if (this.threshold === 0n) return;
+		const threshold = this.threshold;
+		if (this.strictThreshold) {
+			const actual = this.exactIn ? amountOut : amountIn;
+			if (actual !== threshold) throw new Error(`TakerTraitsNonExactThresholdAmount: ${this.exactIn ? "amountOut" : "amountIn"} ${actual} != threshold ${threshold}`);
+		} else if (this.exactIn) {
+			if (amountOut < threshold) throw new Error(`TakerTraitsInsufficientMinOutputAmount: amountOut ${amountOut} < threshold ${threshold}`);
+		} else if (amountIn > threshold) throw new Error(`TakerTraitsExceedingMaxInputAmount: amountIn ${amountIn} > threshold ${threshold}`);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/programs/swap-vm-program.ts
+/**
+* Represents encoded SwapVM program bytecode
+**/
+var SwapVmProgram = class extends HexString$1 {};
+
+//#endregion
+//#region src/swap-vm/instructions/instruction.ts
+var Instruction = class {
+	constructor(opcode, args) {
+		this.opcode = opcode;
+		this.args = args;
+	}
+	toJSON() {
+		return {
+			opcode: this.opcode.id.toString(),
+			args: this.args.toJSON()
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/opcode.ts
+var Opcode = class {
+	constructor(id, coder) {
+		this.id = id;
+		this.coder = coder;
+	}
+	argsCoder() {
+		return this.coder;
+	}
+	createIx(args) {
+		return new Instruction(this, args);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/empty.ts
+var EmptyCoder = class {
+	encode(_) {
+		return HexString$1.EMPTY;
+	}
+	decode(_) {
+		return new EmptyArgs();
+	}
+};
+var EmptyArgs = class {
+	static CODER = new EmptyCoder();
+	toJSON() {
+		return null;
+	}
+};
+const EMPTY_OPCODE = new Opcode(Symbol("empty"), EmptyArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/programs/program-builder.ts
+/**
+* Abstract base class for building SwapVM programs
+**/
+var ProgramBuilder = class {
+	program = [];
+	constructor(ixsSet) {
+		this.ixsSet = ixsSet;
+	}
+	/**
+	* Decodes a SwapVM program into builder instructions
+	**/
+	decode(program) {
+		const iter = BytesIter.HexString(program.toString());
+		while (!iter.isEmpty()) {
+			const opcodeIdx = Number(iter.nextByte());
+			const argsLength = Number(iter.nextByte());
+			const argsHex = argsLength ? iter.nextBytes(argsLength) : "0x";
+			if (opcodeIdx === 0) throw new Error("Invalid opcode: 0 (NOT_INSTRUCTION)");
+			const opcode = this.ixsSet[opcodeIdx];
+			if (!opcode) throw new Error(`Opcode at index ${opcodeIdx} is missing`);
+			this.program.push(opcode.createIx(opcode.argsCoder().decode(new HexString$1(argsHex))));
+		}
+		return this;
+	}
+	/**
+	* Builds the SwapVM program bytecode from accumulated instructions
+	**/
+	build() {
+		const builder = new BytesBuilder();
+		for (const ix of this.program) {
+			const { args, opcode } = ix;
+			const opcodeIdx = this.ixsSet.findIndex((o) => o.id === opcode.id);
+			const coder = opcode.argsCoder();
+			const encoded = coder.encode(args);
+			const encodedBytes = trim0x(encoded.toString());
+			builder.addByte(BigInt(opcodeIdx)).addByte(BigInt(encodedBytes.length / 2));
+			if (encodedBytes.length) builder.addBytes(add0x(encodedBytes));
+		}
+		return new SwapVmProgram(builder.asHex());
+	}
+	/**
+	* Returns the current list of instructions in the program
+	**/
+	getInstructions() {
+		return this.program;
+	}
+	/**
+	* Adds an instruction to the program with validation
+	**/
+	add(ix) {
+		const opcodeId = this.ixsSet.findIndex((o) => o.id === ix.opcode.id);
+		if (opcodeId === -1) {
+			const opcodes = this.ixsSet.map((i) => String(i.id)).filter((s) => s !== EMPTY_OPCODE.toString()).join(", ");
+			throw new Error(`Invalid opcode ${String(ix.opcode.id)}: Supported opcodes: ${opcodes}`);
+		}
+		this.program.push(ix);
+		return this;
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/balances/balances-args-coder.ts
+var BalancesArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint16(BigInt(args.tokenBalances.length));
+		for (const { tokenHalf } of args.tokenBalances) builder.addBytes(tokenHalf.toString());
+		for (const { value } of args.tokenBalances) builder.addUint256(value);
+		return new HexString$1(builder.asHex());
+	}
+	decode(data) {
+		const iter = BytesIter.HexString(data.toString());
+		const tokenCount = Number(iter.nextUint16());
+		const tokenHalfs = [];
+		for (let i = 0; i < tokenCount; i++) {
+			const bytes = iter.nextBytes(10);
+			const hexString = add0x(bytes);
+			tokenHalfs.push(AddressHalf.fromHex(hexString));
+		}
+		const tokenBalances = [];
+		for (let i = 0; i < tokenCount; i++) tokenBalances.push({
+			tokenHalf: tokenHalfs[i],
+			value: BigInt(iter.nextUint256())
+		});
+		return new BalancesArgs(tokenBalances);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/balances/balances-args.ts
+/**
+* Arguments for setBalances and balances instructions containing token-amount pairs
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Balances.sol#L10
+**/
+var BalancesArgs = class BalancesArgs {
+	static CODER = new BalancesArgsCoder();
+	constructor(tokenBalances) {
+		this.tokenBalances = tokenBalances;
+	}
+	/**
+	*  Decodes hex data into BalancesArgs instance
+	**/
+	static decode(data) {
+		return BalancesArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return { tokenBalances: this.tokenBalances.map(({ tokenHalf, value }) => ({
+			token: tokenHalf.toString(),
+			value: value.toString()
+		})) };
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/balances/opcodes.ts
+/**
+* Sets initial token balances for the swap program
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Balances.sol#L59
+**/
+const staticBalancesXD = new Opcode(Symbol("Balances.staticBalancesXD"), BalancesArgs.CODER);
+/**
+* Reads token balances from program data or contract storage
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Balances.sol#L89
+**/
+const dynamicBalancesXD = new Opcode(Symbol("Balances.dynamicBalancesXD"), BalancesArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/balances/index.ts
+var balances_exports = {};
+__export(balances_exports, {
+	BalancesArgs: () => BalancesArgs,
+	dynamicBalancesXD: () => dynamicBalancesXD,
+	staticBalancesXD: () => staticBalancesXD
+});
+
+//#endregion
+//#region src/swap-vm/instructions/controls/jump-args-coder.ts
+var JumpArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint16(args.nextPC);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.BigInt(data.toString());
+		const nextPC = iter.nextUint16();
+		return new JumpArgs(nextPC);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/jump-args.ts
+const UINT_16_MAX$1 = 0xffffn;
+/**
+* Arguments for jump instructions containing target program counter
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Controls.sol#L10
+**/
+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`);
+	}
+	/**
+	* Decodes hex data into JumpArgs instance
+	**/
+	static decode(data) {
+		return JumpArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return { nextPC: this.nextPC };
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/jump-if-token-args-coder.ts
+var JumpIfTokenArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addBytes(args.tokenTail.toString());
+		builder.addUint16(args.nextPC);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.HexString(data.toString());
+		const tokenTailBytes = iter.nextBytes(10);
+		const tokenTail = AddressHalf.fromHex(tokenTailBytes);
+		const nextPC = BigInt(iter.nextUint16());
+		return new JumpIfTokenArgs(tokenTail, nextPC);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/jump-if-token-args.ts
+var JumpIfTokenArgs = class JumpIfTokenArgs {
+	static CODER = new JumpIfTokenArgsCoder();
+	constructor(tokenTail, nextPC) {
+		this.tokenTail = tokenTail;
+		this.nextPC = nextPC;
+	}
+	static decode(data) {
+		return JumpIfTokenArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			tokenTail: this.tokenTail.toString(),
+			nextPC: this.nextPC
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/deadline-args-coder.ts
+var DeadlineArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint40(args.deadline);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.BigInt(data.toString());
+		const deadline$1 = iter.nextUint40();
+		return new DeadlineArgs(deadline$1);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/deadline-args.ts
+var DeadlineArgs = class DeadlineArgs {
+	static CODER = new DeadlineArgsCoder();
+	constructor(deadline$1) {
+		this.deadline = deadline$1;
+	}
+	static decode(data) {
+		return DeadlineArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return { deadline: this.deadline.toString() };
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/only-taker-token-balance-non-zero-args-coder.ts
+var OnlyTakerTokenBalanceNonZeroArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addAddress(args.token.toString());
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.HexString(data.toString());
+		const token = new Address$1(iter.nextUint160());
+		return new OnlyTakerTokenBalanceNonZeroArgs(token);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/only-taker-token-balance-non-zero-args.ts
+/**
+* Arguments for checking if taker holds any amount of a token
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Controls.sol#L10
+**/
+var OnlyTakerTokenBalanceNonZeroArgs = class OnlyTakerTokenBalanceNonZeroArgs {
+	static CODER = new OnlyTakerTokenBalanceNonZeroArgsCoder();
+	constructor(token) {
+		this.token = token;
+	}
+	/**
+	* Decodes hex data into OnlyTakerTokenBalanceNonZeroArgs instance
+	**/
+	static decode(data) {
+		return OnlyTakerTokenBalanceNonZeroArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return { token: this.token.toString() };
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/only-taker-token-balance-gte-args-coder.ts
+var OnlyTakerTokenBalanceGteArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addAddress(args.token.toString());
+		builder.addUint256(args.minAmount);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.HexString(data.toString());
+		const token = new Address$1(iter.nextUint160());
+		const minAmount = BigInt(iter.nextUint256());
+		return new OnlyTakerTokenBalanceGteArgs(token, minAmount);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/only-taker-token-balance-gte-args.ts
+/**
+* Arguments for checking if taker holds at least specified amount of token
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Controls.sol#L10
+**/
+var OnlyTakerTokenBalanceGteArgs = class OnlyTakerTokenBalanceGteArgs {
+	static CODER = new OnlyTakerTokenBalanceGteArgsCoder();
+	constructor(token, minAmount) {
+		this.token = token;
+		this.minAmount = minAmount;
+		assert$1(minAmount >= 0n, "minAmount must be non-negative");
+	}
+	/**
+	* Decodes hex data into OnlyTakerTokenBalanceGteArgs instance
+	**/
+	static decode(data) {
+		return OnlyTakerTokenBalanceGteArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			token: this.token.toString(),
+			minAmount: this.minAmount.toString()
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/only-taker-token-supply-share-gte-args-coder.ts
+var OnlyTakerTokenSupplyShareGteArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addAddress(args.token.toString());
+		builder.addUint64(args.minShareE18);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.HexString(data.toString());
+		const token = new Address$1(iter.nextUint160());
+		const bytes = iter.nextBytes(8);
+		const minShareE18 = BigInt(add0x(bytes));
+		return new OnlyTakerTokenSupplyShareGteArgs(token, minShareE18);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/only-taker-token-supply-share-gte-args.ts
+const UINT_64_MAX$1 = 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
+**/
+var OnlyTakerTokenSupplyShareGteArgs = class OnlyTakerTokenSupplyShareGteArgs {
+	static CODER = new OnlyTakerTokenSupplyShareGteArgsCoder();
+	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`);
+	}
+	/**
+	* Decodes hex data into OnlyTakerTokenSupplyShareGteArgs instance
+	**/
+	static decode(data) {
+		return OnlyTakerTokenSupplyShareGteArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			token: this.token.toString(),
+			minShareE18: this.minShareE18.toString()
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/salt-args-coder.ts
+var SaltArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint64(args.salt);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.BigInt(data.toString());
+		const bytes = iter.nextUint64();
+		return new SaltArgs(bytes);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/salt-args.ts
+/**
+* Arguments for salt instruction used to add uniqueness to order hashes
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Controls.sol#L48
+**/
+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`);
+	}
+	/**
+	* Decodes hex data into SaltArgs instance
+	**/
+	static decode(data) {
+		return SaltArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return { salt: this.salt.toString() };
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/controls/opcodes.ts
+/**
+*  Unconditional jump to specified program counter
+*  @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Controls.sol#L52
+**/
+const jump = new Opcode(Symbol("Controls.jump"), JumpArgs.CODER);
+const jumpIfTokenIn = new Opcode(Symbol("Controls.jumpIfTokenIn"), JumpIfTokenArgs.CODER);
+const jumpIfTokenOut = new Opcode(Symbol("Controls.jumpIfTokenOut"), JumpIfTokenArgs.CODER);
+const deadline = new Opcode(Symbol("Controls.deadline"), DeadlineArgs.CODER);
+/**
+* Requires taker to hold any amount of specified token (supports NFTs)
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Controls.sol#L77
+**/
+const onlyTakerTokenBalanceNonZero = new Opcode(Symbol("Controls.onlyTakerTokenBalanceNonZero"), OnlyTakerTokenBalanceNonZeroArgs.CODER);
+/**
+* Requires taker to hold at least specified amount of token
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Controls.sol#L86
+*/
+const onlyTakerTokenBalanceGte = new Opcode(Symbol("Controls.onlyTakerTokenBalanceGte"), OnlyTakerTokenBalanceGteArgs.CODER);
+/**
+* Requires taker to hold at least specified share of token's total supply
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Controls.sol#L96
+**/
+const onlyTakerTokenSupplyShareGte = new Opcode(Symbol("Controls.onlyTakerTokenSupplyShareGte"), OnlyTakerTokenSupplyShareGteArgs.CODER);
+/**
+* No-op instruction used to add uniqueness to order hashes (prevents replay attacks)
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Controls.sol#L48
+**/
+const salt = new Opcode(Symbol("Controls.salt"), SaltArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/controls/index.ts
+var controls_exports = {};
+__export(controls_exports, {
+	DeadlineArgs: () => DeadlineArgs,
+	JumpArgs: () => JumpArgs,
+	JumpIfTokenArgs: () => JumpIfTokenArgs,
+	OnlyTakerTokenBalanceGteArgs: () => OnlyTakerTokenBalanceGteArgs,
+	OnlyTakerTokenBalanceNonZeroArgs: () => OnlyTakerTokenBalanceNonZeroArgs,
+	OnlyTakerTokenSupplyShareGteArgs: () => OnlyTakerTokenSupplyShareGteArgs,
+	SaltArgs: () => SaltArgs,
+	deadline: () => deadline,
+	jump: () => jump,
+	jumpIfTokenIn: () => jumpIfTokenIn,
+	jumpIfTokenOut: () => jumpIfTokenOut,
+	onlyTakerTokenBalanceGte: () => onlyTakerTokenBalanceGte,
+	onlyTakerTokenBalanceNonZero: () => onlyTakerTokenBalanceNonZero,
+	onlyTakerTokenSupplyShareGte: () => onlyTakerTokenSupplyShareGte,
+	salt: () => salt
+});
+
+//#endregion
+//#region src/swap-vm/instructions/invalidators/invalidate-bit-1d-args-coder.ts
+var InvalidateBit1DArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint32(args.bitIndex);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.BigInt(data.toString());
+		const bitIndex = iter.nextUint32();
+		return new InvalidateBit1DArgs(bitIndex);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/invalidators/invalidate-bit-1d-args.ts
+/**
+* Arguments for invalidateBit1D instruction to invalidate a specific bit index
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Invalidators.sol#L75
+**/
+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`);
+	}
+	/**
+	* Decodes hex data into InvalidateBit1DArgs instance
+	**/
+	static decode(data) {
+		return InvalidateBit1DArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return { bitIndex: this.bitIndex.toString() };
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/invalidators/invalidate-token-in-1d-args-coder.ts
+var InvalidateTokenIn1DArgsCoder = class {
+	encode(_args) {
+		return new HexString$1("0x");
+	}
+	decode(_data) {
+		return new InvalidateTokenIn1DArgs();
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/invalidators/invalidate-token-in-1d-args.ts
+var InvalidateTokenIn1DArgs = class InvalidateTokenIn1DArgs {
+	static CODER = new InvalidateTokenIn1DArgsCoder();
+	constructor() {}
+	static decode(data) {
+		return InvalidateTokenIn1DArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/invalidators/invalidate-token-out-1d-args-coder.ts
+var InvalidateTokenOut1DArgsCoder = class {
+	encode(_args) {
+		return new HexString$1("0x");
+	}
+	decode(_data) {
+		return new InvalidateTokenOut1DArgs();
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/invalidators/invalidate-token-out-1d-args.ts
+var InvalidateTokenOut1DArgs = class InvalidateTokenOut1DArgs {
+	static CODER = new InvalidateTokenOut1DArgsCoder();
+	constructor() {}
+	static decode(data) {
+		return InvalidateTokenOut1DArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/invalidators/opcodes.ts
+/**
+* Invalidates a specific bit index for order uniqueness
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Invalidators.sol#L75
+**/
+const invalidateBit1D = new Opcode(Symbol("Invalidators.invalidateBit1D"), InvalidateBit1DArgs.CODER);
+/**
+* Invalidates order by token input to prevent re-use
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Invalidators.sol#L85
+**/
+const invalidateTokenIn1D = new Opcode(Symbol("Invalidators.invalidateTokenIn1D"), InvalidateTokenIn1DArgs.CODER);
+/**
+* Invalidates order by token output to prevent re-use
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Invalidators.sol#L103
+**/
+const invalidateTokenOut1D = new Opcode(Symbol("Invalidators.invalidateTokenOut1D"), InvalidateTokenOut1DArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/invalidators/index.ts
+var invalidators_exports = {};
+__export(invalidators_exports, {
+	InvalidateBit1DArgs: () => InvalidateBit1DArgs,
+	InvalidateTokenIn1DArgs: () => InvalidateTokenIn1DArgs,
+	InvalidateTokenOut1DArgs: () => InvalidateTokenOut1DArgs,
+	invalidateBit1D: () => invalidateBit1D,
+	invalidateTokenIn1D: () => invalidateTokenIn1D,
+	invalidateTokenOut1D: () => invalidateTokenOut1D
+});
+
+//#endregion
+//#region src/swap-vm/instructions/xyc-swap/xyc-swap-xd-args-coder.ts
+var XycSwapXDArgsCoder = class {
+	encode(_args) {
+		return new HexString$1("0x");
+	}
+	decode(_data) {
+		return new XycSwapXDArgs();
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/xyc-swap/xyc-swap-xd-args.ts
+/**
+* Arguments for xycSwapXD instruction (no arguments required)
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/XYCSwap.sol#L15
+**/
+var XycSwapXDArgs = class XycSwapXDArgs {
+	static CODER = new XycSwapXDArgsCoder();
+	constructor() {}
+	/**
+	* Decodes hex data into XycSwapXDArgs instance
+	**/
+	static decode(data) {
+		return XycSwapXDArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/xyc-swap/opcodes.ts
+/**
+* Basic swap using constant product formula (x*y=k)
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/XYCSwap.sol#L15
+**/
+const xycSwapXD = new Opcode(Symbol("XYCSwap.xycSwapXD"), XycSwapXDArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/xyc-swap/index.ts
+var xyc_swap_exports = {};
+__export(xyc_swap_exports, {
+	XycSwapXDArgs: () => XycSwapXDArgs,
+	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);
+		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);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/concentrate/concentrate-grow-liquidity-2d-args.ts
+/**
+* Arguments for concentrateGrowLiquidity2D instruction with two deltas
+* @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`);
+	}
+	/**
+	* Helper to create args from token addresses and deltas (handles ordering)
+	**/
+	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);
+	}
+	/**
+	* Decodes hex data into ConcentrateGrowLiquidity2DArgs instance
+	**/
+	static decode(data) {
+		return ConcentrateGrowLiquidity2DArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			deltaLt: this.deltaLt.toString(),
+			deltaGt: this.deltaGt.toString()
+		};
+	}
+};
+
+//#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);
+	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)
+	};
+}
+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);
+}
+
+//#endregion
+//#region src/swap-vm/instructions/concentrate/index.ts
+var concentrate_exports = {};
+__export(concentrate_exports, {
+	ConcentrateGrowLiquidity2DArgs: () => ConcentrateGrowLiquidity2DArgs,
+	ConcentrateGrowLiquidityXDArgs: () => ConcentrateGrowLiquidityXDArgs,
+	computeDeltas: () => computeDeltas,
+	concentrateGrowLiquidity2D: () => concentrateGrowLiquidity2D,
+	concentrateGrowLiquidityXD: () => concentrateGrowLiquidityXD
+});
+
+//#endregion
+//#region src/swap-vm/instructions/decay/decay-xd-args-coder.ts
+var DecayXDArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint16(args.decayPeriod);
+		return new HexString$1(builder.asHex());
+	}
+	decode(data) {
+		const iter = BytesIter.BigInt(data.toString());
+		const decayPeriod = iter.nextUint16();
+		return new DecayXDArgs(decayPeriod);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/decay/decay-xd-args.ts
+/**
+* Arguments for decayXD instruction with decay period
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Decay.sol#L79
+**/
+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`);
+	}
+	/**
+	* Decodes hex data into DecayXDArgs instance
+	**/
+	static decode(data) {
+		return DecayXDArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return { decayPeriod: this.decayPeriod.toString() };
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/decay/opcodes.ts
+/**
+* Applies time-based decay to balance adjustments
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Decay.sol#L79
+**/
+const decayXD = new Opcode(Symbol("Decay.decayXD"), DecayXDArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/decay/index.ts
+var decay_exports = {};
+__export(decay_exports, {
+	DecayXDArgs: () => DecayXDArgs,
+	decayXD: () => decayXD
+});
+
+//#endregion
+//#region src/swap-vm/instructions/limit-swap/limit-swap-direction-args-coder.ts
+var LimitSwapDirectionArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint8(args.makerDirectionLt ? 1n : 0n);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.BigInt(data.toString());
+		const makerDirectionLt = iter.nextUint8() !== 0n;
+		return new LimitSwapDirectionArgs(makerDirectionLt);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/limit-swap/limit-swap-direction-args.ts
+/**
+* Arguments for limit swap instructions (limitSwap1D, limitSwapOnlyFull1D)
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/LimitSwap.sol#L27
+**/
+var LimitSwapDirectionArgs = class LimitSwapDirectionArgs {
+	static CODER = new LimitSwapDirectionArgsCoder();
+	constructor(makerDirectionLt) {
+		this.makerDirectionLt = makerDirectionLt;
+	}
+	static fromTokens(tokenIn, tokenOut) {
+		return new LimitSwapDirectionArgs(BigInt(tokenIn.toString()) < BigInt(tokenOut.toString()));
+	}
+	/**
+	* Decodes hex data into LimitSwapDirectionArgs instance
+	**/
+	static decode(data) {
+		return LimitSwapDirectionArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return { makerDirectionLt: this.makerDirectionLt };
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/limit-swap/opcodes.ts
+/**
+* Limit order swap with proportional execution
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/LimitSwap.sol#L27
+**/
+const limitSwap1D = new Opcode(Symbol("LimitSwap.limitSwap1D"), LimitSwapDirectionArgs.CODER);
+/**
+* Limit order swap requiring full amount execution
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/LimitSwap.sol#L44
+**/
+const limitSwapOnlyFull1D = new Opcode(Symbol("LimitSwap.limitSwapOnlyFull1D"), LimitSwapDirectionArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/limit-swap/index.ts
+var limit_swap_exports = {};
+__export(limit_swap_exports, {
+	LimitSwapDirectionArgs: () => LimitSwapDirectionArgs,
+	limitSwap1D: () => limitSwap1D,
+	limitSwapOnlyFull1D: () => limitSwapOnlyFull1D
+});
+
+//#endregion
+//#region src/swap-vm/instructions/min-rate/min-rate-args-coder.ts
+var MinRateArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint64(args.rateLt);
+		builder.addUint64(args.rateGt);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.BigInt(data.toString());
+		const rateLt = iter.nextUint64();
+		const rateGt = iter.nextUint64();
+		return new MinRateArgs(rateLt, rateGt);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/min-rate/min-rate-args.ts
+/**
+* Arguments for min rate instructions (requireMinRate1D, adjustMinRate1D)
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/MinRate.sol#L36
+**/
+var MinRateArgs = class MinRateArgs {
+	static CODER = new MinRateArgsCoder();
+	/**
+	* rateLt - minimum acceptable rate for token with lower address (uint64)
+	* rateGt - minimum acceptable rate for token with higher address (uint64)
+	**/
+	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`);
+	}
+	static fromTokens(tokenA, tokenB, rateA, rateB) {
+		if (BigInt(tokenA.toString()) < BigInt(tokenB.toString())) return new MinRateArgs(rateA, rateB);
+		return new MinRateArgs(rateB, rateA);
+	}
+	/**
+	* Decodes hex data into MinRateArgs instance
+	**/
+	static decode(data) {
+		return MinRateArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			rateLt: this.rateLt.toString(),
+			rateGt: this.rateGt.toString()
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/min-rate/opcodes.ts
+/**
+* Enforces minimum exchange rate or reverts
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/MinRate.sol#L36
+**/
+const requireMinRate1D = new Opcode(Symbol("MinRate.requireMinRate1D"), MinRateArgs.CODER);
+/**
+* Adjusts swap amounts to meet minimum rate if needed
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/MinRate.sol#L50
+**/
+const adjustMinRate1D = new Opcode(Symbol("MinRate.adjustMinRate1D"), MinRateArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/min-rate/index.ts
+var min_rate_exports = {};
+__export(min_rate_exports, {
+	MinRateArgs: () => MinRateArgs,
+	adjustMinRate1D: () => adjustMinRate1D,
+	requireMinRate1D: () => requireMinRate1D
+});
+
+//#endregion
+//#region src/swap-vm/instructions/dutch-auction/dutch-auction-args-coder.ts
+var DutchAuctionArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint40(args.startTime);
+		builder.addUint16(args.duration);
+		builder.addUint32(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();
+		return new DutchAuctionArgs(startTime, duration, decayFactor);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/dutch-auction/dutch-auction-args.ts
+/**
+* @notice Dutch Auction instruction for time-based price decay with deadline
+* @dev Implements an exponential decay auction mechanism that works after any swap:
+* - Designed to be used after any swap instruction (LimitSwap, XYCSwap, etc.) which sets amounts
+* - Applies time-based decay to the amounts calculated by the previous swap
+* - Maker sells token0 and receives token1
+* - Price improves for taker over time through exponential decay until deadline
+* - Reverts if current time exceeds deadline
+* - 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
+*
+* Example usage:
+* 1. Any swap instruction sets: 100 token1 → 1000 token0
+* 2. DutchAuction with decayFactor = 0.99e18, after 100 seconds:
+*    - exactIn: Taker gets ~2.73x more token0 for the same token1
+*    - exactOut: Taker needs only ~36.6% of initial token1
+* 3. After deadline, the auction expires and cannot be executed
+*
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/DutchAuction.sol#L66
+*/
+var DutchAuctionArgs = class DutchAuctionArgs {
+	static CODER = new DutchAuctionArgsCoder();
+	/**
+	* startTime - auction start time (uint40)
+	* duration - auction duration in seconds (uint16)
+	* decayFactor - price decay per second, 1e18 = no decay (uint32)
+	**/
+	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}`);
+	}
+	/**
+	* Decodes hex data into DutchAuctionArgs instance
+	**/
+	static decode(data) {
+		return DutchAuctionArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			startTime: this.startTime.toString(),
+			duration: this.duration.toString(),
+			decayFactor: this.decayFactor.toString()
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/dutch-auction/opcodes.ts
+/**
+* Dutch auction with time-based decay on amountIn
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/DutchAuction.sol#L75
+**/
+const dutchAuctionBalanceIn1D = new Opcode(Symbol("DutchAuction.dutchAuctionBalanceIn1D"), DutchAuctionArgs.CODER);
+/**
+* Dutch auction with time-based decay on amountOut
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/DutchAuction.sol#L85
+**/
+const dutchAuctionBalanceOut1D = new Opcode(Symbol("DutchAuction.dutchAuctionBalanceOut1D"), DutchAuctionArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/dutch-auction/index.ts
+var dutch_auction_exports = {};
+__export(dutch_auction_exports, {
+	DutchAuctionArgs: () => DutchAuctionArgs,
+	dutchAuctionBalanceIn1D: () => dutchAuctionBalanceIn1D,
+	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 {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint64(args.baseGasPrice);
+		builder.addUint96(args.ethToToken1Price);
+		builder.addUint24(args.gasAmount);
+		builder.addUint64(args.maxPriceDecay);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.BigInt(data.toString());
+		const baseGasPrice = iter.nextUint64();
+		const ethToToken1Price = iter.nextUint96();
+		const gasAmount = iter.nextUint24();
+		const maxPriceDecay = iter.nextUint64();
+		return new BaseFeeAdjusterArgs(baseGasPrice, ethToToken1Price, gasAmount, maxPriceDecay);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/base-fee-adjuster/base-fee-adjuster-args.ts
+/**
+* @notice Base Fee Gas Price Adjuster instruction for dynamic price adjustment based on network gas costs
+* @dev Adjusts swap prices based on current gas conditions to compensate for transaction costs:
+* - Works only for 1=>0 swaps (token1 to token0), compatible with LimitSwap and DutchAuction
+* - When gas price exceeds base level, maker improves the price to compensate taker for gas costs
+* - The adjustment is proportional to the difference between current and base gas prices
+* - Maximum adjustment is limited by maxPriceDecay parameter
+*
+* This creates adaptive limit orders that automatically become more attractive during high gas periods,
+* ensuring execution even when transaction costs are elevated.
+*
+* Example usage:
+* 1. LimitSwap sets base price: 1 ETH for 3000 USDC
+* 2. BaseFeeAdjuster with baseGasPrice=20 gwei, current=100 gwei
+* 3. Extra cost = 80 gwei * 150k gas * 3000 USDC/ETH = 36 USDC
+* 4. With maxPriceDecay=0.99e18 (1% max), final price: 1 ETH for 2970 USDC
+*
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/BaseFeeAdjuster.sol#L75
+*/
+var BaseFeeAdjusterArgs = class BaseFeeAdjusterArgs {
+	static CODER = new BaseFeeAdjusterArgsCoder();
+	/**
+	* baseGasPrice - base gas price for comparison (uint64)
+	* ethToToken1Price - ETH price in token1 units, e.g.,
+	* 3000e18 for 1 ETH = 3000 USDC (uint96)
+	* gasAmount - gas amount to compensate for (uint24)
+	**/
+	constructor(baseGasPrice, ethToToken1Price, gasAmount, maxPriceDecay) {
+		this.baseGasPrice = baseGasPrice;
+		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`);
+	}
+	/**
+	* Decodes hex data into BaseFeeAdjusterArgs instance
+	**/
+	static decode(data) {
+		return BaseFeeAdjusterArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			baseGasPrice: this.baseGasPrice.toString(),
+			ethToToken1Price: this.ethToToken1Price.toString(),
+			gasAmount: this.gasAmount.toString(),
+			maxPriceDecay: this.maxPriceDecay.toString()
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/base-fee-adjuster/opcodes.ts
+/**
+* Adjusts swap prices based on network gas costs
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/BaseFeeAdjuster.sol#L75
+**/
+const baseFeeAdjuster1D = new Opcode(Symbol("BaseFeeAdjuster.baseFeeAdjuster1D"), BaseFeeAdjusterArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/base-fee-adjuster/index.ts
+var base_fee_adjuster_exports = {};
+__export(base_fee_adjuster_exports, {
+	BaseFeeAdjusterArgs: () => BaseFeeAdjusterArgs,
+	baseFeeAdjuster1D: () => baseFeeAdjuster1D
+});
+
+//#endregion
+//#region src/swap-vm/instructions/twap-swap/twap-swap-args-coder.ts
+var TWAPSwapArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint256(args.balanceIn);
+		builder.addUint256(args.balanceOut);
+		builder.addUint256(args.startTime);
+		builder.addUint256(args.duration);
+		builder.addUint256(args.priceBumpAfterIlliquidity);
+		builder.addUint256(args.minTradeAmountOut);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.BigInt(data.toString());
+		const balanceIn = iter.nextUint256();
+		const balanceOut = iter.nextUint256();
+		const startTime = iter.nextUint256();
+		const duration = iter.nextUint256();
+		const priceBumpAfterIlliquidity = iter.nextUint256();
+		const minTradeAmountOut = iter.nextUint256();
+		return new TWAPSwapArgs(balanceIn, balanceOut, startTime, duration, priceBumpAfterIlliquidity, minTradeAmountOut);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/twap-swap/twap-swap-args.ts
+/**
+* @notice TWAP Hook with exponential dutch auction and illiquidity handling
+* @dev Implements a TWAP (Time-Weighted Average Price) selling strategy with the following features:
+* - Linear liquidity unlocking over time
+* - Exponential price decay (dutch auction) for better price discovery
+* - Automatic price bump after periods of insufficient liquidity
+* - Minimum trade size enforcement during TWAP duration
+*
+* Minimum Trade Size (minTradeAmountOut):
+* The minimum trade size protects against gas cost impact on execution price.
+* It should be set 1000x+ larger than the expected transaction fees on the deployment network.
+*
+* For example:
+* - Ethereum mainnet with $50 gas cost → minTradeAmountOut should be $50,000+
+* - Arbitrum/Optimism with $0.50 gas cost → minTradeAmountOut should be $500+
+* - BSC/Polygon with $0.05 gas cost → minTradeAmountOut should be $50+
+*
+* This ensures gas costs remain negligible (<0.1%) relative to trade value.
+*
+* Price Bump Configuration Guidelines:
+*
+* The priceBumpAfterIlliquidity compensates for mandatory waiting periods due to linear unlocking.
+* Time to unlock minTradeAmountOut = (minTradeAmountOut / balance0) * duration
+*
+* Examples:
+* - minTradeAmountOut = 0.1% of balance0, duration = 24h → 14.4 min to unlock each min trade
+*   Recommended bump: 1.05e18 - 1.10e18 (5-10%)
+*
+* - minTradeAmountOut = 1% of balance0, duration = 24h → 14.4 min to unlock each min trade
+*   Recommended bump: 1.10e18 - 1.20e18 (10-20%)
+*
+* - minTradeAmountOut = 5% of balance0, duration = 24h → 1.2 hours to unlock each min trade
+*   Recommended bump: 1.30e18 - 1.50e18 (30-50%)
+*
+* - minTradeAmountOut = 10% of balance0, duration = 24h → 2.4 hours to unlock each min trade
+*   Recommended bump: 1.50e18 - 2.00e18 (50-100%)
+*
+* Additional factors to consider:
+* - Network gas costs: Higher gas requires larger bumps
+* - Pair volatility: Volatile pairs need larger bumps to compensate for price risk
+* - Market depth: Thin markets may need higher bumps to attract arbitrageurs
+*
+* The bump should ensure profitability after the mandatory waiting period.
+*
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/TWAPSwap.sol#L104
+*/
+var TWAPSwapArgs = class TWAPSwapArgs {
+	static CODER = new TWAPSwapArgsCoder();
+	/**
+	* balanceIn - expected amount of token1 for initial price (uint256)
+	* balanceOut - total amount of token0 for TWAP (uint256)
+	* startTime - TWAP start time (uint256)
+	* duration - TWAP duration (uint256)
+	* priceBumpAfterIlliquidity - price jump when liquidity insufficient, e.g. 1.10e18 = +10% (uint256)
+	* minTradeAmountOut - minimum trade size for token0 (uint256)
+	**/
+	constructor(balanceIn, balanceOut, startTime, duration, priceBumpAfterIlliquidity, minTradeAmountOut) {
+		this.balanceIn = balanceIn;
+		this.balanceOut = balanceOut;
+		this.startTime = startTime;
+		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`);
+	}
+	/**
+	* Decodes hex data into TWAPSwapArgs instance
+	**/
+	static decode(data) {
+		return TWAPSwapArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			balanceIn: this.balanceIn.toString(),
+			balanceOut: this.balanceOut.toString(),
+			startTime: this.startTime.toString(),
+			duration: this.duration.toString(),
+			priceBumpAfterIlliquidity: this.priceBumpAfterIlliquidity.toString(),
+			minTradeAmountOut: this.minTradeAmountOut.toString()
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/twap-swap/opcodes.ts
+/**
+* TWAP trading with exponential dutch auction and illiquidity handling
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/TWAPSwap.sol#L104
+**/
+const twap = new Opcode(Symbol("TWAPSwap.twap"), TWAPSwapArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/twap-swap/index.ts
+var twap_swap_exports = {};
+__export(twap_swap_exports, {
+	TWAPSwapArgs: () => TWAPSwapArgs,
+	twap: () => twap
+});
+
+//#endregion
+//#region src/swap-vm/instructions/fee/flat-fee-args-coder.ts
+var FlatFeeArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint32(args.fee);
+		return new HexString$1(add0x(builder.asHex()));
+	}
+	decode(data) {
+		const iter = BytesIter.BigInt(data.toString());
+		const fee = iter.nextUint32();
+		return new FlatFeeArgs(fee);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/fee/flat-fee-args.ts
+const FEE_100_PERCENT$1 = 1e9;
+/**
+* Arguments for flat fee instructions (flatFeeXD, flatFeeAmountInXD, flatFeeAmountOutXD, progressiveFeeXD)
+* @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}`);
+	}
+	/**
+	* Decodes hex data into FlatFeeArgs instance
+	**/
+	static decode(data) {
+		return FlatFeeArgs.CODER.decode(data);
+	}
+	/**
+	* Creates a FlatFeeArgs instance from percentage
+	* @param percent - Fee as percentage (e.g., 1 for 1%, 0.1 for 0.1%)
+	* @returns FlatFeeArgs instance
+	*/
+	static fromPercent(percent) {
+		return FlatFeeArgs.fromBps(percent * 100);
+	}
+	/**
+	* Creates a FlatFeeArgs instance from basis points
+	* @param bps - Fee in basis points (10000 bps = 100%)
+	* @returns FlatFeeArgs instance
+	*/
+	static fromBps(bps) {
+		const fee = BigInt(bps * 1e5);
+		return new FlatFeeArgs(fee);
+	}
+	toJSON() {
+		return { fee: this.fee.toString() };
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/fee/protocol-fee-args-coder.ts
+var ProtocolFeeArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint32(args.fee);
+		builder.addAddress(args.to.toString());
+		return new HexString$1(builder.asHex());
+	}
+	decode(data) {
+		const iter = BytesIter.HexString(data.toString());
+		const fee = iter.nextUint32();
+		const to = new Address$1(iter.nextAddress());
+		return new ProtocolFeeArgs(BigInt(fee), to);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/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
+**/
+var ProtocolFeeArgs = class ProtocolFeeArgs {
+	static CODER = new ProtocolFeeArgsCoder();
+	/**
+	* fee - 1e9 = 100% (uint32)
+	* to - address to send pulled tokens to (20 bytes)
+	**/
+	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}`);
+	}
+	/**
+	* Decodes hex data into ProtocolFeeArgs instance
+	**/
+	static decode(data) {
+		return ProtocolFeeArgs.CODER.decode(data);
+	}
+	/**
+	* Creates a ProtocolFeeArgs instance from percentage
+	* @param percent - Fee as percentage (e.g., 1 for 1%, 0.1 for 0.1%)
+	* @param to - Address to receive the protocol fee
+	* @returns ProtocolFeeArgs instance
+	*/
+	static fromPercent(percent, to) {
+		return ProtocolFeeArgs.fromBps(percent * 100, to);
+	}
+	/**
+	* Creates a ProtocolFeeArgs instance from basis points
+	* @param bps - Fee in basis points (10000 bps = 100%)
+	* @param to - Address to receive the protocol fee
+	* @returns ProtocolFeeArgs instance
+	*/
+	static fromBps(bps, to) {
+		const fee = BigInt(bps * 1e5);
+		return new ProtocolFeeArgs(fee, to);
+	}
+	toJSON() {
+		return {
+			fee: this.fee.toString(),
+			to: this.to.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
+**/
+const flatFeeAmountInXD = new Opcode(Symbol("Fee.flatFeeAmountInXD"), FlatFeeArgs.CODER);
+/**
+* Applies fee to amountOut
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L72
+**/
+const flatFeeAmountOutXD = new Opcode(Symbol("Fee.flatFeeAmountOutXD"), FlatFeeArgs.CODER);
+/**
+* Applies progressive fee to amountIn
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L78
+**/
+const progressiveFeeInXD = new Opcode(Symbol("Fee.progressiveFeeInXD"), FlatFeeArgs.CODER);
+/**
+* Applies progressive fee to amountOut
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Fee.sol#L106
+**/
+const progressiveFeeOutXD = new Opcode(Symbol("Fee.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
+**/
+const protocolFeeAmountOutXD = new Opcode(Symbol("Fee.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
+**/
+const aquaProtocolFeeAmountOutXD = new Opcode(Symbol("Fee.aquaProtocolFeeAmountOutXD"), ProtocolFeeArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/fee/index.ts
+var fee_exports = {};
+__export(fee_exports, {
+	FlatFeeArgs: () => FlatFeeArgs,
+	ProtocolFeeArgs: () => ProtocolFeeArgs,
+	aquaProtocolFeeAmountOutXD: () => aquaProtocolFeeAmountOutXD,
+	flatFeeAmountInXD: () => flatFeeAmountInXD,
+	flatFeeAmountOutXD: () => flatFeeAmountOutXD,
+	progressiveFeeInXD: () => progressiveFeeInXD,
+	progressiveFeeOutXD: () => progressiveFeeOutXD,
+	protocolFeeAmountOutXD: () => protocolFeeAmountOutXD
+});
+
+//#endregion
+//#region src/swap-vm/instructions/extruction/extruction-args-coder.ts
+var ExtructionArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addAddress(args.target.toString());
+		builder.addBytes(args.extructionArgs.toString());
+		return new HexString$1(builder.asHex());
+	}
+	decode(data) {
+		const iter = BytesIter.HexString(data.toString());
+		const target = new Address$1(iter.nextAddress());
+		const extructionArgs = new HexString$1(iter.rest());
+		return new ExtructionArgs(target, extructionArgs);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/extruction/extruction-args.ts
+/**
+* Arguments for extruction instruction to call external contract logic
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Extruction.sol#L33
+**/
+var ExtructionArgs = class ExtructionArgs {
+	static CODER = new ExtructionArgsCoder();
+	/**
+	* target - External contract address (20 bytes)
+	* extructionArgs - Arguments to pass to external contract (variable)
+	**/
+	constructor(target, extructionArgs) {
+		this.target = target;
+		this.extructionArgs = extructionArgs;
+	}
+	/**
+	* Decodes hex data into ExtructionArgs instance
+	**/
+	static decode(data) {
+		return ExtructionArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			target: this.target.toString(),
+			extructionArgs: this.extructionArgs.toString()
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/extruction/opcodes.ts
+/**
+* Calls external contract to perform custom logic, potentially modifying swap state
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Extruction.sol#L33
+**/
+const extruction = new Opcode(Symbol("Extruction.extruction"), ExtructionArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/extruction/index.ts
+var extruction_exports = {};
+__export(extruction_exports, {
+	ExtructionArgs: () => ExtructionArgs,
+	extruction: () => extruction
+});
+
+//#endregion
+//#region src/swap-vm/instructions/stable-swap/stable-swap-2d-args-coder.ts
+var StableSwap2DArgsCoder = class {
+	encode(args) {
+		const builder = new BytesBuilder();
+		builder.addUint32(args.fee);
+		builder.addUint32(args.A);
+		builder.addUint256(args.rateLt);
+		builder.addUint256(args.rateGt);
+		return new HexString$1(add0x(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);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/stable-swap/stable-swap-2d-args.ts
+/**
+* Arguments for stableSwap2D instruction for stablecoin optimized swaps
+**/
+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;
+		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`);
+	}
+	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);
+	}
+	/**
+	* Decodes hex data into StableSwap2DArgs instance
+	**/
+	static decode(data) {
+		return StableSwap2DArgs.CODER.decode(data);
+	}
+	toJSON() {
+		return {
+			fee: this.fee.toString(),
+			A: this.A.toString(),
+			rateLt: this.rateLt.toString(),
+			rateGt: this.rateGt.toString()
+		};
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/stable-swap/opcodes.ts
+/**
+* Stablecoin optimized swap using StableSwap algorithm (Curve-style)
+**/
+const stableSwap2D = new Opcode(Symbol("StableSwap.stableSwap2D"), StableSwap2DArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/instructions/stable-swap/index.ts
+var stable_swap_exports = {};
+__export(stable_swap_exports, {
+	StableSwap2DArgs: () => StableSwap2DArgs,
+	stableSwap2D: () => stableSwap2D
+});
+
+//#endregion
+//#region src/swap-vm/instructions/index.ts
+var instructions_exports = {};
+__export(instructions_exports, {
+	EMPTY_OPCODE: () => EMPTY_OPCODE,
+	_allInstructions: () => _allInstructions,
+	aquaInstructions: () => aquaInstructions,
+	balances: () => balances_exports,
+	baseFeeAdjuster: () => base_fee_adjuster_exports,
+	concentrate: () => concentrate_exports,
+	controls: () => controls_exports,
+	decay: () => decay_exports,
+	dutchAuction: () => dutch_auction_exports,
+	extruction: () => extruction_exports,
+	fee: () => fee_exports,
+	invalidators: () => invalidators_exports,
+	limitSwap: () => limit_swap_exports,
+	minRate: () => min_rate_exports,
+	oraclePriceAdjuster: () => oracle_price_adjuster_exports,
+	stableSwap: () => stable_swap_exports,
+	twapSwap: () => twap_swap_exports,
+	xycSwap: () => xyc_swap_exports
+});
+/**
+* Regular opcodes array - matching SwapVM contract exactly (44 opcodes)
+* @see https://github.com/1inch/swap-vm/blob/main/src/opcodes/Opcodes.sol#L46
+*/
+const _allInstructions = [
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	jump,
+	jumpIfTokenIn,
+	jumpIfTokenOut,
+	deadline,
+	onlyTakerTokenBalanceNonZero,
+	onlyTakerTokenBalanceGte,
+	onlyTakerTokenSupplyShareGte,
+	staticBalancesXD,
+	dynamicBalancesXD,
+	invalidateBit1D,
+	invalidateTokenIn1D,
+	invalidateTokenOut1D,
+	xycSwapXD,
+	concentrateGrowLiquidityXD,
+	concentrateGrowLiquidity2D,
+	decayXD,
+	limitSwap1D,
+	limitSwapOnlyFull1D,
+	requireMinRate1D,
+	adjustMinRate1D,
+	dutchAuctionBalanceIn1D,
+	dutchAuctionBalanceOut1D,
+	oraclePriceAdjuster1D,
+	baseFeeAdjuster1D,
+	twap,
+	extruction,
+	salt,
+	flatFeeAmountInXD,
+	flatFeeAmountOutXD,
+	progressiveFeeInXD,
+	progressiveFeeOutXD,
+	protocolFeeAmountOutXD,
+	aquaProtocolFeeAmountOutXD
+];
+/**
+* Aqua opcodes array - matching AquaSwapVM contract (29 opcodes)
+* @see https://github.com/1inch/swap-vm/blob/main/src/opcodes/AquaOpcodes.sol#L28
+*/
+const aquaInstructions = [
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	EMPTY_OPCODE,
+	jump,
+	jumpIfTokenIn,
+	jumpIfTokenOut,
+	deadline,
+	onlyTakerTokenBalanceNonZero,
+	onlyTakerTokenBalanceGte,
+	onlyTakerTokenSupplyShareGte,
+	xycSwapXD,
+	concentrateGrowLiquidityXD,
+	concentrateGrowLiquidity2D,
+	decayXD,
+	salt,
+	flatFeeAmountInXD,
+	flatFeeAmountOutXD,
+	progressiveFeeInXD,
+	progressiveFeeOutXD,
+	protocolFeeAmountOutXD,
+	aquaProtocolFeeAmountOutXD
+];
+
+//#endregion
+//#region src/swap-vm/instructions/debug/debug-empty-args.ts
+var DebugEmptyArgsCoder = class {
+	encode(_args) {
+		return HexString$1.EMPTY;
+	}
+	decode(_data) {
+		return new DebugEmptyArgs();
+	}
+};
+/**
+* Debug empty instruction arguments - used for debugging purposes
+* @see https://github.com/1inch/swap-vm/blob/main/src/instructions/Debug.sol
+**/
+var DebugEmptyArgs = class DebugEmptyArgs {
+	static CODER = new DebugEmptyArgsCoder();
+	/**
+	* Decodes hex data into DebugEmptyArgs instance
+	**/
+	static decode(_data) {
+		return DebugEmptyArgs.CODER.decode(_data);
+	}
+	toJSON() {
+		return null;
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/debug/debug-args.ts
+/**
+* Base class for all debug instruction arguments
+* Debug instructions don't have parameters, they just print/log state
+*/
+var DebugArgs = class {
+	toJSON() {
+		return null;
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/debug/print-swap-registers.ts
+var PrintSwapRegistersArgsCoder = class {
+	encode(_args) {
+		return HexString$1.EMPTY;
+	}
+	decode(_data) {
+		return new PrintSwapRegistersArgs();
+	}
+};
+/**
+* Debug instruction to print swap registers
+* @see Debug._printSwapRegisters in Solidity
+*/
+var PrintSwapRegistersArgs = class PrintSwapRegistersArgs extends DebugArgs {
+	static CODER = new PrintSwapRegistersArgsCoder();
+	static decode(_data) {
+		return PrintSwapRegistersArgs.CODER.decode(_data);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/debug/print-swap-query.ts
+var PrintSwapQueryArgsCoder = class {
+	encode(_args) {
+		return HexString$1.EMPTY;
+	}
+	decode(_data) {
+		return new PrintSwapQueryArgs();
+	}
+};
+/**
+* Debug instruction to print swap query information
+* @see Debug._printSwapQuery in Solidity
+*/
+var PrintSwapQueryArgs = class PrintSwapQueryArgs extends DebugArgs {
+	static CODER = new PrintSwapQueryArgsCoder();
+	static decode(_data) {
+		return PrintSwapQueryArgs.CODER.decode(_data);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/debug/print-context.ts
+var PrintContextArgsCoder = class {
+	encode(_args) {
+		return HexString$1.EMPTY;
+	}
+	decode(_data) {
+		return new PrintContextArgs();
+	}
+};
+/**
+* Debug instruction to print execution context
+* @see Debug._printContext in Solidity
+*/
+var PrintContextArgs = class PrintContextArgs extends DebugArgs {
+	static CODER = new PrintContextArgsCoder();
+	static decode(_data) {
+		return PrintContextArgs.CODER.decode(_data);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/debug/print-amount-for-swap.ts
+var PrintAmountForSwapArgsCoder = class {
+	encode(_args) {
+		return HexString$1.EMPTY;
+	}
+	decode(_data) {
+		return new PrintAmountForSwapArgs();
+	}
+};
+/**
+* Debug instruction to print amount for swap
+* @see Debug._printAmountForSwap in Solidity
+*/
+var PrintAmountForSwapArgs = class PrintAmountForSwapArgs extends DebugArgs {
+	static CODER = new PrintAmountForSwapArgsCoder();
+	static decode(_data) {
+		return PrintAmountForSwapArgs.CODER.decode(_data);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/debug/print-free-memory-pointer.ts
+var PrintFreeMemoryPointerArgsCoder = class {
+	encode(_args) {
+		return HexString$1.EMPTY;
+	}
+	decode(_data) {
+		return new PrintFreeMemoryPointerArgs();
+	}
+};
+/**
+* Debug instruction to print free memory pointer
+* @see Debug._printFreeMemoryPointer in Solidity
+*/
+var PrintFreeMemoryPointerArgs = class PrintFreeMemoryPointerArgs extends DebugArgs {
+	static CODER = new PrintFreeMemoryPointerArgsCoder();
+	static decode(_data) {
+		return PrintFreeMemoryPointerArgs.CODER.decode(_data);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/debug/print-gas-left.ts
+var PrintGasLeftArgsCoder = class {
+	encode(_args) {
+		return HexString$1.EMPTY;
+	}
+	decode(_data) {
+		return new PrintGasLeftArgs();
+	}
+};
+/**
+* Debug instruction to print remaining gas
+* @see Debug._printGasLeft in Solidity
+*/
+var PrintGasLeftArgs = class PrintGasLeftArgs extends DebugArgs {
+	static CODER = new PrintGasLeftArgsCoder();
+	static decode(_data) {
+		return PrintGasLeftArgs.CODER.decode(_data);
+	}
+};
+
+//#endregion
+//#region src/swap-vm/instructions/debug/opcodes.ts
+/**
+* Debug empty opcode - placeholder
+*/
+const debugEmpty = new Opcode(Symbol("Debug.Empty"), DebugEmptyArgs.CODER);
+const printSwapRegisters = new Opcode(Symbol("Debug.printSwapRegisters"), PrintSwapRegistersArgs.CODER);
+const printSwapQuery = new Opcode(Symbol("Debug.printSwapQuery"), PrintSwapQueryArgs.CODER);
+const printContext = new Opcode(Symbol("Debug.printContext"), PrintContextArgs.CODER);
+const printAmountForSwap = new Opcode(Symbol("debug.printAmountForSwap"), PrintAmountForSwapArgs.CODER);
+const printFreeMemoryPointer = new Opcode(Symbol("Debug.printFreeMemoryPointer"), PrintFreeMemoryPointerArgs.CODER);
+const printGasLeft = new Opcode(Symbol("Debug.printGasLeft"), PrintGasLeftArgs.CODER);
+
+//#endregion
+//#region src/swap-vm/programs/regular-program-builder.ts
+var RegularProgramBuilder = class RegularProgramBuilder extends ProgramBuilder {
+	constructor() {
+		super([..._allInstructions]);
+	}
+	static decode(program) {
+		return new RegularProgramBuilder().decode(program);
+	}
+	/**
+	* Enables debug mode for the program
+	* WARNING: Debug instructions will throw an error if debug mode is not enabled
+	*/
+	withDebug() {
+		this.ixsSet[0] = printSwapRegisters;
+		this.ixsSet[1] = printSwapQuery;
+		this.ixsSet[2] = printContext;
+		this.ixsSet[3] = printAmountForSwap;
+		this.ixsSet[4] = printFreeMemoryPointer;
+		this.ixsSet[5] = printGasLeft;
+		return this;
+	}
+	/**
+	* Sets initial token balances for the swap program
+	**/
+	staticBalancesXD(data) {
+		super.add(staticBalancesXD.createIx(new BalancesArgs(data.tokenBalances)));
+		return this;
+	}
+	/**
+	* Reads token balances from program data or contract storage
+	**/
+	dynamicBalancesXD(data) {
+		super.add(dynamicBalancesXD.createIx(new BalancesArgs(data.tokenBalances)));
+		return this;
+	}
+	/**
+	* Unconditional jump to specified program counter
+	**/
+	jump(data) {
+		super.add(jump.createIx(new JumpArgs(data.nextPC)));
+		return this;
+	}
+	/**
+	* Jumps if tokenIn is the specified token
+	**/
+	jumpIfTokenIn(data) {
+		super.add(jumpIfTokenIn.createIx(new JumpIfTokenArgs(data.tokenTail, data.nextPC)));
+		return this;
+	}
+	/**
+	* Jumps if tokenOut is the specified token
+	**/
+	jumpIfTokenOut(data) {
+		super.add(jumpIfTokenOut.createIx(new JumpIfTokenArgs(data.tokenTail, data.nextPC)));
+		return this;
+	}
+	/**
+	* Reverts if the deadline has been reached
+	**/
+	deadline(data) {
+		super.add(deadline.createIx(new DeadlineArgs(data.deadline)));
+		return this;
+	}
+	/**
+	* Requires taker to hold any amount of specified token (supports NFTs)
+	**/
+	onlyTakerTokenBalanceNonZero(data) {
+		super.add(onlyTakerTokenBalanceNonZero.createIx(new OnlyTakerTokenBalanceNonZeroArgs(data.token)));
+		return this;
+	}
+	/**
+	* Requires taker to hold at least specified amount of token
+	**/
+	onlyTakerTokenBalanceGte(data) {
+		super.add(onlyTakerTokenBalanceGte.createIx(new OnlyTakerTokenBalanceGteArgs(data.token, data.minAmount)));
+		return this;
+	}
+	/**
+	* Requires taker to hold at least specified share of token's total supply
+	**/
+	onlyTakerTokenSupplyShareGte(data) {
+		super.add(onlyTakerTokenSupplyShareGte.createIx(new OnlyTakerTokenSupplyShareGteArgs(data.token, data.minShareE18)));
+		return this;
+	}
+	/**
+	* No-op instruction used to add uniqueness to order hashes (prevents replay attacks)
+	**/
+	salt(data) {
+		super.add(salt.createIx(new SaltArgs(data.salt)));
+		return this;
+	}
+	/**
+	* Invalidates a specific bit index for order uniqueness
+	**/
+	invalidateBit1D(data) {
+		super.add(invalidateBit1D.createIx(new InvalidateBit1DArgs(data.bitIndex)));
+		return this;
+	}
+	/**
+	* Invalidates order by token input to prevent re-use
+	**/
+	invalidateTokenIn1D() {
+		super.add(invalidateTokenIn1D.createIx(new InvalidateTokenIn1DArgs()));
+		return this;
+	}
+	/**
+	* Invalidates order by token output to prevent re-use
+	**/
+	invalidateTokenOut1D() {
+		super.add(invalidateTokenOut1D.createIx(new InvalidateTokenOut1DArgs()));
+		return this;
+	}
+	/**
+	* Basic swap using constant product formula (x*y=k)
+	**/
+	xycSwapXD() {
+		super.add(xycSwapXD.createIx(new XycSwapXDArgs()));
+		return this;
+	}
+	/**
+	* Concentrates liquidity within price bounds for multiple tokens
+	**/
+	concentrateGrowLiquidityXD(data) {
+		super.add(concentrateGrowLiquidityXD.createIx(new ConcentrateGrowLiquidityXDArgs(data.tokenDeltas)));
+		return this;
+	}
+	/**
+	* Concentrates liquidity within price bounds for two tokens
+	**/
+	concentrateGrowLiquidity2D(data) {
+		super.add(concentrateGrowLiquidity2D.createIx(new ConcentrateGrowLiquidity2DArgs(data.deltaLt, data.deltaGt)));
+		return this;
+	}
+	/**
+	* Applies time-based decay to balance adjustments
+	**/
+	decayXD(data) {
+		super.add(decayXD.createIx(new DecayXDArgs(data.decayPeriod)));
+		return this;
+	}
+	/**
+	* Limit order swap with proportional execution
+	**/
+	limitSwap1D(data) {
+		super.add(limitSwap1D.createIx(new LimitSwapDirectionArgs(data.makerDirectionLt)));
+		return this;
+	}
+	/**
+	* Limit order swap requiring full amount execution
+	**/
+	limitSwapOnlyFull1D(data) {
+		super.add(limitSwapOnlyFull1D.createIx(new LimitSwapDirectionArgs(data.makerDirectionLt)));
+		return this;
+	}
+	/**
+	* Enforces minimum exchange rate or reverts
+	**/
+	requireMinRate1D(data) {
+		super.add(requireMinRate1D.createIx(new MinRateArgs(data.rateLt, data.rateGt)));
+		return this;
+	}
+	/**
+	* Adjusts swap amounts to meet minimum rate if needed
+	**/
+	adjustMinRate1D(data) {
+		super.add(adjustMinRate1D.createIx(new MinRateArgs(data.rateLt, data.rateGt)));
+		return this;
+	}
+	/**
+	* Dutch auction with time-based decay on amountIn
+	**/
+	dutchAuctionBalanceIn1D(data) {
+		super.add(dutchAuctionBalanceIn1D.createIx(new DutchAuctionArgs(data.startTime, data.duration, data.decayFactor)));
+		return this;
+	}
+	/**
+	* Dutch auction with time-based decay on amountOut
+	**/
+	dutchAuctionBalanceOut1D(data) {
+		super.add(dutchAuctionBalanceOut1D.createIx(new DutchAuctionArgs(data.startTime, data.duration, data.decayFactor)));
+		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) {
+		super.add(baseFeeAdjuster1D.createIx(new BaseFeeAdjusterArgs(data.baseGasPrice, data.ethToToken1Price, data.gasAmount, data.maxPriceDecay)));
+		return this;
+	}
+	/**
+	* TWAP trading with exponential dutch auction and illiquidity handling
+	**/
+	twap(data) {
+		super.add(twap.createIx(new TWAPSwapArgs(data.balanceIn, data.balanceOut, data.startTime, data.duration, data.priceBumpAfterIlliquidity, data.minTradeAmountOut)));
+		return this;
+	}
+	/**
+	* Calls external contract to perform custom logic
+	**/
+	extruction(data) {
+		super.add(extruction.createIx(new ExtructionArgs(data.target, data.extructionArgs)));
+		return this;
+	}
+	/**
+	* Applies fee to amountIn
+	**/
+	flatFeeAmountInXD(data) {
+		super.add(flatFeeAmountInXD.createIx(new FlatFeeArgs(data.fee)));
+		return this;
+	}
+	/**
+	* Applies fee to amountOut
+	**/
+	flatFeeAmountOutXD(data) {
+		super.add(flatFeeAmountOutXD.createIx(new FlatFeeArgs(data.fee)));
+		return this;
+	}
+	/**
+	* Applies progressive fee to amountIn
+	**/
+	progressiveFeeInXD(data) {
+		super.add(progressiveFeeInXD.createIx(new FlatFeeArgs(data.fee)));
+		return this;
+	}
+	/**
+	* Applies progressive fee to amountOut
+	**/
+	progressiveFeeOutXD(data) {
+		super.add(progressiveFeeOutXD.createIx(new FlatFeeArgs(data.fee)));
+		return this;
+	}
+	/**
+	* Applies protocol fee to amountOut with direct transfer
+	**/
+	protocolFeeAmountOutXD(data) {
+		super.add(protocolFeeAmountOutXD.createIx(new ProtocolFeeArgs(data.fee, data.to)));
+		return this;
+	}
+	/**
+	* Applies protocol fee to amountOut through Aqua protocol
+	**/
+	aquaProtocolFeeAmountOutXD(data) {
+		super.add(aquaProtocolFeeAmountOutXD.createIx(new ProtocolFeeArgs(data.fee, data.to)));
+		return this;
+	}
+	/**
+	* DEBUG: Prints current swap registers (amounts and tokens)
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintSwapRegisters() {
+		super.add(printSwapRegisters.createIx(new PrintSwapRegistersArgs()));
+		return this;
+	}
+	/**
+	* DEBUG: Prints current swap query state
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintSwapQuery() {
+		super.add(printSwapQuery.createIx(new PrintSwapQueryArgs()));
+		return this;
+	}
+	/**
+	* DEBUG: Prints execution context information
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintContext() {
+		super.add(printContext.createIx(new PrintContextArgs()));
+		return this;
+	}
+	/**
+	* DEBUG: Prints calculated amount for swap
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintAmountForSwap() {
+		super.add(printAmountForSwap.createIx(new PrintAmountForSwapArgs()));
+		return this;
+	}
+	/**
+	* DEBUG: Prints current free memory pointer value
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintFreeMemoryPointer() {
+		super.add(printFreeMemoryPointer.createIx(new PrintFreeMemoryPointerArgs()));
+		return this;
+	}
+	/**
+	* DEBUG: Prints remaining gas
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintGasLeft() {
+		super.add(printGasLeft.createIx(new PrintGasLeftArgs()));
+		return this;
+	}
+};
+
+//#endregion
+//#region src/swap-vm/programs/aqua-program-builder.ts
+var AquaProgramBuilder = class AquaProgramBuilder extends ProgramBuilder {
+	constructor() {
+		super([...aquaInstructions]);
+	}
+	static decode(program) {
+		return new AquaProgramBuilder().decode(program);
+	}
+	/**
+	* Enables debug mode for the program
+	* WARNING: Debug instructions will throw an error if debug mode is not enabled
+	*/
+	withDebug() {
+		this.ixsSet[0] = printSwapRegisters;
+		this.ixsSet[1] = printSwapQuery;
+		this.ixsSet[2] = printContext;
+		this.ixsSet[3] = printAmountForSwap;
+		this.ixsSet[4] = printFreeMemoryPointer;
+		this.ixsSet[5] = printGasLeft;
+		return this;
+	}
+	/**
+	* Unconditional jump to specified program counter
+	**/
+	jump(data) {
+		super.add(jump.createIx(new JumpArgs(data.nextPC)));
+		return this;
+	}
+	/**
+	* Jumps if tokenIn is the specified token
+	**/
+	jumpIfTokenIn(data) {
+		super.add(jumpIfTokenIn.createIx(new JumpIfTokenArgs(data.tokenTail, data.nextPC)));
+		return this;
+	}
+	/**
+	* Jumps if tokenOut is the specified token
+	**/
+	jumpIfTokenOut(data) {
+		super.add(jumpIfTokenOut.createIx(new JumpIfTokenArgs(data.tokenTail, data.nextPC)));
+		return this;
+	}
+	/**
+	* Reverts if the deadline has been reached
+	**/
+	deadline(data) {
+		super.add(deadline.createIx(new DeadlineArgs(data.deadline)));
+		return this;
+	}
+	/**
+	* Requires taker to hold any amount of specified token (supports NFTs)
+	**/
+	onlyTakerTokenBalanceNonZero(data) {
+		super.add(onlyTakerTokenBalanceNonZero.createIx(new OnlyTakerTokenBalanceNonZeroArgs(data.token)));
+		return this;
+	}
+	/**
+	* Requires taker to hold at least specified amount of token
+	**/
+	onlyTakerTokenBalanceGte(data) {
+		super.add(onlyTakerTokenBalanceGte.createIx(new OnlyTakerTokenBalanceGteArgs(data.token, data.minAmount)));
+		return this;
+	}
+	/**
+	* Requires taker to hold at least specified share of token's total supply
+	**/
+	onlyTakerTokenSupplyShareGte(data) {
+		super.add(onlyTakerTokenSupplyShareGte.createIx(new OnlyTakerTokenSupplyShareGteArgs(data.token, data.minShareE18)));
+		return this;
+	}
+	/**
+	* No-op instruction used to add uniqueness to order hashes (prevents replay attacks)
+	**/
+	salt(data) {
+		super.add(salt.createIx(new SaltArgs(data.salt)));
+		return this;
+	}
+	/**
+	* Basic swap using constant product formula (x*y=k)
+	**/
+	xycSwapXD() {
+		super.add(xycSwapXD.createIx(new XycSwapXDArgs()));
+		return this;
+	}
+	/**
+	* Concentrates liquidity within price bounds for multiple tokens
+	**/
+	concentrateGrowLiquidityXD(data) {
+		super.add(concentrateGrowLiquidityXD.createIx(new ConcentrateGrowLiquidityXDArgs(data.tokenDeltas)));
+		return this;
+	}
+	/**
+	* Concentrates liquidity within price bounds for two tokens
+	**/
+	concentrateGrowLiquidity2D(data) {
+		super.add(concentrateGrowLiquidity2D.createIx(new ConcentrateGrowLiquidity2DArgs(data.deltaLt, data.deltaGt)));
+		return this;
+	}
+	/**
+	* Applies time-based decay to balance adjustments
+	**/
+	decayXD(data) {
+		super.add(decayXD.createIx(new DecayXDArgs(data.decayPeriod)));
+		return this;
+	}
+	/**
+	* Applies fee to amountIn
+	**/
+	flatFeeAmountInXD(data) {
+		super.add(flatFeeAmountInXD.createIx(new FlatFeeArgs(data.fee)));
+		return this;
+	}
+	/**
+	* Applies fee to amountOut
+	**/
+	flatFeeAmountOutXD(data) {
+		super.add(flatFeeAmountOutXD.createIx(new FlatFeeArgs(data.fee)));
+		return this;
+	}
+	/**
+	* Applies progressive fee to amountIn
+	**/
+	progressiveFeeInXD(data) {
+		super.add(progressiveFeeInXD.createIx(new FlatFeeArgs(data.fee)));
+		return this;
+	}
+	/**
+	* Applies progressive fee to amountOut
+	**/
+	progressiveFeeOutXD(data) {
+		super.add(progressiveFeeOutXD.createIx(new FlatFeeArgs(data.fee)));
+		return this;
+	}
+	/**
+	* Applies protocol fee to amountOut with direct transfer
+	**/
+	protocolFeeAmountOutXD(data) {
+		super.add(protocolFeeAmountOutXD.createIx(new ProtocolFeeArgs(data.fee, data.to)));
+		return this;
+	}
+	/**
+	* Applies protocol fee to amountOut through Aqua protocol
+	**/
+	aquaProtocolFeeAmountOutXD(data) {
+		super.add(aquaProtocolFeeAmountOutXD.createIx(new ProtocolFeeArgs(data.fee, data.to)));
+		return this;
+	}
+	/**
+	* DEBUG: Prints current swap registers (amounts and tokens)
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintSwapRegisters() {
+		super.add(printSwapRegisters.createIx(new PrintSwapRegistersArgs()));
+		return this;
+	}
+	/**
+	* DEBUG: Prints current swap query state
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintSwapQuery() {
+		super.add(printSwapQuery.createIx(new PrintSwapQueryArgs()));
+		return this;
+	}
+	/**
+	* DEBUG: Prints execution context information
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintContext() {
+		super.add(printContext.createIx(new PrintContextArgs()));
+		return this;
+	}
+	/**
+	* DEBUG: Prints calculated amount for swap
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintAmountForSwap() {
+		super.add(printAmountForSwap.createIx(new PrintAmountForSwapArgs()));
+		return this;
+	}
+	/**
+	* DEBUG: Prints current free memory pointer value
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintFreeMemoryPointer() {
+		super.add(printFreeMemoryPointer.createIx(new PrintFreeMemoryPointerArgs()));
+		return this;
+	}
+	/**
+	* DEBUG: Prints remaining gas
+	* WARNING: Requires withDebug() to be called first, otherwise will throw an error
+	*/
+	debugPrintGasLeft() {
+		super.add(printGasLeft.createIx(new PrintGasLeftArgs()));
+		return this;
+	}
+};
+
+//#endregion
+//#region src/swap-vm/order.ts
+/**
+* Representation of a SwapVM order.
+*/
+var Order = class Order {
+	static ABI = {
+		type: "tuple",
+		components: [
+			{
+				name: "maker",
+				type: "address"
+			},
+			{
+				name: "traits",
+				type: "uint256"
+			},
+			{
+				name: "data",
+				type: "bytes"
+			}
+		]
+	};
+	constructor(maker, traits, program) {
+		this.maker = maker;
+		this.traits = traits;
+		this.program = program;
+	}
+	static new(params) {
+		return new Order(params.maker, params.traits, params.program);
+	}
+	/**
+	* Reconstructs an `Order` from its ABI-encoded representation.
+	*
+	* 🎯 Non-obvious:
+	* - Any change to how `MakerTraits` packs `hooksData` must preserve the contract that
+	*   `hooksDataEndsAtByte(traits)` points exactly to the start of the program, or decoding will drift.
+	*/
+	static decode(encoded) {
+		const [{ maker, traits, data }] = decodeAbiParameters([Order.ABI], encoded.toString());
+		const makerTraits = MakerTraits.decode(traits, new HexString$1(data));
+		const program = new HexString$1(data).sliceBytes(MakerTraits.hooksDataEndsAtByte(traits));
+		return new Order(new Address$1(maker), makerTraits, new SwapVmProgram(program.toString()));
+	}
+	/**
+	* Computes an order hash used for signing or as a deterministic order identifier.
+	*
+	* Hashing modes:
+	* - Aqua mode (`traits.useAquaInsteadOfSignature === true`):
+	*   - Returns `keccak256(encode())`.
+	*   - Ignores provided `domain` completely.
+	* - EIP-712 signature mode (`useAquaInsteadOfSignature === false`):
+	*   - Requires a `domain`; if missing, an assertion error is thrown.
+	*
+	* ⚠️ IMPORTANT:
+	* - Callers must ensure they pass the same `domain` parameters that the verifier
+	*   uses on-chain; mismatches will produce hashes that cannot be verified.
+	*/
+	hash(domain) {
+		if (this.traits.useAquaInsteadOfSignature) return new HexString$1(keccak256(this.encode().toString()));
+		assert(domain, "domain info required if isUseOfAquaInsteadOfSignatureEnabled is false");
+		return new HexString$1(hashTypedData({
+			domain: {
+				...domain,
+				verifyingContract: domain.verifyingContract.toString()
+			},
+			primaryType: "Order",
+			types: { Order: [
+				{
+					name: "maker",
+					type: "address"
+				},
+				{
+					name: "traits",
+					type: "uint256"
+				},
+				{
+					name: "data",
+					type: "bytes"
+				}
+			] },
+			message: this.build()
+		}));
+	}
+	/**
+	* ABI-encodes the order into the exact bytes blob expected by on-chain contracts.
+	*
+	* Usage:
+	* - Input to `keccak256` in Aqua mode (`hash()`).
+	* - Payload for contract methods expecting an `Order` tuple.
+	*/
+	encode() {
+		const encoded = encodeAbiParameters([Order.ABI], [this.build()]);
+		return new HexString$1(encoded);
+	}
+	/**
+	* Produces the ABI-ready `BuiltOrder` tuple`.
+	*/
+	build() {
+		const { traits, hooksData } = this.traits.encode(this.maker);
+		return {
+			maker: this.maker.toString(),
+			traits,
+			data: hooksData.concat(this.program).toString()
+		};
+	}
+};
+
+//#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 {
+	feeBpsIn;
+	deltas;
+	decayPeriod;
+	protocolFee;
+	salt;
+	constructor(tokenA, tokenB) {
+		this.tokenA = tokenA;
+		this.tokenB = tokenB;
+	}
+	static new(tokens) {
+		return new AquaAMMStrategy(tokens.tokenA, tokens.tokenB);
+	}
+	withProtocolFee(bps, receiver) {
+		this.protocolFee = {
+			bps,
+			receiver
+		};
+		return this;
+	}
+	withDeltas(a, b) {
+		this.deltas = {
+			a,
+			b
+		};
+		return this;
+	}
+	withDecayPeriod(decayPeriod) {
+		this.decayPeriod = decayPeriod;
+		return this;
+	}
+	withFeeTokenIn(bps) {
+		this.feeBpsIn = bps;
+		return this;
+	}
+	withSalt(salt$1) {
+		this.salt = salt$1;
+		return this;
+	}
+	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.decayPeriod) builder.decayXD({ decayPeriod: this.decayPeriod });
+		if (this.feeBpsIn) {
+			const data = FlatFeeArgs.fromBps(this.feeBpsIn);
+			builder.add(flatFeeAmountInXD.createIx(data));
+		}
+		if (this.protocolFee) {
+			const data = ProtocolFeeArgs.fromBps(this.protocolFee.bps, this.protocolFee.receiver);
+			builder.add(aquaProtocolFeeAmountOutXD.createIx(data));
+		}
+		builder.xycSwapXD();
+		if (this.salt) builder.salt({ salt: this.salt });
+		return builder.build();
+	}
+};
+
+//#endregion
+//#region src/abi/index.ts
+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 };