> ## Documentation Index
> Fetch the complete documentation index at: https://shield.fi/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Get rebalance state

> Read pool state and tick data for a position rebalance.



## OpenAPI

````yaml openapi.json GET /pools/{key}/rebalance-state
openapi: 3.1.0
info:
  title: Shield Swap API
  description: >-
    Shield Swap REST API for pools, positions, routes, quotes, and settlement
    status. Transactions target the configured shield_swap program and
    `token_registry.aleo`.


    ## Numeric wire format


    Exact financial values are JSON strings, not JSON numbers. Unsigned decimal
    inputs use ASCII digits and an optional `.` fraction, for example
    `"1234.50"`; base-unit integers use ASCII digits only. Grouping separators,
    localized decimal commas, signs, exponent notation, whitespace, Unicode
    digits, and redundant leading zeros are not accepted for those inputs.
    Signed response metrics may include a leading `-`. Clients should localize
    only for display and convert user input back to this canonical form before
    sending it.


    ## Authentication


    Most endpoints require credentials from a wallet that has accepted the
    current terms of use (recorded by `/auth/verify`). Public routes are
    `/health`, `/ready`, `/metrics`, `POST /auth/challenge`, `POST
    /auth/verify`, `/protocol/state`, `/compliance*`, `GET /tokens`, `GET
    /pools`, `GET /pools/stats`, `GET /pools/{key}`, `GET /pools/{key}/ohlcv`,
    `GET /pools/{key}/liquidity-distribution`, `GET /pools/{key}/trades`, `GET
    /pools/{key}/stats`, `GET /pools/{key}/oracle`, `GET /explore/*`, and
    `/geckoterminal/*`.


    Browsers use HTTP-only session cookies issued by `/auth/verify`. Access
    sessions last 15 minutes and are renewed through `/auth/refresh`.
    Programmatic clients use a long-lived token from `POST /api-tokens` as
    `Authorization: Bearer ss_…`. API tokens cover data and trading routes and
    can request WebSocket tickets. Token management, code redemption, and admin
    routes require a browser session.


    ## WebSocket feed


    The live feed runs on the separate websocket gateway at `GET /ws`.


    1. Request a ticket from `GET /auth/ws-ticket` using a browser session or
    API token.

    2. Open the socket and send the `authenticate` frame within 5 seconds.

    3. Subscribe to each required room.

    4. Before the 60-second ticket expires, request a new ticket and send
    another `authenticate` frame.


    The socket accepts WebSocket tickets only. Session JWTs and API tokens are
    rejected.


    ```json

    {"action": "authenticate", "token": "<ticket from /auth/ws-ticket>"}

    {"action": "subscribe", "room": "trades:<pool_key>"}

    {"action": "unsubscribe", "room": "<room>"}

    {"action": "synchronize"}

    ```


    After reconnecting, resend subscriptions and then send `synchronize`. The
    gateway replies `{"control": "synchronized"}` when those subscriptions are
    active. Refetch any REST data that depends on the stream after receiving the
    reply.


    Each connection allows 32 rooms, 240 client frames per minute, and 2 KB per
    frame. A client may subscribe only to the balance room for its ticket
    subject.


    Rooms:

    - `pool_launches`: newly created pools

    - `pool_stats:<pool_key>`: price & liquidity updates

    - `ohlcv:<pool_key>`: candle updates

    - `trades:<pool_key>`: swaps / mints / burns

    - `balances:<address>`: balance-change hints for an address


    - `protocol_config`: revisioned protocol-configuration invalidations


    Server messages are either events (`{"type": <event>, "data": { … }}`) or
    control messages (`{"control": <value>}`). Event types are `PoolLaunch`,
    `PoolStats`, `Ohlcv`, `Trade`, `BalanceChange`, and `ProtocolConfigChanged`.
    Its data contains `revision`, `observed_block`, and the changed
    `scope`/`key` pairs. Financial fields use the numeric format described
    above.


    Treat `ProtocolConfigChanged` as an invalidation, not as the new
    configuration. Fetch `GET /protocol/state?minimum_revision=<revision>`;
    retry a `503 protocol_revision_pending` after the advertised `Retry-After`;
    and discard or requote any `/route` result whose `protocol_revision` is
    older. Subscribe to `pool_stats:<pool_key>` separately when live price and
    liquidity updates matter.


    The gateway currently sends `synchronized` and `resync_required` controls.
    `resync_required` means the stream may have missed updates, so refetch
    affected data over REST. Ignore unknown control values.


    Event delivery is at most once. Treat REST as the source of truth. During a
    deployment the gateway may close the socket with code 1012 (service
    restart); reconnect and restore the subscriptions.
  contact:
    name: Shield Swap
  license:
    name: ''
  version: 0.1.0
servers:
  - url: https://api.swap.shield.fi
    description: Shield Swap mainnet API
security: []
tags:
  - name: auth
    description: Wallet sign-in, sessions, logout, and WebSocket tickets
  - name: api-tokens
    description: >-
      Long-lived API tokens for programmatic access; send as `Authorization:
      Bearer ss_…` on any gated endpoint
  - name: referral
    description: >-
      Referral code redemption, attribution, activity logging, and
      administration
  - name: pools
    description: Pool metadata, stats, trades, OHLCV
  - name: positions
    description: LP positions
  - name: tokens
    description: Token registry
  - name: explore
    description: Market-wide token, pool, and transaction discovery
  - name: compliance
    description: Token/pair allowlist, pause, and pool-creation gating state
  - name: protocol
    description: Fee tiers and tick spacings
  - name: route
    description: Swap routing
  - name: unclaimed
    description: Pending swap outputs and position fees
  - name: geckoterminal
    description: Public GeckoTerminal integration data
  - name: airdrop
    description: >-
      Faucet: sends ALEO, USDCx, and ETH to a user address as records, once per
      address per 15 min
  - name: debug
    description: On-chain introspection helpers
paths:
  /pools/{key}/rebalance-state:
    get:
      tags:
        - pools
      summary: Get rebalance state
      operationId: get_rebalance_state
      parameters:
        - name: key
          in: path
          description: Pool key
          required: true
          schema:
            type: string
        - name: tick_lower
          in: query
          description: Current lower tick
          required: true
          schema:
            type: integer
            format: int32
        - name: tick_upper
          in: query
          description: Current upper tick
          required: true
          schema:
            type: integer
            format: int32
        - name: old_liquidity
          in: query
          description: Current position liquidity
          required: true
          schema:
            type: string
        - name: mint_tick_lower
          in: query
          description: New lower tick
          required: true
          schema:
            type: integer
            format: int32
        - name: mint_tick_upper
          in: query
          description: New upper tick
          required: true
          schema:
            type: integer
            format: int32
      responses:
        '200':
          description: Consistent pool state and mint hints
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RebalanceStateResponseDoc'
        '400':
          description: Invalid position or tick range
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponseDoc'
        '404':
          description: Pool not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponseDoc'
        '503':
          description: Rebalance state is unavailable
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponseDoc'
      security:
        - bearer_auth: []
components:
  schemas:
    RebalanceStateResponseDoc:
      type: object
      required:
        - data
      properties:
        data:
          $ref: '#/components/schemas/RebalanceState'
    ErrorResponseDoc:
      type: object
      required:
        - error
      properties:
        code:
          type:
            - string
            - 'null'
        error:
          type: string
        ref:
          type:
            - string
            - 'null'
    RebalanceState:
      type: object
      required:
        - observed_block
        - sqrt_price_x_128
        - tick
        - tick_spacing
        - fee_growth_global0_x_128
        - fee_growth_global1_x_128
        - lower
        - upper
        - tick_lower_hint
        - tick_upper_hint
      properties:
        fee_growth_global0_x_128:
          type: string
        fee_growth_global1_x_128:
          type: string
        lower:
          $ref: '#/components/schemas/RebalanceTickState'
        observed_block:
          type: integer
          format: int32
          minimum: 0
        sqrt_price_x_128:
          type: string
        tick:
          type: integer
          format: int32
        tick_lower_hint:
          type: integer
          format: int32
        tick_spacing:
          type: integer
          format: int32
          minimum: 0
        tick_upper_hint:
          type: integer
          format: int32
        upper:
          $ref: '#/components/schemas/RebalanceTickState'
    RebalanceTickState:
      type: object
      required:
        - tick
        - fee_growth_outside0_x_128
        - fee_growth_outside1_x_128
      properties:
        fee_growth_outside0_x_128:
          type: string
        fee_growth_outside1_x_128:
          type: string
        tick:
          type: integer
          format: int32
  securitySchemes:
    bearer_auth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: >-
        Session JWT (browsers receive it as an httpOnly cookie from `POST
        /auth/verify`; 15 min, silently renewed via `POST /auth/refresh`), or a
        long-lived API token (`ss_…`) minted at `POST /api-tokens`. API tokens
        work on data and trading endpoints and can request WebSocket tickets;
        token management and admin endpoints accept session JWTs only.

````