@gala-chain/gswap-sdk 1.0.0-rc.3 → 1.0.0

package/dist/index.cjs

@@ -1,2567 +1,2465 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ALL_FEE_TIERS: () => ALL_FEE_TIERS,
-  Assets: () => Assets,
-  BrowserWalletSigner: () => BrowserWalletSigner,
-  ChainGateway: () => ChainGateway,
-  FEE_TIER: () => FEE_TIER,
-  GC_MAX_TICK: () => GC_MAX_TICK,
-  GC_MIN_TICK: () => GC_MIN_TICK,
-  GSWAP_ENVIRONMENTS: () => GSWAP_ENVIRONMENTS,
-  GSwap: () => GSwap,
-  GSwapSDKError: () => GSwapSDKError,
-  GalaWalletSigner: () => GalaWalletSigner,
-  Pools: () => Pools,
-  Positions: () => Positions,
-  PrivateKeySigner: () => PrivateKeySigner,
-  Quoting: () => Quoting,
-  SubmittedTransaction: () => SubmittedTransaction,
-  Swaps: () => Swaps,
-  Symbols: () => Symbols,
-  TICK_SPACING_BY_FEE: () => TICK_SPACING_BY_FEE,
-  alignTickDown: () => alignTickDown,
-  alignTickUp: () => alignTickUp,
-  assertTickRange: () => assertTickRange,
-  compositeKeyOf: () => compositeKeyOf,
-  getObjectProperty: () => getObjectProperty,
-  getStringProperty: () => getStringProperty,
-  orderSymbols: () => orderSymbols,
-  parseJson: () => parseJson,
-  parseTokenClassKey: () => parseTokenClassKey,
-  readOrderedSymbols: () => readOrderedSymbols,
-  sqrtPriceToTick: () => sqrtPriceToTick,
-  tickFromPrice: () => tickFromPrice,
-  tickToSqrtPrice: () => tickToSqrtPrice,
-  validateFee: () => validateFee,
-  validateNumericAmount: () => validateNumericAmount,
-  validatePriceValues: () => validatePriceValues,
-  validateTickRange: () => validateTickRange,
-  validateTickSpacing: () => validateTickSpacing,
-  validateTokenDecimals: () => validateTokenDecimals,
-  validateWalletAddress: () => validateWalletAddress
-});
-module.exports = __toCommonJS(index_exports);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-// src/utils/validation.ts
-var import_bignumber2 = __toESM(require("bignumber.js"), 1);
+//#endregion
+let bignumber_js = require("bignumber.js");
+bignumber_js = __toESM(bignumber_js, 1);
+let decimal_js = require("decimal.js");
+let debug = require("debug");
+debug = __toESM(debug, 1);
+let _gala_chain_api = require("@gala-chain/api");
 
-// src/classes/gswap_sdk_error.ts
-var GSwapSDKError = class _GSwapSDKError extends Error {
-  constructor(message, code, details, chainMessage, retryAfterMs) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "GSwapSDKError";
-    this.chainMessage = chainMessage;
-    this.retryAfterMs = retryAfterMs;
-  }
-  code;
-  details;
-  chainMessage;
-  retryAfterMs;
-  /** Create the standard missing-signer error. */
-  static noSignerError() {
-    return new _GSwapSDKError(
-      "This method requires a signer. Please provide a signer to the GSwap constructor.",
-      "NO_SIGNER"
-    );
-  }
-  /** Create the error used when confirming a position write without a configured wallet address. */
-  static noWalletAddressError() {
-    return new _GSwapSDKError(
-      "Cannot confirm this write: no walletAddress was provided to the GSwap constructor, so the resulting position cannot be looked up to confirm it landed on chain.",
-      "NO_WALLET_ADDRESS"
-    );
-  }
-  /** Create the error used when no pool can quote the requested pair. */
-  static noPoolAvailableError(tokenIn, tokenOut, fee) {
-    return new _GSwapSDKError("No pool is available for the requested pair.", "NO_POOL_AVAILABLE", {
-      tokenIn,
-      tokenOut,
-      ...fee === void 0 ? {} : { fee }
-    });
-  }
-  /** Create the error used when a pool lacks liquidity for a quote. */
-  static insufficientLiquidityError(tokenIn, tokenOut, fee) {
-    return new _GSwapSDKError(
-      "The selected pool has insufficient liquidity for the requested quote.",
-      "INSUFFICIENT_LIQUIDITY",
-      { tokenIn, tokenOut, ...fee === void 0 ? {} : { fee } }
-    );
-  }
-  /** Convert a chain-gateway bounce into a typed SDK error. */
-  static fromGatewayBounce(code, message, status, retryAfterMs) {
-    const details = { status, chainMessage: message };
-    if (retryAfterMs !== void 0) details["retryAfterMs"] = retryAfterMs;
-    const sdkMessage = code === "CHAIN_DISPATCH_FAILED" ? message : `Gateway rejected ${code}: ${message}`;
-    return new _GSwapSDKError(sdkMessage, code, details, message, retryAfterMs);
-  }
-  /** Convert a GalaChain `Status: 0` response into a typed SDK error. */
-  static fromChainError(errorKey, message, details) {
-    return new _GSwapSDKError(
-      `GalaChain error ${errorKey}: ${message}`,
-      errorKey,
-      { ...details, errorKey, message },
-      message
-    );
-  }
-  /** Create the error used when a token is not registered by the current DEX contract. */
-  static unknownTokenError(token) {
-    const tokenText = typeof token === "string" ? token : JSON.stringify(token);
-    return new _GSwapSDKError(
-      `Token ${tokenText} has no trading symbol on the new DEX contract (no gcdex pool includes it yet).`,
-      "UNKNOWN_TOKEN",
-      { token }
-    );
-  }
-  /** Create the error used when apply-results confirmation does not arrive in time. */
-  static confirmationTimeoutError(uniqueKey, cause) {
-    return new _GSwapSDKError(
-      "Transaction confirmation timed out; the trade may still apply. Confirm the same uniqueKey again later instead of resubmitting.",
-      "CONFIRMATION_TIMEOUT",
-      { uniqueKey, ...cause === void 0 ? {} : { cause } }
-    );
-  }
-  /** Convert an unexpected HTTP response into an SDK error. */
-  static async fromErrorResponse(url, response) {
-    const bodyText = await response.text();
-    const bodyJson = parseJson(bodyText);
-    const errorObject = getObjectProperty(bodyJson, "error");
-    const errorKey = getStringProperty(errorObject, "ErrorKey");
-    const message = getStringProperty(errorObject, "Message");
-    if (errorKey !== void 0 && message !== void 0) {
-      return new _GSwapSDKError(
-        `GalaChain Error ${errorKey} from ${url}: ${message}`,
-        errorKey,
-        { message, errorKey, status: response.status, body: bodyJson, url },
-        message
-      );
-    }
-    return new _GSwapSDKError(`Unexpected HTTP Error ${response.status} from ${url}`, "HTTP_ERROR", {
-      status: response.status,
-      body: bodyJson ?? bodyText,
-      url
-    });
-  }
+//#region src/classes/gswap_sdk_error.ts
+/** Error raised by the SDK for validation, gateway, chain, or transaction failures. */
+var GSwapSDKError = class GSwapSDKError extends Error {
+	code;
+	details;
+	chainMessage;
+	retryAfterMs;
+	constructor(message, code, details, chainMessage, retryAfterMs) {
+		super(message);
+		this.code = code;
+		this.details = details;
+		this.name = "GSwapSDKError";
+		this.chainMessage = chainMessage;
+		this.retryAfterMs = retryAfterMs;
+	}
+	/** Create the standard missing-signer error. */
+	static noSignerError() {
+		return new GSwapSDKError("This method requires a signer. Please provide a signer to the GSwap constructor.", "NO_SIGNER");
+	}
+	/** Create the error used when confirming a position write without a configured wallet address. */
+	static noWalletAddressError() {
+		return new GSwapSDKError("Cannot confirm this write: no walletAddress was provided to the GSwap constructor, so the resulting position cannot be looked up to confirm it landed on chain.", "NO_WALLET_ADDRESS");
+	}
+	/** Create the error used when no pool can quote the requested pair. */
+	static noPoolAvailableError(tokenIn, tokenOut, fee) {
+		return new GSwapSDKError("No pool is available for the requested pair.", "NO_POOL_AVAILABLE", {
+			tokenIn,
+			tokenOut,
+			...fee === void 0 ? {} : { fee }
+		});
+	}
+	/** Create the error used when a pool lacks liquidity for a quote. */
+	static insufficientLiquidityError(tokenIn, tokenOut, fee) {
+		return new GSwapSDKError("The selected pool has insufficient liquidity for the requested quote.", "INSUFFICIENT_LIQUIDITY", {
+			tokenIn,
+			tokenOut,
+			...fee === void 0 ? {} : { fee }
+		});
+	}
+	/** Convert a chain-gateway bounce into a typed SDK error. */
+	static fromGatewayBounce(code, message, status, retryAfterMs) {
+		const details = {
+			status,
+			chainMessage: message
+		};
+		if (retryAfterMs !== void 0) details["retryAfterMs"] = retryAfterMs;
+		const sdkMessage = code === "CHAIN_DISPATCH_FAILED" ? message : `Gateway rejected ${code}: ${message}`;
+		return new GSwapSDKError(sdkMessage, code, details, message, retryAfterMs);
+	}
+	/** Convert a GalaChain `Status: 0` response into a typed SDK error. */
+	static fromChainError(errorKey, message, details) {
+		return new GSwapSDKError(`GalaChain error ${errorKey}: ${message}`, errorKey, {
+			...details,
+			errorKey,
+			message
+		}, message);
+	}
+	/** Create the error used when a token is not registered by the current DEX contract. */
+	static unknownTokenError(token) {
+		const tokenText = typeof token === "string" ? token : JSON.stringify(token);
+		return new GSwapSDKError(`Token ${tokenText} has no trading symbol on the new DEX contract (no gcdex pool includes it yet).`, "UNKNOWN_TOKEN", { token });
+	}
+	/** Create the error used when apply-results confirmation does not arrive in time. */
+	static confirmationTimeoutError(uniqueKey, cause) {
+		return new GSwapSDKError("Transaction confirmation timed out; the trade may still apply. Confirm the same uniqueKey again later instead of resubmitting.", "CONFIRMATION_TIMEOUT", {
+			uniqueKey,
+			...cause === void 0 ? {} : { cause }
+		});
+	}
+	/** Convert an unexpected HTTP response into an SDK error. */
+	static async fromErrorResponse(url, response) {
+		const bodyText = await response.text();
+		const bodyJson = parseJson(bodyText);
+		const errorObject = getObjectProperty(bodyJson, "error");
+		const errorKey = getStringProperty(errorObject, "ErrorKey");
+		const message = getStringProperty(errorObject, "Message");
+		if (errorKey !== void 0 && message !== void 0) return new GSwapSDKError(`GalaChain Error ${errorKey} from ${url}: ${message}`, errorKey, {
+			message,
+			errorKey,
+			status: response.status,
+			body: bodyJson,
+			url
+		}, message);
+		return new GSwapSDKError(`Unexpected HTTP Error ${response.status} from ${url}`, "HTTP_ERROR", {
+			status: response.status,
+			body: bodyJson ?? bodyText,
+			url
+		});
+	}
 };
+/** Narrow an object property without trusting a cast at a network boundary. */
 function getObjectProperty(value, property) {
-  if (typeof value !== "object" || value === null || !(property in value)) return void 0;
-  const propertyValue = value[property];
-  return typeof propertyValue === "object" && propertyValue !== null ? propertyValue : void 0;
+	if (typeof value !== "object" || value === null || !(property in value)) return void 0;
+	const propertyValue = value[property];
+	return typeof propertyValue === "object" && propertyValue !== null ? propertyValue : void 0;
 }
+/** Read a string property from an unknown object. */
 function getStringProperty(value, property) {
-  if (typeof value !== "object" || value === null || !(property in value)) return void 0;
-  const propertyValue = value[property];
-  return typeof propertyValue === "string" ? propertyValue : void 0;
+	if (typeof value !== "object" || value === null || !(property in value)) return void 0;
+	const propertyValue = value[property];
+	return typeof propertyValue === "string" ? propertyValue : void 0;
 }
+/** Parse a response body, preserving non-JSON text for error reporting. */
 function parseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
 }
 
-// src/types/fees.ts
-var FEE_TIER = /* @__PURE__ */ ((FEE_TIER2) => {
-  FEE_TIER2[FEE_TIER2["PERCENT_00_00"] = 0] = "PERCENT_00_00";
-  FEE_TIER2[FEE_TIER2["PERCENT_00_05"] = 500] = "PERCENT_00_05";
-  FEE_TIER2[FEE_TIER2["PERCENT_00_30"] = 3e3] = "PERCENT_00_30";
-  FEE_TIER2[FEE_TIER2["PERCENT_01_00"] = 1e4] = "PERCENT_01_00";
-  return FEE_TIER2;
-})(FEE_TIER || {});
-var TICK_SPACING_BY_FEE = {
-  [0 /* PERCENT_00_00 */]: 200,
-  [500 /* PERCENT_00_05 */]: 10,
-  [3e3 /* PERCENT_00_30 */]: 60,
-  [1e4 /* PERCENT_01_00 */]: 200
+//#endregion
+//#region src/types/fees.ts
+/**
+* Fee tiers for pools.
+*/
+let FEE_TIER = /* @__PURE__ */ function(FEE_TIER) {
+	/** No trading fee. */
+	FEE_TIER[FEE_TIER["PERCENT_00_00"] = 0] = "PERCENT_00_00";
+	/** 0.05% fee tier */
+	FEE_TIER[FEE_TIER["PERCENT_00_05"] = 500] = "PERCENT_00_05";
+	/** 0.3% fee tier */
+	FEE_TIER[FEE_TIER["PERCENT_00_30"] = 3e3] = "PERCENT_00_30";
+	/** 1.0% fee tier */
+	FEE_TIER[FEE_TIER["PERCENT_01_00"] = 1e4] = "PERCENT_01_00";
+	return FEE_TIER;
+}({});
+/** Tick spacing required by the current GalaChainDex contract for each fee tier. */
+const TICK_SPACING_BY_FEE = {
+	[0]: 200,
+	[500]: 10,
+	[3e3]: 60,
+	[1e4]: 200
 };
-var ALL_FEE_TIERS = [
-  0 /* PERCENT_00_00 */,
-  500 /* PERCENT_00_05 */,
-  3e3 /* PERCENT_00_30 */,
-  1e4 /* PERCENT_01_00 */
+/** All fee tiers supported by the current GalaChainDex contract. */
+const ALL_FEE_TIERS = [
+	0,
+	500,
+	3e3,
+	1e4
 ];
 
-// src/utils/ticks.ts
-var import_bignumber = __toESM(require("bignumber.js"), 1);
-var import_decimal = require("decimal.js");
-var GC_MIN_TICK = -887272;
-var GC_MAX_TICK = 887272;
-var DexMath = import_bignumber.default.clone({
-  DECIMAL_PLACES: 60,
-  ROUNDING_MODE: import_bignumber.default.ROUND_DOWN
+//#endregion
+//#region src/utils/ticks.ts
+/** Minimum tick supported by GalaChainDex. */
+const GC_MIN_TICK = -887272;
+/** Maximum tick supported by GalaChainDex. */
+const GC_MAX_TICK = 887272;
+const DexMath = bignumber_js.default.clone({
+	DECIMAL_PLACES: 60,
+	ROUNDING_MODE: bignumber_js.default.ROUND_DOWN
 });
-var DexDecimal = import_decimal.Decimal.clone({ precision: 60 });
+const DexDecimal = decimal_js.Decimal.clone({ precision: 60 });
+/** Convert a tick to the corresponding square-root price. */
 function tickToSqrtPrice(tick) {
-  return new import_bignumber.default(new DexDecimal(1.0001).pow(tick / 2).toString());
+	return new bignumber_js.default(new DexDecimal(1.0001).pow(tick / 2).toString());
 }
+/** Return the greatest tick whose square-root price is no greater than the input. */
 function sqrtPriceToTick(sqrtPrice) {
-  let value;
-  try {
-    value = new DexMath(sqrtPrice);
-  } catch {
-    return Number.NaN;
-  }
-  if (!value.isFinite() || value.isLessThanOrEqualTo(0)) return Number.NaN;
-  const approximate = Math.log(value.toNumber() ** 2) / Math.log(1.0001);
-  if (!Number.isFinite(approximate)) return Number.NaN;
-  let tick = Math.min(GC_MAX_TICK, Math.max(GC_MIN_TICK, Math.floor(approximate)));
-  while (tick < GC_MAX_TICK && tickToSqrtPrice(tick + 1).isLessThanOrEqualTo(value)) tick += 1;
-  while (tick > GC_MIN_TICK && tickToSqrtPrice(tick).isGreaterThan(value)) tick -= 1;
-  return tick;
-}
+	let value;
+	try {
+		value = new DexMath(sqrtPrice);
+	} catch {
+		return NaN;
+	}
+	if (!value.isFinite() || value.isLessThanOrEqualTo(0)) return NaN;
+	const approximate = Math.log(value.toNumber() ** 2) / Math.log(1.0001);
+	if (!Number.isFinite(approximate)) return NaN;
+	let tick = Math.min(GC_MAX_TICK, Math.max(GC_MIN_TICK, Math.floor(approximate)));
+	while (tick < 887272 && tickToSqrtPrice(tick + 1).isLessThanOrEqualTo(value)) tick += 1;
+	while (tick > -887272 && tickToSqrtPrice(tick).isGreaterThan(value)) tick -= 1;
+	return tick;
+}
+/** Return the greatest integer tick whose token1/token0 price is no greater than `price`. */
 function tickFromPrice(price) {
-  const priceText = typeof price === "string" ? price : typeof price === "number" ? price.toString() : import_bignumber.default.isBigNumber(price) ? price.toString() : "NaN";
-  const value = new DexDecimal(priceText);
-  if (!value.isFinite() || value.lessThanOrEqualTo(0)) return Number.NaN;
-  if (!Number.isFinite(value.toNumber())) return Number.NaN;
-  const tick = value.ln().dividedBy(new DexDecimal(1.0001).ln()).floor().toNumber();
-  return Number.isFinite(tick) ? tick : Number.NaN;
-}
+	const priceText = typeof price === "string" ? price : typeof price === "number" ? price.toString() : bignumber_js.default.isBigNumber(price) ? price.toString() : "NaN";
+	const value = new DexDecimal(priceText);
+	if (!value.isFinite() || value.lessThanOrEqualTo(0)) return NaN;
+	if (!Number.isFinite(value.toNumber())) return NaN;
+	const tick = value.ln().dividedBy(new DexDecimal(1.0001).ln()).floor().toNumber();
+	return Number.isFinite(tick) ? tick : NaN;
+}
+/** Align a tick down to the nearest multiple of a positive spacing. */
 function alignTickDown(tick, spacing) {
-  assertSpacing(spacing);
-  return Math.floor(tick / spacing) * spacing;
+	assertSpacing(spacing);
+	return Math.floor(tick / spacing) * spacing;
 }
+/** Align a tick up to the nearest multiple of a positive spacing. */
 function alignTickUp(tick, spacing) {
-  assertSpacing(spacing);
-  return Math.ceil(tick / spacing) * spacing;
+	assertSpacing(spacing);
+	return Math.ceil(tick / spacing) * spacing;
 }
+/** Validate a position range against the global tick bounds and fee-tier spacing. */
 function assertTickRange(lower, upper, fee) {
-  const spacing = TICK_SPACING_BY_FEE[fee];
-  if (spacing === void 0) throw new RangeError(`Unsupported fee tier: ${fee}`);
-  if (!Number.isInteger(lower) || !Number.isInteger(upper)) {
-    throw new RangeError("Ticks must be integers");
-  }
-  if (lower < GC_MIN_TICK || upper > GC_MAX_TICK || lower >= upper) {
-    throw new RangeError(
-      `Tick range must satisfy ${GC_MIN_TICK} <= lower < upper <= ${GC_MAX_TICK}`
-    );
-  }
-  if (lower % spacing !== 0 || upper % spacing !== 0) {
-    throw new RangeError(`Ticks must be aligned to spacing ${spacing}`);
-  }
+	const spacing = TICK_SPACING_BY_FEE[fee];
+	if (spacing === void 0) throw new RangeError(`Unsupported fee tier: ${fee}`);
+	if (!Number.isInteger(lower) || !Number.isInteger(upper)) throw new RangeError("Ticks must be integers");
+	if (lower < -887272 || upper > 887272 || lower >= upper) throw new RangeError(`Tick range must satisfy ${GC_MIN_TICK} <= lower < upper <= ${GC_MAX_TICK}`);
+	if (lower % spacing !== 0 || upper % spacing !== 0) throw new RangeError(`Ticks must be aligned to spacing ${spacing}`);
 }
 function assertSpacing(spacing) {
-  if (!Number.isInteger(spacing) || spacing <= 0)
-    throw new RangeError("Tick spacing must be positive");
+	if (!Number.isInteger(spacing) || spacing <= 0) throw new RangeError("Tick spacing must be positive");
 }
 
-// src/utils/validation.ts
+//#endregion
+//#region src/utils/validation.ts
 function validateNumericAmount(amount, parameterName, allowZero = false) {
-  if (typeof amount === "number") {
-    throw new GSwapSDKError(
-      `Invalid ${parameterName}: use a decimal string or BigNumber, not a JavaScript number`,
-      "VALIDATION_ERROR",
-      { type: "INVALID_NUMERIC_AMOUNT", parameterName, value: amount, reason: "number_input" }
-    );
-  }
-  let bnAmount;
-  try {
-    bnAmount = (0, import_bignumber2.default)(amount);
-  } catch {
-    bnAmount = (0, import_bignumber2.default)(NaN);
-  }
-  if (!bnAmount.isFinite()) {
-    throw new GSwapSDKError(
-      `Invalid ${parameterName}: must be a finite number`,
-      "VALIDATION_ERROR",
-      {
-        type: "INVALID_NUMERIC_AMOUNT",
-        parameterName,
-        value: amount,
-        reason: "not_finite"
-      }
-    );
-  }
-  if (!allowZero && bnAmount.isZero()) {
-    throw new GSwapSDKError(`Invalid ${parameterName}: must be positive`, "VALIDATION_ERROR", {
-      type: "INVALID_NUMERIC_AMOUNT",
-      parameterName,
-      value: amount,
-      reason: "zero_not_allowed"
-    });
-  }
-  if (bnAmount.isNegative()) {
-    throw new GSwapSDKError(
-      `Invalid ${parameterName}: must be ${allowZero ? "non-negative" : "positive"}`,
-      "VALIDATION_ERROR",
-      {
-        type: "INVALID_NUMERIC_AMOUNT",
-        parameterName,
-        value: amount,
-        reason: "negative"
-      }
-    );
-  }
+	if (typeof amount === "number") throw new GSwapSDKError(`Invalid ${parameterName}: use a decimal string or BigNumber, not a JavaScript number`, "VALIDATION_ERROR", {
+		type: "INVALID_NUMERIC_AMOUNT",
+		parameterName,
+		value: amount,
+		reason: "number_input"
+	});
+	let bnAmount;
+	try {
+		bnAmount = (0, bignumber_js.default)(amount);
+	} catch {
+		bnAmount = (0, bignumber_js.default)(NaN);
+	}
+	if (!bnAmount.isFinite()) throw new GSwapSDKError(`Invalid ${parameterName}: must be a finite number`, "VALIDATION_ERROR", {
+		type: "INVALID_NUMERIC_AMOUNT",
+		parameterName,
+		value: amount,
+		reason: "not_finite"
+	});
+	if (!allowZero && bnAmount.isZero()) throw new GSwapSDKError(`Invalid ${parameterName}: must be positive`, "VALIDATION_ERROR", {
+		type: "INVALID_NUMERIC_AMOUNT",
+		parameterName,
+		value: amount,
+		reason: "zero_not_allowed"
+	});
+	if (bnAmount.isNegative()) throw new GSwapSDKError(`Invalid ${parameterName}: must be ${allowZero ? "non-negative" : "positive"}`, "VALIDATION_ERROR", {
+		type: "INVALID_NUMERIC_AMOUNT",
+		parameterName,
+		value: amount,
+		reason: "negative"
+	});
 }
 function validatePriceValues(spotPrice, lowerPrice, upperPrice) {
-  if ([spotPrice, lowerPrice, upperPrice].some((value) => typeof value === "number")) {
-    throw new GSwapSDKError(
-      "Invalid price values: use decimal strings or BigNumber values, not JavaScript numbers",
-      "VALIDATION_ERROR",
-      { type: "INVALID_NUMERIC_AMOUNT", reason: "number_input" }
-    );
-  }
-  const parse = (value) => {
-    try {
-      return (0, import_bignumber2.default)(value);
-    } catch {
-      return (0, import_bignumber2.default)(NaN);
-    }
-  };
-  const bnSpotPrice = parse(spotPrice);
-  const bnLowerPrice = parse(lowerPrice);
-  let bnUpperPrice = parse(upperPrice);
-  bnUpperPrice = bnUpperPrice.isFinite() ? bnUpperPrice : (0, import_bignumber2.default)(1e18);
-  if (!bnSpotPrice.isFinite() || !bnLowerPrice.isFinite() || !bnUpperPrice.isFinite() || !bnSpotPrice.isPositive() || !bnLowerPrice.isPositive() || !bnUpperPrice.isPositive()) {
-    throw new GSwapSDKError(
-      "Invalid price values: all prices must be finite and positive",
-      "VALIDATION_ERROR",
-      {
-        type: "INVALID_PRICE_VALUES",
-        spotPrice,
-        lowerPrice,
-        upperPrice
-      }
-    );
-  }
-  if (bnLowerPrice.isGreaterThan(bnUpperPrice)) {
-    throw new GSwapSDKError(
-      "Invalid price range: lower price must be less than or equal to upper price",
-      "VALIDATION_ERROR",
-      {
-        type: "INVALID_PRICE_RANGE",
-        lowerPrice,
-        upperPrice
-      }
-    );
-  }
+	if ([
+		spotPrice,
+		lowerPrice,
+		upperPrice
+	].some((value) => typeof value === "number")) throw new GSwapSDKError("Invalid price values: use decimal strings or BigNumber values, not JavaScript numbers", "VALIDATION_ERROR", {
+		type: "INVALID_NUMERIC_AMOUNT",
+		reason: "number_input"
+	});
+	const parse = (value) => {
+		try {
+			return (0, bignumber_js.default)(value);
+		} catch {
+			return (0, bignumber_js.default)(NaN);
+		}
+	};
+	const bnSpotPrice = parse(spotPrice);
+	const bnLowerPrice = parse(lowerPrice);
+	let bnUpperPrice = parse(upperPrice);
+	bnUpperPrice = bnUpperPrice.isFinite() ? bnUpperPrice : (0, bignumber_js.default)(0xde0b6b3a7640000);
+	if (!bnSpotPrice.isFinite() || !bnLowerPrice.isFinite() || !bnUpperPrice.isFinite() || !bnSpotPrice.isPositive() || !bnLowerPrice.isPositive() || !bnUpperPrice.isPositive()) throw new GSwapSDKError("Invalid price values: all prices must be finite and positive", "VALIDATION_ERROR", {
+		type: "INVALID_PRICE_VALUES",
+		spotPrice,
+		lowerPrice,
+		upperPrice
+	});
+	if (bnLowerPrice.isGreaterThan(bnUpperPrice)) throw new GSwapSDKError("Invalid price range: lower price must be less than or equal to upper price", "VALIDATION_ERROR", {
+		type: "INVALID_PRICE_RANGE",
+		lowerPrice,
+		upperPrice
+	});
 }
 function validateTokenDecimals(decimals, parameterName) {
-  if (decimals < 0 || !Number.isInteger(decimals)) {
-    throw new GSwapSDKError(
-      `Invalid ${parameterName}: must be a non-negative integer`,
-      "VALIDATION_ERROR",
-      {
-        type: "INVALID_TOKEN_DECIMALS",
-        parameterName,
-        value: decimals
-      }
-    );
-  }
+	if (decimals < 0 || !Number.isInteger(decimals)) throw new GSwapSDKError(`Invalid ${parameterName}: must be a non-negative integer`, "VALIDATION_ERROR", {
+		type: "INVALID_TOKEN_DECIMALS",
+		parameterName,
+		value: decimals
+	});
 }
 function validateTickRange(tickLower, tickUpper) {
-  if (!Number.isInteger(tickLower) || !Number.isInteger(tickUpper)) {
-    throw new GSwapSDKError("Invalid tick values: ticks must be integers", "VALIDATION_ERROR", {
-      type: "INVALID_TICK_VALUES",
-      tickLower,
-      tickUpper
-    });
-  }
-  if (tickLower >= tickUpper) {
-    throw new GSwapSDKError(
-      "Invalid tick range: tickLower must be less than tickUpper",
-      "VALIDATION_ERROR",
-      {
-        type: "INVALID_TICK_RANGE",
-        tickLower,
-        tickUpper
-      }
-    );
-  }
-  if (tickLower < GC_MIN_TICK || tickUpper > GC_MAX_TICK) {
-    throw new GSwapSDKError(
-      `Invalid tick range: ticks must be between ${GC_MIN_TICK} and ${GC_MAX_TICK}`,
-      "VALIDATION_ERROR",
-      {
-        type: "INVALID_TICK_BOUNDS",
-        tickLower,
-        tickUpper,
-        minTick: GC_MIN_TICK,
-        maxTick: GC_MAX_TICK
-      }
-    );
-  }
+	if (!Number.isInteger(tickLower) || !Number.isInteger(tickUpper)) throw new GSwapSDKError("Invalid tick values: ticks must be integers", "VALIDATION_ERROR", {
+		type: "INVALID_TICK_VALUES",
+		tickLower,
+		tickUpper
+	});
+	if (tickLower >= tickUpper) throw new GSwapSDKError("Invalid tick range: tickLower must be less than tickUpper", "VALIDATION_ERROR", {
+		type: "INVALID_TICK_RANGE",
+		tickLower,
+		tickUpper
+	});
+	if (tickLower < -887272 || tickUpper > 887272) throw new GSwapSDKError(`Invalid tick range: ticks must be between ${GC_MIN_TICK} and ${GC_MAX_TICK}`, "VALIDATION_ERROR", {
+		type: "INVALID_TICK_BOUNDS",
+		tickLower,
+		tickUpper,
+		minTick: GC_MIN_TICK,
+		maxTick: GC_MAX_TICK
+	});
 }
 function validateFee(fee) {
-  if (!ALL_FEE_TIERS.some((tier) => Number(tier) === fee)) {
-    throw new GSwapSDKError(
-      "Invalid fee tier: must be one of 0, 500, 3000, or 10000",
-      "VALIDATION_ERROR",
-      {
-        type: "INVALID_FEE",
-        value: fee
-      }
-    );
-  }
+	if (!ALL_FEE_TIERS.some((tier) => Number(tier) === fee)) throw new GSwapSDKError("Invalid fee tier: must be one of 0, 500, 3000, or 10000", "VALIDATION_ERROR", {
+		type: "INVALID_FEE",
+		value: fee
+	});
 }
 function validateTickSpacing(tickSpacing) {
-  if (!Number.isInteger(tickSpacing) || tickSpacing <= 0) {
-    throw new GSwapSDKError(
-      "Invalid tick spacing: must be a positive integer",
-      "VALIDATION_ERROR",
-      {
-        type: "INVALID_TICK_SPACING",
-        value: tickSpacing
-      }
-    );
-  }
+	if (!Number.isInteger(tickSpacing) || tickSpacing <= 0) throw new GSwapSDKError("Invalid tick spacing: must be a positive integer", "VALIDATION_ERROR", {
+		type: "INVALID_TICK_SPACING",
+		value: tickSpacing
+	});
 }
 function validateWalletAddress(address) {
-  if (address === void 0) {
-    throw new GSwapSDKError(
-      "Invalid wallet address: No wallet address provided",
-      "VALIDATION_ERROR",
-      {
-        type: "MISSING_WALLET_ADDRESS",
-        hint: "Either provide a wallet address to the function you are calling, or set one when instantiating GSwapSDK"
-      }
-    );
-  }
-  if (!address || typeof address !== "string" || address.trim().length === 0) {
-    throw new GSwapSDKError(
-      "Invalid wallet address: must be a non-empty string",
-      "VALIDATION_ERROR",
-      {
-        type: "INVALID_WALLET_ADDRESS",
-        value: address
-      }
-    );
-  }
+	if (address === void 0) throw new GSwapSDKError("Invalid wallet address: No wallet address provided", "VALIDATION_ERROR", {
+		type: "MISSING_WALLET_ADDRESS",
+		hint: "Either provide a wallet address to the function you are calling, or set one when instantiating GSwapSDK"
+	});
+	if (!address || typeof address !== "string" || address.trim().length === 0) throw new GSwapSDKError("Invalid wallet address: must be a non-empty string", "VALIDATION_ERROR", {
+		type: "INVALID_WALLET_ADDRESS",
+		value: address
+	});
 }
 
-// src/classes/assets.ts
+//#endregion
+//#region src/classes/assets.ts
+/**
+* Service for handling user asset operations.
+* Provides functionality to retrieve user token balances and asset information.
+*/
 var Assets = class {
-  constructor(dexBackendBaseUrl, httpClient) {
-    this.dexBackendBaseUrl = dexBackendBaseUrl;
-    this.httpClient = httpClient;
-  }
-  dexBackendBaseUrl;
-  httpClient;
-  /**
-   * Gets all token assets owned by a user with their balances.
-   * @param ownerAddress - The wallet address to get assets for.
-   * @param page - Page number for pagination (default: 1).
-   * @param limit - Maximum number of assets to return per page (default: 10).
-   * @returns User assets including token information and balances.
-   * @example
-   * ```typescript
-   * const assets = await assetsService.getUserAssets('eth|123...abc', 1, 20);
-   * console.log(`User has ${assets.count} different tokens`);
-   * assets.tokens.forEach(token => {
-   *   console.log(`${token.symbol}: ${token.quantity}`);
-   * });
-   * ```
-   */
-  async getUserAssets(ownerAddress, page = 1, limit = 10) {
-    validateWalletAddress(ownerAddress);
-    if (!Number.isInteger(page) || page < 1) {
-      throw new GSwapSDKError("Invalid page: must be a positive integer", "VALIDATION_ERROR", {
-        page
-      });
-    }
-    if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
-      throw new GSwapSDKError(
-        "Invalid limit: must be an integer between 1 and 100",
-        "VALIDATION_ERROR",
-        { limit }
-      );
-    }
-    const json = await this.httpClient.sendGetRequest(
-      this.dexBackendBaseUrl,
-      "/user/assets",
-      "",
-      { address: ownerAddress, page: page.toString(), limit: limit.toString() }
-    );
-    return parseUserAssets(json);
-  }
+	dexBackendBaseUrl;
+	httpClient;
+	constructor(dexBackendBaseUrl, httpClient) {
+		this.dexBackendBaseUrl = dexBackendBaseUrl;
+		this.httpClient = httpClient;
+	}
+	/**
+	* Gets all token assets owned by a user with their balances.
+	* @param ownerAddress - The wallet address to get assets for.
+	* @param page - Page number for pagination (default: 1).
+	* @param limit - Maximum number of assets to return per page (default: 10).
+	* @returns User assets including token information and balances.
+	* @example
+	* ```typescript
+	* const assets = await assetsService.getUserAssets('eth|123...abc', 1, 20);
+	* console.log(`User has ${assets.count} different tokens`);
+	* assets.tokens.forEach(token => {
+	*   console.log(`${token.symbol}: ${token.quantity}`);
+	* });
+	* ```
+	*/
+	async getUserAssets(ownerAddress, page = 1, limit = 10) {
+		validateWalletAddress(ownerAddress);
+		if (!Number.isInteger(page) || page < 1) throw new GSwapSDKError("Invalid page: must be a positive integer", "VALIDATION_ERROR", { page });
+		if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new GSwapSDKError("Invalid limit: must be an integer between 1 and 100", "VALIDATION_ERROR", { limit });
+		return parseUserAssets(await this.httpClient.sendGetRequest(this.dexBackendBaseUrl, "/user/assets", "", {
+			address: ownerAddress,
+			page: page.toString(),
+			limit: limit.toString()
+		}));
+	}
 };
 function parseUserAssets(value) {
-  const data = getObjectProperty(value, "data");
-  const tokens = data == null ? void 0 : data["token"];
-  if (!Array.isArray(tokens) || !tokens.every(isRawUserAsset)) {
-    throw new GSwapSDKError(
-      "Backend returned an invalid user assets response.",
-      "INVALID_CHAIN_RESPONSE",
-      {
-        data: value
-      }
-    );
-  }
-  const count = data == null ? void 0 : data["count"];
-  return {
-    tokens: tokens.map((token) => ({ ...token, decimals: parseInt(token.decimals, 10) })),
-    count: typeof count === "number" ? count : 0
-  };
+	const data = getObjectProperty(value, "data");
+	const tokens = data === null || data === void 0 ? void 0 : data["token"];
+	if (!Array.isArray(tokens) || !tokens.every(isRawUserAsset)) throw new GSwapSDKError("Backend returned an invalid user assets response.", "INVALID_CHAIN_RESPONSE", { data: value });
+	const count = data === null || data === void 0 ? void 0 : data["count"];
+	return {
+		tokens: tokens.map((token) => ({
+			...token,
+			decimals: parseInt(token.decimals, 10)
+		})),
+		count: typeof count === "number" ? count : 0
+	};
 }
 function isRawUserAsset(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const entry = value;
-  return typeof entry["image"] === "string" && typeof entry["name"] === "string" && typeof entry["decimals"] === "string" && /^\d+$/u.test(entry["decimals"]) && typeof entry["verify"] === "boolean" && typeof entry["symbol"] === "string" && typeof entry["quantity"] === "string";
+	if (typeof value !== "object" || value === null) return false;
+	const entry = value;
+	return typeof entry["image"] === "string" && typeof entry["name"] === "string" && typeof entry["decimals"] === "string" && /^\d+$/u.test(entry["decimals"]) && typeof entry["verify"] === "boolean" && typeof entry["symbol"] === "string" && typeof entry["quantity"] === "string";
 }
 
-// src/utils/transport.ts
+//#endregion
+//#region src/utils/transport.ts
 async function requestWithTimeout(requestor, url, options, timeoutMs) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  const externalSignal = options.signal;
-  const abortFromCaller = () => controller.abort();
-  externalSignal == null ? void 0 : externalSignal.addEventListener("abort", abortFromCaller, { once: true });
-  try {
-    return await requestor(url, { ...options, signal: controller.signal });
-  } catch (error) {
-    if (controller.signal.aborted) {
-      throw new GSwapSDKError(`Request timed out after ${timeoutMs} ms.`, "REQUEST_TIMEOUT", {
-        url,
-        timeoutMs,
-        cause: error
-      });
-    }
-    throw error;
-  } finally {
-    clearTimeout(timer);
-    externalSignal == null ? void 0 : externalSignal.removeEventListener("abort", abortFromCaller);
-  }
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	const externalSignal = options.signal;
+	const abortFromCaller = () => controller.abort();
+	externalSignal === null || externalSignal === void 0 || externalSignal.addEventListener("abort", abortFromCaller, { once: true });
+	try {
+		return await requestor(url, {
+			...options,
+			signal: controller.signal
+		});
+	} catch (error) {
+		if (controller.signal.aborted) throw new GSwapSDKError(`Request timed out after ${timeoutMs} ms.`, "REQUEST_TIMEOUT", {
+			url,
+			timeoutMs,
+			cause: error
+		});
+		throw error;
+	} finally {
+		clearTimeout(timer);
+		externalSignal === null || externalSignal === void 0 || externalSignal.removeEventListener("abort", abortFromCaller);
+	}
 }
 async function readResponseBody(response) {
-  const text = await response.text();
-  return parseJson(text) ?? text;
+	const text = await response.text();
+	return parseJson(text) ?? text;
 }
+/** Read a case-insensitive response header from either supported header shape. */
 function readHeader(response, name) {
-  var _a;
-  const headers = response.headers;
-  if (headers === void 0) return void 0;
-  if (hasHeaderGetter(headers)) {
-    const value2 = headers.get(name);
-    return value2 === null || value2 === "" ? void 0 : value2;
-  }
-  const value = (_a = Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase())) == null ? void 0 : _a[1];
-  return value === void 0 || value === "" ? void 0 : value;
-}
+	var _Object$entries$find;
+	const headers = response.headers;
+	if (headers === void 0) return void 0;
+	if (hasHeaderGetter(headers)) {
+		const value = headers.get(name);
+		return value === null || value === "" ? void 0 : value;
+	}
+	const value = (_Object$entries$find = Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase())) === null || _Object$entries$find === void 0 ? void 0 : _Object$entries$find[1];
+	return value === void 0 || value === "" ? void 0 : value;
+}
+/** Read a non-negative Retry-After header as milliseconds. */
 function readRetryAfter(response) {
-  const raw = readHeader(response, "retry-after");
-  if (raw === void 0) return void 0;
-  const seconds = Number(raw);
-  return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : void 0;
+	const raw = readHeader(response, "retry-after");
+	if (raw === void 0) return void 0;
+	const seconds = Number(raw);
+	return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : void 0;
 }
+/** Read a non-negative integer block number header. */
 function readBlockNumberHeader(response, headerName = "x-block-number") {
-  const raw = readHeader(response, headerName);
-  if (raw === void 0) return void 0;
-  const blockNumber = Number(raw);
-  return Number.isInteger(blockNumber) && blockNumber >= 0 ? blockNumber : void 0;
+	const raw = readHeader(response, headerName);
+	if (raw === void 0) return void 0;
+	const blockNumber = Number(raw);
+	return Number.isInteger(blockNumber) && blockNumber >= 0 ? blockNumber : void 0;
 }
 function hasHeaderGetter(headers) {
-  return "get" in headers && typeof headers.get === "function";
+	return "get" in headers && typeof headers.get === "function";
 }
 
-// src/classes/submitted_transaction.ts
+//#endregion
+//#region src/classes/submitted_transaction.ts
+/** A submitted v2 transaction whose confirmation mode is explicit in the gateway response. */
 var SubmittedTransaction = class {
-  method;
-  uniqueKey;
-  transactionId;
-  blockNumber;
-  mode;
-  /** The synchronous gateway result, or `undefined` when `mode === 'queued'`. */
-  result;
-  backendBaseUrl;
-  requestor;
-  requestTimeoutMs;
-  positionConfirmation;
-  /** Construct a submitted transaction from a successful gateway response.
-   *
-   * @example
-   * ```ts
-   * const transaction = new SubmittedTransaction({
-   *   method: 'RequestTrade', mode: 'queued', uniqueKey: 'swap-1',
-   *   transactionId: 'request-tx', result: undefined,
-   *   dexBackendBaseUrl: 'https://dex.example', httpRequestor,
-   * });
-   * ```
-   */
-  constructor(options) {
-    this.method = options.method;
-    this.uniqueKey = options.uniqueKey;
-    this.transactionId = options.transactionId;
-    this.blockNumber = options.blockNumber ?? null;
-    this.mode = options.mode;
-    this.result = options.result;
-    this.backendBaseUrl = options.dexBackendBaseUrl.replace(/\/$/u, "");
-    this.requestor = options.httpRequestor;
-    this.requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
-    this.positionConfirmation = options.positionConfirmation;
-  }
-  /** Confirm a queued RequestTrade or prove the affected position for a liquidity write.
-   *
-   * For RequestTrade, calling this method is required to learn the outcome: the queued
-   * acknowledgement proves acceptance, not execution.
-   *
-   * @example
-   * ```ts
-   * const applied = await submitted.confirm({ initialDelayMs: 3_000 });
-   * ```
-   */
-  async confirm(options) {
-    if (this.method === "RequestTrade") {
-      return this.confirmApplied(options);
-    }
-    return this.confirmPosition(options);
-  }
-  async confirmApplied(options) {
-    const schedule = createConfirmationSchedule(options, 3e3);
-    await schedule.waitForRead();
-    const url = `${this.backendBaseUrl}/v1/chain/apply-results/${encodeURIComponent(this.uniqueKey)}?channel=asset&contract=dex-contract`;
-    let lastError;
-    while (true) {
-      let response;
-      let body;
-      try {
-        response = await requestWithTimeout(
-          this.requestor,
-          url,
-          { method: "GET" },
-          this.requestTimeoutMs
-        );
-        body = await readResponseBody(response);
-      } catch (error) {
-        lastError = error;
-        if (!await schedule.waitForRead()) break;
-        continue;
-      }
-      if (response.status === 200) {
-        return this.readAppliedResult(response, body, url);
-      }
-      if (response.status === 404 || response.status === 429 || isTransient(response.status)) {
-        if (response.status === 429) {
-          const retryAfter = readRetryAfter(response);
-          if (retryAfter !== void 0) {
-            if (!await schedule.waitForRead(retryAfter)) break;
-            continue;
-          }
-        }
-      } else {
-        throw new GSwapSDKError(bodyMessage(body), "CONFIRMATION_FAILED", {
-          status: response.status,
-          body,
-          url
-        });
-      }
-      if (!await schedule.waitForRead()) break;
-    }
-    throw GSwapSDKError.confirmationTimeoutError(this.uniqueKey, lastError);
-  }
-  readAppliedResult(response, body, url) {
-    const record = asRecord(body);
-    const status = record == null ? void 0 : record["Status"];
-    const applyTransactionId = readHeader(response, "x-apply-transaction-id") ?? null;
-    const blockNumber = readBlockNumberHeader(response, "x-apply-block-number") ?? null;
-    if (status === 0) {
-      throw GSwapSDKError.fromChainError(
-        getStringProperty(record, "ErrorKey") ?? "CHAIN_ERROR",
-        getStringProperty(record, "Message") ?? "The chain rejected this trade.",
-        {
-          uniqueKey: this.uniqueKey,
-          applyTransactionId,
-          blockNumber,
-          status: response.status,
-          body,
-          url
-        }
-      );
-    }
-    if (status !== 1) throw malformedConfirmation(response, body, url);
-    const result = parseTradeExecution(record == null ? void 0 : record["Data"]);
-    if (result === void 0) throw malformedConfirmation(response, body, url);
-    return {
-      uniqueKey: this.uniqueKey,
-      transactionId: applyTransactionId,
-      blockNumber,
-      requestTransactionId: this.transactionId,
-      result
-    };
-  }
-  /** Confirm a liquidity write against the position's observable effect.
-   *
-   * @returns The position after the write, or `null` for a confirmed full close.
-   * @example
-   * ```ts
-   * const position = await submitted.confirm({ timeoutMs: 60_000 });
-   * ```
-   */
-  async confirmPosition(options) {
-    if (this.positionConfirmation === void 0) throw GSwapSDKError.noWalletAddressError();
-    const schedule = createConfirmationSchedule(options, 0);
-    await schedule.waitForRead();
-    while (true) {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
-      try {
-        const result = await this.positionConfirmation(controller.signal);
-        if (result.confirmed) return result.position;
-      } finally {
-        clearTimeout(timer);
-      }
-      if (!await schedule.waitForRead()) break;
-    }
-    throw GSwapSDKError.confirmationTimeoutError(this.uniqueKey);
-  }
+	method;
+	uniqueKey;
+	transactionId;
+	blockNumber;
+	mode;
+	/** The synchronous gateway result, or `undefined` when `mode === 'queued'`. */
+	result;
+	backendBaseUrl;
+	requestor;
+	requestTimeoutMs;
+	positionConfirmation;
+	/** Construct a submitted transaction from a successful gateway response.
+	*
+	* @example
+	* ```ts
+	* const transaction = new SubmittedTransaction({
+	*   method: 'RequestTrade', mode: 'queued', uniqueKey: 'swap-1',
+	*   transactionId: 'request-tx', result: undefined,
+	*   dexBackendBaseUrl: 'https://dex.example', httpRequestor,
+	* });
+	* ```
+	*/
+	constructor(options) {
+		this.method = options.method;
+		this.uniqueKey = options.uniqueKey;
+		this.transactionId = options.transactionId;
+		this.blockNumber = options.blockNumber ?? null;
+		this.mode = options.mode;
+		this.result = options.result;
+		this.backendBaseUrl = options.dexBackendBaseUrl.replace(/\/$/u, "");
+		this.requestor = options.httpRequestor;
+		this.requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
+		this.positionConfirmation = options.positionConfirmation;
+	}
+	/** Confirm a queued RequestTrade or prove the affected position for a liquidity write.
+	*
+	* For RequestTrade, calling this method is required to learn the outcome: the queued
+	* acknowledgement proves acceptance, not execution.
+	*
+	* @example
+	* ```ts
+	* const applied = await submitted.confirm({ initialDelayMs: 3_000 });
+	* ```
+	*/
+	async confirm(options) {
+		if (this.method === "RequestTrade") return this.confirmApplied(options);
+		return this.confirmPosition(options);
+	}
+	async confirmApplied(options) {
+		const schedule = createConfirmationSchedule(options, 3e3);
+		await schedule.waitForRead();
+		const url = `${this.backendBaseUrl}/v1/chain/apply-results/${encodeURIComponent(this.uniqueKey)}?channel=asset&contract=dex-contract`;
+		let lastError;
+		while (true) {
+			let response;
+			let body;
+			try {
+				response = await requestWithTimeout(this.requestor, url, { method: "GET" }, this.requestTimeoutMs);
+				body = await readResponseBody(response);
+			} catch (error) {
+				lastError = error;
+				if (!await schedule.waitForRead()) break;
+				continue;
+			}
+			if (response.status === 200) return this.readAppliedResult(response, body, url);
+			if (response.status === 404 || response.status === 429 || isTransient(response.status)) {
+				if (response.status === 429) {
+					const retryAfter = readRetryAfter(response);
+					if (retryAfter !== void 0) {
+						if (!await schedule.waitForRead(retryAfter)) break;
+						continue;
+					}
+				}
+			} else throw new GSwapSDKError(bodyMessage(body), "CONFIRMATION_FAILED", {
+				status: response.status,
+				body,
+				url
+			});
+			if (!await schedule.waitForRead()) break;
+		}
+		throw GSwapSDKError.confirmationTimeoutError(this.uniqueKey, lastError);
+	}
+	readAppliedResult(response, body, url) {
+		const record = asRecord$1(body);
+		const status = record === null || record === void 0 ? void 0 : record["Status"];
+		const applyTransactionId = readHeader(response, "x-apply-transaction-id") ?? null;
+		const blockNumber = readBlockNumberHeader(response, "x-apply-block-number") ?? null;
+		if (status === 0) throw GSwapSDKError.fromChainError(getStringProperty(record, "ErrorKey") ?? "CHAIN_ERROR", getStringProperty(record, "Message") ?? "The chain rejected this trade.", {
+			uniqueKey: this.uniqueKey,
+			applyTransactionId,
+			blockNumber,
+			status: response.status,
+			body,
+			url
+		});
+		if (status !== 1) throw malformedConfirmation(response, body, url);
+		const result = parseTradeExecution(record === null || record === void 0 ? void 0 : record["Data"]);
+		if (result === void 0) throw malformedConfirmation(response, body, url);
+		return {
+			uniqueKey: this.uniqueKey,
+			transactionId: applyTransactionId,
+			blockNumber,
+			requestTransactionId: this.transactionId,
+			result
+		};
+	}
+	/** Confirm a liquidity write against the position's observable effect.
+	*
+	* @returns The position after the write, or `null` for a confirmed full close.
+	* @example
+	* ```ts
+	* const position = await submitted.confirm({ timeoutMs: 60_000 });
+	* ```
+	*/
+	async confirmPosition(options) {
+		if (this.positionConfirmation === void 0) throw GSwapSDKError.noWalletAddressError();
+		const schedule = createConfirmationSchedule(options, 0);
+		await schedule.waitForRead();
+		while (true) {
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+			try {
+				const result = await this.positionConfirmation(controller.signal);
+				if (result.confirmed) return result.position;
+			} finally {
+				clearTimeout(timer);
+			}
+			if (!await schedule.waitForRead()) break;
+		}
+		throw GSwapSDKError.confirmationTimeoutError(this.uniqueKey);
+	}
 };
 function createConfirmationSchedule(options, defaultInitialDelayMs) {
-  const timeoutMs = Math.max(0, (options == null ? void 0 : options.timeoutMs) ?? 6e4);
-  const pollIntervalMs = Math.max(500, (options == null ? void 0 : options.pollIntervalMs) ?? 2e3);
-  const initialDelayMs = Math.max(0, (options == null ? void 0 : options.initialDelayMs) ?? defaultInitialDelayMs);
-  const deadline = Date.now() + timeoutMs;
-  let firstRead = true;
-  let attempt = 0;
-  return {
-    async waitForRead(retryAfterMs) {
-      if (firstRead) {
-        firstRead = false;
-        const remaining = Math.max(0, deadline - Date.now());
-        await delay(Math.min(initialDelayMs, remaining));
-        return true;
-      }
-      const backoff = Math.min(8e3, pollIntervalMs * 2 ** Math.min(attempt, 5));
-      attempt += 1;
-      const waitMs = retryAfterMs === void 0 ? jitter(backoff) : retryAfterMs;
-      if (Date.now() + waitMs > deadline) return false;
-      await delay(waitMs);
-      return true;
-    }
-  };
+	const timeoutMs = Math.max(0, (options === null || options === void 0 ? void 0 : options.timeoutMs) ?? 6e4);
+	const pollIntervalMs = Math.max(500, (options === null || options === void 0 ? void 0 : options.pollIntervalMs) ?? 2e3);
+	const initialDelayMs = Math.max(0, (options === null || options === void 0 ? void 0 : options.initialDelayMs) ?? defaultInitialDelayMs);
+	const deadline = Date.now() + timeoutMs;
+	let firstRead = true;
+	let attempt = 0;
+	return { async waitForRead(retryAfterMs) {
+		if (firstRead) {
+			firstRead = false;
+			const remaining = Math.max(0, deadline - Date.now());
+			await delay(Math.min(initialDelayMs, remaining));
+			return true;
+		}
+		const backoff = Math.min(8e3, pollIntervalMs * 2 ** Math.min(attempt, 5));
+		attempt += 1;
+		const waitMs = retryAfterMs === void 0 ? jitter(backoff) : retryAfterMs;
+		if (Date.now() + waitMs > deadline) return false;
+		await delay(waitMs);
+		return true;
+	} };
 }
 function parseTradeExecution(value) {
-  const record = asRecord(value);
-  if (record === void 0 || typeof record["token0"] !== "string" || typeof record["token1"] !== "string" || typeof record["fee"] !== "number") {
-    return void 0;
-  }
-  const optionalFields = [
-    "sell0Qty",
-    "sell1Qty",
-    "buy0Qty",
-    "buy1Qty",
-    "tradingFees",
-    "protocolFees",
-    "totalFees"
-  ];
-  for (const field of optionalFields) {
-    if (field in record && typeof record[field] !== "string") return void 0;
-  }
-  return {
-    token0: record["token0"],
-    token1: record["token1"],
-    fee: record["fee"],
-    ...Object.fromEntries(
-      optionalFields.flatMap(
-        (field) => typeof record[field] === "string" ? [[field, record[field]]] : []
-      )
-    )
-  };
+	const record = asRecord$1(value);
+	if (record === void 0 || typeof record["token0"] !== "string" || typeof record["token1"] !== "string" || typeof record["fee"] !== "number") return;
+	const optionalFields = [
+		"sell0Qty",
+		"sell1Qty",
+		"buy0Qty",
+		"buy1Qty",
+		"tradingFees",
+		"protocolFees",
+		"totalFees"
+	];
+	for (const field of optionalFields) if (field in record && typeof record[field] !== "string") return void 0;
+	return {
+		token0: record["token0"],
+		token1: record["token1"],
+		fee: record["fee"],
+		...Object.fromEntries(optionalFields.flatMap((field) => typeof record[field] === "string" ? [[field, record[field]]] : []))
+	};
 }
 function malformedConfirmation(response, body, url) {
-  return new GSwapSDKError(
-    "Transaction confirmation returned a malformed body",
-    "CONFIRMATION_FAILED",
-    { status: response.status, body, url }
-  );
+	return new GSwapSDKError("Transaction confirmation returned a malformed body", "CONFIRMATION_FAILED", {
+		status: response.status,
+		body,
+		url
+	});
 }
 function isTransient(status) {
-  return status === 500 || status === 502 || status === 503 || status === 504;
+	return status === 500 || status === 502 || status === 503 || status === 504;
 }
 function bodyMessage(body) {
-  return getStringProperty(body, "message") ?? getStringProperty(body, "Message") ?? getStringProperty(getObjectProperty(body, "error"), "message") ?? getStringProperty(getObjectProperty(body, "error"), "Message") ?? (typeof body === "string" ? body : "Transaction confirmation failed");
+	return getStringProperty(body, "message") ?? getStringProperty(body, "Message") ?? getStringProperty(getObjectProperty(body, "error"), "message") ?? getStringProperty(getObjectProperty(body, "error"), "Message") ?? (typeof body === "string" ? body : "Transaction confirmation failed");
 }
-function asRecord(value) {
-  return typeof value === "object" && value !== null ? value : void 0;
+function asRecord$1(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
 }
 function delay(milliseconds) {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+	return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 function jitter(milliseconds) {
-  return Math.max(0, Math.round(milliseconds * (0.9 + Math.random() * 0.2)));
+	return Math.max(0, Math.round(milliseconds * (.9 + Math.random() * .2)));
 }
 
-// src/classes/gateway.ts
+//#endregion
+//#region src/classes/gateway.ts
+/** Thin client for backend-routed v2 writes: synchronous liquidity writes and queued RequestTrade. */
 var ChainGateway = class {
-  requestor;
-  walletAddress;
-  chainCallTimeoutMs;
-  requestTimeoutMs;
-  dexBackendBaseUrl;
-  /** Create a chain gateway client. */
-  constructor(options) {
-    this.dexBackendBaseUrl = trimTrailingSlash(options.dexBackendBaseUrl);
-    this.requestor = options.httpRequestor ?? fetch.bind(globalThis);
-    this.walletAddress = options.walletAddress;
-    this.chainCallTimeoutMs = options.chainCallTimeoutMs ?? 3e4;
-    this.requestTimeoutMs = this.chainCallTimeoutMs;
-  }
-  async submit(method, signedBody, options) {
-    if (method === "Trade") {
-      throw new GSwapSDKError(
-        "The synchronous Trade method was removed; swaps are queued through RequestTrade.",
-        "METHOD_NOT_SUPPORTED",
-        { method }
-      );
-    }
-    const url = `${this.dexBackendBaseUrl}/v1/chain/asset/dex-contract/${method}`;
-    const headers = { "content-type": "application/json" };
-    const walletAddress = (options == null ? void 0 : options.walletAddress) ?? this.walletAddress;
-    if (walletAddress !== void 0) headers["X-Wallet-Address"] = walletAddress;
-    let response;
-    try {
-      response = await requestWithTimeout(
-        this.requestor,
-        url,
-        {
-          method: "POST",
-          headers,
-          body: JSON.stringify(signedBody)
-        },
-        this.chainCallTimeoutMs
-      );
-    } catch (error) {
-      if (error instanceof GSwapSDKError && error.code === "REQUEST_TIMEOUT") {
-        throw new GSwapSDKError(
-          "The submission outcome is unknown because the gateway request timed out. Confirm before retrying.",
-          "SUBMISSION_OUTCOME_UNKNOWN",
-          { uniqueKey: getStringProperty(signedBody, "uniqueKey") ?? "", cause: error }
-        );
-      }
-      throw error;
-    }
-    const body = await readResponseBody(response);
-    if (!response.ok) {
-      throw gatewayError(response, body, url);
-    }
-    const envelope = asRecord2(body);
-    const data = asRecord2((envelope == null ? void 0 : envelope["data"]) ?? (envelope == null ? void 0 : envelope["Data"]));
-    if (data === void 0) {
-      throw invalidGatewayResponse(response, body, url, "Expected a data object.");
-    }
-    const transactionId = getStringProperty(data, "transactionId");
-    const mode = getStringProperty(data, "mode");
-    const rawTransactionId = data["transactionId"];
-    const bodyBlockNumber = data["blockNumber"];
-    const invalidModeMessage = 'Gateway response must contain data.mode="sync" with data.result, or data.mode="queued".';
-    if (mode !== "sync" && mode !== "queued") {
-      throw invalidGatewayResponse(response, body, url, invalidModeMessage);
-    }
-    if ("transactionId" in data && typeof rawTransactionId !== "string" || bodyBlockNumber !== void 0 && bodyBlockNumber !== null && !isBlockNumber(bodyBlockNumber)) {
-      throw invalidGatewayResponse(response, body, url, invalidModeMessage);
-    }
-    if (method === "RequestTrade" && mode === "sync") {
-      throw invalidGatewayResponse(
-        response,
-        body,
-        url,
-        "The gateway executed RequestTrade synchronously, which this SDK refuses; RequestTrade must be queued."
-      );
-    }
-    if (method === "RequestTrade" && mode === "queued") {
-      const signedUniqueKey = getStringProperty(signedBody, "uniqueKey");
-      if ("uniqueKey" in data && (typeof data["uniqueKey"] !== "string" || data["uniqueKey"] !== signedUniqueKey)) {
-        throw invalidGatewayResponse(
-          response,
-          body,
-          url,
-          "Gateway response data.uniqueKey must match the signed RequestTrade uniqueKey."
-        );
-      }
-    } else if (mode === "queued" || !("result" in data)) {
-      throw invalidGatewayResponse(response, body, url, invalidModeMessage);
-    }
-    if (mode === "sync") {
-      const embeddedResult = asRecord2(data["result"]);
-      if (embeddedResult !== void 0) {
-        const resultStatus = embeddedResult["Status"];
-        if (resultStatus !== void 0 && resultStatus !== 1) {
-          throw GSwapSDKError.fromChainError(
-            getStringProperty(embeddedResult, "ErrorKey") ?? "CHAIN_ERROR",
-            getStringProperty(embeddedResult, "Message") ?? "The chain rejected this write.",
-            { status: response.status, body, url }
-          );
-        }
-      }
-    }
-    const uniqueKey = getStringProperty(signedBody, "uniqueKey") ?? "";
-    const headerTransactionId = readHeader(response, "x-transaction-id");
-    const resolvedTransactionId = transactionId === void 0 || transactionId === "" ? headerTransactionId : transactionId;
-    const blockNumber = bodyBlockNumber === null || bodyBlockNumber === void 0 ? readBlockNumberHeader(response) : isBlockNumber(bodyBlockNumber) ? bodyBlockNumber : void 0;
-    return new SubmittedTransaction({
-      method,
-      uniqueKey,
-      transactionId: resolvedTransactionId === void 0 || resolvedTransactionId === "" ? null : resolvedTransactionId,
-      blockNumber: blockNumber ?? null,
-      mode,
-      result: mode === "queued" ? void 0 : data["result"],
-      dexBackendBaseUrl: this.dexBackendBaseUrl,
-      httpRequestor: this.requestor,
-      requestTimeoutMs: this.chainCallTimeoutMs,
-      ...(options == null ? void 0 : options.positionConfirmation) === void 0 ? {} : { positionConfirmation: options.positionConfirmation }
-    });
-  }
-  /** Expose the requestor for sibling read services that share this gateway transport. */
-  get httpRequestor() {
-    return this.requestor;
-  }
+	requestor;
+	walletAddress;
+	chainCallTimeoutMs;
+	requestTimeoutMs;
+	dexBackendBaseUrl;
+	/** Create a chain gateway client. */
+	constructor(options) {
+		this.dexBackendBaseUrl = trimTrailingSlash$1(options.dexBackendBaseUrl);
+		this.requestor = options.httpRequestor ?? fetch.bind(globalThis);
+		this.walletAddress = options.walletAddress;
+		this.chainCallTimeoutMs = options.chainCallTimeoutMs ?? 3e4;
+		this.requestTimeoutMs = this.chainCallTimeoutMs;
+	}
+	async submit(method, signedBody, options) {
+		if (method === "Trade") throw new GSwapSDKError("The synchronous Trade method was removed; swaps are queued through RequestTrade.", "METHOD_NOT_SUPPORTED", { method });
+		const url = `${this.dexBackendBaseUrl}/v1/chain/asset/dex-contract/${method}`;
+		const headers = { "content-type": "application/json" };
+		const walletAddress = (options === null || options === void 0 ? void 0 : options.walletAddress) ?? this.walletAddress;
+		if (walletAddress !== void 0) headers["X-Wallet-Address"] = walletAddress;
+		let response;
+		try {
+			response = await requestWithTimeout(this.requestor, url, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(signedBody)
+			}, this.chainCallTimeoutMs);
+		} catch (error) {
+			if (error instanceof GSwapSDKError && error.code === "REQUEST_TIMEOUT") throw new GSwapSDKError("The submission outcome is unknown because the gateway request timed out. Confirm before retrying.", "SUBMISSION_OUTCOME_UNKNOWN", {
+				uniqueKey: getStringProperty(signedBody, "uniqueKey") ?? "",
+				cause: error
+			});
+			throw error;
+		}
+		const body = await readResponseBody(response);
+		if (!response.ok) throw gatewayError(response, body, url);
+		const envelope = asRecord(body);
+		const data = asRecord((envelope === null || envelope === void 0 ? void 0 : envelope["data"]) ?? (envelope === null || envelope === void 0 ? void 0 : envelope["Data"]));
+		if (data === void 0) throw invalidGatewayResponse(response, body, url, "Expected a data object.");
+		const transactionId = getStringProperty(data, "transactionId");
+		const mode = getStringProperty(data, "mode");
+		const rawTransactionId = data["transactionId"];
+		const bodyBlockNumber = data["blockNumber"];
+		const invalidModeMessage = "Gateway response must contain data.mode=\"sync\" with data.result, or data.mode=\"queued\".";
+		if (mode !== "sync" && mode !== "queued") throw invalidGatewayResponse(response, body, url, invalidModeMessage);
+		if ("transactionId" in data && typeof rawTransactionId !== "string" || bodyBlockNumber !== void 0 && bodyBlockNumber !== null && !isBlockNumber(bodyBlockNumber)) throw invalidGatewayResponse(response, body, url, invalidModeMessage);
+		if (method === "RequestTrade" && mode === "sync") throw invalidGatewayResponse(response, body, url, "The gateway executed RequestTrade synchronously, which this SDK refuses; RequestTrade must be queued.");
+		if (method === "RequestTrade" && mode === "queued") {
+			const signedUniqueKey = getStringProperty(signedBody, "uniqueKey");
+			if ("uniqueKey" in data && (typeof data["uniqueKey"] !== "string" || data["uniqueKey"] !== signedUniqueKey)) throw invalidGatewayResponse(response, body, url, "Gateway response data.uniqueKey must match the signed RequestTrade uniqueKey.");
+		} else if (mode === "queued" || !("result" in data)) throw invalidGatewayResponse(response, body, url, invalidModeMessage);
+		if (mode === "sync") {
+			const embeddedResult = asRecord(data["result"]);
+			if (embeddedResult !== void 0) {
+				const resultStatus = embeddedResult["Status"];
+				if (resultStatus !== void 0 && resultStatus !== 1) throw GSwapSDKError.fromChainError(getStringProperty(embeddedResult, "ErrorKey") ?? "CHAIN_ERROR", getStringProperty(embeddedResult, "Message") ?? "The chain rejected this write.", {
+					status: response.status,
+					body,
+					url
+				});
+			}
+		}
+		const uniqueKey = getStringProperty(signedBody, "uniqueKey") ?? "";
+		const headerTransactionId = readHeader(response, "x-transaction-id");
+		const resolvedTransactionId = transactionId === void 0 || transactionId === "" ? headerTransactionId : transactionId;
+		const blockNumber = bodyBlockNumber === null || bodyBlockNumber === void 0 ? readBlockNumberHeader(response) : isBlockNumber(bodyBlockNumber) ? bodyBlockNumber : void 0;
+		return new SubmittedTransaction({
+			method,
+			uniqueKey,
+			transactionId: resolvedTransactionId === void 0 || resolvedTransactionId === "" ? null : resolvedTransactionId,
+			blockNumber: blockNumber ?? null,
+			mode,
+			result: mode === "queued" ? void 0 : data["result"],
+			dexBackendBaseUrl: this.dexBackendBaseUrl,
+			httpRequestor: this.requestor,
+			requestTimeoutMs: this.chainCallTimeoutMs,
+			...(options === null || options === void 0 ? void 0 : options.positionConfirmation) === void 0 ? {} : { positionConfirmation: options.positionConfirmation }
+		});
+	}
+	/** Expose the requestor for sibling read services that share this gateway transport. */
+	get httpRequestor() {
+		return this.requestor;
+	}
 };
-function trimTrailingSlash(value) {
-  return value.replace(/\/$/u, "");
+function trimTrailingSlash$1(value) {
+	return value.replace(/\/$/u, "");
 }
 function invalidGatewayResponse(response, body, url, message) {
-  return new GSwapSDKError(message, "INVALID_GATEWAY_RESPONSE", {
-    status: response.status,
-    body,
-    url
-  });
+	return new GSwapSDKError(message, "INVALID_GATEWAY_RESPONSE", {
+		status: response.status,
+		body,
+		url
+	});
 }
 function gatewayError(response, body, url) {
-  const object = asRecord2(body);
-  const nested = getObjectProperty(body, "error");
-  const code = getStringProperty(object, "code") ?? getStringProperty(nested, "code") ?? getStringProperty(nested, "ErrorKey") ?? "HTTP_ERROR";
-  const message = getStringProperty(object, "message") ?? getStringProperty(nested, "message") ?? getStringProperty(nested, "Message") ?? (typeof body === "string" ? body : `Gateway request failed with HTTP ${response.status}`);
-  const retryAfterMs = response.status === 429 ? readRetryAfter(response) : void 0;
-  if (code === "HTTP_ERROR") {
-    return new GSwapSDKError(message, code, { status: response.status, body, url });
-  }
-  return GSwapSDKError.fromGatewayBounce(code, message, response.status, retryAfterMs);
-}
-function asRecord2(value) {
-  return typeof value === "object" && value !== null ? value : void 0;
+	const object = asRecord(body);
+	const nested = getObjectProperty(body, "error");
+	const code = getStringProperty(object, "code") ?? getStringProperty(nested, "code") ?? getStringProperty(nested, "ErrorKey") ?? "HTTP_ERROR";
+	const message = getStringProperty(object, "message") ?? getStringProperty(nested, "message") ?? getStringProperty(nested, "Message") ?? (typeof body === "string" ? body : `Gateway request failed with HTTP ${response.status}`);
+	const retryAfterMs = response.status === 429 ? readRetryAfter(response) : void 0;
+	if (code === "HTTP_ERROR") return new GSwapSDKError(message, code, {
+		status: response.status,
+		body,
+		url
+	});
+	return GSwapSDKError.fromGatewayBounce(code, message, response.status, retryAfterMs);
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
 }
 function isBlockNumber(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+	return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
 
-// src/utils/debug.ts
-var import_debug = __toESM(require("debug"), 1);
-var debugLog = (0, import_debug.default)("GSWAP_SDK");
+//#endregion
+//#region src/utils/debug.ts
+const debugLog = (0, debug.default)("GSWAP_SDK");
 
-// src/version.ts
-var SDK_VERSION = true ? "1.0.0-rc.3" : "1.0.0-rc.3";
+//#endregion
+//#region src/version.ts
+/** Package version embedded by the bundler, with a source-test fallback. */
+const SDK_VERSION = "1.0.0";
 
-// src/classes/http_client.ts
+//#endregion
+//#region src/classes/http_client.ts
 var HttpClient = class {
-  /** Create an HTTP client around fetch or an injected requestor. */
-  constructor(httpRequestor = fetch, timeoutMs = 3e4) {
-    this.httpRequestor = httpRequestor;
-    this.timeoutMs = timeoutMs;
-  }
-  httpRequestor;
-  timeoutMs;
-  async sendRequest(method, baseUrl, basePath, endpoint, body, options) {
-    const url = `${baseUrl}${basePath}${endpoint}`;
-    debugLog(`Sending request to ${url} with body:`, body);
-    const response = await requestWithTimeout(
-      this.httpRequestor,
-      url,
-      {
-        method,
-        headers: {
-          "Content-Type": "application/json",
-          "User-Agent": `GalaChain-SDK/${SDK_VERSION}`
-        },
-        ...body ? { body: JSON.stringify(body) } : {},
-        ...(options == null ? void 0 : options.signal) === void 0 ? {} : { signal: options.signal }
-      },
-      this.timeoutMs
-    );
-    if (!response.ok) {
-      throw await GSwapSDKError.fromErrorResponse(url, response);
-    }
-    const json = await readResponseBody(response);
-    debugLog(`Response from ${baseUrl}${basePath}${endpoint}:`, json);
-    return json;
-  }
-  /** Send a JSON POST request and decode its response. */
-  async sendPostRequest(baseUrl, basePath, endpoint, body) {
-    return this.sendRequest("POST", baseUrl, basePath, endpoint, body);
-  }
-  /** Send a GET request with URL-encoded query parameters and decode its response. */
-  async sendGetRequest(baseUrl, basePath, endpoint, params, options) {
-    const searchParams = params ? new URLSearchParams(params) : void 0;
-    const endpointWithParams = searchParams ? `${endpoint}?${searchParams.toString()}` : endpoint;
-    return this.sendRequest("GET", baseUrl, basePath, endpointWithParams, void 0, options);
-  }
+	httpRequestor;
+	timeoutMs;
+	/** Create an HTTP client around fetch or an injected requestor. */
+	constructor(httpRequestor = fetch, timeoutMs = 3e4) {
+		this.httpRequestor = httpRequestor;
+		this.timeoutMs = timeoutMs;
+	}
+	async sendRequest(method, baseUrl, basePath, endpoint, body, options) {
+		const url = `${baseUrl}${basePath}${endpoint}`;
+		debugLog(`Sending request to ${url} with body:`, body);
+		const response = await requestWithTimeout(this.httpRequestor, url, {
+			method,
+			headers: {
+				"Content-Type": "application/json",
+				"User-Agent": `GalaChain-SDK/${SDK_VERSION}`
+			},
+			...body ? { body: JSON.stringify(body) } : {},
+			...(options === null || options === void 0 ? void 0 : options.signal) === void 0 ? {} : { signal: options.signal }
+		}, this.timeoutMs);
+		if (!response.ok) throw await GSwapSDKError.fromErrorResponse(url, response);
+		const json = await readResponseBody(response);
+		debugLog(`Response from ${baseUrl}${basePath}${endpoint}:`, json);
+		return json;
+	}
+	/** Send a JSON POST request and decode its response. */
+	async sendPostRequest(baseUrl, basePath, endpoint, body) {
+		return this.sendRequest("POST", baseUrl, basePath, endpoint, body);
+	}
+	/** Send a GET request with URL-encoded query parameters and decode its response. */
+	async sendGetRequest(baseUrl, basePath, endpoint, params, options) {
+		const searchParams = params ? new URLSearchParams(params) : void 0;
+		const endpointWithParams = searchParams ? `${endpoint}?${searchParams.toString()}` : endpoint;
+		return this.sendRequest("GET", baseUrl, basePath, endpointWithParams, void 0, options);
+	}
 };
 
-// src/utils/ordering.ts
+//#endregion
+//#region src/utils/ordering.ts
+/** Return two trading symbols in the contract's plain-string order. */
 function orderSymbols(a, b) {
-  return a < b ? [a, b] : [b, a];
-}
+	return a < b ? [a, b] : [b, a];
+}
+/** Read an ordered symbol pair from a tuple or object returned by a boundary helper.
+*
+* @example
+* ```ts
+* const pair = readOrderedSymbols(['GALA', 'GUSDC']);
+* console.log(pair.token0);
+* ```
+*/
 function readOrderedSymbols(value) {
-  if (Array.isArray(value) && value.length >= 2) {
-    const token0 = value[0];
-    const token1 = value[1];
-    if (typeof token0 === "string" && typeof token1 === "string") return { token0, token1 };
-  }
-  if (typeof value === "object" && value !== null) {
-    const record = value;
-    const token0 = record["token0"];
-    const token1 = record["token1"];
-    if (typeof token0 === "string" && typeof token1 === "string") return { token0, token1 };
-  }
-  throw new GSwapSDKError("Unable to order trading symbols.", "VALIDATION_ERROR", { value });
-}
+	if (Array.isArray(value) && value.length >= 2) {
+		const token0 = value[0];
+		const token1 = value[1];
+		if (typeof token0 === "string" && typeof token1 === "string") return {
+			token0,
+			token1
+		};
+	}
+	if (typeof value === "object" && value !== null) {
+		const record = value;
+		const token0 = record["token0"];
+		const token1 = record["token1"];
+		if (typeof token0 === "string" && typeof token1 === "string") return {
+			token0,
+			token1
+		};
+	}
+	throw new GSwapSDKError("Unable to order trading symbols.", "VALIDATION_ERROR", { value });
+}
+/** Return the `$`-joined composite key used by GalaChain object identities. */
 function compositeKeyOf(token) {
-  return [token.collection, token.category, token.type, token.additionalKey].join("$");
-}
+	return [
+		token.collection,
+		token.category,
+		token.type,
+		token.additionalKey
+	].join("$");
+}
+/**
+* Parse a pipe- or dollar-separated token class key.
+*
+* The LAST three segments are always `category`, `type` and `additionalKey`; everything before
+* them is the `collection`. Parsing from the right is required because real collections contain
+* the `$` delimiter themselves (for example `$GMUSIC`), so a plain left-to-right `split('$')`
+* shifts every field. Nothing here says anything about the token's symbol: a class key carries
+* no symbol, which must come from the token class or trading-symbol registry.
+*
+* @example
+* ```ts
+* parseTokenClassKey('$GMUSIC$Unit$none$none').collection; // '$GMUSIC'
+* ```
+*/
 function parseTokenClassKey(tokenClassKey) {
-  if (typeof tokenClassKey === "object") {
-    return {
-      collection: tokenClassKey.collection,
-      category: tokenClassKey.category,
-      type: tokenClassKey.type,
-      additionalKey: tokenClassKey.additionalKey
-    };
-  }
-  const parts = tokenClassKey.includes("|") ? tokenClassKey.split("|") : tokenClassKey.split("$");
-  if (parts.length !== 4 || parts.some((part) => part.length === 0)) {
-    throw new GSwapSDKError(
-      "Invalid token class key: expected four non-empty parts",
-      "VALIDATION_ERROR",
-      {
-        tokenClassKey
-      }
-    );
-  }
-  const [collection, category, type, additionalKey] = parts;
-  return {
-    collection,
-    category,
-    type,
-    additionalKey
-  };
+	if (typeof tokenClassKey === "object") return {
+		collection: tokenClassKey.collection,
+		category: tokenClassKey.category,
+		type: tokenClassKey.type,
+		additionalKey: tokenClassKey.additionalKey
+	};
+	const delimiter = tokenClassKey.includes("|") ? "|" : "$";
+	const segments = tokenClassKey.split(delimiter);
+	const tail = segments.slice(-3);
+	const collection = segments.slice(0, -3).join(delimiter);
+	if (segments.length < 4 || collection.length === 0 || tail.some((part) => part.length === 0)) throw new GSwapSDKError("Invalid token class key: expected a collection followed by category, type and additionalKey", "VALIDATION_ERROR", { tokenClassKey });
+	const [category, type, additionalKey] = tail;
+	return {
+		collection,
+		category,
+		type,
+		additionalKey
+	};
 }
 
-// src/classes/pools.ts
+//#endregion
+//#region src/classes/pools.ts
+/** Read-only pool and current-price access for the current GalaChainDex contract. */
 var Pools = class {
-  /**
-   * Creates a pool service.
-   *
-   * @example
-   * ```ts
-   * const pools = new Pools(gateway, symbols);
-   * ```
-   */
-  constructor(gateway, symbols) {
-    this.gateway = gateway;
-    this.symbols = symbols;
-    this.http = new HttpClient(gateway.httpRequestor, gateway.requestTimeoutMs ?? 3e4);
-  }
-  gateway;
-  symbols;
-  http;
-  /**
-   * Fetches every current-contract pool from the swap backend.
-   *
-   * @example
-   * ```ts
-   * const pools = await service.getPools();
-   * console.log(pools.length);
-   * ```
-   */
-  async getPools(options) {
-    const response = await this.http.sendGetRequest(
-      this.gateway.dexBackendBaseUrl,
-      "/v2/trade",
-      "/pools",
-      void 0,
-      (options == null ? void 0 : options.signal) === void 0 ? void 0 : { signal: options.signal }
-    );
-    if (!Array.isArray(response.data) || !response.data.every(isPoolListInfo)) {
-      throw new GSwapSDKError("Backend returned an invalid pool list.", "INVALID_CHAIN_RESPONSE", {
-        data: response.data
-      });
-    }
-    return response.data;
-  }
-  /**
-   * Fetches one pool from the backend, preserving whether the request order was flipped.
-   *
-   * @example
-   * ```ts
-   * const pool = await service.getPool('GUSDC', 'GALA', 3000);
-   * console.log(pool.flippedFromRequest);
-   * ```
-   */
-  async getPool(token0, token1, fee) {
-    validateFee(fee);
-    return this.getBackend("/pool", await this.backendParams(token0, token1, fee));
-  }
-  /**
-   * Fetches the current sqrt price, price, and tick for one pool.
-   *
-   * @example
-   * ```ts
-   * const slot0 = await service.getSlot0('GALA', 'GUSDC', 3000);
-   * console.log(slot0.tick);
-   * ```
-   */
-  async getSlot0(token0, token1, fee) {
-    validateFee(fee);
-    return this.getBackend("/slot0", await this.backendParams(token0, token1, fee));
-  }
-  /**
-   * Fetches the complete chain composite pool snapshot, in canonical symbol order.
-   *
-   * @example
-   * ```ts
-   * const composite = await service.getCompositePool('GALA', 'GUSDC', 3000);
-   * console.log(composite.positions?.length ?? 0);
-   * ```
-   */
-  async getCompositePool(token0, token1, fee) {
-    validateFee(fee);
-    const first = await resolveSymbol(this.symbols, token0);
-    const second = await resolveSymbol(this.symbols, token1);
-    const ordered = readOrderedSymbols(orderSymbols(first, second));
-    return this.getBackend("/composite-pool", {
-      token0: ordered.token0,
-      token1: ordered.token1,
-      fee: String(fee)
-    });
-  }
-  async backendParams(token0, token1, fee) {
-    return {
-      token0: await resolveSymbol(this.symbols, token0),
-      token1: await resolveSymbol(this.symbols, token1),
-      fee: String(fee)
-    };
-  }
-  async getBackend(endpoint, params) {
-    try {
-      const response = await this.http.sendGetRequest(
-        this.gateway.dexBackendBaseUrl,
-        "/v2/trade",
-        endpoint,
-        params
-      );
-      return response.data;
-    } catch (error) {
-      if (error instanceof GSwapSDKError) throw error;
-      throw new GSwapSDKError("Pool request failed.", "HTTP_ERROR", { cause: error });
-    }
-  }
+	gateway;
+	symbols;
+	/**
+	* Creates a pool service.
+	*
+	* @example
+	* ```ts
+	* const pools = new Pools(gateway, symbols);
+	* ```
+	*/
+	constructor(gateway, symbols) {
+		this.gateway = gateway;
+		this.symbols = symbols;
+		this.http = new HttpClient(gateway.httpRequestor, gateway.requestTimeoutMs ?? 3e4);
+	}
+	http;
+	/**
+	* Fetches every current-contract pool from the swap backend.
+	*
+	* @example
+	* ```ts
+	* const pools = await service.getPools();
+	* console.log(pools.length);
+	* ```
+	*/
+	async getPools(options) {
+		const response = await this.http.sendGetRequest(this.gateway.dexBackendBaseUrl, "/v2/trade", "/pools", void 0, (options === null || options === void 0 ? void 0 : options.signal) === void 0 ? void 0 : { signal: options.signal });
+		if (!Array.isArray(response.data) || !response.data.every(isPoolListInfo)) throw new GSwapSDKError("Backend returned an invalid pool list.", "INVALID_CHAIN_RESPONSE", { data: response.data });
+		return response.data;
+	}
+	/**
+	* Fetches one pool from the backend, preserving whether the request order was flipped.
+	*
+	* @example
+	* ```ts
+	* const pool = await service.getPool('GUSDC', 'GALA', 3000);
+	* console.log(pool.flippedFromRequest);
+	* ```
+	*/
+	async getPool(token0, token1, fee) {
+		validateFee(fee);
+		return this.getBackend("/pool", await this.backendParams(token0, token1, fee));
+	}
+	/**
+	* Fetches the current sqrt price, price, and tick for one pool.
+	*
+	* @example
+	* ```ts
+	* const slot0 = await service.getSlot0('GALA', 'GUSDC', 3000);
+	* console.log(slot0.tick);
+	* ```
+	*/
+	async getSlot0(token0, token1, fee) {
+		validateFee(fee);
+		return this.getBackend("/slot0", await this.backendParams(token0, token1, fee));
+	}
+	/**
+	* Fetches the complete chain composite pool snapshot, in canonical symbol order.
+	*
+	* @example
+	* ```ts
+	* const composite = await service.getCompositePool('GALA', 'GUSDC', 3000);
+	* console.log(composite.positions?.length ?? 0);
+	* ```
+	*/
+	async getCompositePool(token0, token1, fee) {
+		validateFee(fee);
+		const first = await resolveSymbol$2(this.symbols, token0);
+		const second = await resolveSymbol$2(this.symbols, token1);
+		const ordered = readOrderedSymbols(orderSymbols(first, second));
+		return this.getBackend("/composite-pool", {
+			token0: ordered.token0,
+			token1: ordered.token1,
+			fee: String(fee)
+		});
+	}
+	async backendParams(token0, token1, fee) {
+		return {
+			token0: await resolveSymbol$2(this.symbols, token0),
+			token1: await resolveSymbol$2(this.symbols, token1),
+			fee: String(fee)
+		};
+	}
+	async getBackend(endpoint, params) {
+		try {
+			return (await this.http.sendGetRequest(this.gateway.dexBackendBaseUrl, "/v2/trade", endpoint, params)).data;
+		} catch (error) {
+			if (error instanceof GSwapSDKError) throw error;
+			throw new GSwapSDKError("Pool request failed.", "HTTP_ERROR", { cause: error });
+		}
+	}
 };
-async function resolveSymbol(symbols, token) {
-  const resolved = await symbols.resolve(token);
-  if (resolved.symbol.length > 0) return resolved.symbol;
-  throw new GSwapSDKError("Token could not be resolved to a trading symbol.", "SYMBOL_NOT_FOUND", {
-    token
-  });
+async function resolveSymbol$2(symbols, token) {
+	const resolved = await symbols.resolve(token);
+	if (resolved.symbol.length > 0) return resolved.symbol;
+	throw new GSwapSDKError("Token could not be resolved to a trading symbol.", "SYMBOL_NOT_FOUND", { token });
 }
 function isPoolListInfo(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const row = value;
-  const requiredNumbers = ["fee", "tickSpacing", "protocolFees", "tradingFees"];
-  const optionalStrings = [
-    "token0CompositeKey",
-    "token1CompositeKey",
-    "creator",
-    "price",
-    "sqrtPrice",
-    "token0Tvl",
-    "token1Tvl"
-  ];
-  const optionalNumbers = [
-    "tick",
-    "tvlUsd",
-    "volume1d",
-    "volume7d",
-    "volume30d",
-    "trades1d",
-    "fee24h",
-    "apr1d",
-    "token0Price",
-    "token1Price"
-  ];
-  return row["contractVersion"] === "v2" && typeof row["token0"] === "string" && typeof row["token1"] === "string" && typeof row["poolName"] === "string" && typeof row["poolRef"] === "string" && requiredNumbers.every((key) => isFiniteNumber(row[key])) && optionalStrings.every((key) => isOptionalString(row[key])) && optionalNumbers.every((key) => isOptionalNumber(row[key]));
+	if (typeof value !== "object" || value === null) return false;
+	const row = value;
+	return row["contractVersion"] === "v2" && typeof row["token0"] === "string" && typeof row["token1"] === "string" && typeof row["poolName"] === "string" && typeof row["poolRef"] === "string" && [
+		"fee",
+		"tickSpacing",
+		"protocolFees",
+		"tradingFees"
+	].every((key) => isFiniteNumber(row[key])) && [
+		"token0CompositeKey",
+		"token1CompositeKey",
+		"creator",
+		"price",
+		"sqrtPrice",
+		"token0Tvl",
+		"token1Tvl"
+	].every((key) => isOptionalString(row[key])) && [
+		"tick",
+		"tvlUsd",
+		"volume1d",
+		"volume7d",
+		"volume30d",
+		"trades1d",
+		"fee24h",
+		"apr1d",
+		"token0Price",
+		"token1Price"
+	].every((key) => isOptionalNumber(row[key]));
 }
 function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
+	return typeof value === "number" && Number.isFinite(value);
 }
 function isOptionalString(value) {
-  return value === void 0 || typeof value === "string";
+	return value === void 0 || typeof value === "string";
 }
 function isOptionalNumber(value) {
-  return value === void 0 || isFiniteNumber(value);
+	return value === void 0 || isFiniteNumber(value);
 }
 
-// src/classes/positions.ts
-var import_bignumber3 = __toESM(require("bignumber.js"), 1);
+//#endregion
+//#region src/classes/positions.ts
+/**
+* Manages current-contract concentrated-liquidity positions.
+*
+* @example
+* ```typescript
+* const positions = gSwap.positions;
+* const mine = await positions.getUserPositions('client|012345678901234567890123');
+* console.log(mine.length);
+* ```
+*/
 var Positions = class {
-  constructor(gateway, symbols, signer, walletAddress) {
-    this.gateway = gateway;
-    this.symbols = symbols;
-    this.signer = signer;
-    this.walletAddress = walletAddress;
-    this.http = new HttpClient(gateway.httpRequestor, gateway.requestTimeoutMs ?? 3e4);
-  }
-  gateway;
-  symbols;
-  signer;
-  walletAddress;
-  http;
-  /**
-   * Gets all current-contract positions owned by an address.
-   *
-   * @param owner - GalaChain owner identity.
-   * @returns Enriched positions from the v2 trade backend.
-   * @example
-   * ```typescript
-   * const positions = await gSwap.positions.getUserPositions('client|012345678901234567890123');
-   * ```
-   */
-  async getUserPositions(owner) {
-    const response = await this.get("/positions", { user: owner });
-    return response.data.map((position) => this.mapPosition(position));
-  }
-  /**
-   * Gets one position, normalizing a caller-supplied reversed pair to canonical symbol order.
-   * Reversed pairs also invert the price axis, so `[lower, upper]` becomes `[-upper, -lower]`.
-   *
-   * @param args - Pair, owner, fee, and position tick range.
-   * @returns The position, or `null` when the backend returns 404.
-   * @example
-   * ```typescript
-   * const position = await gSwap.positions.getPosition({
-   *   token0: 'GALA', token1: 'GUSDC', owner: 'client|012345678901234567890123',
-   *   fee: 3000, tickLower: -19200, tickUpper: 12000,
-   * });
-   * ```
-   */
-  async getPosition(args, signal) {
-    const pair = await this.symbols.orderPair(args.token0, args.token1);
-    const ticks = this.canonicalTicks(args.tickLower, args.tickUpper, pair.flipped);
-    const response = await this.getNullable(
-      "/position",
-      {
-        token0: pair.token0.symbol,
-        token1: pair.token1.symbol,
-        fee: `${args.fee}`,
-        owner: args.owner,
-        tickLower: `${ticks.tickLower}`,
-        tickUpper: `${ticks.tickUpper}`
-      },
-      signal
-    );
-    return response === null ? null : this.mapPosition(response.data);
-  }
-  /**
-   * Estimates the other token amount and resulting liquidity for a deposit.
-   *
-   * @param args - Pair, tick range, deposit amount, and the amount's caller-side token index.
-   * @returns Backend liquidity estimate.
-   * @example
-   * ```typescript
-   * const estimate = await gSwap.positions.estimateAddLiquidity({
-   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
-   *   tickLower: -19200, tickUpper: 12000, amount: '100', amountIsToken0: true,
-   * });
-   * ```
-   */
-  async estimateAddLiquidity(args) {
-    validateNumericAmount(args.amount, "amount");
-    const response = await this.get("/add-liq-estimate", {
-      token0: this.requestToken(args.token0),
-      token1: this.requestToken(args.token1),
-      fee: `${args.fee}`,
-      tickLower: `${args.tickLower}`,
-      tickUpper: `${args.tickUpper}`,
-      amount: new import_bignumber3.default(args.amount).toFixed(),
-      amountIsToken0: String(args.amountIsToken0)
-    });
-    return response.data;
-  }
-  /**
-   * Estimates token amounts released by burning liquidity.
-   *
-   * @param args - Pair, tick range, fee tier, and liquidity quantity.
-   * @returns Estimated token0 and token1 quantities.
-   * @example
-   * ```typescript
-   * const estimate = await gSwap.positions.estimateRemoveLiquidity({
-   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
-   *   tickLower: -19200, tickUpper: 12000, liquidity: '1000',
-   * });
-   * ```
-   */
-  async estimateRemoveLiquidity(args) {
-    validateNumericAmount(args.liquidity, "liquidity");
-    const response = await this.get("/remove-liq-estimate", {
-      token0: this.requestToken(args.token0),
-      token1: this.requestToken(args.token1),
-      fee: `${args.fee}`,
-      tickLower: `${args.tickLower}`,
-      tickUpper: `${args.tickUpper}`,
-      liquidity: new import_bignumber3.default(args.liquidity).toFixed()
-    });
-    return response.data;
-  }
-  /**
-   * Adds liquidity using an explicit tick range. Exactly one canonical deposit field is emitted.
-   *
-   * @param args - Pair, fee, range, deposit amount, and caller-side token index.
-   * @returns The synchronously submitted transaction.
-   * @example
-   * ```typescript
-   * const tx = await gSwap.positions.addLiquidityByTicks({
-   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
-   *   tickLower: -19200, tickUpper: 12000, amount: '100', amountIsToken0: true,
-   * });
-   * await tx.confirm();
-   * ```
-   */
-  async addLiquidityByTicks(args) {
-    validateFee(args.fee);
-    const pair = await this.symbols.orderPair(args.token0, args.token1);
-    const ticks = this.canonicalTicks(args.tickLower, args.tickUpper, pair.flipped);
-    assertTickRange(ticks.tickLower, ticks.tickUpper, args.fee);
-    validateNumericAmount(args.amount, "amount");
-    const amount = new import_bignumber3.default(args.amount).toFixed();
-    const dto = {
-      token0: pair.token0.symbol,
-      token1: pair.token1.symbol,
-      fee: args.fee,
-      tickLower: ticks.tickLower,
-      tickUpper: ticks.tickUpper,
-      uniqueKey: this.uniqueKey(),
-      ...pair.flipped !== args.amountIsToken0 ? { depositQuantityToken0: amount } : { depositQuantityToken1: amount }
-    };
-    return this.submit("AddLiquidity", dto, {
-      kind: "add",
-      identity: {
-        token0: pair.token0.symbol,
-        token1: pair.token1.symbol,
-        fee: args.fee,
-        tickLower: ticks.tickLower,
-        tickUpper: ticks.tickUpper
-      }
-    });
-  }
-  /**
-   * Adds liquidity from prices, flooring the lower tick and ceiling the upper tick to fee spacing.
-   * The resulting range is therefore no narrower than the requested price interval.
-   *
-   * @param args - Pair, fee, price range, deposit amount, and caller-side token index.
-   * @returns The synchronously submitted transaction.
-   * @example
-   * ```typescript
-   * const tx = await gSwap.positions.addLiquidityByPrice({
-   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
-   *   minPrice: '0.14', maxPrice: '0.16', amount: '100', amountIsToken0: true,
-   * });
-   * ```
-   */
-  async addLiquidityByPrice(args) {
-    validateFee(args.fee);
-    this.rejectNumber(args.minPrice, "minPrice");
-    this.rejectNumber(args.maxPrice, "maxPrice");
-    const minPrice = new import_bignumber3.default(args.minPrice);
-    const maxPrice = new import_bignumber3.default(args.maxPrice);
-    if (!minPrice.isFinite() || !maxPrice.isFinite() || minPrice.isLessThanOrEqualTo(0) || maxPrice.isLessThanOrEqualTo(0)) {
-      throw new GSwapSDKError("Price bounds must be finite and positive.", "VALIDATION_ERROR");
-    }
-    if (minPrice.isGreaterThan(maxPrice)) {
-      throw new GSwapSDKError(
-        "minPrice must be less than or equal to maxPrice.",
-        "VALIDATION_ERROR"
-      );
-    }
-    const spacing = this.tickSpacing(args.fee);
-    const tickLower = alignTickDown(tickFromPrice(minPrice), spacing);
-    const tickUpper = alignTickUp(tickFromPrice(maxPrice), spacing);
-    return this.addLiquidityByTicks({
-      token0: args.token0,
-      token1: args.token1,
-      fee: args.fee,
-      tickLower,
-      tickUpper,
-      amount: args.amount,
-      amountIsToken0: args.amountIsToken0
-    });
-  }
-  /**
-   * Removes liquidity by withdrawing at most one canonical token quantity.
-   * Omitting both amounts closes the position and sweeps all accrued fees.
-   *
-   * @param args - Pair, fee, range, and optional caller-side withdrawal amount.
-   * @returns The synchronously submitted transaction.
-   * @example
-   * ```typescript
-   * const tx = await gSwap.positions.removeLiquidity({
-   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
-   *   tickLower: -19200, tickUpper: 12000,
-   * });
-   * ```
-   */
-  async removeLiquidity(args) {
-    validateFee(args.fee);
-    const pair = await this.symbols.orderPair(args.token0, args.token1);
-    const ticks = this.canonicalTicks(args.tickLower, args.tickUpper, pair.flipped);
-    assertTickRange(ticks.tickLower, ticks.tickUpper, args.fee);
-    if (args.amount0 !== void 0 && args.amount1 !== void 0) {
-      throw new GSwapSDKError("Provide at most one of amount0 or amount1.", "VALIDATION_ERROR");
-    }
-    if (args.amount0 !== void 0) validateNumericAmount(args.amount0, "amount0");
-    if (args.amount1 !== void 0) validateNumericAmount(args.amount1, "amount1");
-    const withdrawal = args.amount0 !== void 0 ? pair.flipped ? { withdrawalQuantityToken1: new import_bignumber3.default(args.amount0).toFixed() } : { withdrawalQuantityToken0: new import_bignumber3.default(args.amount0).toFixed() } : args.amount1 !== void 0 ? pair.flipped ? { withdrawalQuantityToken0: new import_bignumber3.default(args.amount1).toFixed() } : { withdrawalQuantityToken1: new import_bignumber3.default(args.amount1).toFixed() } : {};
-    const dto = {
-      token0: pair.token0.symbol,
-      token1: pair.token1.symbol,
-      fee: args.fee,
-      tickLower: ticks.tickLower,
-      tickUpper: ticks.tickUpper,
-      uniqueKey: this.uniqueKey(),
-      ...withdrawal
-    };
-    const isFullClose = args.amount0 === void 0 && args.amount1 === void 0;
-    return this.submit("RemoveLiquidity", dto, {
-      kind: isFullClose ? "removeFull" : "removePartial",
-      identity: {
-        token0: pair.token0.symbol,
-        token1: pair.token1.symbol,
-        fee: args.fee,
-        tickLower: ticks.tickLower,
-        tickUpper: ticks.tickUpper
-      }
-    });
-  }
-  /**
-   * Collects all accrued fees for a position; the contract does not support partial collection.
-   *
-   * @param args - Pair, fee, and tick range identifying the position.
-   * @returns The synchronously submitted transaction.
-   * @example
-   * ```typescript
-   * const tx = await gSwap.positions.collectPositionFees({
-   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
-   *   tickLower: -19200, tickUpper: 12000,
-   * });
-   * ```
-   */
-  async collectPositionFees(args) {
-    validateFee(args.fee);
-    const pair = await this.symbols.orderPair(args.token0, args.token1);
-    const ticks = this.canonicalTicks(args.tickLower, args.tickUpper, pair.flipped);
-    assertTickRange(ticks.tickLower, ticks.tickUpper, args.fee);
-    const dto = {
-      token0: pair.token0.symbol,
-      token1: pair.token1.symbol,
-      fee: args.fee,
-      tickLower: ticks.tickLower,
-      tickUpper: ticks.tickUpper,
-      uniqueKey: this.uniqueKey()
-    };
-    return this.submit("CollectPositionFees", dto, {
-      kind: "collect",
-      identity: {
-        token0: pair.token0.symbol,
-        token1: pair.token1.symbol,
-        fee: args.fee,
-        tickLower: ticks.tickLower,
-        tickUpper: ticks.tickUpper
-      }
-    });
-  }
-  /**
-   * Creates a pool, resolving registered trading symbols and falling back to class collections.
-   * Reversed symbol order inverts the supplied starting price or square-root price.
-   *
-   * @param args - Token class keys or references, fee, exactly one starting price field, and privacy options.
-   * @returns The synchronously submitted transaction.
-   * @example
-   * ```typescript
-   * const tx = await gSwap.positions.createPool({
-   *   token0: 'GALA|Unit|none|none', token1: 'GUSDC|Unit|none|none', fee: 3000,
-   *   startingPrice: '0.15',
-   * });
-   * ```
-   */
-  async createPool(args) {
-    var _a, _b;
-    const hasPrice = args.startingPrice !== void 0;
-    const hasSqrtPrice = args.startingSqrtPrice !== void 0;
-    if (hasPrice === hasSqrtPrice) {
-      throw new GSwapSDKError(
-        "Provide exactly one of startingPrice or startingSqrtPrice.",
-        "VALIDATION_ERROR"
-      );
-    }
-    validateFee(args.fee);
-    const [tokenA, tokenB] = await Promise.all([
-      this.resolveCreateToken(args.token0),
-      this.resolveCreateToken(args.token1)
-    ]);
-    const flipped = tokenA.symbol > tokenB.symbol;
-    const [token0, token1] = flipped ? [tokenB, tokenA] : [tokenA, tokenB];
-    const sourcePriceInput = hasPrice ? args.startingPrice : args.startingSqrtPrice;
-    this.rejectNumber(sourcePriceInput, hasPrice ? "startingPrice" : "startingSqrtPrice");
-    const sourcePrice = new import_bignumber3.default(sourcePriceInput);
-    if (!sourcePrice.isFinite() || sourcePrice.isLessThanOrEqualTo(0)) {
-      throw new GSwapSDKError("Starting price must be finite and positive.", "VALIDATION_ERROR");
-    }
-    const canonicalPrice = flipped ? new import_bignumber3.default(1).dividedBy(sourcePrice) : sourcePrice;
-    const dto = {
-      token0Key: token0.classKey,
-      token1Key: token1.classKey,
-      token0Symbol: token0.symbol,
-      token1Symbol: token1.symbol,
-      fee: args.fee,
-      uniqueKey: this.uniqueKey(),
-      ...hasPrice ? { startingPrice: canonicalPrice.toFixed() } : { startingSqrtPrice: canonicalPrice.toFixed() },
-      ...args.isPrivate === void 0 ? {} : { isPrivate: args.isPrivate },
-      ...args.privateAccess === void 0 ? {} : { privateAccess: args.privateAccess }
-    };
-    const transaction = await this.submit("CreatePool", dto, {
-      kind: "createPool",
-      token0: token0.symbol,
-      token1: token1.symbol,
-      fee: args.fee
-    });
-    (_b = (_a = this.symbols).invalidate) == null ? void 0 : _b.call(_a);
-    return transaction;
-  }
-  async submit(method, dto, confirmation) {
-    if (this.signer === void 0) throw GSwapSDKError.noSignerError();
-    const signed = await this.signer.signObject(method, dto);
-    const submitOptions = this.walletAddress === void 0 ? {} : { walletAddress: this.walletAddress };
-    const owner = this.walletAddress;
-    const positionConfirmation = this.buildPositionConfirmation(confirmation, owner);
-    const options = {
-      ...submitOptions,
-      ...positionConfirmation === void 0 ? {} : { positionConfirmation }
-    };
-    return this.gateway.submit(method, signed, options);
-  }
-  /**
-   * Builds a confirmation closure that proves the write's own effect, not just that a
-   * position row exists (true before most of these writes run too, for any operation on a
-   * pre-existing position — existence alone would false-confirm before the write executes,
-   * and would never confirm a full close, whose whole point is that the position stops
-   * existing).
-   *
-   * The "before" state is captured lazily, on the confirmation closure's own first poll —
-   * not eagerly here in `submit()` — so confirming a write never adds an extra round-trip to
-   * the write itself; the cost of establishing the baseline is paid by `confirm()`, only if
-   * and when the caller actually asks to confirm.
-   */
-  buildPositionConfirmation(confirmation, owner) {
-    if (confirmation === void 0) return void 0;
-    if (confirmation.kind === "createPool") {
-      const { token0, token1, fee } = confirmation;
-      return async (signal) => {
-        const pool = await this.getNullable(
-          "/pool",
-          { token0, token1, fee: `${fee}` },
-          signal
-        );
-        return pool === null ? { confirmed: false } : { confirmed: true, position: null };
-      };
-    }
-    if (owner === void 0) return void 0;
-    const { kind, identity } = confirmation;
-    let baseline;
-    return async (signal) => {
-      const current = await this.getPosition({ ...identity, owner }, signal);
-      if (baseline === void 0) {
-        baseline = {
-          liquidity: new import_bignumber3.default((current == null ? void 0 : current.liquidity) ?? 0),
-          fees: new import_bignumber3.default((current == null ? void 0 : current.fees0) ?? 0).plus(new import_bignumber3.default((current == null ? void 0 : current.fees1) ?? 0))
-        };
-        return kind === "removeFull" && current === null ? { confirmed: true, position: null } : { confirmed: false };
-      }
-      switch (kind) {
-        case "add":
-          return current !== null && new import_bignumber3.default(current.liquidity).isGreaterThan(baseline.liquidity) ? { confirmed: true, position: current } : { confirmed: false };
-        case "removePartial":
-          return current !== null && new import_bignumber3.default(current.liquidity).isLessThan(baseline.liquidity) ? { confirmed: true, position: current } : { confirmed: false };
-        case "removeFull":
-          return current === null ? { confirmed: true, position: null } : { confirmed: false };
-        case "collect": {
-          if (current === null) return { confirmed: false };
-          const currentFees = new import_bignumber3.default(current.fees0 ?? 0).plus(
-            new import_bignumber3.default(current.fees1 ?? 0)
-          );
-          if (currentFees.isLessThan(baseline.fees)) return { confirmed: true, position: current };
-          if (baseline.fees.isZero() && currentFees.isZero())
-            return { confirmed: true, position: current };
-          return { confirmed: false };
-        }
-      }
-    };
-  }
-  async get(endpoint, params, signal) {
-    return this.http.sendGetRequest(
-      this.gateway.dexBackendBaseUrl,
-      "/v2/trade",
-      endpoint,
-      params,
-      signal === void 0 ? void 0 : { signal }
-    );
-  }
-  async getNullable(endpoint, params, signal) {
-    try {
-      return await this.get(endpoint, params, signal);
-    } catch (error) {
-      if (this.isNotFound(error)) return null;
-      throw error;
-    }
-  }
-  isNotFound(error) {
-    if (!(error instanceof GSwapSDKError) || error.details === void 0) return false;
-    return error.details["status"] === 404;
-  }
-  mapPosition(position) {
-    return {
-      token0Symbol: position.token0Symbol,
-      token1Symbol: position.token1Symbol,
-      ...position.token0CompositeKey === void 0 ? {} : { token0CompositeKey: position.token0CompositeKey },
-      ...position.token1CompositeKey === void 0 ? {} : { token1CompositeKey: position.token1CompositeKey },
-      fee: position.fee,
-      tickLower: position.tickLower,
-      tickUpper: position.tickUpper,
-      liquidity: position.liquidity,
-      amount0: position.amount0,
-      amount1: position.amount1,
-      inRange: position.inRange,
-      ...position.currentTick === void 0 ? {} : { currentTick: position.currentTick },
-      ...position.sqrtPrice === void 0 ? {} : { sqrtPrice: position.sqrtPrice },
-      pool: position.poolRef ?? position.pool ?? "",
-      owner: position.owner,
-      ...position.fees0 === void 0 ? {} : { fees0: position.fees0 },
-      ...position.fees1 === void 0 ? {} : { fees1: position.fees1 }
-    };
-  }
-  requestToken(ref) {
-    return typeof ref === "string" ? ref : compositeKeyOf(ref);
-  }
-  canonicalTicks(tickLower, tickUpper, flipped) {
-    return flipped ? { tickLower: -tickUpper, tickUpper: -tickLower } : { tickLower, tickUpper };
-  }
-  tickSpacing(fee) {
-    const spacing = TICK_SPACING_BY_FEE[fee];
-    if (spacing === void 0) {
-      throw new GSwapSDKError(`Unsupported fee tier: ${fee}.`, "VALIDATION_ERROR");
-    }
-    return spacing;
-  }
-  rejectNumber(value, parameterName) {
-    if (typeof value === "number") {
-      throw new GSwapSDKError(
-        `Invalid ${parameterName}: use a decimal string or BigNumber, not a JavaScript number`,
-        "VALIDATION_ERROR"
-      );
-    }
-  }
-  uniqueKey() {
-    return `gswap-sdk-${globalThis.crypto.randomUUID()}`;
-  }
-  async resolveCreateToken(ref) {
-    try {
-      const lookupRef = typeof ref === "object" ? compositeKeyOf(ref) : ref;
-      const resolved = await this.symbols.resolve(lookupRef);
-      const suppliedClassKey = this.tryParseClassKey(ref);
-      return {
-        symbol: resolved.symbol,
-        classKey: suppliedClassKey ?? parseTokenClassKey({
-          collection: resolved.collection,
-          category: resolved.category,
-          type: resolved.type,
-          additionalKey: resolved.additionalKey
-        })
-      };
-    } catch (error) {
-      if (!(error instanceof GSwapSDKError) || error.code !== "UNKNOWN_TOKEN") {
-        throw error;
-      }
-      let classKey;
-      try {
-        classKey = parseTokenClassKey(ref);
-      } catch {
-        throw error;
-      }
-      return { symbol: classKey.collection, classKey };
-    }
-  }
-  tryParseClassKey(ref) {
-    try {
-      return parseTokenClassKey(ref);
-    } catch {
-      return void 0;
-    }
-  }
+	gateway;
+	symbols;
+	signer;
+	walletAddress;
+	constructor(gateway, symbols, signer, walletAddress) {
+		this.gateway = gateway;
+		this.symbols = symbols;
+		this.signer = signer;
+		this.walletAddress = walletAddress;
+		this.http = new HttpClient(gateway.httpRequestor, gateway.requestTimeoutMs ?? 3e4);
+	}
+	http;
+	/**
+	* Gets all current-contract positions owned by an address.
+	*
+	* @param owner - GalaChain owner identity.
+	* @returns Enriched positions from the v2 trade backend.
+	* @example
+	* ```typescript
+	* const positions = await gSwap.positions.getUserPositions('client|012345678901234567890123');
+	* ```
+	*/
+	async getUserPositions(owner) {
+		return (await this.get("/positions", { user: owner })).data.map((position) => this.mapPosition(position));
+	}
+	/**
+	* Gets one position, normalizing a caller-supplied reversed pair to canonical symbol order.
+	* Reversed pairs also invert the price axis, so `[lower, upper]` becomes `[-upper, -lower]`.
+	*
+	* @param args - Pair, owner, fee, and position tick range.
+	* @returns The position, or `null` when the backend returns 404.
+	* @example
+	* ```typescript
+	* const position = await gSwap.positions.getPosition({
+	*   token0: 'GALA', token1: 'GUSDC', owner: 'client|012345678901234567890123',
+	*   fee: 3000, tickLower: -19200, tickUpper: 12000,
+	* });
+	* ```
+	*/
+	async getPosition(args, signal) {
+		const pair = await this.symbols.orderPair(args.token0, args.token1);
+		const ticks = this.canonicalTicks(args.tickLower, args.tickUpper, pair.flipped);
+		const response = await this.getNullable("/position", {
+			token0: pair.token0.symbol,
+			token1: pair.token1.symbol,
+			fee: `${args.fee}`,
+			owner: args.owner,
+			tickLower: `${ticks.tickLower}`,
+			tickUpper: `${ticks.tickUpper}`
+		}, signal);
+		return response === null ? null : this.mapPosition(response.data);
+	}
+	/**
+	* Estimates the other token amount and resulting liquidity for a deposit.
+	*
+	* @param args - Pair, tick range, deposit amount, and the amount's caller-side token index.
+	* @returns Backend liquidity estimate.
+	* @example
+	* ```typescript
+	* const estimate = await gSwap.positions.estimateAddLiquidity({
+	*   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+	*   tickLower: -19200, tickUpper: 12000, amount: '100', amountIsToken0: true,
+	* });
+	* ```
+	*/
+	async estimateAddLiquidity(args) {
+		validateNumericAmount(args.amount, "amount");
+		return (await this.get("/add-liq-estimate", {
+			token0: this.requestToken(args.token0),
+			token1: this.requestToken(args.token1),
+			fee: `${args.fee}`,
+			tickLower: `${args.tickLower}`,
+			tickUpper: `${args.tickUpper}`,
+			amount: new bignumber_js.default(args.amount).toFixed(),
+			amountIsToken0: String(args.amountIsToken0)
+		})).data;
+	}
+	/**
+	* Estimates token amounts released by burning liquidity.
+	*
+	* @param args - Pair, tick range, fee tier, and liquidity quantity.
+	* @returns Estimated token0 and token1 quantities.
+	* @example
+	* ```typescript
+	* const estimate = await gSwap.positions.estimateRemoveLiquidity({
+	*   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+	*   tickLower: -19200, tickUpper: 12000, liquidity: '1000',
+	* });
+	* ```
+	*/
+	async estimateRemoveLiquidity(args) {
+		validateNumericAmount(args.liquidity, "liquidity");
+		return (await this.get("/remove-liq-estimate", {
+			token0: this.requestToken(args.token0),
+			token1: this.requestToken(args.token1),
+			fee: `${args.fee}`,
+			tickLower: `${args.tickLower}`,
+			tickUpper: `${args.tickUpper}`,
+			liquidity: new bignumber_js.default(args.liquidity).toFixed()
+		})).data;
+	}
+	/**
+	* Adds liquidity using an explicit tick range. Exactly one canonical deposit field is emitted.
+	*
+	* @param args - Pair, fee, range, deposit amount, and caller-side token index.
+	* @returns The synchronously submitted transaction.
+	* @example
+	* ```typescript
+	* const tx = await gSwap.positions.addLiquidityByTicks({
+	*   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+	*   tickLower: -19200, tickUpper: 12000, amount: '100', amountIsToken0: true,
+	* });
+	* await tx.confirm();
+	* ```
+	*/
+	async addLiquidityByTicks(args) {
+		validateFee(args.fee);
+		const pair = await this.symbols.orderPair(args.token0, args.token1);
+		const ticks = this.canonicalTicks(args.tickLower, args.tickUpper, pair.flipped);
+		assertTickRange(ticks.tickLower, ticks.tickUpper, args.fee);
+		validateNumericAmount(args.amount, "amount");
+		const amount = new bignumber_js.default(args.amount).toFixed();
+		const dto = {
+			token0: pair.token0.symbol,
+			token1: pair.token1.symbol,
+			fee: args.fee,
+			tickLower: ticks.tickLower,
+			tickUpper: ticks.tickUpper,
+			uniqueKey: this.uniqueKey(),
+			...pair.flipped !== args.amountIsToken0 ? { depositQuantityToken0: amount } : { depositQuantityToken1: amount }
+		};
+		return this.submit("AddLiquidity", dto, {
+			kind: "add",
+			identity: {
+				token0: pair.token0.symbol,
+				token1: pair.token1.symbol,
+				fee: args.fee,
+				tickLower: ticks.tickLower,
+				tickUpper: ticks.tickUpper
+			}
+		});
+	}
+	/**
+	* Adds liquidity from prices, flooring the lower tick and ceiling the upper tick to fee spacing.
+	* The resulting range is therefore no narrower than the requested price interval.
+	*
+	* @param args - Pair, fee, price range, deposit amount, and caller-side token index.
+	* @returns The synchronously submitted transaction.
+	* @example
+	* ```typescript
+	* const tx = await gSwap.positions.addLiquidityByPrice({
+	*   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+	*   minPrice: '0.14', maxPrice: '0.16', amount: '100', amountIsToken0: true,
+	* });
+	* ```
+	*/
+	async addLiquidityByPrice(args) {
+		validateFee(args.fee);
+		this.rejectNumber(args.minPrice, "minPrice");
+		this.rejectNumber(args.maxPrice, "maxPrice");
+		const minPrice = new bignumber_js.default(args.minPrice);
+		const maxPrice = new bignumber_js.default(args.maxPrice);
+		if (!minPrice.isFinite() || !maxPrice.isFinite() || minPrice.isLessThanOrEqualTo(0) || maxPrice.isLessThanOrEqualTo(0)) throw new GSwapSDKError("Price bounds must be finite and positive.", "VALIDATION_ERROR");
+		if (minPrice.isGreaterThan(maxPrice)) throw new GSwapSDKError("minPrice must be less than or equal to maxPrice.", "VALIDATION_ERROR");
+		const spacing = this.tickSpacing(args.fee);
+		const tickLower = alignTickDown(tickFromPrice(minPrice), spacing);
+		const tickUpper = alignTickUp(tickFromPrice(maxPrice), spacing);
+		return this.addLiquidityByTicks({
+			token0: args.token0,
+			token1: args.token1,
+			fee: args.fee,
+			tickLower,
+			tickUpper,
+			amount: args.amount,
+			amountIsToken0: args.amountIsToken0
+		});
+	}
+	/**
+	* Removes liquidity by withdrawing at most one canonical token quantity.
+	* Omitting both amounts closes the position and sweeps all accrued fees.
+	*
+	* @param args - Pair, fee, range, and optional caller-side withdrawal amount.
+	* @returns The synchronously submitted transaction.
+	* @example
+	* ```typescript
+	* const tx = await gSwap.positions.removeLiquidity({
+	*   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+	*   tickLower: -19200, tickUpper: 12000,
+	* });
+	* ```
+	*/
+	async removeLiquidity(args) {
+		validateFee(args.fee);
+		const pair = await this.symbols.orderPair(args.token0, args.token1);
+		const ticks = this.canonicalTicks(args.tickLower, args.tickUpper, pair.flipped);
+		assertTickRange(ticks.tickLower, ticks.tickUpper, args.fee);
+		if (args.amount0 !== void 0 && args.amount1 !== void 0) throw new GSwapSDKError("Provide at most one of amount0 or amount1.", "VALIDATION_ERROR");
+		if (args.amount0 !== void 0) validateNumericAmount(args.amount0, "amount0");
+		if (args.amount1 !== void 0) validateNumericAmount(args.amount1, "amount1");
+		const withdrawal = args.amount0 !== void 0 ? pair.flipped ? { withdrawalQuantityToken1: new bignumber_js.default(args.amount0).toFixed() } : { withdrawalQuantityToken0: new bignumber_js.default(args.amount0).toFixed() } : args.amount1 !== void 0 ? pair.flipped ? { withdrawalQuantityToken0: new bignumber_js.default(args.amount1).toFixed() } : { withdrawalQuantityToken1: new bignumber_js.default(args.amount1).toFixed() } : {};
+		const dto = {
+			token0: pair.token0.symbol,
+			token1: pair.token1.symbol,
+			fee: args.fee,
+			tickLower: ticks.tickLower,
+			tickUpper: ticks.tickUpper,
+			uniqueKey: this.uniqueKey(),
+			...withdrawal
+		};
+		const isFullClose = args.amount0 === void 0 && args.amount1 === void 0;
+		return this.submit("RemoveLiquidity", dto, {
+			kind: isFullClose ? "removeFull" : "removePartial",
+			identity: {
+				token0: pair.token0.symbol,
+				token1: pair.token1.symbol,
+				fee: args.fee,
+				tickLower: ticks.tickLower,
+				tickUpper: ticks.tickUpper
+			}
+		});
+	}
+	/**
+	* Collects all accrued fees for a position; the contract does not support partial collection.
+	*
+	* @param args - Pair, fee, and tick range identifying the position.
+	* @returns The synchronously submitted transaction.
+	* @example
+	* ```typescript
+	* const tx = await gSwap.positions.collectPositionFees({
+	*   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+	*   tickLower: -19200, tickUpper: 12000,
+	* });
+	* ```
+	*/
+	async collectPositionFees(args) {
+		validateFee(args.fee);
+		const pair = await this.symbols.orderPair(args.token0, args.token1);
+		const ticks = this.canonicalTicks(args.tickLower, args.tickUpper, pair.flipped);
+		assertTickRange(ticks.tickLower, ticks.tickUpper, args.fee);
+		const dto = {
+			token0: pair.token0.symbol,
+			token1: pair.token1.symbol,
+			fee: args.fee,
+			tickLower: ticks.tickLower,
+			tickUpper: ticks.tickUpper,
+			uniqueKey: this.uniqueKey()
+		};
+		return this.submit("CollectPositionFees", dto, {
+			kind: "collect",
+			identity: {
+				token0: pair.token0.symbol,
+				token1: pair.token1.symbol,
+				fee: args.fee,
+				tickLower: ticks.tickLower,
+				tickUpper: ticks.tickUpper
+			}
+		});
+	}
+	/**
+	* Creates a pool, resolving registered trading symbols.
+	* Reversed symbol order inverts the supplied starting price or square-root price.
+	*
+	* A token class key carries no symbol, so for a token being proposed into the v2
+	* trading-symbol registry for the first time (no existing pool has registered it yet) the
+	* caller MUST pass `token0Symbol`/`token1Symbol` (the token class's symbol, from the token
+	* list or FetchTokenClasses). The SDK never derives a symbol from the key, and throws a
+	* VALIDATION_ERROR when an unregistered token has none. For an already-registered token a
+	* supplied symbol must match the registered one.
+	*
+	* @param args - Token class keys or references, fee, exactly one starting price field, and privacy options.
+	* @returns The synchronously submitted transaction.
+	* @example
+	* ```typescript
+	* const tx = await gSwap.positions.createPool({
+	*   token0: 'GALA|Unit|none|none', token1: 'GUSDC|Unit|none|none', fee: 3000,
+	*   startingPrice: '0.15',
+	* });
+	* ```
+	*/
+	async createPool(args) {
+		var _this$symbols$invalid, _this$symbols;
+		const hasPrice = args.startingPrice !== void 0;
+		if (hasPrice === (args.startingSqrtPrice !== void 0)) throw new GSwapSDKError("Provide exactly one of startingPrice or startingSqrtPrice.", "VALIDATION_ERROR");
+		validateFee(args.fee);
+		const [tokenA, tokenB] = await Promise.all([this.resolveCreateToken(args.token0, args.token0Symbol), this.resolveCreateToken(args.token1, args.token1Symbol)]);
+		const flipped = tokenA.symbol > tokenB.symbol;
+		const [token0, token1] = flipped ? [tokenB, tokenA] : [tokenA, tokenB];
+		const sourcePriceInput = hasPrice ? args.startingPrice : args.startingSqrtPrice;
+		this.rejectNumber(sourcePriceInput, hasPrice ? "startingPrice" : "startingSqrtPrice");
+		const sourcePrice = new bignumber_js.default(sourcePriceInput);
+		if (!sourcePrice.isFinite() || sourcePrice.isLessThanOrEqualTo(0)) throw new GSwapSDKError("Starting price must be finite and positive.", "VALIDATION_ERROR");
+		const canonicalPrice = flipped ? new bignumber_js.default(1).dividedBy(sourcePrice) : sourcePrice;
+		const dto = {
+			token0Key: token0.classKey,
+			token1Key: token1.classKey,
+			token0Symbol: token0.symbol,
+			token1Symbol: token1.symbol,
+			fee: args.fee,
+			uniqueKey: this.uniqueKey(),
+			...hasPrice ? { startingPrice: canonicalPrice.toFixed() } : { startingSqrtPrice: canonicalPrice.toFixed() },
+			...args.isPrivate === void 0 ? {} : { isPrivate: args.isPrivate },
+			...args.privateAccess === void 0 ? {} : { privateAccess: args.privateAccess }
+		};
+		const transaction = await this.submit("CreatePool", dto, {
+			kind: "createPool",
+			token0: token0.symbol,
+			token1: token1.symbol,
+			fee: args.fee
+		});
+		(_this$symbols$invalid = (_this$symbols = this.symbols).invalidate) === null || _this$symbols$invalid === void 0 || _this$symbols$invalid.call(_this$symbols);
+		return transaction;
+	}
+	async submit(method, dto, confirmation) {
+		if (this.signer === void 0) throw GSwapSDKError.noSignerError();
+		const signed = await this.signer.signObject(method, dto);
+		const submitOptions = this.walletAddress === void 0 ? {} : { walletAddress: this.walletAddress };
+		const owner = this.walletAddress;
+		const positionConfirmation = this.buildPositionConfirmation(confirmation, owner);
+		const options = {
+			...submitOptions,
+			...positionConfirmation === void 0 ? {} : { positionConfirmation }
+		};
+		return this.gateway.submit(method, signed, options);
+	}
+	/**
+	* Builds a confirmation closure that proves the write's own effect, not just that a
+	* position row exists (true before most of these writes run too, for any operation on a
+	* pre-existing position — existence alone would false-confirm before the write executes,
+	* and would never confirm a full close, whose whole point is that the position stops
+	* existing).
+	*
+	* The "before" state is captured lazily, on the confirmation closure's own first poll —
+	* not eagerly here in `submit()` — so confirming a write never adds an extra round-trip to
+	* the write itself; the cost of establishing the baseline is paid by `confirm()`, only if
+	* and when the caller actually asks to confirm.
+	*/
+	buildPositionConfirmation(confirmation, owner) {
+		if (confirmation === void 0) return void 0;
+		if (confirmation.kind === "createPool") {
+			const { token0, token1, fee } = confirmation;
+			return async (signal) => {
+				return await this.getNullable("/pool", {
+					token0,
+					token1,
+					fee: `${fee}`
+				}, signal) === null ? { confirmed: false } : {
+					confirmed: true,
+					position: null
+				};
+			};
+		}
+		if (owner === void 0) return void 0;
+		const { kind, identity } = confirmation;
+		let baseline;
+		return async (signal) => {
+			const current = await this.getPosition({
+				...identity,
+				owner
+			}, signal);
+			if (baseline === void 0) {
+				baseline = {
+					liquidity: new bignumber_js.default((current === null || current === void 0 ? void 0 : current.liquidity) ?? 0),
+					fees: new bignumber_js.default((current === null || current === void 0 ? void 0 : current.fees0) ?? 0).plus(new bignumber_js.default((current === null || current === void 0 ? void 0 : current.fees1) ?? 0))
+				};
+				return kind === "removeFull" && current === null ? {
+					confirmed: true,
+					position: null
+				} : { confirmed: false };
+			}
+			switch (kind) {
+				case "add": return current !== null && new bignumber_js.default(current.liquidity).isGreaterThan(baseline.liquidity) ? {
+					confirmed: true,
+					position: current
+				} : { confirmed: false };
+				case "removePartial": return current !== null && new bignumber_js.default(current.liquidity).isLessThan(baseline.liquidity) ? {
+					confirmed: true,
+					position: current
+				} : { confirmed: false };
+				case "removeFull": return current === null ? {
+					confirmed: true,
+					position: null
+				} : { confirmed: false };
+				case "collect": {
+					if (current === null) return { confirmed: false };
+					const currentFees = new bignumber_js.default(current.fees0 ?? 0).plus(new bignumber_js.default(current.fees1 ?? 0));
+					if (currentFees.isLessThan(baseline.fees)) return {
+						confirmed: true,
+						position: current
+					};
+					if (baseline.fees.isZero() && currentFees.isZero()) return {
+						confirmed: true,
+						position: current
+					};
+					return { confirmed: false };
+				}
+			}
+		};
+	}
+	async get(endpoint, params, signal) {
+		return this.http.sendGetRequest(this.gateway.dexBackendBaseUrl, "/v2/trade", endpoint, params, signal === void 0 ? void 0 : { signal });
+	}
+	async getNullable(endpoint, params, signal) {
+		try {
+			return await this.get(endpoint, params, signal);
+		} catch (error) {
+			if (this.isNotFound(error)) return null;
+			throw error;
+		}
+	}
+	isNotFound(error) {
+		if (!(error instanceof GSwapSDKError) || error.details === void 0) return false;
+		return error.details["status"] === 404;
+	}
+	mapPosition(position) {
+		return {
+			token0Symbol: position.token0Symbol,
+			token1Symbol: position.token1Symbol,
+			...position.token0CompositeKey === void 0 ? {} : { token0CompositeKey: position.token0CompositeKey },
+			...position.token1CompositeKey === void 0 ? {} : { token1CompositeKey: position.token1CompositeKey },
+			fee: position.fee,
+			tickLower: position.tickLower,
+			tickUpper: position.tickUpper,
+			liquidity: position.liquidity,
+			amount0: position.amount0,
+			amount1: position.amount1,
+			inRange: position.inRange,
+			...position.currentTick === void 0 ? {} : { currentTick: position.currentTick },
+			...position.sqrtPrice === void 0 ? {} : { sqrtPrice: position.sqrtPrice },
+			pool: position.poolRef ?? position.pool ?? "",
+			owner: position.owner,
+			...position.fees0 === void 0 ? {} : { fees0: position.fees0 },
+			...position.fees1 === void 0 ? {} : { fees1: position.fees1 }
+		};
+	}
+	requestToken(ref) {
+		return typeof ref === "string" ? ref : compositeKeyOf(ref);
+	}
+	canonicalTicks(tickLower, tickUpper, flipped) {
+		return flipped ? {
+			tickLower: -tickUpper,
+			tickUpper: -tickLower
+		} : {
+			tickLower,
+			tickUpper
+		};
+	}
+	tickSpacing(fee) {
+		const spacing = TICK_SPACING_BY_FEE[fee];
+		if (spacing === void 0) throw new GSwapSDKError(`Unsupported fee tier: ${fee}.`, "VALIDATION_ERROR");
+		return spacing;
+	}
+	rejectNumber(value, parameterName) {
+		if (typeof value === "number") throw new GSwapSDKError(`Invalid ${parameterName}: use a decimal string or BigNumber, not a JavaScript number`, "VALIDATION_ERROR");
+	}
+	uniqueKey() {
+		return `gswap-sdk-${globalThis.crypto.randomUUID()}`;
+	}
+	async resolveCreateToken(ref, symbolOverride) {
+		try {
+			const lookupRef = typeof ref === "object" ? compositeKeyOf(ref) : ref;
+			const resolved = await this.symbols.resolve(lookupRef);
+			if (symbolOverride !== void 0 && symbolOverride !== "" && symbolOverride !== resolved.symbol) throw new GSwapSDKError(`Supplied symbol ${symbolOverride} disagrees with the registered trading symbol ${resolved.symbol}.`, "VALIDATION_ERROR", {
+				token: ref,
+				suppliedSymbol: symbolOverride,
+				registeredSymbol: resolved.symbol
+			});
+			const suppliedClassKey = this.tryParseClassKey(ref);
+			return {
+				symbol: resolved.symbol,
+				classKey: suppliedClassKey ?? parseTokenClassKey({
+					collection: resolved.collection,
+					category: resolved.category,
+					type: resolved.type,
+					additionalKey: resolved.additionalKey
+				})
+			};
+		} catch (error) {
+			if (!(error instanceof GSwapSDKError) || error.code !== "UNKNOWN_TOKEN") throw error;
+			let classKey;
+			try {
+				classKey = parseTokenClassKey(ref);
+			} catch {
+				throw error;
+			}
+			if (symbolOverride === void 0 || symbolOverride === "") throw new GSwapSDKError("Token is not registered in the trading-symbol registry yet; pass token0Symbol/token1Symbol (the token class symbol) to propose one. A symbol cannot be derived from a class key.", "VALIDATION_ERROR", { token: ref });
+			if (!/^[A-Za-z0-9]+$/u.test(symbolOverride)) throw new GSwapSDKError("Invalid trading symbol: must be ASCII letters and digits only.", "VALIDATION_ERROR", { symbol: symbolOverride });
+			return {
+				symbol: symbolOverride,
+				classKey
+			};
+		}
+	}
+	tryParseClassKey(ref) {
+		try {
+			return parseTokenClassKey(ref);
+		} catch {
+			return;
+		}
+	}
 };
 
-// src/classes/quoting.ts
-var import_bignumber4 = __toESM(require("bignumber.js"), 1);
+//#endregion
+//#region src/classes/quoting.ts
+/** Read-only quote service backed by the v2 offline quote engine. */
 var Quoting = class {
-  /**
-   * Creates a quote service.
-   *
-   * @example
-   * ```ts
-   * const quoting = new Quoting('https://swap-backend.stage.defi.ovh.gala.com', http, symbols);
-   * ```
-   */
-  constructor(dexBackendBaseUrl, http, symbols) {
-    this.dexBackendBaseUrl = dexBackendBaseUrl;
-    this.http = http;
-    this.symbols = symbols;
-  }
-  dexBackendBaseUrl;
-  http;
-  symbols;
-  /**
-   * Quotes the output for a positive exact-input amount.
-   *
-   * @example
-   * ```ts
-   * const quote = await quoting.quoteExactInput('GALA', 'GUSDC', '100');
-   * console.log(quote.amountOut);
-   * ```
-   */
-  async quoteExactInput(tokenIn, tokenOut, amountIn, fee) {
-    validateNumericAmount(amountIn, "amountIn");
-    return this.quote(tokenIn, tokenOut, { amountIn: toDecimalString(amountIn) }, fee);
-  }
-  /**
-   * Quotes the input for a positive exact-output amount.
-   *
-   * @example
-   * ```ts
-   * const quote = await quoting.quoteExactOutput('GALA', 'GUSDC', '10', 3000);
-   * console.log(quote.amountIn);
-   * ```
-   */
-  async quoteExactOutput(tokenIn, tokenOut, amountOut, fee) {
-    validateNumericAmount(amountOut, "amountOut");
-    return this.quote(tokenIn, tokenOut, { amountOut: toDecimalString(amountOut) }, fee);
-  }
-  async quote(tokenIn, tokenOut, amount, fee) {
-    validateOptionalFee(fee);
-    const tokenInSymbol = await resolveSymbol2(this.symbols, tokenIn);
-    const tokenOutSymbol = await resolveSymbol2(this.symbols, tokenOut);
-    const params = {
-      tokenIn: tokenInSymbol,
-      tokenOut: tokenOutSymbol,
-      ...amount
-    };
-    if (fee !== void 0) params["fee"] = String(fee);
-    try {
-      const response = await this.http.sendGetRequest(
-        this.dexBackendBaseUrl,
-        "/v2/trade",
-        "/quote",
-        params
-      );
-      return mapQuote(response.data);
-    } catch (error) {
-      throw mapQuoteError(error, tokenIn, tokenOut, fee);
-    }
-  }
+	dexBackendBaseUrl;
+	http;
+	symbols;
+	/**
+	* Creates a quote service.
+	*
+	* @example
+	* ```ts
+	* const quoting = new Quoting('https://swap-backend.stage.defi.ovh.gala.com', http, symbols);
+	* ```
+	*/
+	constructor(dexBackendBaseUrl, http, symbols) {
+		this.dexBackendBaseUrl = dexBackendBaseUrl;
+		this.http = http;
+		this.symbols = symbols;
+	}
+	/**
+	* Quotes the output for a positive exact-input amount.
+	*
+	* @example
+	* ```ts
+	* const quote = await quoting.quoteExactInput('GALA', 'GUSDC', '100');
+	* console.log(quote.amountOut);
+	* ```
+	*/
+	async quoteExactInput(tokenIn, tokenOut, amountIn, fee) {
+		validateNumericAmount(amountIn, "amountIn");
+		return this.quote(tokenIn, tokenOut, { amountIn: toDecimalString$1(amountIn) }, fee);
+	}
+	/**
+	* Quotes the input for a positive exact-output amount.
+	*
+	* @example
+	* ```ts
+	* const quote = await quoting.quoteExactOutput('GALA', 'GUSDC', '10', 3000);
+	* console.log(quote.amountIn);
+	* ```
+	*/
+	async quoteExactOutput(tokenIn, tokenOut, amountOut, fee) {
+		validateNumericAmount(amountOut, "amountOut");
+		return this.quote(tokenIn, tokenOut, { amountOut: toDecimalString$1(amountOut) }, fee);
+	}
+	async quote(tokenIn, tokenOut, amount, fee) {
+		validateOptionalFee(fee);
+		const params = {
+			tokenIn: await resolveSymbol$1(this.symbols, tokenIn),
+			tokenOut: await resolveSymbol$1(this.symbols, tokenOut),
+			...amount
+		};
+		if (fee !== void 0) params["fee"] = String(fee);
+		try {
+			return mapQuote((await this.http.sendGetRequest(this.dexBackendBaseUrl, "/v2/trade", "/quote", params)).data);
+		} catch (error) {
+			throw mapQuoteError(error, tokenIn, tokenOut, fee);
+		}
+	}
 };
 function mapQuote(value) {
-  if (!isQuoteWire(value)) {
-    throw new GSwapSDKError("Backend returned an invalid quote.", "INVALID_CHAIN_RESPONSE", {
-      data: value
-    });
-  }
-  const wire = value;
-  const currentPrice = wire.currentPrice !== void 0 ? new import_bignumber4.default(wire.currentPrice) : orientPrice(wire.currentSqrtPrice, wire.tokenInIsToken0);
-  const newPrice = wire.newPrice !== void 0 ? new import_bignumber4.default(wire.newPrice) : orientPrice(wire.newSqrtPrice, wire.tokenInIsToken0);
-  const priceImpact = newPrice.minus(currentPrice).dividedBy(currentPrice);
-  return {
-    contractVersion: wire.contractVersion,
-    fee: wire.fee,
-    amountIn: wire.amountIn,
-    amountOut: wire.amountOut,
-    ...wire.currentSqrtPrice === void 0 ? {} : { currentSqrtPrice: wire.currentSqrtPrice },
-    ...wire.newSqrtPrice === void 0 ? {} : { newSqrtPrice: wire.newSqrtPrice },
-    feeTier: wire.fee,
-    newTick: wire.newTick,
-    tradingFees: wire.tradingFees,
-    protocolFees: wire.protocolFees,
-    totalFees: wire.totalFees,
-    feeTokenSymbol: wire.feeTokenSymbol,
-    token0Symbol: wire.token0Symbol,
-    token1Symbol: wire.token1Symbol,
-    tokenInIsToken0: wire.tokenInIsToken0,
-    currentPrice,
-    newPrice,
-    priceImpact
-  };
-}
-var HighPrecision = import_bignumber4.default.clone({ DECIMAL_PLACES: 60 });
+	if (!isQuoteWire(value)) throw new GSwapSDKError("Backend returned an invalid quote.", "INVALID_CHAIN_RESPONSE", { data: value });
+	const wire = value;
+	const currentPrice = wire.currentPrice !== void 0 ? new bignumber_js.default(wire.currentPrice) : orientPrice(wire.currentSqrtPrice, wire.tokenInIsToken0);
+	const newPrice = wire.newPrice !== void 0 ? new bignumber_js.default(wire.newPrice) : orientPrice(wire.newSqrtPrice, wire.tokenInIsToken0);
+	const priceImpact = newPrice.minus(currentPrice).dividedBy(currentPrice);
+	return {
+		contractVersion: wire.contractVersion,
+		fee: wire.fee,
+		amountIn: wire.amountIn,
+		amountOut: wire.amountOut,
+		...wire.currentSqrtPrice === void 0 ? {} : { currentSqrtPrice: wire.currentSqrtPrice },
+		...wire.newSqrtPrice === void 0 ? {} : { newSqrtPrice: wire.newSqrtPrice },
+		feeTier: wire.fee,
+		newTick: wire.newTick,
+		tradingFees: wire.tradingFees,
+		protocolFees: wire.protocolFees,
+		totalFees: wire.totalFees,
+		feeTokenSymbol: wire.feeTokenSymbol,
+		token0Symbol: wire.token0Symbol,
+		token1Symbol: wire.token1Symbol,
+		tokenInIsToken0: wire.tokenInIsToken0,
+		currentPrice,
+		newPrice,
+		priceImpact
+	};
+}
+const HighPrecision = bignumber_js.default.clone({ DECIMAL_PLACES: 60 });
 function orientPrice(sqrtPrice, tokenInIsToken0) {
-  const poolPrice = new HighPrecision(sqrtPrice).pow(2);
-  return tokenInIsToken0 ? poolPrice : new HighPrecision(1).dividedBy(poolPrice);
+	const poolPrice = new HighPrecision(sqrtPrice).pow(2);
+	return tokenInIsToken0 ? poolPrice : new HighPrecision(1).dividedBy(poolPrice);
 }
 function isQuoteWire(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const wire = value;
-  const requiredStrings = [
-    "amountIn",
-    "amountOut",
-    "tradingFees",
-    "protocolFees",
-    "totalFees",
-    "feeTokenSymbol",
-    "token0Symbol",
-    "token1Symbol"
-  ];
-  return wire["contractVersion"] === "v2" && typeof wire["fee"] === "number" && Number.isFinite(wire["fee"]) && requiredStrings.every((key) => typeof wire[key] === "string") && typeof wire["newTick"] === "number" && Number.isInteger(wire["newTick"]) && typeof wire["tokenInIsToken0"] === "boolean" && optionalPositiveDecimal(wire["currentSqrtPrice"]) && optionalPositiveDecimal(wire["newSqrtPrice"]) && optionalPositiveDecimal(wire["currentPrice"]) && optionalPositiveDecimal(wire["newPrice"]) && (wire["currentSqrtPrice"] !== void 0 || wire["currentPrice"] !== void 0) && (wire["newSqrtPrice"] !== void 0 || wire["newPrice"] !== void 0);
+	if (typeof value !== "object" || value === null) return false;
+	const wire = value;
+	return wire["contractVersion"] === "v2" && typeof wire["fee"] === "number" && Number.isFinite(wire["fee"]) && [
+		"amountIn",
+		"amountOut",
+		"tradingFees",
+		"protocolFees",
+		"totalFees",
+		"feeTokenSymbol",
+		"token0Symbol",
+		"token1Symbol"
+	].every((key) => typeof wire[key] === "string") && typeof wire["newTick"] === "number" && Number.isInteger(wire["newTick"]) && typeof wire["tokenInIsToken0"] === "boolean" && optionalPositiveDecimal(wire["currentSqrtPrice"]) && optionalPositiveDecimal(wire["newSqrtPrice"]) && optionalPositiveDecimal(wire["currentPrice"]) && optionalPositiveDecimal(wire["newPrice"]) && (wire["currentSqrtPrice"] !== void 0 || wire["currentPrice"] !== void 0) && (wire["newSqrtPrice"] !== void 0 || wire["newPrice"] !== void 0);
 }
 function optionalPositiveDecimal(value) {
-  if (value === void 0) return true;
-  if (typeof value !== "string") return false;
-  try {
-    const decimal = new import_bignumber4.default(value);
-    return decimal.isFinite() && decimal.isGreaterThan(0);
-  } catch {
-    return false;
-  }
+	if (value === void 0) return true;
+	if (typeof value !== "string") return false;
+	try {
+		const decimal = new bignumber_js.default(value);
+		return decimal.isFinite() && decimal.isGreaterThan(0);
+	} catch {
+		return false;
+	}
 }
 function mapQuoteError(error, tokenIn, tokenOut, fee) {
-  if (error instanceof GSwapSDKError) {
-    const status = readStatus(error.details);
-    const message = readMessage(error.details) ?? error.message;
-    if (status === 404 || /no pool|no pools|pool does not exist/iu.test(message)) {
-      return GSwapSDKError.noPoolAvailableError(tokenIn, tokenOut, fee);
-    }
-    if (status === 400 && /insufficient liquidity/iu.test(message)) {
-      return GSwapSDKError.insufficientLiquidityError(tokenIn, tokenOut, fee);
-    }
-    return error;
-  }
-  return new GSwapSDKError("Quote request failed.", "HTTP_ERROR", {
-    cause: error,
-    tokenIn,
-    tokenOut,
-    fee
-  });
+	if (error instanceof GSwapSDKError) {
+		const status = readStatus(error.details);
+		const message = readMessage(error.details) ?? error.message;
+		if (status === 404 || /no pool|no pools|pool does not exist/iu.test(message)) return GSwapSDKError.noPoolAvailableError(tokenIn, tokenOut, fee);
+		if (status === 400 && /insufficient liquidity/iu.test(message)) return GSwapSDKError.insufficientLiquidityError(tokenIn, tokenOut, fee);
+		return error;
+	}
+	return new GSwapSDKError("Quote request failed.", "HTTP_ERROR", {
+		cause: error,
+		tokenIn,
+		tokenOut,
+		fee
+	});
 }
 function readStatus(details) {
-  const status = details == null ? void 0 : details["status"];
-  return typeof status === "number" ? status : void 0;
+	const status = details === null || details === void 0 ? void 0 : details["status"];
+	return typeof status === "number" ? status : void 0;
 }
 function readMessage(details) {
-  const direct = details == null ? void 0 : details["message"];
-  if (typeof direct === "string") return direct;
-  const body = details == null ? void 0 : details["body"];
-  if (typeof body !== "object" || body === null || Array.isArray(body)) return void 0;
-  const message = body["message"];
-  return typeof message === "string" ? message : void 0;
+	const direct = details === null || details === void 0 ? void 0 : details["message"];
+	if (typeof direct === "string") return direct;
+	const body = details === null || details === void 0 ? void 0 : details["body"];
+	if (typeof body !== "object" || body === null || Array.isArray(body)) return void 0;
+	const message = body["message"];
+	return typeof message === "string" ? message : void 0;
 }
 function validateOptionalFee(fee) {
-  if (fee !== void 0 && !ALL_FEE_TIERS.some((tier) => Number(tier) === Number(fee))) {
-    throw new GSwapSDKError(`Invalid fee tier: ${fee}`, "VALIDATION_ERROR", { fee });
-  }
+	if (fee !== void 0 && !ALL_FEE_TIERS.some((tier) => Number(tier) === Number(fee))) throw new GSwapSDKError(`Invalid fee tier: ${fee}`, "VALIDATION_ERROR", { fee });
 }
-function toDecimalString(amount) {
-  return new import_bignumber4.default(amount).toFixed();
+function toDecimalString$1(amount) {
+	return new bignumber_js.default(amount).toFixed();
 }
-async function resolveSymbol2(symbols, token) {
-  const resolved = await symbols.resolve(token);
-  if (resolved.symbol.length > 0) return resolved.symbol;
-  throw new GSwapSDKError("Token could not be resolved to a trading symbol.", "SYMBOL_NOT_FOUND", {
-    token
-  });
+async function resolveSymbol$1(symbols, token) {
+	const resolved = await symbols.resolve(token);
+	if (resolved.symbol.length > 0) return resolved.symbol;
+	throw new GSwapSDKError("Token could not be resolved to a trading symbol.", "SYMBOL_NOT_FOUND", { token });
 }
 
-// src/classes/symbols.ts
-var SYMBOL_CACHE_TTL_MS = 6e4;
+//#endregion
+//#region src/classes/symbols.ts
+const SYMBOL_CACHE_TTL_MS = 6e4;
+/** Symbol registry client for the current GalaChainDex contract. */
 var Symbols = class {
-  /** Create a symbol service backed by the swap backend. */
-  constructor(gateway) {
-    this.gateway = gateway;
-    this.http = new HttpClient(gateway.httpRequestor, gateway.requestTimeoutMs);
-  }
-  gateway;
-  cachedSymbols;
-  cachedAt = 0;
-  refreshInFlight;
-  http;
-  /** List all registered GalaChainDex trading symbols, cached for 60 seconds. */
-  async list() {
-    if (this.cachedSymbols !== void 0 && Date.now() - this.cachedAt < SYMBOL_CACHE_TTL_MS) {
-      return this.cachedSymbols;
-    }
-    if (this.refreshInFlight !== void 0) return this.refreshInFlight;
-    this.refreshInFlight = this.http.sendGetRequest(this.gateway.dexBackendBaseUrl, "/v2/trade", "/symbols").then((response) => parseSymbols(response.data)).then((symbols) => {
-      this.cachedSymbols = symbols;
-      this.cachedAt = Date.now();
-      return symbols;
-    }).finally(() => {
-      this.refreshInFlight = void 0;
-    });
-    return this.refreshInFlight;
-  }
-  /** Invalidate the cached symbol registry after a write changes registration state.
-   *
-   * @example
-   * ```ts
-   * gSwap.symbols.invalidate();
-   * ```
-   */
-  invalidate() {
-    this.cachedSymbols = void 0;
-    this.cachedAt = 0;
-  }
-  /** Force one registry refresh, bypassing the cache.
-   *
-   * @example
-   * ```ts
-   * const symbols = await gSwap.symbols.refresh();
-   * ```
-   */
-  async refresh() {
-    this.invalidate();
-    this.refreshInFlight = void 0;
-    return this.list();
-  }
-  /** Resolve a symbol or token class key to its registered symbol metadata. */
-  async resolve(ref) {
-    let symbols = await this.list();
-    const composite = typeof ref === "string" ? isCompositeKey(ref) ? compositeKeyOf(parseTokenClassKey(ref)) : void 0 : compositeKeyOf(ref);
-    const resolved = symbols.find(
-      (entry) => entry.symbol === ref || composite !== void 0 && compositeKeyOf(entry) === composite
-    );
-    if (resolved === void 0) {
-      symbols = await this.refresh();
-      const refreshed = symbols.find(
-        (entry) => entry.symbol === ref || composite !== void 0 && compositeKeyOf(entry) === composite
-      );
-      if (refreshed === void 0) throw GSwapSDKError.unknownTokenError(ref);
-      return refreshed;
-    }
-    return resolved;
-  }
-  /** Resolve and put two token references in canonical trading-symbol order. */
-  async orderPair(a, b) {
-    const [resolvedA, resolvedB] = await Promise.all([this.resolve(a), this.resolve(b)]);
-    const [token0Symbol, token1Symbol] = orderSymbols(resolvedA.symbol, resolvedB.symbol);
-    return {
-      token0: token0Symbol === resolvedA.symbol ? resolvedA : resolvedB,
-      token1: token1Symbol === resolvedB.symbol ? resolvedB : resolvedA,
-      flipped: token0Symbol !== resolvedA.symbol
-    };
-  }
+	gateway;
+	cachedSymbols;
+	cachedAt = 0;
+	refreshInFlight;
+	http;
+	/** Create a symbol service backed by the swap backend. */
+	constructor(gateway) {
+		this.gateway = gateway;
+		this.http = new HttpClient(gateway.httpRequestor, gateway.requestTimeoutMs);
+	}
+	/** List all registered GalaChainDex trading symbols, cached for 60 seconds. */
+	async list() {
+		if (this.cachedSymbols !== void 0 && Date.now() - this.cachedAt < SYMBOL_CACHE_TTL_MS) return this.cachedSymbols;
+		if (this.refreshInFlight !== void 0) return this.refreshInFlight;
+		this.refreshInFlight = this.http.sendGetRequest(this.gateway.dexBackendBaseUrl, "/v2/trade", "/symbols").then((response) => parseSymbols(response.data)).then((symbols) => {
+			this.cachedSymbols = symbols;
+			this.cachedAt = Date.now();
+			return symbols;
+		}).finally(() => {
+			this.refreshInFlight = void 0;
+		});
+		return this.refreshInFlight;
+	}
+	/** Invalidate the cached symbol registry after a write changes registration state.
+	*
+	* @example
+	* ```ts
+	* gSwap.symbols.invalidate();
+	* ```
+	*/
+	invalidate() {
+		this.cachedSymbols = void 0;
+		this.cachedAt = 0;
+	}
+	/** Force one registry refresh, bypassing the cache.
+	*
+	* @example
+	* ```ts
+	* const symbols = await gSwap.symbols.refresh();
+	* ```
+	*/
+	async refresh() {
+		this.invalidate();
+		this.refreshInFlight = void 0;
+		return this.list();
+	}
+	/** Resolve a symbol or token class key to its registered symbol metadata. */
+	async resolve(ref) {
+		let symbols = await this.list();
+		const composite = typeof ref === "string" ? isCompositeKey(ref) ? compositeKeyOf(parseTokenClassKey(ref)) : void 0 : compositeKeyOf(ref);
+		const resolved = symbols.find((entry) => entry.symbol === ref || composite !== void 0 && compositeKeyOf(entry) === composite);
+		if (resolved === void 0) {
+			symbols = await this.refresh();
+			const refreshed = symbols.find((entry) => entry.symbol === ref || composite !== void 0 && compositeKeyOf(entry) === composite);
+			if (refreshed === void 0) throw GSwapSDKError.unknownTokenError(ref);
+			return refreshed;
+		}
+		return resolved;
+	}
+	/** Resolve and put two token references in canonical trading-symbol order. */
+	async orderPair(a, b) {
+		const [resolvedA, resolvedB] = await Promise.all([this.resolve(a), this.resolve(b)]);
+		const [token0Symbol, token1Symbol] = orderSymbols(resolvedA.symbol, resolvedB.symbol);
+		return {
+			token0: token0Symbol === resolvedA.symbol ? resolvedA : resolvedB,
+			token1: token1Symbol === resolvedB.symbol ? resolvedB : resolvedA,
+			flipped: token0Symbol !== resolvedA.symbol
+		};
+	}
 };
 function parseSymbols(value) {
-  if (!Array.isArray(value) || !value.every(isTradingSymbol)) {
-    throw new GSwapSDKError("Backend returned an invalid symbol list.", "INVALID_CHAIN_RESPONSE", {
-      data: value
-    });
-  }
-  return value;
+	if (!Array.isArray(value) || !value.every(isTradingSymbol)) throw new GSwapSDKError("Backend returned an invalid symbol list.", "INVALID_CHAIN_RESPONSE", { data: value });
+	return value;
 }
 function isTradingSymbol(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const entry = value;
-  return typeof entry["symbol"] === "string" && typeof entry["collection"] === "string" && typeof entry["category"] === "string" && typeof entry["type"] === "string" && typeof entry["additionalKey"] === "string" && typeof entry["decimals"] === "number" && Number.isInteger(entry["decimals"]) && entry["decimals"] >= 0;
+	if (typeof value !== "object" || value === null) return false;
+	const entry = value;
+	return typeof entry["symbol"] === "string" && typeof entry["collection"] === "string" && typeof entry["category"] === "string" && typeof entry["type"] === "string" && typeof entry["additionalKey"] === "string" && typeof entry["decimals"] === "number" && Number.isInteger(entry["decimals"]) && entry["decimals"] >= 0;
 }
 function isCompositeKey(ref) {
-  return ref.includes("|") || ref.includes("$");
+	return ref.includes("|") || ref.includes("$");
 }
 
-// src/classes/swaps.ts
-var import_bignumber5 = __toESM(require("bignumber.js"), 1);
-var UNIQUE_KEY_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/u;
+//#endregion
+//#region src/classes/swaps.ts
+/** The swap backend's apply-results key constraint (`apply-results.dto.ts`). */
+const UNIQUE_KEY_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/u;
+/** Executes queued current-contract RequestTrade operations through the Chain Gateway. */
 var Swaps = class {
-  /**
-   * Creates a swap service.
-   *
-   * @example
-   * ```ts
-   * const swaps = new Swaps(gateway, symbols, signer, 'client|alice');
-   * ```
-   */
-  constructor(gateway, symbols, signer, walletAddress) {
-    this.gateway = gateway;
-    this.symbols = symbols;
-    this.signer = signer;
-    this.walletAddress = walletAddress;
-  }
-  gateway;
-  symbols;
-  signer;
-  walletAddress;
-  /**
-   * Signs and submits an exact-input or exact-output RequestTrade DTO. The returned transaction
-   * is QUEUED; call `await tx.confirm()` to obtain the executed trade or chain rejection.
-   *
-   * @example
-   * ```ts
-   * const submitted = await swaps.swap('GALA', 'GUSDC', 3000, {
-   *   exactIn: '100',
-   *   amountOutMinimum: '14',
-   * });
-   * ```
-   */
-  async swap(tokenIn, tokenOut, fee, amount) {
-    validateFee(fee);
-    const dto = await this.buildRequestTradeDto(tokenIn, tokenOut, fee, amount);
-    if (this.signer === void 0) throw GSwapSDKError.noSignerError();
-    const signedDto = await this.signer.signObject("RequestTrade", dto);
-    const submitOptions = this.walletAddress === void 0 ? {} : { walletAddress: this.walletAddress };
-    return this.gateway.submit("RequestTrade", signedDto, submitOptions);
-  }
-  /**
-   * Confirm a swap by its durable `uniqueKey` without resubmitting it. This is the recovery
-   * path after a `CONFIRMATION_TIMEOUT`, a `SUBMISSION_OUTCOME_UNKNOWN`, a `409` replay
-   * conflict, or a process restart: it reads the same apply-results record that
-   * `SubmittedTransaction.confirm()` reads (retained for 7 days) and resolves the applied trade
-   * or throws the chain's rejection. The first read happens immediately unless
-   * `initialDelayMs` is given.
-   *
-   * @example
-   * ```ts
-   * const applied = await swaps.confirmSwap('gswap-sdk-2f1c…');
-   * ```
-   */
-  async confirmSwap(uniqueKey, options) {
-    if (!UNIQUE_KEY_PATTERN.test(uniqueKey)) {
-      throw new GSwapSDKError(
-        'uniqueKey must be 1-128 characters of A-Z, a-z, 0-9, ".", "_", ":" or "-".',
-        "VALIDATION_ERROR",
-        { uniqueKey }
-      );
-    }
-    const transaction = new SubmittedTransaction({
-      method: "RequestTrade",
-      uniqueKey,
-      transactionId: null,
-      mode: "queued",
-      result: void 0,
-      dexBackendBaseUrl: this.gateway.dexBackendBaseUrl,
-      httpRequestor: this.gateway.httpRequestor,
-      requestTimeoutMs: this.gateway.requestTimeoutMs
-    });
-    return transaction.confirm({ initialDelayMs: 0, ...options });
-  }
-  async buildRequestTradeDto(tokenIn, tokenOut, fee, amount) {
-    const tokenInSymbol = await resolveSymbol3(this.symbols, tokenIn);
-    const tokenOutSymbol = await resolveSymbol3(this.symbols, tokenOut);
-    const ordered = readOrderedSymbols(orderSymbols(tokenInSymbol, tokenOutSymbol));
-    const tokenInIsToken0 = tokenInSymbol === ordered.token0;
-    const dto = {
-      token0: ordered.token0,
-      token1: ordered.token1,
-      fee,
-      uniqueKey: `gswap-sdk-${globalThis.crypto.randomUUID()}`
-    };
-    if ("exactIn" in amount) {
-      const exactIn = amount.exactIn;
-      if (exactIn === void 0) {
-        throw new GSwapSDKError("exactIn is required for an exact-input swap.", "VALIDATION_ERROR");
-      }
-      validateNumericAmount(exactIn, "exactIn");
-      dto[tokenInIsToken0 ? "sell0Qty" : "sell1Qty"] = toDecimalString2(exactIn);
-      if (amount.amountOutMinimum !== void 0) {
-        validateNumericAmount(amount.amountOutMinimum, "amountOutMinimum", true);
-        dto["amountOutMinimum"] = toDecimalString2(amount.amountOutMinimum);
-      }
-    } else {
-      const exactOut = amount.exactOut;
-      if (exactOut === void 0) {
-        throw new GSwapSDKError(
-          "exactOut is required for an exact-output swap.",
-          "VALIDATION_ERROR"
-        );
-      }
-      validateNumericAmount(exactOut, "exactOut");
-      dto[tokenInIsToken0 ? "buy1Qty" : "buy0Qty"] = toDecimalString2(exactOut);
-      if (amount.amountInMaximum !== void 0) {
-        validateNumericAmount(amount.amountInMaximum, "amountInMaximum", true);
-        dto["amountInMaximum"] = toDecimalString2(amount.amountInMaximum);
-      }
-    }
-    return dto;
-  }
+	gateway;
+	symbols;
+	signer;
+	walletAddress;
+	/**
+	* Creates a swap service.
+	*
+	* @example
+	* ```ts
+	* const swaps = new Swaps(gateway, symbols, signer, 'client|alice');
+	* ```
+	*/
+	constructor(gateway, symbols, signer, walletAddress) {
+		this.gateway = gateway;
+		this.symbols = symbols;
+		this.signer = signer;
+		this.walletAddress = walletAddress;
+	}
+	/**
+	* Signs and submits an exact-input or exact-output RequestTrade DTO. The returned transaction
+	* is QUEUED; call `await tx.confirm()` to obtain the executed trade or chain rejection.
+	*
+	* @example
+	* ```ts
+	* const submitted = await swaps.swap('GALA', 'GUSDC', 3000, {
+	*   exactIn: '100',
+	*   amountOutMinimum: '14',
+	* });
+	* ```
+	*/
+	async swap(tokenIn, tokenOut, fee, amount) {
+		validateFee(fee);
+		const dto = await this.buildRequestTradeDto(tokenIn, tokenOut, fee, amount);
+		if (this.signer === void 0) throw GSwapSDKError.noSignerError();
+		const signedDto = await this.signer.signObject("RequestTrade", dto);
+		const submitOptions = this.walletAddress === void 0 ? {} : { walletAddress: this.walletAddress };
+		return this.gateway.submit("RequestTrade", signedDto, submitOptions);
+	}
+	/**
+	* Confirm a swap by its durable `uniqueKey` without resubmitting it. This is the recovery
+	* path after a `CONFIRMATION_TIMEOUT`, a `SUBMISSION_OUTCOME_UNKNOWN`, a `409` replay
+	* conflict, or a process restart: it reads the same apply-results record that
+	* `SubmittedTransaction.confirm()` reads (retained for 7 days) and resolves the applied trade
+	* or throws the chain's rejection. The first read happens immediately unless
+	* `initialDelayMs` is given.
+	*
+	* @example
+	* ```ts
+	* const applied = await swaps.confirmSwap('gswap-sdk-2f1c…');
+	* ```
+	*/
+	async confirmSwap(uniqueKey, options) {
+		if (!UNIQUE_KEY_PATTERN.test(uniqueKey)) throw new GSwapSDKError("uniqueKey must be 1-128 characters of A-Z, a-z, 0-9, \".\", \"_\", \":\" or \"-\".", "VALIDATION_ERROR", { uniqueKey });
+		return new SubmittedTransaction({
+			method: "RequestTrade",
+			uniqueKey,
+			transactionId: null,
+			mode: "queued",
+			result: void 0,
+			dexBackendBaseUrl: this.gateway.dexBackendBaseUrl,
+			httpRequestor: this.gateway.httpRequestor,
+			requestTimeoutMs: this.gateway.requestTimeoutMs
+		}).confirm({
+			initialDelayMs: 0,
+			...options
+		});
+	}
+	async buildRequestTradeDto(tokenIn, tokenOut, fee, amount) {
+		const tokenInSymbol = await resolveSymbol(this.symbols, tokenIn);
+		const tokenOutSymbol = await resolveSymbol(this.symbols, tokenOut);
+		const ordered = readOrderedSymbols(orderSymbols(tokenInSymbol, tokenOutSymbol));
+		const tokenInIsToken0 = tokenInSymbol === ordered.token0;
+		const dto = {
+			token0: ordered.token0,
+			token1: ordered.token1,
+			fee,
+			uniqueKey: `gswap-sdk-${globalThis.crypto.randomUUID()}`
+		};
+		if ("exactIn" in amount) {
+			const exactIn = amount.exactIn;
+			if (exactIn === void 0) throw new GSwapSDKError("exactIn is required for an exact-input swap.", "VALIDATION_ERROR");
+			validateNumericAmount(exactIn, "exactIn");
+			dto[tokenInIsToken0 ? "sell0Qty" : "sell1Qty"] = toDecimalString(exactIn);
+			if (amount.amountOutMinimum !== void 0) {
+				validateNumericAmount(amount.amountOutMinimum, "amountOutMinimum", true);
+				dto["amountOutMinimum"] = toDecimalString(amount.amountOutMinimum);
+			}
+		} else {
+			const exactOut = amount.exactOut;
+			if (exactOut === void 0) throw new GSwapSDKError("exactOut is required for an exact-output swap.", "VALIDATION_ERROR");
+			validateNumericAmount(exactOut, "exactOut");
+			dto[tokenInIsToken0 ? "buy1Qty" : "buy0Qty"] = toDecimalString(exactOut);
+			if (amount.amountInMaximum !== void 0) {
+				validateNumericAmount(amount.amountInMaximum, "amountInMaximum", true);
+				dto["amountInMaximum"] = toDecimalString(amount.amountInMaximum);
+			}
+		}
+		return dto;
+	}
 };
-function toDecimalString2(amount) {
-  return new import_bignumber5.default(amount).toFixed();
+function toDecimalString(amount) {
+	return new bignumber_js.default(amount).toFixed();
 }
-async function resolveSymbol3(symbols, token) {
-  const resolved = await symbols.resolve(token);
-  if (resolved.symbol.length > 0) return resolved.symbol;
-  throw new GSwapSDKError("Token could not be resolved to a trading symbol.", "SYMBOL_NOT_FOUND", {
-    token
-  });
+async function resolveSymbol(symbols, token) {
+	const resolved = await symbols.resolve(token);
+	if (resolved.symbol.length > 0) return resolved.symbol;
+	throw new GSwapSDKError("Token could not be resolved to a trading symbol.", "SYMBOL_NOT_FOUND", { token });
 }
 
-// src/types/env.ts
-var GSWAP_ENVIRONMENTS = {
-  prod: {
-    dexBackendBaseUrl: "https://dex-backend-prod1.defi.gala.com"
-  },
-  stage: {
-    dexBackendBaseUrl: "https://swap-backend.stage.defi.ovh.gala.com"
-  }
+//#endregion
+//#region src/types/env.ts
+/** Built-in GalaSwap deployment environments. */
+const GSWAP_ENVIRONMENTS = {
+	prod: { dexBackendBaseUrl: "https://dex-backend-prod1.defi.gala.com" },
+	stage: { dexBackendBaseUrl: "https://swap-backend.stage.defi.ovh.gala.com" }
 };
 
-// src/classes/gswap.ts
+//#endregion
+//#region src/classes/gswap.ts
+/** Main entry point for the current GalaChainDex SDK. */
 var GSwap = class {
-  dexBackendBaseUrl;
-  chainCallTimeoutMs;
-  signer;
-  walletAddress;
-  gateway;
-  symbols;
-  quoting;
-  pools;
-  positions;
-  swaps;
-  assets;
-  /**
-   * Create an SDK client for prod or stage.
-   *
-   * @example
-   * ```typescript
-   * const gSwap = new GSwap({ env: 'stage' });
-   * const symbols = await gSwap.symbols.list();
-   * ```
-   */
-  constructor(options) {
-    const environment = GSWAP_ENVIRONMENTS[(options == null ? void 0 : options.env) ?? "prod"];
-    this.dexBackendBaseUrl = trimTrailingSlash2(
-      (options == null ? void 0 : options.dexBackendBaseUrl) ?? environment.dexBackendBaseUrl
-    );
-    this.chainCallTimeoutMs = (options == null ? void 0 : options.chainCallTimeoutMs) ?? 3e4;
-    this.signer = options == null ? void 0 : options.signer;
-    this.walletAddress = options == null ? void 0 : options.walletAddress;
-    const httpClient = new HttpClient(options == null ? void 0 : options.httpRequestor, this.chainCallTimeoutMs);
-    this.gateway = new ChainGateway({
-      dexBackendBaseUrl: this.dexBackendBaseUrl,
-      chainCallTimeoutMs: this.chainCallTimeoutMs,
-      ...(options == null ? void 0 : options.httpRequestor) === void 0 ? {} : { httpRequestor: options.httpRequestor },
-      ...this.walletAddress === void 0 ? {} : { walletAddress: this.walletAddress }
-    });
-    this.symbols = new Symbols(this.gateway);
-    this.quoting = new Quoting(this.dexBackendBaseUrl, httpClient, this.symbols);
-    this.pools = new Pools(this.gateway, this.symbols);
-    this.positions = new Positions(this.gateway, this.symbols, this.signer, this.walletAddress);
-    this.swaps = new Swaps(this.gateway, this.symbols, this.signer, this.walletAddress);
-    this.assets = new Assets(this.dexBackendBaseUrl, httpClient);
-  }
+	dexBackendBaseUrl;
+	chainCallTimeoutMs;
+	signer;
+	walletAddress;
+	gateway;
+	symbols;
+	quoting;
+	pools;
+	positions;
+	swaps;
+	assets;
+	/**
+	* Create an SDK client for prod or stage.
+	*
+	* @example
+	* ```typescript
+	* const gSwap = new GSwap({ env: 'stage' });
+	* const symbols = await gSwap.symbols.list();
+	* ```
+	*/
+	constructor(options) {
+		const environment = GSWAP_ENVIRONMENTS[(options === null || options === void 0 ? void 0 : options.env) ?? "prod"];
+		this.dexBackendBaseUrl = trimTrailingSlash((options === null || options === void 0 ? void 0 : options.dexBackendBaseUrl) ?? environment.dexBackendBaseUrl);
+		this.chainCallTimeoutMs = (options === null || options === void 0 ? void 0 : options.chainCallTimeoutMs) ?? 3e4;
+		this.signer = options === null || options === void 0 ? void 0 : options.signer;
+		this.walletAddress = options === null || options === void 0 ? void 0 : options.walletAddress;
+		const httpClient = new HttpClient(options === null || options === void 0 ? void 0 : options.httpRequestor, this.chainCallTimeoutMs);
+		this.gateway = new ChainGateway({
+			dexBackendBaseUrl: this.dexBackendBaseUrl,
+			chainCallTimeoutMs: this.chainCallTimeoutMs,
+			...(options === null || options === void 0 ? void 0 : options.httpRequestor) === void 0 ? {} : { httpRequestor: options.httpRequestor },
+			...this.walletAddress === void 0 ? {} : { walletAddress: this.walletAddress }
+		});
+		this.symbols = new Symbols(this.gateway);
+		this.quoting = new Quoting(this.dexBackendBaseUrl, httpClient, this.symbols);
+		this.pools = new Pools(this.gateway, this.symbols);
+		this.positions = new Positions(this.gateway, this.symbols, this.signer, this.walletAddress);
+		this.swaps = new Swaps(this.gateway, this.symbols, this.signer, this.walletAddress);
+		this.assets = new Assets(this.dexBackendBaseUrl, httpClient);
+	}
 };
-function trimTrailingSlash2(value) {
-  return value.replace(/\/$/u, "");
+function trimTrailingSlash(value) {
+	return value.replace(/\/$/u, "");
 }
 
-// src/classes/signers.ts
-var import_api = require("@gala-chain/api");
-
-// src/utils/eip712.ts
+//#endregion
+//#region src/utils/eip712.ts
+/**
+* Derives the EIP-712 `types` for a DTO from its runtime shape.
+*
+* The generated `types` travel with the signed payload and are what BOTH sides hash, so they
+* must enumerate EVERY field the chain-side DTO will carry. GalaChain refuses any signature
+* whose `types` leave a DTO field uncovered (`assertNoUnsignedFields`, the fix for the
+* 2026-08-18 unsigned-field-injection drain); when that happens signature recovery fails
+* outright and the chain reports "Missing signerPublicKey or signerAddress field in dto".
+*/
 function generateEIP712Types(typeName, params) {
-  const types = {};
-  types[typeName] = [];
-  function fieldsFor(name) {
-    const fields = types[name];
-    if (!fields) throw new Error(`Missing EIP-712 type definition for ${name}`);
-    return fields;
-  }
-  function addField(name, fieldValue, parentTypeName, onlyGetType = false) {
-    if (Array.isArray(fieldValue)) {
-      const type = fieldValue.length > 0 ? addField(name, fieldValue[0], parentTypeName, true) : "string";
-      if (!onlyGetType) fieldsFor(parentTypeName).push({ name, type: (type ?? name) + "[]" });
-    } else if (typeof fieldValue === "object" && fieldValue !== null) {
-      if (types[name]) {
-        throw new Error("Name collisions not yet supported");
-      }
-      types[name] = [];
-      Object.entries(fieldValue).forEach(([key, value]) => {
-        addField(key, value, name);
-      });
-      if (!onlyGetType) fieldsFor(parentTypeName).push({ name, type: name });
-    } else {
-      let eipType;
-      switch (typeof fieldValue) {
-        case "string":
-          eipType = "string";
-          break;
-        case "number":
-          eipType = "int256";
-          break;
-        case "boolean":
-          eipType = "bool";
-          break;
-        case "bigint":
-        case "symbol":
-        case "undefined":
-        case "function":
-        case "object":
-          throw new Error(
-            `Unsupported type, ${typeof fieldValue}, value: ${Object.prototype.toString.call(fieldValue)}`
-          );
-      }
-      if (onlyGetType) {
-        return eipType;
-      }
-      fieldsFor(parentTypeName).push({ name, type: eipType });
-    }
-    return void 0;
-  }
-  Object.entries(params).forEach(([key, value]) => {
-    addField(key, value, typeName);
-  });
-  return types;
-}
-var EIP712_DOMAIN = { name: "ethereum", chainId: 1 };
-var EIP712_CAPABLE_METHODS = /* @__PURE__ */ new Set([
-  "RequestTrade",
-  "AddLiquidity",
-  "RemoveLiquidity",
-  "CollectPositionFees"
+	const types = {};
+	types[typeName] = [];
+	function fieldsFor(name) {
+		const fields = types[name];
+		/* c8 ignore next */
+		if (!fields) throw new Error(`Missing EIP-712 type definition for ${name}`);
+		return fields;
+	}
+	function addField(name, fieldValue, parentTypeName, onlyGetType = false) {
+		if (Array.isArray(fieldValue)) {
+			const type = fieldValue.length > 0 ? addField(name, fieldValue[0], parentTypeName, true) : "string";
+			if (!onlyGetType) fieldsFor(parentTypeName).push({
+				name,
+				type: (type ?? name) + "[]"
+			});
+		} else if (typeof fieldValue === "object" && fieldValue !== null) {
+			if (types[name]) throw new Error("Name collisions not yet supported");
+			types[name] = [];
+			Object.entries(fieldValue).forEach(([key, value]) => {
+				addField(key, value, name);
+			});
+			if (!onlyGetType) fieldsFor(parentTypeName).push({
+				name,
+				type: name
+			});
+		} else {
+			let eipType;
+			switch (typeof fieldValue) {
+				case "string":
+					eipType = "string";
+					break;
+				case "number":
+					eipType = "int256";
+					break;
+				case "boolean":
+					eipType = "bool";
+					break;
+				case "bigint":
+				case "symbol":
+				case "undefined":
+				case "function":
+				case "object": throw new Error(`Unsupported type, ${typeof fieldValue}, value: ${Object.prototype.toString.call(fieldValue)}`);
+			}
+			if (onlyGetType) return eipType;
+			fieldsFor(parentTypeName).push({
+				name,
+				type: eipType
+			});
+		}
+	}
+	Object.entries(params).forEach(([key, value]) => {
+		addField(key, value, typeName);
+	});
+	return types;
+}
+/** Matches every genuine-EIP-712 probe that has actually recovered `client|` on stage. */
+const EIP712_DOMAIN = {
+	name: "ethereum",
+	chainId: 1
+};
+/**
+* The four v2 operations proven to recover the signer correctly via genuine EIP-712: `RequestTrade`
+* never had the problem (one numeric field). `AddLiquidity`/`RemoveLiquidity`/
+* `CollectPositionFees` each need their `types` completed with a handful of fields their real
+* server-side DTO always carries — see the `complete*Fields` functions below. `CreatePool` is a
+* genuinely different, unsolved problem (nested `TokenClassKey` structs, not a flat
+* missing-field gap) and is NOT in this set — callers must keep using `personal-sign` for it.
+*/
+const EIP712_CAPABLE_METHODS = /* @__PURE__ */ new Set([
+	"RequestTrade",
+	"AddLiquidity",
+	"RemoveLiquidity",
+	"CollectPositionFees"
 ]);
+/**
+* Every `complete*Fields` function below shares the same two live-proven rules:
+*  1. Numeric completeness fields MUST be JS `number`, never numeric strings —
+*     `generateEIP712Types` infers a field's Solidity type from `typeof`, and declaring one as
+*     EIP-712 `string` instead of `int256` breaks recovery identically to omitting the field
+*     entirely (verified live on AddLiquidity: `amount0Min: '0'` fails with the exact same
+*     "Missing signerPublicKey" error as `amount0Min` being absent; `amount0Min: 0` succeeds).
+*  2. `positionId` has no such constraint — an empty string works, and does not target an
+*     existing position (`positionId: ''` created a fresh position on AddLiquidity, not an add
+*     to position id `''`; on RemoveLiquidity/CollectPositionFees the real position is still
+*     resolved from `token0`/`token1`/`fee`/`tickLower`/`tickUpper`, not from this field).
+*/
 function numericOr0(dto, field) {
-  return typeof dto[field] === "number" ? dto[field] : 0;
-}
+	return typeof dto[field] === "number" ? dto[field] : 0;
+}
+/**
+* `AddLiquidity`'s real server-side DTO always carries `amount0Desired`/`amount0Min`/
+* `amount1Desired`/`amount1Min`/`positionId` once reconstructed, regardless of which deposit
+* convention the caller used (`Positions.addLiquidityByTicks` only ever sends
+* `depositQuantityToken0`/`depositQuantityToken1`). Proven empirically by bisection: none of the
+* five alone fixes recovery, all five together does (live 201, tx `407d9b24...`, block
+* `2429022`).
+*/
 function completeAddLiquidityFields(dto) {
-  return {
-    ...dto,
-    amount0Desired: numericOr0(dto, "amount0Desired"),
-    amount0Min: numericOr0(dto, "amount0Min"),
-    amount1Desired: numericOr0(dto, "amount1Desired"),
-    amount1Min: numericOr0(dto, "amount1Min"),
-    positionId: dto["positionId"] ?? ""
-  };
-}
+	return {
+		...dto,
+		amount0Desired: numericOr0(dto, "amount0Desired"),
+		amount0Min: numericOr0(dto, "amount0Min"),
+		amount1Desired: numericOr0(dto, "amount1Desired"),
+		amount1Min: numericOr0(dto, "amount1Min"),
+		positionId: dto["positionId"] ?? ""
+	};
+}
+/**
+* `RemoveLiquidity`'s real server-side DTO always carries `amount`/`amount0Min`/`amount1Min`/
+* `positionId` — `Positions.removeLiquidity` only ever sends a `withdrawalQuantityTokenX` (or
+* neither, for a full close). Proven empirically: every subset of these four fails, all four
+* together succeeds (live, random-signer probe — recovery confirmed by the response moving from
+* "Missing signerPublicKey" to a genuine position-not-found 404).
+*/
 function completeRemoveLiquidityFields(dto) {
-  return {
-    ...dto,
-    amount: numericOr0(dto, "amount"),
-    amount0Min: numericOr0(dto, "amount0Min"),
-    amount1Min: numericOr0(dto, "amount1Min"),
-    positionId: dto["positionId"] ?? ""
-  };
-}
+	return {
+		...dto,
+		amount: numericOr0(dto, "amount"),
+		amount0Min: numericOr0(dto, "amount0Min"),
+		amount1Min: numericOr0(dto, "amount1Min"),
+		positionId: dto["positionId"] ?? ""
+	};
+}
+/**
+* `CollectPositionFees`'s real server-side DTO always carries `amount0Requested`/
+* `amount1Requested`/`positionId` — `Positions.collectPositionFees` sends only the five identity
+* fields. Proven empirically the same way as `completeRemoveLiquidityFields`.
+*/
 function completeCollectPositionFeesFields(dto) {
-  return {
-    ...dto,
-    amount0Requested: numericOr0(dto, "amount0Requested"),
-    amount1Requested: numericOr0(dto, "amount1Requested"),
-    positionId: dto["positionId"] ?? ""
-  };
-}
-var EIP712_FIELD_COMPLETERS = {
-  AddLiquidity: completeAddLiquidityFields,
-  RemoveLiquidity: completeRemoveLiquidityFields,
-  CollectPositionFees: completeCollectPositionFeesFields
+	return {
+		...dto,
+		amount0Requested: numericOr0(dto, "amount0Requested"),
+		amount1Requested: numericOr0(dto, "amount1Requested"),
+		positionId: dto["positionId"] ?? ""
+	};
+}
+const EIP712_FIELD_COMPLETERS = {
+	AddLiquidity: completeAddLiquidityFields,
+	RemoveLiquidity: completeRemoveLiquidityFields,
+	CollectPositionFees: completeCollectPositionFeesFields
 };
+/**
+* Completes a DTO's fields for EIP-712 signing (a no-op for methods with no known gap, e.g.
+* `RequestTrade`) and derives its `types`. Exported separately from the signing call itself so tests
+* can assert on the exact payload without needing a live provider.
+*/
 function buildEIP712Payload(methodName, dto) {
-  const completer = EIP712_FIELD_COMPLETERS[methodName];
-  const completedDto = completer ? completer(dto) : dto;
-  const types = generateEIP712Types(methodName, completedDto);
-  return { completedDto, types };
+	const completer = EIP712_FIELD_COMPLETERS[methodName];
+	const completedDto = completer ? completer(dto) : dto;
+	return {
+		completedDto,
+		types: generateEIP712Types(methodName, completedDto)
+	};
 }
 
-// src/classes/signers.ts
-var ETHEREUM_SIGNED_MESSAGE = String.fromCharCode(25) + "Ethereum Signed Message:\n";
+//#endregion
+//#region src/classes/signers.ts
+const ETHEREUM_SIGNED_MESSAGE = String.fromCharCode(25) + "Ethereum Signed Message:\n";
+/** The EIP-191 header for `dto`'s canonical JSON (UTF-8 byte length; any `prefix` on it is ignored). */
 function personalSignPrefixFor(dto) {
-  const withoutPrefix = { ...dto };
-  delete withoutPrefix["prefix"];
-  const message = (0, import_api.serialize)(withoutPrefix);
-  return ETHEREUM_SIGNED_MESSAGE + String(new TextEncoder().encode(message).length);
+	const withoutPrefix = { ...dto };
+	delete withoutPrefix["prefix"];
+	const message = (0, _gala_chain_api.serialize)(withoutPrefix);
+	return ETHEREUM_SIGNED_MESSAGE + String(new TextEncoder().encode(message).length);
 }
 function getWalletProvider() {
-  var _a;
-  const globalObject = globalThis;
-  const wallet = (_a = globalObject.window) == null ? void 0 : _a.gala;
-  if (!wallet) {
-    throw new GSwapSDKError(
-      "Gala wallet is not available. Please ensure the Gala wallet is connected.",
-      "GALA_WALLET_NOT_AVAILABLE"
-    );
-  }
-  return wallet;
+	var _globalObject$window;
+	const wallet = (_globalObject$window = globalThis.window) === null || _globalObject$window === void 0 ? void 0 : _globalObject$window.gala;
+	if (!wallet) throw new GSwapSDKError("Gala wallet is not available. Please ensure the Gala wallet is connected.", "GALA_WALLET_NOT_AVAILABLE");
+	return wallet;
 }
 function getNativeSignature(value) {
-  if (typeof value !== "string") {
-    throw new GSwapSDKError("Wallet returned an invalid signature.", "INVALID_SIGNATURE");
-  }
-  if (!/^[0-9a-fA-F]{130}$/u.test(value)) {
-    throw new GSwapSDKError("Wallet returned an invalid native signature.", "INVALID_SIGNATURE");
-  }
-  return value;
+	if (typeof value !== "string") throw new GSwapSDKError("Wallet returned an invalid signature.", "INVALID_SIGNATURE");
+	if (!/^[0-9a-fA-F]{130}$/u.test(value)) throw new GSwapSDKError("Wallet returned an invalid native signature.", "INVALID_SIGNATURE");
+	return value;
 }
 function getPersonalSignature(value) {
-  if (typeof value !== "string" || !/^(?:0x)?[0-9a-fA-F]{130}$/u.test(value)) {
-    throw new GSwapSDKError(
-      "Wallet returned an invalid personal-sign signature.",
-      "INVALID_SIGNATURE"
-    );
-  }
-  return value;
+	if (typeof value !== "string" || !/^(?:0x)?[0-9a-fA-F]{130}$/u.test(value)) throw new GSwapSDKError("Wallet returned an invalid personal-sign signature.", "INVALID_SIGNATURE");
+	return value;
 }
 function normalizeEthereumAccount(address, allowGalaPrefix) {
-  const normalized = allowGalaPrefix && address.startsWith("eth|") ? address.slice(4) : address;
-  if (!/^0x[0-9a-fA-F]{40}$/u.test(normalized)) {
-    throw new GSwapSDKError(
-      "Wallet address must be the selected Ethereum account in 0x-prefixed form.",
-      "VALIDATION_ERROR",
-      { type: "INVALID_WALLET_ADDRESS", value: address }
-    );
-  }
-  return `0x${normalized.slice(2).toLowerCase()}`;
+	const normalized = allowGalaPrefix && address.startsWith("eth|") ? address.slice(4) : address;
+	if (!/^0x[0-9a-fA-F]{40}$/u.test(normalized)) throw new GSwapSDKError("Wallet address must be the selected Ethereum account in 0x-prefixed form.", "VALIDATION_ERROR", {
+		type: "INVALID_WALLET_ADDRESS",
+		value: address
+	});
+	return `0x${normalized.slice(2).toLowerCase()}`;
 }
 function getErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (typeof error === "object" && error !== null && "message" in error) {
-    const message = error.message;
-    return typeof message === "string" ? message : "";
-  }
-  return "";
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	if (typeof error === "object" && error !== null && "message" in error) {
+		const message = error.message;
+		return typeof message === "string" ? message : "";
+	}
+	return "";
 }
 function isUnsupportedNativeSchemeError(error) {
-  return /unsupported|unknown scheme/i.test(getErrorMessage(error));
+	return /unsupported|unknown scheme/i.test(getErrorMessage(error));
 }
 function personalSign(provider, dto, walletAddress, methodName) {
-  const prefix = personalSignPrefixFor(dto);
-  const payload = { ...dto, prefix };
-  const params = methodName !== void 0 ? [(0, import_api.serialize)(payload), walletAddress, methodName] : [(0, import_api.serialize)(dto), walletAddress];
-  return provider.request({ method: methodName !== void 0 ? "gala_signChainDto" : "personal_sign", params }).then((value) => ({ ...payload, signature: getPersonalSignature(value) }));
-}
+	const prefix = personalSignPrefixFor(dto);
+	const payload = {
+		...dto,
+		prefix
+	};
+	const params = methodName !== void 0 ? [
+		(0, _gala_chain_api.serialize)(payload),
+		walletAddress,
+		methodName
+	] : [(0, _gala_chain_api.serialize)(dto), walletAddress];
+	return provider.request({
+		method: methodName !== void 0 ? "gala_signChainDto" : "personal_sign",
+		params
+	}).then((value) => ({
+		...payload,
+		signature: getPersonalSignature(value)
+	}));
+}
+/**
+* Signs a DTO via genuine EIP-712 (`eth_signTypedData_v4`) — correctly resolves the `client|`
+* identity, unlike `personal_sign`, for the operations in `EIP712_CAPABLE_METHODS`.
+*
+* Constructs the raw JSON-RPC payload by hand (`{domain, types: {...types, EIP712Domain},
+* primaryType, message}`) rather than depending on ethers.js, matching exactly what
+* `ethers.TypedDataEncoder.getPayload`/`Wallet.signTypedData` produce internally — verified
+* byte-for-byte equivalent (same recovered address from the same signature against both
+* constructions) before this shipped, since gswap-sdk deliberately has no ethers dependency.
+*/
 function signEIP712(provider, methodName, dto, walletAddress) {
-  const { completedDto, types } = buildEIP712Payload(methodName, dto);
-  const prefix = personalSignPrefixFor(completedDto);
-  const message = { ...completedDto, prefix };
-  const eip712Domain = [
-    { name: "name", type: "string" },
-    { name: "chainId", type: "uint256" }
-  ];
-  const payload = {
-    domain: EIP712_DOMAIN,
-    types: { ...types, EIP712Domain: eip712Domain },
-    primaryType: methodName,
-    message
-  };
-  return provider.request({
-    method: "eth_signTypedData_v4",
-    params: [walletAddress, JSON.stringify(payload)]
-  }).then((value) => ({
-    ...message,
-    types,
-    domain: EIP712_DOMAIN,
-    signature: getPersonalSignature(value)
-  }));
-}
+	const { completedDto, types } = buildEIP712Payload(methodName, dto);
+	const prefix = personalSignPrefixFor(completedDto);
+	const message = {
+		...completedDto,
+		prefix
+	};
+	const eip712Domain = [{
+		name: "name",
+		type: "string"
+	}, {
+		name: "chainId",
+		type: "uint256"
+	}];
+	const payload = {
+		domain: EIP712_DOMAIN,
+		types: {
+			...types,
+			EIP712Domain: eip712Domain
+		},
+		primaryType: methodName,
+		message
+	};
+	return provider.request({
+		method: "eth_signTypedData_v4",
+		params: [walletAddress, JSON.stringify(payload)]
+	}).then((value) => ({
+		...message,
+		types,
+		domain: EIP712_DOMAIN,
+		signature: getPersonalSignature(value)
+	}));
+}
+/**
+* A GalaChain native signer backed by a secp256k1 private key.
+*
+* Native signing produces the bare GalaChain signature format, without a personal-sign prefix
+* or EIP-712 metadata. The private-key identity is recovered by the chain.
+*/
 var PrivateKeySigner = class {
-  keyBuffer;
-  /**
-   * Creates a native signer from a hex or base64 secp256k1 private key.
-   *
-   * @example
-   * ```typescript
-   * const signer = new PrivateKeySigner('1'.padStart(64, '0'));
-   * const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
-   * ```
-   */
-  constructor(privateKey) {
-    this.keyBuffer = import_api.signatures.normalizePrivateKey(privateKey);
-  }
-  /**
-   * Signs the DTO with GalaChain native signing.
-   *
-   * @example
-   * ```typescript
-   * const signed = await signer.signObject('RequestTrade', {
-   *   token0: 'GALA',
-   *   token1: 'GUSDC',
-   *   fee: 3000,
-   * });
-   * ```
-   */
-  signObject(_methodName, dto) {
-    const signature = import_api.signatures.getSignature(dto, this.keyBuffer);
-    return Promise.resolve({ ...dto, signature });
-  }
+	keyBuffer;
+	/**
+	* Creates a native signer from a hex or base64 secp256k1 private key.
+	*
+	* @example
+	* ```typescript
+	* const signer = new PrivateKeySigner('1'.padStart(64, '0'));
+	* const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
+	* ```
+	*/
+	constructor(privateKey) {
+		this.keyBuffer = _gala_chain_api.signatures.normalizePrivateKey(privateKey);
+	}
+	/**
+	* Signs the DTO with GalaChain native signing.
+	*
+	* @example
+	* ```typescript
+	* const signed = await signer.signObject('RequestTrade', {
+	*   token0: 'GALA',
+	*   token1: 'GUSDC',
+	*   fee: 3000,
+	* });
+	* ```
+	*/
+	signObject(_methodName, dto) {
+		const signature = _gala_chain_api.signatures.getSignature(dto, this.keyBuffer);
+		return Promise.resolve({
+			...dto,
+			signature
+		});
+	}
 };
+/**
+* A Gala Wallet signer using native GalaChain signing, with an opt-in personal-sign mode and
+* automatic fallback for older wallets.
+*
+* The selected Ethereum account is passed to Gala Wallet. Personal-sign resolves the bare
+* `eth|` identity; the legacy EIP-712 `eth_signTypedData` path is not used. The fallback calls
+* `gala_signChainDto([serialize({ ...dto, prefix }), walletAddress, methodName])`.
+*/
 var GalaWalletSigner = class {
-  /** The wallet address supplied to Gala Wallet for each signing request. */
-  walletAddress;
-  /** The scheme currently used, including any automatic native-to-personal fallback. */
-  effectiveScheme;
-  /**
-   * Creates a Gala Wallet signer.
-   *
-   * @example
-   * ```typescript
-   * const signer = new GalaWalletSigner('0x0123456789012345678901234567890123456789');
-   * const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
-   * ```
-   *
-   * @param walletAddress - The selected Ethereum account (`0x` plus 40 hex digits); Gala Wallet's
-   * `eth|0x...` form is also accepted and normalized.
-   * @param options - Select native signing or personal-sign explicitly.
-   */
-  constructor(walletAddress, options = {}) {
-    this.walletAddress = normalizeEthereumAccount(walletAddress, true);
-    this.effectiveScheme = options.scheme ?? "native";
-  }
-  /**
-   * Signs a DTO through `gala_signChainDto`.
-   *
-   * @example
-   * ```typescript
-   * const signed = await signer.signObject('AddLiquidity', {
-   *   token0: 'GALA',
-   *   token1: 'GUSDC',
-   *   tickLower: -60,
-   *   tickUpper: 60,
-   * });
-   * ```
-   */
-  async signObject(methodName, dto) {
-    const wallet = getWalletProvider();
-    if (this.effectiveScheme === "personal-sign") {
-      return personalSign(wallet, dto, this.walletAddress, methodName);
-    }
-    try {
-      const signature = await wallet.request({
-        method: "gala_signChainDto",
-        params: [(0, import_api.serialize)(dto), this.walletAddress, methodName, "native"]
-      });
-      return { ...dto, signature: getNativeSignature(signature) };
-    } catch (error) {
-      if (!isUnsupportedNativeSchemeError(error)) {
-        throw error;
-      }
-      this.effectiveScheme = "personal-sign";
-      return personalSign(wallet, dto, this.walletAddress, methodName);
-    }
-  }
+	/** The wallet address supplied to Gala Wallet for each signing request. */
+	walletAddress;
+	/** The scheme currently used, including any automatic native-to-personal fallback. */
+	effectiveScheme;
+	/**
+	* Creates a Gala Wallet signer.
+	*
+	* @example
+	* ```typescript
+	* const signer = new GalaWalletSigner('0x0123456789012345678901234567890123456789');
+	* const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
+	* ```
+	*
+	* @param walletAddress - The selected Ethereum account (`0x` plus 40 hex digits); Gala Wallet's
+	* `eth|0x...` form is also accepted and normalized.
+	* @param options - Select native signing or personal-sign explicitly.
+	*/
+	constructor(walletAddress, options = {}) {
+		this.walletAddress = normalizeEthereumAccount(walletAddress, true);
+		this.effectiveScheme = options.scheme ?? "native";
+	}
+	/**
+	* Signs a DTO through `gala_signChainDto`.
+	*
+	* @example
+	* ```typescript
+	* const signed = await signer.signObject('AddLiquidity', {
+	*   token0: 'GALA',
+	*   token1: 'GUSDC',
+	*   tickLower: -60,
+	*   tickUpper: 60,
+	* });
+	* ```
+	*/
+	async signObject(methodName, dto) {
+		const wallet = getWalletProvider();
+		if (this.effectiveScheme === "personal-sign") return personalSign(wallet, dto, this.walletAddress, methodName);
+		try {
+			const signature = await wallet.request({
+				method: "gala_signChainDto",
+				params: [
+					(0, _gala_chain_api.serialize)(dto),
+					this.walletAddress,
+					methodName,
+					"native"
+				]
+			});
+			return {
+				...dto,
+				signature: getNativeSignature(signature)
+			};
+		} catch (error) {
+			if (!isUnsupportedNativeSchemeError(error)) throw error;
+			this.effectiveScheme = "personal-sign";
+			return personalSign(wallet, dto, this.walletAddress, methodName);
+		}
+	}
 };
+/**
+* A personal-sign signer for MetaMask and other EIP-1193 browser wallets.
+*
+* The chain recovers this signature using the EIP-191 wrap applied by the wallet to
+* `personal_sign`. This is the browser-wallet path used by the v2 frontend and resolves the
+* bare `eth|` identity.
+*/
 var BrowserWalletSigner = class {
-  /**
-   * Creates a browser-wallet signer.
-   *
-   * Defaults to `personal_sign` — unchanged from every existing integration, since it only ever
-   * resolves the bare `eth|` identity and changing that silently would be a real behavior
-   * break for anyone already depending on it. Pass `{ scheme: 'eip712' }` to correctly resolve
-   * a registered `client|` alias instead, for `RequestTrade`/`AddLiquidity`/`RemoveLiquidity`/
-   * `CollectPositionFees` (`EIP712_CAPABLE_METHODS`) — `CreatePool` and any other method still
-   * falls back to `personal_sign` even in `'eip712'` mode, since its EIP-712 signing is a
-   * separate, unsolved chain-side problem.
-   *
-   * @example
-   * ```typescript
-   * const signer = new BrowserWalletSigner(window.ethereum, '0x0123456789012345678901234567890123456789');
-   * const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
-   * ```
-   * @example
-   * ```typescript
-   * // Correctly resolves a registered client| alias instead of the bare eth| address.
-   * const signer = new BrowserWalletSigner(window.ethereum, walletAddress, { scheme: 'eip712' });
-   * ```
-   */
-  constructor(provider, walletAddress, options = {}) {
-    this.provider = provider;
-    this.walletAddress = normalizeEthereumAccount(walletAddress, false);
-    this.scheme = options.scheme ?? "personal-sign";
-  }
-  provider;
-  walletAddress;
-  scheme;
-  /**
-   * Signs the DTO with `eth_signTypedData_v4` (when constructed with `{ scheme: 'eip712' }` and
-   * `methodName` is in `EIP712_CAPABLE_METHODS`) or the EIP-1193 `personal_sign` method
-   * (otherwise — the default).
-   *
-   * @example
-   * ```typescript
-   * const signed = await signer.signObject('RequestTrade', {
-   *   token0: 'GALA',
-   *   token1: 'GUSDC',
-   *   fee: 3000,
-   * });
-   * ```
-   */
-  signObject(methodName, dto) {
-    if (this.scheme === "eip712" && EIP712_CAPABLE_METHODS.has(methodName)) {
-      return signEIP712(this.provider, methodName, dto, this.walletAddress);
-    }
-    return personalSign(this.provider, dto, this.walletAddress);
-  }
+	provider;
+	/**
+	* Creates a browser-wallet signer.
+	*
+	* Defaults to `personal_sign` — unchanged from every existing integration, since it only ever
+	* resolves the bare `eth|` identity and changing that silently would be a real behavior
+	* break for anyone already depending on it. Pass `{ scheme: 'eip712' }` to correctly resolve
+	* a registered `client|` alias instead, for `RequestTrade`/`AddLiquidity`/`RemoveLiquidity`/
+	* `CollectPositionFees` (`EIP712_CAPABLE_METHODS`) — `CreatePool` and any other method still
+	* falls back to `personal_sign` even in `'eip712'` mode, since its EIP-712 signing is a
+	* separate, unsolved chain-side problem.
+	*
+	* @example
+	* ```typescript
+	* const signer = new BrowserWalletSigner(window.ethereum, '0x0123456789012345678901234567890123456789');
+	* const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
+	* ```
+	* @example
+	* ```typescript
+	* // Correctly resolves a registered client| alias instead of the bare eth| address.
+	* const signer = new BrowserWalletSigner(window.ethereum, walletAddress, { scheme: 'eip712' });
+	* ```
+	*/
+	constructor(provider, walletAddress, options = {}) {
+		this.provider = provider;
+		this.walletAddress = normalizeEthereumAccount(walletAddress, false);
+		this.scheme = options.scheme ?? "personal-sign";
+	}
+	walletAddress;
+	scheme;
+	/**
+	* Signs the DTO with `eth_signTypedData_v4` (when constructed with `{ scheme: 'eip712' }` and
+	* `methodName` is in `EIP712_CAPABLE_METHODS`) or the EIP-1193 `personal_sign` method
+	* (otherwise — the default).
+	*
+	* @example
+	* ```typescript
+	* const signed = await signer.signObject('RequestTrade', {
+	*   token0: 'GALA',
+	*   token1: 'GUSDC',
+	*   fee: 3000,
+	* });
+	* ```
+	*/
+	signObject(methodName, dto) {
+		if (this.scheme === "eip712" && EIP712_CAPABLE_METHODS.has(methodName)) return signEIP712(this.provider, methodName, dto, this.walletAddress);
+		return personalSign(this.provider, dto, this.walletAddress);
+	}
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ALL_FEE_TIERS,
-  Assets,
-  BrowserWalletSigner,
-  ChainGateway,
-  FEE_TIER,
-  GC_MAX_TICK,
-  GC_MIN_TICK,
-  GSWAP_ENVIRONMENTS,
-  GSwap,
-  GSwapSDKError,
-  GalaWalletSigner,
-  Pools,
-  Positions,
-  PrivateKeySigner,
-  Quoting,
-  SubmittedTransaction,
-  Swaps,
-  Symbols,
-  TICK_SPACING_BY_FEE,
-  alignTickDown,
-  alignTickUp,
-  assertTickRange,
-  compositeKeyOf,
-  getObjectProperty,
-  getStringProperty,
-  orderSymbols,
-  parseJson,
-  parseTokenClassKey,
-  readOrderedSymbols,
-  sqrtPriceToTick,
-  tickFromPrice,
-  tickToSqrtPrice,
-  validateFee,
-  validateNumericAmount,
-  validatePriceValues,
-  validateTickRange,
-  validateTickSpacing,
-  validateTokenDecimals,
-  validateWalletAddress
-});
+
+//#endregion
+exports.ALL_FEE_TIERS = ALL_FEE_TIERS;
+exports.Assets = Assets;
+exports.BrowserWalletSigner = BrowserWalletSigner;
+exports.ChainGateway = ChainGateway;
+exports.FEE_TIER = FEE_TIER;
+exports.GC_MAX_TICK = GC_MAX_TICK;
+exports.GC_MIN_TICK = GC_MIN_TICK;
+exports.GSWAP_ENVIRONMENTS = GSWAP_ENVIRONMENTS;
+exports.GSwap = GSwap;
+exports.GSwapSDKError = GSwapSDKError;
+exports.GalaWalletSigner = GalaWalletSigner;
+exports.Pools = Pools;
+exports.Positions = Positions;
+exports.PrivateKeySigner = PrivateKeySigner;
+exports.Quoting = Quoting;
+exports.SubmittedTransaction = SubmittedTransaction;
+exports.Swaps = Swaps;
+exports.Symbols = Symbols;
+exports.TICK_SPACING_BY_FEE = TICK_SPACING_BY_FEE;
+exports.alignTickDown = alignTickDown;
+exports.alignTickUp = alignTickUp;
+exports.assertTickRange = assertTickRange;
+exports.compositeKeyOf = compositeKeyOf;
+exports.getObjectProperty = getObjectProperty;
+exports.getStringProperty = getStringProperty;
+exports.orderSymbols = orderSymbols;
+exports.parseJson = parseJson;
+exports.parseTokenClassKey = parseTokenClassKey;
+exports.readOrderedSymbols = readOrderedSymbols;
+exports.sqrtPriceToTick = sqrtPriceToTick;
+exports.tickFromPrice = tickFromPrice;
+exports.tickToSqrtPrice = tickToSqrtPrice;
+exports.validateFee = validateFee;
+exports.validateNumericAmount = validateNumericAmount;
+exports.validatePriceValues = validatePriceValues;
+exports.validateTickRange = validateTickRange;
+exports.validateTickSpacing = validateTickSpacing;
+exports.validateTokenDecimals = validateTokenDecimals;
+exports.validateWalletAddress = validateWalletAddress;
 //# sourceMappingURL=index.cjs.map