Radix Core API - Babylon (Bottlenose)

vv1.2.0

Base URL

https://xrd.nownodes.io/core

Authentication

api-keyAuthapiKey

API Key: api-key in header

Core

LTS

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

Get Construction Metadata

POST

https://xrd.nownodes.io/core/lts/transaction/construction

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information necessary to build a transaction

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

Response

200OK

All info needed to build a transaction

500Internal Server Error

Server error

Get Construction Metadata

curl -X POST 'https://xrd.nownodes.io/core/lts/transaction/construction' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}"
  }'

const response = await fetch('https://xrd.nownodes.io/core/lts/transaction/construction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/transaction/construction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}"
}

response = requests.post('https://xrd.nownodes.io/core/lts/transaction/construction', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/lts/transaction/construction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/lts/transaction/construction";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/lts/transaction/construction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}"
}

response = requests.post('https://xrd.nownodes.io/core/lts/transaction/construction', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/transaction/construction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}"
}

{
  "current_epoch": 0,
  "ledger_clock": {
    "unix_timestamp_ms": 0,
    "date_time": "string"
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Submit Transaction

POST

https://xrd.nownodes.io/core/lts/transaction/submit

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

notarized_transaction_hexstringrequired

A hex-encoded, compiled notarized transaction.

force_recalculateboolean

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

Response

200OK

Transaction Submit Response

400Bad Request

Client error

500Internal Server Error

Server error

Submit Transaction

curl -X POST 'https://xrd.nownodes.io/core/lts/transaction/submit' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "notarized_transaction_hex": "string",
    "force_recalculate": true
  }'

const response = await fetch('https://xrd.nownodes.io/core/lts/transaction/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "notarized_transaction_hex": "string",
      "force_recalculate": true
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/transaction/submit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "notarized_transaction_hex": "string",
    "force_recalculate": true
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "notarized_transaction_hex": "string",
  "force_recalculate": True
}

response = requests.post('https://xrd.nownodes.io/core/lts/transaction/submit', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/lts/transaction/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "notarized_transaction_hex": "string",
      "force_recalculate": true
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/lts/transaction/submit";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "notarized_transaction_hex": "string",
    "force_recalculate": true
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/lts/transaction/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "notarized_transaction_hex": "string",
      "force_recalculate": true
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "notarized_transaction_hex": "string",
  "force_recalculate": True
}

response = requests.post('https://xrd.nownodes.io/core/lts/transaction/submit', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/transaction/submit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "notarized_transaction_hex": "string",
    "force_recalculate": true
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "notarized_transaction_hex": "string",
  "force_recalculate": true
}

{
  "duplicate": true
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string",
  "details": {
    "type": "PriorityThresholdNotMet"
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string",
  "details": {
    "type": "PriorityThresholdNotMet"
  }
}

Get Transaction Status

POST

https://xrd.nownodes.io/core/lts/transaction/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

intent_hashIntentHashInputrequired

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.

Response

200OK

Transaction status response

400Bad Request

Client error

500Internal Server Error

Server error

Get Transaction Status

curl -X POST 'https://xrd.nownodes.io/core/lts/transaction/status' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "intent_hash": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/lts/transaction/status', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "intent_hash": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/transaction/status')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "intent_hash": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "intent_hash": "string"
}

response = requests.post('https://xrd.nownodes.io/core/lts/transaction/status', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/lts/transaction/status', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "intent_hash": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/lts/transaction/status";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "intent_hash": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/lts/transaction/status', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "intent_hash": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "intent_hash": "string"
}

response = requests.post('https://xrd.nownodes.io/core/lts/transaction/status', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/transaction/status')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "intent_hash": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "intent_hash": "string"
}

{
  "intent_status": "CommittedSuccess",
  "status_description": "string",
  "committed_state_version": 1,
  "invalid_from_epoch": 0,
  "known_payloads": [
    {
      "payload_hash": "string",
      "payload_hash_bech32m": "string",
      "state_version": 1,
      "status": "CommittedSuccess",
      "error_message": "string"
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get All Account Balances

POST

https://xrd.nownodes.io/core/lts/state/account-all-fungible-resource-balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns balances for all resources associated with an account

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

account_addressstringrequired

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

Response

200OK

Account all resource balances response

500Internal Server Error

Server error

Get All Account Balances

curl -X POST 'https://xrd.nownodes.io/core/lts/state/account-all-fungible-resource-balances' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "account_address": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/lts/state/account-all-fungible-resource-balances', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/state/account-all-fungible-resource-balances')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "account_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "account_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/lts/state/account-all-fungible-resource-balances', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/lts/state/account-all-fungible-resource-balances', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/lts/state/account-all-fungible-resource-balances";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "account_address": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/lts/state/account-all-fungible-resource-balances', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "account_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/lts/state/account-all-fungible-resource-balances', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/state/account-all-fungible-resource-balances')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "account_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "account_address": "string"
}

{
  "state_version": 1,
  "ledger_header_summary": {
    "epoch_round": {
      "epoch": 0,
      "round": 0
    },
    "ledger_hashes": {
      "state_tree_hash": "string",
      "transaction_tree_hash": "string",
      "receipt_tree_hash": "string"
    },
    "proposer_timestamp": {
      "unix_timestamp_ms": 0,
      "date_time": "string"
    }
  },
  "account_address": "string",
  "fungible_resource_balances": [
    {
      "fungible_resource_address": "string",
      "amount": "string"
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Single Account Balance

POST

https://xrd.nownodes.io/core/lts/state/account-fungible-resource-balance

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns balance of a single fungible resource in an account

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

account_addressstringrequired

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

resource_addressResourceAddressrequired

The Bech32m-encoded human readable version of the resource address

Response

200OK

Account resource balance response

500Internal Server Error

Server error

Get Single Account Balance

curl -X POST 'https://xrd.nownodes.io/core/lts/state/account-fungible-resource-balance' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "account_address": "string",
    "resource_address": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/lts/state/account-fungible-resource-balance', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string",
      "resource_address": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/state/account-fungible-resource-balance')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "account_address": "string",
    "resource_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "account_address": "string",
  "resource_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/lts/state/account-fungible-resource-balance', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/lts/state/account-fungible-resource-balance', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string",
      "resource_address": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/lts/state/account-fungible-resource-balance";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "account_address": "string",
    "resource_address": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/lts/state/account-fungible-resource-balance', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string",
      "resource_address": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "account_address": "string",
  "resource_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/lts/state/account-fungible-resource-balance', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/state/account-fungible-resource-balance')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "account_address": "string",
    "resource_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "account_address": "string",
  "resource_address": "string"
}

{
  "state_version": 1,
  "ledger_header_summary": {
    "epoch_round": {
      "epoch": 0,
      "round": 0
    },
    "ledger_hashes": {
      "state_tree_hash": "string",
      "transaction_tree_hash": "string",
      "receipt_tree_hash": "string"
    },
    "proposer_timestamp": {
      "unix_timestamp_ms": 0,
      "date_time": "string"
    }
  },
  "account_address": "string",
  "fungible_resource_balance": {
    "fungible_resource_address": "string",
    "amount": "string"
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Account Deposit Behaviour

POST

https://xrd.nownodes.io/core/lts/state/account-deposit-behaviour

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns deposit behaviour of a single account for multiple resource addresses

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

account_addressstringrequired

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

resource_addressesArray<ResourceAddress>

The resource addresses to check the deposit behaviours of.

badgePresentedBadge

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

Show child attributes

typePresentedBadgeTypeResourceNonFungiblerequired

resource_addressResourceAddressrequired

The Bech32m-encoded human readable version of the resource address

Response

200OK

Account deposit behaviour response

500Internal Server Error

Server error

Get Account Deposit Behaviour

curl -X POST 'https://xrd.nownodes.io/core/lts/state/account-deposit-behaviour' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "account_address": "string",
    "resource_addresses": [
      "string"
    ],
    "badge": {
      "type": "Resource",
      "resource_address": "string"
    }
  }'

const response = await fetch('https://xrd.nownodes.io/core/lts/state/account-deposit-behaviour', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string",
      "resource_addresses": [
        "string"
      ],
      "badge": {
        "type": "Resource",
        "resource_address": "string"
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/state/account-deposit-behaviour')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "account_address": "string",
    "resource_addresses": [
      "string"
    ],
    "badge": {
      "type": "Resource",
      "resource_address": "string"
    }
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "account_address": "string",
  "resource_addresses": [
    "string"
  ],
  "badge": {
    "type": "Resource",
    "resource_address": "string"
  }
}

response = requests.post('https://xrd.nownodes.io/core/lts/state/account-deposit-behaviour', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/lts/state/account-deposit-behaviour', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string",
      "resource_addresses": [
        "string"
      ],
      "badge": {
        "type": "Resource",
        "resource_address": "string"
      }
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/lts/state/account-deposit-behaviour";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "account_address": "string",
    "resource_addresses": [
      "string"
    ],
    "badge": {
      "type": "Resource",
      "resource_address": "string"
    }
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/lts/state/account-deposit-behaviour', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string",
      "resource_addresses": [
        "string"
      ],
      "badge": {
        "type": "Resource",
        "resource_address": "string"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "account_address": "string",
  "resource_addresses": [
    "string"
  ],
  "badge": {
    "type": "Resource",
    "resource_address": "string"
  }
}

response = requests.post('https://xrd.nownodes.io/core/lts/state/account-deposit-behaviour', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/state/account-deposit-behaviour')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "account_address": "string",
    "resource_addresses": [
      "string"
    ],
    "badge": {
      "type": "Resource",
      "resource_address": "string"
    }
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "account_address": "string",
  "resource_addresses": [
    "string"
  ],
  "badge": {
    "type": "Resource",
    "resource_address": "string"
  }
}

{
  "state_version": 1,
  "ledger_header_summary": {
    "epoch_round": {
      "epoch": 0,
      "round": 0
    },
    "ledger_hashes": {
      "state_tree_hash": "string",
      "transaction_tree_hash": "string",
      "receipt_tree_hash": "string"
    },
    "proposer_timestamp": {
      "unix_timestamp_ms": 0,
      "date_time": "string"
    }
  },
  "default_deposit_rule": "Accept",
  "is_badge_authorized_depositor": true,
  "resource_specific_behaviours": {}
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Transaction Outcomes

POST

https://xrd.nownodes.io/core/lts/stream/transaction-outcomes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

A request to retrieve a sublist of committed transactions from the ledger.

networkNetworkIdentifierrequired

The logical name of the network

from_state_versionStateVersion<int64>[1, 100000000000000]required

The first (resultant) state version to be returned

limitintegerrequired

The maximum number of transactions that will be returned.

Response

200OK

Paged response

400Bad Request

Client error

500Internal Server Error

Server error

Get Transaction Outcomes

curl -X POST 'https://xrd.nownodes.io/core/lts/stream/transaction-outcomes' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "from_state_version": 1,
    "limit": 0
  }'

const response = await fetch('https://xrd.nownodes.io/core/lts/stream/transaction-outcomes', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "from_state_version": 1,
      "limit": 0
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/stream/transaction-outcomes')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "from_state_version": 1,
    "limit": 0
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "from_state_version": 1,
  "limit": 0
}

response = requests.post('https://xrd.nownodes.io/core/lts/stream/transaction-outcomes', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/lts/stream/transaction-outcomes', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "from_state_version": 1,
      "limit": 0
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/lts/stream/transaction-outcomes";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "from_state_version": 1,
    "limit": 0
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/lts/stream/transaction-outcomes', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "from_state_version": 1,
      "limit": 0
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "from_state_version": 1,
  "limit": 0
}

response = requests.post('https://xrd.nownodes.io/core/lts/stream/transaction-outcomes', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/stream/transaction-outcomes')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "from_state_version": 1,
    "limit": 0
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "from_state_version": 1,
  "limit": 0
}

{
  "from_state_version": 1,
  "count": 0,
  "max_ledger_state_version": 1,
  "committed_transaction_outcomes": [
    {
      "state_version": 1,
      "proposer_timestamp_ms": 0,
      "accumulator_hash": "string",
      "user_transaction_identifiers": {
        "intent_hash": "string",
        "intent_hash_bech32m": "string",
        "signed_intent_hash": "string",
        "signed_intent_hash_bech32m": "string",
        "payload_hash": "string",
        "payload_hash_bech32m": "string"
      },
      "status": "Success",
      "fungible_entity_balance_changes": [
        {
          "entity_address": "string",
          "fee_balance_change": {
            "resource_address": "string",
            "balance_change": "string"
          },
          "fee_balance_changes": [
            {
              "type": "FeePayment",
              "resource_address": "string",
              "balance_change": "string"
            }
          ],
          "non_fee_balance_changes": [
            {
              "resource_address": "string",
              "balance_change": "string"
            }
          ]
        }
      ],
      "non_fungible_entity_balance_changes": [
        {
          "entity_address": "string",
          "resource_address": "string",
          "added": [
            "string"
          ],
          "removed": [
            "string"
          ]
        }
      ],
      "resultant_account_fungible_balances": [
        {
          "account_address": "string",
          "resultant_balances": [
            {
              "resource_address": "string",
              "resultant_balance": "string"
            }
          ]
        }
      ],
      "total_fee": "string"
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Account Transaction Outcomes

POST

https://xrd.nownodes.io/core/lts/stream/account-transaction-outcomes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

A request to retrieve a sublist of committed transactions from the ledger.

networkNetworkIdentifierrequired

The logical name of the network

account_addressstringrequired

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

from_state_versionStateVersion<int64>[1, 100000000000000]required

The first (resultant) state version to be returned

limitintegerrequired

The maximum number of transactions that will be returned.

Response

200OK

Paged response

400Bad Request

Client error

500Internal Server Error

Server error

Get Account Transaction Outcomes

curl -X POST 'https://xrd.nownodes.io/core/lts/stream/account-transaction-outcomes' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "account_address": "string",
    "from_state_version": 1,
    "limit": 0
  }'

const response = await fetch('https://xrd.nownodes.io/core/lts/stream/account-transaction-outcomes', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string",
      "from_state_version": 1,
      "limit": 0
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/stream/account-transaction-outcomes')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "account_address": "string",
    "from_state_version": 1,
    "limit": 0
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "account_address": "string",
  "from_state_version": 1,
  "limit": 0
}

response = requests.post('https://xrd.nownodes.io/core/lts/stream/account-transaction-outcomes', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/lts/stream/account-transaction-outcomes', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string",
      "from_state_version": 1,
      "limit": 0
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/lts/stream/account-transaction-outcomes";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "account_address": "string",
    "from_state_version": 1,
    "limit": 0
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/lts/stream/account-transaction-outcomes', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string",
      "from_state_version": 1,
      "limit": 0
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "account_address": "string",
  "from_state_version": 1,
  "limit": 0
}

response = requests.post('https://xrd.nownodes.io/core/lts/stream/account-transaction-outcomes', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/lts/stream/account-transaction-outcomes')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "account_address": "string",
    "from_state_version": 1,
    "limit": 0
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "account_address": "string",
  "from_state_version": 1,
  "limit": 0
}

{
  "from_state_version": 1,
  "count": 0,
  "max_ledger_state_version": 1,
  "committed_transaction_outcomes": [
    {
      "state_version": 1,
      "proposer_timestamp_ms": 0,
      "accumulator_hash": "string",
      "user_transaction_identifiers": {
        "intent_hash": "string",
        "intent_hash_bech32m": "string",
        "signed_intent_hash": "string",
        "signed_intent_hash_bech32m": "string",
        "payload_hash": "string",
        "payload_hash_bech32m": "string"
      },
      "status": "Success",
      "fungible_entity_balance_changes": [
        {
          "entity_address": "string",
          "fee_balance_change": {
            "resource_address": "string",
            "balance_change": "string"
          },
          "fee_balance_changes": [
            {
              "type": "FeePayment",
              "resource_address": "string",
              "balance_change": "string"
            }
          ],
          "non_fee_balance_changes": [
            {
              "resource_address": "string",
              "balance_change": "string"
            }
          ]
        }
      ],
      "non_fungible_entity_balance_changes": [
        {
          "entity_address": "string",
          "resource_address": "string",
          "added": [
            "string"
          ],
          "removed": [
            "string"
          ]
        }
      ],
      "resultant_account_fungible_balances": [
        {
          "account_address": "string",
          "resultant_balances": [
            {
              "resource_address": "string",
              "resultant_balance": "string"
            }
          ]
        }
      ],
      "total_fee": "string"
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Status

For status and configuration details for the node / engine.

Get Network Configuration

POST

https://xrd.nownodes.io/core/status/network-configuration

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Response

200OK

Network Configuration

500Internal Server Error

Server error

Get Network Configuration

curl -X POST 'https://xrd.nownodes.io/core/status/network-configuration'

const response = await fetch('https://xrd.nownodes.io/core/status/network-configuration', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/status/network-configuration')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.post('https://xrd.nownodes.io/core/status/network-configuration')
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/status/network-configuration', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/status/network-configuration";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/status/network-configuration', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://xrd.nownodes.io/core/status/network-configuration')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/status/network-configuration')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "version": {
    "core_version": "string",
    "api_version": "string"
  },
  "network": "{{network}}",
  "network_id": 0,
  "network_hrp_suffix": "string",
  "usd_price_in_xrd": "string",
  "address_types": [
    {
      "hrp_prefix": "string",
      "entity_type": "GlobalPackage",
      "address_byte_prefix": 0,
      "address_byte_length": 0
    }
  ],
  "well_known_addresses": {
    "xrd": "string",
    "secp256k1_signature_virtual_badge": "string",
    "ed25519_signature_virtual_badge": "string",
    "package_of_direct_caller_virtual_badge": "string",
    "global_caller_virtual_badge": "string",
    "system_transaction_badge": "string",
    "package_owner_badge": "string",
    "validator_owner_badge": "string",
    "account_owner_badge": "string",
    "identity_owner_badge": "string",
    "package_package": "string",
    "resource_package": "string",
    "account_package": "string",
    "identity_package": "string",
    "consensus_manager_package": "string",
    "access_controller_package": "string",
    "transaction_processor_package": "string",
    "metadata_module_package": "string",
    "royalty_module_package": "string",
    "role_assignment_module_package": "string",
    "genesis_helper_package": "string",
    "faucet_package": "string",
    "pool_package": "string",
    "locker_package": "string",
    "consensus_manager": "string",
    "genesis_helper": "string",
    "faucet": "string",
    "transaction_tracker": "string"
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Network Status

POST

https://xrd.nownodes.io/core/status/network-status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

Response

200OK

Network Status

500Internal Server Error

Server error

Get Network Status

curl -X POST 'https://xrd.nownodes.io/core/status/network-status' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}"
  }'

const response = await fetch('https://xrd.nownodes.io/core/status/network-status', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/status/network-status')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}"
}

response = requests.post('https://xrd.nownodes.io/core/status/network-status', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/status/network-status', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/status/network-status";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/status/network-status', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}"
}

response = requests.post('https://xrd.nownodes.io/core/status/network-status', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/status/network-status')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}"
}

{
  "pre_genesis_state_identifier": {
    "state_version": 1,
    "state_tree_hash": "string",
    "transaction_tree_hash": "string",
    "receipt_tree_hash": "string"
  },
  "genesis_epoch_round": {
    "epoch": 0,
    "round": 0
  },
  "post_genesis_state_identifier": {
    "state_version": 1,
    "state_tree_hash": "string",
    "transaction_tree_hash": "string",
    "receipt_tree_hash": "string"
  },
  "post_genesis_epoch_round": {
    "epoch": 0,
    "round": 0
  },
  "current_state_identifier": {
    "state_version": 1,
    "state_tree_hash": "string",
    "transaction_tree_hash": "string",
    "receipt_tree_hash": "string"
  },
  "current_epoch_round": {
    "epoch": 0,
    "round": 0
  },
  "current_protocol_version": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Scenarios' results.

POST

https://xrd.nownodes.io/core/status/scenarios

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

Response

200OK

Scenarios' results

500Internal Server Error

Server error

Get Scenarios' results.

curl -X POST 'https://xrd.nownodes.io/core/status/scenarios' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}"
  }'

const response = await fetch('https://xrd.nownodes.io/core/status/scenarios', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/status/scenarios')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}"
}

response = requests.post('https://xrd.nownodes.io/core/status/scenarios', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/status/scenarios', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/status/scenarios";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/status/scenarios', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}"
}

response = requests.post('https://xrd.nownodes.io/core/status/scenarios', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/status/scenarios')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}"
}

{
  "executed_scenarios": [
    {
      "sequence_number": 0,
      "logical_name": "string",
      "committed_transactions": [
        {
          "logical_name": "string",
          "state_version": 1,
          "intent_hash": "string",
          "intent_hash_bech32m": "string"
        }
      ],
      "addresses": {}
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Transaction

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

Parse Transaction Payload

POST

https://xrd.nownodes.io/core/transaction/parse

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

payload_hexstringrequired

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_modestringAnyNotarizedSignedUnsignedLedger

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.

validation_modestringNoneStaticFull

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.

response_modestringBasicFull

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.

transaction_format_optionsTransactionFormatOptions

Requested transaction formats to include in the response

Show child attributes

manifestboolean

Whether to return the raw manifest (default true)

blobsboolean

Whether to return the hex-encoded blobs (default false)

messageboolean

Whether to return the transaction message (default true)

balance_changesboolean

Whether to return the transaction balance changes (default false)

raw_system_transactionboolean

Whether to return the raw hex-encoded system transaction bytes (default false)

raw_notarized_transactionboolean

Whether to return the raw hex-encoded notarized transaction bytes (default true)

raw_ledger_transactionboolean

Whether to return the raw hex-encoded ledger transaction bytes (default false)

Response

200OK

Transaction Parse Response

400Bad Request

Client error

500Internal Server Error

Server error

Parse Transaction Payload

curl -X POST 'https://xrd.nownodes.io/core/transaction/parse' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "payload_hex": "string",
    "parse_mode": "Any",
    "validation_mode": "None",
    "response_mode": "Basic",
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    }
  }'

const response = await fetch('https://xrd.nownodes.io/core/transaction/parse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "payload_hex": "string",
      "parse_mode": "Any",
      "validation_mode": "None",
      "response_mode": "Basic",
      "transaction_format_options": {
        "manifest": true,
        "blobs": true,
        "message": true,
        "balance_changes": true,
        "raw_system_transaction": true,
        "raw_notarized_transaction": true,
        "raw_ledger_transaction": true
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/parse')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "payload_hex": "string",
    "parse_mode": "Any",
    "validation_mode": "None",
    "response_mode": "Basic",
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    }
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "payload_hex": "string",
  "parse_mode": "Any",
  "validation_mode": "None",
  "response_mode": "Basic",
  "transaction_format_options": {
    "manifest": True,
    "blobs": True,
    "message": True,
    "balance_changes": True,
    "raw_system_transaction": True,
    "raw_notarized_transaction": True,
    "raw_ledger_transaction": True
  }
}

response = requests.post('https://xrd.nownodes.io/core/transaction/parse', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/transaction/parse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "payload_hex": "string",
      "parse_mode": "Any",
      "validation_mode": "None",
      "response_mode": "Basic",
      "transaction_format_options": {
        "manifest": true,
        "blobs": true,
        "message": true,
        "balance_changes": true,
        "raw_system_transaction": true,
        "raw_notarized_transaction": true,
        "raw_ledger_transaction": true
      }
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/transaction/parse";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "payload_hex": "string",
    "parse_mode": "Any",
    "validation_mode": "None",
    "response_mode": "Basic",
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    }
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/transaction/parse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "payload_hex": "string",
      "parse_mode": "Any",
      "validation_mode": "None",
      "response_mode": "Basic",
      "transaction_format_options": {
        "manifest": true,
        "blobs": true,
        "message": true,
        "balance_changes": true,
        "raw_system_transaction": true,
        "raw_notarized_transaction": true,
        "raw_ledger_transaction": true
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "payload_hex": "string",
  "parse_mode": "Any",
  "validation_mode": "None",
  "response_mode": "Basic",
  "transaction_format_options": {
    "manifest": True,
    "blobs": True,
    "message": True,
    "balance_changes": True,
    "raw_system_transaction": True,
    "raw_notarized_transaction": True,
    "raw_ledger_transaction": True
  }
}

response = requests.post('https://xrd.nownodes.io/core/transaction/parse', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/parse')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "payload_hex": "string",
    "parse_mode": "Any",
    "validation_mode": "None",
    "response_mode": "Basic",
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    }
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "payload_hex": "string",
  "parse_mode": "Any",
  "validation_mode": "None",
  "response_mode": "Basic",
  "transaction_format_options": {
    "manifest": true,
    "blobs": true,
    "message": true,
    "balance_changes": true,
    "raw_system_transaction": true,
    "raw_notarized_transaction": true,
    "raw_ledger_transaction": true
  }
}

{
  "parsed": {
    "type": "NotarizedTransaction"
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Transaction Submit

POST

https://xrd.nownodes.io/core/transaction/submit

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

notarized_transaction_hexstringrequired

A hex-encoded, compiled notarized transaction.

force_recalculateboolean

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

Response

200OK

Transaction Submit Response

400Bad Request

Client error

500Internal Server Error

Server error

Transaction Submit

curl -X POST 'https://xrd.nownodes.io/core/transaction/submit' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "notarized_transaction_hex": "string",
    "force_recalculate": true
  }'

const response = await fetch('https://xrd.nownodes.io/core/transaction/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "notarized_transaction_hex": "string",
      "force_recalculate": true
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/submit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "notarized_transaction_hex": "string",
    "force_recalculate": true
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "notarized_transaction_hex": "string",
  "force_recalculate": True
}

response = requests.post('https://xrd.nownodes.io/core/transaction/submit', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/transaction/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "notarized_transaction_hex": "string",
      "force_recalculate": true
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/transaction/submit";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "notarized_transaction_hex": "string",
    "force_recalculate": true
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/transaction/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "notarized_transaction_hex": "string",
      "force_recalculate": true
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "notarized_transaction_hex": "string",
  "force_recalculate": True
}

response = requests.post('https://xrd.nownodes.io/core/transaction/submit', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/submit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "notarized_transaction_hex": "string",
    "force_recalculate": true
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "notarized_transaction_hex": "string",
  "force_recalculate": true
}

{
  "duplicate": true
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string",
  "details": {
    "type": "PriorityThresholdNotMet"
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string",
  "details": {
    "type": "PriorityThresholdNotMet"
  }
}

Get Transaction Status

POST

https://xrd.nownodes.io/core/transaction/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

intent_hashIntentHashInputrequired

Response

200OK

Transaction status response

400Bad Request

Client error

500Internal Server Error

Server error

Get Transaction Status

curl -X POST 'https://xrd.nownodes.io/core/transaction/status' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "intent_hash": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/transaction/status', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "intent_hash": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/status')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "intent_hash": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "intent_hash": "string"
}

response = requests.post('https://xrd.nownodes.io/core/transaction/status', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/transaction/status', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "intent_hash": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/transaction/status";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "intent_hash": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/transaction/status', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "intent_hash": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "intent_hash": "string"
}

response = requests.post('https://xrd.nownodes.io/core/transaction/status', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/status')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "intent_hash": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "intent_hash": "string"
}

{
  "intent_status": "CommittedSuccess",
  "status_description": "string",
  "invalid_from_epoch": 0,
  "known_payloads": [
    {
      "payload_hash": "string",
      "payload_hash_bech32m": "string",
      "state_version": 1,
      "status": "CommittedSuccess",
      "error_message": "string"
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Transaction Receipt

POST

https://xrd.nownodes.io/core/transaction/receipt

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Gets the transaction receipt for a committed transaction.

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

intent_hashIntentHashInputrequired

transaction_format_optionsTransactionFormatOptions

Requested transaction formats to include in the response

Show child attributes

manifestboolean

Whether to return the raw manifest (default true)

blobsboolean

Whether to return the hex-encoded blobs (default false)

messageboolean

Whether to return the transaction message (default true)

balance_changesboolean

Whether to return the transaction balance changes (default false)

raw_system_transactionboolean

Whether to return the raw hex-encoded system transaction bytes (default false)

raw_notarized_transactionboolean

Whether to return the raw hex-encoded notarized transaction bytes (default true)

raw_ledger_transactionboolean

Whether to return the raw hex-encoded ledger transaction bytes (default false)

Response

200OK

Committed transaction found response

400Bad Request

Client error

404Not Found

Committed transaction not found response

500Internal Server Error

Server error

Get Transaction Receipt

curl -X POST 'https://xrd.nownodes.io/core/transaction/receipt' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "intent_hash": "string",
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    }
  }'

const response = await fetch('https://xrd.nownodes.io/core/transaction/receipt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "intent_hash": "string",
      "transaction_format_options": {
        "manifest": true,
        "blobs": true,
        "message": true,
        "balance_changes": true,
        "raw_system_transaction": true,
        "raw_notarized_transaction": true,
        "raw_ledger_transaction": true
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/receipt')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "intent_hash": "string",
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    }
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "intent_hash": "string",
  "transaction_format_options": {
    "manifest": True,
    "blobs": True,
    "message": True,
    "balance_changes": True,
    "raw_system_transaction": True,
    "raw_notarized_transaction": True,
    "raw_ledger_transaction": True
  }
}

response = requests.post('https://xrd.nownodes.io/core/transaction/receipt', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/transaction/receipt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "intent_hash": "string",
      "transaction_format_options": {
        "manifest": true,
        "blobs": true,
        "message": true,
        "balance_changes": true,
        "raw_system_transaction": true,
        "raw_notarized_transaction": true,
        "raw_ledger_transaction": true
      }
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/transaction/receipt";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "intent_hash": "string",
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    }
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/transaction/receipt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "intent_hash": "string",
      "transaction_format_options": {
        "manifest": true,
        "blobs": true,
        "message": true,
        "balance_changes": true,
        "raw_system_transaction": true,
        "raw_notarized_transaction": true,
        "raw_ledger_transaction": true
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "intent_hash": "string",
  "transaction_format_options": {
    "manifest": True,
    "blobs": True,
    "message": True,
    "balance_changes": True,
    "raw_system_transaction": True,
    "raw_notarized_transaction": True,
    "raw_ledger_transaction": True
  }
}

response = requests.post('https://xrd.nownodes.io/core/transaction/receipt', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/receipt')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "intent_hash": "string",
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    }
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "intent_hash": "string",
  "transaction_format_options": {
    "manifest": true,
    "blobs": true,
    "message": true,
    "balance_changes": true,
    "raw_system_transaction": true,
    "raw_notarized_transaction": true,
    "raw_ledger_transaction": true
  }
}

{
  "committed": {
    "resultant_state_identifiers": {
      "state_version": 1,
      "state_tree_hash": "string",
      "transaction_tree_hash": "string",
      "receipt_tree_hash": "string"
    },
    "ledger_transaction": {
      "type": "Genesis",
      "payload_hex": "string"
    },
    "receipt": {
      "status": "Succeeded",
      "fee_summary": {
        "execution_cost_units_consumed": 0,
        "finalization_cost_units_consumed": 0,
        "xrd_total_execution_cost": "string",
        "xrd_total_finalization_cost": "string",
        "xrd_total_royalty_cost": "string",
        "xrd_total_storage_cost": "string",
        "xrd_total_tipping_cost": "string"
      },
      "costing_parameters": {
        "execution_cost_unit_price": "string",
        "execution_cost_unit_limit": 0,
        "execution_cost_unit_loan": 0,
        "finalization_cost_unit_price": "string",
        "finalization_cost_unit_limit": 0,
        "xrd_usd_price": "string",
        "xrd_storage_price": "string",
        "xrd_archive_storage_price": "string",
        "tip_percentage": 0
      },
      "fee_source": {
        "from_vaults": [
          {
            "vault_entity": {
              "entity_type": "GlobalPackage",
              "is_global": true,
              "entity_address": "string"
            },
            "xrd_amount": "string"
          }
        ]
      },
      "fee_destination": {
        "to_proposer": "string",
        "to_validator_set": "string",
        "to_burn": "string",
        "to_royalty_recipients": [
          {
            "royalty_recipient": {
              "entity_type": "GlobalPackage",
              "is_global": true,
              "entity_address": "string"
            },
            "xrd_amount": "string"
          }
        ]
      },
      "state_updates": {
        "deleted_partitions": [
          {
            "entity_type": "GlobalPackage",
            "entity_address": "string",
            "entity_module": "TypeInfo",
            "partition_kind": "Field",
            "partition_number": 0
          }
        ],
        "created_substates": [
          {
            "substate_id": {
              "entity_type": "GlobalPackage",
              "entity_address": "string",
              "entity_module": "TypeInfo",
              "partition_kind": "Field",
              "partition_number": 0,
              "substate_type": "BootLoaderModuleFieldVmBoot",
              "substate_key": {
                "key_type": "Field",
                "db_sort_key_hex": "string"
              }
            },
            "value": {
              "substate_hex": "string",
              "substate_data_hash": "string",
              "substate_data": {
                "substate_type": "BootLoaderModuleFieldVmBoot",
                "is_locked": true
              }
            },
            "system_structure": {
              "type": "SystemField"
            }
          }
        ],
        "updated_substates": [
          {
            "substate_id": {
              "entity_type": "GlobalPackage",
              "entity_address": "string",
              "entity_module": "TypeInfo",
              "partition_kind": "Field",
              "partition_number": 0,
              "substate_type": "BootLoaderModuleFieldVmBoot",
              "substate_key": {
                "key_type": "Field",
                "db_sort_key_hex": "string"
              }
            },
            "new_value": {
              "substate_hex": "string",
              "substate_data_hash": "string",
              "substate_data": {
                "substate_type": "BootLoaderModuleFieldVmBoot",
                "is_locked": true
              }
            },
            "previous_value": {
              "substate_hex": "string",
              "substate_data_hash": "string",
              "substate_data": {
                "substate_type": "BootLoaderModuleFieldVmBoot",
                "is_locked": true
              }
            },
            "system_structure": {
              "type": "SystemField"
            }
          }
        ],
        "deleted_substates": [
          {
            "substate_id": {
              "entity_type": "GlobalPackage",
              "entity_address": "string",
              "entity_module": "TypeInfo",
              "partition_kind": "Field",
              "partition_number": 0,
              "substate_type": "BootLoaderModuleFieldVmBoot",
              "substate_key": {
                "key_type": "Field",
                "db_sort_key_hex": "string"
              }
            },
            "previous_value": {
              "substate_hex": "string",
              "substate_data_hash": "string",
              "substate_data": {
                "substate_type": "BootLoaderModuleFieldVmBoot",
                "is_locked": true
              }
            },
            "system_structure": {
              "type": "SystemField"
            }
          }
        ],
        "new_global_entities": [
          {
            "entity_type": "GlobalPackage",
            "is_global": true,
            "entity_address": "string"
          }
        ]
      },
      "events": [
        {
          "type": {
            "emitter": {
              "type": "Function"
            },
            "type_reference": {
              "full_type_id": {
                "entity_address": "string",
                "schema_hash": "string",
                "local_type_id": {
                  "kind": "WellKnown",
                  "id": 0,
                  "as_sbor": {
                    "hex": "string"
                  }
                }
              }
            },
            "name": "string"
          },
          "data": {
            "hex": "string"
          }
        }
      ],
      "next_epoch": {
        "epoch": 0,
        "validators": [
          {
            "address": "string",
            "key": {
              "key_type": "EcdsaSecp256k1",
              "key_hex": "string"
            },
            "stake": "string"
          }
        ],
        "significant_protocol_update_readiness": [
          {
            "readiness_signal_name": "string",
            "signalled_stake": "string"
          }
        ]
      },
      "output": [
        {
          "hex": "string"
        }
      ],
      "error_message": "string"
    },
    "balance_changes": {
      "fungible_entity_balance_changes": [
        {
          "entity_address": "string",
          "fee_balance_change": {
            "resource_address": "string",
            "balance_change": "string"
          },
          "fee_balance_changes": [
            {
              "type": "FeePayment",
              "resource_address": "string",
              "balance_change": "string"
            }
          ],
          "non_fee_balance_changes": [
            {
              "resource_address": "string",
              "balance_change": "string"
            }
          ]
        }
      ],
      "non_fungible_entity_balance_changes": [
        {
          "entity_address": "string",
          "resource_address": "string",
          "added": [
            "string"
          ],
          "removed": [
            "string"
          ]
        }
      ]
    },
    "proposer_timestamp_ms": 0
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Scrypto Call Preview

POST

https://xrd.nownodes.io/core/transaction/call-preview

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

at_ledger_stateLedgerStateSelector

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).

Show child attributes

typeLedgerStateSelectorTypeByStateVersionrequired

targetTargetIdentifierrequired

Show child attributes

typeTargetIdentifierTypeMethodFunctionrequired

argumentsArray<string>required

Argument list

Response

200OK

Result of the scrypto function call

400Bad Request

Client error

500Internal Server Error

Server error

Scrypto Call Preview

curl -X POST 'https://xrd.nownodes.io/core/transaction/call-preview' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "at_ledger_state": {
      "type": "ByStateVersion"
    },
    "target": {
      "type": "Method"
    },
    "arguments": [
      "string"
    ]
  }'

const response = await fetch('https://xrd.nownodes.io/core/transaction/call-preview', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "at_ledger_state": {
        "type": "ByStateVersion"
      },
      "target": {
        "type": "Method"
      },
      "arguments": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/call-preview')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "at_ledger_state": {
      "type": "ByStateVersion"
    },
    "target": {
      "type": "Method"
    },
    "arguments": [
      "string"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "at_ledger_state": {
    "type": "ByStateVersion"
  },
  "target": {
    "type": "Method"
  },
  "arguments": [
    "string"
  ]
}

response = requests.post('https://xrd.nownodes.io/core/transaction/call-preview', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/transaction/call-preview', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "at_ledger_state": {
        "type": "ByStateVersion"
      },
      "target": {
        "type": "Method"
      },
      "arguments": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/transaction/call-preview";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "at_ledger_state": {
      "type": "ByStateVersion"
    },
    "target": {
      "type": "Method"
    },
    "arguments": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/transaction/call-preview', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "at_ledger_state": {
        "type": "ByStateVersion"
      },
      "target": {
        "type": "Method"
      },
      "arguments": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "at_ledger_state": {
    "type": "ByStateVersion"
  },
  "target": {
    "type": "Method"
  },
  "arguments": [
    "string"
  ]
}

response = requests.post('https://xrd.nownodes.io/core/transaction/call-preview', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/call-preview')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "at_ledger_state": {
      "type": "ByStateVersion"
    },
    "target": {
      "type": "Method"
    },
    "arguments": [
      "string"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "target": {
    "type": "method",
    "component_address": "component_loc1qftacppvmr9ezmekxqpq58en0nk954x0a7jv2zz0hc7qfxlgx4",
    "method_name": "lock_fee"
  },
  "arguments": [
    "a120000000000010632d5ec66b050000000000000000000000000000000000000000000000"
  ]
}

{
  "target": {
    "type": "function",
    "package_address": "package_loc1q9ufgsc8yh5fkv8kzny3vnp68gkmuytc004k0j8dkwvs0xq76q",
    "blueprint_name": "GumballMachine",
    "function_name": "instantiate_gumball_machine"
  },
  "arguments": [
    "a120000000000010632d5ec66b050000000000000000000000000000000000000000000000"
  ]
}

{
  "at_ledger_state": {
    "state_version": 1,
    "header_summary": {
      "epoch_round": {
        "epoch": 0,
        "round": 0
      },
      "ledger_hashes": {
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "proposer_timestamp": {
        "unix_timestamp_ms": 0,
        "date_time": "string"
      }
    }
  },
  "status": "Succeeded",
  "output": {
    "hex": "string"
  },
  "error_message": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Transaction Preview

POST

https://xrd.nownodes.io/core/transaction/preview

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

at_ledger_stateLedgerStateSelector

Show child attributes

typeLedgerStateSelectorTypeByStateVersionrequired

manifeststringrequired

A text-representation of a transaction manifest

blobs_hexArray<string>

An array of hex-encoded blob data (optional)

start_epoch_inclusiveinteger<int64>[0, 10000000000]required

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

end_epoch_exclusiveinteger<int64>[0, 10000000000]required

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

notary_public_keyPublicKey

The notary public key to use (optional)

Show child attributes

key_typePublicKeyTypeEcdsaSecp256k1EddsaEd25519required

notary_is_signatoryboolean

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

tip_percentageinteger<int32>[0, 65535]required

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

nonceinteger<int64>[0, 4294967295]required

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).

signer_public_keysArray<PublicKey>required

A list of public keys to be used as transaction signers

Show child attributes

key_typePublicKeyTypeEcdsaSecp256k1EddsaEd25519required

messageTransactionMessage

An optional transaction message. Only affects the costing.

Show child attributes

typeTransactionMessageTypePlaintextEncryptedrequired

flagsobjectrequired

Show child attributes

use_free_creditbooleanrequired

assume_all_signature_proofsbooleanrequired

skip_epoch_checkbooleanrequired

disable_auth_checksboolean

Can be used to skip performing auth checks during runtime.

This could be used to e.g.:

Preview protocol update style transactions
Mint resources for previewing trades with resources you don't own. If doing this, be warned:
- Only resources which were potentially mintable/burnable at creation time will be mintable/burnable, due to feature flags on the resource.
- Please see the below warning about unexpected results if using this approach.

Please be warned - this mode of operation is quite a departure from normal operation:

Calculated fees will likely be lower than a standard execution
This mode can subtly break invariants some dApp code might rely on, or result in unexpected behaviour, so the resulting execution result might not be valid for your needs. For example, if I used this flag to mint pool units to preview a redemption (or some dApp interaction which behind the scenes redeemed them), they'd redeem for less than they're currently worth, because the blueprint code relies on the total supply of the pool units to calculate their redemption worth, and you've just inflated the total supply through the mint operation.

Response

200OK

Transaction preview response

400Bad Request

Client error

500Internal Server Error

Server error

Transaction Preview

curl -X POST 'https://xrd.nownodes.io/core/transaction/preview' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "at_ledger_state": {
      "type": "ByStateVersion"
    },
    "manifest": "string",
    "blobs_hex": [
      "string"
    ],
    "start_epoch_inclusive": 0,
    "end_epoch_exclusive": 0,
    "notary_public_key": {
      "key_type": "EcdsaSecp256k1"
    },
    "notary_is_signatory": true,
    "tip_percentage": 0,
    "nonce": 0,
    "signer_public_keys": [
      {
        "key_type": "EcdsaSecp256k1"
      }
    ],
    "message": {
      "type": "Plaintext"
    },
    "flags": {
      "use_free_credit": true,
      "assume_all_signature_proofs": true,
      "skip_epoch_check": true,
      "disable_auth_checks": true
    }
  }'

const response = await fetch('https://xrd.nownodes.io/core/transaction/preview', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "at_ledger_state": {
        "type": "ByStateVersion"
      },
      "manifest": "string",
      "blobs_hex": [
        "string"
      ],
      "start_epoch_inclusive": 0,
      "end_epoch_exclusive": 0,
      "notary_public_key": {
        "key_type": "EcdsaSecp256k1"
      },
      "notary_is_signatory": true,
      "tip_percentage": 0,
      "nonce": 0,
      "signer_public_keys": [
        {
          "key_type": "EcdsaSecp256k1"
        }
      ],
      "message": {
        "type": "Plaintext"
      },
      "flags": {
        "use_free_credit": true,
        "assume_all_signature_proofs": true,
        "skip_epoch_check": true,
        "disable_auth_checks": true
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/preview')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "at_ledger_state": {
      "type": "ByStateVersion"
    },
    "manifest": "string",
    "blobs_hex": [
      "string"
    ],
    "start_epoch_inclusive": 0,
    "end_epoch_exclusive": 0,
    "notary_public_key": {
      "key_type": "EcdsaSecp256k1"
    },
    "notary_is_signatory": true,
    "tip_percentage": 0,
    "nonce": 0,
    "signer_public_keys": [
      {
        "key_type": "EcdsaSecp256k1"
      }
    ],
    "message": {
      "type": "Plaintext"
    },
    "flags": {
      "use_free_credit": true,
      "assume_all_signature_proofs": true,
      "skip_epoch_check": true,
      "disable_auth_checks": true
    }
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "at_ledger_state": {
    "type": "ByStateVersion"
  },
  "manifest": "string",
  "blobs_hex": [
    "string"
  ],
  "start_epoch_inclusive": 0,
  "end_epoch_exclusive": 0,
  "notary_public_key": {
    "key_type": "EcdsaSecp256k1"
  },
  "notary_is_signatory": True,
  "tip_percentage": 0,
  "nonce": 0,
  "signer_public_keys": [
    {
      "key_type": "EcdsaSecp256k1"
    }
  ],
  "message": {
    "type": "Plaintext"
  },
  "flags": {
    "use_free_credit": True,
    "assume_all_signature_proofs": True,
    "skip_epoch_check": True,
    "disable_auth_checks": True
  }
}

response = requests.post('https://xrd.nownodes.io/core/transaction/preview', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/transaction/preview', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "at_ledger_state": {
        "type": "ByStateVersion"
      },
      "manifest": "string",
      "blobs_hex": [
        "string"
      ],
      "start_epoch_inclusive": 0,
      "end_epoch_exclusive": 0,
      "notary_public_key": {
        "key_type": "EcdsaSecp256k1"
      },
      "notary_is_signatory": true,
      "tip_percentage": 0,
      "nonce": 0,
      "signer_public_keys": [
        {
          "key_type": "EcdsaSecp256k1"
        }
      ],
      "message": {
        "type": "Plaintext"
      },
      "flags": {
        "use_free_credit": true,
        "assume_all_signature_proofs": true,
        "skip_epoch_check": true,
        "disable_auth_checks": true
      }
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/transaction/preview";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "at_ledger_state": {
      "type": "ByStateVersion"
    },
    "manifest": "string",
    "blobs_hex": [
      "string"
    ],
    "start_epoch_inclusive": 0,
    "end_epoch_exclusive": 0,
    "notary_public_key": {
      "key_type": "EcdsaSecp256k1"
    },
    "notary_is_signatory": true,
    "tip_percentage": 0,
    "nonce": 0,
    "signer_public_keys": [
      {
        "key_type": "EcdsaSecp256k1"
      }
    ],
    "message": {
      "type": "Plaintext"
    },
    "flags": {
      "use_free_credit": true,
      "assume_all_signature_proofs": true,
      "skip_epoch_check": true,
      "disable_auth_checks": true
    }
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/transaction/preview', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "at_ledger_state": {
        "type": "ByStateVersion"
      },
      "manifest": "string",
      "blobs_hex": [
        "string"
      ],
      "start_epoch_inclusive": 0,
      "end_epoch_exclusive": 0,
      "notary_public_key": {
        "key_type": "EcdsaSecp256k1"
      },
      "notary_is_signatory": true,
      "tip_percentage": 0,
      "nonce": 0,
      "signer_public_keys": [
        {
          "key_type": "EcdsaSecp256k1"
        }
      ],
      "message": {
        "type": "Plaintext"
      },
      "flags": {
        "use_free_credit": true,
        "assume_all_signature_proofs": true,
        "skip_epoch_check": true,
        "disable_auth_checks": true
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "at_ledger_state": {
    "type": "ByStateVersion"
  },
  "manifest": "string",
  "blobs_hex": [
    "string"
  ],
  "start_epoch_inclusive": 0,
  "end_epoch_exclusive": 0,
  "notary_public_key": {
    "key_type": "EcdsaSecp256k1"
  },
  "notary_is_signatory": True,
  "tip_percentage": 0,
  "nonce": 0,
  "signer_public_keys": [
    {
      "key_type": "EcdsaSecp256k1"
    }
  ],
  "message": {
    "type": "Plaintext"
  },
  "flags": {
    "use_free_credit": True,
    "assume_all_signature_proofs": True,
    "skip_epoch_check": True,
    "disable_auth_checks": True
  }
}

response = requests.post('https://xrd.nownodes.io/core/transaction/preview', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/transaction/preview')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "at_ledger_state": {
      "type": "ByStateVersion"
    },
    "manifest": "string",
    "blobs_hex": [
      "string"
    ],
    "start_epoch_inclusive": 0,
    "end_epoch_exclusive": 0,
    "notary_public_key": {
      "key_type": "EcdsaSecp256k1"
    },
    "notary_is_signatory": true,
    "tip_percentage": 0,
    "nonce": 0,
    "signer_public_keys": [
      {
        "key_type": "EcdsaSecp256k1"
      }
    ],
    "message": {
      "type": "Plaintext"
    },
    "flags": {
      "use_free_credit": true,
      "assume_all_signature_proofs": true,
      "skip_epoch_check": true,
      "disable_auth_checks": true
    }
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "at_ledger_state": {
    "type": "ByStateVersion"
  },
  "manifest": "string",
  "blobs_hex": [
    "string"
  ],
  "start_epoch_inclusive": 0,
  "end_epoch_exclusive": 0,
  "notary_public_key": {
    "key_type": "EcdsaSecp256k1"
  },
  "notary_is_signatory": true,
  "tip_percentage": 0,
  "nonce": 0,
  "signer_public_keys": [
    {
      "key_type": "EcdsaSecp256k1"
    }
  ],
  "message": {
    "type": "Plaintext"
  },
  "flags": {
    "use_free_credit": true,
    "assume_all_signature_proofs": true,
    "skip_epoch_check": true,
    "disable_auth_checks": true
  }
}

{
  "at_ledger_state": {
    "state_version": 1,
    "header_summary": {
      "epoch_round": {
        "epoch": 0,
        "round": 0
      },
      "ledger_hashes": {
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "proposer_timestamp": {
        "unix_timestamp_ms": 0,
        "date_time": "string"
      }
    }
  },
  "encoded_receipt": "string",
  "receipt": {
    "status": "Succeeded",
    "fee_summary": {
      "execution_cost_units_consumed": 0,
      "finalization_cost_units_consumed": 0,
      "xrd_total_execution_cost": "string",
      "xrd_total_finalization_cost": "string",
      "xrd_total_royalty_cost": "string",
      "xrd_total_storage_cost": "string",
      "xrd_total_tipping_cost": "string"
    },
    "costing_parameters": {
      "execution_cost_unit_price": "string",
      "execution_cost_unit_limit": 0,
      "execution_cost_unit_loan": 0,
      "finalization_cost_unit_price": "string",
      "finalization_cost_unit_limit": 0,
      "xrd_usd_price": "string",
      "xrd_storage_price": "string",
      "xrd_archive_storage_price": "string",
      "tip_percentage": 0
    },
    "fee_source": {
      "from_vaults": [
        {
          "vault_entity": {
            "entity_type": "GlobalPackage",
            "is_global": true,
            "entity_address": "string"
          },
          "xrd_amount": "string"
        }
      ]
    },
    "fee_destination": {
      "to_proposer": "string",
      "to_validator_set": "string",
      "to_burn": "string",
      "to_royalty_recipients": [
        {
          "royalty_recipient": {
            "entity_type": "GlobalPackage",
            "is_global": true,
            "entity_address": "string"
          },
          "xrd_amount": "string"
        }
      ]
    },
    "state_updates": {
      "deleted_partitions": [
        {
          "entity_type": "GlobalPackage",
          "entity_address": "string",
          "entity_module": "TypeInfo",
          "partition_kind": "Field",
          "partition_number": 0
        }
      ],
      "created_substates": [
        {
          "substate_id": {
            "entity_type": "GlobalPackage",
            "entity_address": "string",
            "entity_module": "TypeInfo",
            "partition_kind": "Field",
            "partition_number": 0,
            "substate_type": "BootLoaderModuleFieldVmBoot",
            "substate_key": {
              "key_type": "Field",
              "db_sort_key_hex": "string"
            }
          },
          "value": {
            "substate_hex": "string",
            "substate_data_hash": "string",
            "substate_data": {
              "substate_type": "BootLoaderModuleFieldVmBoot",
              "is_locked": true
            }
          },
          "system_structure": {
            "type": "SystemField"
          }
        }
      ],
      "updated_substates": [
        {
          "substate_id": {
            "entity_type": "GlobalPackage",
            "entity_address": "string",
            "entity_module": "TypeInfo",
            "partition_kind": "Field",
            "partition_number": 0,
            "substate_type": "BootLoaderModuleFieldVmBoot",
            "substate_key": {
              "key_type": "Field",
              "db_sort_key_hex": "string"
            }
          },
          "new_value": {
            "substate_hex": "string",
            "substate_data_hash": "string",
            "substate_data": {
              "substate_type": "BootLoaderModuleFieldVmBoot",
              "is_locked": true
            }
          },
          "previous_value": {
            "substate_hex": "string",
            "substate_data_hash": "string",
            "substate_data": {
              "substate_type": "BootLoaderModuleFieldVmBoot",
              "is_locked": true
            }
          },
          "system_structure": {
            "type": "SystemField"
          }
        }
      ],
      "deleted_substates": [
        {
          "substate_id": {
            "entity_type": "GlobalPackage",
            "entity_address": "string",
            "entity_module": "TypeInfo",
            "partition_kind": "Field",
            "partition_number": 0,
            "substate_type": "BootLoaderModuleFieldVmBoot",
            "substate_key": {
              "key_type": "Field",
              "db_sort_key_hex": "string"
            }
          },
          "previous_value": {
            "substate_hex": "string",
            "substate_data_hash": "string",
            "substate_data": {
              "substate_type": "BootLoaderModuleFieldVmBoot",
              "is_locked": true
            }
          },
          "system_structure": {
            "type": "SystemField"
          }
        }
      ],
      "new_global_entities": [
        {
          "entity_type": "GlobalPackage",
          "is_global": true,
          "entity_address": "string"
        }
      ]
    },
    "events": [
      {
        "type": {
          "emitter": {
            "type": "Function"
          },
          "type_reference": {
            "full_type_id": {
              "entity_address": "string",
              "schema_hash": "string",
              "local_type_id": {
                "kind": "WellKnown",
                "id": 0,
                "as_sbor": {
                  "hex": "string"
                }
              }
            }
          },
          "name": "string"
        },
        "data": {
          "hex": "string"
        }
      }
    ],
    "next_epoch": {
      "epoch": 0,
      "validators": [
        {
          "address": "string",
          "key": {
            "key_type": "EcdsaSecp256k1",
            "key_hex": "string"
          },
          "stake": "string"
        }
      ],
      "significant_protocol_update_readiness": [
        {
          "readiness_signal_name": "string",
          "signalled_stake": "string"
        }
      ]
    },
    "output": [
      {
        "hex": "string"
      }
    ],
    "error_message": "string"
  },
  "instruction_resource_changes": [
    {
      "index": 0,
      "resource_changes": [
        {
          "resource_address": "string",
          "component_entity": {
            "entity_type": "GlobalPackage",
            "is_global": true,
            "entity_address": "string"
          },
          "vault_entity": {
            "entity_type": "GlobalPackage",
            "is_global": true,
            "entity_address": "string"
          },
          "amount": "string"
        }
      ]
    }
  ],
  "logs": [
    {
      "level": "string",
      "message": "string"
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Mempool

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

Get Mempool List

POST

https://xrd.nownodes.io/core/mempool/list

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the hashes of all the transactions currently in the mempool

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

Response

200OK

Mempool List Response

500Internal Server Error

Server error

Get Mempool List

curl -X POST 'https://xrd.nownodes.io/core/mempool/list' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}"
  }'

const response = await fetch('https://xrd.nownodes.io/core/mempool/list', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/mempool/list')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}"
}

response = requests.post('https://xrd.nownodes.io/core/mempool/list', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/mempool/list', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/mempool/list";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/mempool/list', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}"
}

response = requests.post('https://xrd.nownodes.io/core/mempool/list', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/mempool/list')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}"
}

{
  "contents": [
    {
      "intent_hash": "string",
      "intent_hash_bech32m": "string",
      "payload_hash": "string",
      "payload_hash_bech32m": "string"
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Mempool Transaction

POST

https://xrd.nownodes.io/core/mempool/transaction

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the payload of a transaction currently in the mempool

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

payload_hashesArray<NotarizedTransactionHashInput>required

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

Response

200OK

Mempool Transaction Response

404Not Found

Not found error

500Internal Server Error

Server error

Get Mempool Transaction

curl -X POST 'https://xrd.nownodes.io/core/mempool/transaction' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "payload_hashes": [
      "string"
    ]
  }'

const response = await fetch('https://xrd.nownodes.io/core/mempool/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "payload_hashes": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/mempool/transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "payload_hashes": [
      "string"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "payload_hashes": [
    "string"
  ]
}

response = requests.post('https://xrd.nownodes.io/core/mempool/transaction', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/mempool/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "payload_hashes": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/mempool/transaction";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "payload_hashes": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/mempool/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "payload_hashes": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "payload_hashes": [
    "string"
  ]
}

response = requests.post('https://xrd.nownodes.io/core/mempool/transaction', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/mempool/transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "payload_hashes": [
      "string"
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "payload_hashes": [
    "string"
  ]
}

{
  "count": 0,
  "payloads": [
    {
      "hash": "string",
      "hash_bech32m": "string",
      "hex": "string",
      "error": "string"
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

State

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

POST

https://xrd.nownodes.io/core/state/consensus-manager

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

include_readiness_signalsboolean

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

Response

200OK

Current state response

400Bad Request

Client error

500Internal Server Error

Server error

Get Consensus Manager Details

curl -X POST 'https://xrd.nownodes.io/core/state/consensus-manager' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "include_readiness_signals": true
  }'

const response = await fetch('https://xrd.nownodes.io/core/state/consensus-manager', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "include_readiness_signals": true
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/consensus-manager')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "include_readiness_signals": true
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "include_readiness_signals": True
}

response = requests.post('https://xrd.nownodes.io/core/state/consensus-manager', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/state/consensus-manager', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "include_readiness_signals": true
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/state/consensus-manager";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "include_readiness_signals": true
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/state/consensus-manager', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "include_readiness_signals": true
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "include_readiness_signals": True
}

response = requests.post('https://xrd.nownodes.io/core/state/consensus-manager', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/consensus-manager')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "include_readiness_signals": true
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "include_readiness_signals": true
}

{
  "at_ledger_state": {
    "state_version": 1,
    "header_summary": {
      "epoch_round": {
        "epoch": 0,
        "round": 0
      },
      "ledger_hashes": {
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "proposer_timestamp": {
        "unix_timestamp_ms": 0,
        "date_time": "string"
      }
    }
  },
  "config": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "state": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "current_proposal_statistic": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "current_validator_set": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "current_time": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "current_time_rounded_to_minutes": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "current_validator_readiness_signals": [
    {
      "signalled_protocol_version": "string",
      "total_active_stake_proportion": "string",
      "signalling_validators": [
        {
          "index": {
            "index": 0
          },
          "active_stake_proportion": "string"
        }
      ]
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Account Details

POST

https://xrd.nownodes.io/core/state/account

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

account_addressstringrequired

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

Response

200OK

Current state response

400Bad Request

Client error

404Not Found

Not found error

500Internal Server Error

Server error

Get Account Details

curl -X POST 'https://xrd.nownodes.io/core/state/account' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "account_address": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/state/account', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/account')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "account_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "account_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/account', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/state/account', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/state/account";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "account_address": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/state/account', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "account_address": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "account_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/account', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/account')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "account_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "account_address": "string"
}

{
  "at_ledger_state": {
    "state_version": 1,
    "header_summary": {
      "epoch_round": {
        "epoch": 0,
        "round": 0
      },
      "ledger_hashes": {
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "proposer_timestamp": {
        "unix_timestamp_ms": 0,
        "date_time": "string"
      }
    }
  },
  "info": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "owner_role": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "state": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "vaults": [
    {
      "vault_entity": {
        "entity_type": "GlobalPackage",
        "is_global": true,
        "entity_address": "string"
      },
      "resource_amount": {
        "resource_type": "Fungible",
        "resource_address": "string"
      }
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Component Details

POST

https://xrd.nownodes.io/core/state/component

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

component_addressstringrequired

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

Response

200OK

Current state response

400Bad Request

Client error

404Not Found

Not found error

500Internal Server Error

Server error

Get Component Details

curl -X POST 'https://xrd.nownodes.io/core/state/component' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "component_address": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/state/component', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "component_address": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/component')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "component_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "component_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/component', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/state/component', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "component_address": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/state/component";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "component_address": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/state/component', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "component_address": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "component_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/component', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/component')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "component_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "component_address": "string"
}

{
  "at_ledger_state": {
    "state_version": 1,
    "header_summary": {
      "epoch_round": {
        "epoch": 0,
        "round": 0
      },
      "ledger_hashes": {
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "proposer_timestamp": {
        "unix_timestamp_ms": 0,
        "date_time": "string"
      }
    }
  },
  "info": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "state": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "royalty_accumulator": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "owner_role": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "vaults": [
    {
      "vault_entity": {
        "entity_type": "GlobalPackage",
        "is_global": true,
        "entity_address": "string"
      },
      "resource_amount": {
        "resource_type": "Fungible",
        "resource_address": "string"
      }
    }
  ],
  "descendent_nodes": [
    {
      "parent_entity": {
        "entity_type": "GlobalPackage",
        "is_global": true,
        "entity_address": "string"
      },
      "parent_partition_number": 0,
      "parent_substate_key_hex": "string",
      "parent_substate_db_sort_key_hex": "string",
      "entity": {
        "entity_type": "GlobalPackage",
        "is_global": true,
        "entity_address": "string"
      },
      "depth": 0
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Validator Details

POST

https://xrd.nownodes.io/core/state/validator

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

validator_addressComponentAddressrequired

The Bech32m-encoded human readable version of the component address

Response

200OK

Current state response

400Bad Request

Client error

404Not Found

Not found error

500Internal Server Error

Server error

Get Validator Details

curl -X POST 'https://xrd.nownodes.io/core/state/validator' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "validator_address": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/state/validator', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "validator_address": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/validator')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "validator_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "validator_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/validator', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/state/validator', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "validator_address": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/state/validator";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "validator_address": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/state/validator', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "validator_address": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "validator_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/validator', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/validator')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "validator_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "validator_address": "string"
}

{
  "at_ledger_state": {
    "state_version": 1,
    "header_summary": {
      "epoch_round": {
        "epoch": 0,
        "round": 0
      },
      "ledger_hashes": {
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "proposer_timestamp": {
        "unix_timestamp_ms": 0,
        "date_time": "string"
      }
    }
  },
  "address": "string",
  "state": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "protocol_update_readiness_signal": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "owner_role": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "vaults": [
    {
      "vault_entity": {
        "entity_type": "GlobalPackage",
        "is_global": true,
        "entity_address": "string"
      },
      "resource_amount": {
        "resource_type": "Fungible",
        "resource_address": "string"
      }
    }
  ],
  "descendent_nodes": [
    {
      "parent_entity": {
        "entity_type": "GlobalPackage",
        "is_global": true,
        "entity_address": "string"
      },
      "parent_partition_number": 0,
      "parent_substate_key_hex": "string",
      "parent_substate_db_sort_key_hex": "string",
      "entity": {
        "entity_type": "GlobalPackage",
        "is_global": true,
        "entity_address": "string"
      },
      "depth": 0
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Access Controller Details

POST

https://xrd.nownodes.io/core/state/access-controller

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

controller_addressComponentAddressrequired

The Bech32m-encoded human readable version of the component address

Response

200OK

Current state response

400Bad Request

Client error

404Not Found

Not found error

500Internal Server Error

Server error

Get Access Controller Details

curl -X POST 'https://xrd.nownodes.io/core/state/access-controller' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "controller_address": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/state/access-controller', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "controller_address": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/access-controller')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "controller_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "controller_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/access-controller', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/state/access-controller', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "controller_address": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/state/access-controller";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "controller_address": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/state/access-controller', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "controller_address": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "controller_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/access-controller', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/access-controller')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "controller_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "controller_address": "string"
}

{
  "at_ledger_state": {
    "state_version": 1,
    "header_summary": {
      "epoch_round": {
        "epoch": 0,
        "round": 0
      },
      "ledger_hashes": {
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "proposer_timestamp": {
        "unix_timestamp_ms": 0,
        "date_time": "string"
      }
    }
  },
  "state": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "owner_role": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "vaults": [
    {
      "vault_entity": {
        "entity_type": "GlobalPackage",
        "is_global": true,
        "entity_address": "string"
      },
      "resource_amount": {
        "resource_type": "Fungible",
        "resource_address": "string"
      }
    }
  ],
  "descendent_nodes": [
    {
      "parent_entity": {
        "entity_type": "GlobalPackage",
        "is_global": true,
        "entity_address": "string"
      },
      "parent_partition_number": 0,
      "parent_substate_key_hex": "string",
      "parent_substate_db_sort_key_hex": "string",
      "entity": {
        "entity_type": "GlobalPackage",
        "is_global": true,
        "entity_address": "string"
      },
      "depth": 0
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Resource Details

POST

https://xrd.nownodes.io/core/state/resource

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

resource_addressstringrequired

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

Response

200OK

Current state response

400Bad Request

Client error

404Not Found

Not found error

500Internal Server Error

Server error

Get Resource Details

curl -X POST 'https://xrd.nownodes.io/core/state/resource' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "resource_address": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/state/resource', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "resource_address": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/resource')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "resource_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "resource_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/resource', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/state/resource', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "resource_address": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/state/resource";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "resource_address": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/state/resource', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "resource_address": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "resource_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/resource', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/resource')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "resource_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "resource_address": "string"
}

{
  "at_ledger_state": {
    "state_version": 1,
    "header_summary": {
      "epoch_round": {
        "epoch": 0,
        "round": 0
      },
      "ledger_hashes": {
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "proposer_timestamp": {
        "unix_timestamp_ms": 0,
        "date_time": "string"
      }
    }
  },
  "manager": {
    "resource_type": "Fungible"
  },
  "owner_role": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Non-Fungible Details

POST

https://xrd.nownodes.io/core/state/non-fungible

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

resource_addressstringrequired

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

non_fungible_idNonFungibleLocalIdSimpleRepresentationrequired

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.

Response

200OK

Current state response

400Bad Request

Client error

404Not Found

Not found error

500Internal Server Error

Server error

Get Non-Fungible Details

curl -X POST 'https://xrd.nownodes.io/core/state/non-fungible' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "resource_address": "string",
    "non_fungible_id": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/state/non-fungible', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "resource_address": "string",
      "non_fungible_id": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/non-fungible')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "resource_address": "string",
    "non_fungible_id": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "resource_address": "string",
  "non_fungible_id": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/non-fungible', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/state/non-fungible', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "resource_address": "string",
      "non_fungible_id": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/state/non-fungible";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "resource_address": "string",
    "non_fungible_id": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/state/non-fungible', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "resource_address": "string",
      "non_fungible_id": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "resource_address": "string",
  "non_fungible_id": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/non-fungible', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/non-fungible')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "resource_address": "string",
    "non_fungible_id": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "resource_address": "string",
  "non_fungible_id": "string"
}

{
  "at_ledger_state": {
    "state_version": 1,
    "header_summary": {
      "epoch_round": {
        "epoch": 0,
        "round": 0
      },
      "ledger_hashes": {
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "proposer_timestamp": {
        "unix_timestamp_ms": 0,
        "date_time": "string"
      }
    }
  },
  "non_fungible": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Get Package Details

POST

https://xrd.nownodes.io/core/state/package

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Body

application/json

networkNetworkIdentifierrequired

The logical name of the network

package_addressstringrequired

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

Response

200OK

Current state response

400Bad Request

Client error

404Not Found

Not found error

500Internal Server Error

Server error

Get Package Details

curl -X POST 'https://xrd.nownodes.io/core/state/package' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "package_address": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/state/package', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "package_address": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/package')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "package_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "package_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/package', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/state/package', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "package_address": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/state/package";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "package_address": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/state/package', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "package_address": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "package_address": "string"
}

response = requests.post('https://xrd.nownodes.io/core/state/package', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/state/package')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "package_address": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "package_address": "string"
}

{
  "at_ledger_state": {
    "state_version": 1,
    "header_summary": {
      "epoch_round": {
        "epoch": 0,
        "round": 0
      },
      "ledger_hashes": {
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "proposer_timestamp": {
        "unix_timestamp_ms": 0,
        "date_time": "string"
      }
    }
  },
  "owner_role": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  },
  "royalty": {
    "substate_type": "BootLoaderModuleFieldVmBoot",
    "is_locked": true
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string"
}

Stream

To query the transaction or proof stream of the ledger.

Stream Proofs

POST

https://xrd.nownodes.io/core/stream/proofs

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

Body

application/json

A request to retrieve a sublist of proofs.

networkNetworkIdentifierrequired

The logical name of the network

filterStreamProofsFilter

If not provided, defaults to "Any".

Show child attributes

typeStreamProofsFilterTypeAnyNewEpochsProtocolUpdateInitializationsProtocolUpdateExecutionrequired

max_page_sizeinteger

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

continuation_tokenContinuationToken

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.

Response

200OK

Stream proofs response

400Bad Request

Client error

500Internal Server Error

Server error

Stream Proofs

curl -X POST 'https://xrd.nownodes.io/core/stream/proofs' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "filter": {
      "type": "Any"
    },
    "max_page_size": 0,
    "continuation_token": "string"
  }'

const response = await fetch('https://xrd.nownodes.io/core/stream/proofs', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "filter": {
        "type": "Any"
      },
      "max_page_size": 0,
      "continuation_token": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/stream/proofs')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "filter": {
      "type": "Any"
    },
    "max_page_size": 0,
    "continuation_token": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "filter": {
    "type": "Any"
  },
  "max_page_size": 0,
  "continuation_token": "string"
}

response = requests.post('https://xrd.nownodes.io/core/stream/proofs', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/stream/proofs', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "filter": {
        "type": "Any"
      },
      "max_page_size": 0,
      "continuation_token": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/stream/proofs";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "filter": {
      "type": "Any"
    },
    "max_page_size": 0,
    "continuation_token": "string"
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/stream/proofs', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "filter": {
        "type": "Any"
      },
      "max_page_size": 0,
      "continuation_token": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "filter": {
    "type": "Any"
  },
  "max_page_size": 0,
  "continuation_token": "string"
}

response = requests.post('https://xrd.nownodes.io/core/stream/proofs', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/stream/proofs')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "filter": {
      "type": "Any"
    },
    "max_page_size": 0,
    "continuation_token": "string"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "filter": {
    "type": "Any"
  },
  "max_page_size": 0,
  "continuation_token": "string"
}

{
  "page": [
    {
      "ledger_header": {
        "epoch": 0,
        "round": 0,
        "state_version": 1,
        "hashes": {
          "state_tree_hash": "string",
          "transaction_tree_hash": "string",
          "receipt_tree_hash": "string"
        },
        "consensus_parent_round_timestamp_ms": 0,
        "proposer_timestamp_ms": 0,
        "next_epoch": {
          "epoch": 0,
          "validators": [
            {
              "address": "string",
              "key": {
                "key_type": "EcdsaSecp256k1",
                "key_hex": "string"
              },
              "stake": "string"
            }
          ],
          "significant_protocol_update_readiness": [
            {
              "readiness_signal_name": "string",
              "signalled_stake": "string"
            }
          ]
        },
        "next_protocol_version": "string"
      },
      "origin": {
        "type": "Genesis"
      }
    }
  ],
  "continuation_token": "string"
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string",
  "details": {
    "type": "RequestedStateVersionOutOfBounds"
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string",
  "details": {
    "type": "RequestedStateVersionOutOfBounds"
  }
}

Get Committed Transactions

POST

https://xrd.nownodes.io/core/stream/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the list of committed transactions.

Body

application/json

A request to retrieve a sublist of committed transactions from the ledger.

networkNetworkIdentifierrequired

The logical name of the network

from_state_versionStateVersion<int64>[1, 100000000000000]required

The first (resultant) state version to be returned

limitintegerrequired

The maximum number of transactions that will be returned.

sbor_format_optionsSborFormatOptions

Requested SBOR formats to include in the response

Show child attributes

rawboolean

Whether to return the raw hex-encoded bytes (default true)

programmatic_jsonboolean

Whether to return the programmatic json format (normally default true, defaults false for streamed transactions)

transaction_format_optionsTransactionFormatOptions

Requested transaction formats to include in the response

Show child attributes

manifestboolean

Whether to return the raw manifest (default true)

blobsboolean

Whether to return the hex-encoded blobs (default false)

messageboolean

Whether to return the transaction message (default true)

balance_changesboolean

Whether to return the transaction balance changes (default false)

raw_system_transactionboolean

Whether to return the raw hex-encoded system transaction bytes (default false)

raw_notarized_transactionboolean

Whether to return the raw hex-encoded notarized transaction bytes (default true)

raw_ledger_transactionboolean

Whether to return the raw hex-encoded ledger transaction bytes (default false)

substate_format_optionsSubstateFormatOptions

Requested substate formats to include in the response

Show child attributes

rawboolean

Whether to return the raw substate value bytes (default false)

hashboolean

Whether to return the raw substate value bytes hash (default false)

typedboolean

Whether to return the typed substate information (default true)

previousboolean

Whether to return the previous substate value for updates and deletes (default false)

include_proofsboolean

Whether to include LedgerProofs (default false)

Response

200OK

Committed transactions response

400Bad Request

Client error

500Internal Server Error

Server error

Get Committed Transactions

curl -X POST 'https://xrd.nownodes.io/core/stream/transactions' \
  -H 'Content-Type: application/json' \
  -d '{
    "network": "{{network}}",
    "from_state_version": 1,
    "limit": 0,
    "sbor_format_options": {
      "raw": true,
      "programmatic_json": true
    },
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    },
    "substate_format_options": {
      "raw": true,
      "hash": true,
      "typed": true,
      "previous": true
    },
    "include_proofs": true
  }'

const response = await fetch('https://xrd.nownodes.io/core/stream/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "from_state_version": 1,
      "limit": 0,
      "sbor_format_options": {
        "raw": true,
        "programmatic_json": true
      },
      "transaction_format_options": {
        "manifest": true,
        "blobs": true,
        "message": true,
        "balance_changes": true,
        "raw_system_transaction": true,
        "raw_notarized_transaction": true,
        "raw_ledger_transaction": true
      },
      "substate_format_options": {
        "raw": true,
        "hash": true,
        "typed": true,
        "previous": true
      },
      "include_proofs": true
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/stream/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "from_state_version": 1,
    "limit": 0,
    "sbor_format_options": {
      "raw": true,
      "programmatic_json": true
    },
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    },
    "substate_format_options": {
      "raw": true,
      "hash": true,
      "typed": true,
      "previous": true
    },
    "include_proofs": true
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "network": "{{network}}",
  "from_state_version": 1,
  "limit": 0,
  "sbor_format_options": {
    "raw": True,
    "programmatic_json": True
  },
  "transaction_format_options": {
    "manifest": True,
    "blobs": True,
    "message": True,
    "balance_changes": True,
    "raw_system_transaction": True,
    "raw_notarized_transaction": True,
    "raw_ledger_transaction": True
  },
  "substate_format_options": {
    "raw": True,
    "hash": True,
    "typed": True,
    "previous": True
  },
  "include_proofs": True
}

response = requests.post('https://xrd.nownodes.io/core/stream/transactions', json=payload)
data = response.json()

const response = await fetch('https://xrd.nownodes.io/core/stream/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "from_state_version": 1,
      "limit": 0,
      "sbor_format_options": {
        "raw": true,
        "programmatic_json": true
      },
      "transaction_format_options": {
        "manifest": true,
        "blobs": true,
        "message": true,
        "balance_changes": true,
        "raw_system_transaction": true,
        "raw_notarized_transaction": true,
        "raw_ledger_transaction": true
      },
      "substate_format_options": {
        "raw": true,
        "hash": true,
        "typed": true,
        "previous": true
      },
      "include_proofs": true
    }),
});

const data = await response.json();

const endpoint = "https://xrd.nownodes.io/core/stream/transactions";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "network": "{{network}}",
    "from_state_version": 1,
    "limit": 0,
    "sbor_format_options": {
      "raw": true,
      "programmatic_json": true
    },
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    },
    "substate_format_options": {
      "raw": true,
      "hash": true,
      "typed": true,
      "previous": true
    },
    "include_proofs": true
  });
console.log(result);

const response = await fetch('https://xrd.nownodes.io/core/stream/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "network": "{{network}}",
      "from_state_version": 1,
      "limit": 0,
      "sbor_format_options": {
        "raw": true,
        "programmatic_json": true
      },
      "transaction_format_options": {
        "manifest": true,
        "blobs": true,
        "message": true,
        "balance_changes": true,
        "raw_system_transaction": true,
        "raw_notarized_transaction": true,
        "raw_ledger_transaction": true
      },
      "substate_format_options": {
        "raw": true,
        "hash": true,
        "typed": true,
        "previous": true
      },
      "include_proofs": true
    }),
});

const data = await response.json();

import requests

payload = {
  "network": "{{network}}",
  "from_state_version": 1,
  "limit": 0,
  "sbor_format_options": {
    "raw": True,
    "programmatic_json": True
  },
  "transaction_format_options": {
    "manifest": True,
    "blobs": True,
    "message": True,
    "balance_changes": True,
    "raw_system_transaction": True,
    "raw_notarized_transaction": True,
    "raw_ledger_transaction": True
  },
  "substate_format_options": {
    "raw": True,
    "hash": True,
    "typed": True,
    "previous": True
  },
  "include_proofs": True
}

response = requests.post('https://xrd.nownodes.io/core/stream/transactions', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd.nownodes.io/core/stream/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "network": "{{network}}",
    "from_state_version": 1,
    "limit": 0,
    "sbor_format_options": {
      "raw": true,
      "programmatic_json": true
    },
    "transaction_format_options": {
      "manifest": true,
      "blobs": true,
      "message": true,
      "balance_changes": true,
      "raw_system_transaction": true,
      "raw_notarized_transaction": true,
      "raw_ledger_transaction": true
    },
    "substate_format_options": {
      "raw": true,
      "hash": true,
      "typed": true,
      "previous": true
    },
    "include_proofs": true
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "network": "{{network}}",
  "from_state_version": 1,
  "limit": 0,
  "sbor_format_options": {
    "raw": true,
    "programmatic_json": true
  },
  "transaction_format_options": {
    "manifest": true,
    "blobs": true,
    "message": true,
    "balance_changes": true,
    "raw_system_transaction": true,
    "raw_notarized_transaction": true,
    "raw_ledger_transaction": true
  },
  "substate_format_options": {
    "raw": true,
    "hash": true,
    "typed": true,
    "previous": true
  },
  "include_proofs": true
}

{
  "previous_state_identifiers": {
    "state_version": 1,
    "state_tree_hash": "string",
    "transaction_tree_hash": "string",
    "receipt_tree_hash": "string"
  },
  "from_state_version": 1,
  "count": 0,
  "max_ledger_state_version": 1,
  "transactions": [
    {
      "resultant_state_identifiers": {
        "state_version": 1,
        "state_tree_hash": "string",
        "transaction_tree_hash": "string",
        "receipt_tree_hash": "string"
      },
      "ledger_transaction": {
        "type": "Genesis",
        "payload_hex": "string"
      },
      "receipt": {
        "status": "Succeeded",
        "fee_summary": {
          "execution_cost_units_consumed": 0,
          "finalization_cost_units_consumed": 0,
          "xrd_total_execution_cost": "string",
          "xrd_total_finalization_cost": "string",
          "xrd_total_royalty_cost": "string",
          "xrd_total_storage_cost": "string",
          "xrd_total_tipping_cost": "string"
        },
        "costing_parameters": {
          "execution_cost_unit_price": "string",
          "execution_cost_unit_limit": 0,
          "execution_cost_unit_loan": 0,
          "finalization_cost_unit_price": "string",
          "finalization_cost_unit_limit": 0,
          "xrd_usd_price": "string",
          "xrd_storage_price": "string",
          "xrd_archive_storage_price": "string",
          "tip_percentage": 0
        },
        "fee_source": {
          "from_vaults": [
            {
              "vault_entity": {
                "entity_type": "GlobalPackage",
                "is_global": true,
                "entity_address": "string"
              },
              "xrd_amount": "string"
            }
          ]
        },
        "fee_destination": {
          "to_proposer": "string",
          "to_validator_set": "string",
          "to_burn": "string",
          "to_royalty_recipients": [
            {
              "royalty_recipient": {
                "entity_type": "GlobalPackage",
                "is_global": true,
                "entity_address": "string"
              },
              "xrd_amount": "string"
            }
          ]
        },
        "state_updates": {
          "deleted_partitions": [
            {
              "entity_type": "GlobalPackage",
              "entity_address": "string",
              "entity_module": "TypeInfo",
              "partition_kind": "Field",
              "partition_number": 0
            }
          ],
          "created_substates": [
            {
              "substate_id": {
                "entity_type": "GlobalPackage",
                "entity_address": "string",
                "entity_module": "TypeInfo",
                "partition_kind": "Field",
                "partition_number": 0,
                "substate_type": "BootLoaderModuleFieldVmBoot",
                "substate_key": {
                  "key_type": "Field",
                  "db_sort_key_hex": "string"
                }
              },
              "value": {
                "substate_hex": "string",
                "substate_data_hash": "string",
                "substate_data": {
                  "substate_type": "BootLoaderModuleFieldVmBoot",
                  "is_locked": true
                }
              },
              "system_structure": {
                "type": "SystemField"
              }
            }
          ],
          "updated_substates": [
            {
              "substate_id": {
                "entity_type": "GlobalPackage",
                "entity_address": "string",
                "entity_module": "TypeInfo",
                "partition_kind": "Field",
                "partition_number": 0,
                "substate_type": "BootLoaderModuleFieldVmBoot",
                "substate_key": {
                  "key_type": "Field",
                  "db_sort_key_hex": "string"
                }
              },
              "new_value": {
                "substate_hex": "string",
                "substate_data_hash": "string",
                "substate_data": {
                  "substate_type": "BootLoaderModuleFieldVmBoot",
                  "is_locked": true
                }
              },
              "previous_value": {
                "substate_hex": "string",
                "substate_data_hash": "string",
                "substate_data": {
                  "substate_type": "BootLoaderModuleFieldVmBoot",
                  "is_locked": true
                }
              },
              "system_structure": {
                "type": "SystemField"
              }
            }
          ],
          "deleted_substates": [
            {
              "substate_id": {
                "entity_type": "GlobalPackage",
                "entity_address": "string",
                "entity_module": "TypeInfo",
                "partition_kind": "Field",
                "partition_number": 0,
                "substate_type": "BootLoaderModuleFieldVmBoot",
                "substate_key": {
                  "key_type": "Field",
                  "db_sort_key_hex": "string"
                }
              },
              "previous_value": {
                "substate_hex": "string",
                "substate_data_hash": "string",
                "substate_data": {
                  "substate_type": "BootLoaderModuleFieldVmBoot",
                  "is_locked": true
                }
              },
              "system_structure": {
                "type": "SystemField"
              }
            }
          ],
          "new_global_entities": [
            {
              "entity_type": "GlobalPackage",
              "is_global": true,
              "entity_address": "string"
            }
          ]
        },
        "events": [
          {
            "type": {
              "emitter": {
                "type": "Function"
              },
              "type_reference": {
                "full_type_id": {
                  "entity_address": "string",
                  "schema_hash": "string",
                  "local_type_id": {
                    "kind": "WellKnown",
                    "id": 0,
                    "as_sbor": {
                      "hex": "string"
                    }
                  }
                }
              },
              "name": "string"
            },
            "data": {
              "hex": "string"
            }
          }
        ],
        "next_epoch": {
          "epoch": 0,
          "validators": [
            {
              "address": "string",
              "key": {
                "key_type": "EcdsaSecp256k1",
                "key_hex": "string"
              },
              "stake": "string"
            }
          ],
          "significant_protocol_update_readiness": [
            {
              "readiness_signal_name": "string",
              "signalled_stake": "string"
            }
          ]
        },
        "output": [
          {
            "hex": "string"
          }
        ],
        "error_message": "string"
      },
      "balance_changes": {
        "fungible_entity_balance_changes": [
          {
            "entity_address": "string",
            "fee_balance_change": {
              "resource_address": "string",
              "balance_change": "string"
            },
            "fee_balance_changes": [
              {
                "type": "FeePayment",
                "resource_address": "string",
                "balance_change": "string"
              }
            ],
            "non_fee_balance_changes": [
              {
                "resource_address": "string",
                "balance_change": "string"
              }
            ]
          }
        ],
        "non_fungible_entity_balance_changes": [
          {
            "entity_address": "string",
            "resource_address": "string",
            "added": [
              "string"
            ],
            "removed": [
              "string"
            ]
          }
        ]
      },
      "proposer_timestamp_ms": 0
    }
  ],
  "proofs": [
    {
      "ledger_header": {
        "epoch": 0,
        "round": 0,
        "state_version": 1,
        "hashes": {
          "state_tree_hash": "string",
          "transaction_tree_hash": "string",
          "receipt_tree_hash": "string"
        },
        "consensus_parent_round_timestamp_ms": 0,
        "proposer_timestamp_ms": 0,
        "next_epoch": {
          "epoch": 0,
          "validators": [
            {
              "address": "string",
              "key": {
                "key_type": "EcdsaSecp256k1",
                "key_hex": "string"
              },
              "stake": "string"
            }
          ],
          "significant_protocol_update_readiness": [
            {
              "readiness_signal_name": "string",
              "signalled_stake": "string"
            }
          ]
        },
        "next_protocol_version": "string"
      },
      "origin": {
        "type": "Genesis"
      }
    }
  ]
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string",
  "details": {
    "type": "RequestedStateVersionOutOfBounds"
  }
}

{
  "error_type": "Basic",
  "code": 0,
  "message": "string",
  "trace_id": "string",
  "details": {
    "type": "RequestedStateVersionOutOfBounds"
  }
}

Documentation

How to migrate to NOWNodes

Authentication

Core

LTS

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Status

Authorizations

Response

Authorizations

Body

Response

Authorizations

Body

Response

Transaction

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Mempool

Authorizations

Body

Response

Authorizations

Body

Response

State

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response