Radix Gateway API - Babylon

vv1.5.2

Base URL

https://xrd-gateway.nownodes.io

Authentication

api-keyAuthapiKey

API Key: api-key in header

Geteway

Status

Query information about the Gateway API status.

Get Gateway Status

POST

https://xrd-gateway.nownodes.io/status/gateway-status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the Gateway API version and current ledger state.

Response

200OK

Network Gateway Information

Get Gateway Status

curl -X POST 'https://xrd-gateway.nownodes.io/status/gateway-status'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/status/gateway-status')
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-gateway.nownodes.io/status/gateway-status')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/status/gateway-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({});
console.log(result);

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/status/gateway-status')
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)

200

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "release_info": {
    "release_version": "string",
    "open_api_schema_version": "string",
    "image_tag": "string"
  }
}

Get Network Configuration

POST

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns network identifier, network name and well-known network addresses.

Response

200OK

Network Configuration

Get Network Configuration

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/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-gateway.nownodes.io/status/network-configuration')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/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-gateway.nownodes.io/status/network-configuration', {
  method: 'POST',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/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)

200

{
  "network_id": "<network-id>",
  "network_name": "<network-name>",
  "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",
    "access_rules_package": "string",
    "role_assignment_module_package": "string",
    "genesis_helper_package": "string",
    "faucet_package": "string",
    "consensus_manager": "string",
    "genesis_helper": "string",
    "faucet": "string",
    "pool_package": "string",
    "transaction_tracker": "string"
  }
}

Transaction

Query status of, construct, preview and submit transactions.

Get Construction Metadata

POST

https://xrd-gateway.nownodes.io/transaction/construction

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information needed to construct a new transaction including current epoch number.

Response

200OK

Returns information needed to construct transaction.

Get Construction Metadata

curl -X POST 'https://xrd-gateway.nownodes.io/transaction/construction'

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/construction', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/transaction/construction')
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-gateway.nownodes.io/transaction/construction')
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/construction', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/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({});
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/construction', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://xrd-gateway.nownodes.io/transaction/construction')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/transaction/construction')
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)

200

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  }
}

Preview Transaction

POST

https://xrd-gateway.nownodes.io/transaction/preview

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Previews transaction against the network. This endpoint is effectively a proxy towards the Core API /v0/transaction/preview endpoint. See the Core API documentation for more details.

Body

application/json

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>>= 0required

A decimal-string-encoded integer between 0 and 2^32 - 1, used to ensure the transaction intent is unique.

signer_public_keysArray<PublicKey>required

A list of public keys to be used as transaction signers

Show child attributes

key_typePublicKeyTypeEcdsaSecp256k1EddsaEd25519required

flagsobjectrequired

Show child attributes

use_free_creditbooleanrequired

assume_all_signature_proofsbooleanrequired

skip_epoch_checkbooleanrequired

Response

200OK

Successful Preview

4XX

Client-originated request error

Preview Transaction

curl -X POST 'https://xrd-gateway.nownodes.io/transaction/preview' \
  -H 'Content-Type: application/json' \
  -d '{
    "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"
      }
    ],
    "flags": {
      "use_free_credit": true,
      "assume_all_signature_proofs": true,
      "skip_epoch_check": true
    }
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/preview', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "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"
        }
      ],
      "flags": {
        "use_free_credit": true,
        "assume_all_signature_proofs": true,
        "skip_epoch_check": true
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/transaction/preview')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "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"
      }
    ],
    "flags": {
      "use_free_credit": true,
      "assume_all_signature_proofs": true,
      "skip_epoch_check": true
    }
  }'

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

import requests

payload = {
  "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"
    }
  ],
  "flags": {
    "use_free_credit": True,
    "assume_all_signature_proofs": True,
    "skip_epoch_check": True
  }
}

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

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/preview', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "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"
        }
      ],
      "flags": {
        "use_free_credit": true,
        "assume_all_signature_proofs": true,
        "skip_epoch_check": true
      }
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/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({
    "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"
      }
    ],
    "flags": {
      "use_free_credit": true,
      "assume_all_signature_proofs": true,
      "skip_epoch_check": true
    }
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/preview', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "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"
        }
      ],
      "flags": {
        "use_free_credit": true,
        "assume_all_signature_proofs": true,
        "skip_epoch_check": true
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "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"
    }
  ],
  "flags": {
    "use_free_credit": True,
    "assume_all_signature_proofs": True,
    "skip_epoch_check": True
  }
}

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/transaction/preview')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "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"
      }
    ],
    "flags": {
      "use_free_credit": true,
      "assume_all_signature_proofs": true,
      "skip_epoch_check": true
    }
  }'

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

Request Body

{
  "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"
    }
  ],
  "flags": {
    "use_free_credit": true,
    "assume_all_signature_proofs": true,
    "skip_epoch_check": true
  }
}

{
  "encoded_receipt": "string",
  "receipt": {},
  "resource_changes": [
    {}
  ],
  "logs": [
    {
      "level": "string",
      "message": "string"
    }
  ]
}

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

Submit Transaction

POST

https://xrd-gateway.nownodes.io/transaction/submit

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Submits a signed transaction payload to the network.

Body

application/json

notarized_transaction_hexNotarizedTransactionHexStringrequired

Hex-encoded notarized transaction payload which can be submitted.

Response

200OK

Successful Submission

4XX

Client-originated request error

Submit Transaction

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

payload = {
  "notarized_transaction_hex": "string"
}

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

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

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/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({
    "notarized_transaction_hex": "string"
  });
console.log(result);

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

const data = await response.json();

import requests

payload = {
  "notarized_transaction_hex": "string"
}

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

require 'net/http'
require 'json'

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

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

Request Body

{
  "notarized_transaction_hex": "string"
}

{
  "duplicate": true
}

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

Get Committed Transaction Details

POST

https://xrd-gateway.nownodes.io/transaction/committed-details

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the committed details and receipt of the transaction for a given transaction identifier. Transaction identifiers which don't correspond to a committed transaction will return a TransactionNotFoundError.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Optional. This allows for a request to be made against a historic state. If a constraint is specified, the Gateway will resolve the request against the ledger state at that time. If not specified, requests will be made with respect to the top of the committed ledger.

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

intent_hashHashBech32mStringrequired

Bech32m-encoded hash.

opt_insTransactionDetailsOptIns

Show child attributes

raw_hexbooleanfalse

if set to true, raw transaction hex is returned.

receipt_state_changesbooleanfalse

if set to true, state changes inside receipt object are returned.

receipt_fee_summarybooleanfalse

if set to true, fee summary inside receipt object is returned.

receipt_fee_sourcebooleanfalse

if set to true, fee source inside receipt object is returned.

receipt_fee_destinationbooleanfalse

if set to true, fee destination inside receipt object is returned.

receipt_costing_parametersbooleanfalse

if set to true, costing parameters inside receipt object is returned.

receipt_eventsbooleanfalse

if set to true, events inside receipt object is returned.

receipt_outputbooleantrue

(true by default) if set to true, transaction receipt output is returned.

affected_global_entitiesbooleanfalse

if set to true, all affected global entities by given transaction are returned.

manifest_instructionsbooleanfalse

if set to true, manifest instructions for user transactions are returned.

balance_changesbooleanfalse

if set to true, returns the fungible and non-fungible balance changes.

Warning! This opt-in might be missing for recently committed transactions, in that case a null value will be returned. Retry the request until non-null value is returned.

Response

200OK

Transaction Status

4XX

Client-originated request error

Get Committed Transaction Details

curl -X POST 'https://xrd-gateway.nownodes.io/transaction/committed-details' \
  -H 'Content-Type: application/json' \
  -d '{
    "intent_hash": "<transaction-intent-hash>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/committed-details', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "intent_hash": "<transaction-intent-hash>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/transaction/committed-details')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "intent_hash": "<transaction-intent-hash>"
  }'

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

import requests

payload = {
  "intent_hash": "<transaction-intent-hash>"
}

response = requests.post('https://xrd-gateway.nownodes.io/transaction/committed-details', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/committed-details', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "intent_hash": "<transaction-intent-hash>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/transaction/committed-details";
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({
    "intent_hash": "<transaction-intent-hash>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/committed-details', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "intent_hash": "<transaction-intent-hash>"
    }),
});

const data = await response.json();

import requests

payload = {
  "intent_hash": "<transaction-intent-hash>"
}

response = requests.post('https://xrd-gateway.nownodes.io/transaction/committed-details', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/transaction/committed-details')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "intent_hash": "<transaction-intent-hash>"
  }'

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

Request Body

{
  "intent_hash": "<transaction-intent-hash>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "transaction": {
    "state_version": 0,
    "epoch": 0,
    "round": 0,
    "round_timestamp": "string",
    "transaction_status": "Unknown",
    "payload_hash": "string",
    "intent_hash": "string",
    "fee_paid": "string",
    "affected_global_entities": [
      "string"
    ],
    "confirmed_at": "2024-01-15T09:30:00Z",
    "error_message": "string",
    "raw_hex": "string",
    "receipt": {
      "status": "Unknown",
      "fee_summary": {},
      "costing_parameters": {},
      "fee_destination": {},
      "fee_source": {},
      "state_updates": {},
      "next_epoch": {},
      "output": {},
      "events": [
        {
          "name": "string",
          "emitter": {},
          "data": {
            "kind": "Bool",
            "type_name": "string",
            "field_name": "string"
          }
        }
      ],
      "error_message": "string"
    },
    "manifest_instructions": "string",
    "manifest_classes": [
      "General"
    ],
    "message": {},
    "balance_changes": {
      "fungible_fee_balance_changes": [
        {
          "type": "FeePayment",
          "entity_address": "string",
          "resource_address": "string",
          "balance_change": "string"
        }
      ],
      "fungible_balance_changes": [
        {
          "entity_address": "string",
          "resource_address": "string",
          "balance_change": "string"
        }
      ],
      "non_fungible_balance_changes": [
        {
          "entity_address": "string",
          "resource_address": "string",
          "added": [
            "string"
          ],
          "removed": [
            "string"
          ]
        }
      ]
    }
  }
}

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

Get Transaction Status

POST

https://xrd-gateway.nownodes.io/transaction/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns overall transaction status and all of its known payloads based on supplied intent hash.

Body

application/json

intent_hashHashBech32mStringrequired

Bech32m-encoded hash.

Response

200OK

Transaction Status

4XX

Client-originated request error

Get Transaction Status

curl -X POST 'https://xrd-gateway.nownodes.io/transaction/status' \
  -H 'Content-Type: application/json' \
  -d '{
    "intent_hash": "<transaction-intent-hash>"
  }'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/transaction/status')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "intent_hash": "<transaction-intent-hash>"
  }'

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

import requests

payload = {
  "intent_hash": "<transaction-intent-hash>"
}

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

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

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/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({
    "intent_hash": "<transaction-intent-hash>"
  });
console.log(result);

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

const data = await response.json();

import requests

payload = {
  "intent_hash": "<transaction-intent-hash>"
}

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/transaction/status')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "intent_hash": "<transaction-intent-hash>"
  }'

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

Request Body

{
  "intent_hash": "<transaction-intent-hash>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "status": "Unknown",
  "intent_status": "Unknown",
  "intent_status_description": "string",
  "known_payloads": [
    {
      "payload_hash": "string",
      "status": "Unknown",
      "payload_status": "Unknown",
      "payload_status_description": "string",
      "error_message": "string",
      "latest_error_message": "string",
      "handling_status": "HandlingSubmission",
      "handling_status_reason": "string",
      "submission_error": "string"
    }
  ],
  "committed_state_version": 0,
  "permanently_rejects_at_epoch": 0,
  "error_message": "string"
}

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

PreValidate deposit of resources to an account

POST

https://xrd-gateway.nownodes.io/transaction/account-deposit-pre-validation

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Helper endpoint that allows pre-validation if a deposit of certain resources to a given account can succeed or not. It is only meant for pre-validation usage, it does not guarantee that execution will succeed.

Body

application/json

account_addressAddressrequired

Bech32m-encoded human readable version of the address.

resource_addressesArray<Address>required

badgeTransactionAccountDepositPreValidationAuthorizedDepositorBadge

Show child attributes

badge_typeAccountAuthorizedDepositorBadgeTypeResourceBadgeNonFungibleBadgerequired

resource_addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

Pre-validation response, including all deciding factors that were used to generate that response.

4XX

Client-originated request error

PreValidate deposit of resources to an account

curl -X POST 'https://xrd-gateway.nownodes.io/transaction/account-deposit-pre-validation' \
  -H 'Content-Type: application/json' \
  -d '{
    "account_address": "<account-address>",
    "resource_addresses": [
      "<resource-address>"
    ]
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/account-deposit-pre-validation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_address": "<account-address>",
      "resource_addresses": [
        "<resource-address>"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/transaction/account-deposit-pre-validation')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_address": "<account-address>",
    "resource_addresses": [
      "<resource-address>"
    ]
  }'

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

import requests

payload = {
  "account_address": "<account-address>",
  "resource_addresses": [
    "<resource-address>"
  ]
}

response = requests.post('https://xrd-gateway.nownodes.io/transaction/account-deposit-pre-validation', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/account-deposit-pre-validation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_address": "<account-address>",
      "resource_addresses": [
        "<resource-address>"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/transaction/account-deposit-pre-validation";
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({
    "account_address": "<account-address>",
    "resource_addresses": [
      "<resource-address>"
    ]
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/transaction/account-deposit-pre-validation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_address": "<account-address>",
      "resource_addresses": [
        "<resource-address>"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "account_address": "<account-address>",
  "resource_addresses": [
    "<resource-address>"
  ]
}

response = requests.post('https://xrd-gateway.nownodes.io/transaction/account-deposit-pre-validation', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/transaction/account-deposit-pre-validation')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_address": "<account-address>",
    "resource_addresses": [
      "<resource-address>"
    ]
  }'

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

Request Body

{
  "account_address": "<account-address>",
  "resource_addresses": [
    "<resource-address>"
  ]
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "allows_try_deposit_batch": true,
  "resource_specific_behaviour": [
    {
      "resource_address": "string",
      "allows_try_deposit": true
    }
  ],
  "deciding_factors": {
    "is_badge_authorized_depositor": true,
    "default_deposit_rule": "Accept",
    "resource_specific_details": [
      {
        "resource_address": "string",
        "vault_exists": true,
        "is_xrd": true,
        "resource_preference_rule": "Allowed"
      }
    ]
  }
}

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

Stream

Browse through the history of transactions.

Get Transactions Stream

POST

https://xrd-gateway.nownodes.io/stream/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns transactions which have been committed to the ledger. Check detailed documentation for brief explanation

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

defines lower boundary (inclusive) for queried data. i.e { "from_state_version" = {"epoch" = 10} }, will return data from epoch 10 till current max ledger tip.

from_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

kind_filterstringUserEpochChangeAll

Limit returned transactions by their kind. Defaults to user.

manifest_accounts_withdrawn_from_filterArray<Address>

manifest_accounts_deposited_into_filterArray<Address>

manifest_badges_presented_filterArray<Address>

manifest_resources_filterArray<Address>

affected_global_entities_filterArray<Address>

events_filterArray<StreamTransactionsRequestEventFilterItem>

Show child attributes

eventstringDepositWithdrawalrequired

emitter_addressAddress

Bech32m-encoded human readable version of the address.

resource_addressAddress

Bech32m-encoded human readable version of the address.

accounts_with_manifest_owner_method_callsArray<Address>

accounts_without_manifest_owner_method_callsArray<Address>

manifest_class_filterobject

Show child attributes

classManifestClassGeneralTransferPoolContributionPoolRedemptionValidatorStakeValidatorUnstakeValidatorClaimAccountDepositSettingsUpdaterequired

High-level manifest class type:

General: A general manifest that involves any amount of arbitrary components and packages where nothing more concrete can be said about the manifest and its nature.
Transfer: A manifest of a 1-to-1 transfer to a one-to-many transfer of resources.
PoolContribution: A manifest that contributed some amount of resources to a liquidity pool that can be a one-resource pool, two-resource pool, or a multi-resource pool.
PoolRedemption: A manifest that redeemed resources from a liquidity pool. Similar to contributions, this can be any of the three pool blueprints available in the pool package.
ValidatorStake: A manifest where XRD is staked to one or more validators.
ValidatorUnstake: A manifest where XRD is unstaked from one or more validators.
ValidatorClaim: A manifest where XRD is claimed from one or more validators.
AccountDepositSettingsUpdate: A manifest that updated the deposit settings of the account.

match_only_most_specificbooleanfalse

orderstringAscDesc

Configures the order of returned result set. Defaults to desc.

opt_insTransactionDetailsOptIns

Show child attributes

raw_hexbooleanfalse

if set to true, raw transaction hex is returned.

receipt_state_changesbooleanfalse

if set to true, state changes inside receipt object are returned.

receipt_fee_summarybooleanfalse

if set to true, fee summary inside receipt object is returned.

receipt_fee_sourcebooleanfalse

if set to true, fee source inside receipt object is returned.

receipt_fee_destinationbooleanfalse

if set to true, fee destination inside receipt object is returned.

receipt_costing_parametersbooleanfalse

if set to true, costing parameters inside receipt object is returned.

receipt_eventsbooleanfalse

if set to true, events inside receipt object is returned.

receipt_outputbooleantrue

(true by default) if set to true, transaction receipt output is returned.

affected_global_entitiesbooleanfalse

if set to true, all affected global entities by given transaction are returned.

manifest_instructionsbooleanfalse

if set to true, manifest instructions for user transactions are returned.

balance_changesbooleanfalse

if set to true, returns the fungible and non-fungible balance changes.

Warning! This opt-in might be missing for recently committed transactions, in that case a null value will be returned. Retry the request until non-null value is returned.

Response

200OK

Transactions (paginated)

4XX

Client-originated request error

Get Transactions Stream

curl -X POST 'https://xrd-gateway.nownodes.io/stream/transactions' \
  -H 'Content-Type: application/json' \
  -d '{
    "limit_per_page": 5
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/stream/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "limit_per_page": 5
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/stream/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "limit_per_page": 5
  }'

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

import requests

payload = {
  "limit_per_page": 5
}

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

const response = await fetch('https://xrd-gateway.nownodes.io/stream/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "limit_per_page": 5
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/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({
    "limit_per_page": 5
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/stream/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "limit_per_page": 5
    }),
});

const data = await response.json();

import requests

payload = {
  "limit_per_page": 5
}

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/stream/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "limit_per_page": 5
  }'

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

Request Body

{
  "limit_per_page": 5
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "state_version": 0,
      "epoch": 0,
      "round": 0,
      "round_timestamp": "string",
      "transaction_status": "Unknown",
      "payload_hash": "string",
      "intent_hash": "string",
      "fee_paid": "string",
      "affected_global_entities": [
        "string"
      ],
      "confirmed_at": "2024-01-15T09:30:00Z",
      "error_message": "string",
      "raw_hex": "string",
      "receipt": {
        "status": "Unknown",
        "fee_summary": {},
        "costing_parameters": {},
        "fee_destination": {},
        "fee_source": {},
        "state_updates": {},
        "next_epoch": {},
        "output": {},
        "events": [
          {
            "name": "string",
            "emitter": {},
            "data": {
              "kind": "Bool",
              "type_name": "string",
              "field_name": "string"
            }
          }
        ],
        "error_message": "string"
      },
      "manifest_instructions": "string",
      "manifest_classes": [
        "General"
      ],
      "message": {},
      "balance_changes": {
        "fungible_fee_balance_changes": [
          {
            "type": "FeePayment",
            "entity_address": "string",
            "resource_address": "string",
            "balance_change": "string"
          }
        ],
        "fungible_balance_changes": [
          {
            "entity_address": "string",
            "resource_address": "string",
            "balance_change": "string"
          }
        ],
        "non_fungible_balance_changes": [
          {
            "entity_address": "string",
            "resource_address": "string",
            "added": [
              "string"
            ],
            "removed": [
              "string"
            ]
          }
        ]
      }
    }
  ]
}

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

State

Query information snapshot about state of ledger entities at present or past time.

Get Entity Details

POST

https://xrd-gateway.nownodes.io/state/entity/details

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed information for collection of entities. Aggregate resources globally by default.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

opt_insStateEntityDetailsOptIns

Check detailed OptIns documentation for more details

Show child attributes

ancestor_identitiesbooleanfalse

if set to true, ancestor addresses - parent_address, owner_address and global_address for entities are returned.

component_royalty_configbooleanfalse

if set to true, royalty_config for component entities is returned.

component_royalty_vault_balancebooleanfalse

if set to true, royalty_vault_balance for component entities is returned.

package_royalty_vault_balancebooleanfalse

if set to true, royalty_vault_balance for package entities is returned.

non_fungible_include_nfidsbooleanfalse

if set to true, first page of non fungible ids are returned for each non fungible resource, with next_cursor which can be later used at /state/entity/page/non-fungible-vault/ids endpoint.

explicit_metadataArray<string>

allows specifying explicitly metadata properties which should be returned in response.

addressesArray<Address>required

limited to max 100 items.

aggregation_levelResourceAggregationLevelGlobalVault

Response

200OK

Entity Details

4XX

Client-originated request error

Get Entity Details

curl -X POST 'https://xrd-gateway.nownodes.io/state/entity/details' \
  -H 'Content-Type: application/json' \
  -d '{
    "addresses": [
      "<entity-address>"
    ],
    "aggregation_level": "Vault",
    "opt_ins": {
      "ancestor_identities": true,
      "component_royalty_config": true,
      "component_royalty_vault_balance": true,
      "package_royalty_vault_balance": true,
      "non_fungible_include_nfids": true,
      "explicit_metadata": [
        "name",
        "description"
      ]
    }
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/details', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "addresses": [
        "<entity-address>"
      ],
      "aggregation_level": "Vault",
      "opt_ins": {
        "ancestor_identities": true,
        "component_royalty_config": true,
        "component_royalty_vault_balance": true,
        "package_royalty_vault_balance": true,
        "non_fungible_include_nfids": true,
        "explicit_metadata": [
          "name",
          "description"
        ]
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/details')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "addresses": [
      "<entity-address>"
    ],
    "aggregation_level": "Vault",
    "opt_ins": {
      "ancestor_identities": true,
      "component_royalty_config": true,
      "component_royalty_vault_balance": true,
      "package_royalty_vault_balance": true,
      "non_fungible_include_nfids": true,
      "explicit_metadata": [
        "name",
        "description"
      ]
    }
  }'

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

import requests

payload = {
  "addresses": [
    "<entity-address>"
  ],
  "aggregation_level": "Vault",
  "opt_ins": {
    "ancestor_identities": True,
    "component_royalty_config": True,
    "component_royalty_vault_balance": True,
    "package_royalty_vault_balance": True,
    "non_fungible_include_nfids": True,
    "explicit_metadata": [
      "name",
      "description"
    ]
  }
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/details', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/details', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "addresses": [
        "<entity-address>"
      ],
      "aggregation_level": "Vault",
      "opt_ins": {
        "ancestor_identities": true,
        "component_royalty_config": true,
        "component_royalty_vault_balance": true,
        "package_royalty_vault_balance": true,
        "non_fungible_include_nfids": true,
        "explicit_metadata": [
          "name",
          "description"
        ]
      }
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/entity/details";
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({
    "addresses": [
      "<entity-address>"
    ],
    "aggregation_level": "Vault",
    "opt_ins": {
      "ancestor_identities": true,
      "component_royalty_config": true,
      "component_royalty_vault_balance": true,
      "package_royalty_vault_balance": true,
      "non_fungible_include_nfids": true,
      "explicit_metadata": [
        "name",
        "description"
      ]
    }
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/details', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "addresses": [
        "<entity-address>"
      ],
      "aggregation_level": "Vault",
      "opt_ins": {
        "ancestor_identities": true,
        "component_royalty_config": true,
        "component_royalty_vault_balance": true,
        "package_royalty_vault_balance": true,
        "non_fungible_include_nfids": true,
        "explicit_metadata": [
          "name",
          "description"
        ]
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "addresses": [
    "<entity-address>"
  ],
  "aggregation_level": "Vault",
  "opt_ins": {
    "ancestor_identities": True,
    "component_royalty_config": True,
    "component_royalty_vault_balance": True,
    "package_royalty_vault_balance": True,
    "non_fungible_include_nfids": True,
    "explicit_metadata": [
      "name",
      "description"
    ]
  }
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/details', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/details')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "addresses": [
      "<entity-address>"
    ],
    "aggregation_level": "Vault",
    "opt_ins": {
      "ancestor_identities": true,
      "component_royalty_config": true,
      "component_royalty_vault_balance": true,
      "package_royalty_vault_balance": true,
      "non_fungible_include_nfids": true,
      "explicit_metadata": [
        "name",
        "description"
      ]
    }
  }'

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

Request Body

{
  "addresses": [
    "<entity-address>"
  ],
  "aggregation_level": "Vault",
  "opt_ins": {
    "ancestor_identities": true,
    "component_royalty_config": true,
    "component_royalty_vault_balance": true,
    "package_royalty_vault_balance": true,
    "non_fungible_include_nfids": true,
    "explicit_metadata": [
      "name",
      "description"
    ]
  }
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "items": [
    {
      "address": "string",
      "fungible_resources": {
        "total_count": 0,
        "next_cursor": "string",
        "items": [
          {
            "aggregation_level": "Global",
            "resource_address": "string",
            "explicit_metadata": {
              "total_count": 0,
              "next_cursor": "string",
              "items": [
                {
                  "key": "string",
                  "value": {
                    "raw_hex": "string",
                    "programmatic_json": {
                      "kind": "Bool",
                      "type_name": "string",
                      "field_name": "string"
                    },
                    "typed": {
                      "type": "String"
                    }
                  },
                  "is_locked": true,
                  "last_updated_at_state_version": 1
                }
              ]
            }
          }
        ]
      },
      "non_fungible_resources": {
        "total_count": 0,
        "next_cursor": "string",
        "items": [
          {
            "aggregation_level": "Global",
            "resource_address": "string",
            "explicit_metadata": {
              "total_count": 0,
              "next_cursor": "string",
              "items": [
                {
                  "key": "string",
                  "value": {
                    "raw_hex": "string",
                    "programmatic_json": {
                      "kind": "Bool",
                      "type_name": "string",
                      "field_name": "string"
                    },
                    "typed": {
                      "type": "String"
                    }
                  },
                  "is_locked": true,
                  "last_updated_at_state_version": 1
                }
              ]
            }
          }
        ]
      },
      "ancestor_identities": {
        "parent_address": "string",
        "owner_address": "string",
        "global_address": "string"
      },
      "metadata": {
        "total_count": 0,
        "next_cursor": "string",
        "items": [
          {
            "key": "string",
            "value": {
              "raw_hex": "string",
              "programmatic_json": {
                "kind": "Bool",
                "type_name": "string",
                "field_name": "string"
              },
              "typed": {
                "type": "String"
              }
            },
            "is_locked": true,
            "last_updated_at_state_version": 1
          }
        ]
      },
      "explicit_metadata": {
        "total_count": 0,
        "next_cursor": "string",
        "items": [
          {
            "key": "string",
            "value": {
              "raw_hex": "string",
              "programmatic_json": {
                "kind": "Bool",
                "type_name": "string",
                "field_name": "string"
              },
              "typed": {
                "type": "String"
              }
            },
            "is_locked": true,
            "last_updated_at_state_version": 1
          }
        ]
      },
      "details": {
        "type": "FungibleResource"
      }
    }
  ]
}

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

Get Entity Metadata Page

POST

https://xrd-gateway.nownodes.io/state/entity/page/metadata

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all the metadata properties associated with a given global entity. The returned response is in a paginated format, ordered by first appearance on the ledger.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

Entity Metadata (paginated)

4XX

Client-originated request error

Get Entity Metadata Page

curl -X POST 'https://xrd-gateway.nownodes.io/state/entity/page/metadata' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "<entity-address>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/metadata', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<entity-address>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/metadata')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<entity-address>"
  }'

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

import requests

payload = {
  "address": "<entity-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/metadata', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/metadata', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<entity-address>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/entity/page/metadata";
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({
    "address": "<entity-address>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/metadata', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<entity-address>"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "<entity-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/metadata', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/metadata')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<entity-address>"
  }'

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

Request Body

{
  "address": "<entity-address>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "key": "string",
      "value": {
        "raw_hex": "string",
        "programmatic_json": {
          "kind": "Bool",
          "type_name": "string",
          "field_name": "string"
        },
        "typed": {
          "type": "String"
        }
      },
      "is_locked": true,
      "last_updated_at_state_version": 1
    }
  ],
  "address": "string"
}

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

Get Entity Schema Page

POST

https://xrd-gateway.nownodes.io/state/entity/page/schemas

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all the schemas associated with a given global entity. The returned response is in a paginated format, ordered by first appearance on the ledger.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

Entity Schemas (paginated)

4XX

Client-originated request error

Get Entity Schema Page

curl -X POST 'https://xrd-gateway.nownodes.io/state/entity/page/schemas' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "<package-address>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/schemas', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<package-address>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/schemas')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<package-address>"
  }'

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

import requests

payload = {
  "address": "<package-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/schemas', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/schemas', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<package-address>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/entity/page/schemas";
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({
    "address": "<package-address>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/schemas', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<package-address>"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "<package-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/schemas', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/schemas')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<package-address>"
  }'

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

Request Body

{
  "address": "<package-address>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "schema_hash_hex": "string",
      "schema_hex": "string"
    }
  ],
  "address": "string"
}

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

Get page of Global Entity Fungible Resource Balances

POST

https://xrd-gateway.nownodes.io/state/entity/page/fungibles

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total amount of each fungible resource owned by a given global entity. Result can be aggregated globally or per vault. The returned response is in a paginated format, ordered by the resource's first appearance on the ledger.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

addressAddressrequired

Bech32m-encoded human readable version of the address.

aggregation_levelResourceAggregationLevelGlobalVault

opt_insStateEntityFungiblesPageRequestOptIns

Check detailed OptIns documentation for more details

Show child attributes

explicit_metadataArray<string>

allows specifying explicitly metadata properties which should be returned in response, limited to max 20 items.

Response

200OK

Entity Fungibles (paginated)

4XX

Client-originated request error

Get page of Global Entity Fungible Resource Balances

curl -X POST 'https://xrd-gateway.nownodes.io/state/entity/page/fungibles/' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "<component-entity-address>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/fungibles/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/fungibles/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<component-entity-address>"
  }'

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

import requests

payload = {
  "address": "<component-entity-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/fungibles/', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/fungibles/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/entity/page/fungibles/";
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({
    "address": "<component-entity-address>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/fungibles/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "<component-entity-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/fungibles/', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/fungibles/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<component-entity-address>"
  }'

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

Request Body

{
  "address": "<component-entity-address>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "aggregation_level": "Global",
      "resource_address": "string",
      "explicit_metadata": {
        "total_count": 0,
        "next_cursor": "string",
        "items": [
          {
            "key": "string",
            "value": {
              "raw_hex": "string",
              "programmatic_json": {
                "kind": "Bool",
                "type_name": "string",
                "field_name": "string"
              },
              "typed": {
                "type": "String"
              }
            },
            "is_locked": true,
            "last_updated_at_state_version": 1
          }
        ]
      }
    }
  ],
  "address": "string"
}

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

Get page of Global Entity Fungible Resource Vaults

POST

https://xrd-gateway.nownodes.io/state/entity/page/fungible-vaults

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns vaults for fungible resource owned by a given global entity. The returned response is in a paginated format, ordered by the resource's first appearance on the ledger.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

addressAddressrequired

Bech32m-encoded human readable version of the address.

resource_addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

Entity Fungibles (paginated)

4XX

Client-originated request error

Get page of Global Entity Fungible Resource Vaults

curl -X POST 'https://xrd-gateway.nownodes.io/state/entity/page/fungible-vaults/' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "<component-entity-address>",
    "resource_address": "<resource-address>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/fungible-vaults/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>",
      "resource_address": "<resource-address>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/fungible-vaults/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<component-entity-address>",
    "resource_address": "<resource-address>"
  }'

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

import requests

payload = {
  "address": "<component-entity-address>",
  "resource_address": "<resource-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/fungible-vaults/', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/fungible-vaults/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>",
      "resource_address": "<resource-address>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/entity/page/fungible-vaults/";
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({
    "address": "<component-entity-address>",
    "resource_address": "<resource-address>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/fungible-vaults/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>",
      "resource_address": "<resource-address>"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "<component-entity-address>",
  "resource_address": "<resource-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/fungible-vaults/', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/fungible-vaults/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<component-entity-address>",
    "resource_address": "<resource-address>"
  }'

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

Request Body

{
  "address": "<component-entity-address>",
  "resource_address": "<resource-address>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "vault_address": "string",
      "amount": "string",
      "last_updated_at_state_version": 1
    }
  ],
  "address": "string",
  "resource_address": "string"
}

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

Get page of Global Entity Non-Fungible Resource Balances

POST

https://xrd-gateway.nownodes.io/state/entity/page/non-fungibles

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total amount of each non-fungible resource owned by a given global entity. Result can be aggregated globally or per vault. The returned response is in a paginated format, ordered by the resource's first appearance on the ledger.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

addressAddressrequired

Bech32m-encoded human readable version of the address.

aggregation_levelResourceAggregationLevelGlobalVault

opt_insStateEntityNonFungiblesPageRequestOptIns

Check detailed OptIns documentation for more details

Show child attributes

non_fungible_include_nfidsbooleanfalse

if set to true, first page of non fungible ids are returned for each non fungible resource, with cursor which can be later used at /state/entity/page/non-fungible-vault/ids endpoint.

explicit_metadataArray<string>

allows specifying explicitly metadata properties which should be returned in response, limited to max 20 items.

Response

200OK

Entity Non-Fungibles (paginated)

4XX

Client-originated request error

Get page of Global Entity Non-Fungible Resource Balances

curl -X POST 'https://xrd-gateway.nownodes.io/state/entity/page/non-fungibles/' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "<component-entity-address>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/non-fungibles/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/non-fungibles/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<component-entity-address>"
  }'

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

import requests

payload = {
  "address": "<component-entity-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/non-fungibles/', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/non-fungibles/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/entity/page/non-fungibles/";
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({
    "address": "<component-entity-address>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/non-fungibles/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "<component-entity-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/non-fungibles/', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/non-fungibles/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<component-entity-address>"
  }'

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

Request Body

{
  "address": "<component-entity-address>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "aggregation_level": "Global",
      "resource_address": "string",
      "explicit_metadata": {
        "total_count": 0,
        "next_cursor": "string",
        "items": [
          {
            "key": "string",
            "value": {
              "raw_hex": "string",
              "programmatic_json": {
                "kind": "Bool",
                "type_name": "string",
                "field_name": "string"
              },
              "typed": {
                "type": "String"
              }
            },
            "is_locked": true,
            "last_updated_at_state_version": 1
          }
        ]
      }
    }
  ],
  "address": "string"
}

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

Get page of Global Entity Non-Fungible Resource Vaults

POST

https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vaults

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns vaults for non fungible resource owned by a given global entity. The returned response is in a paginated format, ordered by the resource's first appearance on the ledger.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

addressAddressrequired

Bech32m-encoded human readable version of the address.

resource_addressAddressrequired

Bech32m-encoded human readable version of the address.

opt_insStateEntityNonFungibleResourceVaultsPageOptIns

Check detailed OptIns documentation for more details

Show child attributes

non_fungible_include_nfidsboolean

if set to true, first page of non fungible ids are returned for each non fungible resource, with cursor which can be later used at /state/entity/page/non-fungible-vault/ids endpoint.

Response

200OK

Entity Fungibles (paginated)

4XX

Client-originated request error

Get page of Global Entity Non-Fungible Resource Vaults

curl -X POST 'https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vaults/' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "<component-entity-address>",
    "resource_address": "<resource-address>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vaults/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>",
      "resource_address": "<resource-address>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vaults/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<component-entity-address>",
    "resource_address": "<resource-address>"
  }'

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

import requests

payload = {
  "address": "<component-entity-address>",
  "resource_address": "<resource-address>"
}

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

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vaults/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>",
      "resource_address": "<resource-address>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vaults/";
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({
    "address": "<component-entity-address>",
    "resource_address": "<resource-address>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vaults/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>",
      "resource_address": "<resource-address>"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "<component-entity-address>",
  "resource_address": "<resource-address>"
}

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vaults/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<component-entity-address>",
    "resource_address": "<resource-address>"
  }'

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

Request Body

{
  "address": "<component-entity-address>",
  "resource_address": "<resource-address>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "total_count": 0,
      "next_cursor": "string",
      "items": [
        "string"
      ],
      "vault_address": "string",
      "last_updated_at_state_version": 1
    }
  ],
  "address": "string",
  "resource_address": "string"
}

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

Get page of Non-Fungibles in Vault

POST

https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vault/ids

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all non-fungible IDs of a given non-fungible resource owned by a given entity. The returned response is in a paginated format, ordered by the resource's first appearence on the ledger.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

addressAddressrequired

Bech32m-encoded human readable version of the address.

vault_addressAddressrequired

Bech32m-encoded human readable version of the address.

resource_addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

Entity Non-Fungible IDs (paginated)

4XX

Client-originated request error

Get page of Non-Fungibles in Vault

curl -X POST 'https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vault/ids' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "<component-entity-address>",
    "resource_address": null,
    "vault_address": null
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vault/ids', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>",
      "resource_address": null,
      "vault_address": null
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vault/ids')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<component-entity-address>",
    "resource_address": null,
    "vault_address": null
  }'

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

import requests

payload = {
  "address": "<component-entity-address>",
  "resource_address": None,
  "vault_address": None
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vault/ids', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vault/ids', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>",
      "resource_address": null,
      "vault_address": null
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vault/ids";
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({
    "address": "<component-entity-address>",
    "resource_address": null,
    "vault_address": null
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vault/ids', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "<component-entity-address>",
      "resource_address": null,
      "vault_address": null
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "<component-entity-address>",
  "resource_address": None,
  "vault_address": None
}

response = requests.post('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vault/ids', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/entity/page/non-fungible-vault/ids')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "<component-entity-address>",
    "resource_address": null,
    "vault_address": null
  }'

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

Request Body

{
  "address": "<component-entity-address>",
  "resource_address": null,
  "vault_address": null
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    "string"
  ],
  "address": "string",
  "resource_address": "string"
}

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

Get page of Non-Fungible Ids in Resource Collection

POST

https://xrd-gateway.nownodes.io/state/non-fungible/ids

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the non-fungible IDs of a given non-fungible resource. Returned response is in a paginated format, ordered by their first appearance on the ledger.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

resource_addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

Non-Fungible IDs (paginated)

4XX

Client-originated request error

Get page of Non-Fungible Ids in Resource Collection

curl -X POST 'https://xrd-gateway.nownodes.io/state/non-fungible/ids' \
  -H 'Content-Type: application/json' \
  -d '{
    "resource_address": "<non-fungible-entity-address>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/non-fungible/ids', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "resource_address": "<non-fungible-entity-address>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/non-fungible/ids')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "resource_address": "<non-fungible-entity-address>"
  }'

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

import requests

payload = {
  "resource_address": "<non-fungible-entity-address>"
}

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

const response = await fetch('https://xrd-gateway.nownodes.io/state/non-fungible/ids', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "resource_address": "<non-fungible-entity-address>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/non-fungible/ids";
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({
    "resource_address": "<non-fungible-entity-address>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/non-fungible/ids', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "resource_address": "<non-fungible-entity-address>"
    }),
});

const data = await response.json();

import requests

payload = {
  "resource_address": "<non-fungible-entity-address>"
}

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/non-fungible/ids')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "resource_address": "<non-fungible-entity-address>"
  }'

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

Request Body

{
  "resource_address": "<non-fungible-entity-address>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "resource_address": "string",
  "non_fungible_ids": {
    "total_count": 0,
    "next_cursor": "string",
    "items": [
      "string"
    ]
  }
}

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

Get Non-Fungible Data

POST

https://xrd-gateway.nownodes.io/state/non-fungible/data

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns data associated with a given non-fungible ID of a given non-fungible resource.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

resource_addressAddressrequired

Bech32m-encoded human readable version of the address.

non_fungible_idsArray<NonFungibleId>required

limited to max 100 items.

Response

200OK

Non-Fungible ID Data

4XX

Client-originated request error

Get Non-Fungible Data

curl -X POST 'https://xrd-gateway.nownodes.io/state/non-fungible/data' \
  -H 'Content-Type: application/json' \
  -d '{
    "resource_address": "<non-fungible-entity-address>",
    "non_fungible_ids": [
      "#1#"
    ]
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/non-fungible/data', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "resource_address": "<non-fungible-entity-address>",
      "non_fungible_ids": [
        "#1#"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/non-fungible/data')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "resource_address": "<non-fungible-entity-address>",
    "non_fungible_ids": [
      "#1#"
    ]
  }'

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

import requests

payload = {
  "resource_address": "<non-fungible-entity-address>",
  "non_fungible_ids": [
    "#1#"
  ]
}

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

const response = await fetch('https://xrd-gateway.nownodes.io/state/non-fungible/data', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "resource_address": "<non-fungible-entity-address>",
      "non_fungible_ids": [
        "#1#"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/non-fungible/data";
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({
    "resource_address": "<non-fungible-entity-address>",
    "non_fungible_ids": [
      "#1#"
    ]
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/non-fungible/data', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "resource_address": "<non-fungible-entity-address>",
      "non_fungible_ids": [
        "#1#"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "resource_address": "<non-fungible-entity-address>",
  "non_fungible_ids": [
    "#1#"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/non-fungible/data')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "resource_address": "<non-fungible-entity-address>",
    "non_fungible_ids": [
      "#1#"
    ]
  }'

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

Request Body

{
  "resource_address": "<non-fungible-entity-address>",
  "non_fungible_ids": [
    "#1#"
  ]
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "resource_address": "string",
  "non_fungible_id_type": "String",
  "non_fungible_ids": [
    {
      "is_burned": true,
      "non_fungible_id": "string",
      "data": {
        "raw_hex": "string",
        "programmatic_json": {
          "kind": "Bool",
          "type_name": "string",
          "field_name": "string"
        }
      },
      "last_updated_at_state_version": 1
    }
  ]
}

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

Get Non-Fungible Location

POST

https://xrd-gateway.nownodes.io/state/non-fungible/location

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns location of a given non-fungible ID.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

resource_addressAddressrequired

Bech32m-encoded human readable version of the address.

non_fungible_idsArray<NonFungibleId>required

limited to max 100 items.

Response

200OK

Non-Fungible ID Location

4XX

Client-originated request error

Get Non-Fungible Location

curl -X POST 'https://xrd-gateway.nownodes.io/state/non-fungible/location' \
  -H 'Content-Type: application/json' \
  -d '{
    "resource_address": "<non-fungible-entity-address>",
    "non_fungible_ids": [
      "#1#"
    ]
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/non-fungible/location', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "resource_address": "<non-fungible-entity-address>",
      "non_fungible_ids": [
        "#1#"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/non-fungible/location')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "resource_address": "<non-fungible-entity-address>",
    "non_fungible_ids": [
      "#1#"
    ]
  }'

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

import requests

payload = {
  "resource_address": "<non-fungible-entity-address>",
  "non_fungible_ids": [
    "#1#"
  ]
}

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

const response = await fetch('https://xrd-gateway.nownodes.io/state/non-fungible/location', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "resource_address": "<non-fungible-entity-address>",
      "non_fungible_ids": [
        "#1#"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/non-fungible/location";
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({
    "resource_address": "<non-fungible-entity-address>",
    "non_fungible_ids": [
      "#1#"
    ]
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/non-fungible/location', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "resource_address": "<non-fungible-entity-address>",
      "non_fungible_ids": [
        "#1#"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "resource_address": "<non-fungible-entity-address>",
  "non_fungible_ids": [
    "#1#"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/non-fungible/location')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "resource_address": "<non-fungible-entity-address>",
    "non_fungible_ids": [
      "#1#"
    ]
  }'

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

Request Body

{
  "resource_address": "<non-fungible-entity-address>",
  "non_fungible_ids": [
    "#1#"
  ]
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "resource_address": "string",
  "non_fungible_ids": [
    {
      "non_fungible_id": "string",
      "owning_vault_address": "string",
      "owning_vault_parent_ancestor_address": "string",
      "owning_vault_global_ancestor_address": "string",
      "is_burned": true,
      "last_updated_at_state_version": 1
    }
  ]
}

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

Get KeyValueStore Keys

POST

https://xrd-gateway.nownodes.io/state/key-value-store/keys

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Allows to iterate over key value store keys.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

key_value_store_addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

KeyValueStore keys collection

4XX

Client-originated request error

Get KeyValueStore Keys

curl -X POST 'https://xrd-gateway.nownodes.io/state/key-value-store/keys' \
  -H 'Content-Type: application/json' \
  -d '{
    "key_value_store_address": "<key-value-store-address>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/key-value-store/keys', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "key_value_store_address": "<key-value-store-address>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/key-value-store/keys')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "key_value_store_address": "<key-value-store-address>"
  }'

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

import requests

payload = {
  "key_value_store_address": "<key-value-store-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/key-value-store/keys', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/state/key-value-store/keys', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "key_value_store_address": "<key-value-store-address>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/key-value-store/keys";
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({
    "key_value_store_address": "<key-value-store-address>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/key-value-store/keys', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "key_value_store_address": "<key-value-store-address>"
    }),
});

const data = await response.json();

import requests

payload = {
  "key_value_store_address": "<key-value-store-address>"
}

response = requests.post('https://xrd-gateway.nownodes.io/state/key-value-store/keys', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/key-value-store/keys')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "key_value_store_address": "<key-value-store-address>"
  }'

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

Request Body

{
  "key_value_store_address": "<key-value-store-address>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "key": {
        "raw_hex": "string",
        "programmatic_json": {
          "kind": "Bool",
          "type_name": "string",
          "field_name": "string"
        }
      },
      "last_updated_at_state_version": 1
    }
  ],
  "key_value_store_address": "string"
}

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

Get KeyValueStore Data

POST

https://xrd-gateway.nownodes.io/state/key-value-store/data

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns data (value) associated with a given key of a given key-value store. Check detailed documentation for explanation

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

key_value_store_addressAddressrequired

Bech32m-encoded human readable version of the address.

keysArray<StateKeyValueStoreDataRequestKeyItem>required

limited to max 100 items.

Show child attributes

key_hexHexString

Hex-encoded binary blob.

key_jsonProgrammaticScryptoSborValue

Arbitrary SBOR value represented as programmatic JSON with optional property name annotations.

All scalar types (Bool, I*, U*, String, Reference, Own, Decimal, PreciseDecimal, NonFungibleLocalId) convey their value via value string property with notable exception of Bool type that uses regular JSON boolean type. Numeric values as string-encoded to preserve accuracy and simplify implementation on platforms with no native support for 64-bit long numerical values.

Common properties represented as nullable strings:

type_name is only output when a schema is present and the type has a name,
field_name is only output when the value is a child of a Tuple or Enum, which has a type with named fields,
variant_name is only output when a schema is present and the type is an Enum.

The following is a non-normative example annotated Tuple value with String and U32 fields:

Copied!

{
  "kind": "Tuple",
  "type_name": "CustomStructure",
  "fields": [
    {
      "kind": "String",
      "field_name": "favorite_color",
      "value": "Blue"
    },
    {
      "kind": "U32",
      "field_name": "usage_counter",
      "value": "462231"
    }
  ]
}

Show child attributes

kindProgrammaticScryptoSborValueKindBoolI8I16I32I64I128U8U16U32U64U128StringEnumArrayBytesMapTupleReferenceOwnDecimalPreciseDecimalNonFungibleLocalIdrequired

These are the Scrypto SBOR ValueKinds, but with Bytes added as an alias for Vec, to display such values as hex-encoded strings.

type_namestring | null

The name of the type of this value. This is only output when a schema is present and the type has a name. This property is ignored when the value is used as an input to the API.

field_namestring | null

The name of the field which hosts this value. This property is only included if this value is a child of a Tuple or Enum with named fields. This property is ignored when the value is used as an input to the API.

Response

200OK

Non-Fungible ID Data

4XX

Client-originated request error

Get KeyValueStore Data

curl -X POST 'https://xrd-gateway.nownodes.io/state/key-value-store/data' \
  -H 'Content-Type: application/json' \
  -d '{
    "key_value_store_address": "<key-value-store-address>",
    "keys": [
      {
        "key_hex": "5C21010901000000"
      },
      {
        "key_json": {
          "kind": "Tuple",
          "fields": [
            {
              "kind": "U32",
              "value": "1"
            }
          ]
        }
      }
    ]
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/key-value-store/data', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "key_value_store_address": "<key-value-store-address>",
      "keys": [
        {
          "key_hex": "5C21010901000000"
        },
        {
          "key_json": {
            "kind": "Tuple",
            "fields": [
              {
                "kind": "U32",
                "value": "1"
              }
            ]
          }
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/key-value-store/data')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "key_value_store_address": "<key-value-store-address>",
    "keys": [
      {
        "key_hex": "5C21010901000000"
      },
      {
        "key_json": {
          "kind": "Tuple",
          "fields": [
            {
              "kind": "U32",
              "value": "1"
            }
          ]
        }
      }
    ]
  }'

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

import requests

payload = {
  "key_value_store_address": "<key-value-store-address>",
  "keys": [
    {
      "key_hex": "5C21010901000000"
    },
    {
      "key_json": {
        "kind": "Tuple",
        "fields": [
          {
            "kind": "U32",
            "value": "1"
          }
        ]
      }
    }
  ]
}

response = requests.post('https://xrd-gateway.nownodes.io/state/key-value-store/data', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/state/key-value-store/data', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "key_value_store_address": "<key-value-store-address>",
      "keys": [
        {
          "key_hex": "5C21010901000000"
        },
        {
          "key_json": {
            "kind": "Tuple",
            "fields": [
              {
                "kind": "U32",
                "value": "1"
              }
            ]
          }
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/key-value-store/data";
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({
    "key_value_store_address": "<key-value-store-address>",
    "keys": [
      {
        "key_hex": "5C21010901000000"
      },
      {
        "key_json": {
          "kind": "Tuple",
          "fields": [
            {
              "kind": "U32",
              "value": "1"
            }
          ]
        }
      }
    ]
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/key-value-store/data', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "key_value_store_address": "<key-value-store-address>",
      "keys": [
        {
          "key_hex": "5C21010901000000"
        },
        {
          "key_json": {
            "kind": "Tuple",
            "fields": [
              {
                "kind": "U32",
                "value": "1"
              }
            ]
          }
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "key_value_store_address": "<key-value-store-address>",
  "keys": [
    {
      "key_hex": "5C21010901000000"
    },
    {
      "key_json": {
        "kind": "Tuple",
        "fields": [
          {
            "kind": "U32",
            "value": "1"
          }
        ]
      }
    }
  ]
}

response = requests.post('https://xrd-gateway.nownodes.io/state/key-value-store/data', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/key-value-store/data')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "key_value_store_address": "<key-value-store-address>",
    "keys": [
      {
        "key_hex": "5C21010901000000"
      },
      {
        "key_json": {
          "kind": "Tuple",
          "fields": [
            {
              "kind": "U32",
              "value": "1"
            }
          ]
        }
      }
    ]
  }'

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

Request Body

{
  "key_value_store_address": "<key-value-store-address>",
  "keys": [
    {
      "key_hex": "5C21010901000000"
    },
    {
      "key_json": {
        "kind": "Tuple",
        "fields": [
          {
            "kind": "U32",
            "value": "1"
          }
        ]
      }
    }
  ]
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "key_value_store_address": "string",
  "entries": [
    {
      "key": {
        "raw_hex": "string",
        "programmatic_json": {
          "kind": "Bool",
          "type_name": "string",
          "field_name": "string"
        }
      },
      "value": {
        "raw_hex": "string",
        "programmatic_json": {
          "kind": "Bool",
          "type_name": "string",
          "field_name": "string"
        }
      },
      "last_updated_at_state_version": 1,
      "is_locked": true
    }
  ]
}

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

Get Validators List

POST

https://xrd-gateway.nownodes.io/state/validators/list

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

Response

200OK

Validators List

4XX

Client-originated request error

Get Validators List

curl -X POST 'https://xrd-gateway.nownodes.io/state/validators/list' \
  -H 'Content-Type: application/json' \
  -d '{
    "at_ledger_state": null
  }'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/validators/list')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "at_ledger_state": null
  }'

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

import requests

payload = {
  "at_ledger_state": None
}

response = requests.post('https://xrd-gateway.nownodes.io/state/validators/list', json=payload)
data = response.json()

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

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/validators/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({
    "at_ledger_state": null
  });
console.log(result);

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

const data = await response.json();

import requests

payload = {
  "at_ledger_state": None
}

response = requests.post('https://xrd-gateway.nownodes.io/state/validators/list', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/validators/list')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "at_ledger_state": null
  }'

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

Request Body

{
  "at_ledger_state": null
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "validators": {
    "total_count": 0,
    "next_cursor": "string",
    "items": [
      {
        "address": "string",
        "stake_vault": {
          "balance": "string",
          "last_changed_at_state_version": 0,
          "address": "string"
        },
        "pending_xrd_withdraw_vault": {
          "balance": "string",
          "last_changed_at_state_version": 0,
          "address": "string"
        },
        "locked_owner_stake_unit_vault": {
          "balance": "string",
          "last_changed_at_state_version": 0,
          "address": "string"
        },
        "pending_owner_stake_unit_unlock_vault": {
          "balance": "string",
          "last_changed_at_state_version": 0,
          "address": "string"
        },
        "state": {},
        "active_in_epoch": {
          "stake": "string",
          "stake_percentage": 0,
          "key": {
            "key_type": "EcdsaSecp256k1"
          }
        },
        "metadata": {
          "total_count": 0,
          "next_cursor": "string",
          "items": [
            {
              "key": "string",
              "value": {
                "raw_hex": "string",
                "programmatic_json": {
                  "kind": "Bool",
                  "type_name": "string",
                  "field_name": "string"
                },
                "typed": {
                  "type": "String"
                }
              },
              "is_locked": true,
              "last_updated_at_state_version": 1
            }
          ]
        },
        "effective_fee_factor": {
          "current": {
            "fee_factor": "string"
          },
          "pending": {
            "fee_factor": "string",
            "effective_at_epoch": 0
          }
        }
      }
    ]
  }
}

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

Get Account resource preferences

POST

https://xrd-gateway.nownodes.io/state/account/page/resource-preferences

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns paginable collection of resource preference rules for given account.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

account_addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

Account resource preferences page

4XX

Client-originated request error

Get Account resource preferences

curl -X POST 'https://xrd-gateway.nownodes.io/state/account/page/resource-preferences' \
  -H 'Content-Type: application/json' \
  -d '{
    "account_address": null
  }'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/account/page/resource-preferences')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_address": null
  }'

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

import requests

payload = {
  "account_address": None
}

response = requests.post('https://xrd-gateway.nownodes.io/state/account/page/resource-preferences', json=payload)
data = response.json()

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

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/account/page/resource-preferences";
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({
    "account_address": null
  });
console.log(result);

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

const data = await response.json();

import requests

payload = {
  "account_address": None
}

response = requests.post('https://xrd-gateway.nownodes.io/state/account/page/resource-preferences', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/account/page/resource-preferences')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_address": null
  }'

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

Request Body

{
  "account_address": null
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "resource_address": "string",
      "resource_preference_rule": "Allowed",
      "last_updated_at_state_version": 1
    }
  ],
  "account_address": "string"
}

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

Get Account authorized depositors

POST

https://xrd-gateway.nownodes.io/state/account/page/authorized-depositors

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns paginable collection of authorized depositors for given account.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

account_addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

Account resource preferences page

4XX

Client-originated request error

Get Account authorized depositors

curl -X POST 'https://xrd-gateway.nownodes.io/state/account/page/authorized-depositors' \
  -H 'Content-Type: application/json' \
  -d '{
    "account_address": null
  }'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/account/page/authorized-depositors')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_address": null
  }'

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

import requests

payload = {
  "account_address": None
}

response = requests.post('https://xrd-gateway.nownodes.io/state/account/page/authorized-depositors', json=payload)
data = response.json()

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

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/account/page/authorized-depositors";
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({
    "account_address": null
  });
console.log(result);

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

const data = await response.json();

import requests

payload = {
  "account_address": None
}

response = requests.post('https://xrd-gateway.nownodes.io/state/account/page/authorized-depositors', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/account/page/authorized-depositors')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_address": null
  }'

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

Request Body

{
  "account_address": null
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "badge_type": "ResourceBadge"
    }
  ],
  "account_address": "string"
}

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

Get Package Blueprints Page

POST

https://xrd-gateway.nownodes.io/state/package/page/blueprints

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all the blueprints associated with a given package entity. The returned response is in a paginated format, ordered by first appearance on the ledger.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

package_addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

Package Blueprints (paginated)

4XX

Client-originated request error

Get Package Blueprints Page

curl -X POST 'https://xrd-gateway.nownodes.io/state/package/page/blueprints' \
  -H 'Content-Type: application/json' \
  -d '{
    "package_address": "<package-address>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/package/page/blueprints', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "package_address": "<package-address>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/package/page/blueprints')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "package_address": "<package-address>"
  }'

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

import requests

payload = {
  "package_address": "<package-address>"
}

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

const response = await fetch('https://xrd-gateway.nownodes.io/state/package/page/blueprints', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "package_address": "<package-address>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/package/page/blueprints";
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({
    "package_address": "<package-address>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/package/page/blueprints', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "package_address": "<package-address>"
    }),
});

const data = await response.json();

import requests

payload = {
  "package_address": "<package-address>"
}

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/package/page/blueprints')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "package_address": "<package-address>"
  }'

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

Request Body

{
  "package_address": "<package-address>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "name": "string",
      "version": "string",
      "definition": {},
      "dependant_entities": [
        "string"
      ],
      "auth_template": {},
      "auth_template_is_locked": true,
      "royalty_config": {
        "is_enabled": true,
        "method_rules": [
          {
            "method_name": "string",
            "royalty_amount": {
              "amount": "string",
              "unit": "XRD"
            }
          }
        ]
      },
      "royalty_config_is_locked": true
    }
  ],
  "package_address": "string"
}

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

Get Package Codes Page

POST

https://xrd-gateway.nownodes.io/state/package/page/codes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all the codes associated with a given package entity. The returned response is in a paginated format, ordered by first appearance on the ledger.

Body

application/json

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

cursorstring | null

This cursor allows forward pagination, by providing the cursor from the previous request.

limit_per_pageinteger | null

The page size requested.

package_addressAddressrequired

Bech32m-encoded human readable version of the address.

Response

200OK

Package Blueprints (paginated)

4XX

Client-originated request error

Get Package Codes Page

curl -X POST 'https://xrd-gateway.nownodes.io/state/package/page/codes' \
  -H 'Content-Type: application/json' \
  -d '{
    "package_address": "<package-address>"
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/state/package/page/codes', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "package_address": "<package-address>"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/package/page/codes')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "package_address": "<package-address>"
  }'

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

import requests

payload = {
  "package_address": "<package-address>"
}

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

const response = await fetch('https://xrd-gateway.nownodes.io/state/package/page/codes', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "package_address": "<package-address>"
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/state/package/page/codes";
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({
    "package_address": "<package-address>"
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/state/package/page/codes', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "package_address": "<package-address>"
    }),
});

const data = await response.json();

import requests

payload = {
  "package_address": "<package-address>"
}

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

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/state/package/page/codes')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "package_address": "<package-address>"
  }'

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

Request Body

{
  "package_address": "<package-address>"
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "total_count": 0,
  "next_cursor": "string",
  "items": [
    {
      "vm_type": "Native",
      "code_hash_hex": "string",
      "code_hex": "string"
    }
  ],
  "package_address": "string"
}

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

Statistics

Calculate particular statistics based on current or historic ledger state.

Get Validators Uptime

POST

https://xrd-gateway.nownodes.io/statistics/validators/uptime

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns validators uptime data for time range limited by from_state_version and at_state_version.

Body

application/json

For at_ledger_state and from_ledger_state you can use one of state_version, epoch, epoch and round, or timestamp, but then ongoing epoch will be selected and used for querying data. i.e for request with { "from_state_version" = { "state_version" = 100 }, "at_state_version" = { "state_version" = 300} } gateway api will check in which epoch transactions with state version 100 and 300 were and then use that as inclusive boundary for request.

defines upper boundary (inclusive) for queried data. i.e { "at_state_version" = {"epoch" = 10} }, will return data till 10 epoch.

at_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

defines lower boundary (inclusive) for queried data. i.e { "from_state_version" = {"epoch" = 10} }, will return data from epoch 10 till current max ledger tip.

from_ledger_stateLedgerStateSelector | null

Show child attributes

state_versioninteger<int64> | null[1, 100000000000000]

If provided, the latest ledger state lower than or equal to the given state version is returned.

timestampstring<date-time> | null

If provided, the latest ledger state lower than or equal to the given round timestamp is returned.

epochinteger<int64> | null[0, 10000000000]

If provided, the ledger state lower than or equal to the given epoch at round 0 is returned.

roundinteger<int64> | null[0, 10000000000]

If provided must be accompanied with epoch, the ledger state lower than or equal to the given epoch and round is returned.

validator_addressesArray<Address>

Response

200OK

Validators Uptime

4XX

Client-originated request error

Get Validators Uptime

curl -X POST 'https://xrd-gateway.nownodes.io/statistics/validators/uptime' \
  -H 'Content-Type: application/json' \
  -d '{
    "at_ledger_state": {
      "state_version": 1,
      "timestamp": "2024-01-15T09:30:00Z",
      "epoch": 0,
      "round": 0
    },
    "from_ledger_state": {
      "state_version": 1,
      "timestamp": "2024-01-15T09:30:00Z",
      "epoch": 0,
      "round": 0
    },
    "validator_addresses": [
      "string"
    ]
  }'

const response = await fetch('https://xrd-gateway.nownodes.io/statistics/validators/uptime', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "at_ledger_state": {
        "state_version": 1,
        "timestamp": "2024-01-15T09:30:00Z",
        "epoch": 0,
        "round": 0
      },
      "from_ledger_state": {
        "state_version": 1,
        "timestamp": "2024-01-15T09:30:00Z",
        "epoch": 0,
        "round": 0
      },
      "validator_addresses": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/statistics/validators/uptime')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "at_ledger_state": {
      "state_version": 1,
      "timestamp": "2024-01-15T09:30:00Z",
      "epoch": 0,
      "round": 0
    },
    "from_ledger_state": {
      "state_version": 1,
      "timestamp": "2024-01-15T09:30:00Z",
      "epoch": 0,
      "round": 0
    },
    "validator_addresses": [
      "string"
    ]
  }'

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

import requests

payload = {
  "at_ledger_state": {
    "state_version": 1,
    "timestamp": "2024-01-15T09:30:00Z",
    "epoch": 0,
    "round": 0
  },
  "from_ledger_state": {
    "state_version": 1,
    "timestamp": "2024-01-15T09:30:00Z",
    "epoch": 0,
    "round": 0
  },
  "validator_addresses": [
    "string"
  ]
}

response = requests.post('https://xrd-gateway.nownodes.io/statistics/validators/uptime', json=payload)
data = response.json()

const response = await fetch('https://xrd-gateway.nownodes.io/statistics/validators/uptime', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "at_ledger_state": {
        "state_version": 1,
        "timestamp": "2024-01-15T09:30:00Z",
        "epoch": 0,
        "round": 0
      },
      "from_ledger_state": {
        "state_version": 1,
        "timestamp": "2024-01-15T09:30:00Z",
        "epoch": 0,
        "round": 0
      },
      "validator_addresses": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://xrd-gateway.nownodes.io/statistics/validators/uptime";
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({
    "at_ledger_state": {
      "state_version": 1,
      "timestamp": "2024-01-15T09:30:00Z",
      "epoch": 0,
      "round": 0
    },
    "from_ledger_state": {
      "state_version": 1,
      "timestamp": "2024-01-15T09:30:00Z",
      "epoch": 0,
      "round": 0
    },
    "validator_addresses": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://xrd-gateway.nownodes.io/statistics/validators/uptime', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "at_ledger_state": {
        "state_version": 1,
        "timestamp": "2024-01-15T09:30:00Z",
        "epoch": 0,
        "round": 0
      },
      "from_ledger_state": {
        "state_version": 1,
        "timestamp": "2024-01-15T09:30:00Z",
        "epoch": 0,
        "round": 0
      },
      "validator_addresses": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "at_ledger_state": {
    "state_version": 1,
    "timestamp": "2024-01-15T09:30:00Z",
    "epoch": 0,
    "round": 0
  },
  "from_ledger_state": {
    "state_version": 1,
    "timestamp": "2024-01-15T09:30:00Z",
    "epoch": 0,
    "round": 0
  },
  "validator_addresses": [
    "string"
  ]
}

response = requests.post('https://xrd-gateway.nownodes.io/statistics/validators/uptime', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xrd-gateway.nownodes.io/statistics/validators/uptime')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "at_ledger_state": {
      "state_version": 1,
      "timestamp": "2024-01-15T09:30:00Z",
      "epoch": 0,
      "round": 0
    },
    "from_ledger_state": {
      "state_version": 1,
      "timestamp": "2024-01-15T09:30:00Z",
      "epoch": 0,
      "round": 0
    },
    "validator_addresses": [
      "string"
    ]
  }'

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

Request Body

{
  "at_ledger_state": {
    "state_version": 1,
    "timestamp": "2024-01-15T09:30:00Z",
    "epoch": 0,
    "round": 0
  },
  "from_ledger_state": {
    "state_version": 1,
    "timestamp": "2024-01-15T09:30:00Z",
    "epoch": 0,
    "round": 0
  },
  "validator_addresses": [
    "string"
  ]
}

{
  "ledger_state": {
    "network": "<network-name>",
    "state_version": 0,
    "proposer_round_timestamp": "string",
    "epoch": 0,
    "round": 0
  },
  "validators": {
    "items": [
      {
        "address": "string",
        "proposals_made": 0,
        "proposals_missed": 0,
        "epochs_active_in": 0
      }
    ]
  }
}

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

Documentation

How to migrate to NOWNodes

Authentication

Geteway

Status

Authorizations

Response

Authorizations

Response

Transaction

Authorizations

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Stream

Authorizations

Body

Response

State

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response