logo
Powered by Redocly

Radix Core API - Babylon (Bottlenose) (v1.2.0)

Download OpenAPI specification:Download

License: The Radix License, Version 1.0

This API is exposed by the Babylon Radix node to give clients access to the Radix Engine, Mempool and State in the node.

The default configuration is intended for use by node-runners on a private network, and is not intended to be exposed publicly. Very heavy load may impact the node's function. The node exposes a configuration flag which allows disabling certain endpoints which may be problematic, but monitoring is advised. This configuration parameter is api.core.flags.enable_unbounded_endpoints / RADIXDLT_CORE_API_FLAGS_ENABLE_UNBOUNDED_ENDPOINTS.

This API exposes queries against the node's current state (see /lts/state/ or /state/), and streams of transaction history (under /lts/stream/ or /stream).

If you require queries against snapshots of historical ledger state, you may also wish to consider using the Gateway API.

Integration and forward compatibility guarantees

Integrators (such as exchanges) are recommended to use the /lts/ endpoints - they have been designed to be clear and simple for integrators wishing to create and monitor transactions involving fungible transfers to/from accounts.

All endpoints under /lts/ have high guarantees of forward compatibility in future node versions. We may add new fields, but existing fields will not be changed. Assuming the integrating code uses a permissive JSON parser which ignores unknown fields, any additions will not affect existing code.

Other endpoints may be changed with new node versions carrying protocol-updates, although any breaking changes will be flagged clearly in the corresponding release notes.

All responses may have additional fields added, so clients are advised to use JSON parsers which ignore unknown fields on JSON objects.

SDKs

The following SDKs are currently available for the Core API:

For other languages, you can use a HTTP client of your choice and code the JSON models yourself. You could also consider using an Open API generator, but unless you have experience with battling the gremlins in Open API generators, it may be more trouble than it's worth.

Sub-APIs

The API is split into 6 sub apis:

  • Long Term Support (/lts/*) - For long term support/backward compatible endpoints aimed at integrators such as exchanges.
  • Status (/status/*) - For status and configuration details for the node / engine.
  • Transaction (/transaction/*) - For transaction construction, preview, submission, and monitoring the status of an individual transaction.
  • Mempool (/mempool/*) - For information on the contents of the node's mempool.
  • Current State (/state/*) - For reading the state of entities. At present, we only support reading details from the top of the currently committed ledger.
  • Stream (/stream/*) - For reading the committed transactions.

Concepts

Interacting with this API effectively may require knowledge about the Radix Babylon Transaction Model and the State Model.

We share some very high-level details below, but please see the official documentation for more details on this.

Transactions

User transactions are formed of a core "intent", which is then signed by 0+ signatories, before being notarized. The output is called a notarized payload. It is this notarized transaction payload which is submitted to the network.

For most users, this construction process will generally happen in their Radix Wallet. If you wish to construct transactions programmatically or offline, you will need to integrate the Radix Engine Toolkit into your application for construction and finalization.

Once submitted, a transaction payload can end up being either rejected or committed. Transactions get rejected if they fail to pass certain criteria at the given time. A transaction payload can be marked as a:

  • Permanent Rejection if it is never possible for it to be committed (eg it's statically invalid, or only valid up until epoch 100 and it's now epoch 101)
  • Temporary Rejection if it still may be possible that the transaction payload could be committed

A given intent typically is only part of one submitted notarized payload, but it's possible for a notary to notarize and submit multiple payloads for the same intent. The Radix Engine ensures that any intent can only be committed once.

A committed transaction is either committed with an outcome of "Success" or "Failure":

  • Committed Failure will result in fees being paid up until the failure point, but all other changes will be discarded.
  • Committed Success will result in all changes being committed.

Only committed transactions appear on ledger. The status of rejected transactions can be read at submission time or from the transaction status endpoint - by virtue of a rejection cache on the node. This cache is limited in size, so rejected statuses may no longer be tracked after a period of time.

For a more robust handling of transaction rejections, consider running your own Gateway.

State Model

The Radix Engine State Model can be thought of as a forest of state sub-trees. A state sub-tree consists of "entities". These entities have an ID, and 0 or more "substates" at keys underneath them. These substates are typed, and can own other entities, forming a tree of ownership.

Each state sub-tree has a root entity, and a single Bech32M Global Address, with a human-readable-prefix (and prefix byte) matching the root entity type.

As an example, entities include concepts like Components, Packages, Vaults, Resource Managers and Key-Value Stores. Substates under a component include the Component Struct, Component Data, and Access Rules substates.

Transaction Construction

To construct and submit a transaction using the LTS endpoints:

  • Query /lts/transaction/construction to retrieve the current epoch (according to your node). Check also that the ledger_clock is close to the current time - this ensures that the node is synced up.
  • Make use of the Radix Engine Toolkit to construct the intent, sign/notarize, and compile the notarized transaction.
  • You can use /lts/transaction/submit to submit the transaction
  • Use /lts/transaction/status to check the status of the transaction
  • Use /lts/stream/transaction-outcomes to look up the outcome of the transaction, from its state version

LTS Endpoints

For long term support/backward compatible endpoints aimed at integrators such as exchanges.

Get Construction Metadata

Returns information necessary to build a transaction

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

Responses
200

All info needed to build a transaction

500

Server error

post/lts/transaction/construction
Request samples
application/json
{
  • "network": "{{network}}"
}
Response samples
application/json
{
  • "current_epoch": 10000000000,
  • "ledger_clock": {
    }
}

Submit Transaction

Submits a notarized transaction to the network. Returns whether the transaction submission was already included in the node's mempool.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

notarized_transaction_hex
required
string

A hex-encoded, compiled notarized transaction.

force_recalculate
boolean

If true, the transaction validity is freshly recalculated without using any caches (defaults false)

Responses
200

Transaction Submit Response

400

Client error

500

Server error

post/lts/transaction/submit
Request samples
application/json
{
  • "network": "{{network}}",
  • "notarized_transaction_hex": "string",
  • "force_recalculate": true
}
Response samples
application/json
{
  • "duplicate": true
}

Get Transaction Status

Shares the node's knowledge of any payloads associated with the given intent hash. Generally there will be a single payload for a given intent, but it's theoretically possible there may be multiple. This knowledge is summarised into a status for the intent. This summarised status in the response is likely sufficient for most clients.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

intent_hash
required
string (IntentHashInput)

The intent hash for a user transaction, also known as the transaction id. This hash identifies the core content "intent" of the transaction. Each intent can only be committed once. This hash gets signed by any signatories on the transaction, to create the signed intent. Either hex or Bech32m-encoded strings are supported.

Responses
200

Transaction status response

400

Client error

500

Server error

post/lts/transaction/status
Request samples
application/json
{
  • "network": "{{network}}",
  • "intent_hash": "string"
}
Response samples
application/json
{
  • "intent_status": "CommittedSuccess",
  • "status_description": "string",
  • "committed_state_version": 1,
  • "invalid_from_epoch": 10000000000,
  • "known_payloads": [
    ]
}

Get All Account Balances

Returns balances for all resources associated with an account

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

account_address
required
string

The Bech32m-encoded human readable version of the account's address

Responses
200

Account all resource balances response

500

Server error

post/lts/state/account-all-fungible-resource-balances
Request samples
application/json
{
  • "network": "{{network}}",
  • "account_address": "string"
}
Response samples
application/json
{
  • "state_version": 1,
  • "ledger_header_summary": {
    },
  • "account_address": "string",
  • "fungible_resource_balances": [
    ]
}

Get Single Account Balance

Returns balance of a single fungible resource in an account

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

account_address
required
string

The Bech32m-encoded human readable version of the account's address

resource_address
required
string (ResourceAddress)

The Bech32m-encoded human readable version of the resource address

Responses
200

Account resource balance response

500

Server error

post/lts/state/account-fungible-resource-balance
Request samples
application/json
{
  • "network": "{{network}}",
  • "account_address": "string",
  • "resource_address": "string"
}
Response samples
application/json
{
  • "state_version": 1,
  • "ledger_header_summary": {
    },
  • "account_address": "string",
  • "fungible_resource_balance": {
    }
}

Get Account Deposit Behaviour

Returns deposit behaviour of a single account for multiple resource addresses

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

account_address
required
string

The Bech32m-encoded human readable version of the account's address.

resource_addresses
Array of strings (ResourceAddress) <= 20 items

The resource addresses to check the deposit behaviours of.

object (PresentedBadge)

The depositor badge to check against the account's set of authorized depositors.

Responses
200

Account deposit behaviour response

500

Server error

post/lts/state/account-deposit-behaviour
Request samples
application/json
{
  • "network": "{{network}}",
  • "account_address": "string",
  • "resource_addresses": [
    ],
  • "badge": {
    }
}
Response samples
application/json
{
  • "state_version": 1,
  • "ledger_header_summary": {
    },
  • "default_deposit_rule": "Accept",
  • "is_badge_authorized_depositor": true,
  • "resource_specific_behaviours": {
    }
}

Get Transaction Outcomes

Returns a list of committed transaction outcomes (containing balance changes) from a given state version.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

from_state_version
required
integer <int64> (StateVersion) [ 1 .. 100000000000000 ]

The first (resultant) state version to be returned

limit
required
integer

The maximum number of transactions that will be returned.

Responses
200

Paged response

400

Client error

500

Server error

post/lts/stream/transaction-outcomes
Request samples
application/json
{
  • "network": "{{network}}",
  • "from_state_version": 1,
  • "limit": 0
}
Response samples
application/json
{
  • "from_state_version": 1,
  • "count": 10000,
  • "max_ledger_state_version": 1,
  • "committed_transaction_outcomes": [
    ]
}

Get Account Transaction Outcomes

Returns a list of committed transaction outcomes (containing balance changes) from a given state version, filtered to only transactions which involved the given account.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

account_address
required
string

The Bech32m-encoded human readable version of the account's address

from_state_version
required
integer <int64> (StateVersion) [ 1 .. 100000000000000 ]

The first (resultant) state version to be returned

limit
required
integer

The maximum number of transactions that will be returned.

Responses
200

Paged response

400

Client error

500

Server error

post/lts/stream/account-transaction-outcomes
Request samples
application/json
{
  • "network": "{{network}}",
  • "account_address": "string",
  • "from_state_version": 1,
  • "limit": 0
}
Response samples
application/json
{
  • "from_state_version": 1,
  • "count": 10000,
  • "max_ledger_state_version": 1,
  • "committed_transaction_outcomes": [
    ]
}

Status Endpoints

For status and configuration details for the node / engine.

Get Network Configuration

Returns the network configuration of the network the node is connected to.

Responses
200

Network Configuration

500

Server error

post/status/network-configuration
Response samples
application/json
{
  • "version": {
    },
  • "network": "{{network}}",
  • "network_id": 255,
  • "network_hrp_suffix": "string",
  • "usd_price_in_xrd": "string",
  • "address_types": [
    ],
  • "well_known_addresses": {
    }
}

Get Network Status

Returns the current state and status of the node's copy of the ledger.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

Responses
200

Network Status

500

Server error

post/status/network-status
Request samples
application/json
{
  • "network": "{{network}}"
}
Response samples
application/json
{
  • "pre_genesis_state_identifier": {
    },
  • "genesis_epoch_round": {
    },
  • "post_genesis_state_identifier": {
    },
  • "post_genesis_epoch_round": {
    },
  • "current_state_identifier": {
    },
  • "current_epoch_round": {
    },
  • "current_protocol_version": "string"
}

Get Scenarios' results.

Get results of test "Scenarios" executed on this Network. Note: these Scenarios are meant to only be executed on test Networks; on a production Node, the response is expected to be empty.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

Responses
200

Scenarios' results

500

Server error

post/status/scenarios
Request samples
application/json
{
  • "network": "{{network}}"
}
Response samples
application/json
{
  • "executed_scenarios": [
    ]
}

Transaction Endpoints

For transaction construction, preview, submission, and monitoring the status of an individual transaction.

Parse Transaction Payload

Extracts the contents and hashes of various types of transaction payloads, or sub-payloads.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

payload_hex
required
string

A hex-encoded payload of a full transaction or a partial transaction - either a notarized transaction, a signed transaction intent an unsigned transaction intent, or a ledger payload.

parse_mode
string

The type of transaction payload that should be assumed. If omitted, "Any" is used - where the payload is attempted to be parsed as each of the following in turn: Notarized, Signed, Unsigned, Ledger.

Enum: "Any" "Notarized" "Signed" "Unsigned" "Ledger"
validation_mode
string

The type of validation that should be performed, if the payload correctly decompiles as a Notarized Transaction. This is only relevant for Notarized payloads. If omitted, "Static" is used.

Enum: "None" "Static" "Full"
response_mode
string

The amount of information to return in the response. "Basic" includes the type, validity information, and any relevant identifiers. "Full" also includes the fully parsed information. If omitted, "Full" is used.

Enum: "Basic" "Full"
object (TransactionFormatOptions)

Requested transaction formats to include in the response

Responses
200

Transaction Parse Response

400

Client error

500

Server error

post/transaction/parse
Request samples
application/json
{
  • "network": "{{network}}",
  • "payload_hex": "string",
  • "parse_mode": "Any",
  • "validation_mode": "None",
  • "response_mode": "Basic",
  • "transaction_format_options": {
    }
}
Response samples
application/json
{
  • "parsed": {
    }
}

Transaction Submit

Submits a notarized transaction to the network. Returns whether the transaction submission was already included in the node's mempool.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

notarized_transaction_hex
required
string

A hex-encoded, compiled notarized transaction.

force_recalculate
boolean

If true, the transaction validity is freshly recalculated without using any caches (defaults false)

Responses
200

Transaction Submit Response

400

Client error

500

Server error

post/transaction/submit
Request samples
application/json
{
  • "network": "{{network}}",
  • "notarized_transaction_hex": "string",
  • "force_recalculate": true
}
Response samples
application/json
{
  • "duplicate": true
}

Get Transaction Status

Shares the node's knowledge of any payloads associated with the given intent hash. Generally there will be a single payload for a given intent, but it's theoretically possible there may be multiple. This knowledge is summarised into a status for the intent. This summarised status in the response is likely sufficient for most clients.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

intent_hash
required
string (IntentHashInput)

The intent hash for a user transaction, also known as the transaction id. This hash identifies the core content "intent" of the transaction. Each intent can only be committed once. This hash gets signed by any signatories on the transaction, to create the signed intent. Either hex or Bech32m-encoded strings are supported.

Responses
200

Transaction status response

400

Client error

500

Server error

post/transaction/status
Request samples
application/json
{
  • "network": "{{network}}",
  • "intent_hash": "string"
}
Response samples
application/json
{
  • "intent_status": "CommittedSuccess",
  • "status_description": "string",
  • "invalid_from_epoch": 10000000000,
  • "known_payloads": [
    ]
}

Get Transaction Receipt

Gets the transaction receipt for a committed transaction.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

intent_hash
required
string (IntentHashInput)

The intent hash for a user transaction, also known as the transaction id. This hash identifies the core content "intent" of the transaction. Each intent can only be committed once. This hash gets signed by any signatories on the transaction, to create the signed intent. Either hex or Bech32m-encoded strings are supported.

object (TransactionFormatOptions)

Requested transaction formats to include in the response

Responses
200

Committed transaction found response

400

Client error

404

Committed transaction not found response

500

Server error

post/transaction/receipt
Request samples
application/json
{
  • "network": "{{network}}",
  • "intent_hash": "string",
  • "transaction_format_options": {
    }
}
Response samples
application/json
{
  • "committed": {
    }
}

Scrypto Call Preview

Preview a scrypto function or method call against the latest network state. Returns the result of the scrypto function or method call.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

object (LedgerStateSelector)

An optional specification of a historical ledger state at which to execute the request. The "historical state" feature (see the db.historical_substate_values.enable flag) must be enabled on the Node, and the requested point in history must be recent enough (in accordance with the Node's configured state_hash_tree.state_version_history_length).

required
object (TargetIdentifier)
arguments
required
Array of strings

Argument list

Responses
200

Result of the scrypto function call

400

Client error

500

Server error

post/transaction/call-preview
Request samples
application/json
{
  • "target": {
    },
  • "arguments": [
    ]
}
Response samples
application/json
{
  • "at_ledger_state": {
    },
  • "status": "Succeeded",
  • "output": {
    },
  • "error_message": "string"
}

Transaction Preview

Preview a transaction against the latest network state, and returns the preview receipt.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

object (LedgerStateSelector)

An optional specification of a historical ledger state at which to execute the request. The "historical state" feature (see the db.historical_substate_values.enable flag) must be enabled on the Node, and the requested point in history must be recent enough (in accordance with the Node's configured state_hash_tree.state_version_history_length).

manifest
required
string

A text-representation of a transaction manifest

blobs_hex
Array of strings

An array of hex-encoded blob data (optional)

start_epoch_inclusive
required
integer <int64> [ 0 .. 10000000000 ]

An integer between 0 and 10^10, marking the epoch at which the transaction starts being valid

end_epoch_exclusive
required
integer <int64> [ 0 .. 10000000000 ]

An integer between 0 and 10^10, marking the epoch at which the transaction is no longer valid

object (PublicKey)

The notary public key to use (optional)

notary_is_signatory
boolean

Whether the notary should count as a signatory (optional, default false)

tip_percentage
required
integer <int32> [ 0 .. 65535 ]

An integer between 0 and 65535, giving the validator tip as a percentage amount. A value of 1 corresponds to 1% of the fee.

nonce
required
integer <int64> [ 0 .. 4294967295 ]

An integer between 0 and 2^32 - 1, chosen to allow a unique intent to be created (to enable submitting an otherwise identical/duplicate intent).

required
Array of objects (PublicKey)

A list of public keys to be used as transaction signers

object (TransactionMessage)

An optional transaction message. Only affects the costing.

required
object
Responses
200

Transaction preview response

400

Client error

500

Server error

post/transaction/preview
Request samples
application/json
{
  • "network": "{{network}}",
  • "at_ledger_state": {
    },
  • "manifest": "string",
  • "blobs_hex": [
    ],
  • "start_epoch_inclusive": 10000000000,
  • "end_epoch_exclusive": 10000000000,
  • "notary_public_key": {
    },
  • "notary_is_signatory": true,
  • "tip_percentage": 65535,
  • "nonce": 4294967295,
  • "signer_public_keys": [
    ],
  • "message": {
    },
  • "flags": {
    }
}
Response samples
application/json
{
  • "at_ledger_state": {
    },
  • "encoded_receipt": "string",
  • "receipt": {
    },
  • "instruction_resource_changes": [
    ],
  • "logs": [
    ]
}

Mempool Endpoints

For information on the contents of the node's mempool.

Get Mempool List

Returns the hashes of all the transactions currently in the mempool

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

Responses
200

Mempool List Response

500

Server error

post/mempool/list
Request samples
application/json
{
  • "network": "{{network}}"
}
Response samples
application/json
{
  • "contents": [
    ]
}

Get Mempool Transaction

Returns the payload of a transaction currently in the mempool

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

payload_hashes
required
Array of strings (NotarizedTransactionHashInput)

A list of payload hashes to attempt to read. Each hash must be either hex, or in Bech32m format.

Responses
200

Mempool Transaction Response

404

Not found error

500

Server error

post/mempool/transaction
Request samples
application/json
{
  • "network": "{{network}}",
  • "payload_hashes": [
    ]
}
Response samples
application/json
{
  • "count": 0,
  • "payloads": [
    ]
}

State Endpoints

For reading the state of entities. At present, we only support reading details from the top of the currently committed ledger.

Get Consensus Manager Details

Reads the consensus manager's substate/s from the top of the current ledger.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

include_readiness_signals
boolean

Whether to include protocol update readiness signals of active validator set (default false).

Responses
200

Current state response

400

Client error

500

Server error

post/state/consensus-manager
Request samples
application/json
{
  • "network": "{{network}}",
  • "include_readiness_signals": true
}
Response samples
application/json
{
  • "at_ledger_state": {
    },
  • "config": {
    },
  • "state": {
    },
  • "current_proposal_statistic": {
    },
  • "current_validator_set": {
    },
  • "current_time": {
    },
  • "current_time_rounded_to_minutes": {
    },
  • "current_validator_readiness_signals": [
    ]
}

Get Account Details

Reads the account's substate/s from the top of the current ledger. Also returns all vaults under the account.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

account_address
required
string

The Bech32m-encoded human readable version of the account's global address

Responses
200

Current state response

400

Client error

404

Not found error

500

Server error

post/state/account
Request samples
application/json
{
  • "network": "{{network}}",
  • "account_address": "string"
}
Response samples
application/json
{
  • "at_ledger_state": {
    },
  • "info": {
    },
  • "owner_role": {
    },
  • "state": {
    },
  • "vaults": [
    ]
}

Get Component Details

Reads the component's substate/s from the top of the current ledger. Also recursively extracts vault balance totals from the component's entity subtree.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

component_address
required
string

The Bech32m-encoded human readable version of the component's global address

Responses
200

Current state response

400

Client error

404

Not found error

500

Server error

post/state/component
Request samples
application/json
{
  • "network": "{{network}}",
  • "component_address": "string"
}
Response samples
application/json
{
  • "at_ledger_state": {
    },
  • "info": {
    },
  • "state": {
    },
  • "royalty_accumulator": {
    },
  • "owner_role": {
    },
  • "vaults": [
    ],
  • "descendent_nodes": [
    ]
}

Get Validator Details

Reads the validator's substate/s from the top of the current ledger.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

validator_address
required
string (ComponentAddress)

The Bech32m-encoded human readable version of the component address

Responses
200

Current state response

400

Client error

404

Not found error

500

Server error

post/state/validator
Request samples
application/json
{
  • "network": "{{network}}",
  • "validator_address": "string"
}
Response samples
application/json
{
  • "at_ledger_state": {
    },
  • "address": "string",
  • "state": {
    },
  • "protocol_update_readiness_signal": {
    },
  • "owner_role": {
    },
  • "vaults": [
    ],
  • "descendent_nodes": [
    ]
}

Get Access Controller Details

Reads the access controller's substate/s from the top of the current ledger.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

controller_address
required
string (ComponentAddress)

The Bech32m-encoded human readable version of the component address

Responses
200

Current state response

400

Client error

404

Not found error

500

Server error

post/state/access-controller
Request samples
application/json
{
  • "network": "{{network}}",
  • "controller_address": "string"
}
Response samples
application/json
{
  • "at_ledger_state": {
    },
  • "state": {
    },
  • "owner_role": {
    },
  • "vaults": [
    ],
  • "descendent_nodes": [
    ]
}

Get Resource Details

Reads the resource manager's substate/s from the top of the current ledger.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

resource_address
required
string

The Bech32m-encoded human readable version of the resource's global address

Responses
200

Current state response

400

Client error

404

Not found error

500

Server error

post/state/resource
Request samples
application/json
{
  • "network": "{{network}}",
  • "resource_address": "string"
}
Response samples
application/json
{
  • "at_ledger_state": {
    },
  • "manager": {
    },
  • "owner_role": {
    }
}

Get Non-Fungible Details

Reads the data associated with a single Non-Fungible Unit under a Non-Fungible Resource.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

resource_address
required
string

The Bech32m-encoded human readable version of the resource's global address

non_fungible_id
required
string (NonFungibleLocalIdSimpleRepresentation)

The simple string representation of the non-fungible id.

  • For string ids, this is <the-string-id>
  • For integer ids, this is #the-integer-id#
  • For bytes ids, this is [the-lower-case-hex-representation]
  • For RUID ids, this is {...-...-...-...} where ... are each 16 hex characters. A given non-fungible resource has a fixed NonFungibleIdType, so this representation uniquely identifies this non-fungible under the given resource address.
Responses
200

Current state response

400

Client error

404

Not found error

500

Server error

post/state/non-fungible
Request samples
application/json
{
  • "network": "{{network}}",
  • "resource_address": "string",
  • "non_fungible_id": "string"
}
Response samples
application/json
{
  • "at_ledger_state": {
    },
  • "non_fungible": {
    }
}

Get Package Details

Reads the package's substate/s from the top of the current ledger.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

package_address
required
string

The Bech32m-encoded human readable version of the package's global address

Responses
200

Current state response

400

Client error

404

Not found error

500

Server error

post/state/package
Request samples
application/json
{
  • "network": "{{network}}",
  • "package_address": "string"
}
Response samples
application/json
{
  • "at_ledger_state": {
    },
  • "owner_role": {
    },
  • "royalty": {
    }
}

Stream Endpoints

To query the transaction or proof stream of the ledger.

Stream Proofs

Returns a stream of proofs committed to the node's ledger.

NOTE: This endpoint may return different results on different nodes:

  • Each node may persist different subset of signatures on a given proofs, as long as enough of the validator set has signed.
  • Inside an epoch, different nodes may receive and persist / keep different proofs, subject to constraints on gaps between proofs.

Proofs during an epoch can also be garbage collected by the node after the fact. Therefore proofs may disappear from this stream.

Some proofs (such as during genesis and protocol update enactment) are created on a node and don't include signatures.

This stream accepts four different options in the request:

  • All proofs forward (from state version)
  • All end-of-epoch proofs (from epoch number)
  • All end-of-epoch proofs triggering a protocol update
  • All node-injected proofs enacting genesis or a protocol update (for protocol update name, from state version)

The end-of-epoch proofs can be used to "trustlessly" verify the validator set for a given epoch. By tracking the fact that validators for epoch N sign the next validator set for epoch N + 1, this chain of proofs can be used to provide proof of the current validator set from a hardcoded start.

When a validator set is known for a given epoch, this can be used to verify the various transaction hash trees in the epoch, and to prove other data.

NOTE: This endpoint was built after agreeing the new Radix convention for paged APIs. Its models therefore follow the new convention, rather than attempting to align with existing loose Core API conventions.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

object (StreamProofsFilter)

If not provided, defaults to "Any".

max_page_size
integer

If specified, the maximum number of proofs that will be returned.

continuation_token
string (ContinuationToken)

A continuation token is returned if and only if there are further non-empty pages of items currently available. The token can be provided in a following request to fetch the next page of results. The filter and sort should not be changed when re-using the continuation token.

Responses
200

Stream proofs response

400

Client error

500

Server error

post/stream/proofs
Request samples
application/json
{
  • "network": "{{network}}",
  • "filter": {
    },
  • "max_page_size": 0,
  • "continuation_token": "string"
}
Response samples
application/json
{
  • "page": [
    ],
  • "continuation_token": "string"
}

Get Committed Transactions

Returns the list of committed transactions.

Request
Request Body schema: application/json
required
network
required
string (NetworkIdentifier)

The logical name of the network

from_state_version
required
integer <int64> (StateVersion) [ 1 .. 100000000000000 ]

The first (resultant) state version to be returned

limit
required
integer

The maximum number of transactions that will be returned.

object (SborFormatOptions)

Requested SBOR formats to include in the response

object (TransactionFormatOptions)

Requested transaction formats to include in the response

object (SubstateFormatOptions)

Requested substate formats to include in the response

include_proofs
boolean

Whether to include LedgerProofs (default false)

Responses
200

Committed transactions response

400

Client error

500

Server error

post/stream/transactions
Request samples
application/json
{
  • "network": "{{network}}",
  • "from_state_version": 1,
  • "limit": 0,
  • "sbor_format_options": {
    },
  • "transaction_format_options": {
    },
  • "substate_format_options": {
    },
  • "include_proofs": true
}
Response samples
application/json
{
  • "previous_state_identifiers": {
    },
  • "from_state_version": 1,
  • "count": 10000,
  • "max_ledger_state_version": 1,
  • "transactions": [
    ],
  • "proofs": [
    ]
}