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

package/dist/index.d.ts

@@ -1,140 +1,213 @@
 import BigNumber from 'bignumber.js';
-import { EventEmitter } from 'events';
 
-type Branding<BrandT> = {
-    _type: BrandT;
-};
-type Brand<T, BrandT> = T & Branding<BrandT>;
-
-type NumericAmount = string | number | BigNumber;
-type SqrtPrice = Brand<BigNumber, 'SqrtPrice'>;
-type SqrtPriceIn = Brand<NumericAmount, 'SqrtPriceIn'> | SqrtPrice;
-type Price = Brand<BigNumber, 'Price'>;
-type PriceIn = Brand<NumericAmount, 'PriceIn'> | Price;
-
-interface GalaChainTokenClassKey {
-    collection: string;
-    category: string;
-    type: string;
-    additionalKey: string;
+/** Pool metadata returned by GalaChainDex. */
+interface PoolInfo {
+    token0: string;
+    token1: string;
+    fee: number;
+    name?: string;
+    token0Key: string;
+    token1Key: string;
+    tickSpacing: number;
+    protocolFees: number;
+    tradingFees: number;
+    creator?: string;
+    isPrivate?: boolean;
+    flippedFromRequest?: boolean;
 }
-
-/**
- * Result from getting a price quote for a token swap.
- * Contains pricing information and impact analysis for the proposed trade.
- */
-interface GetQuoteResult {
-    /** Raw amount of token0 that would be involved in the swap (ordered by token address) */
-    amount0: BigNumber;
-    /** Raw amount of token1 that would be involved in the swap (ordered by token address) */
-    amount1: BigNumber;
-    /** Current square root price of the pool before the trade */
-    currentPoolSqrtPrice: SqrtPrice;
-    /** New square root price of the pool after the trade would execute */
-    newPoolSqrtPrice: SqrtPrice;
-    /** Amount of the input token (the token being sold) */
-    inTokenAmount: BigNumber;
-    /** Amount of the output token (the token being bought) */
-    outTokenAmount: BigNumber;
-    /** Current price of the pool (how many output tokens per input token) */
-    currentPrice: Price;
-    /** New price of the pool after the trade (how many output tokens per input token) */
-    newPrice: Price;
-    /** Price impact of the trade as a percentage (e.g., 0.05 for 0.05% impact) */
-    priceImpact: BigNumber;
-    /** Fee tier of the pool used for this quote (e.g., 500 for 0.05%, 3000 for 0.3%) */
-    feeTier: number;
+/** Pool summary returned by the backend pool-list route. */
+interface PoolListInfo {
+    contractVersion: 'v2';
+    token0: string;
+    token1: string;
+    token0CompositeKey?: string | undefined;
+    token1CompositeKey?: string | undefined;
+    fee: number;
+    poolName: string;
+    poolRef: string;
+    tickSpacing: number;
+    protocolFees: number;
+    tradingFees: number;
+    creator?: string | undefined;
+    price?: string | undefined;
+    sqrtPrice?: string | undefined;
+    tick?: number | undefined;
+    token0Tvl?: string | undefined;
+    token1Tvl?: string | undefined;
+    tvlUsd?: number | undefined;
+    volume1d?: number | undefined;
+    volume7d?: number | undefined;
+    volume30d?: number | undefined;
+    trades1d?: number | undefined;
+    fee24h?: number | undefined;
+    apr1d?: number | undefined;
+    token0Price?: number | undefined;
+    token1Price?: number | undefined;
 }
-/**
- * Result from getting all liquidity positions for a user.
- * Contains summary information about each position owned by the wallet.
- */
-interface GetUserPositionsResult {
-    /** Unique hash identifier for the liquidity pool */
-    poolHash: string;
-    /** Unique identifier for this specific liquidity position */
-    positionId: string;
-    /** Token class key for the first token in the pair */
-    token0ClassKey: GalaChainTokenClassKey;
-    /** Token class key for the second token in the pair */
-    token1ClassKey: GalaChainTokenClassKey;
-    /** URL or path to the image/icon for token0 */
-    token0Img: string;
-    /** URL or path to the image/icon for token1 */
-    token1Img: string;
-    /** Symbol/ticker for token0 (e.g., "GALA") */
+/** Current pool price state. */
+interface Slot0 {
+    token0: string;
+    token1: string;
+    fee: number;
+    price: string;
+    sqrtPrice: string;
+    tick: number;
+    flippedFromRequest?: boolean;
+}
+/** Full raw composite pool snapshot returned by the contract. */
+interface CompositePool {
+    pool: PoolInfo;
+    currentTradingPrice: Slot0;
+    initializedTicks?: Array<{
+        pool: string;
+        lexigraphicTickIndex: string;
+    }>;
+    reverseInitializedTicks?: Array<{
+        pool: string;
+        lexigraphicTickIndex: string;
+    }>;
+    positionBoundaries?: unknown[];
+    positions?: Array<{
+        pool: string;
+        lexigraphicTickIndexLow: string;
+        lexigraphicTickIndexHigh: string;
+        owner: string;
+        liquidity: string;
+    }>;
+    token0TradingSymbol?: {
+        symbol: string;
+        decimals: number;
+    };
+    token1TradingSymbol?: {
+        symbol: string;
+        decimals: number;
+    };
+    token0LiquidityBalance?: TokenBalance;
+    token1LiquidityBalance?: TokenBalance;
+    token0ProtocolFeesBalance?: TokenBalance;
+    token1ProtocolFeesBalance?: TokenBalance;
+}
+/** A token balance embedded in a composite pool result. */
+interface TokenBalance {
+    collection?: string;
+    category?: string;
+    type?: string;
+    additionalKey?: string;
+    quantity?: string;
+    owner?: string;
+}
+/** A normalized current-contract liquidity position. */
+interface Position {
+    pool: string;
     token0Symbol: string;
-    /** Symbol/ticker for token1 (e.g., "USDC") */
     token1Symbol: string;
-    /** Fee tier of the pool (e.g., 500 for 0.05%, 3000 for 0.3%) */
+    token0CompositeKey?: string;
+    token1CompositeKey?: string;
     fee: number;
-    /** Amount of liquidity provided in this position */
-    liquidity: BigNumber;
-    /** Lower tick boundary of the position's price range */
     tickLower: number;
-    /** Upper tick boundary of the position's price range */
     tickUpper: number;
-    /** Timestamp when the position was created */
-    createdAt: string;
+    owner: string;
+    liquidity: string;
+    amount0: string;
+    amount1: string;
+    inRange: boolean;
+    currentTick?: number;
+    sqrtPrice?: string;
+    fees0?: string;
+    fees1?: string;
 }
-/**
- * Result from getting detailed information about a specific liquidity position.
- * Contains comprehensive data about position state, fees, and token information.
- */
-interface GetPositionResult {
-    /** Fee tier of the pool (e.g., 500 for 0.05%, 3000 for 0.3%) */
+/** Quote response returned by `/v2/trade/quote`. */
+interface QuoteResult {
+    contractVersion: 'v2';
     fee: number;
-    /** Fee growth inside the position's tick range for token0 since position creation */
-    feeGrowthInside0Last: BigNumber;
-    /** Fee growth inside the position's tick range for token1 since position creation */
-    feeGrowthInside1Last: BigNumber;
-    /** Amount of liquidity provided in this position */
-    liquidity: BigNumber;
-    /** Unique hash identifier for the liquidity pool */
-    poolHash: string;
-    /** Unique identifier for this specific liquidity position */
-    positionId: string;
-    /** Lower tick boundary of the position's price range */
-    tickLower: number;
-    /** Upper tick boundary of the position's price range */
-    tickUpper: number;
-    /** Token class key for the first token in the pair (ordered by token address) */
-    token0ClassKey: GalaChainTokenClassKey;
-    /** Token class key for the second token in the pair (ordered by token address) */
-    token1ClassKey: GalaChainTokenClassKey;
-    /** Amount of token0 fees accumulated and owed to the position owner */
-    tokensOwed0: BigNumber;
-    /** Amount of token1 fees accumulated and owed to the position owner */
-    tokensOwed1: BigNumber;
+    amountIn: string;
+    amountOut: string;
+    currentSqrtPrice?: string;
+    newSqrtPrice?: string;
+    newTick: number;
+    tradingFees: string;
+    protocolFees: string;
+    totalFees: string;
+    feeTokenSymbol: string;
+    token0Symbol: string;
+    token1Symbol: string;
+    tokenInIsToken0: boolean;
+    feeTier: number;
+    currentPrice?: BigNumber;
+    newPrice?: BigNumber;
+    priceImpact?: BigNumber;
 }
-/**
- * Represents a single asset (token) in a user's wallet.
- * Contains token metadata and balance information.
- */
+/** The executed trade as reported by the ApplyRequests result (contract Trade response). */
+interface TradeExecution {
+    token0: string;
+    token1: string;
+    fee: number;
+    sell0Qty?: string;
+    sell1Qty?: string;
+    buy0Qty?: string;
+    buy1Qty?: string;
+    tradingFees?: string;
+    protocolFees?: string;
+    totalFees?: string;
+}
+/** Terminal outcome of a queued RequestTrade, read from apply-results. */
+interface AppliedTrade {
+    uniqueKey: string;
+    /** The ApplyRequests transaction that executed the trade (x-apply-transaction-id), when reported. */
+    transactionId: string | null;
+    /** Block of the ApplyRequests transaction (x-apply-block-number), when reported. */
+    blockNumber: number | null;
+    /** The RequestTrade transaction that queued it, when the gateway reported one. */
+    requestTransactionId: string | null;
+    result: TradeExecution;
+}
+/** A token balance returned by the backend user-assets route. */
 interface UserAsset {
-    /** URL to the token's icon/image */
     image: string;
-    /** Human-readable name of the token */
     name: string;
-    /** Number of decimal places this token uses */
     decimals: number;
-    /** Whether this token has been verified/approved */
     verify: boolean;
-    /** Trading symbol for the token */
     symbol: string;
-    /** User's balance of this token as a decimal string */
     quantity: string;
 }
-/**
- * Result from getting a user's asset balances.
- * Contains paginated list of tokens and their balances.
- */
-interface GetUserAssetsResult {
-    /** Array of tokens owned by the user */
+/** User token balances returned by the backend. */
+interface UserAssetsResult {
     tokens: UserAsset[];
-    /** Total number of different tokens the user owns */
     count: number;
 }
+/** Backend add-liquidity estimate. */
+interface AddLiquidityEstimate {
+    amount0: string;
+    amount1: string;
+    liquidity: string;
+    token0Symbol: string;
+    token1Symbol: string;
+    tickLower: number;
+    tickUpper: number;
+    amountIsCanonicalToken0: boolean;
+}
+/** Backend remove-liquidity estimate. */
+interface RemoveLiquidityEstimate {
+    amount0: string;
+    amount1: string;
+}
+/** A symbol registry entry returned by FetchTokenTradingSymbols. */
+interface TradingSymbol {
+    symbol: string;
+    collection: string;
+    category: string;
+    type: string;
+    additionalKey: string;
+    decimals: number;
+}
+/** Result envelope returned by the chain gateway for a submitted write; queued RequestTrade has no result. */
+interface ChainSubmissionResult {
+    transactionId?: string;
+    blockNumber?: number | null;
+    mode: 'sync' | 'queued';
+    result?: unknown;
+    uniqueKey?: string;
+}
 
 type FetchReturnValue = Awaited<ReturnType<typeof fetch>>;
 interface HTTPResponse {
@@ -142,15 +215,22 @@ interface HTTPResponse {
     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>;
 
 declare class HttpClient {
     private readonly httpRequestor;
-    constructor(httpRequestor?: HttpRequestor);
+    private readonly timeoutMs;
+    /** Create an HTTP client around fetch or an injected requestor. */
+    constructor(httpRequestor?: HttpRequestor, timeoutMs?: number);
     private sendRequest;
+    /** Send a JSON POST request and decode its response. */
     sendPostRequest<TReturnType>(baseUrl: string, basePath: string, endpoint: string, body: unknown): Promise<TReturnType>;
-    sendGetRequest<TReturnType>(baseUrl: string, basePath: string, endpoint: string, params?: Record<string, string>): Promise<TReturnType>;
+    /** Send a GET request with URL-encoded query parameters and decode its response. */
+    sendGetRequest<TReturnType>(baseUrl: string, basePath: string, endpoint: string, params?: Record<string, string>, options?: Pick<RequestInit, 'signal'>): Promise<TReturnType>;
 }
 
 /**
@@ -176,826 +256,980 @@ declare class Assets {
      * });
      * ```
      */
-    getUserAssets(ownerAddress: string, page?: number, limit?: number): Promise<GetUserAssetsResult>;
+    getUserAssets(ownerAddress: string, page?: number, limit?: number): Promise<UserAssetsResult>;
 }
 
-/**
- * @hideconstructor
- * Represents a pending blockchain transaction.
- *
- * Usage: Call `wait()` immediately after receiving the PendingTransaction
- * to ensure proper event handling:
- *```typescript
- * const pendingTx = await gSwap.swap(...);
- * const result = await pendingTx.wait(); // Call immediately - if you delay then the event may be missed
- *```
- */
-declare class PendingTransaction {
-    readonly transactionId: string;
-    readonly message: string;
-    readonly error: boolean;
-    private readonly waitDelegate;
-    constructor(transactionId: string, message: string, error: boolean, waitDelegate: () => Promise<{
-        txId: string;
-        transactionHash: string;
-        Data: Record<string, unknown>;
-    }>);
-    /**
-     * Waits for the transaction to be confirmed.
-     * This should be called immediately after receiving the PendingTransaction
-     * to ensure proper event handling. If you delay calling this method and the
-     * transaction confirms before you call this method, an error will be thrown.
+/** Result of one position-confirmation poll. */
+type PositionConfirmationResult = {
+    confirmed: true;
+    position: Position | null;
+} | {
+    confirmed: false;
+    position?: Position | null;
+};
+/** A submitted v2 transaction whose confirmation mode is explicit in the gateway response. */
+declare class SubmittedTransaction<TConfirmation = AppliedTrade | Position | null> {
+    readonly method: string;
+    readonly uniqueKey: string;
+    readonly transactionId: string | null;
+    readonly blockNumber: number | null;
+    readonly mode: 'sync' | 'queued';
+    /** The synchronous gateway result, or `undefined` when `mode === 'queued'`. */
+    readonly result: unknown;
+    private readonly backendBaseUrl;
+    private readonly requestor;
+    private readonly requestTimeoutMs;
+    private readonly positionConfirmation;
+    /** Construct a submitted transaction from a successful gateway response.
      *
-     * @returns A promise that resolves when the transaction is confirmed.
+     * @example
+     * ```ts
+     * const transaction = new SubmittedTransaction({
+     *   method: 'RequestTrade', mode: 'queued', uniqueKey: 'swap-1',
+     *   transactionId: 'request-tx', result: undefined,
+     *   dexBackendBaseUrl: 'https://dex.example', httpRequestor,
+     * });
+     * ```
      */
-    wait(): Promise<{
-        txId: string;
-        transactionHash: string;
-        Data: Record<string, unknown>;
-    }>;
+    constructor(options: {
+        method: string;
+        uniqueKey: string;
+        transactionId: string | null;
+        mode: 'sync' | 'queued';
+        result: unknown;
+        dexBackendBaseUrl: string;
+        httpRequestor: HttpRequestor;
+        blockNumber?: number | null | undefined;
+        requestTimeoutMs?: number | undefined;
+        positionConfirmation?: ((signal: AbortSignal) => Promise<PositionConfirmationResult>) | undefined;
+    });
+    /** Confirm a queued RequestTrade or prove the affected position for a liquidity write.
+     *
+     * For RequestTrade, calling this method is required to learn the outcome: the queued
+     * acknowledgement proves acceptance, not execution.
+     *
+     * @example
+     * ```ts
+     * const applied = await submitted.confirm({ initialDelayMs: 3_000 });
+     * ```
+     */
+    confirm(options?: ConfirmOptions): Promise<TConfirmation>;
+    private confirmApplied;
+    private readAppliedResult;
+    /** Confirm a liquidity write against the position's observable effect.
+     *
+     * @returns The position after the write, or `null` for a confirmed full close.
+     * @example
+     * ```ts
+     * const position = await submitted.confirm({ timeoutMs: 60_000 });
+     * ```
+     */
+    private confirmPosition;
 }
-
 /**
- * A transaction signing interface. See {@link PrivateKeySigner} and {@link GalaWalletSigner} for implementations.
+ * Controls timeout and polling behavior for confirmation.
+ *
+ * - `timeoutMs` (default 60 000): overall deadline, counted from the `confirm()` call and
+ *   including `initialDelayMs`. At least one read is always made.
+ * - `pollIntervalMs` (default 2 000, minimum 500): base interval, doubled with jitter up to 8 s.
+ * - `initialDelayMs`: wait before the first read. Defaults to 3 000 for a queued RequestTrade
+ *   (the AutoApplier needs a few seconds) and 0 for liquidity writes (already executed).
  */
-interface GalaChainSigner {
-    signObject: <TObjectType extends Record<string, unknown>>(methodName: string, object: TObjectType) => Promise<TObjectType & {
-        signature: string;
-    }>;
+interface ConfirmOptions {
+    timeoutMs?: number | undefined;
+    pollIntervalMs?: number | undefined;
+    initialDelayMs?: number | undefined;
 }
-/**
- * A signing implementation that uses a private key string to sign requests.
- */
-declare class PrivateKeySigner implements GalaChainSigner {
-    private readonly keyBuffer;
-    constructor(privateKey: string);
-    signObject<TObjectType extends Record<string, unknown>>(_methodName: string, obj: TObjectType): Promise<TObjectType & {
-        signature: string;
-    }>;
+
+/** Options for a chain-gateway client. */
+interface ChainGatewayOptions {
+    dexBackendBaseUrl: string;
+    httpRequestor?: HttpRequestor | undefined;
+    walletAddress?: string | undefined;
+    chainCallTimeoutMs?: number | undefined;
+}
+/** Optional attribution and operation-specific confirmation hooks for a write. */
+interface ChainSubmitOptions {
+    walletAddress?: string | undefined;
+    positionConfirmation?: ((signal: AbortSignal) => Promise<PositionConfirmationResult>) | undefined;
+}
+/** Thin client for backend-routed v2 writes: synchronous liquidity writes and queued RequestTrade. */
+declare class ChainGateway {
+    private readonly requestor;
+    private readonly walletAddress;
+    private readonly chainCallTimeoutMs;
+    readonly requestTimeoutMs: number;
+    readonly dexBackendBaseUrl: string;
+    /** Create a chain gateway client. */
+    constructor(options: ChainGatewayOptions);
+    /** Submit a signed v2 DTO through the chain gateway. */
+    submit(method: 'RequestTrade', signedBody: Record<string, unknown>, options?: ChainSubmitOptions): Promise<SubmittedTransaction<AppliedTrade>>;
+    submit(method: string, signedBody: Record<string, unknown>, options?: ChainSubmitOptions): Promise<SubmittedTransaction<Position | null>>;
+    /** Expose the requestor for sibling read services that share this gateway transport. */
+    get httpRequestor(): HttpRequestor;
 }
+
 /**
- * A signing implementation that uses Gala Wallet to sign requests.
+ * Fee tiers for pools.
  */
-declare class GalaWalletSigner implements GalaChainSigner {
-    readonly walletAddress: string;
-    constructor(walletAddress: string);
-    signObject<TObjectType extends Record<string, unknown>>(methodName: string, obj: TObjectType): Promise<TObjectType & {
-        signature: string;
-    }>;
-    private static generateEIP712Types;
+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. */
+declare const TICK_SPACING_BY_FEE: Readonly<Record<FEE_TIER, number>>;
+/** All fee tiers supported by the current GalaChainDex contract. */
+declare const ALL_FEE_TIERS: readonly FEE_TIER[];
 
-declare class Bundler {
-    private readonly bundlerBaseUrl;
-    private readonly bundlingAPIBasePath;
-    private readonly transactionWaitTimeoutMs;
-    private readonly signer;
-    private readonly httpClient;
-    constructor(bundlerBaseUrl: string, bundlingAPIBasePath: string, transactionWaitTimeoutMs: number, signer: GalaChainSigner | undefined, httpClient: HttpClient);
-    signObject<TInputType extends Record<string, unknown>>(methodName: string, toSign: TInputType): Promise<TInputType & {
-        signature: string;
-    }>;
-    sendBundlerRequest(method: string, body: Record<string, unknown>, stringsInstructions: string[]): Promise<PendingTransaction>;
-    hasSigner(): boolean;
+interface GalaChainTokenClassKey {
+    collection: string;
+    category: string;
+    type: string;
+    additionalKey: string;
 }
 
-type BundlerResponse = {
-    status: 'FAILED';
-    transactionHash: string;
-    data: {
-        ErrorCode: number;
-        ErrorKey: string;
-        ErrorPayload: Record<string, unknown>;
-        Message: string;
-        transactionId: string;
-    };
-} | {
-    status: 'PROCESSED';
-    transactionHash: string;
-    data: {
-        Data: Record<string, unknown>;
-        transactionId: string;
-    };
+/** A symbol or a GalaChain token class key accepted by v2 operations. */
+type TokenRef = string | GalaChainTokenClassKey;
+/** Return two trading symbols in the contract's plain-string order. */
+declare function orderSymbols(a: string, b: string): [string, string];
+/** Read an ordered symbol pair from a tuple or object returned by a boundary helper.
+ *
+ * @example
+ * ```ts
+ * const pair = readOrderedSymbols(['GALA', 'GUSDC']);
+ * console.log(pair.token0);
+ * ```
+ */
+declare function readOrderedSymbols(value: unknown): {
+    token0: string;
+    token1: string;
 };
-interface BundlerRequest {
-    data: string;
-    message: string;
-    error: boolean;
-}
-declare abstract class TradeEventEmitter extends EventEmitter {
-    abstract connect(): Promise<void>;
-    abstract disconnect(): void;
-    abstract isConnected(): boolean;
-}
-declare class EventSocketClient extends TradeEventEmitter {
-    private socket;
-    private readonly bundlerUrl;
-    constructor(bundlerUrl: string);
-    connect(): Promise<void>;
-    disconnect(): void;
-    isConnected(): boolean;
-}
+/** Return the `$`-joined composite key used by GalaChain object identities. */
+declare function compositeKeyOf(token: GalaChainTokenClassKey): string;
+/** Parse a pipe- or dollar-separated token class key. */
+declare function parseTokenClassKey(tokenClassKey: TokenRef): GalaChainTokenClassKey;
 
-/**
- * Service for handling real-time event streaming and socket connections.
- * Manages the global socket connection for transaction status updates.
- */
-declare class Events {
-    private globalSocketClient?;
-    private globalWaitHelper;
-    private connectionPromise?;
-    static readonly instance: Events;
-    static tradeEventEmitterConstructor: new (url: string) => TradeEventEmitter;
-    /**
-     * Establishes a global socket connection for real-time event streaming.
-     * This connection is shared across all service instances.
-     * @param bundlerBaseUrl - Optional bundler base URL. If not provided, uses default.
-     * @returns The connected EventSocketClient.
+/** Symbol registry client for the current GalaChainDex contract. */
+declare class Symbols {
+    private readonly gateway;
+    private cachedSymbols;
+    private cachedAt;
+    private refreshInFlight;
+    private readonly http;
+    /** Create a symbol service backed by the swap backend. */
+    constructor(gateway: Pick<ChainGateway, 'httpRequestor' | 'dexBackendBaseUrl'> & {
+        requestTimeoutMs?: number | undefined;
+    });
+    /** List all registered GalaChainDex trading symbols, cached for 60 seconds. */
+    list(): Promise<TradingSymbol[]>;
+    /** Invalidate the cached symbol registry after a write changes registration state.
+     *
      * @example
-     * ```typescript
-     * await eventsService.connectEventSocket();
+     * ```ts
+     * gSwap.symbols.invalidate();
+     * ```
+     */
+    invalidate(): void;
+    /** Force one registry refresh, bypassing the cache.
      *
-     * // Socket is now available for transaction updates
+     * @example
+     * ```ts
+     * const symbols = await gSwap.symbols.refresh();
      * ```
      */
-    connectEventSocket(bundlerBaseUrl?: string): Promise<TradeEventEmitter>;
+    refresh(): Promise<TradingSymbol[]>;
+    /** Resolve a symbol or token class key to its registered symbol metadata. */
+    resolve(ref: TokenRef): Promise<TradingSymbol>;
+    /** Resolve and put two token references in canonical trading-symbol order. */
+    orderPair(a: TokenRef, b: TokenRef): Promise<{
+        token0: TradingSymbol;
+        token1: TradingSymbol;
+        flipped: boolean;
+    }>;
+}
+/** Alias exported for callers that use the contract's shorter type name. */
+type TokenClassKey = GalaChainTokenClassKey;
+
+type PoolGateway = Pick<ChainGateway, 'httpRequestor' | 'dexBackendBaseUrl'> & {
+    requestTimeoutMs?: number | undefined;
+};
+type PoolSymbols = Pick<Symbols, 'resolve'>;
+/** Read-only pool and current-price access for the current GalaChainDex contract. */
+declare class Pools {
+    private readonly gateway;
+    private readonly symbols;
     /**
-     * Disconnects the global socket connection and cleans up resources.
+     * Creates a pool service.
+     *
+     * @example
+     * ```ts
+     * const pools = new Pools(gateway, symbols);
+     * ```
      */
-    disconnectEventSocket(): void;
+    constructor(gateway: PoolGateway, symbols: PoolSymbols);
+    private readonly http;
     /**
-     * Checks if the global socket connection is active.
-     * @returns True if connected, false otherwise.
+     * Fetches every current-contract pool from the swap backend.
+     *
+     * @example
+     * ```ts
+     * const pools = await service.getPools();
+     * console.log(pools.length);
+     * ```
      */
-    eventSocketConnected(): boolean;
+    getPools(options?: {
+        signal?: AbortSignal | undefined;
+    }): Promise<PoolListInfo[]>;
     /**
-     * Registers a transaction ID for waiting and timeout handling.
-     * @param txId - The transaction ID to register.
-     * @param timeoutMs - Timeout in milliseconds.
+     * Fetches one pool from the backend, preserving whether the request order was flipped.
+     *
+     * @example
+     * ```ts
+     * const pool = await service.getPool('GUSDC', 'GALA', 3000);
+     * console.log(pool.flippedFromRequest);
+     * ```
      */
-    registerTxId(txId: string, timeoutMs: number): void;
+    getPool(token0: TokenRef, token1: TokenRef, fee: FEE_TIER): Promise<PoolInfo>;
     /**
-     * Waits for a transaction to complete.
-     * @param txId - The transaction ID to wait for.
-     * @returns Promise that resolves when the transaction completes.
-     */
-    wait(txId: string): Promise<{
-        txId: string;
-        transactionHash: string;
-        Data: Record<string, unknown>;
-    }>;
+     * Fetches the current sqrt price, price, and tick for one pool.
+     *
+     * @example
+     * ```ts
+     * const slot0 = await service.getSlot0('GALA', 'GUSDC', 3000);
+     * console.log(slot0.tick);
+     * ```
+     */
+    getSlot0(token0: TokenRef, token1: TokenRef, fee: FEE_TIER): Promise<Slot0>;
     /**
-     * Internal handler for socket messages.
-     * @param response - The bundler response.
-     * @param txId - The transaction ID.
+     * Fetches the complete chain composite pool snapshot, in canonical symbol order.
+     *
+     * @example
+     * ```ts
+     * const composite = await service.getCompositePool('GALA', 'GUSDC', 3000);
+     * console.log(composite.positions?.length ?? 0);
+     * ```
      */
-    private internalHandleSocketMessage;
+    getCompositePool(token0: TokenRef, token1: TokenRef, fee: FEE_TIER): Promise<CompositePool>;
+    private backendParams;
+    private getBackend;
 }
 
-interface QuoteExactAmountRawResponse {
-    amount0: string;
-    amount1: string;
-    currentSqrtPrice: string;
-    newSqrtPrice: string;
-}
-interface QuoteExactAmountResponse {
-    amount0: BigNumber;
-    amount1: BigNumber;
-    currentSqrtPrice: SqrtPrice;
-    newSqrtPrice: SqrtPrice;
-}
-interface GetPoolDataRawResponse {
-    bitmap: Record<string, string>;
-    fee: number;
-    feeGrowthGlobal0: string;
-    feeGrowthGlobal1: string;
-    grossPoolLiquidity: string;
-    liquidity: string;
-    maxLiquidityPerTick: string;
-    protocolFees: number;
-    protocolFeesToken0: string;
-    protocolFeesToken1: string;
-    sqrtPrice: string;
-    tickSpacing: number;
-    token0: string;
-    token0ClassKey: {
-        additionalKey: string;
-        category: string;
-        collection: string;
-        type: string;
-    };
-    token1: string;
-    token1ClassKey: {
-        additionalKey: string;
-        category: string;
-        collection: string;
-        type: string;
-    };
+/** The signing schemes supported by the Gala Wallet signer. */
+type GalaWalletScheme = 'native' | 'personal-sign';
+/** The request surface used by an EIP-1193 browser wallet. */
+interface BrowserWalletProvider {
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
 }
-interface GetPoolDataResponse {
-    bitmap: Record<string, string>;
-    fee: number;
-    feeGrowthGlobal0: BigNumber;
-    feeGrowthGlobal1: BigNumber;
-    grossPoolLiquidity: BigNumber;
-    liquidity: BigNumber;
-    maxLiquidityPerTick: BigNumber;
-    protocolFees: number;
-    protocolFeesToken0: BigNumber;
-    protocolFeesToken1: BigNumber;
-    sqrtPrice: SqrtPrice;
-    tickSpacing: number;
-    token0: string;
-    token0ClassKey: {
-        additionalKey: string;
-        category: string;
-        collection: string;
-        type: string;
-    };
-    token1: string;
-    token1ClassKey: {
-        additionalKey: string;
-        category: string;
-        collection: string;
-        type: string;
-    };
-}
-interface TransactionPendingResponse {
-    data: string;
-    message: string;
-    error: boolean;
+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.
+ */
+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>>;
 }
-
-declare class Pools {
-    private readonly gatewayBaseUrl;
-    private readonly dexContractBasePath;
-    private readonly httpClient;
-    constructor(gatewayBaseUrl: string, dexContractBasePath: string, httpClient: HttpClient);
+/**
+ * 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.
+ */
+declare class PrivateKeySigner implements GalaChainSigner {
+    private readonly keyBuffer;
     /**
-     * Gets pool data for a specific token pair and fee tier.
+     * 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' });
+     * ```
      */
-    getPoolData(token0: GalaChainTokenClassKey | string, token1: GalaChainTokenClassKey | string, fee: number): Promise<GetPoolDataResponse>;
+    constructor(privateKey: string);
     /**
-     * Calculates the nearest valid tick value for a given price.
+     * Signs the DTO with GalaChain native signing.
+     *
+     * @example
+     * ```typescript
+     * const signed = await signer.signObject('RequestTrade', {
+     *   token0: 'GALA',
+     *   token1: 'GUSDC',
+     *   fee: 3000,
+     * });
+     * ```
      */
-    calculateTicksForPrice(price: PriceIn, tickSpacing: number): number;
-    calculatePriceForTicks(tick: number): Price;
+    signObject<T extends Record<string, unknown>>(_methodName: string, dto: T): Promise<SignedDto<T>>;
+}
+/**
+ * A Gala Wallet signer using native GalaChain signing, with an opt-in personal-sign mode and
+ * automatic fallback for older wallets.
+ *
+ * The selected Ethereum account is passed to Gala Wallet. Personal-sign resolves the bare
+ * `eth|` identity; the legacy EIP-712 `eth_signTypedData` path is not used. The fallback calls
+ * `gala_signChainDto([serialize({ ...dto, prefix }), walletAddress, methodName])`.
+ */
+declare class GalaWalletSigner implements GalaChainSigner {
+    /** The wallet address supplied to Gala Wallet for each signing request. */
+    readonly walletAddress: string;
+    /** The scheme currently used, including any automatic native-to-personal fallback. */
+    effectiveScheme: GalaWalletScheme;
     /**
-     * Calculates the current spot price of a pool based on sqrt price.
-     * Price is defined as the amount of outToken you would receive for 1 inToken.
+     * Creates a Gala Wallet signer.
+     *
+     * @example
+     * ```typescript
+     * const signer = new GalaWalletSigner('0x0123456789012345678901234567890123456789');
+     * const signed = await signer.signObject('RequestTrade', { token0: 'GALA', token1: 'GUSDC' });
+     * ```
+     *
+     * @param walletAddress - The selected Ethereum account (`0x` plus 40 hex digits); Gala Wallet's
+     * `eth|0x...` form is also accepted and normalized.
+     * @param options - Select native signing or personal-sign explicitly.
      */
-    calculateSpotPrice(inToken: GalaChainTokenClassKey | string, outToken: GalaChainTokenClassKey | string, poolSqrtPrice: SqrtPriceIn): BigNumber;
+    constructor(walletAddress: string, options?: {
+        scheme?: GalaWalletScheme | 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>>;
 }
-
 /**
- * Fee tiers for pools.
+ * 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.
  */
-declare enum FEE_TIER {
-    /** 0.05% fee tier */
-    PERCENT_00_05 = 500,
-    /** 0.3% fee tier */
-    PERCENT_00_30 = 3000,
-    /** 1.0% fee tier */
-    PERCENT_01_00 = 10000
+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';
+    });
+    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>>;
 }
 
+interface Branding<BrandT> {
+    _type: BrandT;
+}
+type Brand<T, BrandT> = T & Branding<BrandT>;
+
+type NumericAmount = string | BigNumber;
+type SqrtPrice = Brand<BigNumber, 'SqrtPrice'>;
+type SqrtPriceIn = Brand<NumericAmount, 'SqrtPriceIn'> | SqrtPrice;
+type Price = Brand<BigNumber, 'Price'>;
+type PriceIn = Brand<NumericAmount, 'PriceIn'> | Price;
+
+type PositionGateway = Pick<ChainGateway, 'httpRequestor' | 'dexBackendBaseUrl'> & {
+    submit: (method: string, signedBody: Record<string, unknown>, options?: ChainSubmitOptions) => Promise<SubmittedTransaction<Position | null>>;
+    requestTimeoutMs?: number | undefined;
+};
+type PositionSymbols = Pick<Symbols, 'resolve' | 'orderPair'> & {
+    invalidate?: () => void;
+};
 /**
- * Handles position management operations for liquidity positions.
+ * Manages current-contract concentrated-liquidity positions.
+ *
+ * @example
+ * ```typescript
+ * const positions = gSwap.positions;
+ * const mine = await positions.getUserPositions('client|012345678901234567890123');
+ * console.log(mine.length);
+ * ```
  */
 declare class Positions {
-    private readonly gatewayBaseUrl;
-    private readonly dexContractBasePath;
-    private readonly options?;
-    private readonly httpClient;
-    private readonly bundlerService;
-    private readonly poolService;
-    constructor(gatewayBaseUrl: string, dexContractBasePath: string, bundlerService: Bundler, poolService: Pools, httpClient: HttpClient, options?: {
-        walletAddress?: string | undefined;
-    } | undefined);
+    private readonly gateway;
+    private readonly symbols;
+    private readonly signer?;
+    private readonly walletAddress?;
+    constructor(gateway: PositionGateway, symbols: PositionSymbols, signer?: GalaChainSigner | undefined, walletAddress?: string | undefined);
+    private readonly http;
     /**
-     * Get all liquidity positions for a specific wallet address.
-     * @param ownerAddress - The wallet address to get positions for.
-     * @param limit - Maximum number of positions to return.
-     * @param bookmark - Pagination bookmark for retrieving additional results. If you call this function and it returns a bookmark that is not an empty string, you can pass that bookmark as this parameter in a subsequent call to fetch the next page.
-     * @returns User positions and pagination bookmark
+     * Gets all current-contract positions owned by an address.
+     *
+     * @param owner - GalaChain owner identity.
+     * @returns Enriched positions from the v2 trade backend.
      * @example
      * ```typescript
-     * const positions = await gSwap.positions.getUserPositions('eth|123...abc');
-     * console.log(positions);
+     * const positions = await gSwap.positions.getUserPositions('client|012345678901234567890123');
      * ```
      */
-    getUserPositions(ownerAddress: string, limit?: number, bookmark?: string): Promise<{
-        bookmark: string;
-        positions: GetUserPositionsResult[];
-    }>;
+    getUserPositions(owner: string): Promise<Position[]>;
     /**
-     * Gets detailed information about a specific liquidity position.
-     * @param ownerAddress - The wallet address that owns the position.
-     * @param position - Position parameters including tokens, fee, and tick range.
-     * @param position.token0ClassKey - The first token in the position.
-     * @param position.token1ClassKey - The second token in the position.
-     * @param position.fee - The pool fee tier.
-     * @param position.tickLower - The lower tick of the position range.
-     * @param position.tickUpper - The upper tick of the position range.
-     * @returns Detailed position information.
+     * Gets one position, normalizing a caller-supplied reversed pair to canonical symbol order.
+     * Reversed pairs also invert the price axis, so `[lower, upper]` becomes `[-upper, -lower]`.
+     *
+     * @param args - Pair, owner, fee, and position tick range.
+     * @returns The position, or `null` when the backend returns 404.
      * @example
      * ```typescript
-     * const position = await gSwap.positions.getPosition('eth|123...abc', {
-     *   token0ClassKey: 'GALA|Unit|none|none',
-     *   token1ClassKey: 'GUSDC|Unit|none|none',
-     *   fee: 500,
-     *   tickLower: -6000,
-     *   tickUpper: 6000
+     * const position = await gSwap.positions.getPosition({
+     *   token0: 'GALA', token1: 'GUSDC', owner: 'client|012345678901234567890123',
+     *   fee: 3000, tickLower: -19200, tickUpper: 12000,
      * });
-     * console.log('Position:', position);
      * ```
      */
-    getPosition(ownerAddress: string, position: {
-        token0ClassKey: GalaChainTokenClassKey | string;
-        token1ClassKey: GalaChainTokenClassKey | string;
-        fee: number;
+    getPosition(args: {
+        token0: TokenRef;
+        token1: TokenRef;
+        fee: FEE_TIER;
+        owner: string;
         tickLower: number;
         tickUpper: number;
-    }): Promise<GetPositionResult>;
+    }, signal?: AbortSignal): Promise<Position | null>;
     /**
-     * Estimates the token amounts that would be received from removing liquidity from a position.
-     * @param args - Parameters for estimating liquidity removal.
-     * @param args.ownerAddress - The wallet address that owns the position.
-     * @param args.positionId - The position identifier.
-     * @param args.token0 - The first token in the pair.
-     * @param args.token1 - The second token in the pair.
-     * @param args.fee - The pool fee tier.
-     * @param args.tickLower - The lower tick of the position range.
-     * @param args.tickUpper - The upper tick of the position range.
-     * @param args.amount - The amount of liquidity to remove.
-     * @returns Estimated token amounts that would be received.
+     * Estimates the other token amount and resulting liquidity for a deposit.
+     *
+     * @param args - Pair, tick range, deposit amount, and the amount's caller-side token index.
+     * @returns Backend liquidity estimate.
      * @example
      * ```typescript
-     * const estimation = await gSwap.positions.estimateRemoveLiquidity({
-     *   ownerAddress: 'client|635f048ab243d7eb7f5ba044',
-     *   positionId: '210f8e4dd1bbe1b4af4b977330ee7e4b68bc716f66e39c87a60fff0976ded3ea',
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDT|Unit|none|none',
-     *   fee: 3000,
-     *   tickLower: -41100,
-     *   tickUpper: -40080,
-     *   amount: '1491.973332758921980256'
+     * const estimate = await gSwap.positions.estimateAddLiquidity({
+     *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+     *   tickLower: -19200, tickUpper: 12000, amount: '100', amountIsToken0: true,
      * });
-     * console.log('Estimated tokens:', estimation);
      * ```
      */
-    estimateRemoveLiquidity(args: {
-        ownerAddress: string;
-        positionId: string;
-        token0: GalaChainTokenClassKey | string;
-        token1: GalaChainTokenClassKey | string;
-        fee: number;
+    estimateAddLiquidity(args: {
+        token0: TokenRef;
+        token1: TokenRef;
+        fee: FEE_TIER;
         tickLower: number;
         tickUpper: number;
         amount: NumericAmount;
-    }): Promise<{
-        amount0: BigNumber;
-        amount1: BigNumber;
-    }>;
+        amountIsToken0: boolean;
+    }): Promise<AddLiquidityEstimate>;
     /**
-     * Gets detailed information about a liquidity position by its ID.
-     * @param ownerAddress - The wallet address that owns the position.
-     * @param positionId - The unique identifier of the position.
-     * @returns Detailed position information, or undefined if not found.
+     * Estimates token amounts released by burning liquidity.
+     *
+     * @param args - Pair, tick range, fee tier, and liquidity quantity.
+     * @returns Estimated token0 and token1 quantities.
      * @example
      * ```typescript
-     * const position = await gSwap.positions.getPositionById('eth|123...abc', 'position-uuid-123');
-     * if (position) {
-     *   console.log('Position found:', position);
-     * } else {
-     *   console.log('Position not found');
-     * }
+     * const estimate = await gSwap.positions.estimateRemoveLiquidity({
+     *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+     *   tickLower: -19200, tickUpper: 12000, liquidity: '1000',
+     * });
      * ```
      */
-    getPositionById(ownerAddress: string, positionId: string): Promise<GetPositionResult | undefined>;
+    estimateRemoveLiquidity(args: {
+        token0: TokenRef;
+        token1: TokenRef;
+        fee: FEE_TIER;
+        tickLower: number;
+        tickUpper: number;
+        liquidity: NumericAmount;
+    }): Promise<RemoveLiquidityEstimate>;
     /**
-     * Creates a new position or adds liquidity to a position, using a specific tick range. Consider using `addLiquidityByPrice()` instead unless you want to use ticks directly.
-     * @param args - Parameters for adding liquidity.
-     * @param args.walletAddress - The wallet address adding liquidity.
-     * @param args.positionId - The position identifier. If you're creating a new position, this should be an empty string.
-     * @param args.token0 - The first token in the pair.
-     * @param args.token1 - The second token in the pair.
-     * @param args.fee - The pool fee tier.
-     * @param args.tickLower - The lower tick of the position range.
-     * @param args.tickUpper - The upper tick of the position range.
-     * @param args.amount0Desired - Desired (also maximum) amount of token0 to add.
-     * @param args.amount1Desired - Desired (also maximum) amount of token1 to add.
-     * @param args.amount0Min - Minimum amount of token0 to add (slippage protection).
-     * @param args.amount1Min - Minimum amount of token1 to add (slippage protection).
-     * @returns Pending transaction.
+     * Adds liquidity using an explicit tick range. Exactly one canonical deposit field is emitted.
+     *
+     * @param args - Pair, fee, range, deposit amount, and caller-side token index.
+     * @returns The synchronously submitted transaction.
      * @example
      * ```typescript
-     * const result = await gSwap.positions.addLiquidityByTicks({
-     *   walletAddress: 'eth|123...abc',
-     *   positionId: '',
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDC|Unit|none|none',
-     *   fee: 500,
-     *   tickSpacing: 10,
-     *   tickLower: -6000,
-     *   tickUpper: 6000,
-     *   amount0Desired: '100',
-     *   amount1Desired: '50',
-     *   amount0Min: '95',
-     *   amount1Min: '47.5'
+     * const tx = await gSwap.positions.addLiquidityByTicks({
+     *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+     *   tickLower: -19200, tickUpper: 12000, amount: '100', amountIsToken0: true,
      * });
-     * console.log('Liquidity added:', result);
+     * await tx.confirm();
      * ```
      */
     addLiquidityByTicks(args: {
-        walletAddress?: string;
-        positionId: string;
-        token0: GalaChainTokenClassKey | string;
-        token1: GalaChainTokenClassKey | string;
+        token0: TokenRef;
+        token1: TokenRef;
         fee: FEE_TIER;
         tickLower: number;
         tickUpper: number;
-        amount0Desired: NumericAmount;
-        amount1Desired: NumericAmount;
-        amount0Min: NumericAmount;
-        amount1Min: NumericAmount;
-    }): Promise<PendingTransaction>;
+        amount: NumericAmount;
+        amountIsToken0: boolean;
+    }): Promise<SubmittedTransaction<Position | null>>;
     /**
-     * Creates a new position or adds liquidity to a position, using a specified price range. Note that this method automatically converts your minPrice and maxPrice to ticks, rounding down if necessary.
-     * @param args - Parameters for adding liquidity.
-     * @param args.walletAddress - The wallet address adding liquidity.
-     * @param args.positionId - The position identifier. This should be an empty string if you are creating a new position.
-     * @param args.token0 - The first token in the pair.
-     * @param args.token1 - The second token in the pair.
-     * @param args.fee - The pool fee tier.
-     * @param args.tickSpacing - The tick spacing for the pool.
-     * @param args.minPrice - The minimum price for the position range.
-     * @param args.maxPrice - The maximum price for the position range.
-     * @param args.amount0Desired - Desired (also maximum) amount of token0 to add.
-     * @param args.amount1Desired - Desired (also maximum) amount of token1 to add.
-     * @param args.amount0Min - Minimum amount of token0 to add (slippage protection).
-     * @param args.amount1Min - Minimum amount of token1 to add (slippage protection).
-     * @returns Pending transaction.
+     * Adds liquidity from prices, flooring the lower tick and ceiling the upper tick to fee spacing.
+     * The resulting range is therefore no narrower than the requested price interval.
+     *
+     * @param args - Pair, fee, price range, deposit amount, and caller-side token index.
+     * @returns The synchronously submitted transaction.
      * @example
      * ```typescript
-     * const result = await gSwap.positions.addLiquidityByPrice({
-     *   walletAddress: 'eth|123...abc',
-     *   positionId: '',
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDC|Unit|none|none',
-     *   fee: 500,
-     *   tickSpacing: 10,
-     *   minPrice: '0.45',
-     *   maxPrice: '0.55',
-     *   amount0Desired: '100',
-     *   amount1Desired: '50',
-     *   amount0Min: '95',
-     *   amount1Min: '47.5'
+     * const tx = await gSwap.positions.addLiquidityByPrice({
+     *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+     *   minPrice: '0.14', maxPrice: '0.16', amount: '100', amountIsToken0: true,
      * });
-     * console.log('Liquidity added with price range:', result);
      * ```
      */
     addLiquidityByPrice(args: {
-        walletAddress?: string;
-        positionId: string;
-        token0: GalaChainTokenClassKey | string;
-        token1: GalaChainTokenClassKey | string;
-        fee: number;
-        tickSpacing: number;
+        token0: TokenRef;
+        token1: TokenRef;
+        fee: FEE_TIER;
         minPrice: PriceIn;
         maxPrice: PriceIn;
-        amount0Desired: NumericAmount;
-        amount1Desired: NumericAmount;
-        amount0Min: NumericAmount;
-        amount1Min: NumericAmount;
-    }): Promise<PendingTransaction>;
+        amount: NumericAmount;
+        amountIsToken0: boolean;
+    }): Promise<SubmittedTransaction<Position | null>>;
     /**
-     * Removes liquidity from a position.
-     * @param args - Parameters for removing liquidity.
-     * @param args.walletAddress - The wallet address removing liquidity.
-     * @param args.positionId - The position identifier.
-     * @param args.token0 - The first token in the pair.
-     * @param args.token1 - The second token in the pair.
-     * @param args.fee - The pool fee tier.
-     * @param args.tickLower - The lower tick of the position range.
-     * @param args.tickUpper - The upper tick of the position range.
-     * @param args.amount - The amount of liquidity to remove.
-     * @param args.amount0Min - Minimum amount of token0 to receive (slippage protection, optional).
-     * @param args.amount1Min - Minimum amount of token1 to receive (slippage protection, optional).
-     * @returns Pending transaction.
+     * Removes liquidity by withdrawing at most one canonical token quantity.
+     * Omitting both amounts closes the position and sweeps all accrued fees.
+     *
+     * @param args - Pair, fee, range, and optional caller-side withdrawal amount.
+     * @returns The synchronously submitted transaction.
      * @example
      * ```typescript
-     * // Remove 50% of liquidity from a position
-     * const result = await gSwap.positions.removeLiquidity({
-     *   walletAddress: 'eth|123...abc',
-     *   positionId: 'position-123',
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDC|Unit|none|none',
-     *   fee: 500,
-     *   tickLower: -6000,
-     *   tickUpper: 6000,
-     *   amount: '50000000000000000000', // 50% of position liquidity
-     *   amount0Min: '45',
-     *   amount1Min: '22'
+     * const tx = await gSwap.positions.removeLiquidity({
+     *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+     *   tickLower: -19200, tickUpper: 12000,
      * });
-     * console.log('Liquidity removed:', result);
      * ```
      */
     removeLiquidity(args: {
-        walletAddress?: string;
-        positionId: string;
-        token0: GalaChainTokenClassKey | string;
-        token1: GalaChainTokenClassKey | string;
-        fee: number;
+        token0: TokenRef;
+        token1: TokenRef;
+        fee: FEE_TIER;
         tickLower: number;
         tickUpper: number;
-        amount: NumericAmount;
-        amount0Min?: NumericAmount;
-        amount1Min?: NumericAmount;
-    }): Promise<PendingTransaction>;
+        amount0?: NumericAmount | undefined;
+        amount1?: NumericAmount | undefined;
+    }): Promise<SubmittedTransaction<Position | null>>;
     /**
-     * Collects accumulated fees from a liquidity position.
-     * @param args - Parameters for collecting fees.
-     * @param args.walletAddress - The wallet address collecting fees.
-     * @param args.positionId - The position identifier.
-     * @param args.token0 - The first token in the pair.
-     * @param args.token1 - The second token in the pair.
-     * @param args.fee - The pool fee tier.
-     * @param args.tickLower - The lower tick of the position range.
-     * @param args.tickUpper - The upper tick of the position range.
-     * @param args.amount0Requested - Desired amount of token0 fees to collect.
-     * @param args.amount1Requested - Desired amount of token1 fees to collect.
-     * @returns Pending transaction.
+     * Collects all accrued fees for a position; the contract does not support partial collection.
+     *
+     * @param args - Pair, fee, and tick range identifying the position.
+     * @returns The synchronously submitted transaction.
      * @example
      * ```typescript
-     * // Collect all accumulated fees from a position
-     * const result = await gSwap.positions.collectPositionFees({
-     *   walletAddress: 'eth|123...abc',
-     *   positionId: 'position-123',
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDC|Unit|none|none',
-     *   fee: 500,
-     *   tickLower: -6000,
-     *   tickUpper: 6000,
-     *   amount0Requested: '1000000000000000000', // Max fees available
-     *   amount1Requested: '500000000' // Max fees available
+     * const tx = await gSwap.positions.collectPositionFees({
+     *   token0: 'GALA', token1: 'GUSDC', fee: 3000,
+     *   tickLower: -19200, tickUpper: 12000,
      * });
-     * console.log('Fees collected:', result);
      * ```
      */
     collectPositionFees(args: {
-        walletAddress?: string;
-        positionId: string;
-        token0: GalaChainTokenClassKey | string;
-        token1: GalaChainTokenClassKey | string;
-        fee: number;
+        token0: TokenRef;
+        token1: TokenRef;
+        fee: FEE_TIER;
         tickLower: number;
         tickUpper: number;
-        amount0Requested: NumericAmount;
-        amount1Requested: NumericAmount;
-    }): Promise<PendingTransaction>;
-    calculateOptimalPositionSize(tokenAmount: NumericAmount, spotPrice: NumericAmount, lowerPrice: NumericAmount, upperPrice: NumericAmount, tokenDecimals: number, otherTokenDecimals: number): BigNumber;
-    private sendUserPositionsRequest;
-    private sendPositionRequest;
+    }): Promise<SubmittedTransaction<Position | null>>;
+    /**
+     * Creates a pool, resolving registered trading symbols and falling back to class collections.
+     * Reversed symbol order inverts the supplied starting price or square-root price.
+     *
+     * @param args - Token class keys or references, fee, exactly one starting price field, and privacy options.
+     * @returns The synchronously submitted transaction.
+     * @example
+     * ```typescript
+     * const tx = await gSwap.positions.createPool({
+     *   token0: 'GALA|Unit|none|none', token1: 'GUSDC|Unit|none|none', fee: 3000,
+     *   startingPrice: '0.15',
+     * });
+     * ```
+     */
+    createPool(args: {
+        token0: TokenRef;
+        token1: TokenRef;
+        fee: FEE_TIER;
+        startingPrice?: NumericAmount | undefined;
+        startingSqrtPrice?: NumericAmount | undefined;
+        isPrivate?: boolean | undefined;
+        privateAccess?: string[] | undefined;
+    }): Promise<SubmittedTransaction<Position | null>>;
+    private submit;
+    /**
+     * Builds a confirmation closure that proves the write's own effect, not just that a
+     * position row exists (true before most of these writes run too, for any operation on a
+     * pre-existing position — existence alone would false-confirm before the write executes,
+     * and would never confirm a full close, whose whole point is that the position stops
+     * existing).
+     *
+     * The "before" state is captured lazily, on the confirmation closure's own first poll —
+     * not eagerly here in `submit()` — so confirming a write never adds an extra round-trip to
+     * the write itself; the cost of establishing the baseline is paid by `confirm()`, only if
+     * and when the caller actually asks to confirm.
+     */
+    private buildPositionConfirmation;
+    private get;
+    private getNullable;
+    private isNotFound;
+    private mapPosition;
+    private requestToken;
+    private canonicalTicks;
+    private tickSpacing;
+    private rejectNumber;
+    private uniqueKey;
+    private resolveCreateToken;
+    private tryParseClassKey;
 }
 
-/**
- * Handles quote operations for token swaps.
- */
+type QuoteSymbols = Pick<Symbols, 'resolve'>;
+/** Read-only quote service backed by the v2 offline quote engine. */
 declare class Quoting {
-    private readonly gatewayBaseUrl;
-    private readonly dexContractBasePath;
-    private readonly httpClient;
-    constructor(gatewayBaseUrl: string, dexContractBasePath: string, httpClient?: HttpClient);
+    private readonly dexBackendBaseUrl;
+    private readonly http;
+    private readonly symbols;
     /**
-     * Gets a quote for an exact amount of token being sold.
-     * @param tokenIn - The input token to sell.
-     * @param tokenOut - The output token to buy.
-     * @param amountIn - The exact amount of input tokens you want to sell.
-     * @param fee - The pool fee tier. If not specified, will check all available fee tiers and return the best quote.
-     * @returns The expected number of tokens you will receive (buy) when/if you execute the swap.
-     */
-    quoteExactInput(tokenIn: GalaChainTokenClassKey | string, tokenOut: GalaChainTokenClassKey | string, amountIn: NumericAmount, fee?: FEE_TIER): Promise<GetQuoteResult>;
+     * Creates a quote service.
+     *
+     * @example
+     * ```ts
+     * const quoting = new Quoting('https://swap-backend.stage.defi.ovh.gala.com', http, symbols);
+     * ```
+     */
+    constructor(dexBackendBaseUrl: string, http: HttpClient, symbols: QuoteSymbols);
     /**
-     * Gets a quote for an exact amount of tokens being bought.
-     * @param tokenIn - The input token sell.
-     * @param tokenOut - The output token to buy.
-     * @param amountOut - The exact amount of output tokens you want to buy.
-     * @param fee - The pool fee tier. If not specified, will check all available fee tiers and return the best quote.
-     * @returns The expected number of tokens you will need to sell (input) to receive the specified amount of output tokens.
-     */
-    quoteExactOutput(tokenIn: GalaChainTokenClassKey | string, tokenOut: GalaChainTokenClassKey | string, amountOut: string | number | BigNumber, fee?: FEE_TIER): Promise<GetQuoteResult>;
-    private getSingleQuote;
-    private getSingleQuoteExactInput;
-    private getSingleQuoteExactOutput;
-    private sendQuoteRequest;
-}
-
-/**
- * Service for handling token swap operations.
- */
-declare class Swaps {
-    private readonly bundlerService;
-    private readonly options?;
-    constructor(bundlerService: Bundler, options?: {
-        walletAddress?: string | undefined;
-    } | undefined);
+     * Quotes the output for a positive exact-input amount.
+     *
+     * @example
+     * ```ts
+     * const quote = await quoting.quoteExactInput('GALA', 'GUSDC', '100');
+     * console.log(quote.amountOut);
+     * ```
+     */
+    quoteExactInput(tokenIn: TokenRef, tokenOut: TokenRef, amountIn: NumericAmount, fee?: FEE_TIER): Promise<QuoteResult>;
     /**
-     * Executes a token swap transaction.
-     * @param walletAddress - The wallet address executing the swap.
-     * @param tokenIn - The input token to sell.
-     * @param tokenOut - The output token to buy.
-     * @param fee - The pool fee tier.
-     * @param amount - Swap parameters specifying either exact input or exact output.
-     * @param amount.exactIn - For exact input swaps, the exact amount of input tokens to sell.
-     * @param amount.amountOutMinimum - For exact input swaps, the minimum amount of output tokens to buy (slippage protection).
-     * @param amount.exactOut - For exact output swaps, the exact amount of output tokens to buy.
-     * @param amount.amountInMaximum - For exact output swaps, the maximum amount of input tokens to sell (slippage protection).
-     * @returns Pending transaction.
+     * Quotes the input for a positive exact-output amount.
+     *
      * @example
-     * ```typescript
-     * // Exact input swap: sell 100 GALA for USDC
-     * const result = await swapsService.swap(
-     *   'GALA|Unit|none|none',
-     *   'GUSDC|Unit|none|none',
-     *   500,
-     *   { exactIn: '100', amountOutMinimum: '45' },
-     *   'eth|123...abc', // your wallet address
-     * );
-     * console.log('Swap successful:', result);
-     * ```
-     */
-    swap(tokenIn: GalaChainTokenClassKey | string, tokenOut: GalaChainTokenClassKey | string, fee: number, amount: {
-        exactIn: NumericAmount;
-        amountOutMinimum?: NumericAmount;
-    } | {
-        exactOut: NumericAmount;
-        amountInMaximum?: NumericAmount;
-    }, walletAddress?: string): Promise<PendingTransaction>;
+     * ```ts
+     * const quote = await quoting.quoteExactOutput('GALA', 'GUSDC', '10', 3000);
+     * console.log(quote.amountIn);
+     * ```
+     */
+    quoteExactOutput(tokenIn: TokenRef, tokenOut: TokenRef, amountOut: NumericAmount, fee?: FEE_TIER): Promise<QuoteResult>;
+    private quote;
 }
 
-/**
- * Main class for interacting with the gSwap decentralized exchange.
- * Provides methods for trading, liquidity management, and position handling.
- */
-declare class GSwap {
-    readonly gatewayBaseUrl: string;
-    readonly dexContractBasePath: string;
-    readonly tokenContractBasePath: string;
-    readonly bundlerBaseUrl: string;
-    readonly bundlingAPIBasePath: string;
+type SwapAmount = {
+    exactIn: NumericAmount;
+    exactOut?: undefined;
+    amountOutMinimum?: NumericAmount | undefined;
+    amountInMaximum?: undefined;
+} | {
+    exactIn?: undefined;
+    exactOut: NumericAmount;
+    amountOutMinimum?: undefined;
+    amountInMaximum?: NumericAmount | undefined;
+};
+interface SwapGateway {
+    submit: (method: 'RequestTrade', signedBody: Record<string, unknown>, options?: ChainSubmitOptions) => Promise<SubmittedTransaction<AppliedTrade>>;
     readonly dexBackendBaseUrl: string;
-    readonly transactionWaitTimeoutMs: number;
-    readonly signer?: GalaChainSigner | undefined;
+    readonly httpRequestor: HttpRequestor;
+    readonly requestTimeoutMs: number;
+}
+type SwapSymbols = Pick<Symbols, 'resolve'>;
+/** Executes queued current-contract RequestTrade operations through the Chain Gateway. */
+declare class Swaps {
+    private readonly gateway;
+    private readonly symbols;
+    private readonly signer?;
+    private readonly walletAddress?;
     /**
-     * Quoting functionality for price discovery and trade estimation.
-     * Use this to get quotes for token swaps without executing transactions.
+     * Creates a swap service.
      *
      * @example
-     * ```typescript
-     * // Get the best quote across all fee tiers
-     * const quote = await gSwap.quoting.quoteExactInput(tokenA, tokenB, amount);
+     * ```ts
+     * const swaps = new Swaps(gateway, symbols, signer, 'client|alice');
      * ```
      */
-    readonly quoting: Quoting;
+    constructor(gateway: SwapGateway, symbols: SwapSymbols, signer?: GalaChainSigner | undefined, walletAddress?: string | undefined);
     /**
-     * Position management operations for liquidity positions.
-     * Use this to manage liquidity positions including creation, modification, and fee collection.
+     * Signs and submits an exact-input or exact-output RequestTrade DTO. The returned transaction
+     * is QUEUED; call `await tx.confirm()` to obtain the executed trade or chain rejection.
      *
      * @example
-     * ```typescript
-     * // Get all user positions
-     * const positions = await gSwap.positions.getUserPositions('eth|123...abc');
-     *
-     * // Add liquidity to a position using price range
-     * const result = await gSwap.positions.addLiquidityByPrice({
-     *   walletAddress: 'eth|123...abc',
-     *   positionId: '',
-     *   token0: 'GALA|Unit|none|none',
-     *   token1: 'GUSDC|Unit|none|none',
-     *   fee: 500,
-     *   tickSpacing: 10,
-     *   minPrice: '0.45',
-     *   maxPrice: '0.55',
-     *   amount0Desired: '100',
-     *   amount1Desired: '50',
-     *   amount0Min: '95',
-     *   amount1Min: '47.5'
+     * ```ts
+     * const submitted = await swaps.swap('GALA', 'GUSDC', 3000, {
+     *   exactIn: '100',
+     *   amountOutMinimum: '14',
      * });
      * ```
      */
-    readonly positions: Positions;
+    swap(tokenIn: TokenRef, tokenOut: TokenRef, fee: FEE_TIER, amount: SwapAmount): Promise<SubmittedTransaction<AppliedTrade>>;
     /**
-     * Token swap operations for trading tokens.
-     * Use this to execute token swaps on the DEX.
+     * Confirm a swap by its durable `uniqueKey` without resubmitting it. This is the recovery
+     * path after a `CONFIRMATION_TIMEOUT`, a `SUBMISSION_OUTCOME_UNKNOWN`, a `409` replay
+     * conflict, or a process restart: it reads the same apply-results record that
+     * `SubmittedTransaction.confirm()` reads (retained for 7 days) and resolves the applied trade
+     * or throws the chain's rejection. The first read happens immediately unless
+     * `initialDelayMs` is given.
      *
      * @example
-     * ```typescript
-     * // Execute an exact input swap: sell 100 GALA for USDC
-     * const result = await gSwap.swaps.swap(
-     *   'GALA|Unit|none|none',
-     *   'GUSDC|Unit|none|none',
-     *   500,
-     *   { exactIn: '100', amountOutMinimum: '45' },
-     *   'eth|123...abc', // your wallet address
-     * );
+     * ```ts
+     * const applied = await swaps.confirmSwap('gswap-sdk-2f1c…');
      * ```
      */
+    confirmSwap(uniqueKey: string, options?: ConfirmOptions): Promise<AppliedTrade>;
+    private buildRequestTradeDto;
+}
+
+/** SDK deployment environment. */
+type GSwapEnv = 'prod' | 'stage';
+/** Backend URL used by one SDK deployment environment. */
+interface GSwapEnvironmentConfig {
+    dexBackendBaseUrl: string;
+}
+/** Built-in GalaSwap deployment environments. */
+declare const GSWAP_ENVIRONMENTS: Readonly<Record<GSwapEnv, GSwapEnvironmentConfig>>;
+
+/** Options for constructing a backend-routed SDK client. */
+interface GSwapOptions {
+    signer?: GalaChainSigner | undefined;
+    walletAddress?: string | undefined;
+    env?: GSwapEnv | undefined;
+    dexBackendBaseUrl?: string | undefined;
+    httpRequestor?: HttpRequestor | undefined;
+    chainCallTimeoutMs?: number | undefined;
+}
+/** Main entry point for the current GalaChainDex SDK. */
+declare class GSwap {
+    readonly dexBackendBaseUrl: string;
+    readonly chainCallTimeoutMs: number;
+    readonly signer: GalaChainSigner | undefined;
+    readonly walletAddress: string | undefined;
+    readonly gateway: ChainGateway;
+    readonly symbols: Symbols;
+    readonly quoting: Quoting;
+    readonly pools: Pools;
+    readonly positions: Positions;
     readonly swaps: Swaps;
-    /**
-     * User asset management operations.
-     * Use this to retrieve user token balances and asset information.
-     *
-     * @example
-     * ```typescript
-     * // Get user assets with pagination
-     * const assets = await gSwap.assets.getUserAssets('eth|123...abc', 1, 20);
-     * console.log(`User has ${assets.count} different tokens`);
-     * ```
-     */
     readonly assets: Assets;
     /**
-     * Event management operations for real-time socket connections.
-     * Use this to manage event streaming and transaction status updates.
+     * Create an SDK client for prod or stage.
      *
      * @example
      * ```typescript
-     * // Connect to event socket for transaction updates
-     * await GSwap.events.connectEventSocket();
-     *
-     * // Check if socket is connected
-     * const isConnected = GSwap.events.eventSocketConnected();
+     * const gSwap = new GSwap({ env: 'stage' });
+     * const symbols = await gSwap.symbols.list();
      * ```
      */
-    static readonly events: Events;
-    private readonly httpClient;
-    private readonly httpRequestor;
-    private readonly bundler;
-    readonly pools: Pools;
-    /**
-     * Creates a new SDK instance.
-     * @param options - Customization options.
-     * @param options.signer - The signer to use for authenticated operations. Required if you use any functionality that creates transactions (such as swapping). Not required for readonly operations.
-     * @param options.gatewayBaseUrl - Base URL for the GalaChain Gateway API.
-     * @param options.dexContractBasePath - Base path for DEX contract API endpoints, within the GalaChain Gateway API.
-     * @param options.tokenContractBasePath - Base path for token contract API endpoints, within the GalaChain Gateway API.
-     * @param options.bundlerBaseUrl - Base URL for the DEX transaction bundling API.
-     * @param options.bundlingAPIBasePath - Base path for transaction bundling API endpoints.
-     * @param options.dexBackendBaseUrl - Base URL for the DEX backend API (for user assets and other data).
-     * @param options.httpRequestor - Custom HTTP requestor to use for API calls. Defaults to the global `fetch` function.
-     * @param options.transactionWaitTimeoutMs - Timeout in milliseconds for waiting for transactions to complete. Defaults to 300,000 milliseconds (five minutes).
-     * @param options.walletAddress - Optional default wallet address for operations that require a wallet address (e.x. swapping). If not provided, you must specify the wallet address in each method call.
-     */
-    constructor(options?: {
-        signer?: GalaChainSigner | undefined;
-        gatewayBaseUrl?: string | undefined;
-        dexContractBasePath?: string | undefined;
-        tokenContractBasePath?: string | undefined;
-        bundlerBaseUrl?: string | undefined;
-        bundlingAPIBasePath?: string | undefined;
-        dexBackendBaseUrl?: string | undefined;
-        transactionWaitTimeoutMs?: number | undefined;
-        walletAddress?: string | undefined;
-        httpRequestor?: HttpRequestor | undefined;
-    });
+    constructor(options?: GSwapOptions);
 }
 
+/** Error raised by the SDK for validation, gateway, chain, or transaction failures. */
 declare class GSwapSDKError extends Error {
     readonly code: string;
     readonly details?: Record<string, unknown> | undefined;
-    constructor(message: string, code: string, details?: Record<string, unknown> | undefined);
+    readonly chainMessage: string | undefined;
+    readonly retryAfterMs: number | undefined;
+    constructor(message: string, code: string, details?: Record<string, unknown> | undefined, chainMessage?: string, retryAfterMs?: number);
+    /** Create the standard missing-signer error. */
     static noSignerError(): GSwapSDKError;
-    static fromErrorResponse(url: string, response: HTTPResponse): Promise<GSwapSDKError>;
-    static incorrectTokenOrderingError(specifiedToken0: GalaChainTokenClassKey | string, specifiedToken1: GalaChainTokenClassKey | string): GSwapSDKError;
-    static transactionWaitTimeoutError(txId: string): GSwapSDKError;
-    static transactionWaitFailedError(txId: string, detail: Record<string, unknown>): GSwapSDKError;
-    static socketConnectionRequiredError(): GSwapSDKError;
+    /** Create the error used when confirming a position write without a configured wallet address. */
+    static noWalletAddressError(): GSwapSDKError;
+    /** Create the error used when no pool can quote the requested pair. */
     static noPoolAvailableError(tokenIn: GalaChainTokenClassKey | string, tokenOut: GalaChainTokenClassKey | string, fee?: number): GSwapSDKError;
+    /** Create the error used when a pool lacks liquidity for a quote. */
+    static insufficientLiquidityError(tokenIn: GalaChainTokenClassKey | string, tokenOut: GalaChainTokenClassKey | string, fee?: number): GSwapSDKError;
+    /** Convert a chain-gateway bounce into a typed SDK error. */
+    static fromGatewayBounce(code: string, message: string, status: number, retryAfterMs?: number): GSwapSDKError;
+    /** Convert a GalaChain `Status: 0` response into a typed SDK error. */
+    static fromChainError(errorKey: string, message: string, details?: Record<string, unknown>): GSwapSDKError;
+    /** Create the error used when a token is not registered by the current DEX contract. */
+    static unknownTokenError(token: GalaChainTokenClassKey | string): GSwapSDKError;
+    /** Create the error used when apply-results confirmation does not arrive in time. */
+    static confirmationTimeoutError(uniqueKey: string, cause?: unknown): GSwapSDKError;
+    /** Convert an unexpected HTTP response into an SDK error. */
+    static fromErrorResponse(url: string, response: HTTPResponse): Promise<GSwapSDKError>;
 }
+/** Narrow an object property without trusting a cast at a network boundary. */
+declare function getObjectProperty(value: unknown, property: string): Record<string, unknown> | undefined;
+/** Read a string property from an unknown object. */
+declare function getStringProperty(value: unknown, property: string): string | undefined;
+/** Parse a response body, preserving non-JSON text for error reporting. */
+declare function parseJson(text: string): unknown;
 
-declare function stringifyTokenClassKey(tokenClassKey: GalaChainTokenClassKey | string, separator?: string): string;
-declare function parseTokenClassKey(tokenClassKey: string | GalaChainTokenClassKey): GalaChainTokenClassKey;
-declare function compareTokens(first: GalaChainTokenClassKey | string, second: GalaChainTokenClassKey | string): number;
-declare function getTokenOrdering<TAttributesType = undefined>(first: GalaChainTokenClassKey | string, second: GalaChainTokenClassKey | string, assertCorrectness: boolean, token1Data?: TAttributesType, token2Data?: TAttributesType): {
-    token0: string | GalaChainTokenClassKey;
-    token1: string | GalaChainTokenClassKey;
-    zeroForOne: true;
-    token0Attributes: TAttributesType | undefined;
-    token1Attributes: TAttributesType | undefined;
+/** Common identity fields for v2 pool writes. */
+interface V2PoolWriteBase {
+    token0: string;
+    token1: string;
+    fee: FEE_TIER;
+    uniqueKey: string;
+}
+/** A v2 RequestTrade with exactly one selected trade-side quantity. */
+type RequestTradeDTO = V2PoolWriteBase & ({
+    sell0Qty: string;
+    sell1Qty?: never;
+    buy0Qty?: never;
+    buy1Qty?: never;
 } | {
-    token0: string | GalaChainTokenClassKey;
-    token1: string | GalaChainTokenClassKey;
-    zeroForOne: false;
-    token0Attributes: TAttributesType | undefined;
-    token1Attributes: TAttributesType | undefined;
+    sell0Qty?: never;
+    sell1Qty: string;
+    buy0Qty?: never;
+    buy1Qty?: never;
+} | {
+    sell0Qty?: never;
+    sell1Qty?: never;
+    buy0Qty: string;
+    buy1Qty?: never;
+} | {
+    sell0Qty?: never;
+    sell1Qty?: never;
+    buy0Qty?: never;
+    buy1Qty: string;
+}) & {
+    amountOutMinimum?: string | undefined;
+    amountInMaximum?: string | undefined;
 };
+/** A v2 liquidity deposit with exactly one selected deposit quantity. */
+type AddLiquidityDTO = V2PoolWriteBase & {
+    tickLower: number;
+    tickUpper: number;
+} & ({
+    depositQuantityToken0: string;
+    depositQuantityToken1?: never;
+} | {
+    depositQuantityToken0?: never;
+    depositQuantityToken1: string;
+});
+/** A v2 liquidity withdrawal; omitting both quantities closes the position. */
+type RemoveLiquidityDTO = V2PoolWriteBase & {
+    tickLower: number;
+    tickUpper: number;
+} & ({
+    withdrawalQuantityToken0: string;
+    withdrawalQuantityToken1?: never;
+} | {
+    withdrawalQuantityToken0?: never;
+    withdrawalQuantityToken1: string;
+} | {
+    withdrawalQuantityToken0?: never;
+    withdrawalQuantityToken1?: never;
+});
+/** A v2 request to sweep all fees from one position. */
+interface CollectPositionFeesDTO extends V2PoolWriteBase {
+    tickLower: number;
+    tickUpper: number;
+}
+/** A v2 pool creation request with exactly one initial-price representation. */
+type CreatePoolDTO = {
+    token0Key: GalaChainTokenClassKey;
+    token1Key: GalaChainTokenClassKey;
+    token0Symbol: string;
+    token1Symbol: string;
+    fee: FEE_TIER;
+    isPrivate?: boolean | undefined;
+    privateAccess?: string[] | undefined;
+    uniqueKey: string;
+} & ({
+    startingPrice: string;
+    startingSqrtPrice?: never;
+} | {
+    startingPrice?: never;
+    startingSqrtPrice: string;
+});
+/** Optional page cursor accepted by chain read methods. */
+interface PageDTO {
+    limit?: number | undefined;
+    bookmark?: string | undefined;
+}
+/** Fetch all registered trading symbols. */
+type FetchTokenTradingSymbolsDTO = PageDTO;
+/** Fetch a composite pool snapshot. */
+interface FetchCompositePoolDataDTO {
+    token0: string;
+    token1: string;
+    fee: FEE_TIER;
+}
+/** Fetch one current trading price, or all prices when no pair is supplied. */
+type FetchCurrentTradingPricesDTO = Partial<FetchCompositePoolDataDTO> & PageDTO;
+/** Fetch pools, optionally narrowed to one pair and paged. */
+type FetchPoolsDTO = Partial<FetchCompositePoolDataDTO> & PageDTO;
+/** Fetch all liquidity positions, optionally narrowed to a pool reference. */
+interface FetchLiquidityPositionsDTO extends PageDTO {
+    pool?: string | undefined;
+}
+
+/** Minimum tick supported by GalaChainDex. */
+declare const GC_MIN_TICK = -887272;
+/** Maximum tick supported by GalaChainDex. */
+declare const GC_MAX_TICK = 887272;
+/** Convert a tick to the corresponding square-root price. */
+declare function tickToSqrtPrice(tick: number): BigNumber;
+/** Return the greatest tick whose square-root price is no greater than the input. */
+declare function sqrtPriceToTick(sqrtPrice: BigNumber.Value): number;
+/** Return the greatest integer tick whose token1/token0 price is no greater than `price`. */
+declare function tickFromPrice(price: BigNumber.Value): number;
+/** Align a tick down to the nearest multiple of a positive spacing. */
+declare function alignTickDown(tick: number, spacing: number): number;
+/** Align a tick up to the nearest multiple of a positive spacing. */
+declare function alignTickUp(tick: number, spacing: number): number;
+/** Validate a position range against the global tick bounds and fee-tier spacing. */
+declare function assertTickRange(lower: number, upper: number, fee: FEE_TIER): void;
 
 declare function validateNumericAmount(amount: NumericAmount, parameterName: string, allowZero?: boolean): void;
 declare function validatePriceValues(spotPrice: NumericAmount, lowerPrice: NumericAmount, upperPrice: NumericAmount): void;
 declare function validateTokenDecimals(decimals: number, parameterName: string): void;
 declare function validateTickRange(tickLower: number, tickUpper: number): void;
-declare function validateFee(fee: number): void;
+declare function validateFee(fee: number): asserts fee is FEE_TIER;
 declare function validateTickSpacing(tickSpacing: number): void;
 declare function validateWalletAddress(address?: string): asserts address is string;
 
-export { Assets, Bundler, type BundlerRequest, type BundlerResponse, EventSocketClient, Events, FEE_TIER, GSwap, GSwapSDKError, type GalaChainSigner, type GalaChainTokenClassKey, GalaWalletSigner, type GetPoolDataRawResponse, type GetPoolDataResponse, type GetPositionResult, type GetQuoteResult, type GetUserAssetsResult, type GetUserPositionsResult, type NumericAmount, PendingTransaction, Pools, Positions, type Price, type PriceIn, PrivateKeySigner, type QuoteExactAmountRawResponse, type QuoteExactAmountResponse, Quoting, type SqrtPrice, type SqrtPriceIn, Swaps, TradeEventEmitter, type TransactionPendingResponse, type UserAsset, compareTokens, getTokenOrdering, parseTokenClassKey, stringifyTokenClassKey, validateFee, validateNumericAmount, validatePriceValues, validateTickRange, validateTickSpacing, validateTokenDecimals, validateWalletAddress };
+export { ALL_FEE_TIERS, type AddLiquidityDTO, type AddLiquidityEstimate, type AppliedTrade, Assets, type BrowserWalletProvider, BrowserWalletSigner, ChainGateway, type ChainGatewayOptions, type ChainSubmissionResult, type ChainSubmitOptions, type CollectPositionFeesDTO, type CompositePool, type ConfirmOptions, type CreatePoolDTO, FEE_TIER, type FetchCompositePoolDataDTO, type FetchCurrentTradingPricesDTO, type FetchLiquidityPositionsDTO, type FetchPoolsDTO, type FetchTokenTradingSymbolsDTO, GC_MAX_TICK, GC_MIN_TICK, GSWAP_ENVIRONMENTS, GSwap, type GSwapEnv, type GSwapEnvironmentConfig, type GSwapOptions, GSwapSDKError, type GalaChainSigner, type GalaChainTokenClassKey, type GalaWalletScheme, GalaWalletSigner, type NumericAmount, type PageDTO, type PoolInfo, type PoolListInfo, Pools, type Position, type PositionConfirmationResult, Positions, type Price, type PriceIn, PrivateKeySigner, type QuoteResult, Quoting, type RemoveLiquidityDTO, type RemoveLiquidityEstimate, type RequestTradeDTO, type Slot0, type SqrtPrice, type SqrtPriceIn, SubmittedTransaction, type SwapAmount, Swaps, Symbols, TICK_SPACING_BY_FEE, type TokenBalance, type TokenClassKey, type TokenRef, type TradeExecution, type TradingSymbol, type UserAsset, type UserAssetsResult, type V2PoolWriteBase, alignTickDown, alignTickUp, assertTickRange, compositeKeyOf, getObjectProperty, getStringProperty, orderSymbols, parseJson, parseTokenClassKey, readOrderedSymbols, sqrtPriceToTick, tickFromPrice, tickToSqrtPrice, validateFee, validateNumericAmount, validatePriceValues, validateTickRange, validateTickSpacing, validateTokenDecimals, validateWalletAddress };