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

# Get user wallet activity (deposits, withdrawals, transfers)

> Immutable log of on-chain events that affected the wallet's vault position. Each row is a frozen-in-time record; rows never mutate after emission. 

`?vault_id=` narrows to one vault; omitted = activity across every vault the wallet has touched. Each row echoes its `vault_id` so wallet-wide consumers can distinguish per-vault activity. 

Async deposit/redeem lifecycles emit multiple rows (one at request time with `status=pending`, a later one with `status=settled` or `refunded`). Consumers correlate them via `request_hash` to follow a single action across rows. Sync flows emit one row directly in the settled state. 

Pagination is cursor-only. Default order is `desc` (newest first). Default page size 100, max 1000.



## OpenAPI

````yaml GET /v1/users/{wallet_address}/activity
openapi: 3.1.0
info:
  title: Gauntlet API
  description: Gauntlet vault data and user positions API.
  contact:
    name: Gauntlet
    url: https://gauntlet.xyz
  license:
    name: ''
  version: 1.0.0
servers:
  - url: https://api.gauntlet.xyz
    description: Production
security: []
tags:
  - name: System
    description: Health checks and Prometheus metrics
  - name: Vaults
    description: Vault listings, details, metrics, timeseries
  - name: Users
    description: Per-wallet position state and timeseries
paths:
  /v1/users/{wallet_address}/activity:
    get:
      tags:
        - Users
      summary: Get user wallet activity (deposits, withdrawals, transfers)
      description: >-
        Immutable log of on-chain events that affected the wallet's vault
        position. Each row is a frozen-in-time record; rows never mutate after
        emission. 


        `?vault_id=` narrows to one vault; omitted = activity across every vault
        the wallet has touched. Each row echoes its `vault_id` so wallet-wide
        consumers can distinguish per-vault activity. 


        Async deposit/redeem lifecycles emit multiple rows (one at request time
        with `status=pending`, a later one with `status=settled` or `refunded`).
        Consumers correlate them via `request_hash` to follow a single action
        across rows. Sync flows emit one row directly in the settled state. 


        Pagination is cursor-only. Default order is `desc` (newest first).
        Default page size 100, max 1000.
      operationId: get_user_activity
      parameters:
        - name: wallet_address
          in: path
          description: Ethereum wallet address
          required: true
          schema:
            type: string
        - name: vault_id
          in: query
          description: >-
            CAIP-10 vault identifier. Optional — omit for wallet-wide activity
            across every vault the wallet has touched.
          required: false
          schema:
            type: string
        - name: next
          in: query
          description: Opaque cursor from previous `meta.next_cursor`.
          required: false
          schema:
            type: string
        - name: limit
          in: query
          description: Page size (1–1000, default 100).
          required: false
          schema:
            type: integer
            format: int64
        - name: order
          in: query
          description: 'Sort direction: `desc` (default) or `asc`.'
          required: false
          schema:
            type: string
      responses:
        '200':
          description: User wallet activity
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UserActivityResponse'
        '401':
          description: Missing or invalid auth
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '422':
          description: Invalid cursor
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    UserActivityResponse:
      type: object
      required:
        - meta
        - data
      properties:
        data:
          type: array
          items:
            $ref: '#/components/schemas/UserActivity'
        meta:
          $ref: '#/components/schemas/TimeseriesMeta'
    ErrorResponse:
      type: object
      description: Standard error response envelope returned on 4xx/5xx
      required:
        - error
      properties:
        error:
          $ref: '#/components/schemas/ErrorBody'
    UserActivity:
      type: object
      description: |-
        One immutable entry in the wallet's activity log.

        Each row represents a single on-chain event that affected the
        wallet's vault position. Async deposit/redeem lifecycles emit
        multiple rows (one per lifecycle event — request, solve, refund);
        each row is frozen at emission time and never mutates. To follow
        an async action across rows, correlate via `request_hash`.
      required:
        - block_timestamp
        - type
        - vault_id
        - tx_hash
        - block_number
        - block_hash
        - shares_delta
        - assets_delta
      properties:
        assets_delta:
          $ref: '#/components/schemas/AssetDelta'
          description: |-
            Signed asset delta in the row's asset-token units, using a
            deposit-ledger sign convention (NOT wallet-flow direction):
            - Positive = a deposit-direction action (`deposit`,
              `deposit_pending`, `transfer_in`).
            - Negative = a withdraw-direction action (`withdraw`,
              `deposit_refunded`, `transfer_out`).
            - `0` = no asset movement at this event
              (`deposit` on Aera async solve, `withdraw_pending`,
              `withdraw_refunded`).

            Note: under this convention `deposit_refunded` is negative
            (a deposit was unwound) even though tokens flow back INTO the
            wallet, and async `withdraw` (Aera redeem_solved) is negative
            even though tokens flow back INTO the wallet — the sign tracks
            the deposit-ledger direction, not the user's wallet balance.

            Summing across rows for a single async lifecycle gives the net
            signed asset movement of that lifecycle (no double-counting).
            `assets_delta.token` identifies the asset token when known. Emitted
            as a struct (`{ native: "...", token: { address, symbol } }`) so
            derived denominations (e.g. usd) can be added later without breaking
            the response shape.
        block_hash:
          type: string
          description: |-
            Block hash — 1:1 identifier for the block this event was mined
            in. Consumers needing to detect reorgs should key off this rather
            than `block_number` (multiple blocks can share a number across a
            reorg).
        block_number:
          type: integer
          format: int64
          description: |-
            Block number — kept alongside `block_timestamp` for on-chain
            reconciliation / explorer linking.
        block_timestamp:
          type: integer
          format: int64
          description: Unix seconds, block time (`block.timestamp` from the chain).
        request_hash:
          type:
            - string
            - 'null'
          description: |-
            Aera async-flow correlation hash. Links a `*_pending` row to
            its later terminal row (bare `deposit`/`withdraw` for settled,
            or `*_refunded`) of the same lifecycle. Emitted only on rows
            that participate in an async flow; omitted on sync rows and on
            secondary-market transfers.
        shares_delta:
          type: string
          description: |-
            Signed share delta in 18-decimal units, reported at the event
            where the shares actually moved. Conventions by row type:
            - `deposit` — positive (shares minted to the wallet).
            - `deposit_pending` / `deposit_refunded` — `0` (no share
              movement; deposit requests touch assets only).
            - `withdraw_pending` — negative for Aera async redeems (shares
              leave the wallet at request time, escrowed to the Provisioner).
            - `withdraw` — negative for sync (Morpho) withdraws (shares
              burn on the same row that pays out assets); `0` for Aera
              async redeems (the share movement is recorded on the paired
              `withdraw_pending` row).
            - `withdraw_refunded` — positive (escrowed shares return).
            - `transfer_in` — positive; `transfer_out` — negative.

            Summing across rows for a single async lifecycle gives the net
            share movement of that lifecycle — there is no double-counting.
        tx_hash:
          type: string
          description: Transaction hash of the on-chain event.
        type:
          type: string
          description: >-
            What happened. One of:

            - `deposit` — settled deposit (sync vault flow or async terminal
            solve).

            - `deposit_pending` — async deposit request submitted; awaiting
            solver.

            - `deposit_refunded` — async deposit returned without settling;
            assets bounced back.

            - `withdraw` — settled withdrawal (sync vault flow or async terminal
            solve).

            - `withdraw_pending` — async redeem request submitted; awaiting
            solver.

            - `withdraw_refunded` — async redeem returned without settling;
            shares bounced back.

            - `transfer_in` — vault shares received from another EOA (secondary
            market).

            - `transfer_out` — vault shares sent to another EOA.


            Async deposit/redeem lifecycles emit two rows (a `*_pending` at

            request time, then a separate terminal row — bare `deposit` or

            `_refunded` — at solve time). Rows are immutable; the pending

            row never mutates. Correlate the pair via `request_hash`.
        vault_id:
          type: string
          description: CAIP-10 vault identifier this row belongs to. Always emitted.
    TimeseriesMeta:
      type: object
      required:
        - request_id
        - refreshed_at
        - count
        - limit
      properties:
        count:
          type: integer
          format: int64
          description: Number of points in this response.
        end:
          type:
            - string
            - 'null'
          format: date-time
        limit:
          type: integer
          format: int64
          description: Page-size cap actually applied.
        next_cursor:
          type:
            - string
            - 'null'
          description: Set when more pages exist; pass back as `?next=`.
        refreshed_at:
          type: string
          format: date-time
        request_id:
          type: string
        start:
          type:
            - string
            - 'null'
          format: date-time
          description: Window bounds the response covers (echoes the request when set).
    ErrorBody:
      type: object
      required:
        - code
        - message
      properties:
        code:
          type: string
          description: Machine-readable error code (e.g. `NOT_FOUND`, `UNAUTHORIZED`)
        details: {}
        message:
          type: string
          description: Human-readable error message
    AssetDelta:
      type: object
      description: |-
        Asset-delta envelope on user activity rows. `native` is always present;
        `token` is present when the indexer knows the row's asset token.
        The struct shape is kept stable so derived denominations (usd,
        numeraire token) can be added later without breaking integrators.
      required:
        - native
      properties:
        native:
          type: string
        token:
          oneOf:
            - type: 'null'
            - $ref: '#/components/schemas/TokenRef'
    TokenRef:
      type: object
      required:
        - address
      properties:
        address:
          type: string
        symbol:
          type:
            - string
            - 'null'

````