@gala-chain/gswap-sdk 1.2.0 → 2.0.0-rc.0

package/dist/index.cjs

@@ -26,14 +26,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
+let _gala_chain_gala_core_sdk = require("@gala-chain/gala-core-sdk");
 let bignumber_js = require("bignumber.js");
 bignumber_js = __toESM(bignumber_js, 1);
 let decimal_js = require("decimal.js");
 let debug = require("debug");
 debug = __toESM(debug, 1);
-let _noble_curves_secp256k1 = require("@noble/curves/secp256k1");
-let _noble_hashes_sha3 = require("@noble/hashes/sha3");
-let _noble_hashes_utils = require("@noble/hashes/utils");
 
 //#region src/utils/confirmation_schedule.ts
 const DEFAULT_TIMEOUT_MS = 6e4;
@@ -125,352 +123,30 @@ function readServerMessage(error) {
 }
 
 //#endregion
-//#region src/utils/unique_key_syntax.ts
-/**
-* The shape of a write `uniqueKey`, with NO imports: the pending-swap store and the failure guards
-* need only this check, and importing it from `unique_key.ts` would drag in `GSwapSDKError` and the
-* whole error catalog for it.
-*/
-/** The swap backend's apply-results key constraint (`apply-results.dto.ts`). */
-const UNIQUE_KEY_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/u;
-/**
-* True when `uniqueKey` is a usable write key: 1 to 128 characters of `A-Za-z0-9._:-`, the shape
-* the apply-results route accepts. The one definition behind `assertUniqueKey`, `confirm()` and
-* the pending-swap store, so they can never disagree about what a valid key is.
-*/
-function isValidUniqueKey(uniqueKey) {
-	return typeof uniqueKey === "string" && UNIQUE_KEY_PATTERN.test(uniqueKey);
-}
-
-//#endregion
-//#region src/utils/error_brand.ts
-/**
-* The brand every `GSwapSDKError` carries, and the duck-type check for the "failure shape". This
-* module has NO imports on purpose: it is part of the light `@gala-chain/gswap-sdk/wallet` entry,
-* which must never pull the error catalog or the main bundle in.
-*/
-/**
-* The brand of an SDK error: `error[GSWAP_ERROR_BRAND] === true`. It is a registered symbol
-* (`Symbol.for`), so two copies of the SDK in one page (a wallet bundle and an app bundle) still
-* recognise each other's errors, which `instanceof` cannot do.
-*/
-const GSWAP_ERROR_BRAND = Symbol.for("@gala-chain/gswap-sdk/error");
-function isRecord$4(value) {
-	return typeof value === "object" && value !== null;
-}
-/** True when `value` carries the SDK error brand (a real `GSwapSDKError`, from any copy of the SDK). */
-function hasGSwapErrorBrand(value) {
-	return isRecord$4(value) && value[GSWAP_ERROR_BRAND] === true;
-}
-/**
-* True when `value` is an SDK error (it carries the brand) or a plain-object VIEW of one: a string
-* `code` and an object `params`, which is the shape of `GSwapSDKError` and of the wrapper objects
-* an app builds from one (`{ code, params, status?, phase?, ... }`). A wallet's own error (an
-* EIP-1193 numeric `code`, an ethers error with a string `code` and no `params`) is neither. It
-* says the value has the SDK's shape, not that `code` is a code the SDK knows.
-*
-* @example
-* ```ts
-* if (isGSwapErrorLike(error)) report(error.code, error.params); // no `instanceof`, no SDK import
-* ```
-*/
-function isGSwapErrorLike(value) {
-	if (hasGSwapErrorBrand(value)) return true;
-	return isRecord$4(value) && typeof value["code"] === "string" && isRecord$4(value["params"]) && !Array.isArray(value["params"]);
-}
-
-//#endregion
-//#region src/classes/error_phases.ts
-/**
-* How far an operation had got when it failed, measured against the request it exists to send:
-* for a write, the POST that carries the signed DTO to the gateway; for a read, the GET.
-*
-* - `pre_send`: NOTHING was transmitted. Everything up to the request (validation, symbol
-*   resolution, the signer, the wallet, a key provider) ran and failed, so no write can have been
-*   queued. A write that failed `pre_send` is never "maybe applied".
-* - `in_flight`: the request left (or may have left) and no answer was read: a timeout, a broken
-*   connection, a stream that dropped. For a write the outcome is unknown.
-* - `post_send`: an answer was read, or the write was already accepted: a refusal, an
-*   acknowledgement that proves nothing, an unusable body, and every failure of a confirmation.
-*
-* Each catalog entry declares the phase its code is thrown in; a throw site where the same code
-* can occur in another phase overrides it (`GSwapErrorContext.phase`). It is a typed property of
-* every `GSwapSDKError` (`error.phase`) and `isPreSendError(error)` reads it.
-*
-* This module has no imports, on purpose: it is the closed set of phases, shared by the catalog,
-* the light phase table (`error_phase_table.ts`) and the failure view.
-*/
-const GSWAP_ERROR_PHASES = [
-	"pre_send",
-	"in_flight",
-	"post_send"
-];
-
-//#endregion
-//#region src/utils/failure_outcomes.ts
-/**
-* What a failure means for the operation that raised it, as one vocabulary for every app.
-*
-* - `rejected`: the CHAIN refused the request (a definite no). Nothing was applied, so a NEW
-*   request is safe.
-* - `unknown`: the request MAY have been applied (a timeout, a broken connection, an
-*   acknowledgement that proves nothing, a failed confirmation). Never submit again under a fresh
-*   key: keep `error.uniqueKey` and confirm it.
-* - `not_queued`: the gateway refused the write before queueing it. Nothing is pending.
-* - `not_sent`: the request never left (`error.phase === 'pre_send'`) for a reason outside the
-*   call itself: the signer or the wallet failed (locked, unreachable, the person declined), the
-*   key provider or the token resolver failed, or no key was available yet. Nothing is pending and
-*   nothing was transmitted, so repeating the call is safe and may succeed once the cause (an
-*   unlocked wallet) is gone.
-* - `invalid_input`: the call itself cannot work (a bad argument, a missing signer or wallet, an
-*   unknown token or pool, a corrupt stored key). Repeating the same call fails the same way.
-*   Such an error is also pre-send (`isPreSendError`), but the input is what has to change.
-* - `transient`: a read or connection failed with no state change. Repeating the same call is safe
-*   and may succeed.
+//#region src/classes/gswap_error_catalog.ts
+/**
+* The catalog of every error code gswap-sdk ITSELF throws (the DEX codes): the SINGLE source of
+* truth for its `code`, the named parameters it carries and the English template its `message` is
+* generated from. The codes of the signing, transport and wallet layer (`INVALID_PRIVATE_KEY`,
+* `REQUEST_TIMEOUT`, `SIGNING_FAILED`, `TYPED_DATA_*`, ...) live in `@gala-chain/gala-core-sdk`'s
+* `GALA_ERROR_CATALOG`; no code is defined in both. A `GSwapSDKError` can carry a code of either
+* catalog (`GSwapErrorCode` is the union), and reads its template from both.
 *
-* This module has no imports: the failure view (`FailureView.outcome`) and the classifier both
-* read the closed set from here.
-*/
-const FAILURE_OUTCOMES = [
-	"rejected",
-	"unknown",
-	"not_queued",
-	"not_sent",
-	"invalid_input",
-	"transient"
-];
-
-//#endregion
-//#region src/utils/failure_view.ts
-function isRecord$3(value) {
-	return typeof value === "object" && value !== null;
-}
-/**
-* Reads the failure view of any value: a `GSwapSDKError`, or a plain object with a string `code`
-* (and, optionally, `params`, `status`, `phase`, `uniqueKey`, `shadow`, `notFound`). Anything else
-* (a string, a wallet error with a numeric `code`, `null`) has no view and is `undefined`.
-*
-* Having a view does not mean the SDK knows the code: an ethers error is `{ code:
-* 'ACTION_REJECTED' }` and has a view too. The SDK's guards compare the code with the catalog.
-*
-* @example
-* ```ts
-* const view = toFailureView(error); // an SDK error, or an app's `{ code, params, status }` wrapper
-* if (view?.code === 'CHAIN_REJECTED') showChainRejection(view.params);
-* ```
-*/
-function toFailureView(value) {
-	if (!isRecord$3(value)) return void 0;
-	const { code, params, status, phase, uniqueKey, write, outcome, retryable, shadow, notFound } = value;
-	if (typeof code !== "string" || code === "") return void 0;
-	return {
-		code,
-		params: isRecord$3(params) && !Array.isArray(params) ? params : void 0,
-		status: typeof status === "number" && Number.isFinite(status) ? status : void 0,
-		phase: GSWAP_ERROR_PHASES.find((known) => known === phase),
-		uniqueKey: typeof uniqueKey === "string" && uniqueKey !== "" ? uniqueKey : void 0,
-		write: typeof write === "boolean" ? write : void 0,
-		outcome: FAILURE_OUTCOMES.find((known) => known === outcome),
-		retryable: retryable === false ? false : void 0,
-		shadow: typeof shadow === "boolean" ? shadow : void 0,
-		notFound: typeof notFound === "boolean" ? notFound : void 0
-	};
-}
-/**
-* True when a failure is a WRITE's: it names a `uniqueKey`, or it does not say `write: false`.
-* Fail-closed (see {@link FailureView}): only an explicit read is a read.
-*/
-function isWriteView(view) {
-	return view.uniqueKey !== void 0 || view.write !== false;
-}
-/** A param of a view, when it is a string. */
-function stringParamOf(view, name) {
-	var _view$params;
-	const value = (_view$params = view.params) === null || _view$params === void 0 ? void 0 : _view$params[name];
-	return typeof value === "string" ? value : void 0;
-}
-/** A param of a view, when it is a finite number. */
-function numberParamOf(view, name) {
-	var _view$params2;
-	const value = (_view$params2 = view.params) === null || _view$params2 === void 0 ? void 0 : _view$params2[name];
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-
-//#endregion
-//#region src/classes/error_phase_table.ts
-/**
-* The phase of every catalog code, WITHOUT the catalog. The failure guards (`classifyFailure`,
-* `mayHaveBeenQueued`, ...) need only a code's phase, and the catalog's English templates are
-* ~20 kB: reading the phase from here keeps an app shell that imports a guard from loading them.
-* The catalog entry is still where a code is declared; this table is checked against it AT
-* COMPILE TIME, in both directions (a missing code, an extra code or a different phase is a type
-* error), so the two cannot drift.
-*/
-const GSWAP_ERROR_PHASE_BY_CODE = {
-	HTTP_ERROR: "post_send",
-	UPDATE_REQUIRED: "post_send",
-	REQUEST_TIMEOUT: "in_flight",
-	TRANSPORT_ERROR: "in_flight",
-	REQUEST_FAILED: "in_flight",
-	INVALID_TIMEOUT: "pre_send",
-	METHOD_NOT_SUPPORTED: "pre_send",
-	SUBMISSION_OUTCOME_UNKNOWN: "in_flight",
-	GATEWAY_REPORTED_ERROR: "post_send",
-	GATEWAY_DATA_MISSING: "post_send",
-	GATEWAY_MODE_INVALID: "post_send",
-	GATEWAY_SYNC_REQUEST_TRADE: "post_send",
-	MISSING_UNIQUE_KEY: "post_send",
-	UNIQUE_KEY_MISMATCH: "post_send",
-	SHADOW_NOT_QUEUED: "post_send",
-	SHADOW_SUBMIT_NEEDS_WALLET_ADDRESS: "pre_send",
-	METHOD_NOT_ALLOWED: "post_send",
-	SIGNATURE_INVALID: "post_send",
-	SIGNER_MISMATCH: "post_send",
-	DTO_INVALID: "post_send",
-	BOUNDS_VIOLATION: "post_send",
-	SYMBOL_CONFLICT: "post_send",
-	RATE_LIMITED: "post_send",
-	CHAIN_DISPATCH_FAILED: "post_send",
-	GATEWAY_REJECTED: "post_send",
-	CHAIN_REJECTED: "post_send",
-	INVALID_CHAIN_RESPONSE: "post_send",
-	INVALID_POSITION_RESPONSE: "post_send",
-	CONFIRMATION_TIMEOUT: "post_send",
-	CONFIRMATION_ABORTED: "post_send",
-	CONFIRMATION_FAILED: "post_send",
-	CONFIRMATION_MALFORMED: "post_send",
-	CONFIRMATION_KEY_MISMATCH: "post_send",
-	NO_SIGNER: "pre_send",
-	NO_WALLET_ADDRESS: "post_send",
-	NO_POOL_AVAILABLE: "post_send",
-	INSUFFICIENT_LIQUIDITY: "post_send",
-	UNKNOWN_TOKEN: "pre_send",
-	SYMBOL_NOT_FOUND: "pre_send",
-	STREAM_API_KEY_UNUSABLE: "pre_send",
-	STREAM_WEBSOCKET_UNAVAILABLE: "pre_send",
-	STREAM_NOT_CONNECTED: "pre_send",
-	STREAM_DISCONNECTED: "in_flight",
-	STREAM_REQUEST_TIMEOUT: "in_flight",
-	STREAM_CONNECT_FAILED: "in_flight",
-	STREAM_CLOSED_BEFORE_CONNECT: "in_flight",
-	STREAM_CONNECTION_CLOSED: "in_flight",
-	GALA_WALLET_NOT_AVAILABLE: "pre_send",
-	WALLET_UNAVAILABLE: "pre_send",
-	MALFORMED_WALLET_REQUEST: "pre_send",
-	UNSUPPORTED_WALLET_METHOD: "pre_send",
-	INVALID_SIGNATURE: "pre_send",
-	INVALID_CHAIN_ID: "pre_send",
-	SIGNER_ADDRESS_MISMATCH: "pre_send",
-	INVALID_PRIVATE_KEY: "pre_send",
-	SIGNING_FAILED: "pre_send",
-	KEY_PROVIDER_FAILED: "pre_send",
-	TOKEN_RESOLUTION_FAILED: "pre_send",
-	INVALID_SIGNING_HASH_LENGTH: "pre_send",
-	MISSING_WALLET_ADDRESS: "pre_send",
-	INVALID_WALLET_ADDRESS: "pre_send",
-	INVALID_DECIMAL: "pre_send",
-	PERSONAL_SIGN_NOT_JSON: "pre_send",
-	PERSONAL_SIGN_NOT_OBJECT: "pre_send",
-	PERSONAL_SIGN_BAD_PREFIX: "pre_send",
-	PERSONAL_SIGN_ENVELOPE_FIELDS: "pre_send",
-	PERSONAL_SIGN_NOT_CANONICAL: "pre_send",
-	EIP712_NAME_COLLISION: "pre_send",
-	EIP712_UNSUPPORTED_VALUE: "pre_send",
-	TYPED_DATA_NOT_STRING: "pre_send",
-	TYPED_DATA_UNPAIRED_SURROGATE: "pre_send",
-	TYPED_DATA_NOT_HEX_BYTES: "pre_send",
-	TYPED_DATA_NOT_SAFE_INTEGER: "pre_send",
-	TYPED_DATA_NOT_INTEGER: "pre_send",
-	TYPED_DATA_NOT_BOOLEAN: "pre_send",
-	TYPED_DATA_BAD_ADDRESS: "pre_send",
-	TYPED_DATA_BAD_CHECKSUM: "pre_send",
-	TYPED_DATA_BYTES_LENGTH: "pre_send",
-	TYPED_DATA_OUT_OF_BOUNDS: "pre_send",
-	TYPED_DATA_UNSUPPORTED_TYPE: "pre_send",
-	TYPED_DATA_FIELDS_NOT_LIST: "pre_send",
-	TYPED_DATA_FIELD_MALFORMED: "pre_send",
-	TYPED_DATA_INVALID_FIELD_NAME: "pre_send",
-	TYPED_DATA_DUPLICATE_FIELD: "pre_send",
-	TYPED_DATA_INVALID_TYPE_NAME: "pre_send",
-	TYPED_DATA_CIRCULAR_TYPE: "pre_send",
-	TYPED_DATA_UNKNOWN_FIELD_TYPE: "pre_send",
-	TYPED_DATA_NO_PRIMARY_TYPE: "pre_send",
-	TYPED_DATA_AMBIGUOUS_PRIMARY_TYPE: "pre_send",
-	TYPED_DATA_ARRAY_EXPECTED: "pre_send",
-	TYPED_DATA_ARRAY_LENGTH_MISMATCH: "pre_send",
-	TYPED_DATA_STRUCT_NOT_OBJECT: "pre_send",
-	TYPED_DATA_MISSING_FIELD: "pre_send",
-	TYPED_DATA_DOMAIN_NOT_OBJECT: "pre_send",
-	TYPED_DATA_INVALID_DOMAIN_KEY: "pre_send",
-	NON_CANONICAL_PAIR: "pre_send",
-	UNORDERABLE_SYMBOLS: "pre_send",
-	INVALID_TOKEN_CLASS_KEY: "pre_send",
-	INCOMPLETE_TOKEN_CLASS_KEY: "pre_send",
-	INVALID_TRADING_SYMBOL: "pre_send",
-	NO_VALID_TRADING_SYMBOL: "pre_send",
-	TOKEN_SYMBOL_NOT_REGISTERED: "pre_send",
-	SYMBOL_DISAGREES_WITH_REGISTRY: "pre_send",
-	CREATE_POOL_NEEDS_CLASS_KEY: "pre_send",
-	INVALID_UNIQUE_KEY: "pre_send",
-	INVALID_UNIQUE_KEY_PREFIX: "pre_send",
-	AMOUNT_IS_JS_NUMBER: "pre_send",
-	AMOUNT_NOT_FINITE: "pre_send",
-	AMOUNT_NOT_POSITIVE: "pre_send",
-	AMOUNT_NEGATIVE: "pre_send",
-	PRICE_VALUES_IS_JS_NUMBER: "pre_send",
-	INVALID_PRICE_VALUES: "pre_send",
-	INVALID_PRICE_RANGE: "pre_send",
-	INVALID_PRICE_BOUNDS: "pre_send",
-	PRICE_BOUNDS_ORDER: "pre_send",
-	INVALID_STARTING_PRICE: "pre_send",
-	INVALID_SQRT_PRICE: "pre_send",
-	INVALID_TOKEN_DECIMALS: "pre_send",
-	TICKS_NOT_INTEGERS: "pre_send",
-	INVALID_TICK_RANGE: "pre_send",
-	TICKS_OUT_OF_BOUNDS: "pre_send",
-	TICKS_NOT_ALIGNED: "pre_send",
-	INVALID_TICK_SPACING: "pre_send",
-	INVALID_FEE: "pre_send",
-	EXACT_AMOUNT_REQUIRED: "pre_send",
-	EXACTLY_ONE_OF_REQUIRED: "pre_send",
-	AT_MOST_ONE_OF_ALLOWED: "pre_send",
-	POOL_MISMATCH: "pre_send",
-	INVALID_DTO: "pre_send",
-	DTO_NOT_CANONICAL: "pre_send",
-	SEARCH_TOO_LONG: "pre_send",
-	INVALID_SORT_BY: "pre_send",
-	INVALID_SORT_ORDER: "pre_send",
-	INVALID_PAGE: "pre_send",
-	INVALID_LIMIT: "pre_send"
-};
-/** True for a code the SDK catalog defines. */
-function isCatalogCode(code) {
-	return Object.hasOwn(GSWAP_ERROR_PHASE_BY_CODE, code);
-}
-/** The phase of a view: the one it states, else the catalog's phase for its code, else `undefined`. */
-function phaseOfView(view) {
-	if (view.phase !== void 0) return view.phase;
-	return isCatalogCode(view.code) ? GSWAP_ERROR_PHASE_BY_CODE[view.code] : void 0;
-}
-
-//#endregion
-//#region src/classes/error_catalog.ts
-/**
-* Why a private key was refused (`INVALID_PRIVATE_KEY.params.reason`). A token for the app to map
-* to its own text, never English and never any part of the key.
+* - `code` is the only discriminator. It is stable: apps branch on it, never on message text.
+* - `params` are the named placeholders of the error: a flat object of primitives (string,
+*   number, boolean) that an app feeds to its own localization (i18next, ICU, FormatJS).
+*   Raw server payloads are never params (they are `error.body` / `error.bodyText`), and no
+*   secret (private key, signature, raw DTO) ever is.
+* - `template` is English with `{placeholder}` markers. `error.message` is generated from it
+*   and the params, so the two cannot drift. It is for logs and developers: it is not stable and
+*   must not be shown to users or matched on.
 *
-* - `wrong_length`: raw bytes that are not 32 bytes long.
-* - `bad_encoding`: a string that is neither 64 hex characters (optionally `0x`-prefixed, 63 is
-*   left-padded) nor a 44-character base64 string.
-* - `not_on_curve`: 32 bytes that are not a valid secp256k1 secret scalar.
-* - `no_key_provided`: a lazy key provider returned something that is not a string.
+* Every placeholder in a template is a declared param and every declared param is a placeholder,
+* except the few `unrendered` params that carry server text for the app and are kept out of
+* `message` on purpose (pinned by tests/error_catalog.test.ts). Facts that are not placeholders (HTTP status, URL,
+* `uniqueKey`, transaction ids, the raw body, the cause) are typed properties of the error, see
+* `GalaErrorContext`.
 */
-const INVALID_PRIVATE_KEY_REASONS = [
-	"wrong_length",
-	"bad_encoding",
-	"not_on_curve",
-	"no_key_provided"
-];
 /**
 * Why the outcome of a write submission is unknown (`SUBMISSION_OUTCOME_UNKNOWN.params.reason`).
 * Both say the same thing about the swap (it MAY have been queued: never resubmit under a fresh
@@ -482,20 +158,9 @@ const INVALID_PRIVATE_KEY_REASONS = [
 *   does NOT prove the swap was not sent.
 */
 const SUBMISSION_OUTCOME_UNKNOWN_REASONS = ["timeout", "transport"];
-/**
-* Why a signer could not produce a signature (`SIGNING_FAILED.params.reason`). A token for the
-* app to map to its own text.
-*
-* - `user_rejected`: the person declined in their wallet (an EIP-1193 `4001`, an ethers
-*   `ACTION_REJECTED`, or a wallet that words it "User rejected/denied ..."). Nothing is wrong:
-*   they may simply try again.
-* - `failed`: anything else the signer threw (a locked wallet, an unreachable extension, a wallet
-*   that refused). The original error is `cause`.
-*/
-const SIGNING_FAILURE_REASONS = ["user_rejected", "failed"];
 /** The fee tiers as they appear in `INVALID_FEE.allowed`. */
 const ALLOWED_FEE_TIERS_TEXT = "0,500,3000,10000";
-/** The whole catalog. Add a code here before throwing it anywhere. */
+/** The whole DEX catalog. Add a code here before throwing it anywhere in gswap-sdk. */
 const GSWAP_ERROR_CATALOG = {
 	HTTP_ERROR: {
 		phase: "post_send",
@@ -512,32 +177,11 @@ const GSWAP_ERROR_CATALOG = {
 		template: "The backend refused this app version and requires an update (HTTP {status}); nothing was queued.",
 		params: { status: "number" }
 	},
-	REQUEST_TIMEOUT: {
-		phase: "in_flight",
-		template: "Request to {url} timed out after {timeoutMs} ms.",
-		params: {
-			url: "string",
-			timeoutMs: "number"
-		}
-	},
-	TRANSPORT_ERROR: {
-		phase: "in_flight",
-		template: "The request to {url} failed before the server answered.",
-		params: { url: "string" }
-	},
 	REQUEST_FAILED: {
 		phase: "in_flight",
 		template: "The {operation} request failed.",
 		params: { operation: "string" }
 	},
-	INVALID_TIMEOUT: {
-		phase: "pre_send",
-		template: "{field} must be a positive number of milliseconds, or Infinity for no timeout (got {value}).",
-		params: {
-			field: "string",
-			value: "number"
-		}
-	},
 	METHOD_NOT_SUPPORTED: {
 		phase: "pre_send",
 		template: "The method {method} is not supported; swaps are queued through RequestTrade.",
@@ -767,370 +411,109 @@ const GSWAP_ERROR_CATALOG = {
 		template: "GDEX stream connection closed (code {closeCode}).",
 		params: { closeCode: "number" }
 	},
-	GALA_WALLET_NOT_AVAILABLE: {
+	TOKEN_RESOLUTION_FAILED: {
 		phase: "pre_send",
-		template: "Gala wallet is not available. Please ensure the Gala wallet is connected.",
-		params: {}
+		template: "Token {token} could not be looked up; nothing was sent.",
+		params: { token: "string" }
 	},
-	WALLET_UNAVAILABLE: {
+	MISSING_WALLET_ADDRESS: {
 		phase: "pre_send",
-		template: "No wallet is connected.",
+		template: "Invalid wallet address: No wallet address provided. Either provide a wallet address to the function you are calling, or set one when instantiating GSwapSDK.",
 		params: {}
 	},
-	MALFORMED_WALLET_REQUEST: {
-		phase: "pre_send",
-		template: "Wallet {method} request is malformed.",
-		params: { method: "string" }
-	},
-	UNSUPPORTED_WALLET_METHOD: {
+	NON_CANONICAL_PAIR: {
 		phase: "pre_send",
-		template: "Unsupported wallet method {method}.",
-		params: { method: "string" }
+		template: "The pair {token0}/{token1} is not in canonical order: token0 must sort before token1.",
+		params: {
+			token0: "string",
+			token1: "string"
+		}
 	},
-	INVALID_SIGNATURE: {
+	UNORDERABLE_SYMBOLS: {
 		phase: "pre_send",
-		template: "Wallet returned an invalid {scheme} signature.",
-		params: { scheme: "string" }
+		template: "Unable to order trading symbols: expected a pair of symbols, got {received}.",
+		params: { received: "string" }
 	},
-	INVALID_CHAIN_ID: {
+	INVALID_TOKEN_CLASS_KEY: {
 		phase: "pre_send",
-		template: "Wallet returned an invalid chain id ({chainId}).",
-		params: { chainId: "string" }
+		template: "Invalid token class key \"{tokenClassKey}\": expected a collection followed by category, type and additionalKey",
+		params: { tokenClassKey: "string" }
 	},
-	SIGNER_ADDRESS_MISMATCH: {
+	INCOMPLETE_TOKEN_CLASS_KEY: {
 		phase: "pre_send",
-		template: "The signing key does not belong to the expected account.",
-		params: {}
+		template: "Token class key \"{compositeKey}\" is missing {part}.",
+		params: {
+			compositeKey: "string",
+			part: "string"
+		}
 	},
-	INVALID_PRIVATE_KEY: {
+	INVALID_TRADING_SYMBOL: {
 		phase: "pre_send",
-		template: "Invalid private key: {reason}.",
-		params: { reason: INVALID_PRIVATE_KEY_REASONS }
+		template: "Invalid trading symbol \"{symbol}\": must be 1-32 ASCII letters and digits and not a reserved word (Token, Unit, none).",
+		params: { symbol: "string" }
 	},
-	SIGNING_FAILED: {
+	NO_VALID_TRADING_SYMBOL: {
 		phase: "pre_send",
-		template: "Signing the {method} request failed ({reason}); nothing was sent.",
+		template: "No valid trading symbol for token class {classKey}: \"{displaySymbol}\" is not an acceptable symbol and none is registered",
 		params: {
-			method: "string",
-			reason: SIGNING_FAILURE_REASONS
+			classKey: "string",
+			displaySymbol: "string"
 		}
 	},
-	KEY_PROVIDER_FAILED: {
+	TOKEN_SYMBOL_NOT_REGISTERED: {
 		phase: "pre_send",
-		template: "The signing key could not be fetched; nothing was sent.",
-		params: {}
+		template: "Token {token} is not registered in the trading-symbol registry yet; pass token0Symbol/token1Symbol (the token class symbol) to propose one. A symbol cannot be derived from a class key.",
+		params: { token: "string" }
 	},
-	TOKEN_RESOLUTION_FAILED: {
+	SYMBOL_DISAGREES_WITH_REGISTRY: {
 		phase: "pre_send",
-		template: "Token {token} could not be looked up; nothing was sent.",
-		params: { token: "string" }
+		template: "Supplied symbol {suppliedSymbol} for {token} disagrees with the registered trading symbol {registeredSymbol}.",
+		params: {
+			token: "string",
+			suppliedSymbol: "string",
+			registeredSymbol: "string"
+		}
 	},
-	INVALID_SIGNING_HASH_LENGTH: {
+	CREATE_POOL_NEEDS_CLASS_KEY: {
 		phase: "pre_send",
-		template: "secp256k1 can only sign a 32-byte hash (got {length}).",
-		params: { length: "number" }
+		template: "createPool needs each token as a class key; {token} is a bare trading symbol, which does not carry one.",
+		params: { token: "string" }
 	},
-	MISSING_WALLET_ADDRESS: {
+	AMOUNT_IS_JS_NUMBER: {
 		phase: "pre_send",
-		template: "Invalid wallet address: No wallet address provided. Either provide a wallet address to the function you are calling, or set one when instantiating GSwapSDK.",
-		params: {}
+		template: "Invalid {field}: use a decimal string or BigNumber, not a JavaScript number",
+		params: { field: "string" }
 	},
-	INVALID_WALLET_ADDRESS: {
+	AMOUNT_NOT_FINITE: {
 		phase: "pre_send",
-		template: "Invalid {field}: \"{value}\" is not an accepted wallet address form.",
+		template: "Invalid {field}: must be a finite number (got {value})",
 		params: {
 			field: "string",
 			value: "string"
 		}
 	},
-	INVALID_DECIMAL: {
-		phase: "pre_send",
-		template: "Invalid decimal quantity: {value}",
-		params: { value: "string" }
-	},
-	PERSONAL_SIGN_NOT_JSON: {
+	AMOUNT_NOT_POSITIVE: {
 		phase: "pre_send",
-		template: "Personal-sign DTO is not valid JSON",
-		params: {}
+		template: "Invalid {field}: must be positive (got {value})",
+		params: {
+			field: "string",
+			value: "string"
+		}
 	},
-	PERSONAL_SIGN_NOT_OBJECT: {
+	AMOUNT_NEGATIVE: {
 		phase: "pre_send",
-		template: "Personal-sign DTO must be a JSON object",
-		params: {}
+		template: "Invalid {field}: must not be negative (got {value})",
+		params: {
+			field: "string",
+			value: "string"
+		}
 	},
-	PERSONAL_SIGN_BAD_PREFIX: {
+	PRICE_VALUES_IS_JS_NUMBER: {
 		phase: "pre_send",
-		template: "Personal-sign DTO prefix is not an EIP-191 \"Ethereum Signed Message\" header",
+		template: "Invalid price values: use decimal strings or BigNumber values, not JavaScript numbers",
 		params: {}
 	},
-	PERSONAL_SIGN_ENVELOPE_FIELDS: {
-		phase: "pre_send",
-		template: "Personal-sign DTO carries signing-envelope field(s): {fields}",
-		params: { fields: "string" }
-	},
-	PERSONAL_SIGN_NOT_CANONICAL: {
-		phase: "pre_send",
-		template: "Personal-sign DTO is not in canonical serialized form",
-		params: {}
-	},
-	EIP712_NAME_COLLISION: {
-		phase: "pre_send",
-		template: "Name collisions are not supported when deriving EIP-712 types ({name}).",
-		params: { name: "string" }
-	},
-	EIP712_UNSUPPORTED_VALUE: {
-		phase: "pre_send",
-		template: "Unsupported EIP-712 value of type {valueType}.",
-		params: { valueType: "string" }
-	},
-	TYPED_DATA_NOT_STRING: {
-		phase: "pre_send",
-		template: "Invalid typed data: {what} must be a string",
-		params: { what: "string" }
-	},
-	TYPED_DATA_UNPAIRED_SURROGATE: {
-		phase: "pre_send",
-		template: "Invalid typed data: {what} has an unpaired surrogate",
-		params: { what: "string" }
-	},
-	TYPED_DATA_NOT_HEX_BYTES: {
-		phase: "pre_send",
-		template: "Invalid typed data: {what} must be an even-length 0x hex string",
-		params: { what: "string" }
-	},
-	TYPED_DATA_NOT_SAFE_INTEGER: {
-		phase: "pre_send",
-		template: "Invalid typed data: {what} must be a safe integer",
-		params: { what: "string" }
-	},
-	TYPED_DATA_NOT_INTEGER: {
-		phase: "pre_send",
-		template: "Invalid typed data: {what} must be an integer",
-		params: { what: "string" }
-	},
-	TYPED_DATA_NOT_BOOLEAN: {
-		phase: "pre_send",
-		template: "Invalid typed data: bool must be a boolean",
-		params: {}
-	},
-	TYPED_DATA_BAD_ADDRESS: {
-		phase: "pre_send",
-		template: "Invalid typed data: address must be 0x followed by 40 hex digits",
-		params: {}
-	},
-	TYPED_DATA_BAD_CHECKSUM: {
-		phase: "pre_send",
-		template: "Invalid typed data: address has a bad checksum",
-		params: {}
-	},
-	TYPED_DATA_BYTES_LENGTH: {
-		phase: "pre_send",
-		template: "Invalid typed data: {type} must be exactly {width} bytes",
-		params: {
-			type: "string",
-			width: "number"
-		}
-	},
-	TYPED_DATA_OUT_OF_BOUNDS: {
-		phase: "pre_send",
-		template: "Invalid typed data: value out of bounds for {type}",
-		params: { type: "string" }
-	},
-	TYPED_DATA_UNSUPPORTED_TYPE: {
-		phase: "pre_send",
-		template: "Invalid typed data: unsupported type \"{type}\"",
-		params: { type: "string" }
-	},
-	TYPED_DATA_FIELDS_NOT_LIST: {
-		phase: "pre_send",
-		template: "Invalid typed data: type {typeName} must be a list of fields",
-		params: { typeName: "string" }
-	},
-	TYPED_DATA_FIELD_MALFORMED: {
-		phase: "pre_send",
-		template: "Invalid typed data: type {typeName} has a field without a string name and type",
-		params: { typeName: "string" }
-	},
-	TYPED_DATA_INVALID_FIELD_NAME: {
-		phase: "pre_send",
-		template: "Invalid typed data: invalid field name \"{name}\"",
-		params: { name: "string" }
-	},
-	TYPED_DATA_DUPLICATE_FIELD: {
-		phase: "pre_send",
-		template: "Invalid typed data: duplicate field \"{name}\" in {typeName}",
-		params: {
-			name: "string",
-			typeName: "string"
-		}
-	},
-	TYPED_DATA_INVALID_TYPE_NAME: {
-		phase: "pre_send",
-		template: "Invalid typed data: invalid type name \"{name}\"",
-		params: { name: "string" }
-	},
-	TYPED_DATA_CIRCULAR_TYPE: {
-		phase: "pre_send",
-		template: "Invalid typed data: circular type reference in {typeName}",
-		params: { typeName: "string" }
-	},
-	TYPED_DATA_UNKNOWN_FIELD_TYPE: {
-		phase: "pre_send",
-		template: "Invalid typed data: unknown type \"{type}\" in {typeName}",
-		params: {
-			type: "string",
-			typeName: "string"
-		}
-	},
-	TYPED_DATA_NO_PRIMARY_TYPE: {
-		phase: "pre_send",
-		template: "Invalid typed data: missing primary type",
-		params: {}
-	},
-	TYPED_DATA_AMBIGUOUS_PRIMARY_TYPE: {
-		phase: "pre_send",
-		template: "Invalid typed data: ambiguous primary types or unused types ({roots})",
-		params: { roots: "string" }
-	},
-	TYPED_DATA_ARRAY_EXPECTED: {
-		phase: "pre_send",
-		template: "Invalid typed data: {type} array value must be an array",
-		params: { type: "string" }
-	},
-	TYPED_DATA_ARRAY_LENGTH_MISMATCH: {
-		phase: "pre_send",
-		template: "Invalid typed data: array length mismatch",
-		params: {}
-	},
-	TYPED_DATA_STRUCT_NOT_OBJECT: {
-		phase: "pre_send",
-		template: "Invalid typed data: {typeName} value must be an object",
-		params: { typeName: "string" }
-	},
-	TYPED_DATA_MISSING_FIELD: {
-		phase: "pre_send",
-		template: "Invalid typed data: {typeName} value is missing field \"{field}\"",
-		params: {
-			typeName: "string",
-			field: "string"
-		}
-	},
-	TYPED_DATA_DOMAIN_NOT_OBJECT: {
-		phase: "pre_send",
-		template: "Invalid typed data: domain must be an object",
-		params: {}
-	},
-	TYPED_DATA_INVALID_DOMAIN_KEY: {
-		phase: "pre_send",
-		template: "Invalid typed data: invalid typed-data domain key {key}",
-		params: { key: "string" }
-	},
-	NON_CANONICAL_PAIR: {
-		phase: "pre_send",
-		template: "The pair {token0}/{token1} is not in canonical order: token0 must sort before token1.",
-		params: {
-			token0: "string",
-			token1: "string"
-		}
-	},
-	UNORDERABLE_SYMBOLS: {
-		phase: "pre_send",
-		template: "Unable to order trading symbols: expected a pair of symbols, got {received}.",
-		params: { received: "string" }
-	},
-	INVALID_TOKEN_CLASS_KEY: {
-		phase: "pre_send",
-		template: "Invalid token class key \"{tokenClassKey}\": expected a collection followed by category, type and additionalKey",
-		params: { tokenClassKey: "string" }
-	},
-	INCOMPLETE_TOKEN_CLASS_KEY: {
-		phase: "pre_send",
-		template: "Token class key \"{compositeKey}\" is missing {part}.",
-		params: {
-			compositeKey: "string",
-			part: "string"
-		}
-	},
-	INVALID_TRADING_SYMBOL: {
-		phase: "pre_send",
-		template: "Invalid trading symbol \"{symbol}\": must be 1-32 ASCII letters and digits and not a reserved word (Token, Unit, none).",
-		params: { symbol: "string" }
-	},
-	NO_VALID_TRADING_SYMBOL: {
-		phase: "pre_send",
-		template: "No valid trading symbol for token class {classKey}: \"{displaySymbol}\" is not an acceptable symbol and none is registered",
-		params: {
-			classKey: "string",
-			displaySymbol: "string"
-		}
-	},
-	TOKEN_SYMBOL_NOT_REGISTERED: {
-		phase: "pre_send",
-		template: "Token {token} is not registered in the trading-symbol registry yet; pass token0Symbol/token1Symbol (the token class symbol) to propose one. A symbol cannot be derived from a class key.",
-		params: { token: "string" }
-	},
-	SYMBOL_DISAGREES_WITH_REGISTRY: {
-		phase: "pre_send",
-		template: "Supplied symbol {suppliedSymbol} for {token} disagrees with the registered trading symbol {registeredSymbol}.",
-		params: {
-			token: "string",
-			suppliedSymbol: "string",
-			registeredSymbol: "string"
-		}
-	},
-	CREATE_POOL_NEEDS_CLASS_KEY: {
-		phase: "pre_send",
-		template: "createPool needs each token as a class key; {token} is a bare trading symbol, which does not carry one.",
-		params: { token: "string" }
-	},
-	INVALID_UNIQUE_KEY: {
-		phase: "pre_send",
-		template: "The uniqueKey \"{uniqueKey}\" must be 1-128 characters of A-Z, a-z, 0-9, \".\", \"_\", \":\" or \"-\".",
-		params: { uniqueKey: "string" }
-	},
-	INVALID_UNIQUE_KEY_PREFIX: {
-		phase: "pre_send",
-		template: "uniqueKeyPrefix \"{uniqueKeyPrefix}\" must be at most {maxLength} characters of A-Z, a-z, 0-9, \".\", \"_\", \":\" or \"-\".",
-		params: {
-			uniqueKeyPrefix: "string",
-			maxLength: "number"
-		}
-	},
-	AMOUNT_IS_JS_NUMBER: {
-		phase: "pre_send",
-		template: "Invalid {field}: use a decimal string or BigNumber, not a JavaScript number",
-		params: { field: "string" }
-	},
-	AMOUNT_NOT_FINITE: {
-		phase: "pre_send",
-		template: "Invalid {field}: must be a finite number (got {value})",
-		params: {
-			field: "string",
-			value: "string"
-		}
-	},
-	AMOUNT_NOT_POSITIVE: {
-		phase: "pre_send",
-		template: "Invalid {field}: must be positive (got {value})",
-		params: {
-			field: "string",
-			value: "string"
-		}
-	},
-	AMOUNT_NEGATIVE: {
-		phase: "pre_send",
-		template: "Invalid {field}: must not be negative (got {value})",
-		params: {
-			field: "string",
-			value: "string"
-		}
-	},
-	PRICE_VALUES_IS_JS_NUMBER: {
-		phase: "pre_send",
-		template: "Invalid price values: use decimal strings or BigNumber values, not JavaScript numbers",
-		params: {}
-	},
-	INVALID_PRICE_VALUES: {
+	INVALID_PRICE_VALUES: {
 		phase: "pre_send",
 		template: "Invalid price values: all prices must be finite and positive (spot {spotPrice}, lower {lowerPrice}, upper {upperPrice})",
 		params: {
@@ -1309,156 +692,217 @@ const GSWAP_ERROR_CATALOG = {
 			min: "number",
 			max: "number"
 		}
+	},
+	INVALID_MARKET_TOKEN: {
+		phase: "pre_send",
+		template: "A market read names a token by a symbol or class key of 1 to 120 letters, digits and . _ $ + / : | - characters (got \"{token}\").",
+		params: { token: "string" }
+	},
+	INVALID_TIMEFRAME: {
+		phase: "pre_send",
+		template: "timeframe \"{value}\" is not allowed; it must be one of {allowed}.",
+		params: {
+			value: "string",
+			allowed: "string"
+		}
+	},
+	INVALID_SEASON_ID: {
+		phase: "pre_send",
+		template: "seasonId must be an integer of at least 1 (got {value}).",
+		params: { value: "string" }
+	},
+	INVALID_POLL_INTERVAL: {
+		phase: "pre_send",
+		template: "intervalMs must be a finite number of milliseconds of at least 1 (got {value}).",
+		params: { value: "string" }
 	}
 };
 /**
-* The English template of every error code, `{placeholder}` markers included. An optional seed
-* or fallback for an app's own translations; the SDK's `message` is generated from it.
+* The catalog `GSwapSDKError` reads templates and phases from: core's entries and the DEX entries,
+* merged (never redefined: the two key sets are disjoint, pinned by tests/error_catalog.test.ts).
+*/
+const GSWAP_SDK_ERROR_ENTRIES = {
+	..._gala_chain_gala_core_sdk.GALA_ERROR_CATALOG,
+	...GSWAP_ERROR_CATALOG
+};
+/**
+* The English template of every DEX error code, `{placeholder}` markers included. An optional seed
+* or fallback for an app's own translations; the SDK's `message` is generated from it. The core
+* codes' templates are `galaErrorTemplates` from `@gala-chain/gala-core-sdk`: an app that seeds
+* every code a `GSwapSDKError` can carry merges the two.
 */
 const gswapErrorTemplates = Object.fromEntries(Object.entries(GSWAP_ERROR_CATALOG).map(([code, entry]) => [code, entry.template]));
-const PLACEHOLDER = /\{([A-Za-z0-9_]+)\}/gu;
-/** Fills a template's `{placeholders}` from `params`; an unknown placeholder is left as written. */
-function renderGSwapErrorTemplate(template, params) {
-	return template.replace(PLACEHOLDER, (whole, name) => {
-		const value = params[name];
-		return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : whole;
-	});
-}
 
 //#endregion
-//#region src/classes/gswap_sdk_error.ts
-/**
-* The HTTP status of a version wall: the backend refuses an app version that is too old (HTTP 426
-* Upgrade Required). It is `UPDATE_REQUIRED` on every request the SDK sends, whatever else the body
-* says; a confirmation read keeps `CONFIRMATION_FAILED` because the write it confirms may be applied.
-*/
-const UPDATE_REQUIRED_STATUS = 426;
+//#region src/classes/gswap_error_phase_table.ts
 /**
-* Error raised by the SDK for validation, gateway, chain, or transaction failures.
-*
-* Branch on {@link code} (stable) and render {@link params} through your own localization.
-* {@link message} is English generated from the catalog template for logs and developers: it
-* is not stable and must never be shown to a user or matched on.
+* The phase of every DEX catalog code, WITHOUT the catalog. The failure guards (`classifyFailure`,
+* `mayHaveBeenQueued`, ...) need only a code's phase, and the catalog's English templates are
+* ~15 kB: reading the phase from here keeps an app shell that imports a guard from loading them.
+* The catalog entry is still where a code is declared; this table is checked against it AT
+* COMPILE TIME, in both directions (a missing code, an extra code or a different phase is a type
+* error), so the two cannot drift. The core codes' phases are core's `GALA_ERROR_PHASE_BY_CODE`.
 */
-var GSwapSDKError = class GSwapSDKError extends Error {
-	/** The stable, machine-readable code. */
-	code;
-	/** The named placeholders of the error: a flat object of primitives, safe to localize with. */
-	params;
-	/** The server's `Retry-After` in milliseconds (a `RATE_LIMITED` answer), when it sent one. */
-	retryAfterMs;
-	/** The HTTP status of the response that caused this error, when there was one. */
-	status;
-	/**
-	* The response body parsed as JSON, when the failing response had one; `undefined` for a body
-	* that was not JSON (see {@link bodyText}). Never part of {@link message}.
-	*/
-	body;
-	/**
-	* The raw text of a failing response whose body was NOT JSON (a proxy's HTML 502, a WAF page,
-	* an empty body). It is kept here for diagnostics and is never copied into {@link message},
-	* so it cannot reach a user interface by accident.
-	*/
-	bodyText;
-	/** The URL the failing request went to, when there was one. */
-	url;
-	/** The `uniqueKey` of the write this error is about, when there is one. */
-	uniqueKey;
-	/** The transaction id of the queued request, when known. */
-	requestTransactionId;
-	/** The transaction id of the apply, when known. */
-	applyTransactionId;
-	/** The block the apply landed in, when known. */
-	blockNumber;
-	/**
-	* How far the operation had got when this was thrown, against the request it exists to send
-	* (see {@link GSwapErrorPhase}): `pre_send` means NOTHING was transmitted, so a write that
-	* failed this way cannot have been queued; `in_flight` means the request left and no answer was
-	* read; `post_send` means an answer was read or the write was already accepted. Every catalog
-	* code declares its phase, and a throw site can refine it. Read it with
-	* {@link isPreSendError}; `classifyFailure` already folds it into `outcome` and `retryable`.
-	*/
-	phase;
-	/**
-	* True when this error came from the shadow (dark) path: `swapShadow`, `submitSwapShadow` or
-	* `ChainGateway.submitShadow`, whatever failed there (a validation error, the signer, the
-	* transport, `SHADOW_NOT_QUEUED`). The classification is the same as on the public path; this
-	* is how an app applies its own dark-swap policy (the wallet and frontend_v2 never offer a
-	* public fallback or Retry after one). A shadow gateway refusal that RESOLVES (`{ ok: false }`)
-	* is not an error and has no flag: the call itself says it was shadow.
-	*/
-	shadow;
-	/**
-	* Whether this failure is a WRITE's, as the guards read it: `false` only for the failure of a
-	* READ (a quote, a pool list, an apply-results read), which has no `uniqueKey` to confirm and
-	* nothing pending, so a 5xx there is `transient` and retryable. It is `true` for everything else,
-	* and always when {@link uniqueKey} is set. That is fail-closed: a failure that does not say it
-	* is a read is judged a write, where a 5xx is `unknown` and never retried. Apps that carry an
-	* error through their own wrapper copy this field next to `uniqueKey` (`FailureView.write`).
-	*/
-	write;
-	/**
-	* On `SIGNING_FAILED`: the code the wallet put on the error its signer threw, when it set one: an
-	* EIP-1193 / JSON-RPC number such as `4001` (the person declined) or `-32603`, or an ethers /
-	* viem string such as `'ACTION_REJECTED'`. It is read from the `cause`'s own `code` and is
-	* always a short primitive; `undefined` when the wallet sent none, and on every other code. It is
-	* a typed field, not a param: it is data for an app's analytics or its own wallet-specific
-	* wording, never part of `message`, and `params.reason` stays the stable thing to branch on.
-	*/
-	walletCode;
-	constructor(code, params, context = {}) {
-		super(renderGSwapErrorTemplate(GSWAP_ERROR_CATALOG[code].template, params), context.cause === void 0 ? void 0 : { cause: context.cause });
-		this.name = "GSwapSDKError";
-		this.code = code;
-		this.params = params;
-		this.retryAfterMs = context.retryAfterMs;
-		this.status = context.status;
-		this.body = typeof context.body === "string" ? void 0 : context.body;
-		this.bodyText = typeof context.body === "string" ? context.body : void 0;
-		this.url = context.url;
-		this.uniqueKey = context.uniqueKey;
-		this.requestTransactionId = context.requestTransactionId;
-		this.applyTransactionId = context.applyTransactionId;
-		this.blockNumber = context.blockNumber;
-		this.phase = context.phase ?? GSWAP_ERROR_CATALOG[code].phase;
-		this.shadow = context.shadow ?? false;
-		this.write = context.uniqueKey !== void 0 && context.uniqueKey !== "" ? true : context.write !== false;
-		this.walletCode = context.walletCode;
-	}
-	/**
-	* The SDK error brand (`Symbol.for('@gala-chain/gswap-sdk/error')`), always `true`. The
-	* dependency-free helpers (`isWalletUserRejection`, `isGSwapErrorLike`) recognise an SDK error
-	* by it instead of `instanceof`, so they work across copies of the SDK and without importing
-	* this class. It lives on the prototype: it is not an own property and is never copied or logged.
-	*/
-	get [GSWAP_ERROR_BRAND]() {
-		return true;
-	}
-	/**
-	* True when the failure means "that market, pool or position does not exist" rather than
-	* "something went wrong": an HTTP 404, a pair with no pool at any fee tier
-	* (`NO_POOL_AVAILABLE`), or a token the DEX contract has no trading symbol for
-	* (`UNKNOWN_TOKEN`). A pool that exists but is too thin (`INSUFFICIENT_LIQUIDITY`) is NOT
-	* not-found.
-	*/
-	get notFound() {
-		return this.status === 404 || this.code === "NO_POOL_AVAILABLE" || this.code === "UNKNOWN_TOKEN";
-	}
-	/** Create the standard missing-signer error. */
-	static noSignerError() {
-		return new GSwapSDKError("NO_SIGNER", {});
-	}
-	/** Create the error used when confirming a position write without a configured wallet address. */
-	static noWalletAddressError() {
-		return new GSwapSDKError("NO_WALLET_ADDRESS", {});
-	}
-	/**
-	* Create the error used when no pool can quote the requested pair. `source` is the backend
-	* answer that said so; its status and body are kept.
-	*/
-	static noPoolAvailableError(tokenIn, tokenOut, fee, source) {
-		return new GSwapSDKError("NO_POOL_AVAILABLE", {
-			tokenIn: tokenText(tokenIn),
+const GSWAP_ERROR_PHASE_BY_CODE = {
+	HTTP_ERROR: "post_send",
+	UPDATE_REQUIRED: "post_send",
+	REQUEST_FAILED: "in_flight",
+	METHOD_NOT_SUPPORTED: "pre_send",
+	SUBMISSION_OUTCOME_UNKNOWN: "in_flight",
+	GATEWAY_REPORTED_ERROR: "post_send",
+	GATEWAY_DATA_MISSING: "post_send",
+	GATEWAY_MODE_INVALID: "post_send",
+	GATEWAY_SYNC_REQUEST_TRADE: "post_send",
+	MISSING_UNIQUE_KEY: "post_send",
+	UNIQUE_KEY_MISMATCH: "post_send",
+	SHADOW_NOT_QUEUED: "post_send",
+	SHADOW_SUBMIT_NEEDS_WALLET_ADDRESS: "pre_send",
+	METHOD_NOT_ALLOWED: "post_send",
+	SIGNATURE_INVALID: "post_send",
+	SIGNER_MISMATCH: "post_send",
+	DTO_INVALID: "post_send",
+	BOUNDS_VIOLATION: "post_send",
+	SYMBOL_CONFLICT: "post_send",
+	RATE_LIMITED: "post_send",
+	CHAIN_DISPATCH_FAILED: "post_send",
+	GATEWAY_REJECTED: "post_send",
+	CHAIN_REJECTED: "post_send",
+	INVALID_CHAIN_RESPONSE: "post_send",
+	INVALID_POSITION_RESPONSE: "post_send",
+	CONFIRMATION_TIMEOUT: "post_send",
+	CONFIRMATION_ABORTED: "post_send",
+	CONFIRMATION_FAILED: "post_send",
+	CONFIRMATION_MALFORMED: "post_send",
+	CONFIRMATION_KEY_MISMATCH: "post_send",
+	NO_SIGNER: "pre_send",
+	NO_WALLET_ADDRESS: "post_send",
+	NO_POOL_AVAILABLE: "post_send",
+	INSUFFICIENT_LIQUIDITY: "post_send",
+	UNKNOWN_TOKEN: "pre_send",
+	SYMBOL_NOT_FOUND: "pre_send",
+	STREAM_API_KEY_UNUSABLE: "pre_send",
+	STREAM_WEBSOCKET_UNAVAILABLE: "pre_send",
+	STREAM_NOT_CONNECTED: "pre_send",
+	STREAM_DISCONNECTED: "in_flight",
+	STREAM_REQUEST_TIMEOUT: "in_flight",
+	STREAM_CONNECT_FAILED: "in_flight",
+	STREAM_CLOSED_BEFORE_CONNECT: "in_flight",
+	STREAM_CONNECTION_CLOSED: "in_flight",
+	TOKEN_RESOLUTION_FAILED: "pre_send",
+	MISSING_WALLET_ADDRESS: "pre_send",
+	NON_CANONICAL_PAIR: "pre_send",
+	UNORDERABLE_SYMBOLS: "pre_send",
+	INVALID_TOKEN_CLASS_KEY: "pre_send",
+	INCOMPLETE_TOKEN_CLASS_KEY: "pre_send",
+	INVALID_TRADING_SYMBOL: "pre_send",
+	NO_VALID_TRADING_SYMBOL: "pre_send",
+	TOKEN_SYMBOL_NOT_REGISTERED: "pre_send",
+	SYMBOL_DISAGREES_WITH_REGISTRY: "pre_send",
+	CREATE_POOL_NEEDS_CLASS_KEY: "pre_send",
+	AMOUNT_IS_JS_NUMBER: "pre_send",
+	AMOUNT_NOT_FINITE: "pre_send",
+	AMOUNT_NOT_POSITIVE: "pre_send",
+	AMOUNT_NEGATIVE: "pre_send",
+	PRICE_VALUES_IS_JS_NUMBER: "pre_send",
+	INVALID_PRICE_VALUES: "pre_send",
+	INVALID_PRICE_RANGE: "pre_send",
+	INVALID_PRICE_BOUNDS: "pre_send",
+	PRICE_BOUNDS_ORDER: "pre_send",
+	INVALID_STARTING_PRICE: "pre_send",
+	INVALID_SQRT_PRICE: "pre_send",
+	INVALID_TOKEN_DECIMALS: "pre_send",
+	TICKS_NOT_INTEGERS: "pre_send",
+	INVALID_TICK_RANGE: "pre_send",
+	TICKS_OUT_OF_BOUNDS: "pre_send",
+	TICKS_NOT_ALIGNED: "pre_send",
+	INVALID_TICK_SPACING: "pre_send",
+	INVALID_FEE: "pre_send",
+	EXACT_AMOUNT_REQUIRED: "pre_send",
+	EXACTLY_ONE_OF_REQUIRED: "pre_send",
+	AT_MOST_ONE_OF_ALLOWED: "pre_send",
+	POOL_MISMATCH: "pre_send",
+	INVALID_DTO: "pre_send",
+	DTO_NOT_CANONICAL: "pre_send",
+	SEARCH_TOO_LONG: "pre_send",
+	INVALID_SORT_BY: "pre_send",
+	INVALID_SORT_ORDER: "pre_send",
+	INVALID_PAGE: "pre_send",
+	INVALID_LIMIT: "pre_send",
+	INVALID_MARKET_TOKEN: "pre_send",
+	INVALID_TIMEFRAME: "pre_send",
+	INVALID_SEASON_ID: "pre_send",
+	INVALID_POLL_INTERVAL: "pre_send"
+};
+/** True for a DEX code (gswap-sdk's own catalog). */
+function isDexCatalogCode(code) {
+	return Object.hasOwn(GSWAP_ERROR_PHASE_BY_CODE, code);
+}
+/** True for a code a `GSwapSDKError` can carry: a core code or a DEX code. */
+function isCatalogCode(code) {
+	return (0, _gala_chain_gala_core_sdk.isGalaCatalogCode)(code) || isDexCatalogCode(code);
+}
+/**
+* The phase of a view: the one it states, else the catalog's phase for its code (core's or the
+* DEX catalog's), else `undefined`.
+*/
+function phaseOfView(view) {
+	if (view.phase !== void 0) return view.phase;
+	if ((0, _gala_chain_gala_core_sdk.isGalaCatalogCode)(view.code)) return _gala_chain_gala_core_sdk.GALA_ERROR_PHASE_BY_CODE[view.code];
+	return isDexCatalogCode(view.code) ? GSWAP_ERROR_PHASE_BY_CODE[view.code] : void 0;
+}
+
+//#endregion
+//#region src/classes/gswap_sdk_error.ts
+/**
+* The HTTP status of a version wall: the backend refuses an app version that is too old (HTTP 426
+* Upgrade Required). It is `UPDATE_REQUIRED` on every request the SDK sends, whatever else the body
+* says; a confirmation read keeps `CONFIRMATION_FAILED` because the write it confirms may be applied.
+*/
+const UPDATE_REQUIRED_STATUS = 426;
+/**
+* Error raised by gswap-sdk for validation, gateway, chain, or transaction failures. It is a
+* `GalaSDKError` (`@gala-chain/gala-core-sdk`), and can carry any code of the core catalog or of
+* gswap-sdk's own DEX catalog: the signing, transport and wallet failures of a gswap flow are core
+* codes, thrown either as a `GSwapSDKError` by gswap-sdk or as a plain `GalaSDKError` by core
+* itself (a signer, the fetch requestor). Catch both with `isGSwapError` (or core's `isGalaError`);
+* `instanceof GSwapSDKError` alone misses the second kind.
+*
+* Branch on {@link code} (stable) and render {@link params} through your own localization.
+* {@link message} is English generated from the catalog template for logs and developers: it
+* is not stable and must never be shown to a user or matched on.
+*/
+var GSwapSDKError = class GSwapSDKError extends _gala_chain_gala_core_sdk.GalaSDKError {
+	/** Core's catalog entries and the DEX entries: a `GSwapSDKError` can carry a code of either. */
+	static catalog = GSWAP_SDK_ERROR_ENTRIES;
+	constructor(code, params, context = {}) {
+		super(code, params, context);
+		this.name = "GSwapSDKError";
+	}
+	/**
+	* True when the failure means "that market, pool or position does not exist" rather than
+	* "something went wrong": an HTTP 404, a pair with no pool at any fee tier
+	* (`NO_POOL_AVAILABLE`), or a token the DEX contract has no trading symbol for
+	* (`UNKNOWN_TOKEN`). A pool that exists but is too thin (`INSUFFICIENT_LIQUIDITY`) is NOT
+	* not-found.
+	*/
+	get notFound() {
+		return super.notFound || this.code === "NO_POOL_AVAILABLE" || this.code === "UNKNOWN_TOKEN";
+	}
+	/** Create the standard missing-signer error. */
+	static noSignerError() {
+		return new GSwapSDKError("NO_SIGNER", {});
+	}
+	/** Create the error used when confirming a position write without a configured wallet address. */
+	static noWalletAddressError() {
+		return new GSwapSDKError("NO_WALLET_ADDRESS", {});
+	}
+	/**
+	* Create the error used when no pool can quote the requested pair. `source` is the backend
+	* answer that said so; its status and body are kept.
+	*/
+	static noPoolAvailableError(tokenIn, tokenOut, fee, source) {
+		return new GSwapSDKError("NO_POOL_AVAILABLE", {
+			tokenIn: tokenText(tokenIn),
 			tokenOut: tokenText(tokenOut),
 			fee: feeText(fee)
 		}, sourceContext(source));
@@ -1571,7 +1015,7 @@ var GSwapSDKError = class GSwapSDKError extends Error {
 	/** Convert an unexpected HTTP response into an SDK error. */
 	static async fromErrorResponse(url, response) {
 		const bodyText = await response.text();
-		const bodyJson = parseJson(bodyText);
+		const bodyJson = (0, _gala_chain_gala_core_sdk.parseJson)(bodyText);
 		const errorObject = getObjectProperty(bodyJson, "error");
 		const errorKey = getStringProperty(errorObject, "ErrorKey");
 		const message = getStringProperty(errorObject, "Message");
@@ -1620,7 +1064,7 @@ function sourceContext(source) {
 	};
 }
 function isGSwapError(value, code) {
-	return value instanceof GSwapSDKError && (code === void 0 || value.code === code);
+	return value instanceof _gala_chain_gala_core_sdk.GalaSDKError && (code === void 0 || value.code === code);
 }
 /**
 * True when `value` is an SDK error that was thrown BEFORE anything was transmitted
@@ -1635,8 +1079,9 @@ function isGSwapError(value, code) {
 * error is pre-send too, and repeating the same call fails the same way.
 *
 * It also answers for a plain-object view of an SDK error (`{ code, phase? }`, see
-* `FailureView`): the view's own `phase`, else the catalog's phase for its `code`. It is a plain
-* `boolean`, not a type guard (a view is not a `GSwapSDKError`); use `isGSwapError` to narrow.
+* `FailureView`): the view's own `phase`, else the catalog's phase for its `code` (a core code or
+* a DEX code). It is a plain `boolean`, not a type guard (a view is not a `GSwapSDKError`); use
+* `isGSwapError` to narrow.
 *
 * @example
 * ```ts
@@ -1644,7 +1089,7 @@ function isGSwapError(value, code) {
 * ```
 */
 function isPreSendError(value) {
-	const view = toFailureView(value);
+	const view = (0, _gala_chain_gala_core_sdk.toFailureView)(value);
 	return view !== void 0 && phaseOfView(view) === "pre_send";
 }
 /** Narrow an object property without trusting a cast at a network boundary. */
@@ -1659,165 +1104,6 @@ function getStringProperty(value, property) {
 	const propertyValue = value[property];
 	return typeof propertyValue === "string" ? propertyValue : void 0;
 }
-/** Parse a response body, preserving non-JSON text for error reporting. */
-function parseJson(text) {
-	try {
-		return JSON.parse(text);
-	} catch {
-		return;
-	}
-}
-
-//#endregion
-//#region src/version.ts
-/** Package version embedded by the bundler, with a source-test fallback. */
-const SDK_VERSION = "1.2.0";
-
-//#endregion
-//#region src/utils/transport.ts
-/**
-* Arms the abort timer for a request. `Infinity` means "never time out": `setTimeout` would turn
-* it into 1 ms, so no timer is armed at all. Returns a function that disarms it.
-*/
-function armTimeout(controller, timeoutMs) {
-	if (timeoutMs === Infinity) return () => void 0;
-	const timer = setTimeout(() => controller.abort(), timeoutMs);
-	return () => clearTimeout(timer);
-}
-/**
-* Validates a request timeout in milliseconds: a positive finite number, or `Infinity` for none.
-*
-* @throws GSwapSDKError `INVALID_TIMEOUT` (`params.field` = `name`) otherwise.
-*/
-function validateTimeoutMs(timeoutMs, name) {
-	if (timeoutMs === Infinity || Number.isFinite(timeoutMs) && timeoutMs > 0) return timeoutMs;
-	throw new GSwapSDKError("INVALID_TIMEOUT", {
-		field: name,
-		value: timeoutMs
-	});
-}
-const READABLE_QUERY_SAFE = /[A-Za-z0-9\-._~!'()*$|:,]/u;
-function encodeReadable(text) {
-	let out = "";
-	for (const char of text) if (char === " ") out += "+";
-	else if (READABLE_QUERY_SAFE.test(char)) out += char;
-	else out += encodeScalar(char);
-	return out;
-}
-/** Percent-encodes one code point; a lone surrogate becomes U+FFFD, as `URLSearchParams` does. */
-function encodeScalar(char) {
-	try {
-		return encodeURIComponent(char);
-	} catch {
-		return "%EF%BF%BD";
-	}
-}
-/** Serializes GET parameters, in insertion order, in the encoding the wire options select. */
-function buildQueryString(params, encoding = "standard") {
-	if (encoding === "readable") return Object.entries(params).map(([key, value]) => `${encodeReadable(key)}=${encodeReadable(value)}`).join("&");
-	return new URLSearchParams(params).toString();
-}
-/**
-* The request headers for ANY SDK request, GET or POST, from one place so the wire options reach
-* every request alike. Order, which is the order the requestor sees them in: `User-Agent`
-* (`wire.userAgent`, default `GalaChain-SDK/<version>`, `false` omits it), `parts.defaults`,
-* `wire.headers`, `Content-Type` (JSON bodies only), `parts.fixed`. A later entry replaces an
-* earlier one of the same name regardless of case, so a header is never sent twice.
-*/
-function buildRequestHeaders(wire, parts = {}) {
-	const entries = /* @__PURE__ */ new Map();
-	const put = (headers, last = false) => {
-		for (const [name, value] of Object.entries(headers ?? {})) {
-			if (last) entries.delete(name.toLowerCase());
-			entries.set(name.toLowerCase(), [name, value]);
-		}
-	};
-	if ((wire === null || wire === void 0 ? void 0 : wire.userAgent) !== false) put({ "User-Agent": (wire === null || wire === void 0 ? void 0 : wire.userAgent) ?? `GalaChain-SDK/${"1.2.0"}` });
-	put(parts.defaults);
-	put(wire === null || wire === void 0 ? void 0 : wire.headers);
-	if (parts.json === true && !entries.has("content-type")) put({ "Content-Type": "application/json" });
-	put(parts.fixed, true);
-	return Object.fromEntries(entries.values());
-}
-/**
-* The default requestor: the global `fetch`, with a failure before any answer (offline, DNS,
-* CORS) coded as `TRANSPORT_ERROR` and the original error kept as `cause`. An aborted request is
-* left to {@link requestWithTimeout}, which knows whether the timeout or the caller aborted it.
-* A requestor the app supplies is not wrapped: its rejection reaches the caller unchanged.
-*/
-const fetchRequestor = async (url, init) => {
-	try {
-		return await fetch(url, init);
-	} catch (error) {
-		var _init$signal;
-		if ((init === null || init === void 0 || (_init$signal = init.signal) === null || _init$signal === void 0 ? void 0 : _init$signal.aborted) === true) throw error;
-		throw new GSwapSDKError("TRANSPORT_ERROR", { url }, {
-			url,
-			cause: error
-		});
-	}
-};
-async function requestWithTimeout(requestor, url, options, timeoutMs) {
-	const controller = new AbortController();
-	const disarm = armTimeout(controller, timeoutMs);
-	const externalSignal = options.signal;
-	const abortFromCaller = () => controller.abort();
-	externalSignal === null || externalSignal === void 0 || externalSignal.addEventListener("abort", abortFromCaller, { once: true });
-	try {
-		return await requestor(url, {
-			...options,
-			signal: controller.signal
-		});
-	} catch (error) {
-		if ((externalSignal === null || externalSignal === void 0 ? void 0 : externalSignal.aborted) === true) throw error;
-		if (controller.signal.aborted) throw new GSwapSDKError("REQUEST_TIMEOUT", {
-			url,
-			timeoutMs
-		}, {
-			url,
-			cause: error
-		});
-		throw error;
-	} finally {
-		disarm();
-		externalSignal === null || externalSignal === void 0 || externalSignal.removeEventListener("abort", abortFromCaller);
-	}
-}
-async function readResponseBody(response) {
-	const text = await response.text();
-	return parseJson(text) ?? text;
-}
-/** Read a case-insensitive response header from either supported header shape. */
-function readHeader(response, name) {
-	var _Object$entries$find;
-	const headers = response.headers;
-	if (headers === void 0) return void 0;
-	if (hasHeaderGetter(headers)) {
-		const value = headers.get(name);
-		return value === null || value === "" ? void 0 : value;
-	}
-	const value = (_Object$entries$find = Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase())) === null || _Object$entries$find === void 0 ? void 0 : _Object$entries$find[1];
-	return value === void 0 || value === "" ? void 0 : value;
-}
-/** Read a Retry-After header (delta-seconds or an HTTP date) as non-negative milliseconds. */
-function readRetryAfter(response) {
-	const raw = readHeader(response, "retry-after");
-	if (raw === void 0) return void 0;
-	const seconds = Number(raw);
-	if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
-	const timestamp = Date.parse(raw);
-	return Number.isNaN(timestamp) ? void 0 : Math.max(0, timestamp - Date.now());
-}
-/** Read a non-negative integer block number header. */
-function readBlockNumberHeader(response, headerName = "x-block-number") {
-	const raw = readHeader(response, headerName);
-	if (raw === void 0) return void 0;
-	const blockNumber = Number(raw);
-	return Number.isInteger(blockNumber) && blockNumber >= 0 ? blockNumber : void 0;
-}
-function hasHeaderGetter(headers) {
-	return "get" in headers && typeof headers.get === "function";
-}
 
 //#endregion
 //#region src/classes/apply_results.ts
@@ -1876,8 +1162,8 @@ var AppliedTradeError = class extends GSwapSDKError {
 */
 async function confirmAppliedTrade(client, input, options) {
 	const { uniqueKey } = input;
-	if (!isValidUniqueKey(uniqueKey)) throw new AppliedTradeError("INVALID_UNIQUE_KEY", { uniqueKey: String(uniqueKey) }, { uniqueKey });
-	const requestor = client.httpRequestor ?? fetchRequestor;
+	if (!(0, _gala_chain_gala_core_sdk.isValidUniqueKey)(uniqueKey)) throw new AppliedTradeError("INVALID_UNIQUE_KEY", { uniqueKey: String(uniqueKey) }, { uniqueKey });
+	const requestor = client.httpRequestor ?? _gala_chain_gala_core_sdk.fetchRequestor;
 	const requestTimeoutMs = client.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
 	const signal = options === null || options === void 0 ? void 0 : options.signal;
 	const abortError = (cause) => new AppliedTradeError("CONFIRMATION_ABORTED", {}, {
@@ -1893,12 +1179,12 @@ async function confirmAppliedTrade(client, input, options) {
 		let response;
 		let body;
 		try {
-			response = await requestWithTimeout(requestor, url, {
+			response = await (0, _gala_chain_gala_core_sdk.requestWithTimeout)(requestor, url, {
 				method: "GET",
-				headers: buildRequestHeaders(client.wire),
+				headers: (0, _gala_chain_gala_core_sdk.buildRequestHeaders)(client.wire),
 				...signal === void 0 ? {} : { signal }
 			}, requestTimeoutMs);
-			body = await readResponseBody(response);
+			body = await (0, _gala_chain_gala_core_sdk.readResponseBody)(response);
 		} catch (error) {
 			throwIfAborted(signal, abortError);
 			lastError = error;
@@ -1908,7 +1194,7 @@ async function confirmAppliedTrade(client, input, options) {
 		throwIfAborted(signal, abortError);
 		if (response.status === 200) return readAppliedResult(input, response, body, url);
 		if (response.status === 404 || response.status === 429 || isTransient(response.status)) {
-			const retryAfter = response.status === 429 ? readRetryAfter(response) : void 0;
+			const retryAfter = response.status === 429 ? (0, _gala_chain_gala_core_sdk.readRetryAfter)(response) : void 0;
 			if (!await schedule.waitForRead(retryAfter)) break;
 			continue;
 		}
@@ -1940,8 +1226,8 @@ function readAppliedResult(input, response, body, url) {
 		url
 	});
 	const status = record === null || record === void 0 ? void 0 : record["Status"];
-	const applyTransactionId = readHeader(response, "x-apply-transaction-id") ?? null;
-	const blockNumber = readBlockNumberHeader(response, "x-apply-block-number") ?? null;
+	const applyTransactionId = (0, _gala_chain_gala_core_sdk.readHeader)(response, "x-apply-transaction-id") ?? null;
+	const blockNumber = (0, _gala_chain_gala_core_sdk.readBlockNumberHeader)(response, "x-apply-block-number") ?? null;
 	if (status === 0) {
 		const errorKey = getStringProperty(record, "ErrorKey") ?? "CHAIN_ERROR";
 		const chainMessage = getStringProperty(record, "Message") ?? "";
@@ -1958,9 +1244,9 @@ function readAppliedResult(input, response, body, url) {
 			url
 		});
 	}
-	if (status !== 1) throw malformed$1(input, response, body, url);
+	if (status !== 1) throw malformed(input, response, body, url);
 	const result = parseTradeExecution(record === null || record === void 0 ? void 0 : record["Data"]);
-	if (result === void 0) throw malformed$1(input, response, body, url);
+	if (result === void 0) throw malformed(input, response, body, url);
 	return {
 		uniqueKey,
 		transactionId: applyTransactionId,
@@ -1969,7 +1255,7 @@ function readAppliedResult(input, response, body, url) {
 		result
 	};
 }
-function malformed$1(input, response, body, url) {
+function malformed(input, response, body, url) {
 	return new AppliedTradeError("CONFIRMATION_MALFORMED", {}, {
 		uniqueKey: input.uniqueKey,
 		status: response.status,
@@ -2369,7 +1655,10 @@ var Assets = class {
 function parseUserAssets(value) {
 	const data = getObjectProperty(value, "data");
 	const tokens = data === null || data === void 0 ? void 0 : data["token"];
-	if (!Array.isArray(tokens) || !tokens.every(isRawUserAsset)) throw new GSwapSDKError("INVALID_CHAIN_RESPONSE", { resource: "user assets response" }, { body: value });
+	if (!Array.isArray(tokens) || !tokens.every(isRawUserAsset)) throw new GSwapSDKError("INVALID_CHAIN_RESPONSE", { resource: "user assets response" }, {
+		body: value,
+		write: false
+	});
 	const count = data === null || data === void 0 ? void 0 : data["count"];
 	return {
 		tokens: tokens.map((token) => ({
@@ -2385,178 +1674,6 @@ function isRawUserAsset(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";
 }
 
-//#endregion
-//#region src/utils/wallet_rejection.ts
-/**
-* What the SDK knows about a failure thrown by a WALLET (the signer an app supplies, or wallet
-* code of the app's own): the code the wallet put on it, and whether it means the person declined.
-* Both read only the wallet's own error value; neither shows or forwards its text.
-*/
-/** Codes the EIP-1193 / ethers / viem families use for "the person declined in the wallet". */
-const REJECTION_CODES = [
-	4001,
-	"ACTION_REJECTED",
-	"USER_REJECTED"
-];
-/** The `name` viem / wagmi give the error of a declined request. */
-const REJECTION_NAME = "UserRejectedRequestError";
-/**
-* Wordings of a decline, matched case-insensitively as substrings. This is a LAST RESORT for
-* wallets that set neither a `code` nor a `name`: it reads a third party's text, so it is broad on
-* purpose (a superset of the matchers the Gala wallet and frontend_v2 used) and can in principle
-* match an unrelated message that uses these words.
-*/
-const REJECTION_PHRASES = [
-	"user rejected",
-	"user denied",
-	"user cancel",
-	"rejected the request",
-	"request rejected",
-	"rejected by user",
-	"action_rejected",
-	"cancelled",
-	"canceled"
-];
-/** Properties wallets nest their text under (EIP-1193, ethers, viem, Gala wallet). */
-const TEXT_KEYS = [
-	"message",
-	"Message",
-	"shortMessage",
-	"details",
-	"errorDetails",
-	"reason"
-];
-/** Wallet errors nest their text at most a level or two deep; the bound also stops a cyclic object. */
-const MAX_TEXT_DEPTH = 3;
-function isRecord$2(value) {
-	return typeof value === "object" && value !== null;
-}
-function textsOf(value, depth = 0) {
-	if (typeof value === "string") return [value];
-	if (!isRecord$2(value) || depth >= MAX_TEXT_DEPTH) return [];
-	return TEXT_KEYS.flatMap((key) => textsOf(value[key], depth + 1));
-}
-function wordsADecline(text) {
-	const lower = text.toLowerCase();
-	return REJECTION_PHRASES.some((phrase) => lower.includes(phrase)) || lower.includes("signature") && lower.includes("cancel");
-}
-/**
-* True when a wallet's error (or just its message text) says the person DECLINED the request in
-* their wallet. This is exactly the test behind `SIGNING_FAILED` with `params.reason ===
-* 'user_rejected'`, exported for wallet code outside the SDK (connect and registration flows, a
-* v1 write path) so an app keeps no matcher of its own.
-*
-* It is decided from the wallet's own fields first: a `code` of `4001` (EIP-1193), `'ACTION_REJECTED'`
-* (ethers) or `'USER_REJECTED'`, or `name === 'UserRejectedRequestError'` (viem). Only when those are
-* absent is the wallet's TEXT read (`message`, `Message`, `shortMessage`, `details`, `errorDetails`,
-* `reason`, up to three levels deep, or a bare string): "user rejected", "user denied", "user
-* cancelled", "request rejected", "rejected by user", "rejected the request", "cancelled" /
-* "canceled", or a "signature ... cancel" sentence. The wording fallback is a last resort for
-* wallets that do not set codes; prefer `code` and `name` wherever you control the wallet.
-*
-* An SDK error is never read by its text: a `SIGNING_FAILED` is a decline exactly when its
-* `params.reason` is `user_rejected`, and every other SDK error is not one. The same holds for a
-* plain-object VIEW of an SDK error (`{ code: 'SIGNING_FAILED', params: { reason } }`, the shape
-* of an app's wrapper): a string `code` plus an object `params` is decided by the code alone, with
-* the wallet code list above still honoured for a view that is not branded, and its English is
-* never read. This works without `instanceof`, so it is safe across two copies of the SDK.
-*
-* @example
-* ```ts
-* try {
-*   await wallet.connect();
-* } catch (error) {
-*   if (isWalletUserRejection(error)) return; // the person said no: not an error to report
-*   report(error);
-* }
-* ```
-*/
-function isWalletUserRejection(value) {
-	if (isGSwapErrorLike(value)) {
-		if (value.code === "SIGNING_FAILED") return value.params["reason"] === "user_rejected";
-		return !hasGSwapErrorBrand(value) && REJECTION_CODES.includes(value.code);
-	}
-	if (isRecord$2(value)) {
-		if (REJECTION_CODES.includes(value["code"]) || value["name"] === REJECTION_NAME) return true;
-	}
-	return textsOf(value).some(wordsADecline);
-}
-/** The longest wallet code kept: real ones (`4001`, `ACTION_REJECTED`) are short. */
-const MAX_WALLET_CODE_LENGTH = 64;
-/**
-* The code a wallet put on its error: an EIP-1193 / JSON-RPC number (`4001`, `-32603`) or an
-* ethers / viem string (`'ACTION_REJECTED'`), read from the error's own top-level `code`. Anything
-* else (no code, a non-finite number, an empty or very long string, an object) is `undefined`, so
-* the value is always a safe primitive. Used for `GSwapSDKError.walletCode`.
-*
-* @example
-* ```ts
-* walletDeclineCode({ code: 4001, message: 'User rejected the request.' }); // 4001
-* walletDeclineCode(new Error('locked')); // undefined
-* ```
-*/
-function walletDeclineCode(value) {
-	if (typeof value !== "object" || value === null) return void 0;
-	const { code } = value;
-	if (typeof code === "number") return Number.isFinite(code) ? code : void 0;
-	if (typeof code === "string" && code.length > 0 && code.length <= MAX_WALLET_CODE_LENGTH) return code;
-}
-
-//#endregion
-//#region src/utils/pre_send.ts
-/**
-* The boundary of "nothing was sent". Every place where the SDK hands control to code the APP
-* supplied BEFORE the request leaves (the signer, the token resolver) goes through here, so a
-* failure of that code reaches the caller as a catalogued, pre-send SDK error with the original as
-* `cause`, never as a bare value the SDK cannot classify. An SDK error thrown by that code is
-* already catalogued and passes through untouched. Nothing here is used after the request has
-* been sent: an app's own rejection AFTER send stays what it is, because the SDK cannot know what
-* the server did with the write.
-*/
-/**
-* Signs a DTO with the app's signer. Whatever the signer throws that is not already an SDK error
-* (a locked wallet, an unreachable extension, a wallet that declined) is `SIGNING_FAILED`
-* (`reason` `user_rejected` or `failed`, the original as `cause`), and a signer that returns
-* something other than an object is `SIGNING_FAILED` too: both are pre-send, so a retry is safe.
-*
-* @throws GSwapSDKError SIGNING_FAILED, or the SDK error the signer itself threw.
-*/
-async function signPreSend(signer, method, dto) {
-	let signed;
-	try {
-		signed = await signer.signObject(method, dto);
-	} catch (cause) {
-		if (isGSwapError(cause)) throw cause;
-		const reason = isWalletUserRejection(cause) ? "user_rejected" : "failed";
-		throw new GSwapSDKError("SIGNING_FAILED", {
-			method,
-			reason
-		}, {
-			cause,
-			walletCode: walletDeclineCode(cause)
-		});
-	}
-	if (typeof signed !== "object" || signed === null) throw new GSwapSDKError("SIGNING_FAILED", {
-		method,
-		reason: "failed"
-	}, { cause: signed });
-	return signed;
-}
-/**
-* Runs a token-resolution step (a resolver's `resolve` / `orderPair`, which may read the registry
-* through the app's HTTP stack). A failure that is not an SDK error is `TOKEN_RESOLUTION_FAILED`
-* (`token` names what was being resolved, the original is `cause`); an SDK error passes through.
-*
-* @throws GSwapSDKError TOKEN_RESOLUTION_FAILED, or the SDK error the step itself threw.
-*/
-async function resolvePreSend(token, run) {
-	try {
-		return await run();
-	} catch (cause) {
-		throw isGSwapError(cause) ? cause : new GSwapSDKError("TOKEN_RESOLUTION_FAILED", { token }, { cause });
-	}
-}
-
 //#endregion
 //#region src/classes/dex_fees.ts
 /** DEX methods the backend accepts a fee quote for (its allow-list enumerates the same six). */
@@ -2603,11 +1720,11 @@ function toChainDto(message) {
 * `uniqueKey`, distinct from the DTO's.
 */
 function buildDryRunWrapper(signer, callerPublicKey, method, dto, uniqueKeyPrefix = DRY_RUN_UNIQUE_KEY_PREFIX) {
-	return signPreSend(signer, DRY_RUN_METHOD, {
+	return (0, _gala_chain_gala_core_sdk.signPreSend)(signer, DRY_RUN_METHOD, {
 		callerPublicKey,
 		method,
 		dto,
-		uniqueKey: `${uniqueKeyPrefix}${globalThis.crypto.randomUUID()}`
+		uniqueKey: (0, _gala_chain_gala_core_sdk.createUniqueKey)(uniqueKeyPrefix)
 	});
 }
 /**
@@ -2634,7 +1751,7 @@ var DexFees = class {
 	wire;
 	constructor(client, signer) {
 		this.signer = signer;
-		this.requestor = client.httpRequestor ?? fetchRequestor;
+		this.requestor = client.httpRequestor ?? _gala_chain_gala_core_sdk.fetchRequestor;
 		this.baseUrl = client.dexBackendBaseUrl.replace(/\/$/u, "");
 		this.requestTimeoutMs = client.requestTimeoutMs ?? 3e4;
 		this.wire = client.wire;
@@ -2664,9 +1781,9 @@ var DexFees = class {
 		let ok;
 		let body;
 		try {
-			const response = await requestWithTimeout(this.requestor, url, {
+			const response = await (0, _gala_chain_gala_core_sdk.requestWithTimeout)(this.requestor, url, {
 				method: "POST",
-				headers: buildRequestHeaders(this.wire, {
+				headers: (0, _gala_chain_gala_core_sdk.buildRequestHeaders)(this.wire, {
 					json: true,
 					defaults: { Accept: "application/json" }
 				}),
@@ -2674,7 +1791,7 @@ var DexFees = class {
 			}, this.requestTimeoutMs);
 			status = response.status;
 			ok = response.ok;
-			body = ok ? await readResponseBody(response) : void 0;
+			body = ok ? await (0, _gala_chain_gala_core_sdk.readResponseBody)(response) : void 0;
 		} catch {
 			return null;
 		}
@@ -2725,13 +1842,15 @@ const shadowRejections = /* @__PURE__ */ new WeakSet();
 function isShadowError(value) {
 	var _toFailureView;
 	if (isGSwapError(value)) return value.shadow;
-	if (((_toFailureView = toFailureView(value)) === null || _toFailureView === void 0 ? void 0 : _toFailureView.shadow) === true) return true;
+	if (((_toFailureView = (0, _gala_chain_gala_core_sdk.toFailureView)(value)) === null || _toFailureView === void 0 ? void 0 : _toFailureView.shadow) === true) return true;
 	return typeof value === "object" && value !== null && shadowRejections.has(value);
 }
 /**
 * The same failure, marked as shadow. An SDK error is COPIED (same code, params, status, body,
-* url, ids, cause, phase and stack), never mutated: one error object can be shared by several
-* callers (a registry read many swaps wait on), and only the shadow caller's copy is shadow.
+* url, ids, cause, phase, read/write, wallet code and stack), never mutated: one error object can
+* be shared by several callers (a registry read many swaps wait on), and only the shadow caller's
+* copy is shadow. Everything the deciders read is carried over, so the copy classifies exactly as
+* the original (a failed READ stays a read, never a "maybe queued" write).
 */
 function asShadowError(error) {
 	if (isGSwapError(error)) {
@@ -2747,6 +1866,8 @@ function asShadowError(error) {
 			retryAfterMs: error.retryAfterMs,
 			cause: error.cause,
 			phase: error.phase,
+			write: error.write,
+			walletCode: error.walletCode,
 			shadow: true
 		});
 		if (error.stack !== void 0) copy.stack = error.stack;
@@ -2829,6 +1950,12 @@ var SubmittedTransaction = class {
 	* For RequestTrade, calling this method is required to learn the outcome: the queued
 	* acknowledgement proves acceptance, not execution.
 	*
+	* Every failure is the write's (it carries `uniqueKey`, so `mayHaveBeenQueued` is true): a
+	* re-read that cannot succeed is `CONFIRMATION_FAILED` (a terminal HTTP status) or
+	* `CONFIRMATION_MALFORMED` (an unusable answer); one that may (no answer, a 5xx, 404, 408,
+	* 429) is read again until the deadline, then `CONFIRMATION_TIMEOUT` with the last read error
+	* as `cause`. Confirm the same transaction again; never resubmit the write.
+	*
 	* @example
 	* ```ts
 	* const applied = await submitted.confirm({ initialDelayMs: 3_000 });
@@ -2866,9 +1993,10 @@ var SubmittedTransaction = class {
 		});
 		const schedule = createConfirmationSchedule(options, 0, abortError);
 		await schedule.waitForRead();
+		let lastError;
 		while (true) {
 			const controller = new AbortController();
-			const disarm = armTimeout(controller, this.requestTimeoutMs);
+			const disarm = (0, _gala_chain_gala_core_sdk.armTimeout)(controller, this.requestTimeoutMs);
 			const forwardAbort = () => controller.abort();
 			callerSignal === null || callerSignal === void 0 || callerSignal.addEventListener("abort", forwardAbort, { once: true });
 			try {
@@ -2876,27 +2004,60 @@ var SubmittedTransaction = class {
 				if (result.confirmed) return result.position;
 			} catch (error) {
 				throwIfAborted(callerSignal, abortError);
-				throw error;
+				const terminal = terminalPositionReadFailure(this.uniqueKey, error);
+				if (terminal !== void 0) throw terminal;
+				lastError = error;
 			} finally {
 				disarm();
 				callerSignal === null || callerSignal === void 0 || callerSignal.removeEventListener("abort", forwardAbort);
 			}
 			if (!await schedule.waitForRead()) break;
 		}
-		throw GSwapSDKError.confirmationTimeoutError(this.uniqueKey);
+		throw GSwapSDKError.confirmationTimeoutError(this.uniqueKey, lastError);
 	}
 };
-
-//#endregion
-//#region src/classes/gateway.ts
-/** Thin client for backend-routed v2 writes: synchronous liquidity writes and queued RequestTrade. */
-var ChainGateway = class {
-	requestor;
-	walletAddress;
-	chainCallTimeoutMs;
-	isTransportFailure;
-	answerOfRejectionHook;
-	/** The request timeout in milliseconds (`Infinity` when no timer is armed). */
+/** HTTP answers a confirmation reads again (as the apply-results poll does), not terminal ones. */
+function isRetriedStatus(status) {
+	return status === 404 || status === 408 || status === 429 || status >= 500;
+}
+/**
+* The confirmation error for a position re-read that failed TERMINALLY (an answer that reading
+* again cannot change), or `undefined` when it is worth reading again.
+*/
+function terminalPositionReadFailure(uniqueKey, error) {
+	if (!isGSwapError(error)) return void 0;
+	if (error.code === "INVALID_POSITION_RESPONSE" || error.code === "INVALID_CHAIN_RESPONSE") return new GSwapSDKError("CONFIRMATION_MALFORMED", {}, {
+		uniqueKey,
+		url: error.url,
+		body: error.body ?? error.bodyText,
+		cause: error
+	});
+	const status = error.status;
+	if ((error.code === "HTTP_ERROR" || error.code === "UPDATE_REQUIRED") && status !== void 0 && !isRetriedStatus(status)) {
+		const serverMessage = error.params["serverMessage"];
+		return new GSwapSDKError("CONFIRMATION_FAILED", {
+			status,
+			serverMessage: typeof serverMessage === "string" ? serverMessage : ""
+		}, {
+			uniqueKey,
+			status,
+			url: error.url,
+			body: error.body ?? error.bodyText,
+			cause: error
+		});
+	}
+}
+
+//#endregion
+//#region src/classes/gateway.ts
+/** Thin client for backend-routed v2 writes: synchronous liquidity writes and queued RequestTrade. */
+var ChainGateway = class {
+	requestor;
+	walletAddress;
+	chainCallTimeoutMs;
+	isTransportFailure;
+	answerOfRejectionHook;
+	/** The request timeout in milliseconds (`Infinity` when no timer is armed). */
 	requestTimeoutMs;
 	/** The swap backend base URL every request is sent to, without a trailing slash. */
 	dexBackendBaseUrl;
@@ -2905,9 +2066,9 @@ var ChainGateway = class {
 	/** Create a chain gateway client. */
 	constructor(options) {
 		this.dexBackendBaseUrl = trimTrailingSlash$1(options.dexBackendBaseUrl);
-		this.requestor = options.httpRequestor ?? fetchRequestor;
+		this.requestor = options.httpRequestor ?? _gala_chain_gala_core_sdk.fetchRequestor;
 		this.walletAddress = options.walletAddress;
-		this.chainCallTimeoutMs = validateTimeoutMs(options.chainCallTimeoutMs ?? 3e4, "chainCallTimeoutMs");
+		this.chainCallTimeoutMs = (0, _gala_chain_gala_core_sdk.validateTimeoutMs)(options.chainCallTimeoutMs ?? 3e4, "chainCallTimeoutMs");
 		this.requestTimeoutMs = this.chainCallTimeoutMs;
 		this.wire = options.wire ?? {};
 		this.isTransportFailure = options.isTransportFailure;
@@ -2917,7 +2078,7 @@ var ChainGateway = class {
 		if (method === "Trade") throw new GSwapSDKError("METHOD_NOT_SUPPORTED", { method });
 		const url = this.writeUrl(method);
 		const walletAddress = (options === null || options === void 0 ? void 0 : options.walletAddress) ?? this.walletAddress;
-		const headers = buildRequestHeaders(this.wire, {
+		const headers = (0, _gala_chain_gala_core_sdk.buildRequestHeaders)(this.wire, {
 			json: true,
 			fixed: walletAddress === void 0 ? {} : { "X-Wallet-Address": walletAddress }
 		});
@@ -2946,9 +2107,9 @@ var ChainGateway = class {
 				if (resultStatus !== void 0 && resultStatus !== 1) throw GSwapSDKError.fromChainError(getStringProperty(embeddedResult, "ErrorKey") ?? "CHAIN_ERROR", getStringProperty(embeddedResult, "Message") ?? "", context);
 			}
 		}
-		const headerTransactionId = readHeader(response, "x-transaction-id");
+		const headerTransactionId = (0, _gala_chain_gala_core_sdk.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;
+		const blockNumber = bodyBlockNumber === null || bodyBlockNumber === void 0 ? (0, _gala_chain_gala_core_sdk.readBlockNumberHeader)(response) : isBlockNumber(bodyBlockNumber) ? bodyBlockNumber : void 0;
 		return new SubmittedTransaction({
 			method,
 			uniqueKey,
@@ -2991,7 +2152,7 @@ var ChainGateway = class {
 		if (method === "Trade") throw new GSwapSDKError("METHOD_NOT_SUPPORTED", { method });
 		const walletAddress = (options === null || options === void 0 ? void 0 : options.walletAddress) ?? this.walletAddress;
 		if (walletAddress === void 0) throw new GSwapSDKError("SHADOW_SUBMIT_NEEDS_WALLET_ADDRESS", {});
-		const headers = buildRequestHeaders(this.wire, {
+		const headers = (0, _gala_chain_gala_core_sdk.buildRequestHeaders)(this.wire, {
 			json: true,
 			fixed: {
 				"X-Wallet-Address": walletAddress,
@@ -3030,7 +2191,7 @@ var ChainGateway = class {
 		});
 		let response;
 		try {
-			response = await requestWithTimeout(this.requestor, url, {
+			response = await (0, _gala_chain_gala_core_sdk.requestWithTimeout)(this.requestor, url, {
 				method: "POST",
 				headers,
 				body: payload
@@ -3045,7 +2206,7 @@ var ChainGateway = class {
 		try {
 			return {
 				response,
-				body: await readResponseBody(response)
+				body: await (0, _gala_chain_gala_core_sdk.readResponseBody)(response)
 			};
 		} catch (error) {
 			throw outcomeUnknown("transport", error);
@@ -3130,7 +2291,7 @@ function gatewayError(response, body, url, uniqueKey) {
 	const nested = getObjectProperty(body, "error");
 	const code = getStringProperty(object, "code") ?? getStringProperty(nested, "code") ?? getStringProperty(nested, "ErrorKey") ?? "HTTP_ERROR";
 	const message = serverMessageOfBody(body);
-	const retryAfterMs = response.status === 429 ? readRetryAfter(response) : void 0;
+	const retryAfterMs = response.status === 429 ? (0, _gala_chain_gala_core_sdk.readRetryAfter)(response) : void 0;
 	if (code === "HTTP_ERROR") return new GSwapSDKError("HTTP_ERROR", {
 		status: response.status,
 		url,
@@ -3623,7 +2784,7 @@ var HttpClient = class {
 	* Create an HTTP client around fetch or an injected requestor. `wire` selects the query
 	* encoding and the `User-Agent` (see {@link WireOptions}).
 	*/
-	constructor(httpRequestor = fetchRequestor, timeoutMs = 3e4, wire = {}) {
+	constructor(httpRequestor = _gala_chain_gala_core_sdk.fetchRequestor, timeoutMs = 3e4, wire = {}) {
 		this.httpRequestor = httpRequestor;
 		this.timeoutMs = timeoutMs;
 		this.wire = wire;
@@ -3632,14 +2793,14 @@ var HttpClient = class {
 		const url = `${baseUrl}${basePath}${endpoint}`;
 		debugLog(`Sending request to ${url} with body:`, body);
 		const hasBody = Boolean(body);
-		const response = await requestWithTimeout(this.httpRequestor, url, {
+		const response = await (0, _gala_chain_gala_core_sdk.requestWithTimeout)(this.httpRequestor, url, {
 			method,
-			headers: buildRequestHeaders(this.wire, { json: hasBody }),
+			headers: (0, _gala_chain_gala_core_sdk.buildRequestHeaders)(this.wire, { json: hasBody }),
 			...hasBody ? { body: JSON.stringify(body) } : {},
 			...(options === null || options === void 0 ? void 0 : options.signal) === void 0 ? {} : { signal: options.signal }
-		}, this.timeoutMs);
+		}, this.timeoutMs, { write: false });
 		if (!response.ok) throw await GSwapSDKError.fromErrorResponse(url, response);
-		const json = await readResponseBody(response);
+		const json = await (0, _gala_chain_gala_core_sdk.readResponseBody)(response);
 		debugLog(`Response from ${baseUrl}${basePath}${endpoint}:`, json);
 		return json;
 	}
@@ -3649,7 +2810,7 @@ var HttpClient = class {
 	}
 	/** Send a GET request with URL-encoded query parameters and decode its response. */
 	async sendGetRequest(baseUrl, basePath, endpoint, params, options) {
-		const endpointWithParams = params ? `${endpoint}?${buildQueryString(params, this.wire.queryEncoding)}` : endpoint;
+		const endpointWithParams = params ? `${endpoint}?${(0, _gala_chain_gala_core_sdk.buildQueryString)(params, this.wire.queryEncoding)}` : endpoint;
 		return this.sendRequest("GET", baseUrl, basePath, endpointWithParams, void 0, options);
 	}
 };
@@ -3673,10 +2834,13 @@ function entryRejected(reason) {
 /**
 * Reads a list answer row by row: a row that cannot be used is skipped and reported, instead of
 * rejecting the whole list because of one bad row. An answer that is not a list at all is still
-* `INVALID_CHAIN_RESPONSE`: nothing in it can be trusted.
+* `INVALID_CHAIN_RESPONSE` (a read's: `write: false`): nothing in it can be trusted.
 */
 function readEntries(source, data, parse, onInvalidEntry) {
-	if (!Array.isArray(data)) throw new GSwapSDKError("INVALID_CHAIN_RESPONSE", { resource: `${source} list` }, { body: data });
+	if (!Array.isArray(data)) throw new GSwapSDKError("INVALID_CHAIN_RESPONSE", { resource: `${source} list` }, {
+		body: data,
+		write: false
+	});
 	const rows = [];
 	data.forEach((entry, index) => {
 		const parsed = parse(entry);
@@ -3709,97 +2873,462 @@ function finiteNumberOf(value) {
 }
 
 //#endregion
-//#region src/utils/class_key.ts
+//#region src/classes/leaderboard.ts
 /**
-* Token class keys that never throw: the `$`-joined composite key and the non-throwing parsers.
-* This module imports nothing at run time (the key type is erased), so an app shell that reads a
-* stored key pays for a few hundred bytes, never for the error class or the catalog. The parser
-* that THROWS an SDK error on a bad key (`parseTokenClassKey`) lives in `ordering.ts`.
+* The swap backend's trading-competition reads: seasons (`GET /leaderboard/seasons`) and a
+* season's rankings (`GET /leaderboard?seasonId=`). Public reads: no signer, no wallet. A row that
+* is not usable is skipped and reported to `onInvalidEntry`; an answer that is not the expected
+* list is `INVALID_CHAIN_RESPONSE`.
 */
-/** Return the `$`-joined composite key used by GalaChain object identities. */
-function compositeKeyOf(token) {
-	return [
-		token.collection,
-		token.category,
-		token.type,
-		token.additionalKey
-	].join("$");
+var Leaderboard = class {
+	dexBackendBaseUrl;
+	httpClient;
+	options;
+	/**
+	* Creates a leaderboard service. `options.onInvalidEntry` is told about every season or entry
+	* row that was skipped as unusable.
+	*
+	* @example
+	* ```ts
+	* const leaderboard = new Leaderboard('https://dex-backend-prod1.defi.gala.com', httpClient);
+	* ```
+	*/
+	constructor(dexBackendBaseUrl, httpClient, options = {}) {
+		this.dexBackendBaseUrl = dexBackendBaseUrl;
+		this.httpClient = httpClient;
+		this.options = options;
+	}
+	/**
+	* Every active season, in the backend's order (newest first).
+	*
+	* @example
+	* ```ts
+	* const seasons = await gSwap.leaderboard.getSeasons();
+	* console.log(seasons.map((season) => season.name));
+	* ```
+	*/
+	async getSeasons(options) {
+		const response = await this.httpClient.sendGetRequest(this.dexBackendBaseUrl, "/leaderboard", "/seasons", void 0, signalOption$1(options));
+		return readEntries("seasons", response, parseSeason, (options === null || options === void 0 ? void 0 : options.onInvalidEntry) ?? this.options.onInvalidEntry);
+	}
+	/**
+	* The season running at `options.now` (default: now; `start` and `end` both count as inside),
+	* or `null` between seasons. When seasons overlap, the first in the backend's order.
+	*
+	* @example
+	* ```ts
+	* const season = await gSwap.leaderboard.getCurrentSeason();
+	* console.log(season === null ? 'no season running' : season.name);
+	* ```
+	*/
+	async getCurrentSeason(options) {
+		const now = ((options === null || options === void 0 ? void 0 : options.now) ?? /* @__PURE__ */ new Date()).getTime();
+		return (await this.getSeasons(options)).find((season) => season.start.getTime() <= now && now <= season.end.getTime()) ?? null;
+	}
+	/**
+	* A season's rankings (the backend's top 100 wallets). `seasonId` must be an integer of at
+	* least 1 (`INVALID_SEASON_ID` before anything is sent); a season with no rankings, or none at
+	* all, is an empty list.
+	*
+	* @example
+	* ```ts
+	* const { entries } = await gSwap.leaderboard.getLeaderboard(1);
+	* console.log(entries[0]?.wallet, entries[0]?.totalXp);
+	* ```
+	*/
+	async getLeaderboard(seasonId, options) {
+		var _asEntryRecord;
+		if (typeof seasonId !== "number" || !Number.isSafeInteger(seasonId) || seasonId < 1) throw new GSwapSDKError("INVALID_SEASON_ID", { value: String(seasonId) });
+		const response = await this.httpClient.sendGetRequest(this.dexBackendBaseUrl, "/leaderboard", "", { seasonId: String(seasonId) }, signalOption$1(options));
+		const rows = (_asEntryRecord = asEntryRecord(response)) === null || _asEntryRecord === void 0 ? void 0 : _asEntryRecord["leaderboard"];
+		if (!Array.isArray(rows)) throw new GSwapSDKError("INVALID_CHAIN_RESPONSE", { resource: "leaderboard" }, {
+			body: response,
+			write: false
+		});
+		return {
+			seasonId,
+			entries: readEntries("leaderboard", rows, parseEntry, (options === null || options === void 0 ? void 0 : options.onInvalidEntry) ?? this.options.onInvalidEntry)
+		};
+	}
+	/**
+	* The rankings of the season running at `options.now` (see
+	* {@link Leaderboard.getCurrentSeason}), or `null` between seasons.
+	*
+	* @example
+	* ```ts
+	* const current = await gSwap.leaderboard.getCurrentLeaderboard();
+	* if (current !== null) console.log(current.seasonId, current.entries.length);
+	* ```
+	*/
+	async getCurrentLeaderboard(options) {
+		const season = await this.getCurrentSeason(options);
+		return season === null ? null : this.getLeaderboard(season.id, options);
+	}
+};
+function signalOption$1(options) {
+	return (options === null || options === void 0 ? void 0 : options.signal) === void 0 ? void 0 : { signal: options.signal };
+}
+function positiveInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : void 0;
+}
+function isoDate(value) {
+	if (typeof value !== "string") return void 0;
+	const date = new Date(value);
+	return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+function parseSeason(entry) {
+	const record = asEntryRecord(entry);
+	if (record === void 0) return entryRejected("not an object");
+	const id = positiveInteger(record["id"]);
+	if (id === void 0) return entryRejected("id is not an integer of at least 1");
+	const name = record["name"];
+	if (typeof name !== "string") return entryRejected("name is not a string");
+	const start = isoDate(record["start"]);
+	const end = isoDate(record["end"]);
+	if (start === void 0 || end === void 0) return entryRejected("start or end is not a date");
+	if (start.getTime() > end.getTime()) return entryRejected("start is after end");
+	const rulesId = record["rules_id"];
+	if (typeof rulesId !== "number" || !Number.isSafeInteger(rulesId) || rulesId < 0) return entryRejected("rules_id is not an integer");
+	return entryOk({
+		id,
+		name,
+		start,
+		end,
+		rulesId
+	});
 }
-/**
-* Splits `collection<d>category<d>type<d>additionalKey` from the right, or `undefined` when there
-* are fewer than four segments or any of the four is empty. The one place the split is written;
-* the strict `parseTokenClassKey` calls it too.
-*
-* The LAST three segments are always `category`, `type` and `additionalKey`; everything before
-* them is the `collection`. Parsing from the right is required because real collections contain
-* the `$` delimiter themselves (for example `$GMUSIC`), so a plain left-to-right `split('$')`
-* shifts every field.
-*/
-function splitClassKey(key, delimiter) {
-	const segments = key.split(delimiter);
-	const tail = segments.slice(-3);
-	const collection = segments.slice(0, -3).join(delimiter);
-	if (segments.length < 4 || collection.length === 0 || tail.some((part) => part.length === 0)) return;
-	const [category, type, additionalKey] = tail;
+/** A non-negative decimal, as the backend's DECIMAL columns are serialized (or a finite number). */
+const DECIMAL = /^\d+(?:\.\d+)?$/u;
+function decimalOf(value) {
+	const text = typeof value === "number" ? String(value) : value;
+	return typeof text === "string" && DECIMAL.test(text) ? text : void 0;
+}
+function parseTitle(value) {
+	const record = asEntryRecord(value);
+	if (record === void 0) return void 0;
+	const { name, type, order } = record;
+	if (typeof name !== "string" || typeof type !== "string") return void 0;
+	if (typeof order !== "number" || !Number.isFinite(order)) return void 0;
 	return {
-		collection,
-		category,
+		name,
 		type,
-		additionalKey
+		order
 	};
 }
+function parseEntry(entry) {
+	const record = asEntryRecord(entry);
+	if (record === void 0) return entryRejected("not an object");
+	const wallet = record["wallet"];
+	if (typeof wallet !== "string" || wallet === "") return entryRejected("wallet is not a string");
+	const rank = positiveInteger(record["rank"]);
+	if (rank === void 0) return entryRejected("rank is not an integer of at least 1");
+	const rawTotal = record["total_xp"];
+	const totalXp = rawTotal === void 0 || rawTotal === null ? null : decimalOf(rawTotal);
+	if (totalXp === void 0) return entryRejected("total_xp is not a decimal");
+	const distributionPercent = decimalOf(record["distribution_percent"]);
+	const liquidityXp = decimalOf(record["liquidity_xp"]);
+	const tradingXp = decimalOf(record["trading_xp"]);
+	if (distributionPercent === void 0 || liquidityXp === void 0 || tradingXp === void 0) return entryRejected("distribution_percent, liquidity_xp or trading_xp is not a decimal");
+	const rawTitles = record["mastery_titles"];
+	if (!Array.isArray(rawTitles)) return entryRejected("mastery_titles is not a list");
+	const masteryTitles = [];
+	for (const raw of rawTitles) {
+		const title = parseTitle(raw);
+		if (title === void 0) return entryRejected("a mastery title is not { name, type, order }");
+		masteryTitles.push(title);
+	}
+	return entryOk({
+		wallet,
+		rank,
+		totalXp,
+		distributionPercent,
+		liquidityXp,
+		tradingXp,
+		masteryTitles
+	});
+}
+
+//#endregion
+//#region src/types/market.ts
+/**
+* The swap backend's market data and trading-competition reads: what `GSwap.market` and
+* `GSwap.leaderboard` return. Values are the backend's, unconverted: USD prices as numbers, times
+* as unix seconds or `Date`s, XP as decimal strings.
+*/
+/** The windows `GET /market/price-series` serves (the backend refuses any other with a 400). */
+const PRICE_SERIES_TIMEFRAMES = [
+	"1D",
+	"1W",
+	"1M",
+	"1Y",
+	"ALL"
+];
+/** The most tokens one `GET /market/price` request may name (the backend's limit). */
+const MARKET_PRICE_BATCH_LIMIT = 500;
+
+//#endregion
+//#region src/classes/market.ts
 /**
-* The non-throwing `parseTokenClassKey`: the class key, or `undefined` when `value` is not
-* one. A string is split exactly as `parseTokenClassKey` splits it (`|` form when it contains a
-* `|`, else `$`, from the right, all four parts non-empty). Unlike `parseTokenClassKey`, an
-* object is VALIDATED, not just copied: all four fields must be non-empty strings. Anything else
-* (`undefined`, `null`, a number, an array) is `undefined`, so it is safe on untrusted input (a
-* stored token, a URL parameter, a wallet row) without a `try`/`catch`.
-*
-* Use {@link tryParseCompositeKey} instead when only the `$` form is valid input.
+* The ids `GET /market/price` and `GET /market/price-series` accept (the backend's own allowlist):
+* a symbol, or a class key in the `$` or `|` form. A comma would split the price request.
+*/
+const MARKET_TOKEN_PATTERN = /^[A-Za-z0-9._$+/:|-]{1,120}$/u;
+/**
+* Market data from the swap backend: USD prices (`GET /market/price`), price series
+* (`GET /market/price-series`) and the platform volume totals (`GET /v2/trade/volume`). Public
+* reads: no signer, no wallet.
 *
-* @example
-* ```ts
-* const key = tryParseTokenClassKey(row.compositeKey);
-* if (key === undefined) return failClosed(); // no class is known: never invent one from a symbol
-* ```
+* A token is named by a symbol (`GALA`) or a class key (`GALA$Unit$none$none`,
+* `GALA|Unit|none|none` or the object). The backend answers each token under the exact id it was
+* asked for, so the answer is read back under that id: a token the backend has no entry for is
+* `undefined`, never another token's price.
 */
-function tryParseTokenClassKey(value) {
-	if (typeof value === "string") return splitClassKey(value, value.includes("|") ? "|" : "$");
-	if (typeof value !== "object" || value === null) return void 0;
-	try {
-		const { collection, category, type, additionalKey } = value;
-		if (typeof collection !== "string" || typeof category !== "string" || typeof type !== "string" || typeof additionalKey !== "string" || collection === "" || category === "" || type === "" || additionalKey === "") return;
+var Market = class {
+	dexBackendBaseUrl;
+	httpClient;
+	options;
+	/**
+	* Creates a market service. `options.onInvalidEntry` is told about every price or price point
+	* that was skipped as unusable.
+	*
+	* @example
+	* ```ts
+	* const market = new Market('https://dex-backend-prod1.defi.gala.com', httpClient);
+	* ```
+	*/
+	constructor(dexBackendBaseUrl, httpClient, options = {}) {
+		this.dexBackendBaseUrl = dexBackendBaseUrl;
+		this.httpClient = httpClient;
+		this.options = options;
+	}
+	/**
+	* USD prices of 1 to 500 tokens, in the order asked (a token named twice is asked for once).
+	* The ids go in as many requests as their length needs (see {@link MARKET_PRICE_QUERY_BYTES}),
+	* one after another; any request failing fails the call. A token the backend did not answer
+	* for is `undefined`; one it answered for unusably is `undefined` too, and reported to
+	* `onInvalidEntry`. An answer that is not an object is `INVALID_CHAIN_RESPONSE`.
+	*
+	* @example
+	* ```ts
+	* const [gala, gusdc] = await gSwap.market.getPrices(['GALA$Unit$none$none', 'GUSDC$Unit$none$none']);
+	* console.log(gala?.price, gusdc?.price);
+	* ```
+	*/
+	async getPrices(tokens, options) {
+		if (!Array.isArray(tokens) || tokens.length < 1 || tokens.length > 500) throw new GSwapSDKError("INVALID_TOKEN_BATCH", {
+			method: "getPrices",
+			count: Array.isArray(tokens) ? tokens.length : 0,
+			max: 500
+		});
+		const ids = tokens.map(marketTokenOf);
+		const answered = /* @__PURE__ */ new Map();
+		for (const batch of priceBatches([...new Set(ids)])) {
+			const response = await this.httpClient.sendGetRequest(this.dexBackendBaseUrl, "/market", "/price", { assetIds: batch.join(",") }, signalOption(options));
+			const answer = asEntryRecord(response);
+			if (answer === void 0) throw new GSwapSDKError("INVALID_CHAIN_RESPONSE", { resource: "market prices" }, {
+				body: response,
+				write: false
+			});
+			for (const id of batch) if (Object.hasOwn(answer, id)) answered.set(id, answer[id]);
+		}
+		const onInvalidEntry = (options === null || options === void 0 ? void 0 : options.onInvalidEntry) ?? this.options.onInvalidEntry;
+		return ids.map((id, index) => {
+			if (!answered.has(id)) return void 0;
+			const entry = answered.get(id);
+			const parsed = parseMarketPrice(id, entry);
+			if (parsed.ok) return parsed.value;
+			try {
+				onInvalidEntry === null || onInvalidEntry === void 0 || onInvalidEntry({
+					source: "prices",
+					index,
+					entry,
+					reason: parsed.reason
+				});
+			} catch {}
+		});
+	}
+	/**
+	* The USD price of one token, or `undefined` when the backend has no entry for it (see
+	* {@link Market.getPrices}).
+	*
+	* @example
+	* ```ts
+	* const gala = await gSwap.market.getPrice('GALA$Unit$none$none');
+	* if (gala?.price != null) console.log(`GALA: $${gala.price}`);
+	* ```
+	*/
+	async getPrice(token, options) {
+		const [price] = await this.getPrices([token], options);
+		return price;
+	}
+	/**
+	* A token's USD price line for one window (1D, 1W, 1M, 1Y or ALL; any other is
+	* `INVALID_TIMEFRAME` before anything is sent). The whole series in one answer, oldest first; a
+	* token the backend has no prices for is an empty series. An unusable point is skipped and
+	* reported to `onInvalidEntry`; an answer that is not a series is `INVALID_CHAIN_RESPONSE`.
+	*
+	* @example
+	* ```ts
+	* const series = await gSwap.market.getPriceSeries('GALA$Unit$none$none', '1W');
+	* console.log(series.prices.length, series.currentPrice);
+	* ```
+	*/
+	async getPriceSeries(token, timeframe, options) {
+		if (!PRICE_SERIES_TIMEFRAMES.includes(timeframe)) throw new GSwapSDKError("INVALID_TIMEFRAME", {
+			value: String(timeframe),
+			allowed: PRICE_SERIES_TIMEFRAMES.join(", ")
+		});
+		const id = marketTokenOf(token);
+		const response = await this.httpClient.sendGetRequest(this.dexBackendBaseUrl, "/market", "/price-series", {
+			token: id,
+			timeframe
+		}, signalOption(options));
+		const answer = asEntryRecord(response);
+		const currentPrice = answer === void 0 ? void 0 : nullableFinite(answer["currentPrice"]);
+		const change24h = answer === void 0 ? void 0 : nullableFinite(answer["change24h"]);
+		if (answer === void 0 || !Array.isArray(answer["prices"]) || currentPrice === void 0 || change24h === void 0) throw new GSwapSDKError("INVALID_CHAIN_RESPONSE", { resource: "price series" }, {
+			body: response,
+			write: false
+		});
 		return {
-			collection,
-			category,
-			type,
-			additionalKey
+			token: id,
+			timeframe,
+			prices: readEntries("priceSeries", answer["prices"], parsePricePoint, (options === null || options === void 0 ? void 0 : options.onInvalidEntry) ?? this.options.onInvalidEntry),
+			currentPrice,
+			change24h
 		};
-	} catch {
-		return;
 	}
+	/**
+	* TVL, volume and trade totals across every current-contract pool. Every field must be a finite
+	* number, or the answer is `INVALID_CHAIN_RESPONSE`.
+	*
+	* @example
+	* ```ts
+	* const volume = await gSwap.market.getVolumeSummary();
+	* console.log(`24h: $${volume.volume1d.toFixed(0)} (${(volume.volume1dDelta * 100).toFixed(1)} %)`);
+	* ```
+	*/
+	async getVolumeSummary(options) {
+		var _asEntryRecord;
+		const response = await this.httpClient.sendGetRequest(this.dexBackendBaseUrl, "/v2/trade", "/volume", void 0, signalOption(options));
+		const summary = parseVolumeSummary(asEntryRecord((_asEntryRecord = asEntryRecord(response)) === null || _asEntryRecord === void 0 ? void 0 : _asEntryRecord["data"]));
+		if (summary === void 0) throw new GSwapSDKError("INVALID_CHAIN_RESPONSE", { resource: "volume summary" }, {
+			body: response,
+			write: false
+		});
+		return summary;
+	}
+};
+/**
+* The most query bytes one `GET /market/price` carries. The backend refuses a request line over
+* 16 KB (Node's default header limit: 300 launchpad keys, 17.7 KB encoded, answer HTTP 431,
+* recorded on prod 2026-10-13), so a long list is split well under it (about 135 launchpad keys
+* per request, 270 short ones).
+*/
+const MARKET_PRICE_QUERY_BYTES = 8e3;
+/**
+* The ids in request-sized batches: at most {@link MARKET_PRICE_BATCH_LIMIT} ids and
+* {@link MARKET_PRICE_QUERY_BYTES} of encoded `assetIds` each (the standard encoding's size, the
+* larger of the two, with a `%2C` per id).
+*/
+function priceBatches(ids) {
+	const batches = [];
+	let batch = [];
+	let bytes = 0;
+	for (const id of ids) {
+		const size = encodeURIComponent(id).length + 3;
+		if (batch.length > 0 && (bytes + size > 8e3 || batch.length === 500)) {
+			batches.push(batch);
+			batch = [];
+			bytes = 0;
+		}
+		batch.push(id);
+		bytes += size;
+	}
+	if (batch.length > 0) batches.push(batch);
+	return batches;
 }
 /**
-* Parses a `$`-joined composite key (`Collection$Category$Type$AdditionalKey`, what
-* {@link compositeKeyOf} writes) and nothing else, or `undefined`. It is {@link tryParseTokenClassKey}
-* for a string that may ONLY be in the `$` form: a key that contains `|` is NOT read as the pipe
-* form here (it stays part of a segment), and only a string is accepted. The split is from the
-* right, so a collection that itself contains `$` (production's `$GMUSIC`, stage's
-* `$GMUSIC_TEST1`) stays whole; `'GALA'`, `'GALA$Unit$none'`, `'ETIME$$$'`, `'GALA$Unit$none$'` and
-* `'$$$$'` are `undefined`.
-*
-* It replaces an app's own `parseCompositeKey(key): Components | null` (`?? null`), which had
-* exactly these semantics.
-*
-* @example
-* ```ts
-* tryParseCompositeKey('$GMUSIC_TEST1$Unit$none$none')?.collection; // '$GMUSIC_TEST1'
-* tryParseCompositeKey('GALA$Unit$none'); // undefined
-* ```
+* The id a market read sends for a token: a string as given (a symbol or a class key in either
+* form), an object key in its `$` form. Anything the backend's allowlist refuses is refused here.
 */
-function tryParseCompositeKey(value) {
-	return typeof value === "string" ? splitClassKey(value, "$") : void 0;
+function marketTokenOf(token) {
+	if (typeof token !== "string") {
+		if (!(0, _gala_chain_gala_core_sdk.isTokenClassKey)(token)) throw new GSwapSDKError("INVALID_TOKEN_CLASS_KEY", { tokenClassKey: describeValue(token) });
+		return checkedMarketToken((0, _gala_chain_gala_core_sdk.compositeKeyOf)(token));
+	}
+	return checkedMarketToken(token);
+}
+function checkedMarketToken(id) {
+	if (!MARKET_TOKEN_PATTERN.test(id)) throw new GSwapSDKError("INVALID_MARKET_TOKEN", { token: id });
+	return id;
+}
+function describeValue(value) {
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return Object.prototype.toString.call(value);
+	}
+}
+function signalOption(options) {
+	return (options === null || options === void 0 ? void 0 : options.signal) === void 0 ? void 0 : { signal: options.signal };
+}
+/** A finite number, `null` for `null`, `undefined` for anything else (an unusable value). */
+function nullableFinite(value) {
+	if (value === null) return null;
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseMarketPrice(token, entry) {
+	const record = asEntryRecord(entry);
+	if (record === void 0) return entryRejected("not an object");
+	const price = nullableFinite(record["price"]);
+	if (price === void 0 || price !== null && price < 0) return entryRejected("price is not a non-negative number or null");
+	const change24h = nullableFinite(record["change24h"]);
+	if (change24h === void 0) return entryRejected("change24h is not a number or null");
+	const listed = record["listed"];
+	if (typeof listed !== "boolean") return entryRejected("listed is not a boolean");
+	return entryOk({
+		token,
+		price,
+		change24h,
+		listed
+	});
+}
+function parsePricePoint(entry) {
+	const record = asEntryRecord(entry);
+	const time = finite(record === null || record === void 0 ? void 0 : record["time"]);
+	const price = finite(record === null || record === void 0 ? void 0 : record["price"]);
+	if (time === void 0 || !Number.isInteger(time) || time < 0) return entryRejected("time is not unix seconds");
+	if (price === void 0 || price < 0) return entryRejected("price is not a non-negative number");
+	return entryOk({
+		time,
+		price
+	});
+}
+const VOLUME_FIELDS = [
+	"tvl",
+	"volume1d",
+	"volume7d",
+	"volume30d",
+	"trades1d",
+	"volume1dDelta",
+	"volume7dDelta",
+	"volume30dDelta"
+];
+function parseVolumeSummary(data) {
+	if (data === void 0) return void 0;
+	const summary = {};
+	for (const field of VOLUME_FIELDS) {
+		const value = finite(data[field]);
+		if (value === void 0) return void 0;
+		summary[field] = value;
+	}
+	const trades = summary.trades1d;
+	if (trades === void 0 || !Number.isInteger(trades) || trades < 0) return void 0;
+	return summary;
 }
 
 //#endregion
@@ -3857,11 +3386,30 @@ function parseTokenClassKey(tokenClassKey) {
 		type: tokenClassKey.type,
 		additionalKey: tokenClassKey.additionalKey
 	};
-	const parsed = splitClassKey(tokenClassKey, tokenClassKey.includes("|") ? "|" : "$");
+	const parsed = (0, _gala_chain_gala_core_sdk.splitClassKey)(tokenClassKey, tokenClassKey.includes("|") ? "|" : "$");
 	if (parsed === void 0) throw new GSwapSDKError("INVALID_TOKEN_CLASS_KEY", { tokenClassKey });
 	return parsed;
 }
 
+//#endregion
+//#region src/utils/resolve_pre_send.ts
+/**
+* Runs a token-resolution step (a resolver's `resolve` / `orderPair`, which may read the registry
+* through the app's HTTP stack) on the "nothing was sent" boundary, like core's `signPreSend` does
+* for the signer. A failure that is not an SDK error is `TOKEN_RESOLUTION_FAILED` (`token` names
+* what was being resolved, the original is `cause`); an SDK error of any product (every one is a
+* `GalaSDKError`, core's transport errors included) passes through.
+*
+* @throws GSwapSDKError TOKEN_RESOLUTION_FAILED, or the SDK error the step itself threw.
+*/
+async function resolvePreSend(token, run) {
+	try {
+		return await run();
+	} catch (cause) {
+		throw (0, _gala_chain_gala_core_sdk.isGalaError)(cause) ? cause : new GSwapSDKError("TOKEN_RESOLUTION_FAILED", { token }, { cause });
+	}
+}
+
 //#endregion
 //#region src/classes/symbols.ts
 const SYMBOL_CACHE_TTL_MS = 6e4;
@@ -3925,11 +3473,11 @@ var Symbols = class {
 	/** 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 composite = typeof ref === "string" ? isCompositeKey(ref) ? (0, _gala_chain_gala_core_sdk.compositeKeyOf)(parseTokenClassKey(ref)) : void 0 : (0, _gala_chain_gala_core_sdk.compositeKeyOf)(ref);
+		const resolved = symbols.find((entry) => entry.symbol === ref || composite !== void 0 && (0, _gala_chain_gala_core_sdk.compositeKeyOf)(entry) === composite);
 		if (resolved === void 0) {
 			symbols = await this.refresh();
-			const refreshed = symbols.find((entry) => entry.symbol === ref || composite !== void 0 && compositeKeyOf(entry) === composite);
+			const refreshed = symbols.find((entry) => entry.symbol === ref || composite !== void 0 && (0, _gala_chain_gala_core_sdk.compositeKeyOf)(entry) === composite);
 			if (refreshed === void 0) throw GSwapSDKError.unknownTokenError(ref);
 			return refreshed;
 		}
@@ -3964,7 +3512,7 @@ var Symbols = class {
 		} catch (error) {
 			if (options.registryFailure !== "ignore") throw error;
 		}
-		const wanted = compositeKeyOf(classKey);
+		const wanted = (0, _gala_chain_gala_core_sdk.compositeKeyOf)(classKey);
 		const registered = registry.find((entry) => entry.collection === classKey.collection && entry.category === classKey.category && entry.type === classKey.type && entry.additionalKey === classKey.additionalKey);
 		if (registered !== void 0) return registered.symbol;
 		if (isProposableTradingSymbol(displaySymbol)) return displaySymbol;
@@ -4010,7 +3558,7 @@ function isCompositeKey(ref) {
 }
 /** A token reference as the caller wrote it: a string verbatim, a class key as its `$` composite. */
 function rawTokenOf(ref) {
-	return typeof ref === "string" ? ref : compositeKeyOf(ref);
+	return typeof ref === "string" ? ref : (0, _gala_chain_gala_core_sdk.compositeKeyOf)(ref);
 }
 /** The trading symbol of a reference, or `SYMBOL_NOT_FOUND` when the resolver has none. */
 async function tradingSymbolOf(resolver, ref) {
@@ -4108,6 +3656,70 @@ var Pools = class {
 		return readEntries("pools", response.data, parsePoolListInfo, (options === null || options === void 0 ? void 0 : options.onInvalidEntry) ?? this.options.onInvalidEntry);
 	}
 	/**
+	* Watches for pools created from now on, by polling {@link Pools.getPools} every `intervalMs`
+	* (the polling alternative to the realtime stream's `GSwap.stream.subscribePoolCreated`, for a
+	* client that cannot hold a WebSocket open). The first answer is the baseline: a pool that
+	* existed then is never reported. Each later pool is judged once, when it first appears, against
+	* `minTvl` and `tokens`. A poll never overlaps the previous one (a tick that finds one still in
+	* flight is skipped), and nothing is reported after the returned function stops the watcher.
+	*
+	* @example
+	* ```ts
+	* const stop = gSwap.pools.watchNewPools((pool) => console.log('new pool', pool.poolRef), {
+	*   intervalMs: 60_000,
+	*   tokens: ['GALA'],
+	* });
+	* // later
+	* stop();
+	* ```
+	*/
+	watchNewPools(onPool, options = {}) {
+		const intervalMs = options.intervalMs ?? 3e4;
+		if (typeof intervalMs !== "number" || !Number.isFinite(intervalMs) || intervalMs < 1) throw new GSwapSDKError("INVALID_POLL_INTERVAL", { value: String(intervalMs) });
+		let known;
+		let stopped = false;
+		let polling = false;
+		const report = (error) => {
+			try {
+				var _options$onError;
+				(_options$onError = options.onError) === null || _options$onError === void 0 || _options$onError.call(options, error);
+			} catch {}
+		};
+		const wanted = (pool) => (options.minTvl === void 0 || (pool.tvlUsd ?? 0) >= options.minTvl) && (options.tokens === void 0 || options.tokens.includes(pool.token0) || options.tokens.includes(pool.token1));
+		const poll = async () => {
+			if (stopped || polling) return;
+			polling = true;
+			try {
+				const pools = await this.getPools();
+				if (known === void 0) {
+					known = new Set(pools.map((pool) => pool.poolRef));
+					return;
+				}
+				for (const pool of pools) {
+					if (stopped) return;
+					if (known.has(pool.poolRef)) continue;
+					known.add(pool.poolRef);
+					if (!wanted(pool)) continue;
+					try {
+						onPool(pool);
+					} catch (error) {
+						report(error);
+					}
+				}
+			} catch (error) {
+				if (!stopped) report(error);
+			} finally {
+				polling = false;
+			}
+		};
+		poll();
+		const timer = setInterval(() => void poll(), intervalMs);
+		return () => {
+			stopped = true;
+			clearInterval(timer);
+		};
+	}
+	/**
 	* Fetches one pool from the backend, preserving whether the request order was flipped.
 	*
 	* @example
@@ -4169,8 +3781,11 @@ var Pools = class {
 		try {
 			return (await this.http.sendGetRequest(this.gateway.dexBackendBaseUrl, "/v2/trade", endpoint, params)).data;
 		} catch (error) {
-			if (error instanceof GSwapSDKError) throw error;
-			throw new GSwapSDKError("REQUEST_FAILED", { operation: "pool" }, { cause: error });
+			if (isGSwapError(error)) throw error;
+			throw new GSwapSDKError("REQUEST_FAILED", { operation: "pool" }, {
+				cause: error,
+				write: false
+			});
 		}
 	}
 };
@@ -4393,49 +4008,6 @@ function frameSlot0(slot0) {
 	};
 }
 
-//#endregion
-//#region src/utils/unique_key.ts
-/**
-* The `uniqueKey` prefix frontend_v2 and wallet_extension have always sent
-* (`galaswap-operation-<uuid>`). defi-backend does not depend on it: the chain-write verifier
-* only requires a non-empty key of at most 256 characters, and apply-results accepts
-* `[A-Za-z0-9._:-]{1,128}`; the only code that mints a prefixed key itself is the server-side v1
-* trade builder, which nothing reads back by prefix.
-*/
-const DEFAULT_UNIQUE_KEY_PREFIX = "galaswap-operation-";
-/** A canonical UUID is 36 characters; the apply-results key limit is 128. */
-const MAX_UNIQUE_KEY_PREFIX_LENGTH = 92;
-const UNIQUE_KEY_PREFIX_PATTERN = /^[A-Za-z0-9._:-]*$/u;
-/**
-* Validates a caller-supplied `uniqueKey` prefix. The whole key (`<prefix><uuid>`) must stay a
-* valid apply-results key, otherwise `confirm()` could never read the outcome of the write.
-*
-* @throws GSwapSDKError `INVALID_UNIQUE_KEY_PREFIX` when the prefix has characters outside
-* `A-Za-z0-9._:-` or is longer than 92 characters.
-*/
-function resolveUniqueKeyPrefix(prefix) {
-	if (prefix === void 0) return DEFAULT_UNIQUE_KEY_PREFIX;
-	if (!UNIQUE_KEY_PREFIX_PATTERN.test(prefix) || prefix.length > MAX_UNIQUE_KEY_PREFIX_LENGTH) throw new GSwapSDKError("INVALID_UNIQUE_KEY_PREFIX", {
-		uniqueKeyPrefix: prefix,
-		maxLength: MAX_UNIQUE_KEY_PREFIX_LENGTH
-	});
-	return prefix;
-}
-/**
-* Validates a caller-supplied write `uniqueKey`: 1 to 128 characters of `A-Za-z0-9._:-`, the
-* shape the apply-results route accepts, so the write's outcome can always be read back with
-* `confirm()`. A key is one attempt's identity: reuse it only to retry that same attempt.
-*
-* @throws GSwapSDKError `INVALID_UNIQUE_KEY` otherwise.
-*/
-function assertUniqueKey(uniqueKey) {
-	if (!isValidUniqueKey(uniqueKey)) throw new GSwapSDKError("INVALID_UNIQUE_KEY", { uniqueKey: String(uniqueKey) });
-}
-/** A fresh per-attempt key: `<prefix><random UUID>`. */
-function createUniqueKey(prefix) {
-	return `${prefix}${globalThis.crypto.randomUUID()}`;
-}
-
 //#endregion
 //#region src/utils/dto_builders.ts
 const decimalString = (amount) => new bignumber_js.default(amount).toFixed();
@@ -4459,7 +4031,7 @@ const decimalString = (amount) => new bignumber_js.default(amount).toFixed();
 function buildRequestTradeDto(input) {
 	validateFee(input.fee);
 	assertCanonicalPair(input.token0, input.token1);
-	assertUniqueKey(input.uniqueKey);
+	(0, _gala_chain_gala_core_sdk.assertUniqueKey)(input.uniqueKey);
 	const dto = {
 		token0: input.token0,
 		token1: input.token1,
@@ -4495,7 +4067,7 @@ function assertPoolPosition(input) {
 	validateFee(input.fee);
 	assertCanonicalPair(input.token0, input.token1);
 	assertTickRange(input.tickLower, input.tickUpper, input.fee);
-	assertUniqueKey(input.uniqueKey);
+	(0, _gala_chain_gala_core_sdk.assertUniqueKey)(input.uniqueKey);
 }
 /**
 * Builds the AddLiquidity DTO: exactly one of `depositQuantityToken0` / `depositQuantityToken1`
@@ -4558,7 +4130,7 @@ function buildCollectPositionFeesDto(input) {
 */
 function buildCreatePoolDto(input) {
 	validateFee(input.fee);
-	assertUniqueKey(input.uniqueKey);
+	(0, _gala_chain_gala_core_sdk.assertUniqueKey)(input.uniqueKey);
 	assertCanonicalPair(input.token0Symbol, input.token1Symbol);
 	for (const symbol of [input.token0Symbol, input.token1Symbol]) if (!isProposableTradingSymbol(symbol)) throw new GSwapSDKError("INVALID_TRADING_SYMBOL", { symbol });
 	for (const key of [input.token0Key, input.token1Key]) assertClassKey(key);
@@ -4781,7 +4353,7 @@ var Positions = class {
 		this.signer = signer;
 		this.walletAddress = walletAddress;
 		this.http = new HttpClient(gateway.httpRequestor, gateway.requestTimeoutMs ?? 3e4, gateway.wire);
-		this.uniqueKeyPrefix = resolveUniqueKeyPrefix(options.uniqueKeyPrefix);
+		this.uniqueKeyPrefix = (0, _gala_chain_gala_core_sdk.resolveUniqueKeyPrefix)(options.uniqueKeyPrefix);
 		this.onInvalidEntry = options.onInvalidEntry;
 	}
 	http;
@@ -4849,7 +4421,10 @@ var Positions = class {
 			if ((signal === null || signal === void 0 ? void 0 : signal.aborted) === true) throw error;
 			return {
 				kind: "unknown",
-				error: isGSwapError(error) ? error : new GSwapSDKError("REQUEST_FAILED", { operation: "position" }, { cause: error })
+				error: isGSwapError(error) ? error : new GSwapSDKError("REQUEST_FAILED", { operation: "position" }, {
+					cause: error,
+					write: false
+				})
 			};
 		}
 	}
@@ -5220,7 +4795,7 @@ var Positions = class {
 	}
 	async submit(method, dto, confirmation) {
 		if (this.signer === void 0) throw GSwapSDKError.noSignerError();
-		const signed = await signPreSend(this.signer, method, dto);
+		const signed = await (0, _gala_chain_gala_core_sdk.signPreSend)(this.signer, method, dto);
 		const submitOptions = this.walletAddress === void 0 ? {} : { walletAddress: this.walletAddress };
 		const owner = this.walletAddress;
 		const positionConfirmation = this.buildPositionConfirmation(confirmation, owner);
@@ -5316,7 +4891,7 @@ var Positions = class {
 		}
 	}
 	isNotFound(error) {
-		return error instanceof GSwapSDKError && error.status === 404;
+		return isGSwapError(error) && error.status === 404;
 	}
 	canonicalTicks(tickLower, tickUpper, flipped) {
 		return flipped ? {
@@ -5341,8 +4916,8 @@ var Positions = class {
 	}
 	/** The caller's `uniqueKey` (validated), else a fresh one. */
 	uniqueKeyFor(supplied) {
-		if (supplied === void 0) return createUniqueKey(this.uniqueKeyPrefix);
-		assertUniqueKey(supplied);
+		if (supplied === void 0) return (0, _gala_chain_gala_core_sdk.createUniqueKey)(this.uniqueKeyPrefix);
+		(0, _gala_chain_gala_core_sdk.assertUniqueKey)(supplied);
 		return supplied;
 	}
 	/**
@@ -5354,7 +4929,7 @@ var Positions = class {
 	}
 	async resolveCreateToken(ref, symbolOverride) {
 		try {
-			const lookupRef = typeof ref === "object" ? compositeKeyOf(ref) : ref;
+			const lookupRef = typeof ref === "object" ? (0, _gala_chain_gala_core_sdk.compositeKeyOf)(ref) : ref;
 			const resolved = await resolvePreSend(rawTokenOf(ref), () => this.symbols.resolve(lookupRef));
 			if (symbolOverride !== void 0 && symbolOverride !== "" && symbolOverride !== resolved.symbol) throw new GSwapSDKError("SYMBOL_DISAGREES_WITH_REGISTRY", {
 				token: rawTokenOf(ref),
@@ -5373,7 +4948,7 @@ var Positions = class {
 				})
 			};
 		} catch (error) {
-			if (!(error instanceof GSwapSDKError) || error.code !== "UNKNOWN_TOKEN") throw error;
+			if (!isGSwapError(error, "UNKNOWN_TOKEN")) throw error;
 			let classKey;
 			try {
 				classKey = parseTokenClassKey(ref);
@@ -5458,7 +5033,10 @@ function parsePosition(value) {
 function readPositionBody(data) {
 	const parsed = parsePosition(data);
 	if (parsed.ok) return parsed.value;
-	throw new GSwapSDKError("INVALID_POSITION_RESPONSE", { reason: parsed.reason }, { body: data });
+	throw new GSwapSDKError("INVALID_POSITION_RESPONSE", { reason: parsed.reason }, {
+		body: data,
+		write: false
+	});
 }
 
 //#endregion
@@ -5526,7 +5104,10 @@ var Quoting = class {
 	}
 };
 function mapQuote(value) {
-	if (!isQuoteWire(value)) throw new GSwapSDKError("INVALID_CHAIN_RESPONSE", { resource: "quote" }, { body: value });
+	if (!isQuoteWire(value)) throw new GSwapSDKError("INVALID_CHAIN_RESPONSE", { resource: "quote" }, {
+		body: value,
+		write: false
+	});
 	const wire = value;
 	const currentPrice = wire.currentPrice !== void 0 ? new bignumber_js.default(wire.currentPrice) : orientPrice(wire.currentSqrtPrice, wire.tokenInIsToken0);
 	const newPrice = wire.newPrice !== void 0 ? new bignumber_js.default(wire.newPrice) : orientPrice(wire.newSqrtPrice, wire.tokenInIsToken0);
@@ -5611,7 +5192,10 @@ function mapQuoteError(error, tokenIn, tokenOut, fee, queried) {
 		if (error.status === 400 && /insufficient liquidity/iu.test(message)) return GSwapSDKError.insufficientLiquidityError(tokenIn, tokenOut, fee, error);
 		return error;
 	}
-	return new GSwapSDKError("REQUEST_FAILED", { operation: "quote" }, { cause: error });
+	return new GSwapSDKError("REQUEST_FAILED", { operation: "quote" }, {
+		cause: error,
+		write: false
+	});
 }
 function validateOptionalFee(fee) {
 	if (fee !== void 0 && !ALL_FEE_TIERS.some((tier) => Number(tier) === Number(fee))) throw new GSwapSDKError("INVALID_FEE", {
@@ -5765,7 +5349,7 @@ var Swaps = class {
 		this.symbols = symbols;
 		this.signer = signer;
 		this.walletAddress = walletAddress;
-		this.uniqueKeyPrefix = resolveUniqueKeyPrefix(options.uniqueKeyPrefix);
+		this.uniqueKeyPrefix = (0, _gala_chain_gala_core_sdk.resolveUniqueKeyPrefix)(options.uniqueKeyPrefix);
 	}
 	uniqueKeyPrefix;
 	/**
@@ -5817,8 +5401,8 @@ var Swaps = class {
 	*/
 	async buildSwap(tokenIn, tokenOut, fee, amount, options) {
 		validateFee(fee);
-		const uniqueKey = (options === null || options === void 0 ? void 0 : options.uniqueKey) ?? createUniqueKey(this.uniqueKeyPrefix);
-		assertUniqueKey(uniqueKey);
+		const uniqueKey = (options === null || options === void 0 ? void 0 : options.uniqueKey) ?? (0, _gala_chain_gala_core_sdk.createUniqueKey)(this.uniqueKeyPrefix);
+		(0, _gala_chain_gala_core_sdk.assertUniqueKey)(uniqueKey);
 		const tokenInSymbol = await tradingSymbolOf(this.symbols, tokenIn);
 		const tokenOutSymbol = await tradingSymbolOf(this.symbols, tokenOut);
 		const ordered = this.orientPool(tokenInSymbol, tokenOutSymbol, options === null || options === void 0 ? void 0 : options.pool);
@@ -5860,7 +5444,7 @@ var Swaps = class {
 	async signRequestTrade(dto) {
 		assertCanonicalV2Dto("RequestTrade", dto);
 		if (this.signer === void 0) throw GSwapSDKError.noSignerError();
-		return signPreSend(this.signer, "RequestTrade", dto);
+		return (0, _gala_chain_gala_core_sdk.signPreSend)(this.signer, "RequestTrade", dto);
 	}
 	/** The pool's two symbols in contract order: the quote's own when pinned, else string order. */
 	orientPool(tokenInSymbol, tokenOutSymbol, pool) {
@@ -5890,7 +5474,7 @@ var Swaps = class {
 	* ```
 	*/
 	async confirmSwap(uniqueKey, options) {
-		assertUniqueKey(uniqueKey);
+		(0, _gala_chain_gala_core_sdk.assertUniqueKey)(uniqueKey);
 		return new SubmittedTransaction({
 			method: "RequestTrade",
 			uniqueKey,
@@ -5913,7 +5497,8 @@ var Swaps = class {
 /**
 * Main entry point for the current GalaChainDex SDK: one client bundling the services that read
 * and write through the swap backend (`quoting`, `swaps`, `pools`, `positions`, `assets`,
-* `symbols`, `fees`, `stream`). See {@link GSwapOptions} for configuration.
+* `market`, `leaderboard`, `symbols`, `fees`, `stream`). See {@link GSwapOptions} for
+* configuration.
 */
 var GSwap = class {
 	/** The swap backend base URL every request goes to, without a trailing slash. */
@@ -5938,6 +5523,10 @@ var GSwap = class {
 	swaps;
 	/** User token balances. */
 	assets;
+	/** USD prices, price series and the platform volume totals. */
+	market;
+	/** Trading-competition seasons and rankings. */
+	leaderboard;
 	/** Network-fee quotes (DryRun) signed with this client's signer. */
 	fees;
 	/** The realtime stream endpoint {@link GSwap.stream} connects to. */
@@ -5980,6 +5569,8 @@ var GSwap = class {
 		this.positions = new Positions(this.gateway, resolver, this.signer, this.walletAddress, keyOptions);
 		this.swaps = new Swaps(this.gateway, resolver, this.signer, this.walletAddress, keyOptions);
 		this.assets = new Assets(this.dexBackendBaseUrl, httpClient);
+		this.market = new Market(this.dexBackendBaseUrl, httpClient, lenient);
+		this.leaderboard = new Leaderboard(this.dexBackendBaseUrl, httpClient, lenient);
 		this.fees = new DexFees(this.gateway, this.signer);
 		this.dexBackendWsUrl = (options === null || options === void 0 ? void 0 : options.dexBackendWsUrl) ?? ((options === null || options === void 0 ? void 0 : options.dexBackendBaseUrl) === void 0 ? environment.dexBackendWsUrl : `${this.dexBackendBaseUrl.replace(/^http/u, "ws")}/ws`);
 		this.webSocketImpl = options === null || options === void 0 ? void 0 : options.webSocketImpl;
@@ -6096,6 +5687,13 @@ const BY_CODE = {
 	GATEWAY_SYNC_REQUEST_TRADE: UNKNOWN,
 	MISSING_UNIQUE_KEY: UNKNOWN,
 	UNIQUE_KEY_MISMATCH: UNKNOWN,
+	GATEWAY_WRITE_OUTCOME_UNKNOWN: UNKNOWN,
+	GATEWAY_RESPONSE_INVALID: UNKNOWN,
+	BRIDGE_RESPONSE_INVALID: UNKNOWN,
+	BRIDGE_WRITE_OUTCOME_UNKNOWN: UNKNOWN,
+	BRIDGE_OUT_OUTCOME_UNKNOWN: UNKNOWN,
+	BRIDGE_DEPOSIT_OUTCOME_UNKNOWN: UNKNOWN,
+	BRIDGE_STATUS_TIMEOUT: UNKNOWN,
 	SHADOW_NOT_QUEUED: NOT_QUEUED_FINAL,
 	METHOD_NOT_ALLOWED: NOT_QUEUED,
 	SIGNATURE_INVALID: NOT_QUEUED,
@@ -6108,6 +5706,14 @@ const BY_CODE = {
 	CHAIN_REJECTED: REJECTED,
 	INVALID_CHAIN_RESPONSE: TRANSIENT,
 	INVALID_POSITION_RESPONSE: TRANSIENT,
+	GATEWAY_READ_REJECTED: TRANSIENT,
+	GATEWAY_READ_RESPONSE_INVALID: TRANSIENT,
+	BRIDGE_READ_RESPONSE_INVALID: TRANSIENT,
+	BRIDGE_TOKEN_NOT_FOUND: INVALID_INPUT,
+	TOKEN_NOT_WRAPPABLE: INVALID_INPUT,
+	BRIDGE_CHAIN_READ_FAILED: TRANSIENT,
+	TOKEN_CLASS_NOT_FOUND: INVALID_INPUT,
+	PAGINATION_LIMIT_EXCEEDED: INVALID_INPUT,
 	CONFIRMATION_TIMEOUT: UNKNOWN,
 	CONFIRMATION_ABORTED: UNKNOWN,
 	CONFIRMATION_FAILED: UNKNOWN,
@@ -6121,6 +5727,7 @@ const BY_CODE = {
 	SIGNING_FAILED: NOT_SENT,
 	KEY_PROVIDER_FAILED: NOT_SENT,
 	TOKEN_RESOLUTION_FAILED: NOT_SENT,
+	TOKEN_NAME_RESOLUTION_FAILED: NOT_SENT,
 	NO_WALLET_ADDRESS: INVALID_INPUT,
 	NO_POOL_AVAILABLE: INVALID_INPUT,
 	INSUFFICIENT_LIQUIDITY: INVALID_INPUT
@@ -6132,11 +5739,11 @@ const BY_CODE = {
 * it is `not_sent` and Retry is safe.
 */
 function classifyInvalidPrivateKey(view) {
-	return stringParamOf(view, "reason") === "no_key_provided" ? NOT_SENT : INVALID_INPUT;
+	return (0, _gala_chain_gala_core_sdk.stringParamOf)(view, "reason") === "no_key_provided" ? NOT_SENT : INVALID_INPUT;
 }
 /** The status of an HTTP failure: the one it carries, else its `status` param. */
 function statusOfView(view) {
-	return view.status ?? numberParamOf(view, "status");
+	return view.status ?? (0, _gala_chain_gala_core_sdk.numberParamOf)(view, "status");
 }
 /**
 * An HTTP failure with no gateway or chain code: its meaning depends on the status and on read vs
@@ -6145,7 +5752,7 @@ function statusOfView(view) {
 function classifyHttpError(view) {
 	const status = statusOfView(view);
 	if (status === void 0) return UNKNOWN;
-	if (isWriteView(view)) {
+	if ((0, _gala_chain_gala_core_sdk.isWriteView)(view)) {
 		if (status === 429) return NOT_QUEUED;
 		if (status === 408 || status >= 500) return UNKNOWN;
 		return NOT_QUEUED_FINAL;
@@ -6153,13 +5760,21 @@ function classifyHttpError(view) {
 	return status === 408 || status === 429 || status >= 500 ? TRANSIENT : INVALID_INPUT;
 }
 /**
+* A core `./bridge` GalaConnect HTTP failure: like {@link classifyHttpError}, except that a
+* WRITE answered 409 is `unknown`: GalaChain's "this uniqueKey was already consumed", after which
+* an earlier attempt under the key may be applied (a bridge-out that locked the tokens).
+*/
+function classifyGalaConnectHttpError(view) {
+	return (0, _gala_chain_gala_core_sdk.isWriteView)(view) && statusOfView(view) === 409 ? UNKNOWN : classifyHttpError(view);
+}
+/**
 * The version wall (HTTP 426). On a write the gateway refused it before queueing anything, and a
 * repeat of the same app version is refused the same way, so it is `not_queued` with no Retry. On a
 * read nothing changed either, and only an update helps: `invalid_input`, no Retry. Both say "show
 * the update screen", not "try again".
 */
 function classifyUpdateRequired(view) {
-	return isWriteView(view) ? NOT_QUEUED_FINAL : INVALID_INPUT;
+	return (0, _gala_chain_gala_core_sdk.isWriteView)(view) ? NOT_QUEUED_FINAL : INVALID_INPUT;
 }
 /**
 * The chain dispatch failed. The gateway echoes the upstream status: 409 is "this uniqueKey was
@@ -6173,7 +5788,17 @@ function classifyChainDispatchFailed(view) {
 	return status === 422 ? REJECTED : NOT_QUEUED;
 }
 /**
-* Classifies any thrown value from its code (and, for two codes, its HTTP status), never from
+* GalaChain answered a core `GatewayWrites` token-contract write with a `Status` other than 1: the
+* chain's verdict, so the write was not applied (`rejected`), except where the verdict does not
+* prove that: a 409 is "this uniqueKey was already consumed" (an earlier attempt under it may be
+* applied), and a 5xx, or no status at all, cannot be judged.
+*/
+function classifyGatewayWriteRejected(view) {
+	const status = view.status;
+	return status === void 0 || status === 409 || status >= 500 ? UNKNOWN : REJECTED;
+}
+/**
+* Classifies any thrown value from its code (and, for a few codes, its HTTP status), never from
 * message text, so an app does not have to re-derive "may I offer Retry?" and "is the outcome
 * unknown?" for every code. The decision for each code is in this module's table; a new catalog
 * code cannot be added without one.
@@ -6223,7 +5848,7 @@ function classifyChainDispatchFailed(view) {
 * ```
 */
 function classifyFailure(error, options = {}) {
-	const result = classifyView(toFailureView(error));
+	const result = classifyView((0, _gala_chain_gala_core_sdk.toFailureView)(error));
 	return options.afterQueued === true && result.outcome !== "rejected" ? {
 		...result,
 		retryable: false
@@ -6231,7 +5856,7 @@ function classifyFailure(error, options = {}) {
 }
 /**
 * The classification of a failure view: the table decision for its code, the status-dependent
-* decision for the four codes whose meaning needs it, and for a code the catalog does not define
+* decision for the codes whose meaning needs it, and for a code the catalog does not define
 * (a wallet error, an ethers `ACTION_REJECTED`, a typo, an app's own error): `unknown` unless the
 * view DECLARES its `outcome` (an app's error, `{ code: 'POSITION_STALE', outcome: 'not_sent' }`),
 * then the SDK's own classification of that outcome. A value with no view is `unknown`.
@@ -6243,7 +5868,9 @@ function classifyView(view) {
 		return view.retryable === false ? classification(view.outcome, { retryable: false }) : classification(view.outcome);
 	}
 	const { code } = view;
-	if (code === "HTTP_ERROR") return { ...classifyHttpError(view) };
+	if (code === "HTTP_ERROR" || code === "GATEWAY_HTTP_ERROR") return { ...classifyHttpError(view) };
+	if (code === "GALACONNECT_HTTP_ERROR") return { ...classifyGalaConnectHttpError(view) };
+	if (code === "GATEWAY_WRITE_REJECTED" || code === "BRIDGE_REQUEST_REJECTED") return { ...classifyGatewayWriteRejected(view) };
 	if (code === "UPDATE_REQUIRED") return { ...classifyUpdateRequired(view) };
 	if (code === "CHAIN_DISPATCH_FAILED") return { ...classifyChainDispatchFailed(view) };
 	if (code === "INVALID_PRIVATE_KEY") return { ...classifyInvalidPrivateKey(view) };
@@ -6422,7 +6049,7 @@ var PendingSwapStore = class {
 	* `invalid_unique_key`.
 	*/
 	remember(swap) {
-		if (!isValidUniqueKey(swap.uniqueKey)) {
+		if (!(0, _gala_chain_gala_core_sdk.isValidUniqueKey)(swap.uniqueKey)) {
 			this.report([{
 				swap,
 				reason: "invalid_unique_key"
@@ -6500,7 +6127,7 @@ var PendingSwapStore = class {
 		}) ?? [];
 	}
 	pruneReasonOf(entry, now) {
-		if (!isValidUniqueKey(entry.uniqueKey)) return "invalid_unique_key";
+		if (!(0, _gala_chain_gala_core_sdk.isValidUniqueKey)(entry.uniqueKey)) return "invalid_unique_key";
 		return now - entry.createdAt < 6048e5 ? void 0 : "expired";
 	}
 	/** Tells `onPrune` about each dropped entry; the hook is diagnostics and cannot break the store. */
@@ -6561,796 +6188,12 @@ var PendingSwapStore = class {
 };
 
 //#endregion
-//#region src/utils/eip712.ts
-/**
-* Genuine EIP-712 typed-data signing for the four v2 dex-contract operations proven (2026-09-16,
-* live bisection against stage — see defi-backend's `chain-findings-artifact` memory /
-* https://claude.ai/artifact/3N9MevSjoQdU7gqnVB3dfU) to recover the `client|` identity correctly
-* via `eth_signTypedData_v4`, unlike `personal_sign` (which only ever resolves the bare `eth|`
-* form — see `BrowserWalletSigner`'s own doc comment). Mirrors frontend_v2's
-* `src/Services/eip712Types.ts` + `readWriteUtilsV2.ts`'s `EIP712_FIELD_COMPLETERS` exactly —
-* ported here rather than shared as a package because gswap-sdk has no frontend_v2 dependency
-* and should not gain one for four small functions.
-*/
+//#region src/classes/storage_adapters.ts
 /**
-* Derives the EIP-712 `types` for a DTO from its runtime shape.
-*
-* The generated `types` travel with the signed payload and are what BOTH sides hash, so they
-* must enumerate EVERY field the chain-side DTO will carry. GalaChain refuses any signature
-* whose `types` leave a DTO field uncovered (`assertNoUnsignedFields`, the fix for the
-* 2026-08-18 unsigned-field-injection drain); when that happens signature recovery fails
-* outright and the chain reports "Missing signerPublicKey or signerAddress field in dto".
-*/
-function generateEIP712Types(typeName, params) {
-	const types = {};
-	types[typeName] = [];
-	function fieldsFor(name) {
-		const fields = types[name];
-		/* c8 ignore next */
-		if (!fields) throw new Error(`Missing EIP-712 type definition for ${name}`);
-		return fields;
-	}
-	function addField(name, fieldValue, parentTypeName, onlyGetType = false) {
-		if (Array.isArray(fieldValue)) {
-			const type = fieldValue.length > 0 ? addField(name, fieldValue[0], parentTypeName, true) : "string";
-			if (!onlyGetType) fieldsFor(parentTypeName).push({
-				name,
-				type: (type ?? name) + "[]"
-			});
-		} else if (typeof fieldValue === "object" && fieldValue !== null) {
-			if (types[name]) throw new GSwapSDKError("EIP712_NAME_COLLISION", { name });
-			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 GSwapSDKError("EIP712_UNSUPPORTED_VALUE", { valueType: typeof fieldValue });
-			}
-			if (onlyGetType) return eipType;
-			fieldsFor(parentTypeName).push({
-				name,
-				type: eipType
-			});
-		}
-	}
-	Object.entries(params).forEach(([key, value]) => {
-		addField(key, value, typeName);
-	});
-	return types;
-}
-/**
-* Builds the EIP-712 domain from the wallet's LIVE `eth_chainId` result, exactly like frontend_v2
-* (DEFI-1895): a wallet hashes whatever domain it is handed, and MetaMask refuses a `chainId` that
-* differs from its active network, so a hardcoded `1` breaks every wallet that is not on Mainnet.
-* defi-backend recovers the signer from the `domain` the payload carries (live-proven for chain
-* ids 1, 56 and 11155111), so following the wallet is correct on every network.
-*
-* @param chainId - The raw `eth_chainId` result: a `0x` hex string (the JSON-RPC form) or an integer.
-* @throws GSwapSDKError (`INVALID_CHAIN_ID`) when the wallet answers with anything else.
-*/
-function eip712DomainFor(chainId) {
-	const parsed = typeof chainId === "string" && /^0x[0-9a-fA-F]+$/u.test(chainId) ? Number(chainId) : typeof chainId === "number" ? chainId : NaN;
-	if (!Number.isSafeInteger(parsed) || parsed <= 0) throw new GSwapSDKError("INVALID_CHAIN_ID", { chainId: typeof chainId === "string" || typeof chainId === "number" ? String(chainId) : typeof chainId });
-	return {
-		name: "ethereum",
-		chainId: parsed
-	};
-}
-/**
-* The four v2 operations proven to recover the signer correctly via genuine EIP-712: `RequestTrade`
-* never had the problem (one numeric field). `AddLiquidity`/`RemoveLiquidity`/
-* `CollectPositionFees` each need their `types` completed with a handful of fields their real
-* server-side DTO always carries — see the `complete*Fields` functions below. `CreatePool` is a
-* genuinely different, unsolved problem (nested `TokenClassKey` structs, not a flat
-* missing-field gap) and is NOT in this set — callers must keep using `personal-sign` for it.
-*/
-const EIP712_CAPABLE_METHODS = /* @__PURE__ */ new Set([
-	"RequestTrade",
-	"AddLiquidity",
-	"RemoveLiquidity",
-	"CollectPositionFees"
-]);
-/**
-* Every `complete*Fields` function below shares the same two live-proven rules:
-*  1. Numeric completeness fields MUST be JS `number`, never numeric strings —
-*     `generateEIP712Types` infers a field's Solidity type from `typeof`, and declaring one as
-*     EIP-712 `string` instead of `int256` breaks recovery identically to omitting the field
-*     entirely (verified live on AddLiquidity: `amount0Min: '0'` fails with the exact same
-*     "Missing signerPublicKey" error as `amount0Min` being absent; `amount0Min: 0` succeeds).
-*  2. `positionId` has no such constraint — an empty string works, and does not target an
-*     existing position (`positionId: ''` created a fresh position on AddLiquidity, not an add
-*     to position id `''`; on RemoveLiquidity/CollectPositionFees the real position is still
-*     resolved from `token0`/`token1`/`fee`/`tickLower`/`tickUpper`, not from this field).
-*/
-function numericOr0(dto, field) {
-	return typeof dto[field] === "number" ? dto[field] : 0;
-}
-/**
-* `AddLiquidity`'s real server-side DTO always carries `amount0Desired`/`amount0Min`/
-* `amount1Desired`/`amount1Min`/`positionId` once reconstructed, regardless of which deposit
-* convention the caller used (`Positions.addLiquidityByTicks` only ever sends
-* `depositQuantityToken0`/`depositQuantityToken1`). Proven empirically by bisection: none of the
-* five alone fixes recovery, all five together does (live 201, tx `407d9b24...`, block
-* `2429022`).
-*/
-function completeAddLiquidityFields(dto) {
-	return {
-		...dto,
-		amount0Desired: numericOr0(dto, "amount0Desired"),
-		amount0Min: numericOr0(dto, "amount0Min"),
-		amount1Desired: numericOr0(dto, "amount1Desired"),
-		amount1Min: numericOr0(dto, "amount1Min"),
-		positionId: dto["positionId"] ?? ""
-	};
-}
-/**
-* `RemoveLiquidity`'s real server-side DTO always carries `amount`/`amount0Min`/`amount1Min`/
-* `positionId` — `Positions.removeLiquidity` only ever sends a `withdrawalQuantityTokenX` (or
-* neither, for a full close). Proven empirically: every subset of these four fails, all four
-* together succeeds (live, random-signer probe — recovery confirmed by the response moving from
-* "Missing signerPublicKey" to a genuine position-not-found 404).
-*/
-function completeRemoveLiquidityFields(dto) {
-	return {
-		...dto,
-		amount: numericOr0(dto, "amount"),
-		amount0Min: numericOr0(dto, "amount0Min"),
-		amount1Min: numericOr0(dto, "amount1Min"),
-		positionId: dto["positionId"] ?? ""
-	};
-}
-/**
-* `CollectPositionFees`'s real server-side DTO always carries `amount0Requested`/
-* `amount1Requested`/`positionId` — `Positions.collectPositionFees` sends only the five identity
-* fields. Proven empirically the same way as `completeRemoveLiquidityFields`.
-*/
-function completeCollectPositionFeesFields(dto) {
-	return {
-		...dto,
-		amount0Requested: numericOr0(dto, "amount0Requested"),
-		amount1Requested: numericOr0(dto, "amount1Requested"),
-		positionId: dto["positionId"] ?? ""
-	};
-}
-const EIP712_FIELD_COMPLETERS = {
-	AddLiquidity: completeAddLiquidityFields,
-	RemoveLiquidity: completeRemoveLiquidityFields,
-	CollectPositionFees: completeCollectPositionFeesFields
-};
-/**
-* Completes a DTO's fields for EIP-712 signing (a no-op for methods with no known gap, e.g.
-* `RequestTrade`) and derives its `types`. Exported separately from the signing call itself so tests
-* can assert on the exact payload without needing a live provider.
-*/
-function buildEIP712Payload(methodName, dto) {
-	const completer = EIP712_FIELD_COMPLETERS[methodName];
-	const completedDto = completer ? completer(dto) : dto;
-	return {
-		completedDto,
-		types: generateEIP712Types(methodName, completedDto)
-	};
-}
-
-//#endregion
-//#region src/utils/signing.ts
-/**
-* SDK-owned signing primitives.
-*
-* Everything the SDK needs to produce a GalaChain signature lives here, with no dependency on
-* `@gala-chain/api` (which drags `secp256k1` native bindings, `reflect-metadata`, `class-validator`
-* and its own `bignumber.js` major into every consumer). The only runtime dependencies are the
-* audited, pure-JS `@noble/curves` (secp256k1) and `@noble/hashes` (keccak256), which run
-* unchanged in browsers, MV3 service workers, Node and React Native/Hermes.
-*
-* Every function here is pinned byte-for-byte to the signatures produced by `@gala-chain/api`
-* (`serialize`, `signatures.getSignature`), `@gala-chain/connect`, the Gala Wallet extension and
-* frontend_v2 by the golden-vector suite in `tests/signing-golden.test.ts`.
-*/
-const textEncoder$1 = new TextEncoder();
-function toDeterministicNode(node) {
-	if (node === null || node === void 0) return node;
-	if (node instanceof RegExp) return node.toString();
-	const candidate = node;
-	return typeof candidate.toJSON === "function" ? Reflect.apply(candidate.toJSON, node, []) : node;
-}
-function deterministicNode(rawNode) {
-	const node = toDeterministicNode(rawNode);
-	if (node === void 0) return void 0;
-	if (typeof node !== "object" || node === null) return JSON.stringify(node);
-	if (Array.isArray(node)) return `[${node.map((item) => deterministicNode(item) ?? "null").join(",")}]`;
-	const record = node;
-	const members = [];
-	for (const key of Object.keys(record).sort()) {
-		const value = deterministicNode(record[key]);
-		if (value === void 0) continue;
-		members.push(`${JSON.stringify(key)}:${value}`);
-	}
-	return `{${members.join(",")}}`;
-}
-/**
-* GalaChain's deterministic JSON: object keys sorted (UTF-16 code-unit order) at every depth, no
-* whitespace, `undefined`/function members dropped, `toJSON()` honored. Byte-identical to
-* `serialize` from `@gala-chain/api` / `json-stringify-deterministic` for every JSON-shaped
-* value, which is all a DTO ever is.
-*
-* @throws TypeError for circular structures and BigInt values (as `JSON.stringify` does) and
-* when the value itself has no JSON representation (`undefined`, a function, a symbol).
-*/
-function serialize(value) {
-	JSON.stringify(value);
-	const result = deterministicNode(value);
-	if (result === void 0) throw new TypeError("Cannot serialize a value with no JSON representation.");
-	return result;
-}
-/**
-* The exact string GalaChain hashes for a DTO: the (optional, string) `prefix` field PREPENDED to
-* the deterministic serialization of the DTO WITHOUT `signature`, `multisig`, `trace` and `prefix`.
-* Equivalent to `@gala-chain/api` 3.x `getPayloadToSign` for every non-EIP-712 DTO.
-*/
-function getPayloadToSign(dto) {
-	const { prefix, ...rest } = dto;
-	delete rest["signature"];
-	delete rest["multisig"];
-	delete rest["trace"];
-	return (typeof prefix === "string" ? prefix : "") + serialize(rest);
-}
-const ETHEREUM_SIGNED_MESSAGE = String.fromCharCode(25) + "Ethereum Signed Message:\n";
-/**
-* The EIP-191 header for `message`: `"\x19Ethereum Signed Message:\n"` + the message's UTF-8 BYTE
-* length. This is what a wallet's `personal_sign` prepends, and what the chain recomputes when it
-* recovers a personal-signed DTO.
-*/
-function calculatePersonalSignPrefix(message) {
-	return ETHEREUM_SIGNED_MESSAGE + String(textEncoder$1.encode(message).length);
-}
-/**
-* The EIP-191 header for `serialize(dto)` (any `prefix` already on the DTO is ignored). This is
-* deliberately the same string the signers hand a wallet to sign, so the header's length can never
-* disagree with the signed message. Wallet-neutral: it is the value both a browser wallet's
-* `personal_sign` and Gala Wallet's `gala_signChainDto` (personal-sign scheme) prepend.
-*/
-function personalSignPrefixFor(dto) {
-	const withoutPrefix = { ...dto };
-	delete withoutPrefix["prefix"];
-	return calculatePersonalSignPrefix(serialize(withoutPrefix));
-}
-/**
-* The `@gala-chain/connect`-style prefix frontend_v2 puts in the body of an EIP-712 write: the
-* EIP-191 header whose number counts the prefix string ITSELF plus the body (the UTF-8 length of
-* `getPayloadToSign({ ...dto, prefix })`), found by fixpoint because adding the prefix changes the
-* length (a body of 99 bytes settles on 101).
-*
-* It is NOT a personal-sign prefix (a personal-sign write with this value recovers a phantom
-* signer; use `personalSignPrefixFor`). Under EIP-712 the field is an untyped extra that the
-* typed-data hash ignores and defi-backend recomputes, so it only exists to keep the submitted
-* body byte-identical to what frontend_v2 has always sent.
-*/
-function fixpointPrefixFor(dto) {
-	const withoutPrefix = { ...dto };
-	delete withoutPrefix["prefix"];
-	let payloadLength = textEncoder$1.encode(getPayloadToSign(withoutPrefix)).length;
-	let prefix = ETHEREUM_SIGNED_MESSAGE + String(payloadLength);
-	let previousLength = -1;
-	while (payloadLength !== previousLength) {
-		previousLength = payloadLength;
-		prefix = ETHEREUM_SIGNED_MESSAGE + String(payloadLength);
-		payloadLength = textEncoder$1.encode(getPayloadToSign({
-			...withoutPrefix,
-			prefix
-		})).length;
-	}
-	return prefix;
-}
-function invalidPrivateKey(reason) {
-	return new GSwapSDKError("INVALID_PRIVATE_KEY", { reason });
-}
-const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-function decodeBase64(input) {
-	if (!/^[A-Za-z0-9+/]+={0,2}$/u.test(input) || input.length % 4 !== 0) return void 0;
-	const unpadded = input.replace(/=+$/u, "");
-	const bytes = [];
-	let buffer = 0;
-	let bits = 0;
-	for (const char of unpadded) {
-		buffer = buffer << 6 | BASE64_ALPHABET.indexOf(char);
-		bits += 6;
-		if (bits >= 8) {
-			bits -= 8;
-			bytes.push(buffer >> bits & 255);
-		}
-	}
-	return Uint8Array.from(bytes);
-}
-function decodeHex(input) {
-	const bytes = new Uint8Array(input.length / 2);
-	for (let index = 0; index < bytes.length; index += 1) bytes[index] = parseInt(input.slice(index * 2, index * 2 + 2), 16);
-	return bytes;
-}
-/**
-* Normalizes a secp256k1 private key to a fresh 32-byte array (the caller may zero it). Also
-* accepts 32 raw bytes, which are validated and copied. For strings it accepts what `@gala-chain/api`'s
-* `normalizePrivateKey` accepted for a usable key: 64 hex characters (optionally `0x`-prefixed;
-* a 63-character hex key is left-padded with a zero) or a 44-character base64 string.
-*
-* @throws GSwapSDKError (`INVALID_PRIVATE_KEY`; `params.reason` is one of
-* `INVALID_PRIVATE_KEY_REASONS`: `wrong_length` for raw bytes that are not 32 long,
-* `bad_encoding` for any other string shape, `not_on_curve` for an out-of-range scalar).
-*/
-function normalizePrivateKey(input) {
-	if (typeof input !== "string") {
-		if (!(input instanceof Uint8Array) || input.length !== 32) throw invalidPrivateKey("wrong_length");
-		if (!_noble_curves_secp256k1.secp256k1.utils.isValidSecretKey(input)) throw invalidPrivateKey("not_on_curve");
-		return Uint8Array.from(input);
-	}
-	const withoutPrefix = input.startsWith("0x") ? input.slice(2) : input;
-	let key;
-	if (/^[0-9a-fA-F]{63,64}$/u.test(withoutPrefix)) key = decodeHex(withoutPrefix.length === 63 ? `0${withoutPrefix}` : withoutPrefix);
-	else if (withoutPrefix.length === 44) key = decodeBase64(withoutPrefix);
-	if ((key === null || key === void 0 ? void 0 : key.length) !== 32) throw invalidPrivateKey("bad_encoding");
-	if (!_noble_curves_secp256k1.secp256k1.utils.isValidSecretKey(key)) throw invalidPrivateKey("not_on_curve");
-	return key;
-}
-/**
-* Signs a 32-byte keccak256 hash and returns GalaChain's recoverable signature: 64 hex `r` +
-* 64 hex `s` + `1b`/`1c` (`v`), lowercase, no `0x`. Deterministic (RFC 6979) and low-S, exactly
-* what `@gala-chain/api` and the Gala Wallet produce. A DER signature carries no recovery byte
-* and cannot be used: the chain RECOVERS the signer from the signature.
-*/
-function signHash(privateKey, hash) {
-	if (hash.length !== 32) throw new GSwapSDKError("INVALID_SIGNING_HASH_LENGTH", { length: hash.length });
-	const signature = _noble_curves_secp256k1.secp256k1.sign(hash, privateKey, {
-		prehash: false,
-		lowS: true
-	});
-	return (0, _noble_hashes_utils.bytesToHex)(signature.toBytes("compact")) + (signature.recovery === 1 ? "1c" : "1b");
-}
-/**
-* The lowercase `0x` Ethereum address (last 20 bytes of keccak256 of the uncompressed public key)
-* of a normalized private key. The Gala `eth|` identity of a key is this address.
-*/
-function ethAddressOfPrivateKey(privateKey) {
-	const publicKey = _noble_curves_secp256k1.secp256k1.getPublicKey(privateKey, false);
-	return `0x${(0, _noble_hashes_utils.bytesToHex)((0, _noble_hashes_sha3.keccak_256)(publicKey.slice(1)).slice(-20))}`;
-}
-/** keccak256 of a string's UTF-8 bytes. */
-function keccak256Utf8(data) {
-	return (0, _noble_hashes_sha3.keccak_256)(textEncoder$1.encode(data));
-}
-/**
-* GalaChain NATIVE signature over an already-serialized DTO: keccak256 of the exact bytes, with no
-* prefix and no signature envelope. The caller owns serialization, so the bytes shown to a user
-* and the bytes signed can never diverge.
-*/
-function signSerializedNative(privateKey, serializedDto) {
-	return signHash(privateKey, keccak256Utf8(serializedDto));
-}
-/**
-* GalaChain NATIVE signature for a DTO: keccak256 of `getPayloadToSign(dto)`, signed with
-* secp256k1. Byte-identical to `signatures.getSignature` from `@gala-chain/api`.
-*/
-function signNative(privateKey, dto) {
-	return signSerializedNative(privateKey, getPayloadToSign(dto));
-}
-/**
-* Personal-sign hash and signature: keccak256(`prefix` + `message`), both hashed VERBATIM with no
-* further EIP-191 wrapping. Passing `prefix = calculatePersonalSignPrefix(message)` reproduces a
-* wallet's `personal_sign` of `message`. Gala Wallet's `gala_signChainDto` (personal-sign
-* scheme) hashes `prefix` + the exact string it is handed, which can differ from the bare message
-* (see the `signatureOverPrefixlessBody` vectors); that quirk is why the two inputs stay separate.
-*/
-function signPersonalMessage(privateKey, prefix, message) {
-	return signHash(privateKey, keccak256Utf8(prefix + message));
-}
-
-//#endregion
-//#region src/classes/signers.ts
-function getWalletProvider() {
-	var _globalObject$window;
-	const wallet = (_globalObject$window = globalThis.window) === null || _globalObject$window === void 0 ? void 0 : _globalObject$window.gala;
-	if (!wallet) throw new GSwapSDKError("GALA_WALLET_NOT_AVAILABLE", {});
-	return wallet;
-}
-function getNativeSignature(value) {
-	if (typeof value !== "string") throw new GSwapSDKError("INVALID_SIGNATURE", { scheme: "native" });
-	if (!/^(?:0x)?[0-9a-fA-F]{130}$/u.test(value)) throw new GSwapSDKError("INVALID_SIGNATURE", { scheme: "native" });
-	return value;
-}
-function getPersonalSignature(value) {
-	if (typeof value !== "string" || !/^(?:0x)?[0-9a-fA-F]{130}$/u.test(value)) throw new GSwapSDKError("INVALID_SIGNATURE", { scheme: "personal-sign" });
-	return value;
-}
-/**
-* The `0x`-prefixed Ethereum address a Gala account is signed by, or `undefined` when the account
-* names no key (a `client|` alias or a bare GalaChain id is not derivable from a key). Accepts
-* `0x` plus 40 hex digits and `eth|` plus 40 hex digits, with or without `0x`; the caller's casing
-* is kept. For {@link LazyPrivateKeySignerOptions.expectedAddress}, which should only be set for
-* an account whose key can be checked.
-*
-* @example
-* ```ts
-* createLazyPrivateKeySigner(getKey, { expectedAddress: ethereumAddressOfAccount(account) });
-* ```
-*/
-function ethereumAddressOfAccount(account) {
-	const match = /^(?:eth\|(?:0x)?|0x)([0-9a-fA-F]{40})$/u.exec(account);
-	return (match === null || match === void 0 ? void 0 : match[1]) === void 0 ? void 0 : `0x${match[1]}`;
-}
-function normalizeEthereumAccount(address, allowGalaPrefix) {
-	const normalized = allowGalaPrefix ? ethereumAddressOfAccount(address) ?? address : address;
-	if (!/^0x[0-9a-fA-F]{40}$/u.test(normalized)) throw new GSwapSDKError("INVALID_WALLET_ADDRESS", {
-		field: "walletAddress",
-		value: address
-	});
-	return normalized;
-}
-/**
-* The account handed to Gala Wallet as the signer address. An Ethereum account is held to the
-* same strict check as ever (`0x` plus 40 hex digits; `eth|` plus 40 hex digits, with or without
-* `0x`, is normalized to it). A GalaChain id the wallet can also be asked to sign for is passed
-* through verbatim: `client|` plus 24 hex digits, or the bare 24 hex digits that frontend_v2 keeps
-* in `state.user.wallet` after a direct `client|` login. Nothing else is accepted.
-*/
-function normalizeGalaWalletAccount(address) {
-	const eth = /^eth\|(?:0x)?([0-9a-fA-F]{40})$/u.exec(address);
-	if ((eth === null || eth === void 0 ? void 0 : eth[1]) !== void 0) return `0x${eth[1]}`;
-	if (/^0x[0-9a-fA-F]{40}$/u.test(address) || /^(?:client\|)?[0-9a-fA-F]{24}$/u.test(address)) return address;
-	throw new GSwapSDKError("INVALID_WALLET_ADDRESS", {
-		field: "walletAddress",
-		value: address
-	});
-}
-/** An identity Gala Wallet can act as: an account form above, any `eth|`/`client|` alias, verbatim. */
-function assertWalletIdentity(identity) {
-	if (!/^(?:eth\|(?:0x)?[0-9a-fA-F]{40}|0x[0-9a-fA-F]{40}|(?:client\|)?[0-9a-fA-F]{24})$/u.test(identity)) throw new GSwapSDKError("INVALID_WALLET_ADDRESS", {
-		field: "selectAddress",
-		value: identity
-	});
-}
-/** Provider-wide queue: `setAddress` + the signature request must not interleave across signers. */
-const walletIdentityQueue = /* @__PURE__ */ new WeakMap();
-/**
-* Runs `signWith` with `identity` selected on a Gala Wallet that supports `setAddress`. Gala
-* Wallet holds ONE current account, so two signatures for different identities in flight at once
-* would sign as whichever selection came last; the pair (select, sign) is therefore serialized
-* per provider. A failed selection fails the signature (nothing is requested).
-*/
-function withSelectedIdentity(wallet, identity, signWith) {
-	const { setAddress } = wallet;
-	if (identity === void 0 || typeof setAddress !== "function") return signWith();
-	const run = (walletIdentityQueue.get(wallet) ?? Promise.resolve()).catch(() => void 0).then(async () => {
-		await setAddress.call(wallet, identity);
-		return signWith();
-	});
-	walletIdentityQueue.set(wallet, run);
-	return run;
-}
-function personalSign(provider, dto, walletAddress, methodName) {
-	const prefix = personalSignPrefixFor(dto);
-	const payload = {
-		...dto,
-		prefix
-	};
-	const params = methodName !== void 0 ? [
-		serialize(payload),
-		walletAddress,
-		methodName
-	] : [serialize(dto), walletAddress];
-	return provider.request({
-		method: methodName !== void 0 ? "gala_signChainDto" : "personal_sign",
-		params
-	}).then((value) => ({
-		...payload,
-		signature: getPersonalSignature(value)
-	}));
-}
-/**
-* Signs a DTO via genuine EIP-712 (`eth_signTypedData_v4`) — correctly resolves the `client|`
-* identity, unlike `personal_sign`, for the operations in `EIP712_CAPABLE_METHODS`.
-*
-* Constructs the raw JSON-RPC payload by hand (`{domain, types: {...types, EIP712Domain},
-* primaryType, message}`) rather than depending on ethers.js, matching exactly what
-* `ethers.TypedDataEncoder.getPayload`/`Wallet.signTypedData` produce internally — verified
-* byte-for-byte equivalent (same recovered address from the same signature against both
-* constructions) before this shipped, since gswap-sdk deliberately has no ethers dependency.
-*/
-async function signEIP712(provider, methodName, dto, walletAddress) {
-	const { completedDto, types } = buildEIP712Payload(methodName, dto);
-	const domain = eip712DomainFor(await provider.request({
-		method: "eth_chainId",
-		params: []
-	}));
-	const prefix = fixpointPrefixFor(completedDto);
-	const message = {
-		...completedDto,
-		prefix
-	};
-	const eip712Domain = [{
-		name: "name",
-		type: "string"
-	}, {
-		name: "chainId",
-		type: "uint256"
-	}];
-	const payload = {
-		domain,
-		types: {
-			...types,
-			EIP712Domain: eip712Domain
-		},
-		primaryType: methodName,
-		message
-	};
-	const value = await provider.request({
-		method: "eth_signTypedData_v4",
-		params: [walletAddress, JSON.stringify(payload)]
-	});
-	return {
-		...message,
-		signature: getPersonalSignature(value),
-		types,
-		domain
-	};
-}
-/**
-* A GalaChain native signer backed by a secp256k1 private key.
-*
-* Native signing produces the bare GalaChain signature format, without a personal-sign prefix
-* or EIP-712 metadata. The private-key identity is recovered by the chain.
-*/
-var PrivateKeySigner = class {
-	privateKey;
-	/**
-	* Creates a native signer from a hex or base64 secp256k1 private key.
-	*
-	* @example
-	* ```typescript
-	* const signer = new PrivateKeySigner('1'.padStart(64, '0'));
-	* const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
-	* ```
-	*/
-	constructor(privateKey) {
-		this.privateKey = normalizePrivateKey(privateKey);
-	}
-	/**
-	* Signs the DTO with GalaChain native signing.
-	*
-	* @example
-	* ```typescript
-	* const signed = await signer.signObject('RequestTrade', {
-	*   token0: 'GALA',
-	*   token1: 'GUSDC',
-	*   fee: 3000,
-	* });
-	* ```
-	*/
-	signObject(_methodName, dto) {
-		const signature = signNative(this.privateKey, dto);
-		return Promise.resolve({
-			...dto,
-			signature
-		});
-	}
-};
-/**
-* Calls the app's key provider. Whatever it throws or rejects with is the app's own failure to
-* produce a key before anything was signed or sent, so it becomes `KEY_PROVIDER_FAILED` (the
-* original is `cause`); an SDK error is already catalogued and passes through.
-*/
-async function keyFrom(getPrivateKey) {
-	try {
-		return await getPrivateKey();
-	} catch (cause) {
-		throw isGSwapError(cause) ? cause : new GSwapSDKError("KEY_PROVIDER_FAILED", {}, { cause });
-	}
-}
-/**
-* Creates the native-signing equivalent of {@link PrivateKeySigner} for apps that must not hold a
-* key in a long-lived object (an extension that reads its session key at sign time).
-*
-* `getPrivateKey` is called once per `signObject` call, never cached, never shared between calls
-* (concurrent signatures each fetch their own key), and the normalized key bytes are zeroed
-* before `signObject` settles, also on failure. A rejection or exception from `getPrivateKey` (the
-* app's "wallet is locked", a storage read that failed) is a `KEY_PROVIDER_FAILED` error with the
-* original error as `cause`: nothing has been sent, so `classifyFailure` says `not_sent` and Retry
-* is safe, and the app needs no error class of its own to tell this apart. A provider that returns
-* no usable string (`''`, `undefined`) is `INVALID_PRIVATE_KEY` with `reason: 'no_key_provided'`,
-* classified the same way; any other key that is not a valid secp256k1 key string is an
-* `INVALID_PRIVATE_KEY` error. An SDK error the provider throws itself is passed through.
-* Signatures are byte-identical to `new PrivateKeySigner(key).signObject(...)`.
-*
-* A JavaScript string cannot be wiped; the provider owns the lifetime of the string it returns.
-*
-* @example
-* ```typescript
-* const signer = createLazyPrivateKeySigner(
-*   () => SecurityHelper.getSessionSecret(SecurityHelper.SESSION_PRIVATE_KEY_KEY),
-*   { expectedAddress: account.address },
-* );
-* const gswap = new GSwap({ signer });
-* ```
-*/
-function createLazyPrivateKeySigner(getPrivateKey, options = {}) {
-	const expected = options.expectedAddress;
-	const expectedLower = expected === void 0 ? void 0 : normalizeEthereumAccount(expected, true).toLowerCase();
-	return { async signObject(_methodName, dto) {
-		const provided = await keyFrom(getPrivateKey);
-		if (typeof provided !== "string" || provided === "") throw new GSwapSDKError("INVALID_PRIVATE_KEY", { reason: "no_key_provided" });
-		const key = normalizePrivateKey(provided);
-		try {
-			if (expectedLower !== void 0 && ethAddressOfPrivateKey(key) !== expectedLower) throw new GSwapSDKError("SIGNER_ADDRESS_MISMATCH", {});
-			return {
-				...dto,
-				signature: signNative(key, dto)
-			};
-		} finally {
-			key.fill(0);
-		}
-	} };
-}
-/**
-* A Gala Wallet signer using native GalaChain signing, with an opt-in personal-sign mode.
-*
-* The selected Ethereum account is passed to Gala Wallet. There is NO automatic fallback: a
-* wallet that rejects `native` surfaces its error to the caller, because the only alternative,
-* `personal-sign`, silently recovers a phantom signer on every released Gala Wallet.
-*
-* `scheme: 'personal-sign'` calls
-* `gala_signChainDto([serialize({ ...dto, prefix }), walletAddress, methodName])` and REQUIRES
-* a wallet build that contains wallet_extension commit 34ca4e4 (strips the embedded `prefix`
-* field and hashes `prefix` + the prefix-less canonical body, the chain's scheme). Wallets
-* released before that fix hash the string with the `prefix` field still inside it and the
-* signature recovers to an address nobody holds, so only opt in once the fixed wallet is
-* released. See SIGNING-PARITY.md.
-*/
-var GalaWalletSigner = class {
-	/** The wallet address supplied to Gala Wallet for each signing request. */
-	walletAddress;
-	/** The signing scheme used for every request; it never changes after construction. */
-	scheme;
-	/**
-	* Creates a Gala Wallet signer.
-	*
-	* @example
-	* ```typescript
-	* const signer = new GalaWalletSigner('0x0123456789012345678901234567890123456789');
-	* const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
-	* ```
-	*
-	* @param walletAddress - The account passed to Gala Wallet as the signer address. An Ethereum
-	* account is `0x` plus 40 hex digits (Gala Wallet's `eth|...` form is normalized to it and held
-	* to the same check); a GalaChain id is `client|` plus 24 hex digits, or the bare 24 hex digits
-	* frontend_v2 keeps for a direct `client|` login, and is passed through unchanged.
-	* @param options - Select native signing (default) or personal-sign explicitly.
-	* `'personal-sign'` requires a Gala Wallet build with wallet_extension commit 34ca4e4.
-	* `selectAddress` is the identity (`client|...` / `eth|...`) Gala Wallet is switched to with
-	* `window.gala.setAddress` before every signature, when the wallet offers it.
-	*/
-	constructor(walletAddress, options = {}) {
-		this.walletAddress = normalizeGalaWalletAccount(walletAddress);
-		this.scheme = options.scheme ?? "native";
-		if (options.selectAddress !== void 0) assertWalletIdentity(options.selectAddress);
-		this.selectAddress = options.selectAddress;
-	}
-	/** The identity Gala Wallet is switched to before each signature, if one was given. */
-	selectAddress;
-	/**
-	* Signs a DTO through `gala_signChainDto`.
-	*
-	* @example
-	* ```typescript
-	* const signed = await signer.signObject('AddLiquidity', {
-	*   token0: 'GALA',
-	*   token1: 'GUSDC',
-	*   tickLower: -60,
-	*   tickUpper: 60,
-	* });
-	* ```
-	*/
-	async signObject(methodName, dto) {
-		const wallet = getWalletProvider();
-		return withSelectedIdentity(wallet, this.selectAddress, async () => {
-			if (this.scheme === "personal-sign") return personalSign(wallet, dto, this.walletAddress, methodName);
-			const signature = await wallet.request({
-				method: "gala_signChainDto",
-				params: [
-					serialize(dto),
-					this.walletAddress,
-					methodName,
-					"native"
-				]
-			});
-			return {
-				...dto,
-				signature: getNativeSignature(signature)
-			};
-		});
-	}
-};
-/**
-* A personal-sign signer for MetaMask and other EIP-1193 browser wallets.
-*
-* The chain recovers this signature using the EIP-191 wrap applied by the wallet to
-* `personal_sign`. This is the browser-wallet path used by the v2 frontend and resolves the
-* bare `eth|` identity.
-*/
-var BrowserWalletSigner = class {
-	provider;
-	/**
-	* Creates a browser-wallet signer.
-	*
-	* Defaults to `personal_sign` — unchanged from every existing integration, since it only ever
-	* resolves the bare `eth|` identity and changing that silently would be a real behavior
-	* break for anyone already depending on it. Pass `{ scheme: 'eip712' }` to correctly resolve
-	* a registered `client|` alias instead, for `RequestTrade`/`AddLiquidity`/`RemoveLiquidity`/
-	* `CollectPositionFees` (`EIP712_CAPABLE_METHODS`) — `CreatePool` and any other method still
-	* falls back to `personal_sign` even in `'eip712'` mode, since its EIP-712 signing is a
-	* separate, unsolved chain-side problem.
-	*
-	* @example
-	* ```typescript
-	* const signer = new BrowserWalletSigner(window.ethereum, '0x0123456789012345678901234567890123456789');
-	* const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
-	* ```
-	* @example
-	* ```typescript
-	* // Correctly resolves a registered client| alias instead of the bare eth| address.
-	* const signer = new BrowserWalletSigner(window.ethereum, walletAddress, { scheme: 'eip712' });
-	* ```
-	*/
-	constructor(provider, walletAddress, options = {}) {
-		this.provider = provider;
-		this.walletAddress = normalizeEthereumAccount(walletAddress, false);
-		this.scheme = options.scheme ?? "personal-sign";
-	}
-	/** The selected `0x` Ethereum account every signature is requested for. */
-	walletAddress;
-	scheme;
-	/**
-	* Signs the DTO with `eth_signTypedData_v4` (when constructed with `{ scheme: 'eip712' }` and
-	* `methodName` is in `EIP712_CAPABLE_METHODS`) or the EIP-1193 `personal_sign` method
-	* (otherwise — the default).
-	*
-	* @example
-	* ```typescript
-	* const signed = await signer.signObject('RequestTrade', {
-	*   token0: 'GALA',
-	*   token1: 'GUSDC',
-	*   fee: 3000,
-	* });
-	* ```
-	*/
-	signObject(methodName, dto) {
-		if (this.scheme === "eip712" && EIP712_CAPABLE_METHODS.has(methodName)) return signEIP712(this.provider, methodName, dto, this.walletAddress);
-		return personalSign(this.provider, dto, this.walletAddress);
-	}
-};
-
-//#endregion
-//#region src/classes/storage_adapters.ts
-/**
-* A {@link StorageAdapter} over a `chrome.storage` area, the shape the wallet stores pending swaps
-* in: the value lands under the key as the structured value it is (the browser clones it; nothing
-* is serialized here). A missing key resolves `undefined`; a rejection of the area reaches the
-* store, which treats it as "storage unavailable".
+* A {@link StorageAdapter} over a `chrome.storage` area, the shape the wallet stores pending swaps
+* in: the value lands under the key as the structured value it is (the browser clones it; nothing
+* is serialized here). A missing key resolves `undefined`; a rejection of the area reaches the
+* store, which treats it as "storage unavailable".
 *
 * Pass a FUNCTION that returns the area to look it up at each call instead of when the adapter is
 * built: a module that is imported where `chrome` does not exist yet (a test, a closing extension
@@ -7412,658 +6255,6 @@ function webStorageAdapter(area) {
 	};
 }
 
-//#endregion
-//#region src/utils/chain_dto_signing.ts
-/**
-* String-key signing entry points for apps that hold a private key only briefly (the Gala Wallet
-* extension reads its session key at sign time and must not keep it in a long-lived object).
-*
-* These are thin, byte-exact ports of the functions the wallet shipped in
-* `wallet_extension/src/helpers/wallet/signing.ts` (including the fail-closed personal-sign
-* payload resolver from its commit 34ca4e4), re-expressed over the SDK's own primitives. Every
-* function takes the key as a string (`0x`-optional hex, or base64) or as bytes, normalizes it per
-* call, and zeroes the normalized copy before returning, so nothing in this module retains a key.
-* A JavaScript string cannot be wiped; the caller owns the lifetime of the string it passes in.
-*/
-/**
-* Runs `action` with a private normalized copy of the key, zeroed afterwards (also when `action`
-* throws). Bytes given by the caller are copied, never modified: the caller owns them.
-*/
-function withPrivateKey(privateKey, action) {
-	const key = normalizePrivateKey(privateKey);
-	try {
-		return action(key);
-	} finally {
-		key.fill(0);
-	}
-}
-/**
-* GalaChain NATIVE signature over an already-serialized DTO: keccak256 of the exact bytes with no
-* prefix and no envelope (wallet `signChainDtoNative`). The caller owns serialization, so the
-* bytes a user reviewed and the bytes signed cannot diverge.
-*
-* @returns 130 lowercase hex characters, `r || s || v` with `v` = `1b`/`1c`, no `0x`.
-*/
-function signChainDtoNative(privateKey, serializedDto) {
-	return withPrivateKey(privateKey, (key) => signSerializedNative(key, serializedDto));
-}
-/**
-* The personal-sign hash primitive (wallet `signChainDtoHash`): keccak256(`prefix` + `message`),
-* both verbatim, with no further EIP-191 wrap. `message` must be the DTO's serialization WITHOUT
-* its `prefix` field; callers holding a dApp-supplied string go through `signChainDtoPersonalSign`,
-* which derives both inputs from it.
-*/
-function signChainDtoHash(privateKey, prefix, message) {
-	return withPrivateKey(privateKey, (key) => signPersonalMessage(key, prefix, message));
-}
-const PERSONAL_SIGN_HEADER = String.fromCharCode(25) + "Ethereum Signed Message:\n";
-const PERSONAL_SIGN_LENGTH_PATTERN = /^(?:0|[1-9][0-9]*)$/u;
-function isPersonalSignHeader(prefix) {
-	return prefix.startsWith(PERSONAL_SIGN_HEADER) && PERSONAL_SIGN_LENGTH_PATTERN.test(prefix.slice(26));
-}
-/**
-* Top-level fields that would make the chain (`getPayloadToSign`) or defi-backend's personal-sign
-* verifier hash something other than `prefix + serialize(dto minus prefix)`. An unsigned DTO from
-* a dApp never legitimately carries any of them, so they fail closed. Order is part of the error
-* message the wallet shows its user.
-*/
-const PERSONAL_SIGN_FORBIDDEN_FIELDS = [
-	"signature",
-	"multisig",
-	"trace",
-	"types",
-	"domain",
-	"stringsInstructions"
-];
-/**
-* Derives what to hash for a `gala_signChainDto` personal-sign request from the exact string the
-* dApp sent (and the approval card displayed): wallet `resolvePersonalSignChainDtoPayload`.
-*
-* The dApp submits `{ ...dto, prefix, signature }`, which the chain recovers from
-* `keccak256(prefix + serialize(dto WITHOUT prefix))`. So when the string embeds a `prefix`
-* field, that field is removed and the remainder re-serialized; the prefix used is the dApp's own
-* value byte for byte. A string with no `prefix` field is hashed verbatim with an empty prefix
-* (chain-equivalent to a native signature of that exact string).
-*
-* Fails closed (throws `GSwapSDKError` `PERSONAL_SIGN_NOT_JSON`, `PERSONAL_SIGN_NOT_OBJECT`,
-* `PERSONAL_SIGN_BAD_PREFIX`, `PERSONAL_SIGN_ENVELOPE_FIELDS` or `PERSONAL_SIGN_NOT_CANONICAL`) on:
-* malformed JSON; JSON that is not a plain object; a `prefix` that is not an EIP-191
-* "Ethereum Signed Message" header; any signing-envelope field (`signature`, `multisig`, `trace`,
-* `types`, `domain`, `stringsInstructions`); and a string that is not already the canonical
-* serialization of what it parses to (duplicate keys, lossy numbers, key-order tricks the card
-* would render differently). Stripping `prefix` is therefore the ONLY byte change between the
-* reviewed string and the signed message.
-*/
-function resolvePersonalSignChainDtoPayload(data) {
-	let parsed;
-	try {
-		parsed = JSON.parse(data);
-	} catch {
-		throw new GSwapSDKError("PERSONAL_SIGN_NOT_JSON", {});
-	}
-	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new GSwapSDKError("PERSONAL_SIGN_NOT_OBJECT", {});
-	const dto = parsed;
-	if (!Object.prototype.hasOwnProperty.call(dto, "prefix")) return {
-		prefix: "",
-		message: data
-	};
-	const { prefix, ...withoutPrefix } = dto;
-	if (typeof prefix !== "string" || !isPersonalSignHeader(prefix)) throw new GSwapSDKError("PERSONAL_SIGN_BAD_PREFIX", {});
-	const forbidden = PERSONAL_SIGN_FORBIDDEN_FIELDS.filter((field) => Object.prototype.hasOwnProperty.call(withoutPrefix, field));
-	if (forbidden.length > 0) throw new GSwapSDKError("PERSONAL_SIGN_ENVELOPE_FIELDS", { fields: forbidden.join(", ") });
-	if (serialize(dto) !== data) throw new GSwapSDKError("PERSONAL_SIGN_NOT_CANONICAL", {});
-	return {
-		prefix,
-		message: serialize(withoutPrefix)
-	};
-}
-/**
-* Signs a GalaChain personal-sign scheme DTO from the exact string a dApp sent through
-* `gala_signChainDto` (wallet `signChainDtoPersonalSign`). See
-* `resolvePersonalSignChainDtoPayload` for what is signed and what is refused; the signature
-* recovers, under the chain's `getPayloadToSign`, to this key for the DTO the dApp submits with
-* its `prefix`, and equals a `personal_sign` of the bare body when that prefix is the EIP-191
-* header of the bare body's byte length.
-*
-* @throws GSwapSDKError (`PERSONAL_SIGN_*`, see `resolvePersonalSignChainDtoPayload`) before any
-* signing when the input is refused.
-*/
-function signChainDtoPersonalSign(privateKey, data) {
-	const { prefix, message } = resolvePersonalSignChainDtoPayload(data);
-	return signChainDtoHash(privateKey, prefix, message);
-}
-/**
-* Raw object signing (wallet `signObject`), used for transfers, bridge and fee-dry-run DTOs the
-* wallet signs itself. Removes ONLY `signature`, signs `keccak256(serialize(rest))` natively
-* (no `prefix` handling, and `trace` / `multisig` stay in the signed bytes, unlike
-* `signNative`), and returns `{ signature, ...rest }` with the signature as the FIRST key, exactly
-* like the wallet. Callers that must not sign extra fields strip them first.
-*/
-function signRawObject(privateKey, obj) {
-	const rest = { ...obj };
-	delete rest["signature"];
-	return {
-		signature: signChainDtoNative(privateKey, serialize(rest)),
-		...rest
-	};
-}
-/**
-* Drops the `EIP712Domain` entry from a dApp-supplied types map (a typed-data encoder derives the
-* domain type itself and rejects an explicit one). The order of the remaining types is preserved.
-*/
-function stripEip712DomainType(types) {
-	const stripped = {};
-	for (const typeName of Object.keys(types)) if (typeName !== "EIP712Domain") stripped[typeName] = types[typeName];
-	return stripped;
-}
-/**
-* `collection$category$type$additionalKey` for a token-class object (wallet `decodeTokenData`).
-* Lenient on purpose: any missing or non-string part becomes `''`, so a display layer never
-* throws on odd input.
-*/
-function tokenClassDollarKey(token) {
-	const part = (field) => {
-		const value = token === null || token === void 0 ? void 0 : token[field];
-		return typeof value === "string" ? value : "";
-	};
-	return `${part("collection")}$${part("category")}$${part("type")}$${part("additionalKey")}`;
-}
-/**
-* A quantity in the form GalaChain's `IsBigNumber` validator accepts: FIXED notation, no leading
-* zeros, no trailing decimal zeros (`BigNumber#toFixed()`; never `toString()`, which turns
-* `0.00000001` into `1e-8`, and never a JS number in between).
-*
-* @throws GSwapSDKError (`INVALID_DECIMAL`) for a value that is not a finite number. The wallet's
-* `cleanNumber` returned the string `'NaN'` there; signing that text can only fail on chain.
-*/
-function canonicalDecimalString(value) {
-	let parsed = new bignumber_js.default(NaN);
-	try {
-		parsed = new bignumber_js.default(value);
-	} catch {}
-	if (!parsed.isFinite()) throw new GSwapSDKError("INVALID_DECIMAL", { value: String(value) });
-	return parsed.toFixed();
-}
-
-//#endregion
-//#region src/utils/typed_data.ts
-/**
-* EIP-712 (`eth_signTypedData_v4`) hashing and signing for ARBITRARY dApp typed data, built on the
-* SDK's own primitives (`@noble/curves`, `@noble/hashes`) so a wallet can sign a dApp's typed-data
-* approval without ethers. It replaces the wallet's `new ethers.Wallet(key).signTypedData(...)`
-* and is pinned to it: the golden suite reproduces every fixture signature exactly and a seeded
-* differential fuzz compares the digest and signature with ethers for every supported type.
-*
-* Compared with ethers this encoder is deliberately STRICTER (it fails closed rather than coerce):
-* `bool` accepts only a boolean, numbers accept only safe integers / decimal or `0x` strings,
-* strings must be well-formed UTF-16, struct values must be objects whose fields are their own
-* properties, and every struct, field and type name must be a plain identifier. Anything ethers
-* accepts that is NOT in that set is refused here instead of being signed in a different shape
-* from what a user reviewed.
-*/
-const textEncoder = new TextEncoder();
-const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/u;
-const TYPE_SYNTAX = /^([A-Za-z_$][A-Za-z0-9_$]*)((?:\[(?:0|[1-9][0-9]*)?\])*)$/u;
-const BIGINT_DECIMAL = /^-?[0-9]+$/u;
-const BIGINT_HEX = /^-?0x[0-9a-fA-F]+$/u;
-/** The EIP-712 domain members and their types, in the order ethers (and the spec) hash them. */
-const DOMAIN_FIELDS = [
-	{
-		name: "name",
-		type: "string"
-	},
-	{
-		name: "version",
-		type: "string"
-	},
-	{
-		name: "chainId",
-		type: "uint256"
-	},
-	{
-		name: "verifyingContract",
-		type: "address"
-	},
-	{
-		name: "salt",
-		type: "bytes32"
-	}
-];
-function concat(parts) {
-	const out = new Uint8Array(parts.reduce((total, part) => total + part.length, 0));
-	let offset = 0;
-	for (const part of parts) {
-		out.set(part, offset);
-		offset += part.length;
-	}
-	return out;
-}
-function bigintToWord(value) {
-	const word = /* @__PURE__ */ new Uint8Array(32);
-	let rest = value < 0n ? value + (1n << 256n) : value;
-	for (let index = 31; index >= 0; index -= 1) {
-		word[index] = Number(rest & 255n);
-		rest >>= 8n;
-	}
-	return word;
-}
-function hexToBytes(hex) {
-	const body = hex.slice(2);
-	const out = new Uint8Array(body.length / 2);
-	for (let index = 0; index < out.length; index += 1) out[index] = parseInt(body.slice(index * 2, index * 2 + 2), 16);
-	return out;
-}
-function toBytes(value, what) {
-	if (value instanceof Uint8Array) return value;
-	if (typeof value === "string" && /^0x(?:[0-9a-fA-F]{2})*$/u.test(value)) return hexToBytes(value);
-	throw new GSwapSDKError("TYPED_DATA_NOT_HEX_BYTES", { what });
-}
-function toBigInt(value, what) {
-	if (typeof value === "bigint") return value;
-	if (typeof value === "number") {
-		if (!Number.isSafeInteger(value)) throw new GSwapSDKError("TYPED_DATA_NOT_SAFE_INTEGER", { what });
-		return BigInt(value);
-	}
-	if (typeof value === "string") {
-		if (BIGINT_DECIMAL.test(value)) return BigInt(value);
-		if (BIGINT_HEX.test(value)) return value.startsWith("-") ? -BigInt(value.slice(1)) : BigInt(value);
-	}
-	throw new GSwapSDKError("TYPED_DATA_NOT_INTEGER", { what });
-}
-function utf8(value, what) {
-	if (typeof value !== "string") throw new GSwapSDKError("TYPED_DATA_NOT_STRING", { what });
-	for (let index = 0; index < value.length; index += 1) {
-		const unit = value.charCodeAt(index);
-		if (unit >= 55296 && unit <= 56319) {
-			const next = value.charCodeAt(index + 1);
-			if (!(next >= 56320 && next <= 57343)) throw new GSwapSDKError("TYPED_DATA_UNPAIRED_SURROGATE", { what });
-			index += 1;
-		} else if (unit >= 56320 && unit <= 57343) throw new GSwapSDKError("TYPED_DATA_UNPAIRED_SURROGATE", { what });
-	}
-	return textEncoder.encode(value);
-}
-/** EIP-55: a mixed-case address must carry the right checksum; all-lower / all-upper is accepted. */
-function addressBytes(value) {
-	if (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/u.test(value)) throw new GSwapSDKError("TYPED_DATA_BAD_ADDRESS", {});
-	const digits = value.slice(2);
-	if (/[A-F]/u.test(digits) && /[a-f]/u.test(digits)) {
-		const hash = (0, _noble_hashes_sha3.keccak_256)(textEncoder.encode(digits.toLowerCase()));
-		for (let index = 0; index < 40; index += 1) {
-			const nibble = hash[index >> 1] >> (index % 2 === 0 ? 4 : 0) & 15;
-			const char = digits.charAt(index);
-			if (char !== (nibble >= 8 ? char.toUpperCase() : char.toLowerCase())) throw new GSwapSDKError("TYPED_DATA_BAD_CHECKSUM", {});
-		}
-	}
-	return hexToBytes(value);
-}
-/** The encoder for a non-struct, non-array type, or undefined when `base` is not one. */
-function leafEncoder(base) {
-	if (base === "string") return (value) => (0, _noble_hashes_sha3.keccak_256)(utf8(value, "string"));
-	if (base === "bytes") return (value) => (0, _noble_hashes_sha3.keccak_256)(toBytes(value, "bytes"));
-	if (base === "bool") return (value) => {
-		if (typeof value !== "boolean") throw new GSwapSDKError("TYPED_DATA_NOT_BOOLEAN", {});
-		return bigintToWord(value ? 1n : 0n);
-	};
-	if (base === "address") return (value) => concat([/* @__PURE__ */ new Uint8Array(12), addressBytes(value)]);
-	const fixed = /^bytes([1-9][0-9]?)$/u.exec(base);
-	if (fixed !== null) {
-		const width = Number(fixed[1]);
-		if (width > 32 || String(width) !== fixed[1]) return void 0;
-		return (value) => {
-			const bytes = toBytes(value, base);
-			if (bytes.length !== width) throw new GSwapSDKError("TYPED_DATA_BYTES_LENGTH", {
-				type: base,
-				width
-			});
-			return concat([bytes, new Uint8Array(32 - width)]);
-		};
-	}
-	const integer = /^(u?)int([1-9][0-9]*)$/u.exec(base);
-	if (integer !== null) {
-		const width = Number(integer[2]);
-		if (width % 8 !== 0 || width > 256 || String(width) !== integer[2]) return void 0;
-		const signed = integer[1] === "";
-		const lower = signed ? -(1n << BigInt(width - 1)) : 0n;
-		const upper = signed ? (1n << BigInt(width - 1)) - 1n : (1n << BigInt(width)) - 1n;
-		return (value) => {
-			const number = toBigInt(value, base);
-			if (number < lower || number > upper) throw new GSwapSDKError("TYPED_DATA_OUT_OF_BOUNDS", { type: base });
-			return bigintToWord(number);
-		};
-	}
-}
-function parseType(type) {
-	const match = TYPE_SYNTAX.exec(type);
-	if (match === null) throw new GSwapSDKError("TYPED_DATA_UNSUPPORTED_TYPE", { type });
-	const dimensions = [...(match[2] ?? "").matchAll(/\[([0-9]*)\]/gu)].map((dimension) => dimension[1] === "" ? -1 : Number(dimension[1]));
-	return {
-		base: match[1],
-		dimensions
-	};
-}
-function parseFields(typeName, rawFields) {
-	if (!Array.isArray(rawFields)) throw new GSwapSDKError("TYPED_DATA_FIELDS_NOT_LIST", { typeName });
-	const seen = /* @__PURE__ */ new Set();
-	return rawFields.map((raw) => {
-		const field = raw;
-		if (typeof (field === null || field === void 0 ? void 0 : field.name) !== "string" || typeof field.type !== "string") throw new GSwapSDKError("TYPED_DATA_FIELD_MALFORMED", { typeName });
-		if (!IDENTIFIER.test(field.name)) throw new GSwapSDKError("TYPED_DATA_INVALID_FIELD_NAME", { name: field.name });
-		if (seen.has(field.name)) throw new GSwapSDKError("TYPED_DATA_DUPLICATE_FIELD", {
-			name: field.name,
-			typeName
-		});
-		seen.add(field.name);
-		const parsed = parseType(field.type);
-		const base = parsed.base === "uint" || parsed.base === "int" ? `${parsed.base}256` : parsed.base;
-		return {
-			name: field.name,
-			type: base + field.type.slice(parsed.base.length)
-		};
-	});
-}
-/**
-* Builds the struct encoder for a set of type definitions: validates the type graph (unknown or
-* circular references, duplicate fields) and infers the primary type as the single type no other
-* type references, exactly like ethers' `TypedDataEncoder`.
-*/
-function createStructEncoder(rawTypes) {
-	const names = Object.keys(rawTypes);
-	const fields = /* @__PURE__ */ new Map();
-	for (const name of names) {
-		if (!IDENTIFIER.test(name)) throw new GSwapSDKError("TYPED_DATA_INVALID_TYPE_NAME", { name });
-		fields.set(name, parseFields(name, rawTypes[name]));
-	}
-	const children = /* @__PURE__ */ new Map();
-	const parents = /* @__PURE__ */ new Map();
-	for (const name of names) {
-		children.set(name, /* @__PURE__ */ new Set());
-		parents.set(name, /* @__PURE__ */ new Set());
-	}
-	for (const [name, list] of fields) for (const field of list) {
-		var _children$get, _parents$get;
-		const { base } = parseType(field.type);
-		if (base === name) throw new GSwapSDKError("TYPED_DATA_CIRCULAR_TYPE", { typeName: name });
-		if (leafEncoder(base) !== void 0) continue;
-		if (!fields.has(base)) throw new GSwapSDKError("TYPED_DATA_UNKNOWN_FIELD_TYPE", {
-			type: base,
-			typeName: name
-		});
-		(_children$get = children.get(name)) === null || _children$get === void 0 || _children$get.add(base);
-		(_parents$get = parents.get(base)) === null || _parents$get === void 0 || _parents$get.add(name);
-	}
-	const roots = names.filter((name) => {
-		var _parents$get2;
-		return ((_parents$get2 = parents.get(name)) === null || _parents$get2 === void 0 ? void 0 : _parents$get2.size) === 0;
-	});
-	if (roots.length === 0) throw new GSwapSDKError("TYPED_DATA_NO_PRIMARY_TYPE", {});
-	if (roots.length > 1) throw new GSwapSDKError("TYPED_DATA_AMBIGUOUS_PRIMARY_TYPE", { roots: roots.join(", ") });
-	const primaryType = roots[0];
-	const visiting = /* @__PURE__ */ new Set();
-	const checked = /* @__PURE__ */ new Set();
-	const checkCircular = (name) => {
-		if (visiting.has(name)) throw new GSwapSDKError("TYPED_DATA_CIRCULAR_TYPE", { typeName: name });
-		if (checked.has(name)) return;
-		visiting.add(name);
-		for (const child of children.get(name) ?? []) checkCircular(child);
-		visiting.delete(name);
-		checked.add(name);
-	};
-	checkCircular(primaryType);
-	const dependencies = (name, found) => {
-		for (const child of children.get(name) ?? []) if (!found.has(child)) {
-			found.add(child);
-			dependencies(child, found);
-		}
-		return found;
-	};
-	const encodeOne = (name) => `${name}(${(fields.get(name) ?? []).map((field) => `${field.type} ${field.name}`).join(",")})`;
-	const typeHashes = /* @__PURE__ */ new Map();
-	for (const name of names) {
-		const sorted = [...dependencies(name, /* @__PURE__ */ new Set())].filter((dep) => dep !== name).sort();
-		typeHashes.set(name, (0, _noble_hashes_sha3.keccak_256)(textEncoder.encode([name, ...sorted].map(encodeOne).join(""))));
-	}
-	const encodeValue = (parsed, value, depth) => {
-		const dimension = parsed.dimensions[parsed.dimensions.length - 1 - depth];
-		if (dimension !== void 0) {
-			if (!Array.isArray(value)) throw new GSwapSDKError("TYPED_DATA_ARRAY_EXPECTED", { type: parsed.base });
-			if (dimension !== -1 && dimension !== value.length) throw new GSwapSDKError("TYPED_DATA_ARRAY_LENGTH_MISMATCH", {});
-			return (0, _noble_hashes_sha3.keccak_256)(concat(value.map((item) => encodeValue(parsed, item, depth + 1))));
-		}
-		const leaf = leafEncoder(parsed.base);
-		if (leaf !== void 0) return leaf(value);
-		return hashStruct(parsed.base, value);
-	};
-	function hashStruct(typeName, value) {
-		const list = fields.get(typeName);
-		const typeHash = typeHashes.get(typeName);
-		if (list === void 0 || typeHash === void 0) throw new Error(`Internal error: no encoder for struct ${typeName}`);
-		if (value === null || typeof value !== "object" || Array.isArray(value)) throw new GSwapSDKError("TYPED_DATA_STRUCT_NOT_OBJECT", { typeName });
-		const record = value;
-		const words = list.map((field) => {
-			if (!Object.prototype.hasOwnProperty.call(record, field.name)) throw new GSwapSDKError("TYPED_DATA_MISSING_FIELD", {
-				typeName,
-				field: field.name
-			});
-			return encodeValue(parseType(field.type), record[field.name], 0);
-		});
-		return (0, _noble_hashes_sha3.keccak_256)(concat([typeHash, ...words]));
-	}
-	return {
-		primaryType,
-		hashStruct
-	};
-}
-function hashDomain(domain) {
-	if (domain === null || typeof domain !== "object" || Array.isArray(domain)) throw new GSwapSDKError("TYPED_DATA_DOMAIN_NOT_OBJECT", {});
-	for (const key of Object.keys(domain)) if (!DOMAIN_FIELDS.some((field) => field.name === key)) throw new GSwapSDKError("TYPED_DATA_INVALID_DOMAIN_KEY", { key: JSON.stringify(key) });
-	return createStructEncoder({ EIP712Domain: DOMAIN_FIELDS.filter((field) => Object.prototype.hasOwnProperty.call(domain, field.name)) }).hashStruct("EIP712Domain", domain);
-}
-/**
-* The EIP-712 digest `keccak256(0x1901 || domainSeparator || hashStruct(primaryType, message))`
-* that a wallet signs for `eth_signTypedData_v4`. The primary type is inferred, as ethers does.
-*
-* @throws GSwapSDKError (`TYPED_DATA_*`) for any type graph or value it cannot encode
-* exactly (see the module note on strictness).
-*/
-function hashTypedData(payload) {
-	const domainHash = hashDomain(payload.domain);
-	const encoder = createStructEncoder(payload.types);
-	const structHash = encoder.hashStruct(encoder.primaryType, payload.message);
-	return (0, _noble_hashes_sha3.keccak_256)(concat([
-		Uint8Array.of(25, 1),
-		domainHash,
-		structHash
-	]));
-}
-/**
-* Signs a dApp's EIP-712 typed-data approval (the wallet's `signTypedMessage` path), replacing
-* `new ethers.Wallet(key).signTypedData(domain, types, message)`. `types` must already have
-* `EIP712Domain` removed (`stripEip712DomainType`).
-*
-* @returns `0x` + r + s + v with `v` = `0x1b`/`0x1c` (27/28): ethers' serialized signature form,
-* recoverable with `verifyTypedData` / `eth_signTypedData_v4` verifiers. Rejects (never throws
-* synchronously) on invalid input.
-*/
-async function signTypedDataPayload(privateKey, payload) {
-	const digest = hashTypedData(payload);
-	return withPrivateKey(privateKey, (key) => `0x${signHash(key, digest)}`);
-}
-
-//#endregion
-//#region src/utils/axios_requestor.ts
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
-* An axios interceptor may resolve something that is not a response at all (for example a string
-* for ECONNREFUSED). That is a transport failure, not an HTTP answer.
-*/
-function isAxiosLikeResponse(value) {
-	return isRecord$1(value) && typeof value["status"] === "number";
-}
-function readAxiosHeader(headers, name) {
-	if (!isRecord$1(headers)) return null;
-	const getter = headers["get"];
-	if (typeof getter === "function") {
-		const value = getter.call(headers, name);
-		return typeof value === "string" ? value : null;
-	}
-	const match = Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase());
-	return typeof (match === null || match === void 0 ? void 0 : match[1]) === "string" ? match[1] : null;
-}
-function toHttpResponse(answer, url) {
-	if (!isAxiosLikeResponse(answer)) throw new GSwapSDKError("TRANSPORT_ERROR", { url }, { url });
-	const { status, data, headers } = answer;
-	return {
-		ok: status >= 200 && status < 300,
-		status,
-		json: () => Promise.resolve(data),
-		text: () => Promise.resolve(typeof data === "string" ? data : JSON.stringify(data)),
-		headers: { get: (name) => readAxiosHeader(headers, name) }
-	};
-}
-function headersFor(init, omit) {
-	const omitted = new Set(omit.map((name) => name.toLowerCase()));
-	const raw = init === null || init === void 0 ? void 0 : init.headers;
-	const entries = raw === void 0 ? [] : raw instanceof Headers ? [...raw.entries()] : Array.isArray(raw) ? raw.map(([name, value]) => [String(name), String(value)]) : Object.entries(raw).map(([name, value]) => [name, String(value)]);
-	return Object.fromEntries(entries.filter(([name]) => !omitted.has(name.toLowerCase())));
-}
-/**
-* An SDK {@link HttpRequestor} over an axios instance, so the SDK's requests travel through the
-* app's own base URL, interceptors and error handling.
-*
-* A POST's string body is parsed back to the object the SDK serialized it from (axios serializes
-* again, and an interceptor may read the object); a GET goes through `instance.get`. The answer
-* is an HTTP response whose `json()`/`text()` read `response.data`. An answer that is not an
-* axios response is a `TRANSPORT_ERROR` rejection, and so is a rejection that means no HTTP
-* answer arrived (the original error is `cause`): any rejection with `rejectOnHttpError: false`
-* (every status resolves there), an axios error without a `response` with `true`. Any other
-* rejection (an interceptor's error for a 4xx, say) is rethrown unchanged, and so is an abort.
-*
-* Pair it with `ChainGateway`'s `dexBackendBaseUrl: ''` when the instance owns the base URL.
-*
-* @example
-* ```ts
-* const submitGateway = new ChainGateway({
-*   dexBackendBaseUrl: '',
-*   httpRequestor: httpRequestorFromAxios(chainGatewayInstance, { rejectOnHttpError: true }),
-* });
-* ```
-*/
-function httpRequestorFromAxios(instance, options) {
-	const omit = options.omitHeaders ?? ["content-type"];
-	return async (uri, init) => {
-		const signal = (init === null || init === void 0 ? void 0 : init.signal) ?? void 0;
-		const config = {
-			headers: headersFor(init, omit),
-			...signal ? { signal } : {},
-			...options.rejectOnHttpError ? {} : { validateStatus: () => true }
-		};
-		const isPost = ((init === null || init === void 0 ? void 0 : init.method) ?? "GET").toUpperCase() === "POST";
-		const body = isPost && typeof (init === null || init === void 0 ? void 0 : init.body) === "string" ? JSON.parse(init.body) : void 0;
-		let answer;
-		try {
-			answer = await (isPost ? instance.post(uri, body, config) : instance.get(uri, config));
-		} catch (error) {
-			if ((signal === null || signal === void 0 ? void 0 : signal.aborted) === true || !isTransportRejection(error, options.rejectOnHttpError)) throw error;
-			throw new GSwapSDKError("TRANSPORT_ERROR", { url: uri }, {
-				url: uri,
-				cause: error
-			});
-		}
-		return toHttpResponse(answer, uri);
-	};
-}
-/**
-* Whether an axios rejection means no HTTP answer arrived. With `rejectOnHttpError: false` every
-* status resolves, so any rejection is one. With `true`, a 4xx/5xx rejects too, so only an axios
-* error that carries no `response` is (an interceptor's own error is an app answer and passes
-* through; an app whose interceptors turn network errors into their own class names it in
-* `ChainGatewayOptions.isTransportFailure`).
-*/
-function isTransportRejection(error, rejectOnHttpError) {
-	if (!rejectOnHttpError) return true;
-	return isRecord$1(error) && error["isAxiosError"] === true && error["response"] === void 0;
-}
-
-//#endregion
-//#region src/utils/ethers_provider.ts
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isTypedDataTypes(value) {
-	return isRecord(value) && Object.values(value).every((fields) => Array.isArray(fields) && fields.every((field) => isRecord(field) && typeof field["name"] === "string" && typeof field["type"] === "string"));
-}
-function malformed(method) {
-	return new GSwapSDKError("MALFORMED_WALLET_REQUEST", { method });
-}
-/** Splits `eth_signTypedData_v4` params (`[account, JSON payload]`) into what ethers' signer takes. */
-function readTypedDataRequest(params) {
-	const raw = params === null || params === void 0 ? void 0 : params[1];
-	let payload;
-	try {
-		payload = typeof raw === "string" ? JSON.parse(raw) : raw;
-	} catch {
-		throw malformed("eth_signTypedData_v4");
-	}
-	if (!isRecord(payload)) throw malformed("eth_signTypedData_v4");
-	const { domain, types, message } = payload;
-	if (!isRecord(domain) || !isTypedDataTypes(types) || !isRecord(message)) throw malformed("eth_signTypedData_v4");
-	return {
-		domain,
-		types: stripEip712DomainType(types),
-		message
-	};
-}
-/**
-* An EIP-1193 provider over an ethers v6 provider, for {@link BrowserWalletSigner}: apps whose
-* wallet connection is an ethers `BrowserProvider` sign through the very ethers calls they always
-* made, with no hand-written shim.
-*
-* - `eth_chainId` is `provider.send('eth_chainId', [])`: the wallet's LIVE chain. Never
-*   `provider.getNetwork()`, which ethers caches and does not invalidate on `chainChanged`, so a
-*   user who switches networks after connecting would sign against a stale chainId.
-* - `eth_signTypedData_v4` parses the `[account, JSON]` params and calls
-*   `signer.signTypedData(domain, types, message)` with `EIP712Domain` removed from `types`.
-* - `personal_sign` is `options.personalSign(message)` when given, else `signer.signMessage`.
-* - Anything else is `UNSUPPORTED_WALLET_METHOD`; a malformed request is
-*   `MALFORMED_WALLET_REQUEST`; a missing provider is `WALLET_UNAVAILABLE`.
-*
-* `provider` may be `null`/`undefined` (nothing connected): a request that needs it then fails
-* with `WALLET_UNAVAILABLE` rather than at construction, so a signer can be built before the
-* connection state is known.
-*
-* @example
-* ```ts
-* const signer = new BrowserWalletSigner(eip1193ProviderFromEthers(browserProvider), account, {
-*   scheme: 'eip712',
-* });
-* ```
-*/
-function eip1193ProviderFromEthers(provider, options = {}) {
-	const connected = () => {
-		if (provider === null || provider === void 0) throw new GSwapSDKError("WALLET_UNAVAILABLE", {});
-		return provider;
-	};
-	return { request: async ({ method, params }) => {
-		switch (method) {
-			case "eth_chainId": return connected().send("eth_chainId", []);
-			case "eth_signTypedData_v4": {
-				const wallet = connected();
-				const { domain, types, message } = readTypedDataRequest(params);
-				return (await wallet.getSigner()).signTypedData(domain, types, message);
-			}
-			case "personal_sign": {
-				const message = params === null || params === void 0 ? void 0 : params[0];
-				if (typeof message !== "string") throw malformed("personal_sign");
-				if (options.personalSign !== void 0) return options.personalSign(message);
-				return (await connected().getSigner()).signMessage(message);
-			}
-			default: throw new GSwapSDKError("UNSUPPORTED_WALLET_METHOD", { method });
-		}
-	} };
-}
-
 //#endregion
 //#region src/utils/confirmation_state.ts
 /** The state of every confirmation code (a typo is caught by the all-codes test). */
@@ -8091,7 +6282,7 @@ const STATE_OF_CODE = {
 */
 function confirmationStateOf(error) {
 	var _toFailureView, _Object$entries$find;
-	const code = (_toFailureView = toFailureView(error)) === null || _toFailureView === void 0 ? void 0 : _toFailureView.code;
+	const code = (_toFailureView = (0, _gala_chain_gala_core_sdk.toFailureView)(error)) === null || _toFailureView === void 0 ? void 0 : _toFailureView.code;
 	if (code === void 0) return void 0;
 	return (_Object$entries$find = Object.entries(STATE_OF_CODE).find(([known]) => known === code)) === null || _Object$entries$find === void 0 ? void 0 : _Object$entries$find[1];
 }
@@ -8104,43 +6295,6 @@ function isConfirmationTimeout(error) {
 	return confirmationStateOf(error) === "timeout";
 }
 
-//#endregion
-//#region src/utils/fetch_failure.ts
-/**
-* True when a rejection of a `fetch`-based requestor means NO HTTP ANSWER ARRIVED: the network
-* failed, the connection was reset, the host did not resolve, CORS blocked it. For a write that
-* is not a refusal (the request may have been queued), so this is the default
-* `ChainGatewayOptions.isTransportFailure` for a requestor that wraps `fetch` and rejects with
-* its own errors.
-*
-* - Yes: a `TypeError` (what `fetch` rejects with in every engine: `Failed to fetch`, `Load failed`,
-*   `NetworkError when attempting to fetch resource`, undici's `fetch failed`), recognised by name
-*   too so one from another realm (an extension page, an iframe) still counts, and a
-*   `DOMException` named `NetworkError`.
-* - No: an abort (`AbortError`) or a timeout (`TimeoutError`). The SDK's own request layer knows
-*   whether its timer or the caller's signal aborted, and reports those itself
-*   (`REQUEST_TIMEOUT`, or the caller's own abort unchanged); claiming them here would turn the
-*   caller's cancel into "maybe queued".
-* - No: anything else, including an SDK error and a value that is not an object.
-*
-* It never throws.
-*
-* @example
-* ```ts
-* new ChainGateway({ dexBackendBaseUrl, httpRequestor: galaFetch, isTransportFailure: isFetchTransportFailure });
-* ```
-*/
-function isFetchTransportFailure(error) {
-	if (typeof error !== "object" || error === null) return false;
-	try {
-		const name = "name" in error ? error.name : void 0;
-		if (name === "AbortError" || name === "TimeoutError") return false;
-		return error instanceof TypeError || name === "TypeError" || name === "NetworkError";
-	} catch {
-		return false;
-	}
-}
-
 //#endregion
 //#region src/utils/failure_guards.ts
 /**
@@ -8163,7 +6317,7 @@ function isFetchTransportFailure(error) {
 * ```
 */
 function isUniqueKeyConsumed(error) {
-	const view = toFailureView(error);
+	const view = (0, _gala_chain_gala_core_sdk.toFailureView)(error);
 	return (view === null || view === void 0 ? void 0 : view.code) === "CHAIN_DISPATCH_FAILED" && view.status === 409;
 }
 const UNPROVEN_ACKNOWLEDGEMENT_CODES = [
@@ -8199,7 +6353,7 @@ function isCodeIn(code, codes) {
 * error (`{ code: 'ACTION_REJECTED' }`, a numeric `4001`) is never a member.
 */
 function hasCodeIn(error, codes) {
-	const view = toFailureView(error);
+	const view = (0, _gala_chain_gala_core_sdk.toFailureView)(error);
 	return view !== void 0 && isCodeIn(view.code, codes);
 }
 /**
@@ -8252,10 +6406,10 @@ function isUninterpretedAnswer(error) {
 * ```
 */
 function chainErrorKeyOf(error) {
-	const view = toFailureView(error);
+	const view = (0, _gala_chain_gala_core_sdk.toFailureView)(error);
 	if (view === void 0) return void 0;
 	if (view.code !== "CHAIN_REJECTED" && view.code !== "CHAIN_DISPATCH_FAILED") return void 0;
-	const errorKey = stringParamOf(view, "errorKey");
+	const errorKey = (0, _gala_chain_gala_core_sdk.stringParamOf)(view, "errorKey");
 	return errorKey === void 0 || errorKey === "" ? void 0 : errorKey;
 }
 /** Codes that mean "there is no market for this" however the app reached them. */
@@ -8281,10 +6435,10 @@ const NO_MARKET_CODES = [
 * ```
 */
 function isNoMarket(error) {
-	const view = toFailureView(error);
+	const view = (0, _gala_chain_gala_core_sdk.toFailureView)(error);
 	if (view === void 0) return false;
 	if (isCodeIn(view.code, NO_MARKET_CODES)) return true;
-	return !isWriteView(view) && (view.notFound === true || view.status === 404);
+	return !(0, _gala_chain_gala_core_sdk.isWriteView)(view) && (view.notFound === true || view.status === 404);
 }
 
 //#endregion
@@ -8331,42 +6485,38 @@ function classifySubmitEnvelope(envelope) {
 exports.ALL_FEE_TIERS = ALL_FEE_TIERS;
 exports.AppliedTradeError = AppliedTradeError;
 exports.Assets = Assets;
-exports.BrowserWalletSigner = BrowserWalletSigner;
 exports.CanonicalSymbols = CanonicalSymbols;
 exports.ChainGateway = ChainGateway;
-exports.DEFAULT_UNIQUE_KEY_PREFIX = DEFAULT_UNIQUE_KEY_PREFIX;
 exports.DEX_FEE_METHODS = DEX_FEE_METHODS;
 exports.DRY_RUN_METHOD = DRY_RUN_METHOD;
 exports.DRY_RUN_UNIQUE_KEY_PREFIX = DRY_RUN_UNIQUE_KEY_PREFIX;
 exports.DexFees = DexFees;
-exports.EIP712_CAPABLE_METHODS = EIP712_CAPABLE_METHODS;
-exports.FAILURE_OUTCOMES = FAILURE_OUTCOMES;
 exports.FEE_TIER = FEE_TIER;
 exports.GC_MAX_TICK = GC_MAX_TICK;
 exports.GC_MIN_TICK = GC_MIN_TICK;
 exports.GSWAP_ENVIRONMENTS = GSWAP_ENVIRONMENTS;
 exports.GSWAP_ERROR_CATALOG = GSWAP_ERROR_CATALOG;
-exports.GSWAP_ERROR_PHASES = GSWAP_ERROR_PHASES;
 exports.GSWAP_ERROR_PHASE_BY_CODE = GSWAP_ERROR_PHASE_BY_CODE;
 exports.GSwap = GSwap;
 exports.GSwapSDKError = GSwapSDKError;
-exports.GalaWalletSigner = GalaWalletSigner;
 exports.GdexStreamError = GdexStreamError;
 exports.GdexStreamService = GdexStreamService;
-exports.INVALID_PRIVATE_KEY_REASONS = INVALID_PRIVATE_KEY_REASONS;
+exports.Leaderboard = Leaderboard;
+exports.MARKET_PRICE_BATCH_LIMIT = MARKET_PRICE_BATCH_LIMIT;
+exports.MARKET_PRICE_QUERY_BYTES = MARKET_PRICE_QUERY_BYTES;
+exports.Market = Market;
 exports.NOT_QUEUED_FINAL = NOT_QUEUED_FINAL;
 exports.PENDING_SWAPS_STORAGE_KEY = PENDING_SWAPS_STORAGE_KEY;
 exports.PENDING_SWAP_EXPIRY_MS = PENDING_SWAP_EXPIRY_MS;
 exports.PENDING_SWAP_FATES = PENDING_SWAP_FATES;
 exports.PENDING_SWAP_PRUNE_REASONS = PENDING_SWAP_PRUNE_REASONS;
+exports.PRICE_SERIES_TIMEFRAMES = PRICE_SERIES_TIMEFRAMES;
 exports.PendingSwapStore = PendingSwapStore;
 exports.Pools = Pools;
 exports.Positions = Positions;
-exports.PrivateKeySigner = PrivateKeySigner;
 exports.Quoting = Quoting;
 exports.SHADOW_FAILURE_KINDS = SHADOW_FAILURE_KINDS;
 exports.SHADOW_SUBMIT_CODES = SHADOW_SUBMIT_CODES;
-exports.SIGNING_FAILURE_REASONS = SIGNING_FAILURE_REASONS;
 exports.SUBMISSION_OUTCOME_UNKNOWN_REASONS = SUBMISSION_OUTCOME_UNKNOWN_REASONS;
 exports.SubmittedTransaction = SubmittedTransaction;
 exports.Swaps = Swaps;
@@ -8380,47 +6530,29 @@ exports.alignTickUpOrNaN = alignTickUpOrNaN;
 exports.assertCanonicalPair = assertCanonicalPair;
 exports.assertCanonicalV2Dto = assertCanonicalV2Dto;
 exports.assertTickRange = assertTickRange;
-exports.assertUniqueKey = assertUniqueKey;
 exports.buildAddLiquidityDto = buildAddLiquidityDto;
 exports.buildCollectPositionFeesDto = buildCollectPositionFeesDto;
 exports.buildCreatePoolDto = buildCreatePoolDto;
 exports.buildDryRunWrapper = buildDryRunWrapper;
-exports.buildEIP712Payload = buildEIP712Payload;
 exports.buildRemoveLiquidityDto = buildRemoveLiquidityDto;
 exports.buildRequestTradeDto = buildRequestTradeDto;
-exports.calculatePersonalSignPrefix = calculatePersonalSignPrefix;
-exports.canonicalDecimalString = canonicalDecimalString;
 exports.chainErrorKeyOf = chainErrorKeyOf;
 exports.classification = classification;
 exports.classifyFailure = classifyFailure;
 exports.classifyShadowSubmitError = classifyShadowSubmitError;
 exports.classifyShadowSubmitStatus = classifyShadowSubmitStatus;
 exports.classifySubmitEnvelope = classifySubmitEnvelope;
-exports.compositeKeyOf = compositeKeyOf;
 exports.confirmAppliedTrade = confirmAppliedTrade;
 exports.confirmationStateOf = confirmationStateOf;
-exports.createLazyPrivateKeySigner = createLazyPrivateKeySigner;
-exports.createUniqueKey = createUniqueKey;
-exports.eip1193ProviderFromEthers = eip1193ProviderFromEthers;
-exports.eip712DomainFor = eip712DomainFor;
-exports.ethAddressOfPrivateKey = ethAddressOfPrivateKey;
-exports.ethereumAddressOfAccount = ethereumAddressOfAccount;
-exports.fixpointPrefixFor = fixpointPrefixFor;
 exports.frameSlot0 = frameSlot0;
-exports.generateEIP712Types = generateEIP712Types;
 exports.getObjectProperty = getObjectProperty;
-exports.getPayloadToSign = getPayloadToSign;
 exports.getStringProperty = getStringProperty;
 exports.gswapErrorTemplates = gswapErrorTemplates;
-exports.hashTypedData = hashTypedData;
-exports.httpRequestorFromAxios = httpRequestorFromAxios;
 exports.isConfirmationAborted = isConfirmationAborted;
 exports.isConfirmationTimeout = isConfirmationTimeout;
 exports.isCurrentContractDexMessage = isCurrentContractDexMessage;
 exports.isDexFeeMethod = isDexFeeMethod;
-exports.isFetchTransportFailure = isFetchTransportFailure;
 exports.isGSwapError = isGSwapError;
-exports.isGSwapErrorLike = isGSwapErrorLike;
 exports.isGdexLiquidityEvent = isGdexLiquidityEvent;
 exports.isNoMarket = isNoMarket;
 exports.isPreSendError = isPreSendError;
@@ -8435,47 +6567,25 @@ exports.isTickInRange = isTickInRange;
 exports.isUninterpretedAnswer = isUninterpretedAnswer;
 exports.isUniqueKeyConsumed = isUniqueKeyConsumed;
 exports.isUnprovenAcknowledgement = isUnprovenAcknowledgement;
-exports.isValidUniqueKey = isValidUniqueKey;
-exports.isWalletUserRejection = isWalletUserRejection;
-exports.isWriteView = isWriteView;
 exports.mayHaveBeenQueued = mayHaveBeenQueued;
-exports.normalizePrivateKey = normalizePrivateKey;
 exports.notSentClassification = notSentClassification;
 exports.orderSymbols = orderSymbols;
-exports.parseJson = parseJson;
 exports.parseTokenClassKey = parseTokenClassKey;
 exports.pendingSwapFateFor = pendingSwapFateFor;
 exports.pendingSwapFateOfOutcome = pendingSwapFateOfOutcome;
-exports.personalSignPrefixFor = personalSignPrefixFor;
+exports.priceBatches = priceBatches;
 exports.queryTokenOf = queryTokenOf;
 exports.rawTokenOf = rawTokenOf;
 exports.readOrderedSymbols = readOrderedSymbols;
 exports.readShadowSubmitOutcome = readShadowSubmitOutcome;
-exports.renderGSwapErrorTemplate = renderGSwapErrorTemplate;
-exports.resolvePersonalSignChainDtoPayload = resolvePersonalSignChainDtoPayload;
-exports.resolveUniqueKeyPrefix = resolveUniqueKeyPrefix;
-exports.serialize = serialize;
-exports.signChainDtoHash = signChainDtoHash;
-exports.signChainDtoNative = signChainDtoNative;
-exports.signChainDtoPersonalSign = signChainDtoPersonalSign;
-exports.signNative = signNative;
-exports.signPersonalMessage = signPersonalMessage;
-exports.signRawObject = signRawObject;
-exports.signSerializedNative = signSerializedNative;
-exports.signTypedDataPayload = signTypedDataPayload;
 exports.sqrtPriceToTick = sqrtPriceToTick;
 exports.storageAdapterFromChromeStorage = storageAdapterFromChromeStorage;
-exports.stripEip712DomainType = stripEip712DomainType;
 exports.swapRouteFromQuote = swapRouteFromQuote;
 exports.tickFromPrice = tickFromPrice;
 exports.tickToPrice = tickToPrice;
 exports.tickToSqrtPrice = tickToSqrtPrice;
 exports.toChainDto = toChainDto;
-exports.toFailureView = toFailureView;
-exports.tokenClassDollarKey = tokenClassDollarKey;
 exports.tradingSymbolOf = tradingSymbolOf;
-exports.tryParseCompositeKey = tryParseCompositeKey;
-exports.tryParseTokenClassKey = tryParseTokenClassKey;
 exports.validateFee = validateFee;
 exports.validateNumericAmount = validateNumericAmount;
 exports.validatePriceValues = validatePriceValues;
@@ -8483,7 +6593,5 @@ exports.validateTickRange = validateTickRange;
 exports.validateTickSpacing = validateTickSpacing;
 exports.validateTokenDecimals = validateTokenDecimals;
 exports.validateWalletAddress = validateWalletAddress;
-exports.walletDeclineCode = walletDeclineCode;
 exports.webStorageAdapter = webStorageAdapter;
-exports.withPrivateKey = withPrivateKey;
 //# sourceMappingURL=index.cjs.map