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

package/dist/index.cjs

@@ -30,25 +30,38 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ALL_FEE_TIERS: () => ALL_FEE_TIERS,
   Assets: () => Assets,
-  Bundler: () => Bundler,
-  EventSocketClient: () => EventSocketClient,
-  Events: () => Events,
+  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,
-  PendingTransaction: () => PendingTransaction,
   Pools: () => Pools,
   Positions: () => Positions,
   PrivateKeySigner: () => PrivateKeySigner,
   Quoting: () => Quoting,
+  SubmittedTransaction: () => SubmittedTransaction,
   Swaps: () => Swaps,
-  TradeEventEmitter: () => TradeEventEmitter,
-  compareTokens: () => compareTokens,
-  getTokenOrdering: () => getTokenOrdering,
+  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,
-  stringifyTokenClassKey: () => stringifyTokenClassKey,
+  readOrderedSymbols: () => readOrderedSymbols,
+  sqrtPriceToTick: () => sqrtPriceToTick,
+  tickFromPrice: () => tickFromPrice,
+  tickToSqrtPrice: () => tickToSqrtPrice,
   validateFee: () => validateFee,
   validateNumericAmount: () => validateNumericAmount,
   validatePriceValues: () => validatePriceValues,
@@ -60,41 +73,99 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/utils/validation.ts
-var import_bignumber = __toESM(require("bignumber.js"), 1);
+var import_bignumber2 = __toESM(require("bignumber.js"), 1);
 
 // src/classes/gswap_sdk_error.ts
 var GSwapSDKError = class _GSwapSDKError extends Error {
-  constructor(message, code, details) {
+  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 = (() => {
-      try {
-        return JSON.parse(bodyText);
-      } catch {
-        return void 0;
-      }
-    })();
-    const errorKey = typeof bodyJson === "object" && bodyJson && "error" in bodyJson && typeof bodyJson.error === "object" && bodyJson.error && "ErrorKey" in bodyJson.error && typeof bodyJson.error.ErrorKey === "string" ? bodyJson.error.ErrorKey : void 0;
-    const message = typeof bodyJson === "object" && bodyJson && "error" in bodyJson && typeof bodyJson.error === "object" && bodyJson.error && "Message" in bodyJson.error && typeof bodyJson.error.Message === "string" ? bodyJson.error.Message : void 0;
-    if (errorKey && message) {
-      return new _GSwapSDKError(`GalaChain Error ${errorKey} from ${url}: ${message}`, errorKey, {
-        message,
+    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,
-        status: response.status,
-        body: bodyJson,
-        url
-      });
+        { message, errorKey, status: response.status, body: bodyJson, url },
+        message
+      );
     }
     return new _GSwapSDKError(`Unexpected HTTP Error ${response.status} from ${url}`, "HTTP_ERROR", {
       status: response.status,
@@ -102,49 +173,125 @@ var GSwapSDKError = class _GSwapSDKError extends Error {
       url
     });
   }
-  static incorrectTokenOrderingError(specifiedToken0, specifiedToken1) {
-    return new _GSwapSDKError(
-      "Token ordering is incorrect. token0 should sort below token1.",
-      "INCORRECT_TOKEN_ORDERING",
-      {
-        specifiedToken0,
-        specifiedToken1
-      }
-    );
-  }
-  static transactionWaitTimeoutError(txId) {
-    return new _GSwapSDKError("Transaction wait timed out.", "TRANSACTION_WAIT_TIMEOUT", {
-      txId
-    });
-  }
-  static transactionWaitFailedError(txId, detail) {
-    const transactionHash = "transactionId" in detail && typeof detail.transactionId === "string" ? detail.transactionId : void 0;
-    const { transactionId, ...rest } = detail;
-    return new _GSwapSDKError("Transaction wait failed.", "TRANSACTION_WAIT_FAILED", {
-      txId,
-      transactionHash,
-      ...rest
-    });
+};
+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;
+}
+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;
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
   }
-  static socketConnectionRequiredError() {
-    return new _GSwapSDKError(
-      "This method requires a socket connection. Did you call connectSocket()?",
-      "SOCKET_CONNECTION_REQUIRED"
+}
+
+// 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
+};
+var ALL_FEE_TIERS = [
+  0 /* PERCENT_00_00 */,
+  500 /* PERCENT_00_05 */,
+  3e3 /* PERCENT_00_30 */,
+  1e4 /* PERCENT_01_00 */
+];
+
+// 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
+});
+var DexDecimal = import_decimal.Decimal.clone({ precision: 60 });
+function tickToSqrtPrice(tick) {
+  return new import_bignumber.default(new DexDecimal(1.0001).pow(tick / 2).toString());
+}
+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;
+}
+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;
+}
+function alignTickDown(tick, spacing) {
+  assertSpacing(spacing);
+  return Math.floor(tick / spacing) * spacing;
+}
+function alignTickUp(tick, spacing) {
+  assertSpacing(spacing);
+  return Math.ceil(tick / spacing) * 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}`
     );
   }
-  static noPoolAvailableError(tokenIn, tokenOut, fee) {
-    const message = fee !== void 0 ? `No pool available for the specified token pair at fee tier ${fee}` : "No pools available for the specified token pair";
-    return new _GSwapSDKError(message, "NO_POOL_AVAILABLE", {
-      tokenIn,
-      tokenOut,
-      fee
-    });
+  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");
+}
 
 // src/utils/validation.ts
 function validateNumericAmount(amount, parameterName, allowZero = false) {
-  const bnAmount = (0, import_bignumber.default)(amount);
+  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`,
@@ -179,10 +326,24 @@ function validateNumericAmount(amount, parameterName, allowZero = false) {
   }
 }
 function validatePriceValues(spotPrice, lowerPrice, upperPrice) {
-  const bnSpotPrice = (0, import_bignumber.default)(spotPrice);
-  const bnLowerPrice = (0, import_bignumber.default)(lowerPrice);
-  let bnUpperPrice = (0, import_bignumber.default)(upperPrice);
-  bnUpperPrice = bnUpperPrice.isFinite() ? bnUpperPrice : (0, import_bignumber.default)(1e18);
+  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",
@@ -239,26 +400,30 @@ function validateTickRange(tickLower, tickUpper) {
       }
     );
   }
-  if (tickLower < -886800 || tickUpper > 886800) {
+  if (tickLower < GC_MIN_TICK || tickUpper > GC_MAX_TICK) {
     throw new GSwapSDKError(
-      "Invalid tick range: ticks must be between -886800 and 886800",
+      `Invalid tick range: ticks must be between ${GC_MIN_TICK} and ${GC_MAX_TICK}`,
       "VALIDATION_ERROR",
       {
         type: "INVALID_TICK_BOUNDS",
         tickLower,
         tickUpper,
-        minTick: -886800,
-        maxTick: 886800
+        minTick: GC_MIN_TICK,
+        maxTick: GC_MAX_TICK
       }
     );
   }
 }
 function validateFee(fee) {
-  if (!Number.isInteger(fee) || fee < 0) {
-    throw new GSwapSDKError("Invalid fee: must be a non-negative integer", "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) {
@@ -302,6 +467,8 @@ var Assets = class {
     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.
@@ -320,408 +487,555 @@ var Assets = class {
   async getUserAssets(ownerAddress, page = 1, limit = 10) {
     validateWalletAddress(ownerAddress);
     if (!Number.isInteger(page) || page < 1) {
-      throw new Error("Invalid page: must be a positive integer");
+      throw new GSwapSDKError("Invalid page: must be a positive integer", "VALIDATION_ERROR", {
+        page
+      });
     }
     if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
-      throw new Error("Invalid limit: must be an integer between 1 and 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 {
-      tokens: json.data.token.map((token) => ({
-        ...token,
-        decimals: parseInt(token.decimals, 10)
-      })) || [],
-      count: json.data.count || 0
-    };
+    const json = await this.httpClient.sendGetRequest(
+      this.dexBackendBaseUrl,
+      "/user/assets",
+      "",
+      { address: ownerAddress, page: page.toString(), limit: limit.toString() }
+    );
+    return parseUserAssets(json);
   }
 };
-
-// src/classes/bundler.ts
-var import_crypto = __toESM(require("crypto"), 1);
-
-// src/utils/debug.ts
-var import_debug = __toESM(require("debug"), 1);
-var debugLog = (0, import_debug.default)("GSWAP_SDK");
-
-// src/classes/event_socket_client.ts
-var import_events = require("events");
-var import_socket = require("socket.io-client");
-var TradeEventEmitter = class extends import_events.EventEmitter {
-};
-var EventSocketClient = class extends TradeEventEmitter {
-  socket = null;
-  bundlerUrl;
-  constructor(bundlerUrl) {
-    super();
-    this.bundlerUrl = bundlerUrl;
-  }
-  connect() {
-    return new Promise((resolve, reject) => {
-      var _a;
-      if ((_a = this.socket) == null ? void 0 : _a.connected) {
-        resolve();
-        return;
+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
       }
-      this.socket = (0, import_socket.io)(this.bundlerUrl, {
-        transports: ["websocket"],
-        autoConnect: true
-      });
-      this.socket.on("connect", () => {
-        console.log("Connected to bundler socket:", this.bundlerUrl);
-        this.emit("connect");
-        resolve();
-      });
-      this.socket.on("connect_error", (error) => {
-        console.error("Failed to connect to bundler socket:", error);
-        this.emit("error", error);
-        reject(error);
-      });
-      this.socket.on("disconnect", (reason) => {
-        console.log("Disconnected from bundler socket:", reason);
-        this.emit("disconnect", reason);
-      });
-      this.socket.onAny((eventName, ...args) => {
-        var _a2;
-        if (typeof eventName === "string") {
-          const [responseData] = args;
-          this.emit("transaction", eventName, {
-            ...responseData,
-            transactionHash: (_a2 = responseData.data) == null ? void 0 : _a2.transactionId
-          });
-        }
-      });
-    });
+    );
   }
-  disconnect() {
-    if (this.socket) {
-      this.socket.disconnect();
-      this.socket = null;
+  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
+  };
+}
+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";
+}
+
+// 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);
   }
-  isConnected() {
-    var _a;
-    return ((_a = this.socket) == null ? void 0 : _a.connected) ?? false;
-  }
-};
+}
+async function readResponseBody(response) {
+  const text = await response.text();
+  return parseJson(text) ?? text;
+}
+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;
+}
+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;
+}
+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;
+}
+function hasHeaderGetter(headers) {
+  return "get" in headers && typeof headers.get === "function";
+}
 
-// src/classes/tx_waiter.ts
-var TransactionWaiter = class {
-  enabled = false;
-  promiseInfoForTxId = /* @__PURE__ */ new Map();
-  setEnabled(enabled) {
-    this.enabled = enabled;
-    if (!enabled) {
-      for (const [txId, promiseInfo] of this.promiseInfoForTxId.entries()) {
-        clearTimeout(promiseInfo.timeoutId);
-        promiseInfo.reject(
-          GSwapSDKError.transactionWaitFailedError(txId, {
-            message: "Transaction waiter disabled"
-          })
+// src/classes/submitted_transaction.ts
+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;
       }
-      this.promiseInfoForTxId.clear();
-    }
-  }
-  registerTxId(txId, timeoutMs) {
-    if (this.promiseInfoForTxId.has(txId)) {
-      throw new GSwapSDKError(
-        `Transaction ID is already registered`,
-        "TRANSACTION_ID_ALREADY_REGISTERED",
-        { txId }
-      );
-    }
-    if (!this.enabled) {
-      return;
-    }
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-    const timeoutId = setTimeout(() => {
-      const promiseInfo = this.promiseInfoForTxId.get(txId);
-      if (promiseInfo) {
-        if (promiseInfo.waited) {
-          promiseInfo.reject(GSwapSDKError.transactionWaitTimeoutError(txId));
-        } else {
-          promiseInfo.resolve({ txId, transactionHash: txId, Data: {} });
+      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;
+          }
         }
-        this.promiseInfoForTxId.delete(txId);
+      } else {
+        throw new GSwapSDKError(bodyMessage(body), "CONFIRMATION_FAILED", {
+          status: response.status,
+          body,
+          url
+        });
       }
-    }, timeoutMs);
-    this.promiseInfoForTxId.set(txId, {
-      promise,
-      resolve,
-      reject,
-      timeoutId,
-      waited: false
-    });
-  }
-  wait(txId) {
-    const promise = this.promiseInfoForTxId.get(txId);
-    if (!promise) {
-      throw new GSwapSDKError(
-        `Transaction ID is not registered for waiting`,
-        "TRANSACTION_ID_NOT_REGISTERED",
+      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.",
         {
-          txId
+          uniqueKey: this.uniqueKey,
+          applyTransactionId,
+          blockNumber,
+          status: response.status,
+          body,
+          url
         }
       );
     }
-    promise.waited = true;
-    return promise.promise;
+    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
+    };
   }
-  notifySuccess(txId, data) {
-    const promiseInfo = this.promiseInfoForTxId.get(txId);
-    if (!promiseInfo) {
-      return;
+  /** 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;
     }
-    clearTimeout(promiseInfo.timeoutId);
-    promiseInfo.resolve({
-      txId,
-      transactionHash: data.transactionId,
-      Data: data.Data
-    });
-    this.promiseInfoForTxId.delete(txId);
+    throw GSwapSDKError.confirmationTimeoutError(this.uniqueKey);
   }
-  notifyFailure(txId, detail) {
-    const promiseInfo = this.promiseInfoForTxId.get(txId);
-    if (!promiseInfo) {
-      return;
-    }
-    clearTimeout(promiseInfo.timeoutId);
-    if (promiseInfo.waited) {
-      promiseInfo.reject(GSwapSDKError.transactionWaitFailedError(txId, detail));
-    } else {
-      promiseInfo.resolve({ txId, transactionHash: txId, Data: {} });
+};
+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;
     }
-    this.promiseInfoForTxId.delete(txId);
+  };
+}
+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]]] : []
+      )
+    )
+  };
+}
+function malformedConfirmation(response, 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;
+}
+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");
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function jitter(milliseconds) {
+  return Math.max(0, Math.round(milliseconds * (0.9 + Math.random() * 0.2)));
+}
 
-// src/classes/events.ts
-var Events = class _Events {
-  globalSocketClient;
-  globalWaitHelper = new TransactionWaiter();
-  connectionPromise;
-  static instance = new _Events();
-  static tradeEventEmitterConstructor = EventSocketClient;
-  /**
-   * Establishes a global socket connection for real-time event streaming.
-   * This connection is shared across all service instances.
-   * @param bundlerBaseUrl - Optional bundler base URL. If not provided, uses default.
-   * @returns The connected EventSocketClient.
-   * @example
-   * ```typescript
-   * await eventsService.connectEventSocket();
-   *
-   * // Socket is now available for transaction updates
-   * ```
-   */
-  async connectEventSocket(bundlerBaseUrl) {
-    var _a;
-    if (this.connectionPromise) {
-      return this.connectionPromise;
-    }
-    if ((_a = this.globalSocketClient) == null ? void 0 : _a.isConnected()) {
-      return this.globalSocketClient;
+// src/classes/gateway.ts
+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 = bundlerBaseUrl ?? "https://bundle-backend-prod1.defi.gala.com";
-    this.connectionPromise = (async () => {
-      const client = new _Events.tradeEventEmitterConstructor(url);
-      await client.connect();
-      if (!this.globalWaitHelper) {
-        this.globalWaitHelper = new TransactionWaiter();
+    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 }
+        );
       }
-      client.on("transaction", this.internalHandleSocketMessage.bind(this));
-      return client;
-    })();
-    this.globalSocketClient = await this.connectionPromise;
-    this.connectionPromise = void 0;
-    this.globalWaitHelper.setEnabled(true);
-    return this.globalSocketClient;
-  }
-  /**
-   * Disconnects the global socket connection and cleans up resources.
-   */
-  disconnectEventSocket() {
-    if (this.globalSocketClient) {
-      this.globalSocketClient.off("transaction", this.internalHandleSocketMessage.bind(this));
-      this.globalSocketClient.disconnect();
-      this.globalSocketClient = void 0;
-      this.globalWaitHelper.setEnabled(false);
+      throw error;
     }
-  }
-  /**
-   * Checks if the global socket connection is active.
-   * @returns True if connected, false otherwise.
-   */
-  eventSocketConnected() {
-    var _a;
-    return ((_a = this.globalSocketClient) == null ? void 0 : _a.isConnected()) ?? false;
-  }
-  /**
-   * Registers a transaction ID for waiting and timeout handling.
-   * @param txId - The transaction ID to register.
-   * @param timeoutMs - Timeout in milliseconds.
-   */
-  registerTxId(txId, timeoutMs) {
-    this.globalWaitHelper.registerTxId(txId, timeoutMs);
-  }
-  /**
-   * Waits for a transaction to complete.
-   * @param txId - The transaction ID to wait for.
-   * @returns Promise that resolves when the transaction completes.
-   */
-  async wait(txId) {
-    if (!this.eventSocketConnected()) {
-      throw GSwapSDKError.socketConnectionRequiredError();
+    const body = await readResponseBody(response);
+    if (!response.ok) {
+      throw gatewayError(response, body, url);
     }
-    return this.globalWaitHelper.wait(txId);
-  }
-  /**
-   * Internal handler for socket messages.
-   * @param response - The bundler response.
-   * @param txId - The transaction ID.
-   */
-  internalHandleSocketMessage(txId, response) {
-    if (response.status === "PROCESSED") {
-      this.globalWaitHelper.notifySuccess(txId, response.data);
-    } else if (response.status === "FAILED") {
-      this.globalWaitHelper.notifyFailure(txId, response.data);
-    } else {
-      debugLog(`Unknown response status for transaction ${txId}:`, response.status);
+    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.");
     }
-  }
-};
-
-// src/classes/pending_transaction.ts
-var PendingTransaction = class {
-  constructor(transactionId, message, error, waitDelegate) {
-    this.transactionId = transactionId;
-    this.message = message;
-    this.error = error;
-    this.waitDelegate = waitDelegate;
-  }
-  /**
-   * Waits for the transaction to be confirmed.
-   * This should be called immediately after receiving the PendingTransaction
-   * to ensure proper event handling. If you delay calling this method and the
-   * transaction confirms before you call this method, an error will be thrown.
-   *
-   * @returns A promise that resolves when the transaction is confirmed.
-   */
-  wait() {
-    return this.waitDelegate();
-  }
-};
-
-// src/classes/bundler.ts
-function randomUUID() {
-  if (globalThis.crypto) {
-    return globalThis.crypto.randomUUID();
-  }
-  return import_crypto.default.randomUUID();
-}
-var Bundler = class {
-  constructor(bundlerBaseUrl, bundlingAPIBasePath, transactionWaitTimeoutMs, signer, httpClient) {
-    this.bundlerBaseUrl = bundlerBaseUrl;
-    this.bundlingAPIBasePath = bundlingAPIBasePath;
-    this.transactionWaitTimeoutMs = transactionWaitTimeoutMs;
-    this.signer = signer;
-    this.httpClient = httpClient;
-  }
-  async signObject(methodName, toSign) {
-    if (!this.signer) {
-      throw GSwapSDKError.noSignerError();
+    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);
     }
-    const withUniqueKey = {
-      ...toSign,
-      uniqueKey: toSign.uniqueKey ?? `galaswap - operation - ${randomUUID()}`
-    };
-    debugLog("Signing object for method", methodName, withUniqueKey);
-    return this.signer.signObject(methodName, withUniqueKey);
-  }
-  async sendBundlerRequest(method, body, stringsInstructions) {
-    if (!this.hasSigner()) {
-      throw GSwapSDKError.noSignerError();
+    if ("transactionId" in data && typeof rawTransactionId !== "string" || bodyBlockNumber !== void 0 && bodyBlockNumber !== null && !isBlockNumber(bodyBlockNumber)) {
+      throw invalidGatewayResponse(response, body, url, invalidModeMessage);
     }
-    const requestBody = {
-      method,
-      signedDto: await this.signObject(method, body),
-      stringsInstructions
-    };
-    debugLog("Sending bundler request", method, requestBody);
-    const response = await this.httpClient.sendPostRequest(
-      this.bundlerBaseUrl,
-      this.bundlingAPIBasePath,
-      "",
-      requestBody
-    );
-    debugLog("Received bundler response", method, response);
-    Events.instance.registerTxId(response.data, this.transactionWaitTimeoutMs);
-    const transaction = new PendingTransaction(
-      response.data,
-      response.message,
-      response.error,
-      () => {
-        return Events.instance.wait(response.data);
+    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."
+        );
       }
-    );
-    return transaction;
+    } 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 }
+    });
   }
-  hasSigner() {
-    return this.signer !== void 0;
+  /** 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 invalidGatewayResponse(response, body, url, message) {
+  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;
+}
+function isBlockNumber(value) {
+  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");
+
+// src/version.ts
+var SDK_VERSION = true ? "1.0.0-rc.3" : "1.0.0-rc.3";
 
 // src/classes/http_client.ts
 var HttpClient = class {
-  constructor(httpRequestor = fetch) {
+  /** 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) {
+  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 this.httpRequestor(url, {
-      method,
-      headers: {
-        "Content-Type": "application/json",
-        "User-Agent": "GalaChain-SDK/0.0"
+    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 }
       },
-      ...body ? { body: JSON.stringify(body) } : {}
-    });
+      this.timeoutMs
+    );
     if (!response.ok) {
       throw await GSwapSDKError.fromErrorResponse(url, response);
     }
-    const json = await response.json();
+    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);
   }
-  async sendGetRequest(baseUrl, basePath, endpoint, params) {
+  /** 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);
+    return this.sendRequest("GET", baseUrl, basePath, endpointWithParams, void 0, options);
   }
 };
 
-// src/classes/pools.ts
-var import_bignumber2 = __toESM(require("bignumber.js"), 1);
-
-// src/utils/token.ts
-function stringifyTokenClassKey(tokenClassKey, separator = "|") {
-  if (typeof tokenClassKey === "string") {
-    return tokenClassKey;
-  }
-  return `${tokenClassKey.collection}${separator}${tokenClassKey.category}${separator}${tokenClassKey.type}${separator}${tokenClassKey.additionalKey}`;
+// src/utils/ordering.ts
+function orderSymbols(a, b) {
+  return a < b ? [a, b] : [b, a];
+}
+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 });
+}
+function compositeKeyOf(token) {
+  return [token.collection, token.category, token.type, token.additionalKey].join("$");
 }
 function parseTokenClassKey(tokenClassKey) {
   if (typeof tokenClassKey === "object") {
@@ -732,12 +1046,17 @@ function parseTokenClassKey(tokenClassKey) {
       additionalKey: tokenClassKey.additionalKey
     };
   }
-  const [collection, category, type, additionalKey] = tokenClassKey.split("|");
-  if (!collection || !category || !type || !additionalKey) {
-    throw new GSwapSDKError(`Invalid token class key`, "INVALID_TOKEN_CLASS_KEY", {
-      tokenClassKey
-    });
+  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,
@@ -745,1129 +1064,1498 @@ function parseTokenClassKey(tokenClassKey) {
     additionalKey
   };
 }
-function compareTokens(first, second) {
-  return stringifyTokenClassKey(first).localeCompare(stringifyTokenClassKey(second));
-}
-function getTokenOrdering(first, second, assertCorrectness, token1Data, token2Data) {
-  const zeroForOne = compareTokens(first, second) < 0;
-  if (zeroForOne) {
-    return {
-      token0: first,
-      token1: second,
-      zeroForOne,
-      token0Attributes: token1Data,
-      token1Attributes: token2Data
-    };
-  } else {
-    if (assertCorrectness) {
-      throw GSwapSDKError.incorrectTokenOrderingError(first, second);
-    }
-    return {
-      token0: second,
-      token1: first,
-      zeroForOne,
-      token0Attributes: token2Data,
-      token1Attributes: token1Data
-    };
-  }
-}
 
 // src/classes/pools.ts
 var Pools = class {
-  constructor(gatewayBaseUrl, dexContractBasePath, httpClient) {
-    this.gatewayBaseUrl = gatewayBaseUrl;
-    this.dexContractBasePath = dexContractBasePath;
-    this.httpClient = httpClient;
+  /**
+   * 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;
   }
   /**
-   * Gets pool data for a specific token pair and fee tier.
+   * 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 getPoolData(token0, token1, fee) {
+  async getPool(token0, token1, fee) {
     validateFee(fee);
-    const token0Class = parseTokenClassKey(token0);
-    const token1Class = parseTokenClassKey(token1);
-    const ordering = getTokenOrdering(token0Class, token1Class, false);
-    const responseBody = await this.httpClient.sendPostRequest(this.gatewayBaseUrl, this.dexContractBasePath, "/GetPoolData", {
-      token0: ordering.token0,
-      token1: ordering.token1,
-      fee
-    });
-    const rawData = responseBody.Data;
-    return {
-      bitmap: rawData.bitmap,
-      fee: rawData.fee,
-      feeGrowthGlobal0: (0, import_bignumber2.default)(rawData.feeGrowthGlobal0),
-      feeGrowthGlobal1: (0, import_bignumber2.default)(rawData.feeGrowthGlobal1),
-      grossPoolLiquidity: (0, import_bignumber2.default)(rawData.grossPoolLiquidity),
-      liquidity: (0, import_bignumber2.default)(rawData.liquidity),
-      maxLiquidityPerTick: (0, import_bignumber2.default)(rawData.maxLiquidityPerTick),
-      protocolFees: rawData.protocolFees,
-      protocolFeesToken0: (0, import_bignumber2.default)(rawData.protocolFeesToken0),
-      protocolFeesToken1: (0, import_bignumber2.default)(rawData.protocolFeesToken1),
-      sqrtPrice: (0, import_bignumber2.default)(rawData.sqrtPrice),
-      tickSpacing: rawData.tickSpacing,
-      token0: rawData.token0,
-      token0ClassKey: rawData.token0ClassKey,
-      token1: rawData.token1,
-      token1ClassKey: rawData.token1ClassKey
-    };
+    return this.getBackend("/pool", await this.backendParams(token0, token1, fee));
   }
   /**
-   * Calculates the nearest valid tick value for a given price.
+   * 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);
+   * ```
    */
-  calculateTicksForPrice(price, tickSpacing) {
-    validateNumericAmount(price, "price", true);
-    validateTickSpacing(tickSpacing);
-    const priceNumber = (0, import_bignumber2.default)(price).toNumber();
-    if (priceNumber === 0) {
-      return -886800;
-    }
-    if (priceNumber === Infinity) {
-      return 886800;
-    }
-    const uncoercedTicks = Math.round(Math.log(priceNumber) / Math.log(1.0001));
-    const ticks = Math.floor(uncoercedTicks / tickSpacing) * tickSpacing;
-    return Math.min(Math.max(ticks, -886800), 886800);
-  }
-  calculatePriceForTicks(tick) {
-    if (tick === -886800) {
-      return (0, import_bignumber2.default)("0");
-    } else if (tick === 886800) {
-      return (0, import_bignumber2.default)(Infinity);
-    } else {
-      const price = Math.pow(1.0001, tick);
-      return (0, import_bignumber2.default)(price);
-    }
+  async getSlot0(token0, token1, fee) {
+    validateFee(fee);
+    return this.getBackend("/slot0", await this.backendParams(token0, token1, fee));
   }
   /**
-   * Calculates the current spot price of a pool based on sqrt price.
-   * Price is defined as the amount of outToken you would receive for 1 inToken.
+   * 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);
+   * ```
    */
-  calculateSpotPrice(inToken, outToken, poolSqrtPrice) {
-    validateNumericAmount(poolSqrtPrice, "poolSqrtPrice");
-    const ordering = getTokenOrdering(inToken, outToken, false);
-    const poolPrice = (0, import_bignumber2.default)(poolSqrtPrice).pow(2);
-    if (ordering.zeroForOne) {
-      return poolPrice;
-    } else {
-      return (0, import_bignumber2.default)(1).div(poolPrice);
+  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 });
     }
   }
 };
+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
+  });
+}
+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]));
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isOptionalNumber(value) {
+  return value === void 0 || isFiniteNumber(value);
+}
 
 // src/classes/positions.ts
 var import_bignumber3 = __toESM(require("bignumber.js"), 1);
 var Positions = class {
-  constructor(gatewayBaseUrl, dexContractBasePath, bundlerService, poolService, httpClient, options) {
-    this.gatewayBaseUrl = gatewayBaseUrl;
-    this.dexContractBasePath = dexContractBasePath;
-    this.options = options;
-    this.httpClient = httpClient;
-    this.bundlerService = bundlerService;
-    this.poolService = poolService;
+  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);
   }
-  httpClient;
-  bundlerService;
-  poolService;
+  gateway;
+  symbols;
+  signer;
+  walletAddress;
+  http;
   /**
-   * Get all liquidity positions for a specific wallet address.
-   * @param ownerAddress - The wallet address to get positions for.
-   * @param limit - Maximum number of positions to return.
-   * @param bookmark - Pagination bookmark for retrieving additional results. If you call this function and it returns a bookmark that is not an empty string, you can pass that bookmark as this parameter in a subsequent call to fetch the next page.
-   * @returns User positions and pagination bookmark
+   * 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('eth|123...abc');
-   * console.log(positions);
+   * const positions = await gSwap.positions.getUserPositions('client|012345678901234567890123');
    * ```
    */
-  async getUserPositions(ownerAddress, limit, bookmark) {
-    const results = await this.sendUserPositionsRequest("/GetUserPositions", {
-      user: ownerAddress,
-      limit,
-      bookmark
-    });
-    return {
-      bookmark: results.nextBookMark,
-      positions: results.positions
-    };
+  async getUserPositions(owner) {
+    const response = await this.get("/positions", { user: owner });
+    return response.data.map((position) => this.mapPosition(position));
   }
   /**
-   * Gets detailed information about a specific liquidity position.
-   * @param ownerAddress - The wallet address that owns the position.
-   * @param position - Position parameters including tokens, fee, and tick range.
-   * @param position.token0ClassKey - The first token in the position.
-   * @param position.token1ClassKey - The second token in the position.
-   * @param position.fee - The pool fee tier.
-   * @param position.tickLower - The lower tick of the position range.
-   * @param position.tickUpper - The upper tick of the position range.
-   * @returns Detailed position information.
+   * 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('eth|123...abc', {
-   *   token0ClassKey: 'GALA|Unit|none|none',
-   *   token1ClassKey: 'GUSDC|Unit|none|none',
-   *   fee: 500,
-   *   tickLower: -6000,
-   *   tickUpper: 6000
+   * const position = await gSwap.positions.getPosition({
+   *   token0: 'GALA', token1: 'GUSDC', owner: 'client|012345678901234567890123',
+   *   fee: 3000, tickLower: -19200, tickUpper: 12000,
    * });
-   * console.log('Position:', position);
    * ```
    */
-  async getPosition(ownerAddress, position) {
-    const result = await this.sendPositionRequest("/GetPositions", {
-      owner: ownerAddress,
-      token0: parseTokenClassKey(position.token0ClassKey),
-      token1: parseTokenClassKey(position.token1ClassKey),
-      fee: position.fee,
-      tickLower: position.tickLower,
-      tickUpper: position.tickUpper
-    });
-    return result;
+  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 token amounts that would be received from removing liquidity from a position.
-   * @param args - Parameters for estimating liquidity removal.
-   * @param args.ownerAddress - The wallet address that owns the position.
-   * @param args.positionId - The position identifier.
-   * @param args.token0 - The first token in the pair.
-   * @param args.token1 - The second token in the pair.
-   * @param args.fee - The pool fee tier.
-   * @param args.tickLower - The lower tick of the position range.
-   * @param args.tickUpper - The upper tick of the position range.
-   * @param args.amount - The amount of liquidity to remove.
-   * @returns Estimated token amounts that would be received.
+   * 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 estimation = await gSwap.positions.estimateRemoveLiquidity({
-   *   ownerAddress: 'client|635f048ab243d7eb7f5ba044',
-   *   positionId: '210f8e4dd1bbe1b4af4b977330ee7e4b68bc716f66e39c87a60fff0976ded3ea',
-   *   token0: 'GALA|Unit|none|none',
-   *   token1: 'GUSDT|Unit|none|none',
-   *   fee: 3000,
-   *   tickLower: -41100,
-   *   tickUpper: -40080,
-   *   amount: '1491.973332758921980256'
+   * const estimate = await gSwap.positions.estimateAddLiquidity({
+   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+   *   tickLower: -19200, tickUpper: 12000, amount: '100', amountIsToken0: true,
    * });
-   * console.log('Estimated tokens:', estimation);
    * ```
    */
-  async estimateRemoveLiquidity(args) {
-    validateWalletAddress(args.ownerAddress);
-    validateFee(args.fee);
-    validateTickRange(args.tickLower, args.tickUpper);
+  async estimateAddLiquidity(args) {
     validateNumericAmount(args.amount, "amount");
-    const token0TokenClassKey = parseTokenClassKey(args.token0);
-    const token1TokenClassKey = parseTokenClassKey(args.token1);
-    const ordering = getTokenOrdering(token0TokenClassKey, token1TokenClassKey, false);
-    const responseBody = await this.httpClient.sendPostRequest(this.gatewayBaseUrl, this.dexContractBasePath, "/GetRemoveLiquidityEstimation", {
-      tickLower: args.tickLower,
-      tickUpper: args.tickUpper,
-      amount: (0, import_bignumber3.default)(args.amount).toFixed(),
-      token0: ordering.token0,
-      token1: ordering.token1,
-      fee: args.fee,
-      owner: args.ownerAddress,
-      positionId: args.positionId
+    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 {
-      amount0: (0, import_bignumber3.default)(responseBody.Data.amount0),
-      amount1: (0, import_bignumber3.default)(responseBody.Data.amount1)
-    };
+    return response.data;
   }
   /**
-   * Gets detailed information about a liquidity position by its ID.
-   * @param ownerAddress - The wallet address that owns the position.
-   * @param positionId - The unique identifier of the position.
-   * @returns Detailed position information, or undefined if not found.
+   * 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 position = await gSwap.positions.getPositionById('eth|123...abc', 'position-uuid-123');
-   * if (position) {
-   *   console.log('Position found:', position);
-   * } else {
-   *   console.log('Position not found');
-   * }
+   * const estimate = await gSwap.positions.estimateRemoveLiquidity({
+   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+   *   tickLower: -19200, tickUpper: 12000, liquidity: '1000',
+   * });
    * ```
    */
-  async getPositionById(ownerAddress, positionId) {
-    const userPositions = await this.getUserPositions(ownerAddress);
-    const position = userPositions.positions.find((pos) => pos.positionId === positionId);
-    if (!position) {
-      return void 0;
-    }
-    return this.getPosition(ownerAddress, position);
+  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;
   }
   /**
-   * Creates a new position or adds liquidity to a position, using a specific tick range. Consider using `addLiquidityByPrice()` instead unless you want to use ticks directly.
-   * @param args - Parameters for adding liquidity.
-   * @param args.walletAddress - The wallet address adding liquidity.
-   * @param args.positionId - The position identifier. If you're creating a new position, this should be an empty string.
-   * @param args.token0 - The first token in the pair.
-   * @param args.token1 - The second token in the pair.
-   * @param args.fee - The pool fee tier.
-   * @param args.tickLower - The lower tick of the position range.
-   * @param args.tickUpper - The upper tick of the position range.
-   * @param args.amount0Desired - Desired (also maximum) amount of token0 to add.
-   * @param args.amount1Desired - Desired (also maximum) amount of token1 to add.
-   * @param args.amount0Min - Minimum amount of token0 to add (slippage protection).
-   * @param args.amount1Min - Minimum amount of token1 to add (slippage protection).
-   * @returns Pending transaction.
+   * 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 result = await gSwap.positions.addLiquidityByTicks({
-   *   walletAddress: 'eth|123...abc',
-   *   positionId: '',
-   *   token0: 'GALA|Unit|none|none',
-   *   token1: 'GUSDC|Unit|none|none',
-   *   fee: 500,
-   *   tickSpacing: 10,
-   *   tickLower: -6000,
-   *   tickUpper: 6000,
-   *   amount0Desired: '100',
-   *   amount1Desired: '50',
-   *   amount0Min: '95',
-   *   amount1Min: '47.5'
+   * const tx = await gSwap.positions.addLiquidityByTicks({
+   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+   *   tickLower: -19200, tickUpper: 12000, amount: '100', amountIsToken0: true,
    * });
-   * console.log('Liquidity added:', result);
+   * await tx.confirm();
    * ```
    */
   async addLiquidityByTicks(args) {
-    var _a;
-    const walletAddress = args.walletAddress ?? ((_a = this.options) == null ? void 0 : _a.walletAddress);
-    validateWalletAddress(walletAddress);
     validateFee(args.fee);
-    validateTickRange(args.tickLower, args.tickUpper);
-    validateNumericAmount(args.amount0Desired, "amount0Desired", true);
-    validateNumericAmount(args.amount1Desired, "amount1Desired", true);
-    validateNumericAmount(args.amount0Min, "amount0Min", true);
-    validateNumericAmount(args.amount1Min, "amount1Min", true);
-    const token0TokenClassKey = parseTokenClassKey(args.token0);
-    const token1TokenClassKey = parseTokenClassKey(args.token1);
-    const ordering = getTokenOrdering(
-      token0TokenClassKey,
-      token1TokenClassKey,
-      true,
-      [args.amount0Desired, args.amount0Min],
-      [args.amount1Desired, args.amount1Min]
-    );
-    const toSign = {
-      token0: ordering.token0,
-      token1: ordering.token1,
+    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,
-      owner: args.walletAddress,
-      tickLower: args.tickLower,
-      tickUpper: args.tickUpper,
-      amount0Desired: (0, import_bignumber3.default)(ordering.token0Attributes[0]).toFixed(),
-      amount1Desired: (0, import_bignumber3.default)(ordering.token1Attributes[0]).toFixed(),
-      amount0Min: (0, import_bignumber3.default)(ordering.token0Attributes[1]).toFixed(),
-      amount1Min: (0, import_bignumber3.default)(ordering.token1Attributes[1]).toFixed(),
-      positionId: args.positionId,
-      liquidityProvider: args.walletAddress
+      tickLower: ticks.tickLower,
+      tickUpper: ticks.tickUpper,
+      uniqueKey: this.uniqueKey(),
+      ...pair.flipped !== args.amountIsToken0 ? { depositQuantityToken0: amount } : { depositQuantityToken1: amount }
     };
-    const token0StringKey = stringifyTokenClassKey(ordering.token0, "$");
-    const token1StringKey = stringifyTokenClassKey(ordering.token1, "$");
-    const poolString = `$pool$${token0StringKey}$${token1StringKey}$${args.fee}`;
-    const userPositionString = `$userPosition$${args.walletAddress}`;
-    const tokenBalance0 = `$tokenBalance$${token0StringKey}$${args.walletAddress}`;
-    const tokenBalance1 = `$tokenBalance$${token1StringKey}$${args.walletAddress}`;
-    const tokenBalance0Pool = `$tokenBalance$${token0StringKey}$${poolString}`;
-    const tokenBalance1Pool = `$tokenBalance$${token1StringKey}$${poolString}`;
-    const stringsInstructions = [
-      poolString,
-      userPositionString,
-      tokenBalance0,
-      tokenBalance1,
-      tokenBalance0Pool,
-      tokenBalance1Pool
-    ];
-    return this.bundlerService.sendBundlerRequest("AddLiquidity", toSign, stringsInstructions);
+    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
+      }
+    });
   }
   /**
-   * Creates a new position or adds liquidity to a position, using a specified price range. Note that this method automatically converts your minPrice and maxPrice to ticks, rounding down if necessary.
-   * @param args - Parameters for adding liquidity.
-   * @param args.walletAddress - The wallet address adding liquidity.
-   * @param args.positionId - The position identifier. This should be an empty string if you are creating a new position.
-   * @param args.token0 - The first token in the pair.
-   * @param args.token1 - The second token in the pair.
-   * @param args.fee - The pool fee tier.
-   * @param args.tickSpacing - The tick spacing for the pool.
-   * @param args.minPrice - The minimum price for the position range.
-   * @param args.maxPrice - The maximum price for the position range.
-   * @param args.amount0Desired - Desired (also maximum) amount of token0 to add.
-   * @param args.amount1Desired - Desired (also maximum) amount of token1 to add.
-   * @param args.amount0Min - Minimum amount of token0 to add (slippage protection).
-   * @param args.amount1Min - Minimum amount of token1 to add (slippage protection).
-   * @returns Pending transaction.
+   * 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 result = await gSwap.positions.addLiquidityByPrice({
-   *   walletAddress: 'eth|123...abc',
-   *   positionId: '',
-   *   token0: 'GALA|Unit|none|none',
-   *   token1: 'GUSDC|Unit|none|none',
-   *   fee: 500,
-   *   tickSpacing: 10,
-   *   minPrice: '0.45',
-   *   maxPrice: '0.55',
-   *   amount0Desired: '100',
-   *   amount1Desired: '50',
-   *   amount0Min: '95',
-   *   amount1Min: '47.5'
+   * const tx = await gSwap.positions.addLiquidityByPrice({
+   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+   *   minPrice: '0.14', maxPrice: '0.16', amount: '100', amountIsToken0: true,
    * });
-   * console.log('Liquidity added with price range:', result);
    * ```
    */
   async addLiquidityByPrice(args) {
-    var _a, _b, _c, _d, _e;
-    const walletAddress = args.walletAddress ?? ((_a = this.options) == null ? void 0 : _a.walletAddress);
-    validateWalletAddress(walletAddress);
     validateFee(args.fee);
-    validateTickSpacing(args.tickSpacing);
-    validateNumericAmount(args.minPrice, "minPrice", true);
-    validateNumericAmount(args.maxPrice, "maxPrice");
-    validateNumericAmount(args.amount0Desired, "amount0Desired", true);
-    validateNumericAmount(args.amount1Desired, "amount1Desired", true);
-    validateNumericAmount(args.amount0Min, "amount0Min", true);
-    validateNumericAmount(args.amount1Min, "amount1Min", true);
-    if ((0, import_bignumber3.default)(args.minPrice).isGreaterThan((0, import_bignumber3.default)(args.maxPrice))) {
-      throw new Error("Invalid price range: minPrice must be less than or equal to maxPrice");
+    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");
     }
-    const token0TokenClassKey = parseTokenClassKey(args.token0);
-    const token1TokenClassKey = parseTokenClassKey(args.token1);
-    const ordering = getTokenOrdering(
-      token0TokenClassKey,
-      token1TokenClassKey,
-      true,
-      [args.amount0Desired, args.amount0Min],
-      [args.amount1Desired, args.amount1Min]
-    );
-    const minPriceTicks = this.poolService.calculateTicksForPrice(args.minPrice, args.tickSpacing);
-    const maxPriceTicks = this.poolService.calculateTicksForPrice(args.maxPrice, args.tickSpacing);
-    const tickLower = ordering.zeroForOne ? minPriceTicks : maxPriceTicks * -1;
-    const tickUpper = ordering.zeroForOne ? maxPriceTicks : minPriceTicks * -1;
-    const toSign = {
-      token0: ordering.token0,
-      token1: ordering.token1,
+    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,
-      owner: args.walletAddress,
       tickLower,
       tickUpper,
-      amount0Desired: (_b = ordering == null ? void 0 : ordering.token0Attributes) == null ? void 0 : _b[0],
-      amount1Desired: (_c = ordering == null ? void 0 : ordering.token1Attributes) == null ? void 0 : _c[0],
-      amount0Min: (_d = ordering == null ? void 0 : ordering.token0Attributes) == null ? void 0 : _d[1],
-      amount1Min: (_e = ordering == null ? void 0 : ordering.token1Attributes) == null ? void 0 : _e[1],
-      positionId: args.positionId
-    };
-    const token0StringKey = stringifyTokenClassKey(ordering.token0, "$");
-    const token1StringKey = stringifyTokenClassKey(ordering.token1, "$");
-    const poolString = `$pool$${token0StringKey}$${token1StringKey}$${args.fee}`;
-    const userPositionString = `$userPosition$${args.walletAddress}`;
-    const tokenBalance0 = `$tokenBalance$${token0StringKey}$${args.walletAddress}`;
-    const tokenBalance1 = `$tokenBalance$${token1StringKey}$${args.walletAddress}`;
-    const tokenBalance0Pool = `$tokenBalance$${token0StringKey}$${poolString}`;
-    const tokenBalance1Pool = `$tokenBalance$${token1StringKey}$${poolString}`;
-    const stringsInstructions = [
-      poolString,
-      userPositionString,
-      tokenBalance0,
-      tokenBalance1,
-      tokenBalance0Pool,
-      tokenBalance1Pool
-    ];
-    return this.bundlerService.sendBundlerRequest("AddLiquidity", toSign, stringsInstructions);
+      amount: args.amount,
+      amountIsToken0: args.amountIsToken0
+    });
   }
   /**
-   * Removes liquidity from a position.
-   * @param args - Parameters for removing liquidity.
-   * @param args.walletAddress - The wallet address removing liquidity.
-   * @param args.positionId - The position identifier.
-   * @param args.token0 - The first token in the pair.
-   * @param args.token1 - The second token in the pair.
-   * @param args.fee - The pool fee tier.
-   * @param args.tickLower - The lower tick of the position range.
-   * @param args.tickUpper - The upper tick of the position range.
-   * @param args.amount - The amount of liquidity to remove.
-   * @param args.amount0Min - Minimum amount of token0 to receive (slippage protection, optional).
-   * @param args.amount1Min - Minimum amount of token1 to receive (slippage protection, optional).
-   * @returns Pending transaction.
+   * 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
-   * // Remove 50% of liquidity from a position
-   * const result = await gSwap.positions.removeLiquidity({
-   *   walletAddress: 'eth|123...abc',
-   *   positionId: 'position-123',
-   *   token0: 'GALA|Unit|none|none',
-   *   token1: 'GUSDC|Unit|none|none',
-   *   fee: 500,
-   *   tickLower: -6000,
-   *   tickUpper: 6000,
-   *   amount: '50000000000000000000', // 50% of position liquidity
-   *   amount0Min: '45',
-   *   amount1Min: '22'
+   * const tx = await gSwap.positions.removeLiquidity({
+   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+   *   tickLower: -19200, tickUpper: 12000,
    * });
-   * console.log('Liquidity removed:', result);
    * ```
    */
   async removeLiquidity(args) {
-    var _a, _b, _c;
-    const walletAddress = args.walletAddress ?? ((_a = this.options) == null ? void 0 : _a.walletAddress);
-    validateWalletAddress(walletAddress);
     validateFee(args.fee);
-    validateTickRange(args.tickLower, args.tickUpper);
-    validateNumericAmount(args.amount, "amount");
-    if (args.amount0Min !== void 0) {
-      validateNumericAmount(args.amount0Min, "amount0Min", true);
+    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.amount1Min !== void 0) {
-      validateNumericAmount(args.amount1Min, "amount1Min", true);
-    }
-    const token0TokenClassKey = parseTokenClassKey(args.token0);
-    const token1TokenClassKey = parseTokenClassKey(args.token1);
-    const ordering = getTokenOrdering(
-      token0TokenClassKey,
-      token1TokenClassKey,
-      true,
-      [args.amount0Min ?? 0],
-      [args.amount1Min ?? 0]
-    );
-    const toSign = {
-      token0: ordering.token0,
-      token1: ordering.token1,
+    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: args.tickLower,
-      tickUpper: args.tickUpper,
-      amount: (0, import_bignumber3.default)(args.amount).toFixed(),
-      amount0Min: ((_b = ordering == null ? void 0 : ordering.token0Attributes) == null ? void 0 : _b[0]) || "0",
-      amount1Min: ((_c = ordering == null ? void 0 : ordering.token1Attributes) == null ? void 0 : _c[0]) || "0",
-      positionId: args.positionId,
-      recipient: args.walletAddress
+      tickLower: ticks.tickLower,
+      tickUpper: ticks.tickUpper,
+      uniqueKey: this.uniqueKey(),
+      ...withdrawal
     };
-    const token0StringKey = stringifyTokenClassKey(ordering.token0, "$");
-    const token1StringKey = stringifyTokenClassKey(ordering.token1, "$");
-    const poolString = `$pool$${token0StringKey}$${token1StringKey}$${args.fee}`;
-    const userPositionString = `$userPosition$${args.walletAddress}`;
-    const tokenBalance0 = `$tokenBalance$${token0StringKey}$${args.walletAddress}`;
-    const tokenBalance1 = `$tokenBalance$${token1StringKey}$${args.walletAddress}`;
-    const tokenBalance0Pool = `$tokenBalance$${token0StringKey}$${poolString}`;
-    const tokenBalance1Pool = `$tokenBalance$${token1StringKey}$${poolString}`;
-    const stringsInstructions = [
-      poolString,
-      userPositionString,
-      tokenBalance0,
-      tokenBalance1,
-      tokenBalance0Pool,
-      tokenBalance1Pool
-    ];
-    return this.bundlerService.sendBundlerRequest("RemoveLiquidity", toSign, stringsInstructions);
+    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 accumulated fees from a liquidity position.
-   * @param args - Parameters for collecting fees.
-   * @param args.walletAddress - The wallet address collecting fees.
-   * @param args.positionId - The position identifier.
-   * @param args.token0 - The first token in the pair.
-   * @param args.token1 - The second token in the pair.
-   * @param args.fee - The pool fee tier.
-   * @param args.tickLower - The lower tick of the position range.
-   * @param args.tickUpper - The upper tick of the position range.
-   * @param args.amount0Requested - Desired amount of token0 fees to collect.
-   * @param args.amount1Requested - Desired amount of token1 fees to collect.
-   * @returns Pending transaction.
+   * 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
-   * // Collect all accumulated fees from a position
-   * const result = await gSwap.positions.collectPositionFees({
-   *   walletAddress: 'eth|123...abc',
-   *   positionId: 'position-123',
-   *   token0: 'GALA|Unit|none|none',
-   *   token1: 'GUSDC|Unit|none|none',
-   *   fee: 500,
-   *   tickLower: -6000,
-   *   tickUpper: 6000,
-   *   amount0Requested: '1000000000000000000', // Max fees available
-   *   amount1Requested: '500000000' // Max fees available
+   * const tx = await gSwap.positions.collectPositionFees({
+   *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+   *   tickLower: -19200, tickUpper: 12000,
    * });
-   * console.log('Fees collected:', result);
    * ```
    */
   async collectPositionFees(args) {
-    var _a;
-    const walletAddress = args.walletAddress ?? ((_a = this.options) == null ? void 0 : _a.walletAddress);
-    validateWalletAddress(walletAddress);
     validateFee(args.fee);
-    validateTickRange(args.tickLower, args.tickUpper);
-    validateNumericAmount(args.amount0Requested, "amount0Requested", true);
-    validateNumericAmount(args.amount1Requested, "amount1Requested", true);
-    const token0TokenClassKey = parseTokenClassKey(args.token0);
-    const token1TokenClassKey = parseTokenClassKey(args.token1);
-    const ordering = getTokenOrdering(
-      token0TokenClassKey,
-      token1TokenClassKey,
-      true,
-      [args.amount0Requested],
-      [args.amount1Requested]
-    );
-    const toSign = {
-      token0: ordering.token0,
-      token1: ordering.token1,
+    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,
-      amount0Requested: (0, import_bignumber3.default)(ordering.token0Attributes[0]).toFixed(),
-      amount1Requested: (0, import_bignumber3.default)(ordering.token1Attributes[0]).toFixed(),
-      tickLower: args.tickLower,
-      tickUpper: args.tickUpper,
-      positionId: args.positionId,
-      recipient: args.walletAddress
+      tickLower: ticks.tickLower,
+      tickUpper: ticks.tickUpper,
+      uniqueKey: this.uniqueKey()
     };
-    const token0StringKey = stringifyTokenClassKey(ordering.token0, "$");
-    const token1StringKey = stringifyTokenClassKey(ordering.token1, "$");
-    const poolString = `$pool$${token0StringKey}$${token1StringKey}$${args.fee}`;
-    const userPositionString = `$userPosition$${args.walletAddress}`;
-    const tokenBalance0 = `$tokenBalance$${token0StringKey}$${args.walletAddress}`;
-    const tokenBalance1 = `$tokenBalance$${token1StringKey}$${args.walletAddress}`;
-    const tokenBalance0Pool = `$tokenBalance$${token0StringKey}$${poolString}`;
-    const tokenBalance1Pool = `$tokenBalance$${token1StringKey}$${poolString}`;
-    const stringsInstructions = [
-      poolString,
-      userPositionString,
-      tokenBalance0,
-      tokenBalance1,
-      tokenBalance0Pool,
-      tokenBalance1Pool
-    ];
-    return this.bundlerService.sendBundlerRequest(
-      "CollectPositionFees",
-      toSign,
-      stringsInstructions
-    );
+    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
+      }
+    });
   }
-  calculateOptimalPositionSize(tokenAmount, spotPrice, lowerPrice, upperPrice, tokenDecimals, otherTokenDecimals) {
-    validateNumericAmount(tokenAmount, "tokenAmount");
-    validatePriceValues(spotPrice, lowerPrice, upperPrice);
-    validateTokenDecimals(tokenDecimals, "tokenDecimals");
-    validateTokenDecimals(otherTokenDecimals, "otherTokenDecimals");
-    const bnTokenAmount = (0, import_bignumber3.default)(tokenAmount);
-    const bnSpotPrice = (0, import_bignumber3.default)(spotPrice);
-    const bnLowerPrice = (0, import_bignumber3.default)(lowerPrice);
-    let bnUpperPrice = (0, import_bignumber3.default)(upperPrice);
-    bnUpperPrice = bnUpperPrice.isFinite() ? bnUpperPrice : (0, import_bignumber3.default)(1e18);
-    const liquidityAmount = bnTokenAmount.times(10 ** (tokenDecimals - otherTokenDecimals)).times(bnSpotPrice.sqrt()).times(bnUpperPrice.sqrt()).div(bnUpperPrice.sqrt().minus(bnSpotPrice.sqrt()));
-    const yAmount = (0, import_bignumber3.default)(liquidityAmount).times(bnSpotPrice.sqrt().minus(bnLowerPrice.sqrt()));
-    const untruncated = yAmount.div((0, import_bignumber3.default)(10).pow(tokenDecimals - otherTokenDecimals));
-    return import_bignumber3.default.max(
-      (0, import_bignumber3.default)(untruncated.toFixed(otherTokenDecimals, import_bignumber3.default.ROUND_DOWN)),
-      0
-    );
+  /**
+   * 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 sendUserPositionsRequest(endpoint, body) {
-    const responseBody = await this.httpClient.sendPostRequest(this.gatewayBaseUrl, this.dexContractBasePath, endpoint, body);
-    return {
-      nextBookMark: responseBody.Data.nextBookMark,
-      positions: responseBody.Data.positions.map((position) => ({
-        ...position,
-        liquidity: (0, import_bignumber3.default)(position.liquidity)
-      }))
+  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 sendPositionRequest(endpoint, body) {
-    const responseBody = await this.httpClient.sendPostRequest(this.gatewayBaseUrl, this.dexContractBasePath, endpoint, body);
+  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 {
-      ...responseBody.Data,
-      feeGrowthInside0Last: (0, import_bignumber3.default)(responseBody.Data.feeGrowthInside0Last),
-      feeGrowthInside1Last: (0, import_bignumber3.default)(responseBody.Data.feeGrowthInside1Last),
-      liquidity: (0, import_bignumber3.default)(responseBody.Data.liquidity),
-      tokensOwed0: (0, import_bignumber3.default)(responseBody.Data.tokensOwed0),
-      tokensOwed1: (0, import_bignumber3.default)(responseBody.Data.tokensOwed1)
+      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;
+    }
+  }
 };
 
 // src/classes/quoting.ts
 var import_bignumber4 = __toESM(require("bignumber.js"), 1);
-
-// src/types/fees.ts
-var FEE_TIER = /* @__PURE__ */ ((FEE_TIER2) => {
-  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 || {});
-
-// src/classes/quoting.ts
 var Quoting = class {
-  constructor(gatewayBaseUrl, dexContractBasePath, httpClient) {
-    this.gatewayBaseUrl = gatewayBaseUrl;
-    this.dexContractBasePath = dexContractBasePath;
-    this.httpClient = httpClient ?? new HttpClient();
+  /**
+   * 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;
   }
-  httpClient;
+  dexBackendBaseUrl;
+  http;
+  symbols;
   /**
-   * Gets a quote for an exact amount of token being sold.
-   * @param tokenIn - The input token to sell.
-   * @param tokenOut - The output token to buy.
-   * @param amountIn - The exact amount of input tokens you want to sell.
-   * @param fee - The pool fee tier. If not specified, will check all available fee tiers and return the best quote.
-   * @returns The expected number of tokens you will receive (buy) when/if you execute the swap.
+   * 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");
-    if (fee !== void 0) {
-      const result = await this.getSingleQuoteExactInput(tokenIn, tokenOut, fee, amountIn);
-      return result;
-    }
-    const allFees = [500 /* PERCENT_00_05 */, 3e3 /* PERCENT_00_30 */, 1e4 /* PERCENT_01_00 */];
-    const quotePromises = allFees.map(async (feeTier) => {
-      try {
-        return await this.getSingleQuoteExactInput(tokenIn, tokenOut, feeTier, amountIn);
-      } catch (err) {
-        if (err instanceof GSwapSDKError && (err.code === "CONFLICT" || err.code === "OBJECT_NOT_FOUND")) {
-          return void 0;
-        }
-        throw err;
-      }
-    });
-    const results = await Promise.all(quotePromises);
-    const quotes = results.filter((quote) => quote !== void 0);
-    if (quotes.length === 0) {
-      throw GSwapSDKError.noPoolAvailableError(tokenIn, tokenOut);
-    }
-    return quotes.reduce(
-      (best, current) => current.outTokenAmount.isGreaterThan(best.outTokenAmount) ? current : best
-    );
+    return this.quote(tokenIn, tokenOut, { amountIn: toDecimalString(amountIn) }, fee);
   }
   /**
-   * Gets a quote for an exact amount of tokens being bought.
-   * @param tokenIn - The input token sell.
-   * @param tokenOut - The output token to buy.
-   * @param amountOut - The exact amount of output tokens you want to buy.
-   * @param fee - The pool fee tier. If not specified, will check all available fee tiers and return the best quote.
-   * @returns The expected number of tokens you will need to sell (input) to receive the specified amount of output tokens.
+   * 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");
-    if (fee !== void 0) {
-      const result = await this.getSingleQuoteExactOutput(tokenIn, tokenOut, amountOut, fee);
-      return result;
-    }
-    const allFees = [500 /* PERCENT_00_05 */, 3e3 /* PERCENT_00_30 */, 1e4 /* PERCENT_01_00 */];
-    const quotePromises = allFees.map(async (feeTier) => {
-      try {
-        return await this.getSingleQuoteExactOutput(tokenIn, tokenOut, amountOut, feeTier);
-      } catch (err) {
-        if (err instanceof GSwapSDKError && (err.code === "CONFLICT" || err.code === "OBJECT_NOT_FOUND")) {
-          return void 0;
-        }
-        throw err;
-      }
-    });
-    const results = await Promise.all(quotePromises);
-    const quotes = results.filter((quote) => quote !== void 0);
-    if (quotes.length === 0) {
-      throw GSwapSDKError.noPoolAvailableError(tokenIn, tokenOut);
+    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);
     }
-    return quotes.reduce(
-      (best, current) => current.inTokenAmount.isLessThan(best.inTokenAmount) ? current : best
-    );
   }
-  async getSingleQuote(tokenIn, tokenOut, fee, amount, isExactInput) {
-    const tokenInClass = parseTokenClassKey(tokenIn);
-    const tokenOutClass = parseTokenClassKey(tokenOut);
-    const ordering = getTokenOrdering(tokenInClass, tokenOutClass, false);
-    const formattedAmount = isExactInput ? (0, import_bignumber4.default)(amount).toFixed() : (0, import_bignumber4.default)(amount).multipliedBy(-1).toFixed();
-    const response = await this.sendQuoteRequest("/QuoteExactAmount", {
-      ...ordering,
-      fee,
-      amount: formattedAmount
+};
+function mapQuote(value) {
+  if (!isQuoteWire(value)) {
+    throw new GSwapSDKError("Backend returned an invalid quote.", "INVALID_CHAIN_RESPONSE", {
+      data: value
     });
-    const tokenInAmount = ordering.zeroForOne ? response.amount0 : response.amount1;
-    const tokenOutAmount = ordering.zeroForOne ? response.amount1 : response.amount0;
-    let currentPrice = response.currentSqrtPrice.pow(2);
-    let newPrice = response.newSqrtPrice.pow(2);
-    if (!ordering.zeroForOne) {
-      currentPrice = (0, import_bignumber4.default)(1).dividedBy(currentPrice);
-      newPrice = (0, import_bignumber4.default)(1).dividedBy(newPrice);
+  }
+  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 });
+function orientPrice(sqrtPrice, tokenInIsToken0) {
+  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);
+}
+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;
+  }
+}
+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);
     }
-    const priceImpact = newPrice.minus(currentPrice).dividedBy(currentPrice);
-    return {
-      amount0: response.amount0,
-      amount1: response.amount1,
-      currentPoolSqrtPrice: response.currentSqrtPrice,
-      newPoolSqrtPrice: response.newSqrtPrice,
-      currentPrice,
-      newPrice,
-      inTokenAmount: tokenInAmount.abs(),
-      outTokenAmount: tokenOutAmount.abs(),
-      priceImpact,
-      feeTier: 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;
+}
+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;
+}
+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 });
   }
-  async getSingleQuoteExactInput(tokenIn, tokenOut, fee, amountIn) {
-    return this.getSingleQuote(tokenIn, tokenOut, fee, amountIn, true);
+}
+function toDecimalString(amount) {
+  return new import_bignumber4.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
+  });
+}
+
+// src/classes/symbols.ts
+var SYMBOL_CACHE_TTL_MS = 6e4;
+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;
   }
-  async getSingleQuoteExactOutput(tokenIn, tokenOut, amountOut, fee) {
-    return this.getSingleQuote(tokenIn, tokenOut, fee, amountOut, false);
+  /** Invalidate the cached symbol registry after a write changes registration state.
+   *
+   * @example
+   * ```ts
+   * gSwap.symbols.invalidate();
+   * ```
+   */
+  invalidate() {
+    this.cachedSymbols = void 0;
+    this.cachedAt = 0;
   }
-  async sendQuoteRequest(endpoint, body) {
-    const response = await this.httpClient.sendPostRequest(
-      this.gatewayBaseUrl,
-      this.dexContractBasePath,
-      endpoint,
-      body
+  /** 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
     );
-    const responseBody = response;
+    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 {
-      amount0: (0, import_bignumber4.default)(responseBody.Data.amount0),
-      amount1: (0, import_bignumber4.default)(responseBody.Data.amount1),
-      currentSqrtPrice: (0, import_bignumber4.default)(responseBody.Data.currentSqrtPrice),
-      newSqrtPrice: (0, import_bignumber4.default)(responseBody.Data.newSqrtPrice)
+      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;
+}
+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;
+}
+function isCompositeKey(ref) {
+  return ref.includes("|") || ref.includes("$");
+}
 
 // src/classes/swaps.ts
 var import_bignumber5 = __toESM(require("bignumber.js"), 1);
-var MIN_SQRT_PRICE_LIMIT = "0.000000000000000000094212147";
-var MAX_SQRT_PRICE_LIMIT = "18446050999999999999";
+var UNIQUE_KEY_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/u;
 var Swaps = class {
-  constructor(bundlerService, options) {
-    this.bundlerService = bundlerService;
-    this.options = options;
+  /**
+   * 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;
   /**
-   * Executes a token swap transaction.
-   * @param walletAddress - The wallet address executing the swap.
-   * @param tokenIn - The input token to sell.
-   * @param tokenOut - The output token to buy.
-   * @param fee - The pool fee tier.
-   * @param amount - Swap parameters specifying either exact input or exact output.
-   * @param amount.exactIn - For exact input swaps, the exact amount of input tokens to sell.
-   * @param amount.amountOutMinimum - For exact input swaps, the minimum amount of output tokens to buy (slippage protection).
-   * @param amount.exactOut - For exact output swaps, the exact amount of output tokens to buy.
-   * @param amount.amountInMaximum - For exact output swaps, the maximum amount of input tokens to sell (slippage protection).
-   * @returns Pending transaction.
+   * 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
-   * ```typescript
-   * // Exact input swap: sell 100 GALA for USDC
-   * const result = await swapsService.swap(
-   *   'GALA|Unit|none|none',
-   *   'GUSDC|Unit|none|none',
-   *   500,
-   *   { exactIn: '100', amountOutMinimum: '45' },
-   *   'eth|123...abc', // your wallet address
-   * );
-   * console.log('Swap successful:', result);
+   * ```ts
+   * const submitted = await swaps.swap('GALA', 'GUSDC', 3000, {
+   *   exactIn: '100',
+   *   amountOutMinimum: '14',
+   * });
    * ```
    */
-  async swap(tokenIn, tokenOut, fee, amount, walletAddress) {
-    var _a, _b;
-    walletAddress = walletAddress ?? ((_a = this.options) == null ? void 0 : _a.walletAddress);
-    validateWalletAddress(walletAddress);
+  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) {
-      validateNumericAmount(amount.exactIn, "exactIn");
+      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 {
-      validateNumericAmount(amount.exactOut, "exactOut");
+      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");
+        validateNumericAmount(amount.amountInMaximum, "amountInMaximum", true);
+        dto["amountInMaximum"] = toDecimalString2(amount.amountInMaximum);
       }
     }
-    const ordering = getTokenOrdering(tokenIn, tokenOut, false);
-    const zeroForOne = stringifyTokenClassKey(tokenIn) === stringifyTokenClassKey(ordering.token0);
-    const rawAmount = "exactIn" in amount ? (0, import_bignumber5.default)(amount.exactIn).toFixed() : (0, import_bignumber5.default)(amount.exactOut).multipliedBy(-1).toFixed();
-    const rawAmountOutMinimum = "exactIn" in amount ? ((_b = amount.amountOutMinimum) == null ? void 0 : _b.toString()) ? (0, import_bignumber5.default)(amount.amountOutMinimum).multipliedBy(-1).toFixed() : void 0 : (0, import_bignumber5.default)(amount.exactOut ?? 0).multipliedBy(-1).toFixed();
-    const rawAmountInMaximum = "exactIn" in amount ? (0, import_bignumber5.default)(amount.exactIn).toFixed() : amount.amountInMaximum ? (0, import_bignumber5.default)(amount.amountInMaximum).toFixed() : void 0;
-    const toSign = {
-      token0: parseTokenClassKey(ordering.token0),
-      token1: parseTokenClassKey(ordering.token1),
-      fee,
-      amount: rawAmount,
-      zeroForOne,
-      sqrtPriceLimit: ordering.zeroForOne ? MIN_SQRT_PRICE_LIMIT : MAX_SQRT_PRICE_LIMIT,
-      recipient: walletAddress,
-      amountOutMinimum: rawAmountOutMinimum,
-      amountInMaximum: rawAmountInMaximum
-    };
-    const token0StringKey = stringifyTokenClassKey(ordering.token0, "$");
-    const token1StringKey = stringifyTokenClassKey(ordering.token1, "$");
-    const poolString = `$pool$${token0StringKey}$${token1StringKey}$${fee}`;
-    const tokenBalance0 = `$tokenBalance$${token0StringKey}$${walletAddress}`;
-    const tokenBalance1 = `$tokenBalance$${token1StringKey}$${walletAddress}`;
-    const tokenBalance0Pool = `$tokenBalance$${token0StringKey}$${poolString}`;
-    const tokenBalance1Pool = `$tokenBalance$${token1StringKey}$${poolString}`;
-    const stringsInstructions = [
-      poolString,
-      tokenBalance0,
-      tokenBalance1,
-      tokenBalance0Pool,
-      tokenBalance1Pool
-    ];
-    return this.bundlerService.sendBundlerRequest("Swap", toSign, stringsInstructions);
+    return dto;
+  }
+};
+function toDecimalString2(amount) {
+  return new import_bignumber5.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
+  });
+}
+
+// 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"
   }
 };
 
 // src/classes/gswap.ts
 var GSwap = class {
-  gatewayBaseUrl;
-  dexContractBasePath;
-  tokenContractBasePath;
-  bundlerBaseUrl;
-  bundlingAPIBasePath;
   dexBackendBaseUrl;
-  transactionWaitTimeoutMs;
+  chainCallTimeoutMs;
   signer;
+  walletAddress;
+  gateway;
+  symbols;
+  quoting;
+  pools;
+  positions;
+  swaps;
+  assets;
   /**
-   * Quoting functionality for price discovery and trade estimation.
-   * Use this to get quotes for token swaps without executing transactions.
+   * Create an SDK client for prod or stage.
    *
    * @example
    * ```typescript
-   * // Get the best quote across all fee tiers
-   * const quote = await gSwap.quoting.quoteExactInput(tokenA, tokenB, amount);
+   * const gSwap = new GSwap({ env: 'stage' });
+   * const symbols = await gSwap.symbols.list();
    * ```
    */
-  quoting;
+  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);
+  }
+};
+function trimTrailingSlash2(value) {
+  return value.replace(/\/$/u, "");
+}
+
+// src/classes/signers.ts
+var import_api = require("@gala-chain/api");
+
+// src/utils/eip712.ts
+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"
+]);
+function numericOr0(dto, field) {
+  return typeof dto[field] === "number" ? dto[field] : 0;
+}
+function completeAddLiquidityFields(dto) {
+  return {
+    ...dto,
+    amount0Desired: numericOr0(dto, "amount0Desired"),
+    amount0Min: numericOr0(dto, "amount0Min"),
+    amount1Desired: numericOr0(dto, "amount1Desired"),
+    amount1Min: numericOr0(dto, "amount1Min"),
+    positionId: dto["positionId"] ?? ""
+  };
+}
+function completeRemoveLiquidityFields(dto) {
+  return {
+    ...dto,
+    amount: numericOr0(dto, "amount"),
+    amount0Min: numericOr0(dto, "amount0Min"),
+    amount1Min: numericOr0(dto, "amount1Min"),
+    positionId: dto["positionId"] ?? ""
+  };
+}
+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
+};
+function buildEIP712Payload(methodName, dto) {
+  const completer = EIP712_FIELD_COMPLETERS[methodName];
+  const completedDto = completer ? completer(dto) : dto;
+  const types = generateEIP712Types(methodName, completedDto);
+  return { completedDto, types };
+}
+
+// src/classes/signers.ts
+var ETHEREUM_SIGNED_MESSAGE = String.fromCharCode(25) + "Ethereum Signed Message:\n";
+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);
+}
+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;
+}
+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;
+}
+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;
+}
+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()}`;
+}
+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 "";
+}
+function isUnsupportedNativeSchemeError(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) }));
+}
+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)
+  }));
+}
+var PrivateKeySigner = class {
+  keyBuffer;
   /**
-   * Position management operations for liquidity positions.
-   * Use this to manage liquidity positions including creation, modification, and fee collection.
+   * Creates a native signer from a hex or base64 secp256k1 private key.
    *
    * @example
    * ```typescript
-   * // Get all user positions
-   * const positions = await gSwap.positions.getUserPositions('eth|123...abc');
+   * 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.
    *
-   * // Add liquidity to a position using price range
-   * const result = await gSwap.positions.addLiquidityByPrice({
-   *   walletAddress: 'eth|123...abc',
-   *   positionId: '',
-   *   token0: 'GALA|Unit|none|none',
-   *   token1: 'GUSDC|Unit|none|none',
-   *   fee: 500,
-   *   tickSpacing: 10,
-   *   minPrice: '0.45',
-   *   maxPrice: '0.55',
-   *   amount0Desired: '100',
-   *   amount1Desired: '50',
-   *   amount0Min: '95',
-   *   amount1Min: '47.5'
+   * @example
+   * ```typescript
+   * const signed = await signer.signObject('RequestTrade', {
+   *   token0: 'GALA',
+   *   token1: 'GUSDC',
+   *   fee: 3000,
    * });
    * ```
    */
-  positions;
+  signObject(_methodName, dto) {
+    const signature = import_api.signatures.getSignature(dto, this.keyBuffer);
+    return Promise.resolve({ ...dto, signature });
+  }
+};
+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;
   /**
-   * Token swap operations for trading tokens.
-   * Use this to execute token swaps on the DEX.
+   * Creates a Gala Wallet signer.
    *
    * @example
    * ```typescript
-   * // Execute an exact input swap: sell 100 GALA for USDC
-   * const result = await gSwap.swaps.swap(
-   *   'GALA|Unit|none|none',
-   *   'GUSDC|Unit|none|none',
-   *   500,
-   *   { exactIn: '100', amountOutMinimum: '45' },
-   *   'eth|123...abc', // your wallet address
-   * );
+   * 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.
    */
-  swaps;
+  constructor(walletAddress, options = {}) {
+    this.walletAddress = normalizeEthereumAccount(walletAddress, true);
+    this.effectiveScheme = options.scheme ?? "native";
+  }
   /**
-   * User asset management operations.
-   * Use this to retrieve user token balances and asset information.
+   * Signs a DTO through `gala_signChainDto`.
    *
    * @example
    * ```typescript
-   * // Get user assets with pagination
-   * const assets = await gSwap.assets.getUserAssets('eth|123...abc', 1, 20);
-   * console.log(`User has ${assets.count} different tokens`);
+   * const signed = await signer.signObject('AddLiquidity', {
+   *   token0: 'GALA',
+   *   token1: 'GUSDC',
+   *   tickLower: -60,
+   *   tickUpper: 60,
+   * });
    * ```
    */
-  assets;
+  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);
+    }
+  }
+};
+var BrowserWalletSigner = class {
   /**
-   * Event management operations for real-time socket connections.
-   * Use this to manage event streaming and transaction status updates.
+   * 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
-   * // Connect to event socket for transaction updates
-   * await GSwap.events.connectEventSocket();
-   *
-   * // Check if socket is connected
-   * const isConnected = GSwap.events.eventSocketConnected();
+   * 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' });
    * ```
    */
-  static events = Events.instance;
-  httpClient;
-  httpRequestor;
-  bundler;
-  pools;
+  constructor(provider, walletAddress, options = {}) {
+    this.provider = provider;
+    this.walletAddress = normalizeEthereumAccount(walletAddress, false);
+    this.scheme = options.scheme ?? "personal-sign";
+  }
+  provider;
+  walletAddress;
+  scheme;
   /**
-   * Creates a new SDK instance.
-   * @param options - Customization options.
-   * @param options.signer - The signer to use for authenticated operations. Required if you use any functionality that creates transactions (such as swapping). Not required for readonly operations.
-   * @param options.gatewayBaseUrl - Base URL for the GalaChain Gateway API.
-   * @param options.dexContractBasePath - Base path for DEX contract API endpoints, within the GalaChain Gateway API.
-   * @param options.tokenContractBasePath - Base path for token contract API endpoints, within the GalaChain Gateway API.
-   * @param options.bundlerBaseUrl - Base URL for the DEX transaction bundling API.
-   * @param options.bundlingAPIBasePath - Base path for transaction bundling API endpoints.
-   * @param options.dexBackendBaseUrl - Base URL for the DEX backend API (for user assets and other data).
-   * @param options.httpRequestor - Custom HTTP requestor to use for API calls. Defaults to the global `fetch` function.
-   * @param options.transactionWaitTimeoutMs - Timeout in milliseconds for waiting for transactions to complete. Defaults to 300,000 milliseconds (five minutes).
-   * @param options.walletAddress - Optional default wallet address for operations that require a wallet address (e.x. swapping). If not provided, you must specify the wallet address in each method call.
+   * 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,
+   * });
+   * ```
    */
-  constructor(options) {
-    var _a;
-    this.gatewayBaseUrl = ((_a = options == null ? void 0 : options.gatewayBaseUrl) == null ? void 0 : _a.replace(/\/$/, "")) ?? "https://gateway-mainnet.galachain.com";
-    this.dexContractBasePath = (options == null ? void 0 : options.dexContractBasePath) ?? "/api/asset/dexv3-contract";
-    this.tokenContractBasePath = (options == null ? void 0 : options.tokenContractBasePath) ?? "/api/asset/token-contract";
-    this.bundlerBaseUrl = (options == null ? void 0 : options.bundlerBaseUrl) ?? "https://bundle-backend-prod1.defi.gala.com";
-    this.bundlingAPIBasePath = (options == null ? void 0 : options.bundlingAPIBasePath) ?? "/bundle";
-    this.dexBackendBaseUrl = (options == null ? void 0 : options.dexBackendBaseUrl) ?? "https://dex-backend-prod1.defi.gala.com";
-    this.signer = options == null ? void 0 : options.signer;
-    this.transactionWaitTimeoutMs = (options == null ? void 0 : options.transactionWaitTimeoutMs) ?? 3e5;
-    this.httpRequestor = (options == null ? void 0 : options.httpRequestor) ?? fetch.bind(globalThis);
-    this.httpClient = new HttpClient(this.httpRequestor);
-    this.bundler = new Bundler(
-      this.bundlerBaseUrl,
-      this.bundlingAPIBasePath,
-      this.transactionWaitTimeoutMs,
-      this.signer,
-      this.httpClient
-    );
-    this.pools = new Pools(this.gatewayBaseUrl, this.dexContractBasePath, this.httpClient);
-    this.quoting = new Quoting(this.gatewayBaseUrl, this.dexContractBasePath, this.httpClient);
-    this.positions = new Positions(
-      this.gatewayBaseUrl,
-      this.dexContractBasePath,
-      this.bundler,
-      this.pools,
-      this.httpClient,
-      { walletAddress: options == null ? void 0 : options.walletAddress }
-    );
-    this.swaps = new Swaps(this.bundler, { walletAddress: options == null ? void 0 : options.walletAddress });
-    this.assets = new Assets(this.dexBackendBaseUrl, this.httpClient);
-  }
-};
-
-// src/classes/signers.ts
-var import_api = require("@gala-chain/api");
-var import_connect = require("@gala-chain/connect");
-var PrivateKeySigner = class {
-  keyBuffer;
-  constructor(privateKey) {
-    this.keyBuffer = import_api.signatures.normalizePrivateKey(privateKey);
-  }
-  async signObject(_methodName, obj) {
-    const signature = import_api.signatures.getSignature(obj, this.keyBuffer);
-    return { ...obj, signature };
-  }
-};
-var GalaWalletSigner = class _GalaWalletSigner {
-  constructor(walletAddress) {
-    this.walletAddress = walletAddress;
-  }
-  async signObject(methodName, obj) {
-    const globalGala = global.gala;
-    if (!globalGala) {
-      throw new GSwapSDKError(
-        "Gala wallet is not available. Please ensure the Gala wallet is connected.",
-        "GALA_WALLET_NOT_AVAILABLE"
-      );
+  signObject(methodName, dto) {
+    if (this.scheme === "eip712" && EIP712_CAPABLE_METHODS.has(methodName)) {
+      return signEIP712(this.provider, methodName, dto, this.walletAddress);
     }
-    const domain = { name: "ethereum", chainId: 1 };
-    const types = _GalaWalletSigner.generateEIP712Types(methodName, obj);
-    const signRequest = {
-      domain,
-      types,
-      Primary_type: methodName,
-      message: {
-        ...obj,
-        prefix: (0, import_connect.calculatePersonalSignPrefix)(obj)
-      }
-    };
-    await globalGala.setAddress(this.walletAddress);
-    const signature = await globalGala.request({
-      method: "eth_signTypedData",
-      params: [JSON.stringify(signRequest), this.walletAddress]
-    });
-    return { ...obj, domain, types, signature };
-  }
-  static generateEIP712Types(typeName, params) {
-    const types = {};
-    types[typeName] = [];
-    function addField(name, fieldValue, parentTypeName, onlyGetType = false) {
-      if (fieldValue === void 0) {
-      } else if (Array.isArray(fieldValue)) {
-        const type = addField(name, fieldValue[0], parentTypeName, true);
-        if (!onlyGetType) types[parentTypeName].push({ name, type: (type ?? name) + "[]" });
-      } else if (typeof fieldValue === "object" && fieldValue !== null) {
-        if (types[name]) {
-          throw new GSwapSDKError(
-            "Name collisions not yet supported in EIP712 type generation",
-            "EIP712_NAME_COLLISION",
-            { name }
-          );
-        }
-        types[name] = [];
-        Object.entries(fieldValue).forEach(([key, value]) => {
-          addField(key, value, name);
-        });
-        if (!onlyGetType) types[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;
-          default:
-            throw new GSwapSDKError(
-              `Unsupported type for EIP712 signing: ${typeof fieldValue}`,
-              "EIP712_UNSUPPORTED_TYPE",
-              { type: typeof fieldValue, value: fieldValue }
-            );
-        }
-        if (onlyGetType) {
-          return eipType;
-        } else {
-          types[parentTypeName].push({ name, type: eipType });
-        }
-      }
-    }
-    Object.entries(params).forEach(([key, value]) => {
-      addField(key, value, typeName);
-    });
-    return types;
+    return personalSign(this.provider, dto, this.walletAddress);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ALL_FEE_TIERS,
   Assets,
-  Bundler,
-  EventSocketClient,
-  Events,
+  BrowserWalletSigner,
+  ChainGateway,
   FEE_TIER,
+  GC_MAX_TICK,
+  GC_MIN_TICK,
+  GSWAP_ENVIRONMENTS,
   GSwap,
   GSwapSDKError,
   GalaWalletSigner,
-  PendingTransaction,
   Pools,
   Positions,
   PrivateKeySigner,
   Quoting,
+  SubmittedTransaction,
   Swaps,
-  TradeEventEmitter,
-  compareTokens,
-  getTokenOrdering,
+  Symbols,
+  TICK_SPACING_BY_FEE,
+  alignTickDown,
+  alignTickUp,
+  assertTickRange,
+  compositeKeyOf,
+  getObjectProperty,
+  getStringProperty,
+  orderSymbols,
+  parseJson,
   parseTokenClassKey,
-  stringifyTokenClassKey,
+  readOrderedSymbols,
+  sqrtPriceToTick,
+  tickFromPrice,
+  tickToSqrtPrice,
   validateFee,
   validateNumericAmount,
   validatePriceValues,