- gasLimitEstimate
Retrieve details of a specific fungible account (such as a KDA coin account) by its name and fungible type.
In Kadena, a fungible account represents a balance-holding entity for a given fungible token module (e.g., coin, which isthe native KDA token).
This query lets you look up that account’s information by providing its full accountName and the name of the fungible module.
It is commonly used to fetch the balance and metadata for a user or contract address.
Arguments
The full name of the account to retrieve.
Example: "k:abcdef123456..." for a user account or "free.my-contract" for a contract account.
The name of the fungible token module (e.g., coin) associated with the account.
Return type
FungibleGlobally unique identifier for this fungible account node.
The full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).
Per-chain breakdown of this fungible account. Since Kadena operates multiple braided chains, an account can have different balances on each chain.
The name of the fungible token module associated with this account (e.g., coin).
The total balance of this account across all chains for the specified fungible token.
Paginated list of transactions involving this account. Transactions represent operations such as transfers, contract calls, or other state changes that affect this account.
Paginated list of transfers associated with this account. Transfers represent direct movements of the fungible token into or out of this account.
query fungibleAccount($accountName: String!, $fungibleName: String) {
fungibleAccount(accountName: $accountName, fungibleName: $fungibleName) {
id
accountName
chainAccounts {
__typename
# ...FungibleChainAccountFragment
}
fungibleName
totalBalance
transactions(
# Arguments Here
) {
__typename
# ...FungibleAccountTransactionsConnectionFragment
}
transfers(
# Arguments Here
) {
__typename
# ...FungibleAccountTransfersConnectionFragment
}
}
}{ "accountName": "Example String", "fungibleName": "Example String" }
{ "data": { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "accountName": "Example String", "chainAccounts": [ { "__typename": "FungibleChainAccount" } ], "fungibleName": "Example String", "totalBalance": "Example Custom Scalar", "transactions": { "__typename": "FungibleAccountTransactionsConnection" }, "transfers": { "__typename": "FungibleAccountTransfersConnection" } } }
Retrieve all fungible accounts associated with a given public key.
In Kadena, a single public key can control multiple accounts — for example, one on each chain, or accounts tied to
different contracts or modules. This query returns all FungibleAccount objects linked to the provided public key
for a specified fungible token (default: coin).
This is particularly useful when you want to discover all accounts controlled by a user key across the Kadena network, including balances and activity for each.
Arguments
The name of the fungible token module to filter by (e.g., coin for the native KDA token).
Defaults to "coin" if not specified.
The public key used to control the account(s).
Example: "abcdef1234567890...".
Return type
[FungibleGlobally unique identifier for this fungible account node.
The full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).
Per-chain breakdown of this fungible account. Since Kadena operates multiple braided chains, an account can have different balances on each chain.
The name of the fungible token module associated with this account (e.g., coin).
The total balance of this account across all chains for the specified fungible token.
Paginated list of transactions involving this account. Transactions represent operations such as transfers, contract calls, or other state changes that affect this account.
Paginated list of transfers associated with this account. Transfers represent direct movements of the fungible token into or out of this account.
query fungibleAccountsByPublicKey($fungibleName: String, $publicKey: String!) {
fungibleAccountsByPublicKey(fungibleName: $fungibleName, publicKey: $publicKey) {
id
accountName
chainAccounts {
__typename
# ...FungibleChainAccountFragment
}
fungibleName
totalBalance
transactions(
# Arguments Here
) {
__typename
# ...FungibleAccountTransactionsConnectionFragment
}
transfers(
# Arguments Here
) {
__typename
# ...FungibleAccountTransfersConnectionFragment
}
}
}{ "fungibleName": "Example String", "publicKey": "Example String" }
{ "data": [ { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "accountName": "Example String", "chainAccounts": [ { "__typename": "FungibleChainAccount" } ], "fungibleName": "Example String", "totalBalance": "Example Custom Scalar", "transactions": { "__typename": "FungibleAccountTransactionsConnection" }, "transfers": { "__typename": "FungibleAccountTransfersConnection" } } ] }
Retrieve details of a specific fungible account on a specific chain.
In Kadena’s multi-chain architecture, an account can exist on multiple chains simultaneously, each maintaining
its own balance and transaction history. This query lets you retrieve the state of a single FungibleChainAccount
by specifying the account name, the chain ID, and the fungible token module (default: coin).
It’s particularly useful when you need precise, chain-level information — such as a user’s balance or transfer activity — without aggregating data across all chains.
Arguments
The full name of the account to retrieve.
Example: "k:abcdef123456..." for a user account or "free.my-contract" for a contract account.
The chain ID where the account exists. Kadena runs multiple braided chains, and balances are tracked separately on each.
The name of the fungible token module (e.g., coin) associated with the account.
Defaults to "coin" if not specified.
Return type
FungibleGlobally unique identifier for this chain account node.
The full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).
The current balance of this account on the specified chain for the given fungible token.
The chain ID where this account exists.
The name of the fungible token module associated with this account (e.g., coin).
The guard that defines the account’s security conditions. A guard determines who must sign transactions in order to spend from this account.
Paginated list of transactions involving this account on this chain. Transactions represent operations such as transfers, contract calls, or other state changes.
Paginated list of token transfers into or out of this account on this chain. Transfers are a subset of events focused specifically on balance movements.
query fungibleChainAccount(
$accountName: String!
$chainId: String!
$fungibleName: String
) {
fungibleChainAccount(
accountName: $accountName
chainId: $chainId
fungibleName: $fungibleName
) {
id
accountName
balance
chainId
fungibleName
guard {
__typename
# ...IGuardFragment
}
transactions(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransactionsConnectionFragment
}
transfers(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransfersConnectionFragment
}
}
}{ "accountName": "Example String", "chainId": "Example String", "fungibleName": "Example String" }
{ "data": { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "accountName": "Example String", "balance": 40, "chainId": "Example String", "fungibleName": "Example String", "guard": { "__typename": "IGuard" }, "transactions": { "__typename": "FungibleChainAccountTransactionsConnection" }, "transfers": { "__typename": "FungibleChainAccountTransfersConnection" } } }
Retrieve fungible account details across multiple chains.
In Kadena’s multi-chain architecture, an account can exist on several chains simultaneously — each maintaining its own
balance, guard, and activity history. This query allows you to retrieve all FungibleChainAccount objects for a given
account name and fungible token (default: coin) across one or more specified chains in a single request.
It’s especially useful when you want a comprehensive view of how an account is distributed across multiple chains, including balances and per-chain transaction or transfer histories.
Arguments
The full name of the account to retrieve.
Example: "k:abcdef123456..." for a user account or "free.my-contract" for a contract account.
The list of chain IDs where the account exists.
You can specify one or more chains to retrieve FungibleChainAccount details for each.
The name of the fungible token module associated with the account (e.g., coin).
Defaults to "coin" if not specified.
Return type
[FungibleGlobally unique identifier for this chain account node.
The full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).
The current balance of this account on the specified chain for the given fungible token.
The chain ID where this account exists.
The name of the fungible token module associated with this account (e.g., coin).
The guard that defines the account’s security conditions. A guard determines who must sign transactions in order to spend from this account.
Paginated list of transactions involving this account on this chain. Transactions represent operations such as transfers, contract calls, or other state changes.
Paginated list of token transfers into or out of this account on this chain. Transfers are a subset of events focused specifically on balance movements.
query fungibleChainAccounts(
$accountName: String!
$chainIds: [String!]
$fungibleName: String
) {
fungibleChainAccounts(
accountName: $accountName
chainIds: $chainIds
fungibleName: $fungibleName
) {
id
accountName
balance
chainId
fungibleName
guard {
__typename
# ...IGuardFragment
}
transactions(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransactionsConnectionFragment
}
transfers(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransfersConnectionFragment
}
}
}{ "accountName": "Example String", "chainIds": [ "Example String" ], "fungibleName": "Example String" }
{ "data": [ { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "accountName": "Example String", "balance": 40, "chainId": "Example String", "fungibleName": "Example String", "guard": { "__typename": "IGuard" }, "transactions": { "__typename": "FungibleChainAccountTransactionsConnection" }, "transfers": { "__typename": "FungibleChainAccountTransfersConnection" } } ] }
Retrieve all fungible chain accounts associated with a given public key on a specific chain.
In Kadena, a single public key can control multiple accounts on the same chain — for example,
accounts created by different contracts or modules. This query returns all FungibleChainAccount
objects linked to the provided public key for a specified fungible token (default: coin) on the given chain.
It’s especially useful when you want to discover all accounts controlled by a user key on a particular chain, including their balances, guards, and per-chain transaction history.
Arguments
The ID of the chain to search on. Kadena runs multiple braided chains — specify the one where the accounts exist.
The name of the fungible token module to filter by (e.g., coin for the native KDA token).
Defaults to "coin" if not specified.
The public key used to control the account(s).
Example: "abcdef1234567890...".
Return type
[FungibleGlobally unique identifier for this chain account node.
The full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).
The current balance of this account on the specified chain for the given fungible token.
The chain ID where this account exists.
The name of the fungible token module associated with this account (e.g., coin).
The guard that defines the account’s security conditions. A guard determines who must sign transactions in order to spend from this account.
Paginated list of transactions involving this account on this chain. Transactions represent operations such as transfers, contract calls, or other state changes.
Paginated list of token transfers into or out of this account on this chain. Transfers are a subset of events focused specifically on balance movements.
query fungibleChainAccountsByPublicKey(
$chainId: String!
$fungibleName: String
$publicKey: String!
) {
fungibleChainAccountsByPublicKey(
chainId: $chainId
fungibleName: $fungibleName
publicKey: $publicKey
) {
id
accountName
balance
chainId
fungibleName
guard {
__typename
# ...IGuardFragment
}
transactions(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransactionsConnectionFragment
}
transfers(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransfersConnectionFragment
}
}
}{ "chainId": "Example String", "fungibleName": "Example String", "publicKey": "Example String" }
{ "data": [ { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "accountName": "Example String", "balance": 40, "chainId": "Example String", "fungibleName": "Example String", "guard": { "__typename": "IGuard" }, "transactions": { "__typename": "FungibleChainAccountTransactionsConnection" }, "transfers": { "__typename": "FungibleChainAccountTransfersConnection" } } ] }
Estimate the gas limit required to execute one or more transactions on the Kadena blockchain.
This query accepts one or more JSON-encoded transaction inputs and analyzes them to calculate the expected gas usage. It automatically infers the transaction type based on the fields provided and returns the estimated gas limit for each input. If any transaction is invalid or cannot be parsed, the query will throw an error.
Supported input types and required fields:
full-transaction: A fully signed transaction object. Required:cmd,hash,sigsstringified-command: A JSON-stringified command. Required:cmd(optional:sigs)full-command: A complete command object. Required:payload,meta,signerspartial-command: A partially defined command. Required:payloadand eithermetaorsigners(optional:chainIdifsignersis provided withoutmeta)payload: Only the payload of a command. Required:payload,chainIdcode: Pact execution code. Required:code,chainId
All input types optionally accept networkId to override the default network configured in the environment.
query {
gasLimitEstimate(
input: [
"{
\"code\": \"(coin.details \\\"k:1234\\\")\",
\"chainId\": \"3\"
}"
]
) {
amount
inputType
}
}
Arguments
One or more JSON-encoded transaction inputs to estimate gas for. Each entry must follow one of the supported input type structures listed above.
Return type
[GasThe estimated gas limit required to execute the transaction.
The detected input type (e.g., code, payload, full-transaction, etc.).
The normalized JSON representation of the transaction used for estimation.
Whether a pre-execution (preflight) simulation was used during estimation.
Whether signature verification was performed as part of the estimation.
query gasLimitEstimate($input: [String!]!) {
gasLimitEstimate(input: $input) {
amount
inputType
transaction
usedPreflight
usedSignatureVerification
}
}{ "input": [ "Example String" ] }
{ "data": [ { "amount": 40, "inputType": "Example String", "transaction": "Example String", "usedPreflight": true, "usedSignatureVerification": true } ] }
Retrieve general information about this GraphQL API endpoint. It is commonly used to check how far back the indexer’s data goes and to verify the API version your application is interacting with.
Return type
Graphquery graphConfiguration {
graphConfiguration {
minimumBlockHeight
version
}
}{ "data": { "minimumBlockHeight": "Example Custom Scalar", "version": "Example String" } }
Get the height of the block with the highest height.
Return type
BigThe BigInt scalar type represents non-fractional signed whole numeric values.
query lastBlockHeight {
lastBlockHeight
}{ "data": "Example Custom Scalar" }
Retrieve comprehensive information about the Kadena network.
This query returns a NetworkInfo object containing key metrics and configuration details
about the current state of the network.
Developers typically use this query to monitor network health, verify node synchronization, analyze performance metrics, or display high-level blockchain data in explorers and dashboards.
Return type
NetworkThe version of this GraphQL API. Useful to verify compatibility between the client and API.
The current total number of coins in circulation on the network.
The current aggregate hash rate of the Kadena network. Indicates the total mining power securing the network.
The host address or domain of the network node serving this API.
The unique identifier of the network (e.g., mainnet01, testnet04).
The cumulative difficulty of all blocks mined so far. A higher value reflects the total work securing the chain.
The total number of transactions that have been processed across the network.
The current delay (in blocks) between the latest mined block and the block processed by the node. Useful for monitoring node synchronization status.
The list of chain IDs that make up the Kadena network. Kadena operates multiple braided chains in parallel.
The total number of chains in the network.
The genesis block height for each chain in the network. Provides insight into the starting point of each chain’s history.
The version of the node software package running this endpoint.
The service start date and time of the current node. Useful for tracking uptime and deployment history.
The latest block height known by the node’s behavior monitor. Can be used to assess node synchronization and chain progress.
Transaction counters and statistics broken down by chain. Useful for analyzing per-chain activity levels and throughput.
query networkInfo {
networkInfo {
apiVersion
coinsInCirculation
networkHashRate
networkHost
networkId
totalDifficulty
transactionCount
nodeBlockDelay
nodeChains
numberOfChains
genesisHeights {
__typename
# ...GenesisHeightFragment
}
nodePackageVersion
nodeServiceDate
nodeLatestBehaviorHeight
countersOfEachChain {
__typename
# ...CountersOfEachChainFragment
}
}
}{ "data": { "apiVersion": "Example String", "coinsInCirculation": 40, "networkHashRate": 40, "networkHost": "Example String", "networkId": "Example String", "totalDifficulty": 40, "transactionCount": 40, "nodeBlockDelay": 40, "nodeChains": [ "Example String" ], "numberOfChains": 40, "genesisHeights": [ { "__typename": "GenesisHeight" } ], "nodePackageVersion": "Example String", "nodeServiceDate": "Example Custom Scalar", "nodeLatestBehaviorHeight": 40, "countersOfEachChain": [ { "__typename": "CountersOfEachChain" } ] } }
Retrieve a single object in the graph by its globally unique identifier.
All major entities in this API implement the Node interface, which ensures that each one
has a unique id field. This query allows you to fetch any of those entities directly
using that global ID, regardless of its specific type (e.g., Block, Transaction, FungibleAccount).
Arguments
The globally unique identifier (id) of the object to retrieve.
Return type
NodeA globally unique identifier for the object.
query node($id: ID!) {
node(id: $id) {
id
}
}{ "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4" }
{ "data": { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4" } }
Retrieve multiple objects in the graph by their globally unique identifiers.
Like the node query, this query returns any entities that implement the Node interface,
but allows you to request several objects in a single call by passing a list of IDs.
It’s useful when resolving multiple references at once — for example, when reconstructing
relationships between entities or populating a list by ID.
Arguments
A list of globally unique identifiers (id) of the objects to retrieve.
Return type
[Node]!A globally unique identifier for the object.
query nodes($ids: [ID!]!) {
nodes(ids: $ids) {
id
}
}{ "ids": [ "9cfb1c81-4c79-452f-b1f5-8ee6571276b4" ] }
{ "data": [ { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4" } ] }