- completedBlockHeights
Returns the balances for a given account, chain, and module combination.
This query calculates and returns the user's balance for each specified combination
of account, chain ID, and module. For example, it can return how much
balance the account k:9492...5c17 holds on chain 1 within the coin module.
Arguments
The full account name to retrieve balances for.
A list of chain IDs to include in the balance retrieval.
Example: ["0", "1"]
The name of the module that issued the token.
Example: "coin"
Cursor to start paginating after a specific result. Used for forward pagination.
Cursor to start paginating before a specific result. Used for backward pagination.
Maximum number of balance records to return when paginating forward.
Maximum number of balance records to return when paginating backward.
Return type
Queryquery balance(
$accountName: String
$chainIds: [String!]
$module: String
$after: String
$before: String
$first: Int
$last: Int
) {
balance(
accountName: $accountName
chainIds: $chainIds
module: $module
after: $after
before: $before
first: $first
last: $last
) {
edges {
cursor
node {
accountName
module
chainId
balance
}
}
pageInfo {
startCursor
endCursor
hasNextPage
hasPreviousPage
}
}
}{ "accountName": "Example String", "chainIds": [ "Example String" ], "module": "Example String", "after": "Example String", "before": "Example String", "first": 40, "last": 40 }
{ "data": { "edges": [ { "cursor": "Example String", "node": { "accountName": "Example String", "module": "Example String", "chainId": "Example String", "balance": "Example String" } } ], "pageInfo": { "startCursor": "Example String", "endCursor": "Example String", "hasNextPage": true, "hasPreviousPage": true } } }
Retrieve detailed information about a specific block using its unique hash.
Every block in the Kadena blockchain is identified by a cryptographic hash — a unique fingerprint generated from its contents. This query allows you to look up a block directly by that hash, returning all available details about it, such as its height, creation time, transactions, miner, and more.
This is especially useful when you already know the block’s hash (for example, from a transaction receipt or an event log) and want to quickly inspect or verify that block’s contents without scanning the entire chain.
Arguments
The unique cryptographic hash (identifier) of the block to retrieve.
Return type
BlockGlobally unique identifier for this block node.
The cryptographic hash of the block. This serves as its unique identifier within the blockchain.
The specific chain where this block was mined. Kadena is a multi-chain system, and each block belongs to exactly one chain.
The timestamp when this block was created and added to the chain.
The network difficulty at the time the block was mined. Higher difficulty reflects the amount of computational work required to produce a valid block.
The epoch timestamp marking when the difficulty was last adjusted. Kadena targets ~30 seconds per block, and the difficulty is recalibrated periodically to maintain that target.
Consensus flags used internally by the protocol.
The height (block number) of this block within its chain. The genesis block is height 0, and each subsequent block increments by 1.
A nonce value used in the proof-of-work process. Miners vary this value to discover a hash below the target threshold.
The hash of the payload data contained within the block. This ensures the integrity of the transactions and other included data.
The cumulative weight of the chain up to and including this block. Weight increases with each mined block and helps determine the canonical chain.
The target hash threshold that the block’s proof-of-work hash must fall below. This value adjusts with difficulty to regulate block production time.
The coinbase transaction data. This transaction rewards the miner and may include information about block rewards or other protocol-defined payouts.
The neighboring blocks that reference this block as a parent. These neighbors are essential in Kadena’s braided multi-chain architecture.
The proof-of-work hash of the block. This is the result of hashing the block header with the nonce and must satisfy the target condition.
Indicates whether this block is part of the canonical chain. Non-canonical blocks may occur during temporary forks or reorganizations.
The parent block directly preceding this one in the chain. Together with the hash, this forms the cryptographic link that secures the chain.
The total amount of gas used by all transactions in this block, expressed in KDA.
Paginated list of events emitted by transactions within this block.
The account that mined this block and received the coinbase reward.
Paginated list of transactions included in this block.
query block($hash: String!) {
block(hash: $hash) {
id
hash
chainId
creationTime
difficulty
epoch
flags
height
nonce
payloadHash
weight
target
coinbase
neighbors {
__typename
# ...BlockNeighborFragment
}
powHash
canonical
parent {
__typename
# ...BlockFragment
}
totalGasUsedInKda
events(
# Arguments Here
) {
__typename
# ...BlockEventsConnectionFragment
}
minerAccount {
__typename
# ...FungibleChainAccountFragment
}
transactions(
# Arguments Here
) {
__typename
# ...BlockTransactionsConnectionFragment
}
}
}{ "hash": "Example String" }
{ "data": { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "hash": "Example String", "chainId": "Example Custom Scalar", "creationTime": "Example Custom Scalar", "difficulty": "Example Custom Scalar", "epoch": "Example Custom Scalar", "flags": "Example Custom Scalar", "height": "Example Custom Scalar", "nonce": "Example Custom Scalar", "payloadHash": "Example String", "weight": "Example String", "target": "Example String", "coinbase": "Example String", "neighbors": [ { "__typename": "BlockNeighbor" } ], "powHash": "Example String", "canonical": true, "parent": { "__typename": "Block" }, "totalGasUsedInKda": "Example Custom Scalar", "events": { "__typename": "BlockEventsConnection" }, "minerAccount": { "__typename": "FungibleChainAccount" }, "transactions": { "__typename": "BlockTransactionsConnection" } } }
Retrieves blocks based on their depth in the Kadena blockchain.
In Kadena, each new block extends the chain by one unit, and the term depth refers to how far a block is from the current chain tip (the most recent block).
- A block with a depth of
0is the latest block (the chain head). - A block with a depth of
1is one block behind the tip, and so on.
Because new blocks can occasionally be reorganized near the tip, specifying a minimumDepth helps ensure that only blocks that are deep enough — and therefore finalized and stable — are returned.
For example, a minimumDepth of 20 means only blocks that are at least 20 blocks behind the current tip will be included in the results, reducing the chance of including blocks that might later be replaced due to a chain reorganization.
Use this query to fetch finalized blocks across one or more chains.
Arguments
The chain IDs to retrieve blocks from.
The minimum depth of the blocks to retrieve. Blocks closer to the tip than this depth will be excluded.
Cursor to start paginating after a specific result. Used for forward pagination.
Cursor to start paginating before a specific result. Used for backward pagination.
Maximum number of balance records to return when paginating forward.
Maximum number of balance records to return when paginating backward.
Return type
Queryquery blocksFromDepth(
$chainIds: [String!]
$minimumDepth: Int!
$after: String
$before: String
$first: Int
$last: Int
) {
blocksFromDepth(
chainIds: $chainIds
minimumDepth: $minimumDepth
after: $after
before: $before
first: $first
last: $last
) {
edges {
cursor
node {
id
hash
chainId
creationTime
difficulty
epoch
flags
height
nonce
payloadHash
weight
target
coinbase
neighbors {
__typename
# ...BlockNeighborFragment
}
powHash
canonical
parent {
__typename
# ...BlockFragment
}
totalGasUsedInKda
events(
# Arguments Here
) {
__typename
# ...BlockEventsConnectionFragment
}
minerAccount {
__typename
# ...FungibleChainAccountFragment
}
transactions(
# Arguments Here
) {
__typename
# ...BlockTransactionsConnectionFragment
}
}
}
pageInfo {
startCursor
endCursor
hasNextPage
hasPreviousPage
}
totalCount
}
}{ "chainIds": [ "Example String" ], "minimumDepth": 40, "after": "Example String", "before": "Example String", "first": 40, "last": 40 }
{ "data": { "edges": [ { "cursor": "Example String", "node": { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "hash": "Example String", "chainId": "Example Custom Scalar", "creationTime": "Example Custom Scalar", "difficulty": "Example Custom Scalar", "epoch": "Example Custom Scalar", "flags": "Example Custom Scalar", "height": "Example Custom Scalar", "nonce": "Example Custom Scalar", "payloadHash": "Example String", "weight": "Example String", "target": "Example String", "coinbase": "Example String", "neighbors": [ { "__typename": "BlockNeighbor" } ], "powHash": "Example String", "canonical": true, "parent": { "__typename": "Block" }, "totalGasUsedInKda": "Example Custom Scalar", "events": { "__typename": "BlockEventsConnection" }, "minerAccount": { "__typename": "FungibleChainAccount" }, "transactions": { "__typename": "BlockTransactionsConnection" } } } ], "pageInfo": { "startCursor": "Example String", "endCursor": "Example String", "hasNextPage": true, "hasPreviousPage": true }, "totalCount": 40 } }
Retrieve blocks from one or more chains based on their block height range.
In Kadena, height represents a block’s sequential position within its chain, starting at 0 for the genesis block and increasing by 1 for each new block.
This query lets you fetch blocks by specifying a starting height (startHeight) and, optionally, an ending height (endHeight).
It is particularly useful when you want to retrieve a continuous range of blocks — for example, when backfilling data, syncing from a specific point in the chain, or analyzing block activity over a known range.
If endHeight is omitted, the query returns all blocks from the starting height up to the current chain tip.
Arguments
The chain IDs to retrieve blocks from. Kadena runs multiple braided chains in parallel — specify one or more chain IDs here.
The inclusive upper bound of the height range.
If omitted, results will include all blocks from startHeight to the current tip.
The inclusive lower bound of the height range. Blocks with a height below this value will be excluded.
Cursor to start paginating after a specific result. Used for forward pagination.
Cursor to start paginating before a specific result. Used for backward pagination.
Maximum number of records to return when paginating forward.
Maximum number of records to return when paginating backward.
Return type
Queryquery blocksFromHeight(
$chainIds: [String!]
$endHeight: Int
$startHeight: Int!
$after: String
$before: String
$first: Int
$last: Int
) {
blocksFromHeight(
chainIds: $chainIds
endHeight: $endHeight
startHeight: $startHeight
after: $after
before: $before
first: $first
last: $last
) {
edges {
cursor
node {
id
hash
chainId
creationTime
difficulty
epoch
flags
height
nonce
payloadHash
weight
target
coinbase
neighbors {
__typename
# ...BlockNeighborFragment
}
powHash
canonical
parent {
__typename
# ...BlockFragment
}
totalGasUsedInKda
events(
# Arguments Here
) {
__typename
# ...BlockEventsConnectionFragment
}
minerAccount {
__typename
# ...FungibleChainAccountFragment
}
transactions(
# Arguments Here
) {
__typename
# ...BlockTransactionsConnectionFragment
}
}
}
pageInfo {
startCursor
endCursor
hasNextPage
hasPreviousPage
}
totalCount
}
}{ "chainIds": [ "Example String" ], "endHeight": 40, "startHeight": 40, "after": "Example String", "before": "Example String", "first": 40, "last": 40 }
{ "data": { "edges": [ { "cursor": "Example String", "node": { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "hash": "Example String", "chainId": "Example Custom Scalar", "creationTime": "Example Custom Scalar", "difficulty": "Example Custom Scalar", "epoch": "Example Custom Scalar", "flags": "Example Custom Scalar", "height": "Example Custom Scalar", "nonce": "Example Custom Scalar", "payloadHash": "Example String", "weight": "Example String", "target": "Example String", "coinbase": "Example String", "neighbors": [ { "__typename": "BlockNeighbor" } ], "powHash": "Example String", "canonical": true, "parent": { "__typename": "Block" }, "totalGasUsedInKda": "Example Custom Scalar", "events": { "__typename": "BlockEventsConnection" }, "minerAccount": { "__typename": "FungibleChainAccount" }, "transactions": { "__typename": "BlockTransactionsConnection" } } } ], "pageInfo": { "startCursor": "Example String", "endCursor": "Example String", "hasNextPage": true, "hasPreviousPage": true }, "totalCount": 40 } }
Retrieve a list of completed block heights across one or more chains, starting from a given point.
In Kadena’s braided multi-chain architecture, a block height is considered completed only when all chains have successfully produced a block at that height. Since each chain progresses independently, some chains may temporarily lag behind others. This query ensures that only globally finalized heights — where every specified chain has reached that block height — are returned.
This is particularly useful for building indexers, explorers, and analytics tools that require consistent cross-chain data.
You can specify how many completed heights to return with heightCount.
Arguments
The chain IDs to include when checking for completed heights. Only heights where all of these chains have produced a block will be returned.
Whether to include only completed heights.
Defaults to true.
If set to false, the query may include heights that are not yet completed across all chains.
The maximum number of sequential completed heights to return per query. Results are always returned without gaps, starting from the most recent completed height and moving backward if no pagination arguments are provided.
Examples:
- If completed heights are
101,102,103,104, and105, and you setheightCount: 3without pagination, the query returns the 3 most recent completed heights:105,104,103. - If you set
heightCount: 10in the same scenario, the query still returns only the 5 available heights:105,104,103,102,101.
Cursor to start paginating after a specific result. Used for forward pagination.
Cursor to start paginating before a specific result. Used for backward pagination.
Maximum number of results to return when paginating forward.
Maximum number of results to return when paginating backward.
Return type
Queryquery completedBlockHeights(
$chainIds: [String!]
$completedHeights: Boolean
$heightCount: Int
$after: String
$before: String
$first: Int
$last: Int
) {
completedBlockHeights(
chainIds: $chainIds
completedHeights: $completedHeights
heightCount: $heightCount
after: $after
before: $before
first: $first
last: $last
) {
edges {
cursor
node {
id
hash
chainId
creationTime
difficulty
epoch
flags
height
nonce
payloadHash
weight
target
coinbase
neighbors {
__typename
# ...BlockNeighborFragment
}
powHash
canonical
parent {
__typename
# ...BlockFragment
}
totalGasUsedInKda
events(
# Arguments Here
) {
__typename
# ...BlockEventsConnectionFragment
}
minerAccount {
__typename
# ...FungibleChainAccountFragment
}
transactions(
# Arguments Here
) {
__typename
# ...BlockTransactionsConnectionFragment
}
}
}
pageInfo {
startCursor
endCursor
hasNextPage
hasPreviousPage
}
}
}{ "chainIds": [ "Example String" ], "completedHeights": true, "heightCount": 40, "after": "Example String", "before": "Example String", "first": 40, "last": 40 }
{ "data": { "edges": [ { "cursor": "Example String", "node": { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "hash": "Example String", "chainId": "Example Custom Scalar", "creationTime": "Example Custom Scalar", "difficulty": "Example Custom Scalar", "epoch": "Example Custom Scalar", "flags": "Example Custom Scalar", "height": "Example Custom Scalar", "nonce": "Example Custom Scalar", "payloadHash": "Example String", "weight": "Example String", "target": "Example String", "coinbase": "Example String", "neighbors": [ { "__typename": "BlockNeighbor" } ], "powHash": "Example String", "canonical": true, "parent": { "__typename": "Block" }, "totalGasUsedInKda": "Example Custom Scalar", "events": { "__typename": "BlockEventsConnection" }, "minerAccount": { "__typename": "FungibleChainAccount" }, "transactions": { "__typename": "BlockTransactionsConnection" } } } ], "pageInfo": { "startCursor": "Example String", "endCursor": "Example String", "hasNextPage": true, "hasPreviousPage": true } } }
Retrieve blockchain events with powerful filtering options.
In Kadena, events are emitted by smart contracts when specific actions occur (e.g., coin.TRANSFER).
You can filter by event name, module, chain, block, transaction, height range, or minimum depth,
and even by JSON parameters using Prisma-compatible JSON object property filters (stringified).
Arguments
Fully qualified event name (e.g., coin.TRANSFER) to select a specific event type.
The module that emitted the event (e.g., coin).
Hash of the block that contains the event.
Transaction request key (hash) associated with the event.
Chain ID where the event occurred.
Inclusive upper bound for block height.
Inclusive lower bound for block height.
Minimum depth of the block that emitted the event (distance from the chain tip). Use this to return only more-final and stable events.
Event position within the transaction’s execution order.
JSON-stringified Prisma JSON object property filter applied to event parameters.
Example (JSON-escaped): parametersFilter: "{"array_starts_with":"k:abcdefg"}"
Cursor to start paginating after a specific result (forward pagination).
Cursor to start paginating before a specific result (backward pagination).
Maximum number of records to return when paginating forward.
Maximum number of records to return when paginating backward.
Return type
Queryquery events(
$qualifiedEventName: String
$moduleName: String
$blockHash: String
$requestKey: String
$chainId: String
$maxHeight: Int
$minHeight: Int
$minimumDepth: Int
$orderIndex: Int
$parametersFilter: String
$after: String
$before: String
$first: Int
$last: Int
) {
events(
qualifiedEventName: $qualifiedEventName
moduleName: $moduleName
blockHash: $blockHash
requestKey: $requestKey
chainId: $chainId
maxHeight: $maxHeight
minHeight: $minHeight
minimumDepth: $minimumDepth
orderIndex: $orderIndex
parametersFilter: $parametersFilter
after: $after
before: $before
first: $first
last: $last
) {
edges {
cursor
node {
id
name
block {
__typename
# ...BlockFragment
}
chainId
height
moduleName
orderIndex
requestKey
parameters
parameterText
qualifiedName
transaction {
__typename
# ...TransactionFragment
}
}
}
pageInfo {
startCursor
endCursor
hasNextPage
hasPreviousPage
}
totalCount
}
}{ "qualifiedEventName": "Example String", "moduleName": "Example String", "blockHash": "Example String", "requestKey": "Example String", "chainId": "Example String", "maxHeight": 40, "minHeight": 40, "minimumDepth": 40, "orderIndex": 40, "parametersFilter": "Example String", "after": "Example String", "before": "Example String", "first": 40, "last": 40 }
{ "data": { "edges": [ { "cursor": "Example String", "node": { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "name": "Example String", "block": { "__typename": "Block" }, "chainId": "Example Custom Scalar", "height": "Example Custom Scalar", "moduleName": "Example String", "orderIndex": "Example Custom Scalar", "requestKey": "Example String", "parameters": "Example String", "parameterText": "Example String", "qualifiedName": "Example String", "transaction": { "__typename": "Transaction" } } } ], "pageInfo": { "startCursor": "Example String", "endCursor": "Example String", "hasNextPage": true, "hasPreviousPage": true }, "totalCount": 40 } }
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" } } ] }