# Solana
`: pubkey of account to query, as base-58 encoded string.
* `` (optional): configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `encoding` (string): encoding for Account data, either "base58" (slow), "base64", "base64+zstd", or "jsonParsed". "base58" is limited to Account data of less than 129 bytes. "base64" will return base64 encoded data for Account data of any size. "base64+zstd" compresses the Account data using [Zstandard](https://facebook.github.io/zstd/) and base64-encodes the result. ["jsonParsed" encoding](https://docs.solana.com/developing/clients/jsonrpc-api#parsed-responses) attempts to use program-specific state parsers to return more human-readable and explicit account state data. If "jsonParsed" is requested but a parser cannot be found, the field falls back to "base64" encoding, detectable when the `data` field is type `string`.
* `dataSlice` (object): limit the returned account data using the provided `offset: ` and `length: ` fields; only available for "base58", "base64" or "base64+zstd" encodings.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
* ``: if the requested account doesn't exist.
* ``: otherwise a JSON object containing:
* `lamports` (u64): number of lamports assigned to this account, as a u64.
* `owner` (string): base-58 encoded Pubkey of the program this account has been assigned to.
* `data` (\[string, encoding]|object): data associated with the account, either as encoded binary data or JSON format `{: }`, depending on the encoding parameter.
* `executable` (boolean): boolean indicating if the account contains a program (and is strictly read-only).
* `rentEpoch` (u64): the epoch at which this account will next owe rent, as u64.
#### Request example 1
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getAccountInfo",
"params": [
"vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg",
{
"encoding": "base58"
}
],
"id": 1
}'
```
#### Response example 1
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374431575
},
"value": {
"data": [
"",
"base58"
],
"executable": false,
"lamports": 88860054690252,
"owner": "11111111111111111111111111111111",
"rentEpoch": 18446744073709551615,
"space": 0
}
}
}
```
#### Request example 2
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getAccountInfo",
"params": [
"4fYNw3dojWmQ4dXtSGE9epjRGy9pFSx62YypT7avPYvA",
{
"encoding": "jsonParsed"
}
],
"id": 1
}'
```
#### Response example 2
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374431699
},
"value": {
"data": [
"",
"base64"
],
"executable": false,
"lamports": 7998763451,
"owner": "2WRuhE4GJFoE23DYzp2ij6ZnuQ8p9mJeU6gDgfsjR4or",
"rentEpoch": 18446744073709551615,
"space": 0
}
}
}
```
***
### `getBalance`
> **Returns the lamport balance of the account at the given public key.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: pubkey of account to query, as base-58 encoded string.
* ``: configuration object containing the following fields:
* `commitment` (string; optional): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `minContextSlot` (number; optional): sets the minimum slot that the request can be evaluated at.
#### Returns
* `value` (u64): an account balance.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getBalance",
"params": [
"4fYNw3dojWmQ4dXtSGE9epjRGy9pFSx62YypT7avPYvA"
],
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getBalance",
params: ["4fYNw3dojWmQ4dXtSGE9epjRGy9pFSx62YypT7avPYvA"],
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getBalance",
"params": ["4fYNw3dojWmQ4dXtSGE9epjRGy9pFSx62YypT7avPYvA"],
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374431850
},
"value": 7998763451
}
}
```
***
### `getBlock`
> **Returns the transaction list and block metadata for the confirmed block at the specified slot.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: slot, as a u64 integer.
* `` (optional): configuration object containing the following optional fields:
* `encoding` (string): encoding for each returned Transaction, either "json", "jsonParsed", "base58" (slow), "base64". If parameter not provided, the default encoding is "json". ["jsonParsed" encoding](https://docs.solana.com/developing/clients/jsonrpc-api#parsed-responses) attempts to use program-specific instruction parsers to return more human-readable and explicit data in the `transaction.message.instructions` list. If "jsonParsed" is requested but a parser cannot be found, the instruction falls back to regular JSON encoding (`accounts`, `data`, and `programIdIndex` fields).
* `transactionDetails` (string): level of transaction detail to return, either "full", "accounts", "signatures", or "none". If parameter not provided, the default detail level is "full". If "accounts" are requested, transaction details only include signatures and an annotated list of accounts in each transaction. Transaction metadata is limited to only: fee, err, pre\_balances, post\_balances, pre\_token\_balances, and post\_token\_balances.
* `rewards` (boolean): whether to populate the `rewards` array. If parameter not provided, the default includes rewards.
* `commitment` (string; default: "finalized"): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `maxSupportedTransactionVersion` (number): sets the max transaction version to return in responses. If the requested block contains a transaction with a higher version, an error will be returned. If this parameter is omitted, only legacy transactions will be returned, and a block containing any versioned transaction will prompt the error.
#### Returns
* ``: if specified block is not confirmed.
* ``: if block is confirmed, an object with the following fields:
* `blockhash` (string): the blockhash of this block, as base-58 encoded string.
* `previousBlockhash` (string): the blockhash of this block's parent, as base-58 encoded string; if the parent block is not available due to ledger cleanup, this field will return "11111111111111111111111111111111".
* `parentSlot` (u64): the slot index of this block's parent.
* `transactions` (array): to be included if "full" transaction details are requested; an array of JSON objects containing:
* `transaction` (object|\[string,encoding]): a [transaction object](https://docs.solana.com/developing/clients/jsonrpc-api#transaction-structure), either in JSON format or encoded binary data, depending on encoding parameter.
* `meta` (object): a transaction status metadata object, containing `null` or:
* `err` (object|null): an error if transaction failed, null if transaction succeeded. [TransactionError definitions](https://github.com/solana-labs/solana/blob/c0c60386544ec9a9ec7119229f37386d9f070523/sdk/src/transaction/error.rs#L13).
* `fee` (u64): a fee this transaction was charged with, as u64 integer.
* `preBalances` (array): an array of u64 account balances from before the transaction was processed.
* `postBalances` (array): an array of u64 account balances after the transaction was processed.
* `innerInstructions` (array|null): the list of [inner instructions](https://docs.solana.com/developing/clients/jsonrpc-api#inner-instructions-structure) or null if inner instruction recording was not enabled during this transaction.
* `preTokenBalances` (array|undefined): the list of [token balances](https://docs.solana.com/developing/clients/jsonrpc-api#token-balances-structure) from before the transaction was processed or omitted if token balance recording was not yet enabled during this transaction.
* `postTokenBalances` (array|undefined): the list of [token balances](https://docs.solana.com/developing/clients/jsonrpc-api#token-balances-structure) from after the transaction was processed or omitted if token balance recording was not yet enabled during this transaction.
* `logMessages` (array|null): an array of string log messages or `null` if log message recording was not enabled during this transaction.
* `rewards` (array|null): transaction-level rewards, populated if rewards are requested; an array of JSON objects containing:
* `pubkey` (string): the public key, as base-58 encoded string, of the account that received the reward.
* `lamports` (i64): the number of reward lamports credited or debited by the account, as an i64.
* `postBalance` (u64): an account balance in lamports after the reward was applied.
* `rewardType` (string|undefined): the type of reward: "fee", "rent", "voting", "staking".
* `commission` (u8|undefined): a vote account commission when the reward was credited, only present for voting and staking rewards.
* \[DEPRECATED] `status` (object): a transaction status:
* `"Ok": `: a transaction was successful.
* `"Err": `: a transaction failed with TransactionError.
* `loadedAddresses` (object|undefined): transaction addresses loaded from address lookup tables. Undefined if `maxSupportedTransactionVersion` is not set in request params:
* `writable` (array\[string]): an ordered list of base-58 encoded addresses for writable loaded accounts.
* `readonly` (array\[string]): an ordered list of base-58 encoded addresses for readonly loaded accounts.
* `returnData` (object|undefined): the most-recent return data generated by an instruction in the transaction, with the following fields:
* `programId` (string): the program that generated the return data, as base-58 encoded Pubkey.
* `data` (string, encoding): the return data itself, as base-64 encoded binary data.
* `computeUnitsConsumed` (u64|undefined): the number of [compute units](https://docs.solana.com/developing/programming-model/runtime#compute-budget) consumed by the transaction.
* `version` ("legacy"|number|undefined): a transaction version; undefined if `maxSupportedTransactionVersion` is not set in request params.
* `signatures` (array): to be included if "signatures" are requested for transaction details; an array of signatures strings, corresponding to the transaction order in the block.
* `rewards` (array|undefined): block-level rewards, present if rewards are requested; an array of JSON objects containing:
* `pubkey` (string): the public key, as base-58 encoded string, of the account that received the reward.
* `lamports` (i64): the number of reward lamports credited or debited by the account, as an i64.
* `postBalance` (u64): an account balance in lamports after the reward was applied.
* `rewardType` (string|undefined): the type of reward: "fee", "rent", "voting", "staking".
* `commission` (u8|undefined): the vote account commission when the reward was credited, included for voting and staking rewards only.
* `blockTime` (i64|null): estimated production time, as Unix timestamp (seconds since the Unix epoch). null if not available.
* `blockHeight` (u64|null): the number of blocks beneath this block.
#### Request example 1
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getBlock",
"params": [370774640, {"encoding": "json","maxSupportedTransactionVersion":0,"transactionDetails":"full","rewards":false}],
"id": 1
}'
```
#### Response example 1
```json
{
"jsonrpc": "2.0",
"result": {
"blockHeight": 358752908,
"blockTime": 1743307608,
"blockhash": "HF4FCaWTHZqoTSqeZS5xtqfvKB3crSHgqugWCC2CrF6N",
"parentSlot": 370774639,
"previousBlockhash": "2f1r7z58nr7HX92YDko28wAHTyWAHYvmDHfVjSApvw7T",
"transactions": [
{
"meta": {
"computeUnitsConsumed": 150,
"err": null,
"fee": 5000,
"innerInstructions": [],
"loadedAddresses": {
"readonly": [],
"writable": []
},
"logMessages": [
"Program 11111111111111111111111111111111 invoke [1]",
"Program 11111111111111111111111111111111 success"
],
"postBalances": [
10804309975,
10804407530,
1
],
"postTokenBalances": [],
"preBalances": [
10804315088,
10804407417,
1
],
"preTokenBalances": [],
"rewards": null,
"status": {
"Ok": null
}
},
"transaction": {
"message": {
"accountKeys": [
"ANVUJaJoVaJZELtV2AvRp7V5qPV1B84o29zAwDhPj1c2",
"4PkiqJkUvxr9P8C1UsMqGN8NJsUcep9GahDRLfmeu8UK",
"11111111111111111111111111111111"
],
"header": {
"numReadonlySignedAccounts": 0,
"numReadonlyUnsignedAccounts": 1,
"numRequiredSignatures": 1
},
"instructions": [
{
"accounts": [
0,
1
],
"data": "3Bxs4KkuG3n7y751",
"programIdIndex": 2,
"stackHeight": null
}
],
"recentBlockhash": "2XvJSKxQXyiYzdVdWQ3hQkb7FZMRnevWUtyttLCtweha"
},
"signatures": [
"32wUcJEURNhdDJve1y7giwE1zhMWRgGbNwfn3cxsLmtTznnunGEbvDjkispJCVnu7XfTmHreeLfRDpETgzczMG8B"
]
},
"version": "legacy"
}
]
},
"id": 1
}
```
#### Request example 2
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getBlock",
"params": [370774640, "base64"],
"id": 1
}'
```
#### Response example 2
```json
{
"jsonrpc": "2.0",
"result": {
"blockHeight": 358752908,
"blockTime": 1743307608,
"blockhash": "HF4FCaWTHZqoTSqeZS5xtqfvKB3crSHgqugWCC2CrF6N",
"parentSlot": 370774639,
"previousBlockhash": "2f1r7z58nr7HX92YDko28wAHTyWAHYvmDHfVjSApvw7T",
"rewards": [
{
"commission": null,
"lamports": 77800,
"postBalance": 1012068020241072,
"pubkey": "dv2eQHeP4RFrJZ6UeiZWoc3XTtmtZCUKxxCApCDcRNV",
"rewardType": "Fee"
}
],
"transactions": [
{
"meta": {
"computeUnitsConsumed": 150,
"err": null,
"fee": 5000,
"innerInstructions": [],
"loadedAddresses": {
"readonly": [],
"writable": []
},
"logMessages": [
"Program 11111111111111111111111111111111 invoke [1]",
"Program 11111111111111111111111111111111 success"
],
"postBalances": [
10804309975,
10804407530,
1
],
"postTokenBalances": [],
"preBalances": [
10804315088,
10804407417,
1
],
"preTokenBalances": [],
"rewards": [],
"status": {
"Ok": null
}
},
"transaction": [
"AWW00bg6XvEKFL0bfYFKxozs1lqn2iXsNGSISW8ecRprGyocrjVocrAFanSZbvhHxCtlHHELDHJQwMzkvi7AtQwBAAEDizqSQJGZ3Exs17wQBP+BB3AlC5LWj0lppkJp/w/nr98yZ0Y8gaZ3Klk/NF/WDYIThTzpRp42PYFbnRVVqliKHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFsdg39g9WrKEsn+BDMcD8H/kmr6+KwxKnn0feVGtoSUBAgIAAQwCAAAAcQAAAAAAAAA=",
"base64"
]
}
]
},
"id": 1
}
```
***
### `getBlockHeight`
> **Returns the current block height of the validator.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (optional): configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
* ``: a current block height.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getBlockHeight",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getBlockHeight",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getBlockHeight",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": 362409082,
"id": 1
}
```
***
### `getBlockProduction`
> **Returns recent block production statistics for the current or a prior epoch.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (optional): configuration object containing the following optional fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `range` (object): a slot range to return block production for. If parameter not provided, defaults to current epoch:
* `firstSlot` (u64): the first slot to return block production information for (inclusive).
* `lastSlot` (u64): the last slot to return block production information for (inclusive). If parameter not provided, defaults to the highest slot.
* `identity` (string): only return results for this validator identity (base-58 encoded).
#### Returns
* `value` (object): the value containing the following parameters:
* `byIdentity` (object): a dictionary of validator identities, as base-58 encoded strings. Value is a two element array containing the number of leader slots and the number of blocks produced.
* `range` (object): a block production slot range:
* `firstSlot` (u64): the first slot of the block production information (inclusive).
* `lastSlot` (u64): the last slot of block production information (inclusive).
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getBlockProduction",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getBlockProduction",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getBlockProduction",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374432777
},
"value": {
"byIdentity": {
"3zvXem8vqvDYos6BKu66FV84tmDdQwgLxYSempy8tSrs": [
984,
984
],
"4mdQGkbfrFvo5eG722xCXik4hn3xzu2EJD47g7Hd4HfH": [
16,
16
],
"97YUjL2EK42M6jG5VA4fKuVxGXDfxsC5Zawd9haLQJGk": [
200,
200
]
},
"range": {
"firstSlot": 374112000,
"lastSlot": 374432777
}
}
}
}
```
***
### `getBlockCommitment`
> **Returns the commitment (stake-weighted vote count) for the block at the specified slot.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): the block identified by slot.
#### Returns
* `commitment`: a commitment, comprising either:
* `null`: an unknown block.
* ``: a commitment, array of u64 integers logging the amount of cluster stake in lamports that has voted on the block at each depth from 0 to `MAX_LOCKOUT_HISTORY` + 1.
* `totalStake`: a total active stake, in lamports, of the current epoch.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getBlockCommitment",
"params": [5],
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getBlockCommitment",
params: [5],
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getBlockCommitment",
"params": [5],
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"commitment": null,
"totalStake": 157766894165168736
}
}
```
***
### `getBlocks`
> **Returns a list of confirmed block slots between the two given slots.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: `start_slot`, as a u64 integer.
* ``: `end_slot`, as u64 integer (must be no more than 500,000 blocks higher than the `start_slot`).
* ``: a configuration object containing the following field:
* `commitment` (string; default: "finalized"): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
#### Returns
The result field will be an array of u64 integers listing confirmed blocks between `start_slot` and either `end_slot`, if provided, or latest confirmed block, inclusive. Max range allowed is 500,000 slots.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getBlocks",
"params": [374434259, 374434262],
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getBlocks",
params: [374434259, 374434262],
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getBlocks",
"params": [374434259, 374434262],
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": [
374434259,
374434260,
374434261,
374434262
]
}
```
***
### `getBlocksWithLimit`
> **Returns a list of confirmed block slots starting at the given slot, up to the specified limit.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: `start_slot`, as u64 integer.
* ``: limit, as u64 integer (must be no more than 500,000 blocks higher than the `start_slot`).
* `` (optional): a configuration object containing the following field:
* `commitment` (string; default: "finalized"): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
#### Returns
The result field will be an array of u64 integers listing confirmed blocks starting at `start_slot` for up to `limit` blocks, inclusive.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getBlocksWithLimit",
"params": [370778924, 3],
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getBlocksWithLimit",
params: [370778924, 3],
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getBlocksWithLimit",
"params": [370778924, 3],
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": [
370779536,
370779537,
370779538
]
}
```
***
### `getBlockTime`
> **Returns the estimated Unix timestamp for the block at the given slot.**
Each validator reports their UTC time to the ledger on a regular interval by intermittently adding a timestamp to a Vote for a particular block. A requested block's time is calculated from the stake-weighted mean of the Vote timestamps in a set of recent blocks recorded on the ledger.
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: the block identified by slot.
#### Returns
* ``: estimated production time, as Unix timestamp (seconds since the Unix epoch).
* `null`: the timestamp is not available for this block.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getBlockTime",
"params": [374436187],
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getBlockTime",
params: [374436187],
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getBlockTime",
"params": [374436187],
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": 1744726372,
"id": 1
}
```
***
### `getClusterNodes`
> **Returns identity, gossip, and RPC address information for all nodes in the cluster.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
The result field will be an array of JSON objects, each with the following subfields:
* `pubkey` (string): the node public key, as base-58 encoded string.
* `gossip` (string|null): a gossip network address for the node.
* `tpu` (string|null): a TPU network address for the node.
* `rpc` (string|null): a JSON RPC network address for the node, or null if the JSON RPC service is not enabled.
* `version` (string|null): the software version of the node, or null if the version information is not available.
* `featureSet` (u32|null): the unique identifier of the node's feature set.
* `shredVersion` (u16|null): the shred version the node has been configured to use.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getClusterNodes",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getClusterNodes",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getClusterNodes",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": [
{
"featureSet": 3294202862,
"gossip": "63.251.106.87:21810",
"pubkey": "DiwJZxYKQbWBn59EhUhkiB3hM1TLWiQoGvD5mpUHJscu",
"pubsub": "63.251.106.87:21812",
"rpc": "63.251.106.87:21811",
"serveRepair": "63.251.106.87:11812",
"shredVersion": 2405,
"tpu": "63.251.106.87:11803",
"tpuForwards": "63.251.106.87:11804",
"tpuForwardsQuic": "63.251.106.87:11810",
"tpuQuic": "63.251.106.87:11809",
"tpuVote": "63.251.106.87:11805",
"tvu": "63.251.106.87:11801",
"version": "2.2.3"
}
],
"id": 1
}
```
***
### `getEpochInfo`
> **Returns information about the current epoch including slot index, epoch number, and slot count.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (optional): configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
The result field will be an object with the following fields:
* `absoluteSlot` (u64): the current slot.
* `blockHeight` (u64): the current block height.
* `epoch` (u64): the current epoch.
* `slotIndex` (u64): the current slot relative to the start of the current epoch.
* `slotsInEpoch` (u64): the number of slots in this epoch.
* `transactionCount` (u64|null) total number of transactions processed without error since genesis.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getEpochInfo",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getEpochInfo",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getEpochInfo",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"absoluteSlot": 374436745,
"blockHeight": 362413120,
"epoch": 866,
"slotIndex": 324745,
"slotsInEpoch": 432000,
"transactionCount": 15534671467
}
}
```
***
### `getEpochSchedule`
> **Returns the epoch schedule from the cluster's genesis configuration.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
The result is an object containing the following parameters:
* `slotsPerEpoch` (u64): the maximum number of slots in each epoch.
* `leaderScheduleSlotOffset` (u64): the number of slots before beginning of an epoch to calculate a leader schedule for that epoch.
* `warmup` (boolean): whether epochs start short and grow.
* `firstNormalEpoch` (u64): the first normal-length epoch, log2(slotsPerEpoch) - log2(MINIMUM\_SLOTS\_PER\_EPOCH).
* `firstNormalSlot` (u64): MINIMUM\_SLOTS\_PER\_EPOCH \* (2.pow(firstNormalEpoch) - 1).
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getEpochSchedule",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getEpochSchedule",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getEpochSchedule",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"firstNormalEpoch": 0,
"firstNormalSlot": 0,
"leaderScheduleSlotOffset": 432000,
"slotsPerEpoch": 432000,
"warmup": false
}
}
```
***
### `getFeeForMessage`
> **Returns the fee in lamports the network will charge for the given base-64 encoded message.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `message` (string, required): a base-64 encoded message.
* `` (optional): a configuration object containing the following optional fields:
* `commitment` (string): used for retrieving blockhash; the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `minContextSlot` (number; optional): sets the minimum slot that the request can be evaluated at.
#### Returns
* ``: the fee corresponding to the message at the specified blockhash.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getFeeForMessage",
"params":[
"AQABAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAA",
{
"commitment": "processed"
}
],
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getFeeForMessage",
params: ["AQABAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAA", {"commitment": "processed"}],
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getFeeForMessage",
"params": ["AQABAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAA", {"commitment": "processed"}],
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374437860
},
"value": null
}
}
```
***
### `getFirstAvailableBlock`
> **Returns the slot of the lowest confirmed block still available in the ledger (not yet purged).**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
* ``: a slot.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getFirstAvailableBlock",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getFirstAvailableBlock",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getFirstAvailableBlock",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": 370779475,
"id": 1
}
```
***
### `getGenesisHash`
> **Returns the genesis hash of the cluster.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
* ``: the hash as base-58 encoded string.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getGenesisHash",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getGenesisHash",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getGenesisHash",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG",
"id": 1
}
```
***
### `getHealth`
> **Returns the health status of the node — 'ok' if healthy.**
If one or more `--known-validator` arguments are provided to `solana-validator`, "ok" is returned when the node has within `HEALTH_CHECK_SLOT_DISTANCE` slots of the highest known validator, otherwise an error is returned. "ok" is always returned if no known validators are provided.
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
If the node is healthy: "ok" If the node is unhealthy, a JSON RPC error response is returned. The specifics of the error response are UNSTABLE and may change in the future.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getHealth",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getHealth",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getHealth",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example (healthy)
```json
{
"jsonrpc": "2.0",
"result": "ok",
"id": 1
}
```
#### Response example (unhealthy)
```json
{
"jsonrpc": "2.0",
"error": {
"code": -32005,
"message": "Node is unhealthy",
"data": {}
},
"id": 1
}
```
#### Response example (unhealthy; additional info)
```json
{
"jsonrpc": "2.0",
"error": {
"code": -32005,
"message": "Node is behind by 42 slots",
"data": {
"numSlotsBehind": 42
}
},
"id": 1
}
```
***
### `getHighestSnapshotSlot`
NEW: This method is only available in solana-core v1.9 or newer. Please use \[\`getSnapshotSlot\`]\(/rpc-service/chains/chains-api/solana/#getsnapshotslot) for solana-core v1.8
> **Returns the highest slot information that the node has snapshots for.**
This will find the highest full snapshot slot, and the highest incremental snapshot slot based on the full snapshot slot, if there is one.
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
* ``:
* `full` (u64): the highest full snapshot slot.
* `incremental` (u64|undefined): the highest incremental snapshot slot based on `full`.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getHighestSnapshotSlot",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getHighestSnapshotSlot",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getHighestSnapshotSlot",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"full": 374423617,
"incremental": 374438029
}
}
```
#### Response example (no snapshot)
```json
{
"jsonrpc": "2.0",
"error": {
"code": -32008,
"message": "No snapshot"
},
"id": 1
}
```
***
### `getIdentity`
> **Returns the identity public key of the current node.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
The `result` parameter containing the following field:
* `identity` (base-58 encoded string): the identity pubkey of the current node.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getIdentity",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getIdentity",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getIdentity",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"identity": "6ZaNrpjNZMmtAaZ4Tjj7GhmgbqpRR9vnipoCgwqjCHR5"
}
}
```
***
### `getInflationGovernor`
> **Returns the current inflation governor parameters (initial, terminal, taper, foundation).**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (optional): the configuration object containing the following field:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
#### Returns
* `initial` (f64): the initial inflation percentage from time 0.
* `terminal` (f64): the terminal inflation percentage.
* `taper` (f64): the rate per year at which inflation is lowered. Rate reduction is derived using the target slot time in genesis config.
* `foundation` (f64): the percentage of total inflation allocated to the foundation.
* `foundationTerm` (f64): the duration of foundation pool inflation in years.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getInflationGovernor",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getInflationGovernor",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getInflationGovernor",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"foundation": 0.0,
"foundationTerm": 0.0,
"initial": 0.08,
"taper": 0.15,
"terminal": 0.015
}
}
```
***
### `getInflationRate`
> **Returns the specific inflation values for the current epoch.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
* `total` (f64): the total inflation.
* `validator` (f64): the inflation allocated to validators.
* `foundation` (f64): the inflation allocated to the foundation.
* `epoch` (u64): the epoch for which these values are valid.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getInflationRate",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getInflationRate",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getInflationRate",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"epoch": 866,
"foundation": 0.0,
"total": 0.03846001179398413,
"validator": 0.03846001179398413
}
}
```
***
### `getInflationReward`
> **Returns the staking inflation reward earned by a list of addresses for the specified epoch.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: an array of addresses to query, as base-58 encoded strings:
* `` (optional): the configuration object containing the following fields:
* commitment (string; optional): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `epoch` (u64; optional): an epoch for which the reward occurs. If omitted, the previous epoch will be used.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
* `epoch` (u64): the epoch for which reward occurred.
* `effectiveSlot`(u64): the slot in which the rewards are effective
* `amount` (u64): the reward amount in lamports.
* `postBalance` (u64): the post balance of the account in lamports.
* `commission` (u8|undefined): the vote account commission when the reward was credited.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getInflationReward",
"params": [["vgcDar2pryHvMgPkKaZfh8pQy4BJxv7SpwUG7zinWjG"], {"epoch": 865}],
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getInflationReward",
params: [["vgcDar2pryHvMgPkKaZfh8pQy4BJxv7SpwUG7zinWjG"], {"epoch": 865}],
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getInflationReward",
"params": [["vgcDar2pryHvMgPkKaZfh8pQy4BJxv7SpwUG7zinWjG"], {"epoch": 865}],
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": [
{
"amount": 62104278891217,
"commission": 95,
"effectiveSlot": 374112000,
"epoch": 865,
"postBalance": 10748380652807189
}
]
}
```
***
### `getLargestAccounts`
> **Returns the 20 accounts with the largest lamport balances on the network.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (optional): the configuration object containing the following optional fields:
* commitment (string; optional): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `filter` (string; optional): filters results by account type; currently supported: `circulating`|`nonCirculating`.
#### Returns
The result will be a JSON object with value equal to an array of:
* ``: a JSON object containing the following fields:
* `address` (string): the base-58 encoded address of the account.
* `lamports` (u64): the number of lamports in the account, as a u64.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getLargestAccounts",
"params": [
{ "filter": "nonCirculating" }
],
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getLargestAccounts",
params: [{"filter": "nonCirculating"}],
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getLargestAccounts",
"params": [{"filter": "nonCirculating"}],
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": [
{
"lamports": 999999990000000000,
"address": "11111111111111111111111111111111"
},
{
"lamports": 854321560000000000,
"address": "SysvarC1ock11111111111111111111111111111111"
},
{
"lamports": 732000000000000000,
"address": "Stake11111111111111111111111111111111111111"
},
{
"lamports": 690000000000000000,
"address": "Vote111111111111111111111111111111111111111"
},
{
"lamports": 540000000000000000,
"address": "NativeLoader1111111111111111111111111111111"
},
{
"lamports": 500000000000000000,
"address": "Config1111111111111111111111111111111111111"
}
],
"id": 1
}
```
***
### `getLatestBlockhash`
NEW: This method is only available in solana-core v1.9 or newer. Please use \[\`getRecentBlockhash\`]\(/rpc-service/chains/chains-api/solana/#getrecentblockhash) for solana-core v1.8
> **Returns the latest blockhash.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (optional): the configuration object containing the following fields:
* `commitment` (string; optional): used for retrieving blockhash); the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `minContextSlot` (number; optional): sets the minimum slot that the request can be evaluated at.
#### Returns
* ``: a JSON object with value field set to a JSON object including:
* `blockhash` (string): a hash as base-58 encoded string.
* `lastValidBlockHeight` (u64): the last block height at which the blockhash will be valid.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getLatestBlockhash",
"params": [
{
"commitment": "processed"
}
],
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getLatestBlockhash",
params: [{"commitment": "processed"}],
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getLatestBlockhash",
"params": [{"commitment": "processed"}],
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374442143
},
"value": {
"blockhash": "5SVbJEwUwvS2PmGSMKcshCanrCnYcDBEpCp3aR7up6GV",
"lastValidBlockHeight": 362418664
}
}
}
```
***
### `getLeaderSchedule`
> **Returns the leader schedule (slot-to-validator mapping) for the given epoch.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (optional): fetches the leader schedule for the epoch that corresponds to the provided slot. If unspecified, fetches the leader schedule for the current epoch.
* `` (optional): the configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `identity` (string): returns only the results for this validator identity (base-58 encoded).
#### Returns
* `null`: if requested epoch is not found.
* ``: otherwise, the result field will be a dictionary of validator identities, as base-58 encoded strings, and their corresponding leader slot indices as values (indices are relative to the first slot in the requested epoch).
#### Request example 1
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getLeaderSchedule",
"params": [374442395],
"id": 1
}'
```
#### Response example 1
```json
{
"jsonrpc": "2.0",
"result": {
"3zvXem8vqvDYos6BKu66FV84tmDdQwgLxYSempy8tSrs": [
2576,
2577,
2578,
2579,
3448,
3449,
3450
]
},
"id": 1
}
```
#### Request example 2
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getLeaderSchedule",
"params": [
null,
{
"identity": "dv3qDFk1DTF36Z62bNvrCXe9sKATA6xvVy6A798xxAS"
}
],
"id": 1
}'
```
#### Response example 2
```json
{
"jsonrpc": "2.0",
"result": {
"dv3qDFk1DTF36Z62bNvrCXe9sKATA6xvVy6A798xxAS": [
12,
13,
14,
15,
32,
33,
34,
35,
44,
45,
46,
47
]
},
"id": 1
}
```
***
### `getMaxRetransmitSlot`
> **Returns the maximum slot the retransmit stage has seen.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
* ``: the slot.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getMaxRetransmitSlot",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getMaxRetransmitSlot",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getMaxRetransmitSlot",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": 374443337,
"id": 1
}
```
***
### `getMaxShredInsertSlot`
Returns the max slot seen from after shred insert.
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
* ``: the slot.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getMaxShredInsertSlot",
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getMaxShredInsertSlot",
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getMaxShredInsertSlot",
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": 374443465,
"id": 1
}
```
***
### `getMinimumBalanceForRentExemption`
> **Returns the minimum lamport balance an account must hold to be exempt from rent.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: the account data length.
* `` (optional): the configuration object containing the following field:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
#### Returns
* ``: the minimum lamports required in an account.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"method": "getMinimumBalanceForRentExemption",
"params": [50],
"id": 1
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "getMinimumBalanceForRentExemption",
params: [50],
id: 1
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"method": "getMinimumBalanceForRentExemption",
"params": [50],
"id": 1
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": 1238880,
"id": 1
}
```
***
### `getMultipleAccounts`
> **Returns account data for a list of public keys in a single request.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: an array of Pubkeys to query, as base-58 encoded strings (up to a maximum of 100).
* `` (optional): the configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `encoding` (string): encoding for Account data, either "base58" (slow), "base64", "base64+zstd", or "jsonParsed". "base58" is limited to Account data of less than 129 bytes. "base64" will return base64 encoded data for Account data of any size. "base64+zstd" compresses the Account data using [Zstandard](https://facebook.github.io/zstd/) and base64-encodes the result. ["jsonParsed" encoding](https://docs.solana.com/developing/clients/jsonrpc-api#parsed-responses) attempts to use program-specific state parsers to return more human-readable and explicit account state data. If "jsonParsed" is requested but a parser cannot be found, the field falls back to "base64" encoding, detectable when the `data` field is type `string`.
* `dataSlice` (object): limits the returned account data using the provided `offset: ` and `length: ` fields; only available for "base58", "base64" or "base64+zstd" encodings.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
The result will be a JSON object with value equal to an array of:
* `null`: if the account at that Pubkey doesn't exist.
* ``: otherwise, a JSON object containing:
* `lamports` (u64): the number of lamports assigned to this account, as a u64.
* `owner` (string): a base-58 encoded Pubkey of the program this account has been assigned to.
* `data`(\[string, encoding]|object): data associated with the account, either as encoded binary data or JSON format `{: }`, depending on the encoding parameter.
* `executable`(boolean): a boolean indicating if the account contains a program (and is strictly read-only).
* `rentEpoch` (u64): the epoch at which this account will next owe rent, as u64.
#### Request example 1
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getMultipleAccounts",
"params": [
[
"vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg",
"4fYNw3dojWmQ4dXtSGE9epjRGy9pFSx62YypT7avPYvA"
],
{
"dataSlice": {
"offset": 0,
"length": 0
}
}
]
}'
```
#### Response example 1
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374443766
},
"value": [
{
"data": [
"",
"base64"
],
"executable": false,
"lamports": 88860054690252,
"owner": "11111111111111111111111111111111",
"rentEpoch": 18446744073709551615,
"space": 0
},
{
"data": [
"",
"base64"
],
"executable": false,
"lamports": 7998763451,
"owner": "2WRuhE4GJFoE23DYzp2ij6ZnuQ8p9mJeU6gDgfsjR4or",
"rentEpoch": 18446744073709551615,
"space": 0
}
]
}
}
```
#### Request example 2
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getMultipleAccounts",
"params": [
[
"vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg",
"4fYNw3dojWmQ4dXtSGE9epjRGy9pFSx62YypT7avPYvA"
],
{
"encoding": "base58"
}
]
}'
```
#### Response example 2
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374443852
},
"value": [
{
"data": [
"",
"base58"
],
"executable": false,
"lamports": 88860054690252,
"owner": "11111111111111111111111111111111",
"rentEpoch": 18446744073709551615,
"space": 0
},
{
"data": [
"",
"base58"
],
"executable": false,
"lamports": 7998763451,
"owner": "2WRuhE4GJFoE23DYzp2ij6ZnuQ8p9mJeU6gDgfsjR4or",
"rentEpoch": 18446744073709551615,
"space": 0
}
]
}
}
```
***
### `getProgramAccounts`
> **Returns all accounts owned by the given program public key.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: the Pubkey of a program, as base-58 encoded string.
* `` (optional): the configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `encoding` (string): encoding for Account data, either "base58" (slow), "base64", "base64+zstd", or "jsonParsed". "base58" is limited to Account data of less than 129 bytes. "base64" will return base64 encoded data for Account data of any size. "base64+zstd" compresses the Account data using [Zstandard](https://facebook.github.io/zstd/) and base64-encodes the result. ["jsonParsed" encoding](https://docs.solana.com/developing/clients/jsonrpc-api#parsed-responses) attempts to use program-specific state parsers to return more human-readable and explicit account state data. If "jsonParsed" is requested but a parser cannot be found, the field falls back to "base64" encoding, detectable when the `data` field is type `string`.
* `dataSlice` (object): limits the returned account data using the provided `offset: ` and `length: ` fields; only available for "base58", "base64" or "base64+zstd" encodings.
* `filters` (array): filters the results using up to 4 filter objects; the account must meet all the filter criteria to be included in results:
* `memcmp` (object): compares a provided series of bytes with program account data at a particular offset. Fields:
* `offset` (usize): an offset into program account data to start comparison.
* `bytes` (string): the data to match, as encoded string.
* `encoding` (string): an encoding for the filter bytes data, either "base58" or "base64". Data is limited in size to 128 or fewer decoded bytes. NEW: This field, and base64 support generally, is only available in solana-core v1.14.0 or newer. Please omit when querying nodes on earlier versions.
* `dataSize` (u64): compares the program account data length with the provided data size
* `withContext` (boolean): wraps the result in a JSON object.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
By default, the result field will be an array of JSON objects. If `withContext` flag is set, the array will be wrapped in a JSON object.
* `pubkey` (string): the account Pubkey as base-58 encoded string.
* `account` (object): a JSON object, with the following subfields:
* `lamports` (u64): the number of lamports assigned to this account, as a u64.
* `owner` (string): the base-58 encoded Pubkey of the program this account has been assigned to.
* `data` (\[string,encoding]|object): the data associated with the account, either as encoded binary data or JSON format `{: }`, depending on encoding parameter.
* `executable` (bool): a boolean indicating if the account contains a program (and is strictly read-only).
* `rentEpoch` (u64): the epoch at which this account will next owe rent, as a u64.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getProgramAccounts",
"params": [
"675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8",
{
"encoding": "base64"
}
]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getProgramAccounts",
params: ["675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8", {"encoding": "base64"}]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getProgramAccounts",
"params": ["675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8", {"encoding": "base64"}]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": [
{
"account": {
"data": [
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
"base64"
],
"executable": false,
"lamports": 8017920,
"owner": "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8",
"rentEpoch": 18446744073709551615,
"space": 1024
},
"pubkey": "6uSF3nNb8ZZahnLEgDjXVFWTBeS9WVMh89BiRnJKhCT8"
}
],
"id": 1
}
```
***
### `getRecentPerformanceSamples`
> **Returns recent performance samples showing transactions-per-second and slot throughput.**
Performance samples are taken every 60 seconds and include the number of transactions and slots that occur in a given time window.
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `limit` (usize; optional): the number of samples to return (max: 720).
#### Returns
The `result` object containing the following parameters:
* `slot` (u64): the slot in which sample was taken at.
* `numTransactions` (u64): the number of transactions in a sample.
* `numSlots` (u64): the number of slots in a sample.
* `samplePeriodSecs` (u16): the number of seconds in a sample window.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getRecentPerformanceSamples",
"params": [4]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getRecentPerformanceSamples",
params: [4]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getRecentPerformanceSamples",
"params": [4]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": [
{
"numNonVoteTransactions": 4059,
"numSlots": 152,
"numTransactions": 6339,
"samplePeriodSecs": 60,
"slot": 374448056
},
{
"numNonVoteTransactions": 5343,
"numSlots": 150,
"numTransactions": 7592,
"samplePeriodSecs": 60,
"slot": 374447904
},
{
"numNonVoteTransactions": 5971,
"numSlots": 153,
"numTransactions": 8250,
"samplePeriodSecs": 60,
"slot": 374447754
},
{
"numNonVoteTransactions": 6379,
"numSlots": 155,
"numTransactions": 8719,
"samplePeriodSecs": 60,
"slot": 374447601
}
]
}
```
***
### `getSignaturesForAddress`
> **Returns confirmed transaction signatures that include the given address, in reverse chronological order.**
Returns signatures backwards in time from the provided signature or most recent confirmed block.
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): the account address as a base-58 encoded string.
* `` (optional): the configuration object containing the following fields:
* `limit` (number): the maximum transaction signatures to return (between 1 and 1,000, default: 1,000).
* `before` (string): starts searching backwards from this transaction signature. If not provided the search starts from the top of the highest max confirmed block.
* `until` (string): searches until this transaction signature, if found before limit reached.
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
The `result` field is an array of transaction signature information, ordered from newest to oldest transaction:
* `signature` (string): the transaction signature as base-58 encoded string.
* `slot` (u64): the slot that contains the block with the transaction.
* `err` (object|null): Error if transaction failed, null if transaction succeeded. See the [TransactionError definitions](https://github.com/solana-labs/solana/blob/c0c60386544ec9a9ec7119229f37386d9f070523/sdk/src/transaction/error.rs#L13).
* `memo` (string|null): the memo associated with the transaction, null if there is no memo.
* `blockTime` (i64|null): estimated production time, as Unix timestamp (seconds since the Unix epoch) of when transaction was processed. null if not available.
* `confirmationStatus` (string|null): the transaction's cluster confirmation status; either processed, confirmed, or finalized.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignaturesForAddress",
"params": [
"Vote111111111111111111111111111111111111111",
{
"limit": 1
}
]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getSignaturesForAddress",
params: ["Vote111111111111111111111111111111111111111", {"limit": 1}]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getSignaturesForAddress",
"params": ["Vote111111111111111111111111111111111111111", {"limit": 1}]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": [
{
"blockTime": 1744731098,
"confirmationStatus": "finalized",
"err": null,
"memo": null,
"signature": "3wG35yPiT69tZSJRQJ9VTsU9dNR6nd4sQkU7FSyK5cc9Fpt7DXrvYSwbLLBuEo4Sz7DNwSGmTc5bx5mf3MSjZcNN",
"slot": 374448329
}
]
}
```
***
### `getSignatureStatuses`
> **Returns the confirmation status and error state for a list of transaction signatures.**
Unless the `searchTransactionHistory` configuration parameter is included, this method only searches the recent status cache of signatures, which retains statuses for all active slots plus `MAX_RECENT_BLOCKHASHES` rooted slots.
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: an array of transaction signatures to confirm, as base-58 encoded strings (up to a maximum of 256).
* `` (optional): the object containing the following field:
* `searchTransactionHistory` (boolean): if `true`, a Solana node will search its ledger cache for any signatures not found in the recent status cache.
#### Returns
* `null`: an unknown transaction.
* ``: a known transaction; contains the following parameters:
* `slot` (u64): the slot the transaction was processed at.
* `confirmations` (usize|null): the number of blocks since signature confirmation, null if rooted, as well as finalized by a supermajority of the cluster.
* `err` (object|null): Error if transaction failed, null if transaction succeeded. See the [TransactionError definitions](https://github.com/solana-labs/solana/blob/c0c60386544ec9a9ec7119229f37386d9f070523/sdk/src/transaction/error.rs#L13).
* `confirmationStatus` (string|null): the transaction's cluster confirmation status; either `processed`, `confirmed`, or `finalized`.
* \[DEPRECATED] `status` (object): the transaction status:
* `"Ok": `: the transaction was successful.
* `"Err": `: the transaction failed with `TransactionError`.
#### Request example 1
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignatureStatuses",
"params": [
[
"5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW",
"5j7s6NiJS3JAkvgkoc18WVAsiSaci2pxB2A6ueCJP4tprA2TFg9wSyTLeYouxPBJEMzJinENTkpA52YStRW5Dia7"
]
]
}'
```
#### Response example 1
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374449074
},
"value": [
null,
null
]
}
}
```
#### Request example 2
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignatureStatuses",
"params": [
[
"5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW"
],
{
"searchTransactionHistory": true
}
]
}'
```
#### Response example 2
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374449161
},
"value": [
null
]
}
}
```
***
### `getSlot`
> **Returns the slot that has reached the given or default commitment level.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (optional): the configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
* ``: the current slot.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getSlot"
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getSlot"
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getSlot"
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": 374449197,
"id": 1
}
```
***
### `getSlotLeader`
> **Returns the public key of the current slot leader.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: the configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
* ``: the node identity Pubkey as base-58 encoded string.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getSlotLeader"
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getSlotLeader"
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getSlotLeader"
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": "dv3qDFk1DTF36Z62bNvrCXe9sKATA6xvVy6A798xxAS",
"id": 1
}
```
***
### `getSlotLeaders`
> **Returns the ordered list of slot leaders for a given slot range.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: the start slot, as u64 integer.
* ``: the limit, as a u64 integer (between 1 and 5,000).
#### Returns
* ``: the node identity public keys as base-58 encoded strings.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getSlotLeaders",
"params": [374449190, 10]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getSlotLeaders",
params: [374449190, 10]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getSlotLeaders",
"params": [374449190, 10]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": [
"dv4ACNkpYPcE3aKmYDqZm9G5EB3J4MRoeE7WNDRBVJB",
"dv4ACNkpYPcE3aKmYDqZm9G5EB3J4MRoeE7WNDRBVJB",
"dv3qDFk1DTF36Z62bNvrCXe9sKATA6xvVy6A798xxAS",
"dv3qDFk1DTF36Z62bNvrCXe9sKATA6xvVy6A798xxAS",
"dv3qDFk1DTF36Z62bNvrCXe9sKATA6xvVy6A798xxAS",
"dv3qDFk1DTF36Z62bNvrCXe9sKATA6xvVy6A798xxAS",
"dv4ACNkpYPcE3aKmYDqZm9G5EB3J4MRoeE7WNDRBVJB",
"dv4ACNkpYPcE3aKmYDqZm9G5EB3J4MRoeE7WNDRBVJB",
"dv4ACNkpYPcE3aKmYDqZm9G5EB3J4MRoeE7WNDRBVJB",
"dv4ACNkpYPcE3aKmYDqZm9G5EB3J4MRoeE7WNDRBVJB"
]
}
```
***
### `getSupply`
> **Returns information about the current circulating and total lamport supply.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* ``: the configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `excludeNonCirculatingAccountsList` (boolean): set to `true` to exclude non-circulating accounts list from response.
#### Returns
The result contains the `value` object with the following fields:
* `total` (u64): the total supply in lamports.
* `circulating` (u64): the circulating supply in lamports.
* `nonCirculating` (u64): the non-circulating supply in lamports.
* `nonCirculatingAccounts` (array): an array of account addresses of non-circulating accounts, as strings. If `excludeNonCirculatingAccountsList` is enabled, the returned array will be empty.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getSupply"
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getSupply"
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getSupply"
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374451103
},
"value": {
"circulating": 968499669854531580,
"nonCirculating": 315864946596719089,
"nonCirculatingAccounts": [
"AsrYX4FeLXnZcrjcZmrASY2Eq1jvEeQfwxtNTxS5zojA",
"CY7X5o3Wi2eQhTocLmUS6JSWyx1NinBfW7AXRrkRCpi8",
"CHmdL15akDcJgBkY6BP3hzs98Dqr6wbdDC5p8odvtSbq",
"3fV2GaDKa3pZxyDcpMh5Vrh2FVAMUiWUKbYmnBFv8As3",
"9xbcBZoGYFnfJZe81EDuDYKUm8xGkjzW8z4EgnVhNvsv",
"3vSVZC7LfnnyGuacykWoWrbzrmTyFVSXxCbKJUFbJcKS",
"CuatS6njAcfkFHnvai7zXCs7syA9bykXWsDCJEWfhjHG",
"APnSR52EC1eH676m7qTBHUJ1nrGpHYpV7XKPxgRDD8gX",
"9NFMpkv65d2G7UMMFYHeXrBAaB6rVD3BgQ95bKiwr448",
"4U9iUGSHj1kJa7AefG4UdEPd1xVvMyK3suDhngnvazyf",
"6Uz9bTkdAtmzsDWk3Jso9YzzfYiNpEShBZbxUsvMnRbJ",
"8MrstTxNJpwXSFxn5FGwvre2uCcCaRPs94f2FcknVUyr"
],
"total": 1284364616451250669
}
},
"id": 1
}
```
***
### `getTokenAccountBalance`
> **Returns the token balance of an SPL Token account.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): the pubkey of Token account to query, as base-58 encoded string.
* `` (optional): the configuration object containing the following field:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
#### Returns
The result contains the `value` object with the following fields:
* `amount` (string): the raw balance without decimals, a string representation of u64.
* `decimals` (u8): the number of base 10 digits to the right of the decimal place.
* `uiAmount` (number|null): the balance, using mint-prescribed decimals \[DEPRECATED].
* `uiAmountString` (string): the balance as a string, using mint-prescribed decimals.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenAccountBalance",
"params": ["7nxXxpEEsAFf5CSqapwjBjt65xnQUBAdug2pXS89YzmY"]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getTokenAccountBalance",
params: ["7nxXxpEEsAFf5CSqapwjBjt65xnQUBAdug2pXS89YzmY"]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenAccountBalance",
"params": ["7nxXxpEEsAFf5CSqapwjBjt65xnQUBAdug2pXS89YzmY"]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374621302
},
"value": {
"amount": "828545484",
"decimals": 6,
"uiAmount": 828.545484,
"uiAmountString": "828.545484"
}
}
}
```
***
### `getTokenAccountsByDelegate`
> **Returns all SPL Token accounts whose delegate is the given public key.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): the pubkey of account delegate to query, as base-58 encoded string.
* `` (required): either:
* `mint` (string): the pubkey of the specific token Mint to limit accounts to, as base-58 encoded string; or
* `programId` (string): the pubkey of the Token program that owns the accounts, as base-58 encoded string.
* `` (optional): the configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `encoding` (string): encoding for Account data, either "base58" (slow), "base64", "base64+zstd", or "jsonParsed". "base58" is limited to Account data of less than 129 bytes. "base64" will return base64 encoded data for Account data of any size. "base64+zstd" compresses the Account data using [Zstandard](https://facebook.github.io/zstd/) and base64-encodes the result. ["jsonParsed" encoding](https://docs.solana.com/developing/clients/jsonrpc-api#parsed-responses) attempts to use program-specific state parsers to return more human-readable and explicit account state data. If "jsonParsed" is requested but a parser cannot be found, the field falls back to "base64" encoding, detectable when the `data` field is type `string`.
* `dataSlice` (object; optional): limits the returned account data using the provided `offset: ` and `length: ` fields; only available for "base58", "base64" or "base64+zstd" encodings.
* `minContextSlot` (number; optional): sets the minimum slot that the request can be evaluated at.
#### Returns
The result contains the `value` object with the following fields:
* `pubkey` (string): the account Pubkey as base-58 encoded string.
* `account` (object): a JSON object, with the following subfields:
* `lamports` (u64): the number of lamports assigned to this account, as a u64.
* `owner` (string): the base-58 encoded Pubkey of the program this account has been assigned to.
* `data` (object): the Token state data associated with the account, either as encoded binary data or in JSON format `{: }`.
* `executable` (boolean): a boolean indicating if the account contains a program (and is strictly read-only).
* `rentEpoch` (u64): the epoch at which this account will next owe rent, as u64.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenAccountsByDelegate",
"params": [
"4Nd1mBQtrMJVYVfKf2PJy9NZUZdTAsp7D4xWLs4gDB4T",
{
"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
},
{
"encoding": "jsonParsed"
}
]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getTokenAccountsByDelegate",
params: ["4Nd1mBQtrMJVYVfKf2PJy9NZUZdTAsp7D4xWLs4gDB4T", {"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"}, {"encoding": "jsonParsed"}]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenAccountsByDelegate",
"params": ["4Nd1mBQtrMJVYVfKf2PJy9NZUZdTAsp7D4xWLs4gDB4T", {"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"}, {"encoding": "jsonParsed"}]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": {
"context": {
"slot": 1114
},
"value": [
{
"account": {
"data": {
"program": "spl-token",
"parsed": {
"info": {
"tokenAmount": {
"amount": "1",
"decimals": 1,
"uiAmount": 0.1,
"uiAmountString": "0.1"
},
"delegate": "4Nd1mBQtrMJVYVfKf2PJy9NZUZdTAsp7D4xWLs4gDB4T",
"delegatedAmount": {
"amount": "1",
"decimals": 1,
"uiAmount": 0.1,
"uiAmountString": "0.1"
},
"state": "initialized",
"isNative": false,
"mint": "3wyAj7Rt1TWVPZVteFJPLa26JmLvdb1CAKEFZm3NY75E",
"owner": "CnPoSPKXu7wJqxe59Fs72tkBeALovhsCxYeFwPCQH9TD"
},
"type": "account"
},
"space": 165
},
"executable": false,
"lamports": 1726080,
"owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
"rentEpoch": 4
},
"pubkey": "28YTZEwqtMHWrhWcvv34se7pjS7wctgqzCPB3gReCFKp"
}
]
},
"id": 1
}
```
***
### `getTokenAccountsByOwner`
> **Returns all SPL Token accounts owned by the given public key.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): the pubkey of account owner to query, as base-58 encoded string.
* `` (required): either:
* `mint` (string): the pubkey of the specific token Mint to limit accounts to, as base-58 encoded string; or
* `programId` (string): the pubkey of the Token program that owns the accounts, as base-58 encoded string.
* `` (optional): the configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `encoding` (string): encoding for Account data, either "base58" (slow), "base64", "base64+zstd", or "jsonParsed". "base58" is limited to Account data of less than 129 bytes. "base64" will return base64 encoded data for Account data of any size. "base64+zstd" compresses the Account data using [Zstandard](https://facebook.github.io/zstd/) and base64-encodes the result. ["jsonParsed" encoding](https://docs.solana.com/developing/clients/jsonrpc-api#parsed-responses) attempts to use program-specific state parsers to return more human-readable and explicit account state data. If "jsonParsed" is requested but a parser cannot be found, the field falls back to "base64" encoding, detectable when the `data` field is type `string`.
* `dataSlice` (object): limits he returned account data using the provided `offset: ` and `length: ` fields; only available for "base58", "base64" or "base64+zstd" encodings.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
The result contains the `value` object with the following fields:
* `pubkey` (string): the account Pubkey as base-58 encoded string.
* `account` (object): a JSON object, with the following subfields:
* `lamports` (u64): the number of lamports assigned to this account, as a u64.
* `owner` (string): the base-58 encoded Pubkey of the program this account has been assigned to.
* `data` (object): the Token state data associated with the account, either as encoded binary data or in JSON format `{: }`.
* `executable` (boolean): a boolean indicating if the account contains a program (and is strictly read-only).
* `rentEpoch` (u64): the epoch at which this account will next owe rent, as u64.
#### Request parameters
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenAccountsByOwner",
"params": [
"4Qkev8aNZcqFNSRhQzwyLMFSsi94jHqE8WNVTJzTP99F",
{
"mint": "3wyAj7Rt1TWVPZVteFJPLa26JmLvdb1CAKEFZm3NY75E"
},
{
"encoding": "jsonParsed"
}
]
}'
```
#### Response parameters
```
{
"jsonrpc": "2.0",
"result": {
"context": {
"slot": 1114
},
"value": [
{
"account": {
"data": {
"program": "spl-token",
"parsed": {
"accountType": "account",
"info": {
"tokenAmount": {
"amount": "1",
"decimals": 1,
"uiAmount": 0.1,
"uiAmountString": "0.1"
},
"delegate": "4Nd1mBQtrMJVYVfKf2PJy9NZUZdTAsp7D4xWLs4gDB4T",
"delegatedAmount": {
"amount": "1",
"decimals": 1,
"uiAmount": 0.1,
"uiAmountString": "0.1"
},
"state": "initialized",
"isNative": false,
"mint": "3wyAj7Rt1TWVPZVteFJPLa26JmLvdb1CAKEFZm3NY75E",
"owner": "4Qkev8aNZcqFNSRhQzwyLMFSsi94jHqE8WNVTJzTP99F"
},
"type": "account"
},
"space": 165
},
"executable": false,
"lamports": 1726080,
"owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
"rentEpoch": 4
},
"pubkey": "C2gJg6tKpQs41PRS1nC8aw3ZKNZK3HQQZGVrDFDup5nx"
}
]
},
"id": 1
}
```
***
### `getTokenLargestAccounts`
> **Returns the 20 largest accounts of the specified SPL Token mint.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): the Pubkey of token Mint to query, as base-58 encoded string.
* `` (optional): the configuration object containing the following field:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
#### Returns
The result contains the `value` object with the following fields:
* `address` (string): the address of the token account.
* `amount` (string): the raw token account balance without decimals, a string representation of u64.
* `decimals` (u8): the number of base 10 digits to the right of the decimal place.
* `uiAmount` (number|null): the token account balance, using mint-prescribed decimals \[DEPRECATED].
* `uiAmountString` (string): the token account balance as a string, using mint-prescribed decimals.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenLargestAccounts",
"params": ["So11111111111111111111111111111111111111112"]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getTokenLargestAccounts",
params: ["So11111111111111111111111111111111111111112"]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenLargestAccounts",
"params": ["So11111111111111111111111111111111111111112"]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374624734
},
"value": [
{
"address": "35akt5uJn73ZN9FkGgBKpRwbW5scoqV7M1N59cwb4TKV",
"amount": "11109337918819635",
"decimals": 9,
"uiAmount": 11109337.918819636,
"uiAmountString": "11109337.918819635"
},
{
"address": "2ceB4kejtRYjPi2tC6KP9pvmRfcEtrukPT18rWV4yejb",
"amount": "1003836020391687",
"decimals": 9,
"uiAmount": 1003836.020391687,
"uiAmountString": "1003836.020391687"
}
]
},
"id": 1
}
```
***
### `getTokenSupply`
> **Returns the total supply of the specified SPL Token mint.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): the Pubkey of token Mint to query, as base-58 encoded string.
* `` (optional): the configuration object containing the following field:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
#### Returns
The result contains the `value` object with the following fields:
* `amount` (string): the raw total token supply without decimals, a string representation of u64.
* `decimals` (u8): the number of base 10 digits to the right of the decimal place.
* `uiAmount` (number|null): the total token supply, using mint-prescribed decimals \[DEPRECATED].
* `uiAmountString` (string): the total token supply as a string, using mint-prescribed decimals.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenSupply",
"params": ["So11111111111111111111111111111111111111112"]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getTokenSupply",
params: ["So11111111111111111111111111111111111111112"]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenSupply",
"params": ["So11111111111111111111111111111111111111112"]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374624888
},
"value": {
"amount": "0",
"decimals": 9,
"uiAmount": 0.0,
"uiAmountString": "0"
}
}
}
```
***
### `getTransaction`
> **Returns full transaction details and metadata for a confirmed transaction by signature.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): the transaction signature as base-58 encoded string.
* `` (optional): the configuration object containing the following optional fields:
* `encoding` (string): encoding for each returned Transaction, either "json", "jsonParsed", "base58" (slow), "base64". If parameter not provided, the default encoding is "json". ["jsonParsed" encoding](https://docs.solana.com/developing/clients/jsonrpc-api#parsed-responses) attempts to use program-specific instruction parsers to return more human-readable and explicit data in the `transaction.message.instructions` list. If "jsonParsed" is requested but a parser cannot be found, the instruction falls back to regular JSON encoding (`accounts`, `data`, and `programIdIndex` fields).
* `commitment` (string; default: "finalized"): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `maxSupportedTransactionVersion` (number): sets the max transaction version to return in responses. If the requested transaction is a higher version, an error will be returned. If this parameter is omitted, only legacy transactions will be returned, and any versioned transaction will prompt the error.
#### Returns
* `null`: if transaction is not found or not confirmed.
* ``: if transaction is confirmed, an object with the following fields:
* `slot` (u64): the slot this transaction was processed in.
* `transaction` (object|\[string,encoding]): a [transaction](https://docs.solana.com/developing/clients/jsonrpc-api#transaction-structure) object, either in JSON format or encoded binary data, depending on encoding parameter.
* `blockTime` (i64|null): the estimated production time, as Unix timestamp (seconds since the Unix epoch) of when the transaction was processed. null if not available.
* `meta` (object|null): the transaction status metadata object:
* `err` (object|null): Error if transaction failed, null if transaction succeeded. See the [TransactionError](https://docs.rs/solana-sdk/1.14.11/solana_sdk/transaction/enum.TransactionError.html) definitions.
* `fee` (u64): the fee this transaction was charged, as u64 integer.
* `preBalances` (array): an array of u64 account balances from before the transaction was processed.
* `postBalances` (array): an array of u64 account balances after the transaction was processed.
* `innerInstructions` (array|null): the list of [inner instructions](https://docs.solana.com/developing/clients/jsonrpc-api#inner-instructions-structure) or `null` if inner instruction recording was not enabled during this transaction.
* `preTokenBalances` (array|undefined): the list of [token balances](https://docs.solana.com/developing/clients/jsonrpc-api#token-balances-structure) from before the transaction was processed or omitted if token balance recording was not yet enabled during this transaction.
* `postTokenBalances` (array|undefined): the list of [token balances](https://docs.solana.com/developing/clients/jsonrpc-api#token-balances-structure) from after the transaction was processed or omitted if token balance recording was not yet enabled during this transaction.
* `logMessages` (array|null): an array of string log messages or null if log message recording was not enabled during this transaction.
* \[DEPRECATED] `status: `: the transaction status:
* `"Ok": `: the transaction was successful.
* `"Err": `: the transaction failed with TransactionError.
* `rewards` (array|null): the transaction-level rewards, populated if rewards are requested; an array of JSON objects containing:
* `pubkey` (string): the public key, as base-58 encoded string, of the account that received the reward.
* `lamports` (i64): the number of reward lamports credited or debited by the account, as a i64.
* `postBalance` (u64): the account balance in lamports after the reward was applied.
* `rewardType` (string): the type of reward: currently only "rent", other types may be added in the future.
* `commission` (u8|undefined): a vote account commission when the reward was credited, only present for voting and staking rewards.
* `loadedAddresses` (object|undefined): the transaction addresses loaded from address lookup tables. Undefined if `maxSupportedTransactionVersion` is not set in request params.
* `writable` (array\[string]): the ordered list of base-58 encoded addresses for writable loaded accounts.
* `readonly` (array\[string]): the ordered list of base-58 encoded addresses for readonly loaded accounts.
* `returnData` (object|undefined): the most-recent return data generated by an instruction in the transaction, with the following fields:
* `programId` (string): the program that generated the return data, as base-58 encoded Pubkey.
* `data` (\[string, encoding]): the return data itself, as base-64 encoded binary data.
* `computeUnitsConsumed` (u64|undefined): the number of [compute units](https://docs.solana.com/developing/programming-model/runtime#compute-budget) consumed by the transaction.
* `version` ("legacy"|number|undefined): the transaction version. Undefined if `maxSupportedTransactionVersion` is not set in request params.
#### Request example 1
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getTransaction",
"params": [
"jS5UBJWbrxL9DM86LoGznZtqg8q8rP3xPmMv77s7F7qdCwQFg7cchxWHdRSw5X7Bmuvy6dTaejMcgjv2XJQ9dfD",
{
"encoding": "json",
"maxSupportedTransactionVersion": 0
}
]
}'
```
#### Response example 1
```json
{
"jsonrpc": "2.0",
"result": {
"blockTime": 1744798149,
"meta": {
"computeUnitsConsumed": 4726,
"err": null,
"fee": 5000,
"innerInstructions": [],
"loadedAddresses": {
"readonly": [],
"writable": []
},
"logMessages": [
"Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA invoke [1]",
"Program log: Instruction: Transfer",
"Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA consumed 4726 of 200000 compute units",
"Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA success"
],
"postBalances": [
35199803303,
2039280,
2039280,
934087680
],
"postTokenBalances": [
{
"accountIndex": 1,
"mint": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
"owner": "EkkpfzUdwwgeqWb25hWcSi2c5gquELLUB3Z2asr1Xroo",
"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
"uiTokenAmount": {
"amount": "828545485",
"decimals": 6,
"uiAmount": 828.545485,
"uiAmountString": "828.545485"
}
},
{
"accountIndex": 2,
"mint": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
"owner": "DjGkZ6k5hMkaxMAboqc9MUrL8zq59Q8aQUuF6Fmr6DUD",
"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
"uiTokenAmount": {
"amount": "1109995438",
"decimals": 6,
"uiAmount": 1109.995438,
"uiAmountString": "1109.995438"
}
}
],
"preBalances": [
35199808303,
2039280,
2039280,
934087680
],
"preTokenBalances": [
{
"accountIndex": 1,
"mint": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
"owner": "EkkpfzUdwwgeqWb25hWcSi2c5gquELLUB3Z2asr1Xroo",
"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
"uiTokenAmount": {
"amount": "828545486",
"decimals": 6,
"uiAmount": 828.545486,
"uiAmountString": "828.545486"
}
},
{
"accountIndex": 2,
"mint": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
"owner": "DjGkZ6k5hMkaxMAboqc9MUrL8zq59Q8aQUuF6Fmr6DUD",
"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
"uiTokenAmount": {
"amount": "1109995437",
"decimals": 6,
"uiAmount": 1109.995437,
"uiAmountString": "1109.995437"
}
}
],
"rewards": [],
"status": {
"Ok": null
}
},
"slot": 374619973,
"transaction": {
"message": {
"accountKeys": [
"EkkpfzUdwwgeqWb25hWcSi2c5gquELLUB3Z2asr1Xroo",
"7nxXxpEEsAFf5CSqapwjBjt65xnQUBAdug2pXS89YzmY",
"HdUKfS4QwKUQawoLXNyDdsut11mtoYRyntFrhhjdhgR1",
"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
],
"addressTableLookups": [],
"header": {
"numReadonlySignedAccounts": 0,
"numReadonlyUnsignedAccounts": 1,
"numRequiredSignatures": 1
},
"instructions": [
{
"accounts": [
1,
2,
0,
0
],
"data": "3DdGGhkhJbjm",
"programIdIndex": 3,
"stackHeight": null
}
],
"recentBlockhash": "5jKHQZzdu7kazYmicjPgwANsDwAqJnjWCYR1yjEVDZBL"
},
"signatures": [
"jS5UBJWbrxL9DM86LoGznZtqg8q8rP3xPmMv77s7F7qdCwQFg7cchxWHdRSw5X7Bmuvy6dTaejMcgjv2XJQ9dfD"
]
},
"version": 0
},
"id": 1
}
```
#### Request example 2
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getTransaction",
"params": [
"jS5UBJWbrxL9DM86LoGznZtqg8q8rP3xPmMv77s7F7qdCwQFg7cchxWHdRSw5X7Bmuvy6dTaejMcgjv2XJQ9dfD",
{
"encoding": "base64",
"maxSupportedTransactionVersion": 0
}
]
}'
```
#### Response example 2
```json
{
"jsonrpc": "2.0",
"result": {
"blockTime": 1744798149,
"meta": {
"computeUnitsConsumed": 4726,
"err": null,
"fee": 5000,
"innerInstructions": [],
"loadedAddresses": {
"readonly": [],
"writable": []
},
"logMessages": [
"Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA invoke [1]",
"Program log: Instruction: Transfer",
"Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA consumed 4726 of 200000 compute units",
"Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA success"
],
"postBalances": [
35199803303,
2039280,
2039280,
934087680
],
"postTokenBalances": [
{
"accountIndex": 1,
"mint": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
"owner": "EkkpfzUdwwgeqWb25hWcSi2c5gquELLUB3Z2asr1Xroo",
"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
"uiTokenAmount": {
"amount": "828545485",
"decimals": 6,
"uiAmount": 828.545485,
"uiAmountString": "828.545485"
}
},
{
"accountIndex": 2,
"mint": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
"owner": "DjGkZ6k5hMkaxMAboqc9MUrL8zq59Q8aQUuF6Fmr6DUD",
"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
"uiTokenAmount": {
"amount": "1109995438",
"decimals": 6,
"uiAmount": 1109.995438,
"uiAmountString": "1109.995438"
}
}
],
"preBalances": [
35199808303,
2039280,
2039280,
934087680
],
"preTokenBalances": [
{
"accountIndex": 1,
"mint": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
"owner": "EkkpfzUdwwgeqWb25hWcSi2c5gquELLUB3Z2asr1Xroo",
"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
"uiTokenAmount": {
"amount": "828545486",
"decimals": 6,
"uiAmount": 828.545486,
"uiAmountString": "828.545486"
}
},
{
"accountIndex": 2,
"mint": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
"owner": "DjGkZ6k5hMkaxMAboqc9MUrL8zq59Q8aQUuF6Fmr6DUD",
"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
"uiTokenAmount": {
"amount": "1109995437",
"decimals": 6,
"uiAmount": 1109.995437,
"uiAmountString": "1109.995437"
}
}
],
"rewards": [],
"status": {
"Ok": null
}
},
"slot": 374619973,
"transaction": [
"ASSXkS4gFdRPjAgYMtI83mxAdkQQxNnrNjVo0/8n3PuyIfJiogZfy+QQZYpG/KbPbARMNWYYkgyNQtgHSfk+AgiAAQABBMxddFcL+KHOvfWKqE5HeL1iR4V7zrweiMVtVjfN1B7OZOwM3pq0f7lZsDDur9i+ue/ujyUjQwUnXvJRe7/+3hP3EsrzEUsyPOtXf0utjSb34dXGwknd9iobwU0NFQ5NrAbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCpRkXQbtykq1Yx/ZUrutYrW1qb5/p2XC9uMes1kL5LbhcBAwQBAgAACQMBAAAAAAAAAAA=",
"base64"
],
"version": 0
},
"id": 1
}
```
***
### `getTransactionCount`
> **Returns the total number of transactions processed since genesis.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (optional): the configuration object containing the following fields:
* commitment (string; optional): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
* ``: the count.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getTransactionCount"
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getTransactionCount"
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "getTransactionCount"
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": 15541529698
}
```
***
### `getVersion`
> **Returns the running Solana software version of the node.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
The `result` object contains the following parameters:
* `solana-core`: the software version of solana-core.
* `feature-set`: a unique identifier of the current software's feature set.
#### Request parameters
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getVersion"
}'
```
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"feature-set": 3294202862,
"solana-core": "2.2.3"
}
}
```
***
### `getVoteAccounts`
> **Returns current vote accounts and their associated stake for the validator set.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (optional): the configuration object containing the following fields:
* `commitment` (string): the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `votePubkey` (string): only returns the results for this validator vote address (base-58 encoded).
* `keepUnstakedDelinquents` (boolean): set to `true` to not filter out delinquent validators with no stake.
* `delinquentSlotDistance` (u64): specify the number of slots behind the tip that a validator must fall to be considered delinquent. NOTE: For the sake of consistency between ecosystem products, it is not recommended that this argument be specified.
#### Returns
The result field will be a JSON object of `current` and `delinquent` accounts, each containing an array of JSON objects with the following subfields:
* `votePubkey` (string): the vote account address, as base-58 encoded string.
* `nodePubkey` (string): the validator identity, as base-58 encoded string.
* `activatedStake` (u64): the stake, in lamports, delegated to this vote account and active in this epoch.
* `epochVoteAccount` (boolean): `true` if the vote account is staked for this epoch, otherwise `false`.
* `commission` (number): the percentage (0-100) of rewards payout owed to the vote account.
* `lastVote` (u64): the most recent slot voted on by this vote account.
* `epochCredits` (array): the history of how many credits earned by the end of each epoch, as an array of arrays containing: `[epoch, credits, previousCredits]`.
#### Request example 1
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getVoteAccounts"
}'
```
#### Response example 1
```json
{
"jsonrpc": "2.0",
"result": {
"current": [
{
"activatedStake": 2364534867609880,
"commission": 100,
"epochCredits": [
[
863,
931848333,
924939069
],
[
864,
938750237,
931848333
],
[
865,
945661181,
938750237
],
[
866,
952567578,
945661181
],
[
867,
953877279,
952567578
]
],
"epochVoteAccount": true,
"lastVote": 374626126,
"nodePubkey": "Cw6X5R68muAyGRCb7W8ZSP2YbaRjwMs1t5sBEPkhdwbM",
"rootSlot": 374626095,
"votePubkey": "7AETLyAGJWjp6AWzZqZcP362yv5LQ3nLEdwnXNjdNwwF"
}
]
},
"id": 1
}
```
#### Request example 2
Restricts the results to a single validator vote account.
```
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "getVoteAccounts",
"params": [
{
"votePubkey": "BZxzPVaLuAp2JUzR9gbtbrv47qYdSdRQfBWzatxPVjcD"
}
]
}'
```
#### Response example 2
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"current": [],
"delinquent": [
{
"activatedStake": 1997717120,
"commission": 100,
"epochCredits": [
[
851,
13346414,
6438750
],
[
852,
18873026,
13346414
],
[
853,
23618152,
18873026
],
[
854,
29813698,
23618152
],
[
855,
33504018,
29813698
]
],
"epochVoteAccount": true,
"lastVote": 369591011,
"nodePubkey": "9AyV9DykRupCenmHzvFckXLa2Hg8kvG61c6yX215EZCm",
"rootSlot": 369590980,
"votePubkey": "BZxzPVaLuAp2JUzR9gbtbrv47qYdSdRQfBWzatxPVjcD"
}
]
}
}
```
***
### `isBlockhashValid`
NEW: This method is only available in solana-core v1.9 or newer. Please use \[\`getFeeCalculatorForBlockhash\`]\(/rpc-service/chains/chains-api/solana/#getfeecalculatorforblockhash-deprecated) for solana-core v1.8
> **Returns whether a blockhash is still valid or not.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `blockhash` (string; required): the blockhash of this block, as base-58 encoded string.
* `` (optional): the configuration object containing the following fields:
* `commitment` (string): used for retrieving blockhash; the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
* ``: returns `true` if the blockhash is still valid.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"id":45,
"jsonrpc":"2.0",
"method":"isBlockhashValid",
"params":[
"Fv8Be2iVvuSbWr3M5krNf5UT4TwwwtyY14jHBZXiatdv",
{"commitment": "processed"}
]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
id: 45,
jsonrpc: "2.0",
method: "isBlockhashValid",
params: ["Fv8Be2iVvuSbWr3M5krNf5UT4TwwwtyY14jHBZXiatdv", {"commitment": "processed"}]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"id": 45,
"jsonrpc": "2.0",
"method": "isBlockhashValid",
"params": ["Fv8Be2iVvuSbWr3M5krNf5UT4TwwwtyY14jHBZXiatdv", {"commitment": "processed"}]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 45,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374626674
},
"value": false
}
}
```
***
### `minimumLedgerSlot`
> **Returns the lowest slot retained in the node's local ledger.**
This value may increase over time if the node is configured to purge older ledger data.
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required): None.
#### Returns
* ``: the minimum ledger slot.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"id":45,
"jsonrpc":"2.0",
"method":"minimumLedgerSlot"
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
id: 45,
jsonrpc: "2.0",
method: "minimumLedgerSlot"
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"id": 45,
"jsonrpc": "2.0",
"method": "minimumLedgerSlot"
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response exampl
```
{
"jsonrpc": "2.0",
"result": 370994242,
"id": 45
}
```
***
### `requestAirdrop`
> **Requests an airdrop of lamports to the specified public key (devnet/testnet only).**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): the Pubkey of the account to receive lamports, as base-58 encoded string.
* `integer` (required): lamports, as a u64.
* `object` (optional): the configuration object containing the following field:
* `commitment` (string): used for retrieving blockhash and verifying airdrop success; the commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
#### Returns
* ``: the Transaction Signature of airdrop, as base-58 encoded string.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "requestAirdrop",
"params": [
"83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri",
1000000000
]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "requestAirdrop",
params: ["83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri", 1000000000]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "requestAirdrop",
"params": ["83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri", 1000000000]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": "4fv3RBynFREuU71Ajt9GyyiBJ7NKa9NmATmzdyKojdaGC111NfZBni1CJ5pb3AtnryqdjaVKWF9f1wp1d4gwoki5",
"id": 1
}
```
***
### `sendTransaction`
> **Submits a signed, base-64 encoded transaction to the cluster for processing.**
This method does not alter the transaction in any way; it relays the transaction created by clients to the node as-is.
If the node's rpc service receives the transaction, this method immediately succeeds, without waiting for any confirmations. A successful response from this method does not guarantee the transaction is processed or confirmed by the cluster.
While the rpc service will reasonably retry to submit it, the transaction could be rejected if transaction's `recent_blockhash` expires before it lands.
Use [`getSignatureStatuses`](#getsignaturestatuses) to ensure a transaction is processed and confirmed.
Before submitting, the following preflight checks are performed:
1. The transaction signatures are verified.
2. The transaction is simulated against the bank slot specified by the preflight commitment. On failure an error will be returned. Preflight checks may be disabled if desired. It is recommended to specify the same commitment and preflight commitment to avoid confusing behavior.
The returned signature is the first signature in the transaction, which is used to identify the transaction ([transaction id](https://docs.solana.com/terminology#transaction-id)). This identifier can be easily extracted from the transaction data before submission.
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): a fully-signed Transaction, as encoded string.
* `` (optional): the configuration object containing the following fields:
* `skipPreflight` (boolean): if `true`, skip the preflight transaction checks (default: `false`).
* `preflightCommitment` (string; default: "finalized"): a commitment level to use for preflight. The commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `encoding` (string; default: "base58"): the encoding used for the transaction data. Either "base58" (slow, DEPRECATED), or "base64".
* `maxRetries` (usize): the maximum number of times for the RPC node to retry sending the transaction to the leader. If this parameter not provided, the RPC node will retry the transaction until it is finalized or until the blockhash expires.
* `minContextSlot` (number): sets the minimum slot at which to perform preflight transaction checks.
#### Returns
* ``: the first Transaction Signature embedded in the transaction, as base-58 encoded string ([transaction id](https://docs.solana.com/terminology#transaction-id)).
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "sendTransaction",
"params": ["4hXTCkRzt9WyecNzV1XPgCDfGAZzQKNxLXgynz5QDuWWPSAZBZSHptvWRL3BjCvzUXRdKvHL2b7yGrRQcWyaqsaBCncVG7BFggS8w9snUts67BSh3EqKpXLUm5UMHfD7ZBe9GhARjbNQMLJ1QD3Spr6oMTBU6EhdB4RD8CP2xUxr2u3d6fos36PD98XS6oX8TQjLpsMwncs5DAMiD4nNnR8NBfyghGCWvCVifVwvA8B8TJxE1aiyiv2L429BCWfyzAme5sZW8rDb14NeCQHhZbtNqfXhcp2tAnaAT"]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "sendTransaction",
params: ["4hXTCkRzt9WyecNzV1XPgCDfGAZzQKNxLXgynz5QDuWWPSAZBZSHptvWRL3BjCvzUXRdKvHL2b7yGrRQcWyaqsaBCncVG7BFggS8w9snUts67BSh3EqKpXLUm5UMHfD7ZBe9GhARjbNQMLJ1QD3Spr6oMTBU6EhdB4RD8CP2xUxr2u3d6fos36PD98XS6oX8TQjLpsMwncs5DAMiD4nNnR8NBfyghGCWvCVifVwvA8B8TJxE1aiyiv2L429BCWfyzAme5sZW8rDb14NeCQHhZbtNqfXhcp2tAnaAT"]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "sendTransaction",
"params": ["4hXTCkRzt9WyecNzV1XPgCDfGAZzQKNxLXgynz5QDuWWPSAZBZSHptvWRL3BjCvzUXRdKvHL2b7yGrRQcWyaqsaBCncVG7BFggS8w9snUts67BSh3EqKpXLUm5UMHfD7ZBe9GhARjbNQMLJ1QD3Spr6oMTBU6EhdB4RD8CP2xUxr2u3d6fos36PD98XS6oX8TQjLpsMwncs5DAMiD4nNnR8NBfyghGCWvCVifVwvA8B8TJxE1aiyiv2L429BCWfyzAme5sZW8rDb14NeCQHhZbtNqfXhcp2tAnaAT"]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"jsonrpc": "2.0",
"result": "2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb",
"id": 1
}
```
***
### `simulateTransaction`
> **Simulates a transaction against the current or specified bank state without broadcasting it.**
#### Parameters
* `id` (integer; required): a request ID (example: 1).
* `jsonrpc` (string; required): a JSON RPC spec used (example: 2.0).
* `method` (string; required): a method used for the request.
* `params` (array; required):
* `` (required): the transaction, as an encoded string. The transaction must have a valid blockhash, but is not required to be signed.
* `` (optional): the configuration object containing the following fields:
* `sigVerify` (boolean): if `true` the transaction signatures will be verified (default: `false`, conflicts with `replaceRecentBlockhash`).
* `commitment` (string; default: "finalized"): a commitment level to simulate the transaction at. The commitment describes how finalized a block is at that point in time. When querying the ledger state, it's recommended to use lower levels of commitment to report progress and higher levels to ensure the state will not be rolled back. For processing many dependent transactions in series, it's recommended to use "confirmed" commitment, which balances speed with rollback safety. For total safety, it's recommended to use "finalized" commitment:
* `finalized`: the node will query the most recent block confirmed by supermajority of the cluster as having reached maximum lockout, meaning the cluster has recognized this block as finalized.
* `confirmed`: the node will query the most recent block that has been voted on by supermajority of the cluster.
* it incorporates votes from gossip and replay.
* it does not count votes on descendants of a block, only direct votes on that block.
* this confirmation level also upholds "optimistic confirmation" guarantees in release 1.3 and onwards.
* `processed`: the node will query its most recent block. Note that the block may still be skipped by the cluster.
* `encoding` (string; default: "base58"): the encoding used for the transaction data. Either "base58" (slow, DEPRECATED), or "base64".
* `replaceRecentBlockhash` (boolean): if `true` the transaction recent blockhash will be replaced with the most recent blockhash. (default: `false`, conflicts with `sigVerify`).
* `accounts` (object): the accounts configuration object containing the following fields:
* `encoding` (string): encoding for returned Account data, either "base64" (default), "base64+zstd" or "jsonParsed". ["jsonParsed" encoding](https://docs.solana.com/developing/clients/jsonrpc-api#parsed-responses) attempts to use program-specific state parsers to return more human-readable and explicit account state data. If "jsonParsed" is requested but a parser cannot be found, the field falls back to binary encoding, detectable when the `data` field is type ``.
* `addresses` (array): an array of accounts to return, as base-58 encoded strings.
* `minContextSlot` (number): sets the minimum slot that the request can be evaluated at.
#### Returns
The result will be a JSON object with the `value` containing the following fields:
* `err` (object|string|null): Error if transaction failed, null if transaction succeeded. See the [TransactionError](https://github.com/solana-labs/solana/blob/c0c60386544ec9a9ec7119229f37386d9f070523/sdk/src/transaction/error.rs#L13) definitions.
* `logs` (array|null): an array of log messages the transaction instructions output during execution, null if simulation failed before the transaction was able to execute (for example due to an invalid blockhash or signature verification failure).
* `accounts` (array|null): an array of accounts with the same length as the `accounts.addresses` array in the request:
* ``: if the account doesn't exist or if `err` is not null.
* ``: otherwise, a JSON object containing:
* `lamports` (u64): the number of lamports assigned to this account, as a u64.
* `owner` (string): the base-58 encoded Pubkey of the program this account has been assigned to.
* `data` (\[string, encoding]|object): the data associated with the account, either as encoded binary data or JSON format `{: }`, depending on encoding parameter.
* `executable` (boolean): a boolean indicating if the account contains a program (and is strictly read-only).
* `rentEpoch` (u64): the epoch at which this account will next owe rent, as u64.
* `unitsConsumed` (u64|undefined): the number of compute budget units consumed during the processing of this transaction.
* `returnData` (object|null): the most-recent return data generated by an instruction in the transaction, with the following fields:
* `programId` (string): the program that generated the return data, as base-58 encoded Pubkey.
* `data` (\[string, encoding]): the return data itself, as base-64 encoded binary data.
#### Request example
{% tabs %}
{% tab title="cURL" %}
```bash
curl -X POST https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY} \
-H 'Content-Type: application/json' \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "simulateTransaction",
"params": ["AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDArczbMia1tLmq7zz4DinMNN0pJ1JtLdqIJPUw3YrGCzYAMHBsgN27lcgB6H2WQvFgyZuJYHa46puOQo9yQ8CVQbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCp20C7Wj2aiuk5TReAXo+VTVg8QTHjs0UjNMMKCvpzZ+ABAgEBARU=",
{
"encoding": "base64"
}
]
}'
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch("https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "simulateTransaction",
params: ["AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDArczbMia1tLmq7zz4DinMNN0pJ1JtLdqIJPUw3YrGCzYAMHBsgN27lcgB6H2WQvFgyZuJYHa46puOQo9yQ8CVQbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCp20C7Wj2aiuk5TReAXo+VTVg8QTHjs0UjNMMKCvpzZ+ABAgEBARU=", {"encoding": "base64"}]
})
});
const data = await response.json();
console.log(data);
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
response = requests.post(
"https://rpc.crypto-chief.com/solana-devnet/{YOUR_API_KEY}",
json={
"jsonrpc": "2.0",
"id": 1,
"method": "simulateTransaction",
"params": ["AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDArczbMia1tLmq7zz4DinMNN0pJ1JtLdqIJPUw3YrGCzYAMHBsgN27lcgB6H2WQvFgyZuJYHa46puOQo9yQ8CVQbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCp20C7Wj2aiuk5TReAXo+VTVg8QTHjs0UjNMMKCvpzZ+ABAgEBARU=", {"encoding": "base64"}]
}
)
print(response.json())
```
{% endtab %}
{% endtabs %}
#### Response example
```json
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"context": {
"apiVersion": "2.2.3",
"slot": 374627777
},
"value": {
"accounts": null,
"err": "BlockhashNotFound",
"innerInstructions": null,
"logs": [],
"replacementBlockhash": null,
"returnData": null,
"unitsConsumed": 0
}
}
```
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs-rpc.crypto-chief.com/chains/solana.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.