Skip to content
/
tokens

GraphQL Overview

Download GraphQL schema
index.graphql

Queries

Overview

transaction

(...args)
Transaction

Retrieve a specific transaction by its request key, with optional additional filters.

While a requestKey uniquely identifies a transaction at the Pact level, the same request key can appear in multiple blocks due to chain reorganization or orphaned blocks. Because of this, retrieving a transaction by requestKey alone may return more than one match over the chain’s history.

To disambiguate results, you can provide the blockHash parameter.

  • A specific requestKey combined with a blockHash will always return at most one transaction, since that pair is unique.
  • Among those combinations, only one transaction will belong to a canonical block (i.e., part of the main chain).
  • All other matches (with the same requestKey but different blockHash values) represent transactions included in orphaned blocks — blocks that were mined but later discarded due to chain reorganization.

The minimumDepth parameter can also be used to limit results to transactions in blocks that are at least a certain depth from the chain tip, helping ensure finality.

This query is typically used when you need to verify the canonical inclusion of a transaction or inspect all occurrences of a given request key across the chain’s history.

Arguments

blockHash
String

The hash of the block that contains the transaction. When provided along with requestKey, guarantees a unique match. Only one such combination will correspond to a canonical block; others (if any) are from orphaned blocks.

minimumDepth
Int

The minimum depth (distance from the chain tip) the block containing the transaction must have. Useful to filter for transactions in finalized blocks.

requestKey
String!,non-nullrequired

The unique request key of the transaction. Note: The same request key can appear in multiple blocks over time due to chain reorganizations.

Return type

Transaction
id
ID!,non-null

Globally unique identifier for this transaction node.

cmd
TransactionCommand!,non-null

The original signed transaction command submitted to the network. Includes metadata, payload, signers, and network information.

hash
String!,non-null

The unique hash of the transaction. This value is derived from the signed command and serves as the canonical identifier for the transaction on-chain.

result
TransactionInfo!,non-null

The result of executing the transaction. Includes information such as success/failure status, events, continuation data, and any state changes triggered by execution.

sigs
[TransactionSignature!]!,non-null

The list of signatures associated with the transaction. Each signature proves authorization from a required signer and is used to validate that the transaction was properly authorized before execution.

Query sample
query transaction(
  $blockHash: String
  $minimumDepth: Int
  $requestKey: String!
) {
  transaction(
    blockHash: $blockHash
    minimumDepth: $minimumDepth
    requestKey: $requestKey
  ) {
    id 
    cmd {
      __typename
      # ...TransactionCommandFragment
    }
    hash 
    result {
      __typename
      # ...TransactionMempoolInfoFragment
    }
    sigs {
      __typename
      # ...TransactionSignatureFragment
    }
  }
}
Variables
{
  "blockHash": "Example String",
  "minimumDepth": 40,
  "requestKey": "Example String"
}
Response sample
{
  "data": {
    "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
    "cmd": {
      "__typename": "TransactionCommand"
    },
    "hash": "Example String",
    "result": {
      "__typename": "TransactionMempoolInfo"
    },
    "sigs": [
      {
        "__typename": "TransactionSignature"
      }
    ]
  }
}

transactions

(...args)
QueryTransactionsConnection!,non-null

Retrieve a paginated list of transactions with flexible filtering options.

This query allows you to search and explore transactions on the Kadena blockchain based on a wide range of parameters — including account involvement, block location, chain, request key, height range, and coinbase status. It is commonly used by block explorers, wallets, and analytics tools to inspect on-chain activity and trace transaction history.

You can combine multiple filters to refine results. For example:

  • Filter by accountName to find transactions sent from or received by a specific account.
  • Use blockHash to retrieve all transactions included in a particular block.
  • Combine chainId, minHeight, and maxHeight to query transactions over a block range on a specific chain.
  • Provide a requestKey to search for a particular transaction.
  • Set isCoinbase to true to return only mining reward transactions.
  • Use minimumDepth to ensure results include only transactions in finalized blocks.

Arguments

accountName
String

Filter transactions involving a specific account name. Can match either the sender or recipient. Example: "k:abcdef123456...".

blockHash
String

Retrieve only transactions included in the block with this hash. Useful when inspecting all transactions within a specific block.

chainId
String

Restrict results to a specific chain ID.

fungibleName
String

Filter transactions by the fungible token module involved. Example: "coin".

maxHeight
Int

The maximum block height to include in results. Transactions in blocks above this height will be excluded.

minHeight
Int

The minimum block height to include in results. Transactions in blocks below this height will be excluded.

minimumDepth
Int

Minimum depth (distance from the chain tip) of the block containing the transaction. Use this to filter for transactions in finalized blocks.

requestKey
String

Filter by the unique request key of the transaction. Useful when looking up a specific transaction by its identifier.

isCoinbase
Boolean

When true, returns only coinbase transactions — block reward transactions created during mining.

after
String

Cursor to start paginating after a specific result. Used for forward pagination.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

first
Int

Maximum number of transactions to return when paginating forward.

last
Int

Maximum number of transactions to return when paginating backward.

Return type

QueryTransactionsConnection!
edges
[QueryTransactionsConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query transactions(
  $accountName: String
  $blockHash: String
  $chainId: String
  $fungibleName: String
  $maxHeight: Int
  $minHeight: Int
  $minimumDepth: Int
  $requestKey: String
  $isCoinbase: Boolean
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  transactions(
    accountName: $accountName
    blockHash: $blockHash
    chainId: $chainId
    fungibleName: $fungibleName
    maxHeight: $maxHeight
    minHeight: $minHeight
    minimumDepth: $minimumDepth
    requestKey: $requestKey
    isCoinbase: $isCoinbase
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        id 
        cmd {
          __typename
          # ...TransactionCommandFragment
        }
        hash 
        result {
          __typename
          # ...TransactionMempoolInfoFragment
        }
        sigs {
          __typename
          # ...TransactionSignatureFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "accountName": "Example String",
  "blockHash": "Example String",
  "chainId": "Example String",
  "fungibleName": "Example String",
  "maxHeight": 40,
  "minHeight": 40,
  "minimumDepth": 40,
  "requestKey": "Example String",
  "isCoinbase": true,
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "cmd": {
            "__typename": "TransactionCommand"
          },
          "hash": "Example String",
          "result": {
            "__typename": "TransactionMempoolInfo"
          },
          "sigs": [
            {
              "__typename": "TransactionSignature"
            }
          ]
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

transactionsByPublicKey

(...args)
QueryTransactionsByPublicKeyConnection!,non-null

Retrieve a paginated list of transactions associated with a specific public key.

This query returns all transactions that involve accounts controlled by the given publicKey. Because a single public key can control multiple accounts — including accounts on different chains or created by contracts — this query is a convenient way to fetch all related transactions without needing to know each account name individually.

It is commonly used by wallets, explorers, and analytics tools to display a user’s complete on-chain activity, track transactions linked to a particular key, or audit key usage across the network.

Arguments

publicKey
String!,non-nullrequired

The public key to filter transactions by. Example: "abcdef1234567890...".

after
String

Cursor to start paginating after a specific result. Used for forward pagination.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

first
Int

Maximum number of transactions to return when paginating forward.

last
Int

Maximum number of transactions to return when paginating backward.

Return type

QueryTransactionsByPublicKeyConnection!
edges
[QueryTransactionsByPublicKeyConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query transactionsByPublicKey(
  $publicKey: String!
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  transactionsByPublicKey(
    publicKey: $publicKey
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        id 
        cmd {
          __typename
          # ...TransactionCommandFragment
        }
        hash 
        result {
          __typename
          # ...TransactionMempoolInfoFragment
        }
        sigs {
          __typename
          # ...TransactionSignatureFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "publicKey": "Example String",
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "cmd": {
            "__typename": "TransactionCommand"
          },
          "hash": "Example String",
          "result": {
            "__typename": "TransactionMempoolInfo"
          },
          "sigs": [
            {
              "__typename": "TransactionSignature"
            }
          ]
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

transactionsByPactCode

(...args)
QueryTransactionsByPactCodeConnection!,non-null

Retrieve a paginated list of transactions that executed a specific Pact code.

This query allows you to search for transactions based on the exact Pact code they executed. It’s particularly useful when you want to trace all interactions with a specific contract function, audit how and when a certain piece of code was used on-chain, or analyze usage patterns of a given module.

Because the match is performed on the full Pact code string, results will only include transactions where the executed code exactly matches the provided pactCode. This query is commonly used by block explorers, indexers, and analytics tools to track contract usage and behavior over time.

Arguments

pactCode
String!,non-nullrequired

The exact Pact code to filter transactions by. Only transactions that executed this code will be returned. Example: "(coin.transfer \\\"k:abc...\\\" \\\"k:def...\\\" 1.0)"

after
String

Cursor to start paginating after a specific result. Used for forward pagination.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

first
Int

Maximum number of transactions to return when paginating forward.

last
Int

Maximum number of transactions to return when paginating backward.

Return type

QueryTransactionsByPactCodeConnection!
edges
[QueryTransactionsByPactCodeConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
Query sample
query transactionsByPactCode(
  $pactCode: String!
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  transactionsByPactCode(
    pactCode: $pactCode
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        requestKey 
        height 
        chainId 
        canonical 
        creationTime 
        badResult 
        sender 
        gas 
        gasLimit 
        gasPrice 
        code 
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
  }
}
Variables
{
  "pactCode": "Example String",
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "requestKey": "Example String",
          "height": "Example Custom Scalar",
          "chainId": "Example Custom Scalar",
          "canonical": true,
          "creationTime": "Example Custom Scalar",
          "badResult": "Example String",
          "sender": "Example String",
          "gas": "Example String",
          "gasLimit": "Example String",
          "gasPrice": "Example String",
          "code": "Example String"
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    }
  }
}

transfers

(...args)
QueryTransfersConnection!,non-null

Retrieve a paginated list of token transfers with flexible filtering options.

This query returns on-chain transfer events — movements of tokens from one account to another — and supports filtering by block, transaction, account, chain, token type, and more. It is commonly used by explorers, wallets, and analytics tools to display account activity, track token movements, and analyze on-chain transfers.

Transfers can represent either fungible tokens (like coin for KDA) or non-fungible tokens (NFTs), depending on the isNFT flag.

You can combine multiple filters to narrow down results. For example:

  • Filter by accountName to retrieve all incoming and outgoing transfers for a specific account.
  • Use blockHash to get all transfers included in a particular block.
  • Combine chainId and fungibleName to target transfers of a specific token on a specific chain.
  • Provide a requestKey to return transfers associated with a specific transaction.
  • Set isNFT: true to return only NFT transfers.

⚠️ Important: fungibleName cannot be used when isNFT is set to true. NFT transfers do not belong to a fungible token module, so this parameter must be omitted in that case.

Arguments

blockHash
String

Retrieve only transfers included in the block with this hash. Useful when analyzing all token movements in a specific block.

requestKey
String

Filter by the unique request key of the transaction that emitted the transfer.

accountName
String

Filter transfers involving a specific account. Matches both senders and recipients.

chainId
String

Restrict results to transfers that occurred on a specific chain.

fungibleName
String

Filter transfers by the fungible token module involved. Example: "coin". ⚠️ Cannot be used if isNFT is set to true.

isNFT
Boolean

Set to true to retrieve only non-fungible token (NFT) transfers. When false or omitted, only fungible token transfers are returned.

after
String

Cursor to start paginating after a specific result. Used for forward pagination.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

first
Int

Maximum number of transfers to return when paginating forward.

last
Int

Maximum number of transfers to return when paginating backward.

Return type

QueryTransfersConnection!
edges
[QueryTransfersConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query transfers(
  $blockHash: String
  $requestKey: String
  $accountName: String
  $chainId: String
  $fungibleName: String
  $isNFT: Boolean
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  transfers(
    blockHash: $blockHash
    requestKey: $requestKey
    accountName: $accountName
    chainId: $chainId
    fungibleName: $fungibleName
    isNFT: $isNFT
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        amount 
        block {
          __typename
          # ...BlockFragment
        }
        blockHash 
        chainId 
        creationTime 
        crossChainTransfer {
          __typename
          # ...TransferFragment
        }
        height 
        id 
        moduleHash 
        moduleName 
        orderIndex 
        receiverAccount 
        requestKey 
        senderAccount 
        tokenId 
        transaction {
          __typename
          # ...TransactionFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "blockHash": "Example String",
  "requestKey": "Example String",
  "accountName": "Example String",
  "chainId": "Example String",
  "fungibleName": "Example String",
  "isNFT": true,
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "amount": "Example Custom Scalar",
          "block": {
            "__typename": "Block"
          },
          "blockHash": "Example String",
          "chainId": "Example Custom Scalar",
          "creationTime": "Example Custom Scalar",
          "crossChainTransfer": {
            "__typename": "Transfer"
          },
          "height": "Example Custom Scalar",
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "moduleHash": "Example String",
          "moduleName": "Example String",
          "orderIndex": "Example Custom Scalar",
          "receiverAccount": "Example String",
          "requestKey": "Example String",
          "senderAccount": "Example String",
          "tokenId": "Example String",
          "transaction": {
            "__typename": "Transaction"
          }
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

tokens

(...args)
QueryTokensConnection!,non-null

Retrieve a paginated list of all tokens deployed on the Kadena network, excluding the native coin token.

This query returns both fungible tokens and non-fungible token contracts (currently limited to marmalade and marmalade-v2), providing basic metadata such as the token’s name, deployment chain, and contract address.

It is commonly used by explorers, indexers, and dApps to discover tokens deployed on-chain, list available assets, or build token selection interfaces. The results are network-wide and not limited to a specific module or account.

Arguments

after
String

Cursor to start paginating after a specific result. Used for forward pagination.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

first
Int

Maximum number of tokens to return when paginating forward.

last
Int

Maximum number of tokens to return when paginating backward.

Return type

QueryTokensConnection!
edges
[QueryTokensEdge!]!,non-null
pageInfo
PageInfo!,non-null
Query sample
query tokens(
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  tokens(
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        id 
        name 
        chainId 
        address 
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
  }
}
Variables
{
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "name": "Example String",
          "chainId": "Example String",
          "address": "Example String"
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    }
  }
}

pools

(...args)
QueryPoolsConnection!,non-null

Retrieve a paginated list of liquidity pools with sorting and optional protocol filtering.

This query returns AMM pools (currently sourced from a single protocol used by the Sushi team) including reserves, TVL (USD), volume, fees, APR, and recent activity metrics. Prices for TVL/volume/fees are computed using DIA data (https://api.diadata.org) refreshed approximately every 5 minutes.

Use orderBy to sort by TVL, 24h/7d volume, 24h APR, or 24h transaction count (ASC/DESC), and protocolAddress to limit results to a specific protocol/module name on Kadena. Results support cursor-based pagination.

Arguments

after
String

Cursor to start paginating after a specific result (forward pagination).

before
String

Cursor to start paginating before a specific result (backward pagination).

first
Int

Maximum number of pools to return when paginating forward.

last
Int

Maximum number of pools to return when paginating backward.

orderBy
PoolOrderBy
Default:"TVL_USD_DESC"

Sort order for the returned pools.

protocolAddress
String

The protocol/module name (on Kadena) to filter by. Use this to restrict results to a specific DEX implementation.

Return type

QueryPoolsConnection!
edges
[QueryPoolsConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query pools(
  $after: String
  $before: String
  $first: Int
  $last: Int
  $orderBy: PoolOrderBy
  $protocolAddress: String
) {
  pools(
    after: $after
    before: $before
    first: $first
    last: $last
    orderBy: $orderBy
    protocolAddress: $protocolAddress
  ) {
    edges {
      cursor 
      node {
        id 
        address 
        token0 {
          __typename
          # ...TokenFragment
        }
        token1 {
          __typename
          # ...TokenFragment
        }
        reserve0 
        reserve1 
        totalSupply 
        key 
        tvlUsd 
        tvlChange24h 
        volume24hUsd 
        volumeChange24h 
        volume7dUsd 
        fees24hUsd 
        feesChange24h 
        transactionCount24h 
        transactionCountChange24h 
        apr24h 
        createdAt 
        updatedAt 
        charts(
          # Arguments Here
        ) {
          __typename
          # ...PoolChartsFragment
        }
        transactions(
          # Arguments Here
        ) {
          __typename
          # ...PoolTransactionsConnectionFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40,
  "orderBy": "TVL_USD_ASC",
  "protocolAddress": "Example String"
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "address": "Example String",
          "token0": {
            "__typename": "Token"
          },
          "token1": {
            "__typename": "Token"
          },
          "reserve0": "Example String",
          "reserve1": "Example String",
          "totalSupply": "Example String",
          "key": "Example String",
          "tvlUsd": 40,
          "tvlChange24h": 40,
          "volume24hUsd": 40,
          "volumeChange24h": 40,
          "volume7dUsd": 40,
          "fees24hUsd": 40,
          "feesChange24h": 40,
          "transactionCount24h": 40,
          "transactionCountChange24h": 40,
          "apr24h": 40,
          "createdAt": "Example Custom Scalar",
          "updatedAt": "Example Custom Scalar",
          "charts": {
            "__typename": "PoolCharts"
          },
          "transactions": {
            "__typename": "PoolTransactionsConnection"
          }
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

pool

(...args)
Pool

Retrieve a specific liquidity pool by its unique ID.

This query returns detailed information about a single AMM liquidity pool, including its reserves, paired tokens, TVL, trading volume, APR, and recent performance metrics. It’s commonly used by explorers, dashboards, and analytics tools to power individual pool detail views.

You can optionally provide a timeFrame to shape the data returned in metrics and charts, and a type to filter transactions by category (e.g., swaps, adds, removes).

⚠️ Note: While first, after, last, and before arguments are accepted for API consistency, they are not used by the internal resolvers of this query. Pagination of pool transactions is handled by the parent pool resolver, not directly here.

Arguments

id
ID!,non-nullrequired

The globally unique ID of the pool to retrieve.

timeFrame
TimeFrame

Optional time frame used for calculating and returning chart data.

type
PoolTransactionType

Optional transaction type filter (e.g., swaps, adds, removes) applied to the returned transactions.

first
Int

Accepted for API consistency but not used by this resolver.

after
String

Accepted for API consistency but not used by this resolver.

last
Int

Accepted for API consistency but not used by this resolver.

before
String

Accepted for API consistency but not used by this resolver.

Return type

Pool
id
ID!,non-null

Globally unique identifier for this pool node.

address
String!,non-null

The on-chain address / module reference for this pool.

token0
Token!,non-null

The first token in the pair (base/slot-0).

token1
Token!,non-null

The second token in the pair (quote/slot-1).

reserve0
String!,non-null

Current on-chain reserve of token0 held by the pool (as a string for full precision).

reserve1
String!,non-null

Current on-chain reserve of token1 held by the pool (as a string for full precision).

totalSupply
String!,non-null

Total supply of the pool’s LP (liquidity provider) tokens (as a string for full precision).

key
String!,non-null

A stable key for the pool (e.g., a deterministic pair identifier).

tvlUsd
Float!,non-null

Total value locked (USD) in this pool, derived from reserves and external pricing.

tvlChange24h
Float!,non-null

24-hour percentage change in TVL.

volume24hUsd
Float!,non-null

Notional 24-hour traded volume (USD).

volumeChange24h
Float!,non-null

24-hour percentage change in volume.

volume7dUsd
Float!,non-null

Notional 7-day traded volume (USD).

fees24hUsd
Float!,non-null

Notional 24-hour fees accrued by the pool (USD).

feesChange24h
Float!,non-null

24-hour percentage change in fees.

transactionCount24h
Int!,non-null

Count of pool transactions over the last 24 hours.

transactionCountChange24h
Float!,non-null

24-hour percentage change in transaction count.

apr24h
Float!,non-null

24-hour APR estimate derived from recent fees relative to TVL (as a percentage).

createdAt
DateTime!,non-null

Timestamp when this pool record was created.

updatedAt
DateTime!,non-null

Timestamp when this pool record was last updated.

charts
PoolCharts!,non-null

Get chart/series data for this pool over a specified timeframe (e.g., TVL, volume).

timeFrame*
transactions
PoolTransactionsConnection

Get transactions related to this pool, with optional type filtering and cursor-based pagination.

typefirstafterlastbefore
Query sample
query pool(
  $id: ID!
  $timeFrame: TimeFrame
  $type: PoolTransactionType
  $first: Int
  $after: String
  $last: Int
  $before: String
) {
  pool(
    id: $id
    timeFrame: $timeFrame
    type: $type
    first: $first
    after: $after
    last: $last
    before: $before
  ) {
    id 
    address 
    token0 {
      __typename
      # ...TokenFragment
    }
    token1 {
      __typename
      # ...TokenFragment
    }
    reserve0 
    reserve1 
    totalSupply 
    key 
    tvlUsd 
    tvlChange24h 
    volume24hUsd 
    volumeChange24h 
    volume7dUsd 
    fees24hUsd 
    feesChange24h 
    transactionCount24h 
    transactionCountChange24h 
    apr24h 
    createdAt 
    updatedAt 
    charts(
      # Arguments Here
    ) {
      __typename
      # ...PoolChartsFragment
    }
    transactions(
      # Arguments Here
    ) {
      __typename
      # ...PoolTransactionsConnectionFragment
    }
  }
}
Variables
{
  "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
  "timeFrame": "DAY",
  "type": "SWAP",
  "first": 40,
  "after": "Example String",
  "last": 40,
  "before": "Example String"
}
Response sample
{
  "data": {
    "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
    "address": "Example String",
    "token0": {
      "__typename": "Token"
    },
    "token1": {
      "__typename": "Token"
    },
    "reserve0": "Example String",
    "reserve1": "Example String",
    "totalSupply": "Example String",
    "key": "Example String",
    "tvlUsd": 40,
    "tvlChange24h": 40,
    "volume24hUsd": 40,
    "volumeChange24h": 40,
    "volume7dUsd": 40,
    "fees24hUsd": 40,
    "feesChange24h": 40,
    "transactionCount24h": 40,
    "transactionCountChange24h": 40,
    "apr24h": 40,
    "createdAt": "Example Custom Scalar",
    "updatedAt": "Example Custom Scalar",
    "charts": {
      "__typename": "PoolCharts"
    },
    "transactions": {
      "__typename": "PoolTransactionsConnection"
    }
  }
}

poolTransactions

(...args)
PoolTransactionsConnection

Retrieve a paginated list of transactions for a specific liquidity pool.

This query returns all on-chain transactions related to a given AMM pool, such as swaps, liquidity additions, and removals. It is most often used by explorers, analytics dashboards, and dApps to display pool activity, analyze trading behavior, or calculate historical metrics.

You must provide the pairId (the unique pool identifier), and you can optionally filter by type to restrict results to a specific category of transactions.

Arguments

pairId
String!,non-nullrequired

The unique identifier of the liquidity pool pair whose transactions you want to retrieve.

type
PoolTransactionType

Optional transaction type filter to narrow down results. Examples: SWAP, ADD_LIQUIDITY, REMOVE_LIQUIDITY

first
Int

Maximum number of transactions to return when paginating forward.

after
String

Cursor to start paginating after a specific result. Used for forward pagination.

last
Int

Maximum number of transactions to return when paginating backward.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

Return type

PoolTransactionsConnection
edges
[PoolTransactionEdge!],non-null

List of transaction edges

pageInfo
PageInfo

Pagination information

totalCount
Int

Total number of transactions

Query sample
query poolTransactions(
  $pairId: String!
  $type: PoolTransactionType
  $first: Int
  $after: String
  $last: Int
  $before: String
) {
  poolTransactions(
    pairId: $pairId
    type: $type
    first: $first
    after: $after
    last: $last
    before: $before
  ) {
    edges {
      cursor 
      node {
        id 
        maker 
        amount0In 
        amount1In 
        amount0Out 
        amount1Out 
        amountUsd 
        timestamp 
        transactionId 
        requestkey 
        transactionType 
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "pairId": "Example String",
  "type": "SWAP",
  "first": 40,
  "after": "Example String",
  "last": 40,
  "before": "Example String"
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "maker": "Example String",
          "amount0In": "Example Custom Scalar",
          "amount1In": "Example Custom Scalar",
          "amount0Out": "Example Custom Scalar",
          "amount1Out": "Example Custom Scalar",
          "amountUsd": "Example Custom Scalar",
          "timestamp": "Example Custom Scalar",
          "transactionId": 40,
          "requestkey": "Example String",
          "transactionType": "SWAP"
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

liquidityPositions

(...args)
LiquidityPositionsConnection!,non-null

Retrieve a paginated list of a user's liquidity positions across all supported pools.

This query returns all active liquidity positions associated with a given Kadena account (walletAddress), including the amount of liquidity provided, its USD value, and the 24h APR for each position. Each position also includes the underlying pool details for deeper insights.

It is commonly used by wallets, dashboards, and DeFi analytics tools to show a user's liquidity distribution, portfolio value, and performance metrics across supported AMM protocols (currently limited to the Sushi-integrated DEX).

Arguments

walletAddress
String!,non-nullrequired

The Kadena account address whose liquidity positions you want to retrieve. Example: "k:abcd1234..."

first
Int

Maximum number of liquidity positions to return when paginating forward.

after
String

Cursor to start paginating after a specific result. Used for forward pagination.

last
Int

Maximum number of liquidity positions to return when paginating backward.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

orderBy
LiquidityPositionOrderBy
Default:"VALUE_USD_DESC"

Sort order for the returned positions. Defaults to VALUE_USD_DESC. Options:

  • VALUE_USD_ASC / VALUE_USD_DESC
  • LIQUIDITY_ASC / LIQUIDITY_DESC
  • APR_ASC / APR_DESC

Return type

LiquidityPositionsConnection!
edges
[LiquidityPositionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query liquidityPositions(
  $walletAddress: String!
  $first: Int
  $after: String
  $last: Int
  $before: String
  $orderBy: LiquidityPositionOrderBy
) {
  liquidityPositions(
    walletAddress: $walletAddress
    first: $first
    after: $after
    last: $last
    before: $before
    orderBy: $orderBy
  ) {
    edges {
      cursor 
      node {
        id 
        pairId 
        liquidity 
        walletAddress 
        valueUsd 
        apr24h 
        pair {
          __typename
          # ...PoolFragment
        }
        createdAt 
        updatedAt 
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "walletAddress": "Example String",
  "first": 40,
  "after": "Example String",
  "last": 40,
  "before": "Example String",
  "orderBy": "VALUE_USD_ASC"
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "pairId": "Example String",
          "liquidity": "Example String",
          "walletAddress": "Example String",
          "valueUsd": "Example Custom Scalar",
          "apr24h": "Example Custom Scalar",
          "pair": {
            "__typename": "Pool"
          },
          "createdAt": "Example Custom Scalar",
          "updatedAt": "Example Custom Scalar"
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

dexMetrics

(...args)
DexMetrics!,non-null

Retrieve key metrics for the decentralized exchange (DEX), including total value locked (TVL), trading volume, and pool count, with optional historical data.

This query aggregates protocol-level statistics across all pools under a supported DEX (currently limited to the Sushi-integrated deployment) and is commonly used by dashboards, explorers, and analytics tools to visualize network-wide DeFi activity.

If startDate and endDate are not provided, the query defaults to a 30-day historical range. Use protocolAddress to filter metrics for a specific DEX module on Kadena.

Returned data includes the current TVL, total pool count, total volume over the selected period, and historical time series data for both TVL and volume.

Arguments

startDate
DateTime

(Optional) Start date for the historical range used to calculate TVL and volume metrics.

endDate
DateTime

(Optional) End date for the historical range used to calculate TVL and volume metrics.

protocolAddress
String

(Optional) Filter metrics by the protocol’s module name on Kadena. Useful when multiple DEX protocols are supported.

Return type

DexMetrics!
totalPools
Int!,non-null

The total number of liquidity pools deployed under the protocol.

currentTvlUsd
Decimal!,non-null

The current total value locked (TVL) across all pools, expressed in USD. This reflects the combined liquidity available in the protocol at the time of the query.

tvlHistory
[ChartDataPoint!]!,non-null

Historical time-series data points representing TVL evolution over the selected time range. Useful for charting liquidity growth and analyzing protocol trends.

volumeHistory
[ChartDataPoint!]!,non-null

Historical time-series data points representing trading volume over the selected time range. Useful for charting market activity and usage patterns.

totalVolumeUsd
Decimal!,non-null

The total cumulative trading volume (in USD) observed over the specified time range.

Query sample
query dexMetrics(
  $startDate: DateTime
  $endDate: DateTime
  $protocolAddress: String
) {
  dexMetrics(
    startDate: $startDate
    endDate: $endDate
    protocolAddress: $protocolAddress
  ) {
    totalPools 
    currentTvlUsd 
    tvlHistory {
      __typename
      # ...ChartDataPointFragment
    }
    volumeHistory {
      __typename
      # ...ChartDataPointFragment
    }
    totalVolumeUsd 
  }
}
Variables
{
  "startDate": "Example Custom Scalar",
  "endDate": "Example Custom Scalar",
  "protocolAddress": "Example String"
}
Response sample
{
  "data": {
    "totalPools": 40,
    "currentTvlUsd": "Example Custom Scalar",
    "tvlHistory": [
      {
        "__typename": "ChartDataPoint"
      }
    ],
    "volumeHistory": [
      {
        "__typename": "ChartDataPoint"
      }
    ],
    "totalVolumeUsd": "Example Custom Scalar"
  }
}

Subscriptions

Overview

Directives

Overview

Objects

Overview

Interfaces

Overview

Unions

Overview

Enums

Overview

Inputs

Overview

Scalars

Overview