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

package/dist/index.d.cts

@@ -1,3 +1,4 @@
+import { ErrorParamsOf, FailureOutcome, GALA_ERROR_CATALOG, GalaChainSigner, GalaChainTokenClassKey, GalaErrorCode, GalaErrorContext, GalaSDKError, HTTPResponse, HttpRequestor, UniqueKeyOptions, WireOptions } from "@gala-chain/gala-core-sdk";
 import BigNumber from "bignumber.js";
 import "decimal.js";
 //#region src/types/confirm_options.d.ts
@@ -20,19 +21,6 @@ export interface ConfirmOptions {
   signal?: AbortSignal | undefined;
 }
 //#endregion
-//#region src/types/http_requestor.d.ts
-type FetchReturnValue = Awaited<ReturnType<typeof fetch>>;
-interface HTTPResponse {
-  ok: FetchReturnValue['ok'];
-  status: FetchReturnValue['status'];
-  json: FetchReturnValue['json'];
-  text: FetchReturnValue['text'];
-  headers?: {
-    get(name: string): string | null;
-  } | Record<string, string | undefined>;
-}
-type HttpRequestor = (uri: string, options?: Parameters<typeof fetch>[1]) => Promise<HTTPResponse>;
-//#endregion
 //#region src/types/v2_results.d.ts
 /** Pool metadata returned by GalaChainDex. */
 export interface PoolInfo {
@@ -256,80 +244,7 @@ export interface ChainSubmissionResult {
   uniqueKey?: string;
 }
 //#endregion
-//#region src/types/wire.d.ts
-/**
- * How the SDK writes a read request on the wire. The defaults suit a server-side caller; an app
- * that already issues the same requests from its own HTTP stack (frontend_v2, the Gala Wallet)
- * sets these so the SDK's requests are indistinguishable from the ones it replaces.
- *
- * One object, carried by {@link ChainGateway}, so every service built on a gateway (symbols,
- * pools, positions, quoting) shares it without per-service plumbing.
- */
-export interface WireOptions {
-  /**
-   * Query-string encoding of GET parameters.
-   *
-   * - `'standard'` (default): `URLSearchParams` (`application/x-www-form-urlencoded`), where `$`
-   *   and `|` become `%24` and `%7C`.
-   * - `'readable'`: keeps `$ | : ,` and the RFC 3986 sub-delimiters `! ' ( ) *` unescaped, so a
-   *   composite key such as `GALA$Unit$none$none` or `client|abc` reads as written. Everything
-   *   that would change a query's meaning (`& = # % +`, space, non-ASCII, controls) is still
-   *   percent-encoded (a space is `+`), so the server decodes exactly the value that was passed.
-   *   This is the text frontend_v2's `formatUrl` produces for every value it can represent.
-   */
-  queryEncoding?: 'standard' | 'readable' | undefined;
-  /**
-   * The `User-Agent` request header. Defaults to `GalaChain-SDK/<version>`; `false` omits it
-   * (browsers forbid setting it, and an app whose own requests carry none can match them).
-   * `Content-Type` is only ever sent with a request body, never on a GET.
-   */
-  userAgent?: string | false | undefined;
-  /**
-   * Extra request headers for every read, sent after (and so able to replace) the defaults above;
-   * for example axios' `Accept: application/json, text/plain, *\/*`, so a request is the same as
-   * the one an app's own HTTP stack used to send.
-   */
-  headers?: Record<string, string> | undefined;
-}
-//#endregion
-//#region src/classes/error_phases.d.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.
- */
-export declare const GSWAP_ERROR_PHASES: readonly ['pre_send', 'in_flight', 'post_send'];
-/** One member of {@link GSWAP_ERROR_PHASES}. */
-type GSwapErrorPhase = (typeof GSWAP_ERROR_PHASES)[number];
-//#endregion
-//#region src/classes/error_catalog.d.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.
- *
- * - `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.
- */
-export declare const INVALID_PRIVATE_KEY_REASONS: readonly ['wrong_length', 'bad_encoding', 'not_on_curve', 'no_key_provided'];
-/** One member of {@link INVALID_PRIVATE_KEY_REASONS}. */
-type InvalidPrivateKeyReason = (typeof INVALID_PRIVATE_KEY_REASONS)[number];
+//#region src/classes/gswap_error_catalog.d.ts
 /**
  * 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
@@ -343,20 +258,7 @@ type InvalidPrivateKeyReason = (typeof INVALID_PRIVATE_KEY_REASONS)[number];
 export declare const SUBMISSION_OUTCOME_UNKNOWN_REASONS: readonly ['timeout', 'transport'];
 /** One member of {@link SUBMISSION_OUTCOME_UNKNOWN_REASONS}. */
 type SubmissionOutcomeUnknownReason = (typeof SUBMISSION_OUTCOME_UNKNOWN_REASONS)[number];
-/**
- * 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`.
- */
-export declare const SIGNING_FAILURE_REASONS: readonly ['user_rejected', 'failed'];
-/** One member of {@link SIGNING_FAILURE_REASONS}. */
-type SigningFailureReason = (typeof SIGNING_FAILURE_REASONS)[number];
-/** 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. */
 export declare const GSWAP_ERROR_CATALOG: {
   readonly HTTP_ERROR: {
     readonly phase: 'post_send';
@@ -375,21 +277,6 @@ export declare const GSWAP_ERROR_CATALOG: {
       readonly status: 'number';
     };
   };
-  readonly REQUEST_TIMEOUT: {
-    readonly phase: 'in_flight';
-    readonly template: 'Request to {url} timed out after {timeoutMs} ms.';
-    readonly params: {
-      readonly url: 'string';
-      readonly timeoutMs: 'number';
-    };
-  };
-  readonly TRANSPORT_ERROR: {
-    readonly phase: 'in_flight';
-    readonly template: 'The request to {url} failed before the server answered.';
-    readonly params: {
-      readonly url: 'string';
-    };
-  };
   readonly REQUEST_FAILED: {
     readonly phase: 'in_flight';
     readonly template: 'The {operation} request failed.';
@@ -397,14 +284,6 @@ export declare const GSWAP_ERROR_CATALOG: {
       readonly operation: 'string';
     };
   };
-  readonly INVALID_TIMEOUT: {
-    readonly phase: 'pre_send';
-    readonly template: '{field} must be a positive number of milliseconds, or Infinity for no timeout (got {value}).';
-    readonly params: {
-      readonly field: 'string';
-      readonly value: 'number';
-    };
-  };
   readonly METHOD_NOT_SUPPORTED: {
     readonly phase: 'pre_send';
     readonly template: 'The method {method} is not supported; swaps are queued through RequestTrade.';
@@ -668,69 +547,6 @@ export declare const GSWAP_ERROR_CATALOG: {
       readonly closeCode: 'number';
     };
   };
-  readonly GALA_WALLET_NOT_AVAILABLE: {
-    readonly phase: 'pre_send';
-    readonly template: 'Gala wallet is not available. Please ensure the Gala wallet is connected.';
-    readonly params: {};
-  };
-  readonly WALLET_UNAVAILABLE: {
-    readonly phase: 'pre_send';
-    readonly template: 'No wallet is connected.';
-    readonly params: {};
-  };
-  readonly MALFORMED_WALLET_REQUEST: {
-    readonly phase: 'pre_send';
-    readonly template: 'Wallet {method} request is malformed.';
-    readonly params: {
-      readonly method: 'string';
-    };
-  };
-  readonly UNSUPPORTED_WALLET_METHOD: {
-    readonly phase: 'pre_send';
-    readonly template: 'Unsupported wallet method {method}.';
-    readonly params: {
-      readonly method: 'string';
-    };
-  };
-  readonly INVALID_SIGNATURE: {
-    readonly phase: 'pre_send';
-    readonly template: 'Wallet returned an invalid {scheme} signature.';
-    readonly params: {
-      readonly scheme: 'string';
-    };
-  };
-  readonly INVALID_CHAIN_ID: {
-    readonly phase: 'pre_send';
-    readonly template: 'Wallet returned an invalid chain id ({chainId}).';
-    readonly params: {
-      readonly chainId: 'string';
-    };
-  };
-  readonly SIGNER_ADDRESS_MISMATCH: {
-    readonly phase: 'pre_send';
-    readonly template: 'The signing key does not belong to the expected account.';
-    readonly params: {};
-  };
-  readonly INVALID_PRIVATE_KEY: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid private key: {reason}.';
-    readonly params: {
-      readonly reason: readonly ["wrong_length", "bad_encoding", "not_on_curve", "no_key_provided"];
-    };
-  };
-  readonly SIGNING_FAILED: {
-    readonly phase: 'pre_send';
-    readonly template: 'Signing the {method} request failed ({reason}); nothing was sent.';
-    readonly params: {
-      readonly method: 'string';
-      readonly reason: readonly ["user_rejected", "failed"];
-    };
-  };
-  readonly KEY_PROVIDER_FAILED: {
-    readonly phase: 'pre_send';
-    readonly template: 'The signing key could not be fetched; nothing was sent.';
-    readonly params: {};
-  };
   readonly TOKEN_RESOLUTION_FAILED: {
     readonly phase: 'pre_send';
     readonly template: 'Token {token} could not be looked up; nothing was sent.';
@@ -738,248 +554,11 @@ export declare const GSWAP_ERROR_CATALOG: {
       readonly token: 'string';
     };
   };
-  readonly INVALID_SIGNING_HASH_LENGTH: {
-    readonly phase: 'pre_send';
-    readonly template: 'secp256k1 can only sign a 32-byte hash (got {length}).';
-    readonly params: {
-      readonly length: 'number';
-    };
-  };
   readonly MISSING_WALLET_ADDRESS: {
     readonly phase: 'pre_send';
     readonly 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.';
     readonly params: {};
   };
-  readonly INVALID_WALLET_ADDRESS: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid {field}: "{value}" is not an accepted wallet address form.';
-    readonly params: {
-      readonly field: 'string';
-      readonly value: 'string';
-    };
-  };
-  readonly INVALID_DECIMAL: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid decimal quantity: {value}';
-    readonly params: {
-      readonly value: 'string';
-    };
-  };
-  readonly PERSONAL_SIGN_NOT_JSON: {
-    readonly phase: 'pre_send';
-    readonly template: 'Personal-sign DTO is not valid JSON';
-    readonly params: {};
-  };
-  readonly PERSONAL_SIGN_NOT_OBJECT: {
-    readonly phase: 'pre_send';
-    readonly template: 'Personal-sign DTO must be a JSON object';
-    readonly params: {};
-  };
-  readonly PERSONAL_SIGN_BAD_PREFIX: {
-    readonly phase: 'pre_send';
-    readonly template: 'Personal-sign DTO prefix is not an EIP-191 "Ethereum Signed Message" header';
-    readonly params: {};
-  };
-  readonly PERSONAL_SIGN_ENVELOPE_FIELDS: {
-    readonly phase: 'pre_send';
-    readonly template: 'Personal-sign DTO carries signing-envelope field(s): {fields}';
-    readonly params: {
-      readonly fields: 'string';
-    };
-  };
-  readonly PERSONAL_SIGN_NOT_CANONICAL: {
-    readonly phase: 'pre_send';
-    readonly template: 'Personal-sign DTO is not in canonical serialized form';
-    readonly params: {};
-  };
-  readonly EIP712_NAME_COLLISION: {
-    readonly phase: 'pre_send';
-    readonly template: 'Name collisions are not supported when deriving EIP-712 types ({name}).';
-    readonly params: {
-      readonly name: 'string';
-    };
-  };
-  readonly EIP712_UNSUPPORTED_VALUE: {
-    readonly phase: 'pre_send';
-    readonly template: 'Unsupported EIP-712 value of type {valueType}.';
-    readonly params: {
-      readonly valueType: 'string';
-    };
-  };
-  readonly TYPED_DATA_NOT_STRING: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: {what} must be a string';
-    readonly params: {
-      readonly what: 'string';
-    };
-  };
-  readonly TYPED_DATA_UNPAIRED_SURROGATE: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: {what} has an unpaired surrogate';
-    readonly params: {
-      readonly what: 'string';
-    };
-  };
-  readonly TYPED_DATA_NOT_HEX_BYTES: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: {what} must be an even-length 0x hex string';
-    readonly params: {
-      readonly what: 'string';
-    };
-  };
-  readonly TYPED_DATA_NOT_SAFE_INTEGER: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: {what} must be a safe integer';
-    readonly params: {
-      readonly what: 'string';
-    };
-  };
-  readonly TYPED_DATA_NOT_INTEGER: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: {what} must be an integer';
-    readonly params: {
-      readonly what: 'string';
-    };
-  };
-  readonly TYPED_DATA_NOT_BOOLEAN: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: bool must be a boolean';
-    readonly params: {};
-  };
-  readonly TYPED_DATA_BAD_ADDRESS: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: address must be 0x followed by 40 hex digits';
-    readonly params: {};
-  };
-  readonly TYPED_DATA_BAD_CHECKSUM: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: address has a bad checksum';
-    readonly params: {};
-  };
-  readonly TYPED_DATA_BYTES_LENGTH: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: {type} must be exactly {width} bytes';
-    readonly params: {
-      readonly type: 'string';
-      readonly width: 'number';
-    };
-  };
-  readonly TYPED_DATA_OUT_OF_BOUNDS: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: value out of bounds for {type}';
-    readonly params: {
-      readonly type: 'string';
-    };
-  };
-  readonly TYPED_DATA_UNSUPPORTED_TYPE: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: unsupported type "{type}"';
-    readonly params: {
-      readonly type: 'string';
-    };
-  };
-  readonly TYPED_DATA_FIELDS_NOT_LIST: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: type {typeName} must be a list of fields';
-    readonly params: {
-      readonly typeName: 'string';
-    };
-  };
-  readonly TYPED_DATA_FIELD_MALFORMED: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: type {typeName} has a field without a string name and type';
-    readonly params: {
-      readonly typeName: 'string';
-    };
-  };
-  readonly TYPED_DATA_INVALID_FIELD_NAME: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: invalid field name "{name}"';
-    readonly params: {
-      readonly name: 'string';
-    };
-  };
-  readonly TYPED_DATA_DUPLICATE_FIELD: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: duplicate field "{name}" in {typeName}';
-    readonly params: {
-      readonly name: 'string';
-      readonly typeName: 'string';
-    };
-  };
-  readonly TYPED_DATA_INVALID_TYPE_NAME: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: invalid type name "{name}"';
-    readonly params: {
-      readonly name: 'string';
-    };
-  };
-  readonly TYPED_DATA_CIRCULAR_TYPE: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: circular type reference in {typeName}';
-    readonly params: {
-      readonly typeName: 'string';
-    };
-  };
-  readonly TYPED_DATA_UNKNOWN_FIELD_TYPE: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: unknown type "{type}" in {typeName}';
-    readonly params: {
-      readonly type: 'string';
-      readonly typeName: 'string';
-    };
-  };
-  readonly TYPED_DATA_NO_PRIMARY_TYPE: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: missing primary type';
-    readonly params: {};
-  };
-  readonly TYPED_DATA_AMBIGUOUS_PRIMARY_TYPE: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: ambiguous primary types or unused types ({roots})';
-    readonly params: {
-      readonly roots: 'string';
-    };
-  };
-  readonly TYPED_DATA_ARRAY_EXPECTED: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: {type} array value must be an array';
-    readonly params: {
-      readonly type: 'string';
-    };
-  };
-  readonly TYPED_DATA_ARRAY_LENGTH_MISMATCH: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: array length mismatch';
-    readonly params: {};
-  };
-  readonly TYPED_DATA_STRUCT_NOT_OBJECT: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: {typeName} value must be an object';
-    readonly params: {
-      readonly typeName: 'string';
-    };
-  };
-  readonly TYPED_DATA_MISSING_FIELD: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: {typeName} value is missing field "{field}"';
-    readonly params: {
-      readonly typeName: 'string';
-      readonly field: 'string';
-    };
-  };
-  readonly TYPED_DATA_DOMAIN_NOT_OBJECT: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: domain must be an object';
-    readonly params: {};
-  };
-  readonly TYPED_DATA_INVALID_DOMAIN_KEY: {
-    readonly phase: 'pre_send';
-    readonly template: 'Invalid typed data: invalid typed-data domain key {key}';
-    readonly params: {
-      readonly key: 'string';
-    };
-  };
   readonly NON_CANONICAL_PAIR: {
     readonly phase: 'pre_send';
     readonly template: 'The pair {token0}/{token1} is not in canonical order: token0 must sort before token1.';
@@ -1048,21 +627,6 @@ export declare const GSWAP_ERROR_CATALOG: {
       readonly token: 'string';
     };
   };
-  readonly INVALID_UNIQUE_KEY: {
-    readonly phase: 'pre_send';
-    readonly template: 'The uniqueKey "{uniqueKey}" must be 1-128 characters of A-Z, a-z, 0-9, ".", "_", ":" or "-".';
-    readonly params: {
-      readonly uniqueKey: 'string';
-    };
-  };
-  readonly INVALID_UNIQUE_KEY_PREFIX: {
-    readonly phase: 'pre_send';
-    readonly template: 'uniqueKeyPrefix "{uniqueKeyPrefix}" must be at most {maxLength} characters of A-Z, a-z, 0-9, ".", "_", ":" or "-".';
-    readonly params: {
-      readonly uniqueKeyPrefix: 'string';
-      readonly maxLength: 'number';
-    };
-  };
   readonly AMOUNT_IS_JS_NUMBER: {
     readonly phase: 'pre_send';
     readonly template: 'Invalid {field}: use a decimal string or BigNumber, not a JavaScript number';
@@ -1293,69 +857,49 @@ export declare const GSWAP_ERROR_CATALOG: {
       readonly max: 'number';
     };
   };
-};
-/** Every error code the SDK can throw. */
-type GSwapErrorCode = keyof typeof GSWAP_ERROR_CATALOG;
-interface KindToType {
-  string: string;
-  number: number;
-  boolean: boolean;
-}
-/** The value type of a param kind: a primitive, or the union of a closed set's members. */
-type ParamValue<K> = K extends readonly (infer Member)[] ? Member : K extends keyof KindToType ? KindToType[K] : never;
-/** The named params of one error code: a flat object of primitives (or closed string tokens). */
-type GSwapErrorParams<C extends GSwapErrorCode> = { readonly [P in keyof (typeof GSWAP_ERROR_CATALOG)[C]['params']]: ParamValue<(typeof GSWAP_ERROR_CATALOG)[C]['params'][P]>; };
-/**
- * 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.
- */
-export declare const gswapErrorTemplates: { readonly [C in GSwapErrorCode]: string; };
-/** Fills a template's `{placeholders}` from `params`; an unknown placeholder is left as written. */
-export declare function renderGSwapErrorTemplate(template: string, params: Readonly<Record<string, unknown>>): string;
-//#endregion
-//#region src/types/token.d.ts
-/**
- * The four parts of a GalaChain token class key, as the chain keys a token (for example
- * `GALA|Unit|none|none` is collection `GALA`, category `Unit`, type `none`, additionalKey `none`).
- * It carries no trading symbol: a collection and a symbol disagree for many tokens.
- */
-export interface GalaChainTokenClassKey {
-  collection: string;
-  category: string;
-  type: string;
-  additionalKey: string;
-}
-//#endregion
-//#region src/utils/error_brand.d.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.
- */
-declare const GSWAP_ERROR_BRAND: unique symbol;
-/** The least an object must have to be read as an SDK error or its plain-object view. */
-interface GSwapErrorShape {
-  readonly code: string;
-  readonly params: Readonly<Record<string, unknown>>;
-}
-/**
- * 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
- * ```
- */
-export declare function isGSwapErrorLike(value: unknown): value is GSwapErrorShape;
+  readonly INVALID_MARKET_TOKEN: {
+    readonly phase: 'pre_send';
+    readonly template: 'A market read names a token by a symbol or class key of 1 to 120 letters, digits and . _ $ + / : | - characters (got "{token}").';
+    readonly params: {
+      readonly token: 'string';
+    };
+  };
+  readonly INVALID_TIMEFRAME: {
+    readonly phase: 'pre_send';
+    readonly template: 'timeframe "{value}" is not allowed; it must be one of {allowed}.';
+    readonly params: {
+      readonly value: 'string';
+      readonly allowed: 'string';
+    };
+  };
+  readonly INVALID_SEASON_ID: {
+    readonly phase: 'pre_send';
+    readonly template: 'seasonId must be an integer of at least 1 (got {value}).';
+    readonly params: {
+      readonly value: 'string';
+    };
+  };
+  readonly INVALID_POLL_INTERVAL: {
+    readonly phase: 'pre_send';
+    readonly template: 'intervalMs must be a finite number of milliseconds of at least 1 (got {value}).';
+    readonly params: {
+      readonly value: 'string';
+    };
+  };
+};
+/** Every code a `GSwapSDKError` can carry: the core codes and gswap-sdk's own DEX codes. */
+type GSwapErrorCode = GalaErrorCode | keyof typeof GSWAP_ERROR_CATALOG;
+/** Both catalogs as one type: a code of either reads its entry here. */
+type GSwapCatalog = typeof GALA_ERROR_CATALOG & typeof GSWAP_ERROR_CATALOG;
+/** The named params of one error code (core or DEX): a flat object of primitives (or closed string tokens). */
+type GSwapErrorParams<C extends GSwapErrorCode> = ErrorParamsOf<GSwapCatalog, C>;
+/**
+ * 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.
+ */
+export declare const gswapErrorTemplates: { readonly [C in keyof typeof GSWAP_ERROR_CATALOG]: string; };
 //#endregion
 //#region src/classes/gswap_sdk_error.d.ts
 /**
@@ -1364,48 +908,6 @@ export declare function isGSwapErrorLike(value: unknown): value is GSwapErrorSha
  * says; a confirmation read keeps `CONFIRMATION_FAILED` because the write it confirms may be applied.
  */
 export declare const UPDATE_REQUIRED_STATUS = 426;
-/**
- * The facts of an error that are not placeholders of its message: where it happened and what the
- * server said. All optional; none is localized text.
- */
-export interface GSwapErrorContext {
-  /** The HTTP status of the response that caused the error. */
-  status?: number | undefined;
-  /**
-   * The response body: parsed JSON when the failing response had it, else the raw text (which
-   * the error then exposes as {@link GSwapSDKError.bodyText}).
-   */
-  body?: unknown;
-  /** The URL the failing request went to. */
-  url?: string | undefined;
-  /** The `uniqueKey` of the write this error is about: the handle for `confirm()` and recovery. */
-  uniqueKey?: string | undefined;
-  /** The transaction id of the queued request, `null` when unknown. */
-  requestTransactionId?: string | null | undefined;
-  /** The transaction id of the apply, `null` when unknown. */
-  applyTransactionId?: string | null | undefined;
-  /** The block the apply landed in, `null` when unknown. */
-  blockNumber?: number | null | undefined;
-  /** How long to wait before retrying, from the server's `Retry-After`. */
-  retryAfterMs?: number | undefined;
-  /** The error that caused this one (a transport failure, a wallet rejection). */
-  cause?: unknown;
-  /**
-   * The phase of THIS occurrence when it differs from the code's catalog phase (see
-   * {@link GSwapErrorPhase}): for example `UNKNOWN_TOKEN` is `pre_send` from the symbol registry
-   * but `post_send` when it is derived from a quote answer.
-   */
-  phase?: GSwapErrorPhase | undefined;
-  /** True when the failing operation was on the shadow (dark) path; see {@link GSwapSDKError.shadow}. */
-  shadow?: boolean | undefined;
-  /**
-   * `false` for the failure of a READ (see {@link GSwapSDKError.write}); anything else, including
-   * absent, is a write (fail-closed). Ignored when `uniqueKey` is set: that is a write.
-   */
-  write?: boolean | undefined;
-  /** The wallet's own code on the error a signer threw; see {@link GSwapSDKError.walletCode}. */
-  walletCode?: number | string | undefined;
-}
 /** What {@link GSwapSDKError.fromStatus} may be told about the HTTP answer. */
 export interface GSwapStatusErrorOptions {
   /** The URL the request went to. */
@@ -1422,86 +924,21 @@ export interface GSwapStatusErrorOptions {
   retryAfterMs?: number | undefined;
 }
 /**
- * Error raised by the SDK for validation, gateway, chain, or transaction failures.
+ * 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.
  */
-export declare class GSwapSDKError<C extends GSwapErrorCode = GSwapErrorCode> extends Error {
-  /** The stable, machine-readable code. */
-  readonly code: C;
-  /** The named placeholders of the error: a flat object of primitives, safe to localize with. */
-  readonly params: GSwapErrorParams<C>;
-  /** The server's `Retry-After` in milliseconds (a `RATE_LIMITED` answer), when it sent one. */
-  readonly retryAfterMs: number | undefined;
-  /** The HTTP status of the response that caused this error, when there was one. */
-  readonly status: number | undefined;
-  /**
-   * 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}.
-   */
-  readonly body: unknown;
-  /**
-   * 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.
-   */
-  readonly bodyText: string | undefined;
-  /** The URL the failing request went to, when there was one. */
-  readonly url: string | undefined;
-  /** The `uniqueKey` of the write this error is about, when there is one. */
-  readonly uniqueKey: string | undefined;
-  /** The transaction id of the queued request, when known. */
-  readonly requestTransactionId: string | null | undefined;
-  /** The transaction id of the apply, when known. */
-  readonly applyTransactionId: string | null | undefined;
-  /** The block the apply landed in, when known. */
-  readonly blockNumber: number | null | undefined;
-  /**
-   * 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`.
-   */
-  readonly phase: GSwapErrorPhase;
-  /**
-   * 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.
-   */
-  readonly shadow: boolean;
-  /**
-   * 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`).
-   */
-  readonly write: boolean;
-  /**
-   * 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.
-   */
-  readonly walletCode: number | string | undefined;
-  constructor(code: C, params: GSwapErrorParams<C>, context?: GSwapErrorContext);
-  /**
-   * 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](): true;
+export declare class GSwapSDKError<C extends GSwapErrorCode = GSwapErrorCode> extends GalaSDKError<C, GSwapErrorParams<C>> {
+  /** Core's catalog entries and the DEX entries: a `GSwapSDKError` can carry a code of either. */
+  static readonly catalog: Readonly<Record<GSwapErrorCode, import("@gala-chain/gala-core-sdk").GalaErrorCatalogEntry>>;
+  constructor(code: C, params: GSwapErrorParams<C>, context?: GalaErrorContext);
   /**
    * 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
@@ -1530,7 +967,7 @@ export declare class GSwapSDKError<C extends GSwapErrorCode = GSwapErrorCode> ex
    */
   static fromGatewayBounce(gatewayCode: string, serverMessage: string, status: number, body: unknown, url: string, retryAfterMs?: number, uniqueKey?: string): GSwapSDKError;
   /** Convert a GalaChain `Status: 0` response into a typed SDK error. */
-  static fromChainError(errorKey: string, serverMessage: string, context?: GSwapErrorContext): GSwapSDKError<'CHAIN_REJECTED'>;
+  static fromChainError(errorKey: string, serverMessage: string, context?: GalaErrorContext): GSwapSDKError<'CHAIN_REJECTED'>;
   /**
    * Create the error used when a token is not registered by the current DEX contract. `source` is
    * the backend answer that said so (a quote); its status, body and url are kept.
@@ -1565,11 +1002,17 @@ export declare class GSwapSDKError<C extends GSwapErrorCode = GSwapErrorCode> ex
   /** Convert an unexpected HTTP response into an SDK error. */
   static fromErrorResponse(url: string, response: HTTPResponse): Promise<GSwapSDKError>;
 }
-/** Any thrown value that is an SDK error, narrowed to the union of every code. */
+/** Any thrown value that is an SDK error of a gswap flow, narrowed to the union of every code. */
 export type AnyGSwapError = { [C in GSwapErrorCode]: GSwapSDKError<C>; }[GSwapErrorCode];
 /**
- * True when `value` is an SDK error and, when `code` is given, carries exactly that code. With a
- * code, `error.params` narrows to that code's params.
+ * True when `value` is an SDK error a gswap flow can throw and, when `code` is given, carries
+ * exactly that code. With a code, `error.params` narrows to that code's params.
+ *
+ * It recognises every `GalaSDKError` (`instanceof`), not only a `GSwapSDKError`: the signing,
+ * transport and wallet failures of a gswap flow come from `@gala-chain/gala-core-sdk` (a signer,
+ * the fetch requestor), carry a core code, and are core `GalaSDKError`s. For such an error the
+ * fields are exactly a `GSwapSDKError`'s (`notFound` differs only for the DEX not-found codes,
+ * which core never throws), so the narrowing holds for everything a gswap flow throws.
  *
  * @example
  * ```ts
@@ -1593,8 +1036,9 @@ export declare function isGSwapError<C extends GSwapErrorCode>(value: unknown, c
  * 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
@@ -1606,8 +1050,6 @@ export declare function isPreSendError(value: unknown): boolean;
 export declare function getObjectProperty(value: unknown, property: string): Record<string, unknown> | undefined;
 /** Read a string property from an unknown object. */
 export declare function getStringProperty(value: unknown, property: string): string | undefined;
-/** Parse a response body, preserving non-JSON text for error reporting. */
-export declare function parseJson(text: string): unknown;
 //#endregion
 //#region src/classes/apply_results.d.ts
 /**
@@ -1632,7 +1074,7 @@ export declare function parseJson(text: string): unknown;
  * `blockNumber`, `status`, `body`, `url` and the last transport `cause`.
  */
 export declare class AppliedTradeError<C extends GSwapErrorCode = GSwapErrorCode> extends GSwapSDKError<C> {
-  constructor(code: C, params: GSwapErrorParams<C>, context?: GSwapErrorContext);
+  constructor(code: C, params: GSwapErrorParams<C>, context?: GalaErrorContext);
 }
 /** The transport and backend a confirmation reads from. */
 export interface ApplyResultsClient {
@@ -1717,235 +1159,6 @@ export declare class Assets {
   getUserAssets(ownerAddress: string, page?: number, limit?: number): Promise<UserAssetsResult>;
 }
 //#endregion
-//#region src/classes/signers.d.ts
-/** The signing schemes supported by the Gala Wallet signer. */
-export type GalaWalletScheme = 'native' | 'personal-sign';
-/** The request surface used by an EIP-1193 browser wallet. */
-export interface BrowserWalletProvider {
-  request(args: {
-    method: string;
-    params?: unknown[];
-  }): Promise<unknown>;
-}
-/** A DTO together with the signature that belongs in the gateway request body. */
-export type SignedDto<T extends Record<string, unknown>> = T & {
-  signature: string;
-};
-/**
- * A signer for complete GalaChain write bodies.
- *
- * Implementations return the DTO fields together with the signature that belongs in the
- * gateway request body. Signer identity is recovered from that signature; implementations do
- * not add signer hints, typed-data metadata, or a domain.
- */
-export interface GalaChainSigner {
-  /**
-   * Signs a DTO for a named GalaChain contract method.
-   *
-   * @example
-   * ```typescript
-   * const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
-   * ```
-   */
-  signObject<T extends Record<string, unknown>>(methodName: string, dto: T): Promise<SignedDto<T>>;
-}
-/**
- * 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) });
- * ```
- */
-export declare function ethereumAddressOfAccount(account: string): string | undefined;
-/**
- * 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.
- */
-export declare class PrivateKeySigner implements GalaChainSigner {
-  private readonly 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: string);
-  /**
-   * Signs the DTO with GalaChain native signing.
-   *
-   * @example
-   * ```typescript
-   * const signed = await signer.signObject('RequestTrade', {
-   *   token0: 'GALA',
-   *   token1: 'GUSDC',
-   *   fee: 3000,
-   * });
-   * ```
-   */
-  signObject<T extends Record<string, unknown>>(_methodName: string, dto: T): Promise<SignedDto<T>>;
-}
-/** Supplies a private key at sign time: a hex/base64 string, possibly fetched asynchronously. */
-export type PrivateKeyProvider = () => Promise<string> | string;
-/** Options for {@link createLazyPrivateKeySigner}. */
-export interface LazyPrivateKeySignerOptions {
-  /**
-   * When set, every signature first checks that the fetched key belongs to this account (`0x...`
-   * or the Gala `eth|0x...` / `eth|<40 hex>` form, case-insensitive) and refuses to sign otherwise
-   * (`SIGNER_ADDRESS_MISMATCH`). Use it when the key lives in a slot another surface can switch
-   * between the moment a request was approved and the moment it is signed.
-   */
-  expectedAddress?: string | undefined;
-}
-/**
- * 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 });
- * ```
- */
-export declare function createLazyPrivateKeySigner(getPrivateKey: PrivateKeyProvider, options?: LazyPrivateKeySignerOptions): GalaChainSigner;
-/**
- * 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.
- */
-export declare class GalaWalletSigner implements GalaChainSigner {
-  /** The wallet address supplied to Gala Wallet for each signing request. */
-  readonly walletAddress: string;
-  /** The signing scheme used for every request; it never changes after construction. */
-  readonly scheme: GalaWalletScheme;
-  /**
-   * 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: string, options?: {
-    scheme?: GalaWalletScheme | undefined;
-    selectAddress?: string | undefined;
-  });
-  /** The identity Gala Wallet is switched to before each signature, if one was given. */
-  readonly selectAddress: string | undefined;
-  /**
-   * Signs a DTO through `gala_signChainDto`.
-   *
-   * @example
-   * ```typescript
-   * const signed = await signer.signObject('AddLiquidity', {
-   *   token0: 'GALA',
-   *   token1: 'GUSDC',
-   *   tickLower: -60,
-   *   tickUpper: 60,
-   * });
-   * ```
-   */
-  signObject<T extends Record<string, unknown>>(methodName: string, dto: T): Promise<SignedDto<T>>;
-}
-/**
- * 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.
- */
-export declare class BrowserWalletSigner implements GalaChainSigner {
-  private readonly 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: BrowserWalletProvider, walletAddress: string, options?: {
-    scheme?: 'personal-sign' | 'eip712';
-  });
-  /** The selected `0x` Ethereum account every signature is requested for. */
-  readonly walletAddress: string;
-  private readonly 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<T extends Record<string, unknown>>(methodName: string, dto: T): Promise<SignedDto<T>>;
-}
-//#endregion
 //#region src/classes/dex_fees.d.ts
 /** DEX methods the backend accepts a fee quote for (its allow-list enumerates the same six). */
 export declare const DEX_FEE_METHODS: readonly ['Swap', 'RequestTrade', 'AddLiquidity', 'RemoveLiquidity', 'CollectPositionFees', 'CreatePool'];
@@ -2269,6 +1482,12 @@ export declare class SubmittedTransaction<TConfirmation = AppliedTrade | Positio
    * 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 });
@@ -2666,31 +1885,111 @@ export declare class GdexStreamService {
   private isRecord;
 }
 //#endregion
-//#region src/types/fees.d.ts
+//#region src/types/market.d.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). */
+export declare const PRICE_SERIES_TIMEFRAMES: readonly ['1D', '1W', '1M', '1Y', 'ALL'];
+/** One member of {@link PRICE_SERIES_TIMEFRAMES}. */
+export type PriceSeriesTimeframe = (typeof PRICE_SERIES_TIMEFRAMES)[number];
+/** The most tokens one `GET /market/price` request may name (the backend's limit). */
+export declare const MARKET_PRICE_BATCH_LIMIT = 500;
+/** One token's market price, as `GET /market/price` answered it. */
+export interface MarketPrice {
+  /** The id the price was asked for: the token string as given, or an object key's `$` form. */
+  token: string;
+  /** USD price; `null` when the backend knows the token but has no price for it. */
+  price: number | null;
+  /** 24-hour change in percent (`-2.1` is -2.1 %); `null` when unknown. */
+  change24h: number | null;
+  /** Whether the token is on the backend's CoinGecko list (what the swap app's "trending" uses). */
+  listed: boolean;
+}
+/** One point of a price series. */
+export interface PriceSeriesPoint {
+  /** Unix time in seconds. */
+  time: number;
+  /** USD price at `time`. */
+  price: number;
+}
+/** A token's USD price line, as `GET /market/price-series` answered it. */
+export interface PriceSeries {
+  /** The id the series was asked for: the token string as given, or an object key's `$` form. */
+  token: string;
+  timeframe: PriceSeriesTimeframe;
+  /** In the backend's order (oldest first). Empty for a token the backend has no prices for. */
+  prices: PriceSeriesPoint[];
+  /** USD price now; `null` when unknown. */
+  currentPrice: number | null;
+  /** 24-hour change in percent; `null` when unknown. */
+  change24h: number | null;
+}
 /**
- * Fee tiers for pools.
- */
-export declare enum FEE_TIER {
-  /** No trading fee. */
-  PERCENT_00_00 = 0,
-  /** 0.05% fee tier */
-  PERCENT_00_05 = 500,
-  /** 0.3% fee tier */
-  PERCENT_00_30 = 3000,
-  /** 1.0% fee tier */
-  PERCENT_01_00 = 10000
+ * Totals across every current-contract pool, as `GET /v2/trade/volume` answered them. USD amounts;
+ * a delta is a fraction (`-0.11` is 11 % less than the previous period, `0` when that period had
+ * no volume), not a percentage.
+ */
+export interface VolumeSummary {
+  tvl: number;
+  volume1d: number;
+  volume7d: number;
+  volume30d: number;
+  /** Number of trades in the last 24 hours. */
+  trades1d: number;
+  volume1dDelta: number;
+  volume7dDelta: number;
+  volume30dDelta: number;
+}
+/** A trading-competition season, as `GET /leaderboard/seasons` answered it. */
+export interface LeaderboardSeason {
+  id: number;
+  name: string;
+  /** First instant of the season. */
+  start: Date;
+  /** Last instant of the season (inclusive). */
+  end: Date;
+  /** The scoring rules the season uses. */
+  rulesId: number;
+}
+/** An achievement shown on a leaderboard entry. */
+export interface MasteryTitle {
+  name: string;
+  /** For example `trade` or `liquidity`; the backend's own word, passed on as it is. */
+  type: string;
+  /** Display order. */
+  order: number;
+}
+/** One wallet's row on a season's leaderboard. */
+export interface LeaderboardEntry {
+  wallet: string;
+  /** 1 for the top wallet. */
+  rank: number;
+  /** Decimal string; `null` when the backend has no XP breakdown for the wallet yet. */
+  totalXp: string | null;
+  /** The wallet's share of the season's XP, in percent, as a decimal string (`'12.34'`). */
+  distributionPercent: string;
+  liquidityXp: string;
+  tradingXp: string;
+  masteryTitles: MasteryTitle[];
+}
+/** A season's leaderboard (the backend returns at most its top 100 wallets). */
+export interface SeasonLeaderboard {
+  seasonId: number;
+  entries: LeaderboardEntry[];
 }
-/** Tick spacing required by the current GalaChainDex contract for each fee tier. */
-export declare const TICK_SPACING_BY_FEE: Readonly<Record<FEE_TIER, number>>;
-/** All fee tiers supported by the current GalaChainDex contract. */
-export declare const ALL_FEE_TIERS: readonly FEE_TIER[];
 //#endregion
 //#region src/utils/lenient.d.ts
 /** One row of a list answer that the SDK skipped because it was not usable. */
 interface InvalidEntry {
   /** Which read the row came from. */
-  source: 'pools' | 'symbols' | 'positions';
-  /** Position of the row in the answer's array. */
+  source: 'pools' | 'symbols' | 'positions' | 'prices' | 'priceSeries' | 'seasons' | 'leaderboard';
+  /**
+   * Position of the row in the answer's array; for `prices` (an answer keyed by token), the
+   * position of the token in the list asked for.
+   */
   index: number;
   /** The row exactly as the backend sent it. */
   entry: unknown;
@@ -2711,6 +2010,86 @@ type EntryParse<T> = {
   reason: string;
 };
 //#endregion
+//#region src/classes/leaderboard.d.ts
+/** Options of every leaderboard read. */
+export interface LeaderboardReadOptions {
+  signal?: AbortSignal | undefined;
+  /** Overrides the service-level handler for this call. */
+  onInvalidEntry?: InvalidEntryHandler | undefined;
+}
+/** Options of the reads that pick the season running now. */
+export interface CurrentSeasonOptions extends LeaderboardReadOptions {
+  /** The instant "now" is (default: the current time). */
+  now?: Date | undefined;
+}
+/**
+ * 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`.
+ */
+export declare class Leaderboard {
+  private readonly dexBackendBaseUrl;
+  private readonly httpClient;
+  private readonly 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: string, httpClient: HttpClient, options?: {
+    onInvalidEntry?: InvalidEntryHandler | undefined;
+  });
+  /**
+   * 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));
+   * ```
+   */
+  getSeasons(options?: LeaderboardReadOptions): Promise<LeaderboardSeason[]>;
+  /**
+   * 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);
+   * ```
+   */
+  getCurrentSeason(options?: CurrentSeasonOptions): Promise<LeaderboardSeason | 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);
+   * ```
+   */
+  getLeaderboard(seasonId: number, options?: LeaderboardReadOptions): Promise<SeasonLeaderboard>;
+  /**
+   * 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);
+   * ```
+   */
+  getCurrentLeaderboard(options?: CurrentSeasonOptions): Promise<SeasonLeaderboard | null>;
+}
+//#endregion
 //#region src/utils/ordering.d.ts
 /** A symbol or a GalaChain token class key accepted by v2 operations. */
 export type TokenRef = string | GalaChainTokenClassKey;
@@ -2724,25 +2103,144 @@ export declare function orderSymbols(a: string, b: string): [string, string];
  * console.log(pair.token0);
  * ```
  */
-export declare function readOrderedSymbols(value: unknown): {
-  token0: string;
-  token1: string;
-};
+export declare function readOrderedSymbols(value: unknown): {
+  token0: string;
+  token1: string;
+};
+/**
+ * Parse a pipe- or dollar-separated token class key.
+ *
+ * The LAST three segments are always `category`, `type` and `additionalKey`; everything before
+ * them is the `collection`. Parsing from the right is required because real collections contain
+ * the `$` delimiter themselves (for example `$GMUSIC`), so a plain left-to-right `split('$')`
+ * shifts every field. Nothing here says anything about the token's symbol: a class key carries
+ * no symbol, which must come from the token class or trading-symbol registry.
+ *
+ * @example
+ * ```ts
+ * parseTokenClassKey('$GMUSIC$Unit$none$none').collection; // '$GMUSIC'
+ * ```
+ */
+export declare function parseTokenClassKey(tokenClassKey: TokenRef): GalaChainTokenClassKey;
+//#endregion
+//#region src/classes/market.d.ts
+/** Options of every market read. */
+export interface MarketReadOptions {
+  signal?: AbortSignal | undefined;
+}
+/** Options of {@link Market.getPrices} and {@link Market.getPriceSeries}. */
+export interface MarketListOptions extends MarketReadOptions {
+  /** Overrides the service-level handler for this call. */
+  onInvalidEntry?: InvalidEntryHandler | undefined;
+}
+/**
+ * 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.
+ *
+ * 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.
+ */
+export declare class Market {
+  private readonly dexBackendBaseUrl;
+  private readonly httpClient;
+  private readonly 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: string, httpClient: HttpClient, options?: {
+    onInvalidEntry?: InvalidEntryHandler | undefined;
+  });
+  /**
+   * 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);
+   * ```
+   */
+  getPrices(tokens: readonly TokenRef[], options?: MarketListOptions): Promise<Array<MarketPrice | undefined>>;
+  /**
+   * 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}`);
+   * ```
+   */
+  getPrice(token: TokenRef, options?: MarketListOptions): Promise<MarketPrice | undefined>;
+  /**
+   * 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);
+   * ```
+   */
+  getPriceSeries(token: TokenRef, timeframe: PriceSeriesTimeframe, options?: MarketListOptions): Promise<PriceSeries>;
+  /**
+   * 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)} %)`);
+   * ```
+   */
+  getVolumeSummary(options?: MarketReadOptions): Promise<VolumeSummary>;
+}
+/**
+ * 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).
+ */
+export declare const MARKET_PRICE_QUERY_BYTES = 8000;
 /**
- * Parse a pipe- or dollar-separated token class key.
- *
- * The LAST three segments are always `category`, `type` and `additionalKey`; everything before
- * them is the `collection`. Parsing from the right is required because real collections contain
- * the `$` delimiter themselves (for example `$GMUSIC`), so a plain left-to-right `split('$')`
- * shifts every field. Nothing here says anything about the token's symbol: a class key carries
- * no symbol, which must come from the token class or trading-symbol registry.
- *
- * @example
- * ```ts
- * parseTokenClassKey('$GMUSIC$Unit$none$none').collection; // '$GMUSIC'
- * ```
+ * 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).
  */
-export declare function parseTokenClassKey(tokenClassKey: TokenRef): GalaChainTokenClassKey;
+export declare function priceBatches(ids: readonly string[]): string[][];
+//#endregion
+//#region src/types/fees.d.ts
+/**
+ * Fee tiers for pools.
+ */
+export declare enum FEE_TIER {
+  /** No trading fee. */
+  PERCENT_00_00 = 0,
+  /** 0.05% fee tier */
+  PERCENT_00_05 = 500,
+  /** 0.3% fee tier */
+  PERCENT_00_30 = 3000,
+  /** 1.0% fee tier */
+  PERCENT_01_00 = 10000
+}
+/** Tick spacing required by the current GalaChainDex contract for each fee tier. */
+export declare const TICK_SPACING_BY_FEE: Readonly<Record<FEE_TIER, number>>;
+/** All fee tiers supported by the current GalaChainDex contract. */
+export declare const ALL_FEE_TIERS: readonly FEE_TIER[];
 //#endregion
 //#region src/classes/symbols.d.ts
 /** Symbol registry client for the current GalaChainDex contract. */
@@ -2819,8 +2317,6 @@ export declare class Symbols {
     flipped: boolean;
   }>;
 }
-/** Alias exported for callers that use the contract's shorter type name. */
-export type TokenClassKey = GalaChainTokenClassKey;
 /**
  * What the services need from a token resolver: how a token reference becomes a trading symbol,
  * and whether requests carry the caller's references untouched. {@link Symbols} is the registry
@@ -2893,6 +2389,17 @@ export interface PoolListOptions {
   /** Overrides the service-level handler for this call. */
   onInvalidEntry?: InvalidEntryHandler | undefined;
 }
+/** Options of {@link Pools.watchNewPools}. */
+export interface WatchNewPoolsOptions {
+  /** Milliseconds between polls (default 30 000; a finite number of at least 1). */
+  intervalMs?: number | undefined;
+  /** Report only a pool whose `tvlUsd` is at least this (a pool without `tvlUsd` counts as 0). */
+  minTvl?: number | undefined;
+  /** Report only a pool with one of these symbols as `token0` or `token1`. */
+  tokens?: readonly string[] | undefined;
+  /** Told about a poll that failed and about an `onPool` that threw; polling goes on either way. */
+  onError?: ((error: unknown) => void) | undefined;
+}
 /** Read-only pool and current-price access for the current GalaChainDex contract. */
 export declare class Pools {
   private readonly gateway;
@@ -2924,6 +2431,25 @@ export declare class Pools {
    * ```
    */
   getPools(options?: PoolListOptions): Promise<PoolListInfo[]>;
+  /**
+   * 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: (pool: PoolListInfo) => void, options?: WatchNewPoolsOptions): () => void;
   /**
    * Fetches one pool from the backend, preserving whether the request order was flipped.
    *
@@ -3104,42 +2630,6 @@ export interface FetchLiquidityPositionsDTO extends PageDTO {
   pool?: string | undefined;
 }
 //#endregion
-//#region src/utils/unique_key.d.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.
- */
-export declare const DEFAULT_UNIQUE_KEY_PREFIX = "galaswap-operation-";
-/** Options shared by the services that mint `uniqueKey`s for writes. */
-export interface UniqueKeyOptions {
-  /**
-   * Prefix of every minted `uniqueKey` (`<prefix><uuid>`). Defaults to
-   * `DEFAULT_UNIQUE_KEY_PREFIX` (`galaswap-operation-`).
-   */
-  uniqueKeyPrefix?: string | undefined;
-}
-/**
- * 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.
- */
-export declare function resolveUniqueKeyPrefix(prefix: string | undefined): string;
-/**
- * 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.
- */
-export declare function assertUniqueKey(uniqueKey: string): void;
-/** A fresh per-attempt key: `<prefix><random UUID>`. */
-export declare function createUniqueKey(prefix: string): string;
-//#endregion
 //#region src/classes/positions.d.ts
 type PositionGateway = Pick<ChainGateway, 'httpRequestor' | 'dexBackendBaseUrl'> & {
   submit: (method: string, signedBody: Record<string, unknown>, options?: ChainSubmitOptions) => Promise<SubmittedTransaction<Position | null>>;
@@ -3753,8 +3243,9 @@ export interface GSwapOptions {
    */
   symbolResolution?: 'registry' | 'canonical' | undefined;
   /**
-   * Told about every row of a pool, symbol or position list that was skipped as unusable (see
-   * {@link InvalidEntryHandler}); without it such rows are skipped silently.
+   * Told about every row of a pool, symbol, position, price, price-series, season or leaderboard
+   * answer that was skipped as unusable (see {@link InvalidEntryHandler}); without it such rows are
+   * skipped silently.
    */
   onInvalidEntry?: InvalidEntryHandler | undefined;
   /** Realtime stream endpoint. Defaults to the environment's, or is derived from `dexBackendBaseUrl`. */
@@ -3775,7 +3266,8 @@ export interface GSwapOptions {
 /**
  * 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.
  */
 export declare class GSwap {
   /** The swap backend base URL every request goes to, without a trailing slash. */
@@ -3800,6 +3292,10 @@ export declare class GSwap {
   readonly swaps: Swaps;
   /** User token balances. */
   readonly assets: Assets;
+  /** USD prices, price series and the platform volume totals. */
+  readonly market: Market;
+  /** Trading-competition seasons and rankings. */
+  readonly leaderboard: Leaderboard;
   /** Network-fee quotes (DryRun) signed with this client's signer. */
   readonly fees: DexFees;
   /** The realtime stream endpoint {@link GSwap.stream} connects to. */
@@ -3831,133 +3327,19 @@ export declare class GSwap {
   get stream(): GdexStreamService;
 }
 //#endregion
-//#region src/utils/failure_outcomes.d.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.
- *
- * This module has no imports: the failure view (`FailureView.outcome`) and the classifier both
- * read the closed set from here.
- */
-export declare const FAILURE_OUTCOMES: readonly ['rejected', 'unknown', 'not_queued', 'not_sent', 'invalid_input', 'transient'];
-/** One member of {@link FAILURE_OUTCOMES}. */
-type FailureOutcome = (typeof FAILURE_OUTCOMES)[number];
-//#endregion
-//#region src/utils/failure_view.d.ts
-/**
- * A failure as a PLAIN OBJECT: the facts the SDK's guards and `classifyFailure` read, and nothing
- * else. A real `GSwapSDKError` is one (every field below is on it); so is the wrapper an app makes
- * from an SDK error to carry through its own layers (frontend_v2's `V2Failure`, the wallet's
- * `WalletSwapError` data), which has a `code` and `params` but is not an `instanceof` anything the
- * SDK owns. `classifyFailure`, `isRelayableRefusal`, `isUnprovenAcknowledgement`,
- * `isUninterpretedAnswer`, `isPreSendError`, `isShadowError`, `isNoMarket` and `mayHaveBeenQueued`
- * all accept such an object wherever they accept an SDK error, and decide from the SAME fields in
- * the same way, so an app never has to keep the original error just to ask.
- *
- * Only `code` is required. A field that is missing, or has the wrong type, reads as absent: a view
- * with no `status` is not a 404. Nothing here is text: the SDK never reads `message` of a view.
- *
- * READ OR WRITE: a view is a WRITE's unless it says it is a read. This fails CLOSED on purpose:
- * a 5xx on a write may have been queued (`unknown`, no retry) and the same 5xx on a read changed
- * nothing (`transient`, retry), so a wrapper that drops its `uniqueKey` must never turn the first
- * into the second. A view is a read ONLY when it states `write: false` and has no `uniqueKey`;
- * `GSwapSDKError.write` is already set that way for every SDK read. {@link isWriteView}
- * is the one definition.
- *
- * APP ERRORS: a code the SDK catalog does not define is `unknown` (the SDK cannot say what
- * happened, and a wrong "failed" invites a duplicate), unless the view declares `outcome`.
- */
-interface FailureView {
-  /** The catalog code (`'HTTP_ERROR'`, `'CHAIN_REJECTED'`, ...). A string the SDK does not know classifies as `unknown`. */
-  readonly code: string;
-  /** The error's flat params (`status` of an `HTTP_ERROR`, `reason` of a `SIGNING_FAILED`, ...). */
-  readonly params?: Readonly<Record<string, unknown>> | undefined;
-  /** The HTTP status of the answer the failure was made from. */
-  readonly status?: number | undefined;
-  /** How far the request got; when absent, the catalog's phase for `code`. */
-  readonly phase?: GSwapErrorPhase | undefined;
-  /** The `uniqueKey` of the WRITE this is about; its presence makes the failure a write's. */
-  readonly uniqueKey?: string | undefined;
-  /**
-   * `false` says the failed call was a READ (no `uniqueKey` to confirm, nothing pending). Anything
-   * else, including absent, is a write: see the note on {@link FailureView}. With a `uniqueKey`
-   * the failure is a write whatever this says.
-   */
-  readonly write?: boolean | undefined;
-  /**
-   * What an error the APP raised means, for a `code` the SDK catalog does not define (`'POSITION_STALE'`,
-   * `'AMOUNT_SIDE'`): `not_sent` for a step that failed before anything was signed or sent, and so
-   * on. The SDK honours it ONLY for such a code: for a catalog code the SDK's own table decides, so
-   * an app cannot declare a refusal the SDK knows to be unknown as safe. A non-catalog code with no
-   * `outcome` stays `unknown`, and `mayHaveBeenQueued` is then `true`.
-   */
-  readonly outcome?: FailureOutcome | undefined;
-  /**
-   * WITHHOLD-ONLY: `false` takes Retry away from the declared `outcome` (an app's `DID_NOT_QUEUE`
-   * is `{ outcome: 'not_queued', retryable: false }`, the SDK's `NOT_QUEUED_FINAL`). Any other
-   * value, `true` included, reads as absent: a view can never GRANT Retry to an outcome that does
-   * not have it, and it is read only together with `outcome`, for a code the catalog does not
-   * define.
-   */
-  readonly retryable?: false | undefined;
-  /** True when the failure came from the shadow (dark) path. */
-  readonly shadow?: boolean | undefined;
-  /** True for "that market does not exist" (`GSwapSDKError.notFound`). */
-  readonly notFound?: boolean | undefined;
-}
-/**
- * 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);
- * ```
- */
-export declare function toFailureView(value: unknown): FailureView | undefined;
-/**
- * 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.
- */
-export declare function isWriteView(view: FailureView): boolean;
-//#endregion
-//#region src/classes/error_phase_table.d.ts
+//#region src/classes/gswap_error_phase_table.d.ts
 /**
- * The phase of every catalog code, WITHOUT the catalog. The failure guards (`classifyFailure`,
+ * 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
- * ~20 kB: reading the phase from here keeps an app shell that imports a guard from loading them.
+ * ~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.
+ * error), so the two cannot drift. The core codes' phases are core's `GALA_ERROR_PHASE_BY_CODE`.
  */
 export declare const GSWAP_ERROR_PHASE_BY_CODE: {
   readonly HTTP_ERROR: 'post_send';
   readonly UPDATE_REQUIRED: 'post_send';
-  readonly REQUEST_TIMEOUT: 'in_flight';
-  readonly TRANSPORT_ERROR: 'in_flight';
   readonly REQUEST_FAILED: 'in_flight';
-  readonly INVALID_TIMEOUT: 'pre_send';
   readonly METHOD_NOT_SUPPORTED: 'pre_send';
   readonly SUBMISSION_OUTCOME_UNKNOWN: 'in_flight';
   readonly GATEWAY_REPORTED_ERROR: 'post_send';
@@ -3999,54 +3381,8 @@ export declare const GSWAP_ERROR_PHASE_BY_CODE: {
   readonly STREAM_CONNECT_FAILED: 'in_flight';
   readonly STREAM_CLOSED_BEFORE_CONNECT: 'in_flight';
   readonly STREAM_CONNECTION_CLOSED: 'in_flight';
-  readonly GALA_WALLET_NOT_AVAILABLE: 'pre_send';
-  readonly WALLET_UNAVAILABLE: 'pre_send';
-  readonly MALFORMED_WALLET_REQUEST: 'pre_send';
-  readonly UNSUPPORTED_WALLET_METHOD: 'pre_send';
-  readonly INVALID_SIGNATURE: 'pre_send';
-  readonly INVALID_CHAIN_ID: 'pre_send';
-  readonly SIGNER_ADDRESS_MISMATCH: 'pre_send';
-  readonly INVALID_PRIVATE_KEY: 'pre_send';
-  readonly SIGNING_FAILED: 'pre_send';
-  readonly KEY_PROVIDER_FAILED: 'pre_send';
   readonly TOKEN_RESOLUTION_FAILED: 'pre_send';
-  readonly INVALID_SIGNING_HASH_LENGTH: 'pre_send';
   readonly MISSING_WALLET_ADDRESS: 'pre_send';
-  readonly INVALID_WALLET_ADDRESS: 'pre_send';
-  readonly INVALID_DECIMAL: 'pre_send';
-  readonly PERSONAL_SIGN_NOT_JSON: 'pre_send';
-  readonly PERSONAL_SIGN_NOT_OBJECT: 'pre_send';
-  readonly PERSONAL_SIGN_BAD_PREFIX: 'pre_send';
-  readonly PERSONAL_SIGN_ENVELOPE_FIELDS: 'pre_send';
-  readonly PERSONAL_SIGN_NOT_CANONICAL: 'pre_send';
-  readonly EIP712_NAME_COLLISION: 'pre_send';
-  readonly EIP712_UNSUPPORTED_VALUE: 'pre_send';
-  readonly TYPED_DATA_NOT_STRING: 'pre_send';
-  readonly TYPED_DATA_UNPAIRED_SURROGATE: 'pre_send';
-  readonly TYPED_DATA_NOT_HEX_BYTES: 'pre_send';
-  readonly TYPED_DATA_NOT_SAFE_INTEGER: 'pre_send';
-  readonly TYPED_DATA_NOT_INTEGER: 'pre_send';
-  readonly TYPED_DATA_NOT_BOOLEAN: 'pre_send';
-  readonly TYPED_DATA_BAD_ADDRESS: 'pre_send';
-  readonly TYPED_DATA_BAD_CHECKSUM: 'pre_send';
-  readonly TYPED_DATA_BYTES_LENGTH: 'pre_send';
-  readonly TYPED_DATA_OUT_OF_BOUNDS: 'pre_send';
-  readonly TYPED_DATA_UNSUPPORTED_TYPE: 'pre_send';
-  readonly TYPED_DATA_FIELDS_NOT_LIST: 'pre_send';
-  readonly TYPED_DATA_FIELD_MALFORMED: 'pre_send';
-  readonly TYPED_DATA_INVALID_FIELD_NAME: 'pre_send';
-  readonly TYPED_DATA_DUPLICATE_FIELD: 'pre_send';
-  readonly TYPED_DATA_INVALID_TYPE_NAME: 'pre_send';
-  readonly TYPED_DATA_CIRCULAR_TYPE: 'pre_send';
-  readonly TYPED_DATA_UNKNOWN_FIELD_TYPE: 'pre_send';
-  readonly TYPED_DATA_NO_PRIMARY_TYPE: 'pre_send';
-  readonly TYPED_DATA_AMBIGUOUS_PRIMARY_TYPE: 'pre_send';
-  readonly TYPED_DATA_ARRAY_EXPECTED: 'pre_send';
-  readonly TYPED_DATA_ARRAY_LENGTH_MISMATCH: 'pre_send';
-  readonly TYPED_DATA_STRUCT_NOT_OBJECT: 'pre_send';
-  readonly TYPED_DATA_MISSING_FIELD: 'pre_send';
-  readonly TYPED_DATA_DOMAIN_NOT_OBJECT: 'pre_send';
-  readonly TYPED_DATA_INVALID_DOMAIN_KEY: 'pre_send';
   readonly NON_CANONICAL_PAIR: 'pre_send';
   readonly UNORDERABLE_SYMBOLS: 'pre_send';
   readonly INVALID_TOKEN_CLASS_KEY: 'pre_send';
@@ -4056,8 +3392,6 @@ export declare const GSWAP_ERROR_PHASE_BY_CODE: {
   readonly TOKEN_SYMBOL_NOT_REGISTERED: 'pre_send';
   readonly SYMBOL_DISAGREES_WITH_REGISTRY: 'pre_send';
   readonly CREATE_POOL_NEEDS_CLASS_KEY: 'pre_send';
-  readonly INVALID_UNIQUE_KEY: 'pre_send';
-  readonly INVALID_UNIQUE_KEY_PREFIX: 'pre_send';
   readonly AMOUNT_IS_JS_NUMBER: 'pre_send';
   readonly AMOUNT_NOT_FINITE: 'pre_send';
   readonly AMOUNT_NOT_POSITIVE: 'pre_send';
@@ -4087,6 +3421,10 @@ export declare const GSWAP_ERROR_PHASE_BY_CODE: {
   readonly INVALID_SORT_ORDER: 'pre_send';
   readonly INVALID_PAGE: 'pre_send';
   readonly INVALID_LIMIT: 'pre_send';
+  readonly INVALID_MARKET_TOKEN: 'pre_send';
+  readonly INVALID_TIMEFRAME: 'pre_send';
+  readonly INVALID_SEASON_ID: 'pre_send';
+  readonly INVALID_POLL_INTERVAL: 'pre_send';
 };
 //#endregion
 //#region src/classes/pending_swap_fate.d.ts
@@ -4364,255 +3702,6 @@ export declare class PendingSwapStore {
   private fromStored;
 }
 //#endregion
-//#region src/utils/signing.d.ts
-/**
- * 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).
- */
-export declare function serialize(value: unknown): string;
-/**
- * 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.
- */
-export declare function getPayloadToSign(dto: Record<string, unknown>): string;
-/**
- * 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.
- */
-export declare function calculatePersonalSignPrefix(message: string): string;
-/**
- * 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.
- */
-export declare function personalSignPrefixFor(dto: Record<string, unknown>): string;
-/**
- * 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.
- */
-export declare function fixpointPrefixFor(dto: Record<string, unknown>): string;
-/**
- * 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).
- */
-export declare function normalizePrivateKey(input: string | Uint8Array): Uint8Array;
-/**
- * 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.
- */
-export declare function ethAddressOfPrivateKey(privateKey: Uint8Array): string;
-/**
- * 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.
- */
-export declare function signSerializedNative(privateKey: Uint8Array, serializedDto: string): string;
-/**
- * GalaChain NATIVE signature for a DTO: keccak256 of `getPayloadToSign(dto)`, signed with
- * secp256k1. Byte-identical to `signatures.getSignature` from `@gala-chain/api`.
- */
-export declare function signNative(privateKey: Uint8Array, dto: Record<string, unknown>): string;
-/**
- * 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.
- */
-export declare function signPersonalMessage(privateKey: Uint8Array, prefix: string, message: string): string;
-//#endregion
-//#region src/utils/chain_dto_signing.d.ts
-/** A secp256k1 private key as a hex/base64 string or as raw 32 bytes. */
-type PrivateKeyInput = string | Uint8Array;
-/**
- * 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.
- */
-export declare function withPrivateKey<T>(privateKey: PrivateKeyInput, action: (key: Uint8Array) => T): T;
-/**
- * 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`.
- */
-export declare function signChainDtoNative(privateKey: PrivateKeyInput, serializedDto: string): string;
-/**
- * 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.
- */
-export declare function signChainDtoHash(privateKey: PrivateKeyInput, prefix: string, message: string): string;
-/** What a `gala_signChainDto` personal-sign request hashes. */
-interface PersonalSignChainDtoPayload {
-  /** The `prefix` the chain prepends: the DTO's own `prefix` field, or `''` when it has none. */
-  prefix: string;
-  /** The exact message hashed after `prefix`. */
-  message: string;
-}
-/**
- * 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.
- */
-export declare function resolvePersonalSignChainDtoPayload(data: string): PersonalSignChainDtoPayload;
-/**
- * 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.
- */
-export declare function signChainDtoPersonalSign(privateKey: PrivateKeyInput, data: string): string;
-/**
- * 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.
- */
-export declare function signRawObject(privateKey: PrivateKeyInput, obj: Record<string, unknown>): {
-  signature: string;
-} & Record<string, unknown>;
-/**
- * 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.
- */
-export declare function stripEip712DomainType<T>(types: Record<string, T>): Record<string, T>;
-/**
- * `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.
- */
-export declare function tokenClassDollarKey(token: Record<string, unknown> | null | undefined): string;
-/**
- * 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.
- */
-export declare function canonicalDecimalString(value: string | number): string;
-//#endregion
-//#region src/utils/eip712.d.ts
-/** EIP-712 `types`: each struct name mapped to its ordered `{ name, type }` fields. */
-type EIP712Types = Record<string, Array<{
-  name: string;
-  type: string;
-}>>;
-/**
- * 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".
- */
-export declare function generateEIP712Types(typeName: string, params: Record<string, unknown>): EIP712Types;
-/** The EIP-712 domain carried by a signed payload: GalaChain only uses `name` and `chainId`. */
-interface EIP712DomainValue {
-  name: string;
-  chainId: number;
-}
-/**
- * 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.
- */
-export declare function eip712DomainFor(chainId: unknown): EIP712DomainValue;
-/**
- * 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.
- */
-export declare const EIP712_CAPABLE_METHODS: ReadonlySet<string>;
-/**
- * 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.
- */
-export declare function buildEIP712Payload(methodName: string, dto: Record<string, unknown>): {
-  completedDto: Record<string, unknown>;
-  types: EIP712Types;
-};
-//#endregion
-//#region src/utils/typed_data.d.ts
-/** A typed-data payload as `eth_signTypedData_v4` carries it, minus `primaryType` (it is inferred). */
-interface TypedDataPayload {
-  domain: Record<string, unknown>;
-  /** Struct definitions WITHOUT `EIP712Domain` (see `stripEip712DomainType`). */
-  types: Record<string, readonly unknown[]>;
-  message: Record<string, unknown>;
-}
-/**
- * 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).
- */
-export declare function hashTypedData(payload: TypedDataPayload): Uint8Array;
-/**
- * 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.
- */
-export declare function signTypedDataPayload(privateKey: PrivateKeyInput, payload: TypedDataPayload): Promise<string>;
-//#endregion
 //#region src/utils/dto_builders.d.ts
 /** The pool a RequestTrade trades in, its fee tier, the `uniqueKey` and what is traded. */
 type RequestTradeInput = {
@@ -4716,122 +3805,6 @@ type V2WriteMethod = 'RequestTrade' | 'AddLiquidity' | 'RemoveLiquidity' | 'Coll
  */
 export declare function assertCanonicalV2Dto(method: V2WriteMethod, dto: Record<string, unknown>): void;
 //#endregion
-//#region src/utils/axios_requestor.d.ts
-/** What the adapter reads of an axios response. */
-export interface AxiosLikeResponse {
-  status: number;
-  data?: unknown;
-  /** axios' `AxiosHeaders` (has `get`) or a plain header record. */
-  headers?: unknown;
-}
-/** The request config the adapter hands to axios. */
-export interface AxiosLikeConfig {
-  headers: Record<string, string>;
-  signal?: AbortSignal;
-  validateStatus?: () => boolean;
-}
-/**
- * The part of an axios instance the adapter calls. Declared structurally, so the SDK takes no
- * dependency on axios and any axios instance (with its interceptors) satisfies it.
- */
-export interface AxiosLikeInstance {
-  get(url: string, config?: AxiosLikeConfig): Promise<unknown>;
-  post(url: string, data?: unknown, config?: AxiosLikeConfig): Promise<unknown>;
-}
-/** Options of {@link httpRequestorFromAxios}. */
-export interface AxiosRequestorOptions {
-  /**
-   * `true`: leave axios' default status validation alone, so a 4xx/5xx REJECTS through the
-   * instance's own interceptors and the SDK rethrows what the app's error handling produced.
-   * `false`: every HTTP status resolves, so the SDK classifies it itself (shadow submits,
-   * apply-results reads); transport failures still reject.
-   */
-  rejectOnHttpError: boolean;
-  /**
-   * Request headers NOT to hand to axios, matched case-insensitively. Default `['content-type']`:
-   * axios derives `Content-Type: application/json` from the object body it is given, and an
-   * interceptor may set its own, so the SDK's copy would only be a second opinion.
-   */
-  omitHeaders?: readonly string[] | undefined;
-}
-/**
- * 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 }),
- * });
- * ```
- */
-export declare function httpRequestorFromAxios(instance: AxiosLikeInstance, options: AxiosRequestorOptions): HttpRequestor;
-//#endregion
-//#region src/utils/ethers_provider.d.ts
-/**
- * The part of an ethers v6 signer (`JsonRpcSigner`, `Wallet`) the adapter calls. Declared
- * structurally, so the SDK takes no dependency on ethers and an ethers object satisfies it as is.
- */
-export interface EthersLikeSigner {
-  signTypedData(domain: Record<string, unknown>, types: Record<string, Array<{
-    name: string;
-    type: string;
-  }>>, value: Record<string, unknown>): Promise<string>;
-  signMessage(message: string): Promise<string>;
-}
-/** The part of an ethers v6 provider (`BrowserProvider`) the adapter calls. */
-export interface EthersLikeProvider {
-  getSigner(): Promise<EthersLikeSigner>;
-  /** The raw JSON-RPC passthrough (`BrowserProvider.send`). */
-  send(method: string, params: unknown[]): Promise<unknown>;
-}
-/** Options of {@link eip1193ProviderFromEthers}. */
-export interface EthersEip1193Options {
-  /**
-   * Signs a `personal_sign` message when the provider cannot or should not: a wallet SDK that
-   * signs through its own object (TrustWallet's `web3Wallet.signMessage`). When set it answers
-   * every `personal_sign`, and the provider is not touched for it.
-   */
-  personalSign?: ((message: string) => Promise<string>) | undefined;
-}
-/**
- * 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',
- * });
- * ```
- */
-export declare function eip1193ProviderFromEthers(provider: EthersLikeProvider | null | undefined, options?: EthersEip1193Options): BrowserWalletProvider;
-//#endregion
 //#region src/utils/confirmation_state.d.ts
 /**
  * Where a failed CONFIRMATION of a queued write stopped, as a closed set a screen can switch on:
@@ -4867,33 +3840,6 @@ export declare function isConfirmationAborted(error: unknown): boolean;
 /** True when the wait for the apply result ran out of time (`CONFIRMATION_TIMEOUT`). */
 export declare function isConfirmationTimeout(error: unknown): boolean;
 //#endregion
-//#region src/utils/fetch_failure.d.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 });
- * ```
- */
-export declare function isFetchTransportFailure(error: unknown): boolean;
-//#endregion
 //#region src/utils/classification.d.ts
 /**
  * The classification values an app shell may need on their own: what an outcome allows. This module
@@ -4953,7 +3899,7 @@ export declare function notSentClassification(): FailureClassification;
 //#endregion
 //#region src/utils/failure_classification.d.ts
 /**
- * Classifies any thrown value from its code (and, for two codes, its HTTP status), never from
+ * 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.
@@ -5151,52 +4097,6 @@ export declare function chainErrorKeyOf(error: unknown): string | undefined;
  */
 export declare function isNoMarket(error: unknown): boolean;
 //#endregion
-//#region src/utils/class_key.d.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`.
- */
-/** Return the `$`-joined composite key used by GalaChain object identities. */
-export declare function compositeKeyOf(token: GalaChainTokenClassKey): string;
-/**
- * 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.
- *
- * @example
- * ```ts
- * const key = tryParseTokenClassKey(row.compositeKey);
- * if (key === undefined) return failClosed(); // no class is known: never invent one from a symbol
- * ```
- */
-export declare function tryParseTokenClassKey(value: unknown): GalaChainTokenClassKey | undefined;
-/**
- * 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
- * ```
- */
-export declare function tryParseCompositeKey(value: unknown): GalaChainTokenClassKey | undefined;
-//#endregion
 //#region src/utils/shadow_errors.d.ts
 /**
  * True when `value` is a failure of the shadow (dark) path: an SDK error with `shadow: true`, a
@@ -5374,19 +4274,6 @@ export declare function frameSlot0(slot0: {
   flippedFromRequest?: boolean | undefined;
 }): FramedSlot0;
 //#endregion
-//#region src/utils/unique_key_syntax.d.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.
- */
-/**
- * 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.
- */
-export declare function isValidUniqueKey(uniqueKey: unknown): uniqueKey is string;
-//#endregion
 //#region src/utils/validation.d.ts
 /**
  * Validates a decimal amount: a string or `BigNumber`, never a JavaScript number.
@@ -5453,57 +4340,5 @@ export declare function isProposableTradingSymbol(symbol: string): boolean;
  */
 export declare function assertCanonicalPair(token0: string, token1: string): void;
 //#endregion
-//#region src/utils/wallet_rejection.d.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.
- */
-/**
- * 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);
- * }
- * ```
- */
-export declare function isWalletUserRejection(value: unknown): boolean;
-/**
- * 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
- * ```
- */
-export declare function walletDeclineCode(value: unknown): number | string | undefined;
-//#endregion
-export type { AddLiquidityInput, ConfirmationState, CreatePoolInput, EIP712DomainValue, EIP712Types, EntryParse, FailureOutcome, FailureView, GSwapErrorCode, GSwapErrorParams, GSwapErrorPhase, GSwapErrorShape, InvalidEntry, InvalidEntryHandler, InvalidPrivateKeyReason, PersonalSignChainDtoPayload, PoolPositionInput, PrivateKeyInput, RemoveLiquidityInput, RequestTradeInput, SigningFailureReason, SubmissionOutcomeUnknownReason, TickFromPriceOptions, TickInput, TypedDataPayload, V2WriteMethod };
+export type { AddLiquidityInput, ConfirmationState, CreatePoolInput, EntryParse, GSwapErrorCode, GSwapErrorParams, InvalidEntry, InvalidEntryHandler, PoolPositionInput, RemoveLiquidityInput, RequestTradeInput, SubmissionOutcomeUnknownReason, TickFromPriceOptions, TickInput, V2WriteMethod };
 //# sourceMappingURL=index.d.cts.map