Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/mystenlabs/sui/llms.txt

Use this file to discover all available pages before exploring further.

This page provides detailed examples of GraphQL queries for common use cases.

Object Queries

Get Object Details

Query an object with all available fields:
query GetObjectDetails($id: SuiAddress!) {
  object(address: $id) {
    address
    version
    digest
    storageRebate
    
    owner {
      __typename
      ... on AddressOwner {
        owner {
          address
        }
      }
      ... on Shared {
        initialSharedVersion
      }
      ... on Parent {
        parent {
          address
        }
      }
      ... on Immutable {
        __typename
      }
    }
    
    previousTransactionBlock {
      digest
    }
    
    asMoveObject {
      hasPublicTransfer
      contents {
        type {
          repr
          layout
          signature
        }
        json
        bcs
      }
    }
    
    display {
      key
      value
      error
    }
  }
}

Get Object History

query GetObjectHistory($id: SuiAddress!, $first: Int) {
  object(address: $id) {
    address
    version
    
    previousTransactionBlock {
      digest
      sender {
        address
      }
      effects {
        timestamp
      }
    }
    
    # Get historical versions
    asMoveObject {
      contents {
        type {
          repr
        }
      }
    }
  }
}

Get Dynamic Fields

query GetDynamicFields($parentId: SuiAddress!, $first: Int, $after: String) {
  object(address: $parentId) {
    dynamicFields(first: $first, after: $after) {
      nodes {
        name {
          type {
            repr
          }
          json
          bcs
        }
        value {
          ... on MoveObject {
            contents {
              type {
                repr
              }
              json
            }
          }
          ... on MoveValue {
            type {
              repr
            }
            json
            bcs
          }
        }
      }
      pageInfo {
        hasNextPage
        endCursor
      }
    }
  }
}

Address Queries

Get Address Information

query GetAddress($address: SuiAddress!) {
  address(address: $address) {
    address
    
    balance(type: "0x2::sui::SUI") {
      coinType {
        repr
      }
      coinObjectCount
      totalBalance
    }
    
    objects(first: 10) {
      nodes {
        address
        version
        asMoveObject {
          contents {
            type {
              repr
            }
          }
        }
      }
    }
    
    transactionBlocks(first: 10) {
      nodes {
        digest
        effects {
          timestamp
          status
        }
      }
    }
  }
}

Get All Balances

query GetAllBalances($address: SuiAddress!) {
  address(address: $address) {
    balances {
      nodes {
        coinType {
          repr
        }
        coinObjectCount
        totalBalance
      }
    }
  }
}

Get Coins by Type

query GetCoins(
  $address: SuiAddress!
  $type: String
  $first: Int
  $after: String
) {
  address(address: $address) {
    coins(type: $type, first: $first, after: $after) {
      nodes {
        address
        version
        coinBalance
        asCoin {
          coinBalance
        }
      }
      pageInfo {
        hasNextPage
        endCursor
      }
    }
  }
}

Transaction Queries

Get Transaction Block

query GetTransactionBlock($digest: String!) {
  transactionBlock(digest: $digest) {
    digest
    
    sender {
      address
    }
    
    gasInput {
      gasSponsor {
        address
      }
      gasPrice
      gasBudget
      gasPayment {
        nodes {
          address
        }
      }
    }
    
    kind {
      __typename
      ... on ProgrammableTransactionBlock {
        inputs {
          nodes {
            __typename
          }
        }
        transactions {
          nodes {
            __typename
          }
        }
      }
    }
    
    effects {
      status
      errors
      timestamp
      checkpoint {
        sequenceNumber
      }
      
      gasEffects {
        gasObject {
          address
        }
        gasSummary {
          computationCost
          storageCost
          storageRebate
          nonRefundableStorageFee
        }
      }
      
      objectChanges {
        nodes {
          address
          idCreated
          idDeleted
          outputState {
            address
            version
          }
        }
      }
      
      balanceChanges {
        nodes {
          owner {
            address
          }
          amount
          coinType {
            repr
          }
        }
      }
    }
    
    events {
      nodes {
        sendingModule {
          package {
            address
          }
          name
        }
        type {
          repr
        }
        sender {
          address
        }
        json
        bcs
      }
    }
  }
}

Query Transaction Blocks

query QueryTransactionBlocks(
  $filter: TransactionBlockFilter
  $first: Int
  $after: String
) {
  transactionBlocks(filter: $filter, first: $first, after: $after) {
    nodes {
      digest
      sender {
        address
      }
      effects {
        status
        timestamp
        gasEffects {
          gasSummary {
            computationCost
            storageCost
          }
        }
      }
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}
Filter by sender:
{
  "filter": {
    "signAddress": "0x..."
  },
  "first": 50
}
Filter by recipient:
{
  "filter": {
    "recvAddress": "0x..."
  },
  "first": 50
}

Event Queries

Query Events

query QueryEvents($filter: EventFilter, $first: Int, $after: String) {
  events(filter: $filter, first: $first, after: $after) {
    nodes {
      sendingModule {
        package {
          address
        }
        name
      }
      type {
        repr
      }
      sender {
        address
      }
      timestamp
      json
      bcs
      
      transactionBlock {
        digest
      }
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}
Filter by event type:
{
  "filter": {
    "eventType": "0x2::coin::CoinCreated<0x2::sui::SUI>"
  },
  "first": 20
}
Filter by sender:
{
  "filter": {
    "sender": "0x..."
  },
  "first": 20
}
Filter by package:
{
  "filter": {
    "emittingPackage": "0x2"
  },
  "first": 20
}

Checkpoint Queries

Get Checkpoint

query GetCheckpoint($id: UInt53!) {
  checkpoint(id: { sequenceNumber: $id }) {
    sequenceNumber
    timestamp
    networkTotalTransactions
    previousCheckpointDigest
    
    epoch {
      epochId
      referenceGasPrice
    }
    
    transactionBlocks(first: 10) {
      nodes {
        digest
        effects {
          status
        }
      }
    }
  }
}

Query Checkpoints

query QueryCheckpoints($first: Int, $after: String) {
  checkpoints(first: $first, after: $after) {
    nodes {
      sequenceNumber
      timestamp
      networkTotalTransactions
      epoch {
        epochId
      }
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

Epoch Queries

Get Current Epoch

query GetCurrentEpoch {
  epoch {
    epochId
    referenceGasPrice
    startTimestamp
    endTimestamp
    
    validatorSet {
      totalStake
      pendingActiveValidatorsSize
      
      activeValidators(first: 100) {
        nodes {
          name
          description
          imageUrl
          
          address {
            address
          }
          
          votingPower
          stakingPoolActivationEpoch
          stakingPoolSuiBalance
          rewardsPool
          poolTokenBalance
          pendingStake
          pendingTotalSuiWithdraw
          
          apy
        }
      }
    }
  }
}

Get Epoch by ID

query GetEpoch($id: UInt53!) {
  epoch(id: $id) {
    epochId
    referenceGasPrice
    startTimestamp
    endTimestamp
    totalCheckpoints
    totalTransactions
    totalGasFees
    totalStakeRewards
    
    validatorSet {
      totalStake
    }
  }
}

Package Queries

Get Package

query GetPackage($id: SuiAddress!) {
  object(address: $id) {
    address
    version
    
    asMovePackage {
      modules {
        nodes {
          name
          
          fileFormatVersion
          
          functions {
            nodes {
              name
              visibility
              isEntry
              
              parameters {
                repr
              }
              return {
                repr
              }
            }
          }
          
          structs {
            nodes {
              name
              abilities
              
              typeParameters {
                constraints
              }
              
              fields {
                name
                type {
                  repr
                }
              }
            }
          }
        }
      }
    }
  }
}

Combining Queries

Get Complete Address Profile

query GetAddressProfile($address: SuiAddress!) {
  address(address: $address) {
    address
    
    # Balances
    balances(first: 100) {
      nodes {
        coinType {
          repr
        }
        totalBalance
      }
    }
    
    # Recent transactions
    transactionBlocks(first: 10) {
      nodes {
        digest
        effects {
          timestamp
          status
        }
      }
    }
    
    # Owned objects
    objects(first: 20) {
      nodes {
        address
        asMoveObject {
          contents {
            type {
              repr
            }
          }
        }
      }
    }
  }
}

Build docs developers (and LLMs) love