Substrate API Sidecar

v20.1.0

Base URL

https://ksm-playbook.nownodes.io

Substrate API Sidecar is a REST service that makes it easy to interact with blockchain nodes built using Substrate's FRAME framework.

Authentication

api-keyAuthapiKey

API Key: api-key in header

NODE

accounts

Get an array of asset-balances for an account.

GET

https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about an account's asset-balances. This is specific to the assets pallet for parachains. If no assets query parameter is provided, all asset-balances for the given account will be returned.

Parameters

accountIdstring<SS58>requiredpath

SS58 address of the account.

atstring<unsignedInteger or $hex>query

Block at which to query asset-balance info for the specified account.

assetsArray<string><Array of unsignedInteger's>query

An array of AssetId's to be queried. If not supplied, defaults to providing all asset balances associated with the accountId will be returned. The array query param format follows Express 4.x API. ex:?assets[]=1&assets[]=2&assets[]=3.

Response

200OK

successfull operation

400Bad Request

Invalid Address

Get an array of asset-balances for an account.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-balances'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-balances', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-balances')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-balances')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-balances', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-balances";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{accountId}/asset-balances', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-balances')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-balances')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "assets": [
    {
      "assetId": "string",
      "balance": "string",
      "isFrozen": true,
      "isSufficient": true
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get an asset approval for an account.

GET

https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-approvals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about an account's asset approval transaction. It is required to pass in a delegate and an assetId as query parameters.

Parameters

accountIdstring<SS58>requiredpath

SS58 address of the account.

atstring<unsignedInteger or $hex>query

Block at which to query asset approval info for the specified account.

assetIdstring<unsignedInteger>requiredquery

The assetId associated with the asset-approval.

delegatestring<SS58>requiredquery

The delegate's accountId associated with an asset-approval.

Response

200OK

successfull operation

400Bad Request

Invalid Address

Get an asset approval for an account.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-approvals'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-approvals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-approvals')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-approvals')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-approvals', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-approvals";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{accountId}/asset-approvals', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-approvals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/asset-approvals')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "amount": "string",
  "deposit": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get balance information for an account.

GET

https://ksm-playbook.nownodes.io/accounts/{accountId}/balance-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about an account's balance. Replaces /balance/{address} from versions < v1.0.0.

Parameters

accountIdstring<SS58>requiredpath

SS58 address of the account.

atstring<unsignedInteger or $hex>query

Block at which to query balance info for the specified account.

tokenstringquery

Token to query the balance of. If not specified it will query the chains native token (e.g. DOT for Polkadot). Note: this is only relevant for chains that support multiple tokens through the ORML tokens pallet.

denominatedbooleanfalsequery

When set to true it will denominate any balance's given atomic value using the chains given decimal value.

Response

200OK

successful operation

400Bad Request

Invalid Address

404Not Found

account not found

Get balance information for an account.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{accountId}/balance-info'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/balance-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/balance-info')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/balance-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/balance-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{accountId}/balance-info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{accountId}/balance-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/balance-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/balance-info')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "nonce": "string",
  "tokenSymbol": "string",
  "free": "string",
  "reserved": "string",
  "miscFrozen": "string",
  "feeFrozen": "string",
  "frozen": "string",
  "locks": [
    {
      "id": "string",
      "amount": "string",
      "reasons": "Fee = 0"
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Convert a given AccountId to an SS58 address.

GET

https://ksm-playbook.nownodes.io/accounts/{accountId}/convert

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the SS58 prefix, the network address format, the SS58 address, and the AccountId that was given as input parameter, the scheme that was used and if it is a public key or not (boolean).

Parameters

accountIdstring<AccountId or Hex>requiredpath

AccountId or Public Key (hex).

schemestring<string>sr25519query

The cryptographic scheme to be used in order to convert the AccountId to an SS58 address. It can take one of three values [sr25519, ed25519, ecdsa]. The default scheme that is used is sr25519 (if it is not set in the query parameter).

prefixstring<number>42query

The address prefix which can be one of the values found in the SS58-registry.

publicKeystring<boolean>truequery

Defines if the given value in the path parameter is a Public Key (hex) or not (hence AccountId).

Response

200OK

successfully converted the AccountId and retrieved the address info.

400Bad Request

Invalid AccountId

404Not Found

AccountId not found

Convert a given AccountId to an SS58 address.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{accountId}/convert'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/convert', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/convert')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/convert')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/convert', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{accountId}/convert";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{accountId}/convert', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/convert')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/convert')
request = Net::HTTP::Get.new(uri)

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

{
  "ss58Prefix": "string",
  "network": "string",
  "address": "string",
  "accountId": "string",
  "scheme": "string",
  "publicKey": true
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get an array of pool-asset-balances for an account.

GET

https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about an account's pool-asset-balances. This is specific to the pool assets pallet for parachains. If no assets query parameter is provided, all pool-asset-balances for the given account will be returned.

Parameters

accountIdstring<SS58>requiredpath

SS58 address of the account.

atstring<unsignedInteger or $hex>query

Block at which to query pool-asset-balance info for the specified account.

assetsArray<string><Array of unsignedInteger's>query

Response

200OK

successfull operation

400Bad Request

Invalid Address

Get an array of pool-asset-balances for an account.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-balances'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-balances', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-balances')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-balances')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-balances', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-balances";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-balances', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-balances')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-balances')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "poolAssets": [
    {
      "assetId": "string",
      "balance": "string",
      "isFrozen": true,
      "isSufficient": true
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get an asset approval for an account.

GET

https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-approvals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about an account's asset approval transaction. It is required to pass in a delegate and an assetId as query parameters.

Parameters

accountIdstring<SS58>requiredpath

SS58 address of the account.

atstring<unsignedInteger or $hex>query

Block at which to query asset approval info for the specified account.

assetIdstring<unsignedInteger>requiredquery

The assetId associated with the asset-approval.

delegatestring<SS58>requiredquery

The delegate's accountId associated with an asset-approval.

Response

200OK

successfull operation

400Bad Request

Invalid Address

Get an asset approval for an account.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-approvals'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-approvals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-approvals')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-approvals')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-approvals', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-approvals";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-approvals', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-approvals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/pool-asset-approvals')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "amount": "string",
  "deposit": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get proxy account information.

GET

https://ksm-playbook.nownodes.io/accounts/{accountId}/proxy-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about a proxy account. This will include delegated accounts and deposits held.

Parameters

accountIdstring<SS58>requiredpath

SS58 address of the account.

atstring<unsignedInteger or $hex>query

Block at which to query proxy info for the specified account.

Response

200OK

successfull operation

400Bad Request

Invalid Address

Get proxy account information.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{accountId}/proxy-info'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/proxy-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/proxy-info')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/proxy-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/proxy-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{accountId}/proxy-info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{accountId}/proxy-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/proxy-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/proxy-info')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "delegatedAccounts": [
    {
      "delegate": "string",
      "delay": "string",
      "proxyType": "string"
    }
  ],
  "depositHeld": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get vesting information for an account.

GET

https://ksm-playbook.nownodes.io/accounts/{accountId}/vesting-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the vesting schedule for an account. Replaces /vesting/{address} from versions < v1.0.0.

Parameters

accountIdstring<SS58>requiredpath

SS58 address of the account.

atstring<unsignedInteger or $hex>query

Block at which to query the vesting info for the specified account.

Response

200OK

successful operation

400Bad Request

Invalid Address

404Not Found

account not found

Get vesting information for an account.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{accountId}/vesting-info'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/vesting-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/vesting-info')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/vesting-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/vesting-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{accountId}/vesting-info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{accountId}/vesting-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/vesting-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/vesting-info')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "vesting": [
    {
      "locked": "string",
      "perBlock": "string",
      "startingBlock": "string"
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Validate a given address.

GET

https://ksm-playbook.nownodes.io/accounts/{address}/validate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns whether the given address is valid ss58 format, the ss58 prefix if the address has one, the network address format, and what the account ID is for this address.

Parameters

addressstring<SS58 or Hex>requiredpath

SS58 or Hex address of the account.

Response

200OK

successfully retrieved address info

Validate a given address.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{address}/validate'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{address}/validate', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{address}/validate')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{address}/validate')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{address}/validate', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{address}/validate";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{address}/validate', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{address}/validate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{address}/validate')
request = Net::HTTP::Get.new(uri)

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

200

{
  "isValid": true,
  "ss58Prefix": "string",
  "network": "string",
  "accountId": "string"
}

Compares up to 30 SS58 addresses.

GET

https://ksm-playbook.nownodes.io/accounts/compare

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns if the given addresses are equal or not, along with details of each address. Equality is determined by comparing the accountId/publicKey of each address.

Parameters

addressesArray<string>requiredquery

An array or a comma separated string of SS58 addresses. Provide up to 30 addresses using one of these formats ?addresses=...&addresses=... or ?addresses[]=...&addresses[]=... or ?addresses=...,....

Response

200OK

successfully compared at least two SS58 addresses.

400Bad Request

Invalid Address

Compares up to 30 SS58 addresses.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/compare'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/compare', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/compare')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/compare')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/compare', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/compare";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/compare', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/compare')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/compare')
request = Net::HTTP::Get.new(uri)

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

{
  "areEqual": true,
  "addresses": [
    {
      "ss58Format": "string",
      "ss58Prefix": "string",
      "network": "string",
      "publicKey": "string"
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

blocks

Get a range of blocks by their height.

GET

https://ksm-playbook.nownodes.io/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a range query parameter return an array of all the blocks within that range.

Parameters

rangestringrequiredquery

A range of integers. There is a max limit of 500 blocks per request.

eventDocsbooleanfalsequery

When set to true, every event will have an extra docs property with a string of the events documentation.

extrinsicDocsbooleanfalsequery

When set to true, every extrinsic will have an extra docs property with a string of the extrinsics documentation.

noFeesbooleanfalsequery

When set to true, the fee won't be calculated for the extrinsics.

Response

200OK

successful operation

400Bad Request

invalid Block identifier supplied

Get a range of blocks by their height.

curl -X GET 'https://ksm-playbook.nownodes.io/blocks'

const response = await fetch('https://ksm-playbook.nownodes.io/blocks', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/blocks')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/blocks', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/blocks";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/blocks', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/blocks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "number": "string",
    "hash": "string",
    "parentHash": "string",
    "stateRoot": "string",
    "extrinsicRoot": "string",
    "authorId": "string",
    "logs": [
      {
        "type": "string",
        "index": "string",
        "value": [
          "string"
        ]
      }
    ],
    "onInitialize": {
      "events": [
        {
          "method": "string",
          "data": [
            "string"
          ]
        }
      ]
    },
    "extrinsics": [
      {
        "method": {
          "pallet": "string",
          "method": "string"
        },
        "signature": {
          "signature": "string",
          "signer": "string"
        },
        "nonce": "string",
        "args": {},
        "tip": "string",
        "hash": "string",
        "info": {
          "weight": {
            "refTime": "string",
            "proofSize": "string"
          },
          "class": "Normal",
          "partialFee": "string",
          "kind": "string"
        },
        "era": "{\"mortalEra\":[\"64\", \"11\"]}",
        "events": [
          {
            "method": "string",
            "data": [
              "string"
            ]
          }
        ],
        "success": true,
        "paysFee": true
      }
    ],
    "onFinalize": {
      "events": [
        {
          "method": "string",
          "data": [
            "string"
          ]
        }
      ]
    },
    "finalized": true
  }
]

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get a block by its height or hash.

GET

https://ksm-playbook.nownodes.io/blocks/{blockId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a single block. BlockId can either be a block hash or a block height. Replaces /block/{number} from versions < v1.0.0.

Parameters

blockIdstringrequiredpath

Block identifier, as the block height or block hash.

eventDocsbooleanfalsequery

When set to true, every event will have an extra docs property with a string of the events documentation.

extrinsicDocsbooleanfalsequery

When set to true, every extrinsic will have an extra docs property with a string of the extrinsics documentation.

noFeesbooleanfalsequery

When set to true, the fee won't be calculated for the extrinsics.

finalizedKeybooleanquery

When set to false, this will override the chain-config, and omit the finalized key in the response. This can increase performance slightly by avoiding an additional RPC call to the node.

decodedXcmMsgsbooleanfalsequery

When set to true, this will show the decoded XCM messages within the extrinsics of the requested block.

paraIdstringquery

When it is set, this will return only the decoded XCM messages for the specified origin Parachain Id (originParaId). To activate this functionality, ensure that the decodedXcmMsgs parameter is set to true.

Response

200OK

successful operation

400Bad Request

invalid Block identifier supplied

Get a block by its height or hash.

curl -X GET 'https://ksm-playbook.nownodes.io/blocks/{blockId}'

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/{blockId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/{blockId}')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/blocks/{blockId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/{blockId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/blocks/{blockId}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/blocks/{blockId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/blocks/{blockId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/{blockId}')
request = Net::HTTP::Get.new(uri)

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

{
  "number": "string",
  "hash": "string",
  "parentHash": "string",
  "stateRoot": "string",
  "extrinsicRoot": "string",
  "authorId": "string",
  "logs": [
    {
      "type": "string",
      "index": "string",
      "value": [
        "string"
      ]
    }
  ],
  "onInitialize": {
    "events": [
      {
        "method": "string",
        "data": [
          "string"
        ]
      }
    ]
  },
  "extrinsics": [
    {
      "method": {
        "pallet": "string",
        "method": "string"
      },
      "signature": {
        "signature": "string",
        "signer": "string"
      },
      "nonce": "string",
      "args": {},
      "tip": "string",
      "hash": "string",
      "info": {
        "weight": {
          "refTime": "string",
          "proofSize": "string"
        },
        "class": "Normal",
        "partialFee": "string",
        "kind": "string"
      },
      "era": "{\"mortalEra\":[\"64\", \"11\"]}",
      "events": [
        {
          "method": "string",
          "data": [
            "string"
          ]
        }
      ],
      "success": true,
      "paysFee": true
    }
  ],
  "onFinalize": {
    "events": [
      {
        "method": "string",
        "data": [
          "string"
        ]
      }
    ]
  },
  "finalized": true,
  "decodedXcmMsgs": {
    "horizontalMessages": [
      {
        "originParaId": "string",
        "destinationParaId": "string",
        "data": {}
      }
    ],
    "downwardMessages": [
      {
        "sentAt": "string",
        "msg": "string",
        "data": {}
      }
    ],
    "upwardMessages": [
      {
        "originParaId": "string",
        "data": {}
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get a block's header by its height or hash.

GET

https://ksm-playbook.nownodes.io/blocks/{blockId}/header

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a single block's header. BlockId can either be a block hash or a block height.

Parameters

blockIdstringrequiredpath

Block identifier, as the block height or block hash.

Response

200OK

successful operation

400Bad Request

invalid Block identifier supplied

Get a block's header by its height or hash.

curl -X GET 'https://ksm-playbook.nownodes.io/blocks/{blockId}/header'

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/{blockId}/header', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/{blockId}/header')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/blocks/{blockId}/header')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/{blockId}/header', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/blocks/{blockId}/header";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/blocks/{blockId}/header', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/blocks/{blockId}/header')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/{blockId}/header')
request = Net::HTTP::Get.new(uri)

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

{
  "parentHash": "string",
  "number": "string",
  "stateRoot": "string",
  "extrinsicRoot": "string",
  "digest": {
    "logs": [
      {
        "type": "string",
        "index": "string",
        "value": [
          "string"
        ]
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get an extrinsic by its extrinsicIndex and block height or hash. The pair blockId, extrinsicIndex is sometimes referred to as a Timepoint.

GET

https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics/{extrinsicIndex}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a single extrinsic.

Parameters

blockIdstringrequiredpath

Block identifier, as the block height or block hash.

extrinsicIndexstringrequiredpath

The extrinsic's index within the block's body.

eventDocsbooleanfalsequery

When set to true, every event will have an extra docs property with a string of the events documentation.

extrinsicDocsbooleanfalsequery

When set to true, every extrinsic will have an extra docs property with a string of the extrinsics documentation.

Response

200OK

successful operation

400Bad Request

Requested extrinsicIndex does not exist

Get an extrinsic by its extrinsicIndex and block height or hash. The pair blockId, extrinsicIndex is sometimes referred to as a Timepoint.

curl -X GET 'https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics/{extrinsicIndex}'

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics/{extrinsicIndex}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics/{extrinsicIndex}')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics/{extrinsicIndex}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics/{extrinsicIndex}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics/{extrinsicIndex}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics/{extrinsicIndex}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics/{extrinsicIndex}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics/{extrinsicIndex}')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "extrinsic": {
    "method": {
      "pallet": "string",
      "method": "string"
    },
    "signature": {
      "signature": "string",
      "signer": "string"
    },
    "nonce": "string",
    "args": {},
    "tip": "string",
    "hash": "string",
    "info": {
      "weight": {
        "refTime": "string",
        "proofSize": "string"
      },
      "class": "Normal",
      "partialFee": "string",
      "kind": "string"
    },
    "era": "{\"mortalEra\":[\"64\", \"11\"]}",
    "events": [
      {
        "method": "string",
        "data": [
          "string"
        ]
      }
    ],
    "success": true,
    "paysFee": true
  }
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get the most recently finalized block.

GET

https://ksm-playbook.nownodes.io/blocks/head

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the most recently finalized block. Replaces /block from versions < v1.0.0.

Parameters

finalizedbooleantruequery

Boolean representing whether or not to get the finalized head. If it is not set the value defaults to true. When set to false it will attempt to get the newest known block, which may not be finalized.

eventDocsbooleanfalsequery

When set to true, every event will have an extra docs property with a string of the events documentation.

extrinsicDocsbooleanfalsequery

When set to true, every extrinsic will have an extra docs property with a string of the extrinsics documentation.

noFeesbooleanfalsequery

When set to true, the fee won't be calculated for the extrinsics.

decodedXcmMsgsbooleanfalsequery

When set to true, this will show the decoded XCM messages within the extrinsics of the requested block.

paraIdstringquery

Response

200OK

successful operation

Get the most recently finalized block.

curl -X GET 'https://ksm-playbook.nownodes.io/blocks/head'

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/head', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/head')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/blocks/head')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/head', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/blocks/head";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/blocks/head', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/blocks/head')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/head')
request = Net::HTTP::Get.new(uri)

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

200

{
  "number": "string",
  "hash": "string",
  "parentHash": "string",
  "stateRoot": "string",
  "extrinsicRoot": "string",
  "authorId": "string",
  "logs": [
    {
      "type": "string",
      "index": "string",
      "value": [
        "string"
      ]
    }
  ],
  "onInitialize": {
    "events": [
      {
        "method": "string",
        "data": [
          "string"
        ]
      }
    ]
  },
  "extrinsics": [
    {
      "method": {
        "pallet": "string",
        "method": "string"
      },
      "signature": {
        "signature": "string",
        "signer": "string"
      },
      "nonce": "string",
      "args": {},
      "tip": "string",
      "hash": "string",
      "info": {
        "weight": {
          "refTime": "string",
          "proofSize": "string"
        },
        "class": "Normal",
        "partialFee": "string",
        "kind": "string"
      },
      "era": "{\"mortalEra\":[\"64\", \"11\"]}",
      "events": [
        {
          "method": "string",
          "data": [
            "string"
          ]
        }
      ],
      "success": true,
      "paysFee": true
    }
  ],
  "onFinalize": {
    "events": [
      {
        "method": "string",
        "data": [
          "string"
        ]
      }
    ]
  },
  "finalized": true,
  "decodedXcmMsgs": {
    "horizontalMessages": [
      {
        "originParaId": "string",
        "destinationParaId": "string",
        "data": {}
      }
    ],
    "downwardMessages": [
      {
        "sentAt": "string",
        "msg": "string",
        "data": {}
      }
    ],
    "upwardMessages": [
      {
        "originParaId": "string",
        "data": {}
      }
    ]
  }
}

Get information about the header of the most recent finalized block.

GET

https://ksm-playbook.nownodes.io/blocks/head/header

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the most recently finalized block's header.

Parameters

finalizedbooleantruequery

Response

200OK

successful operation

400Bad Request

invalid Block identifier supplied

Get information about the header of the most recent finalized block.

curl -X GET 'https://ksm-playbook.nownodes.io/blocks/head/header'

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/head/header', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/head/header')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/blocks/head/header')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/head/header', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/blocks/head/header";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/blocks/head/header', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/blocks/head/header')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/head/header')
request = Net::HTTP::Get.new(uri)

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

{
  "parentHash": "string",
  "number": "string",
  "stateRoot": "string",
  "extrinsicRoot": "string",
  "digest": {
    "logs": [
      {
        "type": "string",
        "index": "string",
        "value": [
          "string"
        ]
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get a blocks header & its extrinsics as hex values.

GET

https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics-raw

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a block & its extrinsics as hex values. BlockId can either be a block hash or a block height.

Parameters

blockIdstringrequiredpath

Block identifier, as the block height or block hash.

Response

200OK

successful operation

400Bad Request

invalid Block identifier supplied

Get a blocks header & its extrinsics as hex values.

curl -X GET 'https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics-raw'

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics-raw', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics-raw')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics-raw')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics-raw', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics-raw";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics-raw', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics-raw')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/blocks/{blockId}/extrinsics-raw')
request = Net::HTTP::Get.new(uri)

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

{
  "number": "string",
  "parentHash": "string",
  "stateRoot": "string",
  "extrinsicRoot": "string",
  "digest": {
    "logs": [
      {
        "type": "string",
        "index": "string",
        "value": [
          "string"
        ]
      }
    ]
  },
  "extrinsics": [
    "string"
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

contracts

Query an !Ink contract with a given message (method).

POST

https://ksm-playbook.nownodes.io/contracts/ink/{address}/query

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Will return a valid or invalid result.

Body

application/json

Metadata used to instantiate a ContractPromise. This metadata can be generated by compiling the contract you are querying.

ContractMetadata

Parameters

addressstringrequiredpath

SS58 or Hex address of the account associated with the contract.

methodstringgetquery

The message or method used to query.

gasLimitnumber-1query

The gas limit to be used as an option for the queried message.

storageDepositLimitnumbernullquery

The storage deposit limit to be used as an option for the queried message.

argsArray<string>query

Abi params used as args specified in the metadata to be passed into a query. The format to use this query param is ?args[]=1&args[]=2&args[]=3.

Response

200OK

succesful operation

400Bad Request

Invalid Method

Query an !Ink contract with a given message (method).

curl -X POST 'https://ksm-playbook.nownodes.io/contracts/ink/{address}/query' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ksm-playbook.nownodes.io/contracts/ink/{address}/query', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/contracts/ink/{address}/query')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/contracts/ink/{address}/query', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/contracts/ink/{address}/query', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/contracts/ink/{address}/query";
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://ksm-playbook.nownodes.io/contracts/ink/{address}/query', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/contracts/ink/{address}/query', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/contracts/ink/{address}/query')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

{
  "debugMessage": "string",
  "gasConsumed": "string",
  "gasRequired": "string",
  "output": true,
  "result": {},
  "storageDeposit": {}
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

coretime

Get all the leases currently registered on coretime chain.

GET

https://ksm-playbook.nownodes.io/coretime/leases

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

blockIdstringquery

Block identifier, as the block height or block hash.

Response

200OK

successful operation

Get all the leases currently registered on coretime chain.

curl -X GET 'https://ksm-playbook.nownodes.io/coretime/leases'

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/leases', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/leases')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/coretime/leases')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/leases', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/coretime/leases";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/coretime/leases', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/coretime/leases')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/leases')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "leases": [
    {
      "task": "string",
      "until": "string",
      "core": "string"
    }
  ]
}

Get all the regions currently registered on coretime chain.

GET

https://ksm-playbook.nownodes.io/coretime/regions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

blockIdstringquery

Block identifier, as the block height or block hash.

Response

200OK

successful operation

Get all the regions currently registered on coretime chain.

curl -X GET 'https://ksm-playbook.nownodes.io/coretime/regions'

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/regions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/regions')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/coretime/regions')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/regions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/coretime/regions";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/coretime/regions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/coretime/regions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/regions')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "regions": [
    {
      "core": "string",
      "begin": "string",
      "end": "string",
      "owner": "string",
      "paid": "string",
      "mask": "string"
    }
  ]
}

Get all the potential renewals currently registered on coretime chain.

GET

https://ksm-playbook.nownodes.io/coretime/renewals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

blockIdstringquery

Block identifier, as the block height or block hash.

Response

200OK

successful operation

Get all the potential renewals currently registered on coretime chain.

curl -X GET 'https://ksm-playbook.nownodes.io/coretime/renewals'

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/renewals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/renewals')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/coretime/renewals')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/renewals', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/coretime/renewals";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/coretime/renewals', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/coretime/renewals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/renewals')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "renewals": [
    {
      "completion": "string",
      "core": "string",
      "mask": "string",
      "price": "string",
      "task": "string",
      "when": "string"
    }
  ]
}

Get all the reservations currently registered on coretime chain.

GET

https://ksm-playbook.nownodes.io/coretime/reservations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

blockIdstringquery

Block identifier, as the block height or block hash.

Response

200OK

successful operation

Get all the reservations currently registered on coretime chain.

curl -X GET 'https://ksm-playbook.nownodes.io/coretime/reservations'

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/reservations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/reservations')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/coretime/reservations')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/reservations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/coretime/reservations";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/coretime/reservations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/coretime/reservations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/reservations')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "reservations": [
    {
      "task": "string",
      "mask": "string"
    }
  ]
}

Get the generic information about coretime, either on coretime chain or relay chain.

GET

https://ksm-playbook.nownodes.io/coretime/info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

blockIdstringquery

Block identifier, as the block height or block hash.

Response

200OK

successful operation

Get the generic information about coretime, either on coretime chain or relay chain.

curl -X GET 'https://ksm-playbook.nownodes.io/coretime/info'

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/info')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/coretime/info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/coretime/info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/coretime/info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/coretime/info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "configuration": {
    "interludeLength": "string",
    "leadinLength": "string",
    "regionLength": "string",
    "relayBlocksPerTimeslice": "string"
  },
  "currentRegion": {
    "start": "string",
    "end": "string"
  },
  "cores": {
    "total": "string",
    "available": "string",
    "sold": "string",
    "currentCorePrice": "string",
    "selloutPrice": "string",
    "firstCore": "string"
  }
}

Get all the cores information either on coretime chain or relay chain.

GET

https://ksm-playbook.nownodes.io/coretime/overview

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

blockIdstringquery

Block identifier, as the block height or block hash.

Response

200OK

successful operation

Get all the cores information either on coretime chain or relay chain.

curl -X GET 'https://ksm-playbook.nownodes.io/coretime/overview'

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/overview', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/overview')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/coretime/overview')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/coretime/overview', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/coretime/overview";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/coretime/overview', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/coretime/overview')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/coretime/overview')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "cores": [
    {
      "coreId": "string",
      "paraId": "string",
      "workload": {
        "isPool": true,
        "isTask": true,
        "mask": "string",
        "task": "string"
      },
      "workplan": [
        {
          "core": "string",
          "timeslice": "string",
          "info": [
            {
              "isPool": true,
              "isTask": true,
              "mask": "string",
              "task": "string"
            }
          ]
        }
      ],
      "type": {
        "condition": "string",
        "details": "string"
      },
      "regions": [
        {
          "core": "string",
          "begin": "string",
          "end": "string",
          "owner": "string",
          "paid": "string",
          "mask": "string"
        }
      ]
    }
  ]
}

node

node connected to sidecar

Get information about the Substrate node's activity in the peer-to-peer network.

GET

https://ksm-playbook.nownodes.io/node/network

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns network related information of the node.

Response

200OK

successful operation

Get information about the Substrate node's activity in the peer-to-peer network.

curl -X GET 'https://ksm-playbook.nownodes.io/node/network'

const response = await fetch('https://ksm-playbook.nownodes.io/node/network', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/node/network')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/node/network')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/node/network', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/node/network";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/node/network', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/node/network')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/node/network')
request = Net::HTTP::Get.new(uri)

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

200

{
  "nodeRoles": "Full",
  "numPeers": "string",
  "isSyncing": true,
  "shouldHavePeers": true,
  "localPeerId": "string",
  "localListenAddresses": [
    "string"
  ],
  "peersInfo": [
    {
      "peerId": "string",
      "roles": "string",
      "protocolVersion": "string",
      "bestHash": "string",
      "bestNumber": "string"
    }
  ]
}

Get pending extrinsics from the Substrate node.

GET

https://ksm-playbook.nownodes.io/node/transaction-pool

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the extrinsics that the node knows of that have not been included in a block.

Parameters

includeFeebooleanfalsequery

Boolean representing whether or not to include tips, partialFee, and priority in each extrinsic.

Response

200OK

successful operation

Get pending extrinsics from the Substrate node.

curl -X GET 'https://ksm-playbook.nownodes.io/node/transaction-pool'

const response = await fetch('https://ksm-playbook.nownodes.io/node/transaction-pool', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/node/transaction-pool')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/node/transaction-pool')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/node/transaction-pool', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/node/transaction-pool";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/node/transaction-pool', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/node/transaction-pool')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/node/transaction-pool')
request = Net::HTTP::Get.new(uri)

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

200

{
  "pool": [
    {
      "hash": "string",
      "encodedExtrinsic": "string",
      "tip": "string",
      "priority": "string",
      "partialFee": "string"
    }
  ]
}

Get information about the Substrates node's implementation and versioning.

GET

https://ksm-playbook.nownodes.io/node/version

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns versioning information of the node.

Response

200OK

successful operation

Get information about the Substrates node's implementation and versioning.

curl -X GET 'https://ksm-playbook.nownodes.io/node/version'

const response = await fetch('https://ksm-playbook.nownodes.io/node/version', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/node/version')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/node/version')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/node/version', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/node/version";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/node/version', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/node/version')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/node/version')
request = Net::HTTP::Get.new(uri)

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

200

{
  "clientVersion": "string",
  "clientImplName": "string",
  "chain": "string"
}

pallets

pallets employed in the runtime

Get information and metadata associated with an asset.

GET

https://ksm-playbook.nownodes.io/pallets/assets/{assetId}/asset-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information associated with an asset which includes the assets AssetDetails and AssetMetadata.

Parameters

assetIdstring<unsignedInteger>requiredpath

The unsignedInteger Id of an asset.

atstring<unsignedInteger or $hex>query

Block at which to retrieve the assetInfo.

Response

200OK

successful operation

Get information and metadata associated with an asset.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/assets/{assetId}/asset-info'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/assets/{assetId}/asset-info')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/assets/{assetId}/asset-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/assets/{assetId}/asset-info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/assets/{assetId}/asset-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/assets/{assetId}/asset-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "assetInfo": {
    "owner": "string",
    "issuer": "string",
    "admin": "string",
    "freezer": "string",
    "supply": "string",
    "deposit": "string",
    "minBalance": "string",
    "isSufficient": true,
    "accounts": "string",
    "sufficients": "string",
    "approvals": "string",
    "status": "string"
  },
  "assetMetadata": {
    "deposit": "string",
    "name": "string",
    "symbol": "string",
    "decimals": "string",
    "isFrozen": true
  }
}

Get information related to existing liquidity pools.

GET

https://ksm-playbook.nownodes.io/pallets/asset-conversion/liquidity-pools

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of the existing liquidity pools and its corresponding tokens at a given block height. If no block is specified, it returns the latest list available.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the liquidity pools information.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

Get information related to existing liquidity pools.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/asset-conversion/liquidity-pools'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/asset-conversion/liquidity-pools', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/asset-conversion/liquidity-pools')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/asset-conversion/liquidity-pools')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/asset-conversion/liquidity-pools', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/asset-conversion/liquidity-pools";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/asset-conversion/liquidity-pools', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/asset-conversion/liquidity-pools')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/asset-conversion/liquidity-pools')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "pools": "[{\"reserves\":[{\"parents\":\"1\",\"interior\":{\"here\": null}},{\"parents\":\"0\",\"interior\":{\"x2\":[{\"palletInstance\": \"50\"},{\"generalIndex\":\"2\"}]}}],\"lpToken\":{\"lpToken\":\"1\"} },{\"lpToken\":{\"lpToken\":\"0\"}}]"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get the next available liquidity pool id.

GET

https://ksm-playbook.nownodes.io/pallets/asset-conversion/next-available-id

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the next available liquidity pool's id at a given block height. If no block is specified, it returns the latest list available.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the next liquidity pool's id.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

Get the next available liquidity pool id.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/asset-conversion/next-available-id'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/asset-conversion/next-available-id', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/asset-conversion/next-available-id')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/asset-conversion/next-available-id')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/asset-conversion/next-available-id', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/asset-conversion/next-available-id";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/asset-conversion/next-available-id', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/asset-conversion/next-available-id')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/asset-conversion/next-available-id')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "id": "4"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get information and metadata associated with foreign assets.

GET

https://ksm-playbook.nownodes.io/pallets/foreign-assets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information associated with every foreign asset which includes the assets AssetDetails and AssetMetadata.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the foreign assets.

Response

200OK

successful operation

Get information and metadata associated with foreign assets.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/foreign-assets'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/foreign-assets', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/foreign-assets')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/foreign-assets')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/foreign-assets', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/foreign-assets";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/foreign-assets', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/foreign-assets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/foreign-assets')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "items": [
    {
      "foreignAssetInfo": {
        "owner": "string",
        "issuer": "string",
        "admin": "string",
        "freezer": "string",
        "supply": "string",
        "deposit": "string",
        "minBalance": "string",
        "isSufficient": true,
        "accounts": "string",
        "sufficients": "string",
        "approvals": "string",
        "status": "string"
      },
      "foreignAssetMetadata": {
        "deposit": "string",
        "name": "string",
        "symbol": "string",
        "decimals": "string",
        "isFrozen": true
      }
    }
  ]
}

Get information associated with nomination pools.

GET

https://ksm-playbook.nownodes.io/pallets/nomination-pools/info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information and metadata for nomination pools including pool counters and limits.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the nomination pool info.

Response

200OK

successful operation

Get information associated with nomination pools.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/nomination-pools/info'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/nomination-pools/info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/nomination-pools/info')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/nomination-pools/info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/nomination-pools/info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/nomination-pools/info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/nomination-pools/info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/nomination-pools/info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/nomination-pools/info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "counterForBondedPools": 0,
  "counterForMetadata": 0,
  "counterForPoolMembers": 0,
  "counterForReversePoolIdLookup": 0,
  "counterForRewardPools": 0,
  "counterForSubPoolsStorage": 0,
  "lastPoolId": 0,
  "maxPoolMembers": 0,
  "maxPoolMembersPerPool": 0,
  "maxPools": 0,
  "minCreateBond": 0,
  "minJoinBond": 0
}

Get information and metadata associated with a nomination pool.

GET

https://ksm-playbook.nownodes.io/pallets/nomination-pools/{poolId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information associated with a nomination pool which includes the nomination pools' bondedPool, rewardPool and metadata.

Parameters

poolIdstring<unsignedInteger>requiredpath

The unsignedInteger Id of a nomination pool.

atstring<unsignedInteger or $hex>query

Block at which to retrieve the nomination pool.

Response

200OK

successful operation

Get information and metadata associated with a nomination pool.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/nomination-pools/{poolId}'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/nomination-pools/{poolId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/nomination-pools/{poolId}')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/nomination-pools/{poolId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/nomination-pools/{poolId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/nomination-pools/{poolId}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/nomination-pools/{poolId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/nomination-pools/{poolId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/nomination-pools/{poolId}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "bondedPool": {
    "points": 0,
    "state": "string",
    "memberCounter": 0,
    "roles": {
      "depositor": "string",
      "root": "string",
      "nominator": "string",
      "stateToggler": "string"
    }
  },
  "rewardPool": {
    "lastRecordedRewardCounter": 0,
    "lastRecordedTotalPayouts": 0,
    "totalRewardsClaimed": 0
  }
}

Get a list of all on-going referenda that have track `root (0)` and `whitelisted (1)`, along with their associated information.

GET

https://ksm-playbook.nownodes.io/pallets/on-going-referenda

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information associated with on-going referenda which includes the referendum's enactment, submitted and deciding fields.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the on-going referenda.

Response

200OK

successful operation

Get a list of all on-going referenda that have track `root (0)` and `whitelisted (1)`, along with their associated information.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/on-going-referenda'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/on-going-referenda', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/on-going-referenda')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/on-going-referenda')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/on-going-referenda', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/on-going-referenda";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/on-going-referenda', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/on-going-referenda')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/on-going-referenda')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "referenda": [
    {
      "id": "string",
      "decisionDeposit": {
        "who": "string",
        "amount": "string"
      },
      "enactment": "at",
      "submitted": "string",
      "deciding": {
        "since": "string",
        "confirming": "string"
      }
    }
  ]
}

Get a list of constants for a pallet.

GET

https://ksm-playbook.nownodes.io/pallets/{palletId}/consts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of const item metadata for constant items of the specified palletId.

Parameters

palletIdstringrequiredpath

Name or index of the pallet to read constant metadata for. Note: the pallet name must match what is specified in the runtime metadata.

onlyIdsbooleanquery

Only return the names (IDs) of the const items instead of every constant's metadata.

atstring<unsignedInteger or $hex>query

Block at which to retrieve a list of the pallet's constant items.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

could not find pallet with palletId

Get a list of constants for a pallet.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/{palletId}/consts'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/{palletId}/consts";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/{palletId}/consts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "pallet": "democracy",
  "palletIndex": "14",
  "items": [
    {
      "name": "VotingPeriod",
      "type": "4",
      "value": "0x00270600",
      "docs": "Information concerning any given constant.\n\n TWOX-NOTE: SAFE as indexes are not under an attacker’s control."
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get the value of a constant item.

GET

https://ksm-playbook.nownodes.io/pallets/{palletId}/consts/{constantItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the value stored under the constantItemId.

Parameters

palletIdstringrequiredpath

Name or index of the pallet to read constant metadata for. Note: the pallet name must match what is specified in the runtime metadata.

constantItemIdstringrequiredpath

Id of the const item to query for.

atstring<unsignedInteger or $hex>query

Block at which to query the const item at.

metadatabooleanfalsequery

Include the const items metadata (including documentation) if set to true.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

could not find resource with id

Get the value of a constant item.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/{palletId}/consts/{constantItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts/{constantItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts/{constantItemId}')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts/{constantItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts/{constantItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/{palletId}/consts/{constantItemId}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/{palletId}/consts/{constantItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts/{constantItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/consts/{constantItemId}')
request = Net::HTTP::Get.new(uri)

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

{
  "pallet": "democracy",
  "palletIndex": "14",
  "errorItem": "EnactmentPeriod",
  "metadata": {
    "name": "VotingPeriod",
    "type": "4",
    "value": "0x00270600",
    "docs": "Information concerning any given constant.\n\n TWOX-NOTE: SAFE as indexes are not under an attacker’s control."
  }
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get a list of dispatchables for a pallet.

GET

https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of dispatchable item metadata for distpachable items of the specified palletId.

Parameters

palletIdstringrequiredpath

Name or index of the pallet to read dispatchable metadata for. Note: the pallet name must match what is specified in the runtime metadata.

onlyIdsbooleanquery

Only return the names (IDs) of the dispatchable items instead of every dispatchable's metadata.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

could not find pallet with palletId

Get a list of dispatchables for a pallet.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "pallet": "democracy",
  "palletIndex": "14",
  "items": [
    {
      "name": "propose",
      "fields": [
        "string"
      ],
      "index": "0",
      "docs": "Information concerning any given dispatchable.\n\n TWOX-NOTE: SAFE as indexes are not under an attacker’s control.",
      "args": [
        "string"
      ]
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get the value of a dispatchable item.

GET

https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables/{dispatchableItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the value stored under the dispatchableItemId.

Parameters

palletIdstringrequiredpath

Name or index of the pallet to read dispatchable metadata for. Note: the pallet name must match what is specified in the runtime metadata.

dispatchableItemIdstringrequiredpath

Id of the dispatchable item to query for.

metadatabooleanfalsequery

Include the dispatchable items metadata (including documentation) if set to true.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

could not find resource with id

Get the value of a dispatchable item.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables/{dispatchableItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables/{dispatchableItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables/{dispatchableItemId}')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables/{dispatchableItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables/{dispatchableItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables/{dispatchableItemId}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables/{dispatchableItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables/{dispatchableItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/dispatchables/{dispatchableItemId}')
request = Net::HTTP::Get.new(uri)

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

{
  "pallet": "democracy",
  "palletIndex": "14",
  "dispatchableItem": "vote",
  "metadata": {
    "name": "propose",
    "fields": [
      "string"
    ],
    "index": "0",
    "docs": "Information concerning any given dispatchable.\n\n TWOX-NOTE: SAFE as indexes are not under an attacker’s control.",
    "args": [
      "string"
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get a list of errors for a pallet.

GET

https://ksm-playbook.nownodes.io/pallets/{palletId}/errors

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of error item metadata for error items of the specified palletId.

Parameters

palletIdstringrequiredpath

Name or index of the pallet to read error metadata for. Note: the pallet name must match what is specified in the runtime metadata.

onlyIdsbooleanquery

Only return the names (IDs) of the error items instead of every error's metadata.

atstring<unsignedInteger or $hex>query

Block at which to retrieve a list of the pallet's error items.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

could not find pallet with palletId

Get a list of errors for a pallet.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/{palletId}/errors'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/{palletId}/errors";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/{palletId}/errors', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "pallet": "democracy",
  "palletIndex": "14",
  "items": [
    {
      "name": "InsufficientFunds",
      "fields": [
        "string"
      ],
      "index": "0",
      "docs": " Information concerning any given error.\n\n TWOX-NOTE: SAFE as indexes are not under an attacker’s control.",
      "args": [
        "string"
      ]
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get the value of an error item.

GET

https://ksm-playbook.nownodes.io/pallets/{palletId}/errors/{errorItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the value stored under the errorItemId.

Parameters

palletIdstringrequiredpath

Name or index of the pallet to read error metadata for. Note: the pallet name must match what is specified in the runtime metadata.

errorItemIdstringrequiredpath

Id of the error item to query for.

atstring<unsignedInteger or $hex>query

Block at which to query the error item at.

metadatabooleanfalsequery

Include the error items metadata (including documentation) if set to true.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

could not find resource with id

Get the value of an error item.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/{palletId}/errors/{errorItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors/{errorItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors/{errorItemId}')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors/{errorItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors/{errorItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/{palletId}/errors/{errorItemId}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/{palletId}/errors/{errorItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors/{errorItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/errors/{errorItemId}')
request = Net::HTTP::Get.new(uri)

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

{
  "pallet": "democracy",
  "palletIndex": "14",
  "errorItem": "ValueLow",
  "metadata": {
    "name": "InsufficientFunds",
    "fields": [
      "string"
    ],
    "index": "0",
    "docs": " Information concerning any given error.\n\n TWOX-NOTE: SAFE as indexes are not under an attacker’s control.",
    "args": [
      "string"
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get a list of events for a pallet.

GET

https://ksm-playbook.nownodes.io/pallets/{palletId}/events

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of event item metadata for event items of the specified palletId.

Parameters

palletIdstringrequiredpath

Name or index of the pallet to read event metadata for. Note: the pallet name must match what is specified in the runtime metadata.

onlyIdsbooleanquery

Only return the names (IDs) of the event items instead of every event's metadata.

atstring<unsignedInteger or $hex>query

Block at which to retrieve a list of the pallet's event items.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

could not find pallet with palletId

Get a list of events for a pallet.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/{palletId}/events'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/events', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/events')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/events')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/events', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/{palletId}/events";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/{palletId}/events', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/events')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/events')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "pallet": "democracy",
  "palletIndex": "14",
  "items": [
    {
      "name": "Tabled",
      "fields": [
        "string"
      ],
      "index": "0",
      "docs": " Information concerning any given event.\n\n TWOX-NOTE: SAFE as indexes are not under an attacker’s control.",
      "args": [
        "string"
      ]
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get the value of an event item.

GET

https://ksm-playbook.nownodes.io/pallets/{palletId}/events/{eventItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the value stored under the eventItemId.

Parameters

palletIdstringrequiredpath

Name or index of the pallet to read event metadata for. Note: the pallet name must match what is specified in the runtime metadata.

eventItemIdstringrequiredpath

Id of the event item to query for.

atstring<unsignedInteger or $hex>query

Block at which to query the event item at.

metadatabooleanfalsequery

Include the event items metadata (including documentation) if set to true.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

could not find resource with id

Get the value of an event item.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/{palletId}/events/{eventItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/events/{eventItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/events/{eventItemId}')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/events/{eventItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/events/{eventItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/{palletId}/events/{eventItemId}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/{palletId}/events/{eventItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/events/{eventItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/events/{eventItemId}')
request = Net::HTTP::Get.new(uri)

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

{
  "pallet": "democracy",
  "palletIndex": "14",
  "eventItem": "Proposed",
  "metadata": {
    "name": "Tabled",
    "fields": [
      "string"
    ],
    "index": "0",
    "docs": " Information concerning any given event.\n\n TWOX-NOTE: SAFE as indexes are not under an attacker’s control.",
    "args": [
      "string"
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get a list of storage items for a pallet.

GET

https://ksm-playbook.nownodes.io/pallets/{palletId}/storage

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of storage item metadata for storage items of the specified palletId.

Parameters

palletIdstringrequiredpath

Name or index of the pallet to query the storage of. Note: the pallet name must match what is specified in the runtime metadata.

onlyIdsbooleanquery

Only return the names (IDs) of the storage items instead of all of each storage item's metadata.

atstring<unsignedInteger or $hex>query

Block at which to retrieve a list of the pallet's storage items.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

could not find pallet with palletId

Get a list of storage items for a pallet.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/{palletId}/storage'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/{palletId}/storage";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/{palletId}/storage', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage')
request = Net::HTTP::Get.new(uri)

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

{
  "pallet": "democracy",
  "palletIndex": "15",
  "items": [
    {
      "name": "ReferendumInfoOf",
      "modifier": "Optional",
      "type": {},
      "fallback": "0x00",
      "docs": " Information concerning any given referendum.\n\n TWOX-NOTE: SAFE as indexes are not under an attacker’s control."
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get the value of a storage item.

GET

https://ksm-playbook.nownodes.io/pallets/{palletId}/storage/{storageItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the value stored under the storageItemId. If it is a map, query param key1 is required. If the storage item is double map query params key1 and key2 are required.

Parameters

palletIdstringrequiredpath

Name or index of the pallet to query the storage of. Note: pallet name aligns with pallet name as specified in runtime metadata.

storageItemIdstringrequiredpath

Id of the storage item to query for.

keysArray<string>query

Set of N keys used for querying a storage map. It should be queried using the following format - ?keys[]=key1&keys[]=key2. Order matters, as it will determine the order the keys are passed into the storage calls.

atstring<unsignedInteger or $hex>query

Block at which to query the storage item at.

metadatabooleanfalsequery

Include the storage items metadata (including documentation) if set to true.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

could not find resource with id

Get the value of a storage item.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/{palletId}/storage/{storageItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage/{storageItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage/{storageItemId}')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage/{storageItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage/{storageItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/{palletId}/storage/{storageItemId}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/{palletId}/storage/{storageItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage/{storageItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/{palletId}/storage/{storageItemId}')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "pallet": "democracy",
  "palletIndex": "15",
  "storageItem": "referendumInfoOf",
  "keys": [
    "0x00",
    "0x01"
  ],
  "value": {
    "Ongoing": {
      "end": "1612800",
      "proposalHash": "0x7de70fc8be782076d0b5772be77153d172a5381c72dd56d3385e25f62abf507e",
      "threshold": "Supermajorityapproval",
      "delay": "403200",
      "tally": {
        "ayes": "41925212461400000",
        "nays": "214535586500000",
        "turnout": "34485320658000000"
      }
    }
  },
  "metadata": {
    "name": "ReferendumInfoOf",
    "modifier": "Optional",
    "type": {},
    "fallback": "0x00",
    "docs": " Information concerning any given referendum.\n\n TWOX-NOTE: SAFE as indexes are not under an attacker’s control."
  }
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get information and metadata associated with a pool asset.

GET

https://ksm-playbook.nownodes.io/pallets/pool-assets/{assetId}/asset-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information associated with a pool asset which includes the assets AssetDetails and AssetMetadata.

Parameters

assetIdstring<unsignedInteger>requiredpath

The unsignedInteger Id of a pool asset.

atstring<unsignedInteger or $hex>query

Block at which to retrieve the assetInfo.

Response

200OK

successful operation

Get information and metadata associated with a pool asset.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/pool-assets/{assetId}/asset-info'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/pool-assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/pool-assets/{assetId}/asset-info')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/pool-assets/{assetId}/asset-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/pool-assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/pool-assets/{assetId}/asset-info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/pool-assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/pool-assets/{assetId}/asset-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/pool-assets/{assetId}/asset-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "poolAssetInfo": {
    "owner": "string",
    "issuer": "string",
    "admin": "string",
    "freezer": "string",
    "supply": "string",
    "deposit": "string",
    "minBalance": "string",
    "isSufficient": true,
    "accounts": "string",
    "sufficients": "string",
    "approvals": "string",
    "status": "string"
  },
  "poolAssetMetadata": {
    "deposit": "string",
    "name": "string",
    "symbol": "string",
    "decimals": "string",
    "isFrozen": true
  }
}

Get progress on the general Staking pallet system.

GET

https://ksm-playbook.nownodes.io/pallets/staking/progress

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information on the progress of key components of the staking system and estimates of future points of interest. Replaces /staking-info from versions < v1.0.0.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve a staking progress report.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

Get progress on the general Staking pallet system.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/staking/progress'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/staking/progress')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/staking/progress')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/staking/progress";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/staking/progress')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/staking/progress')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "activeEra": "string",
  "forceEra": "ForceNone",
  "nextActiveEraEstimate": "string",
  "nextSessionEstimate": "string",
  "unappliedSlashes": [
    {
      "validator": "string",
      "own": "string",
      "others": [
        "string"
      ],
      "reporters": [
        "string"
      ],
      "payout": "string"
    }
  ],
  "electionStatus": {
    "status": {},
    "toggleEstimate": "string"
  },
  "idealValidatorCount": "string",
  "validatorSet": [
    "string"
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get all validators (active/waiting) of a specific chain.

GET

https://ksm-playbook.nownodes.io/pallets/staking/validators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all validators addresses and their corresponding status which can be either active or waiting. It will also return a list of active validators that will not be part of the next era for staking. They will be under the key "validatorsToBeChilled". It's important to note, that addresses can be present in both the "validators" key, and "validatorsToBeChilled".

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the list of validators.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

Get all validators (active/waiting) of a specific chain.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/staking/validators'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/staking/validators')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/staking/validators')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/staking/validators";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/staking/validators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/staking/validators')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "validators": [
    {
      "address": "string",
      "status": "string"
    }
  ],
  "validatorsToBeChilled": [
    {
      "address": "string",
      "status": "string"
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

runtime

Get the runtime metadata in decoded, JSON form.

GET

https://ksm-playbook.nownodes.io/runtime/metadata

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the runtime metadata as a JSON object. Substrate Reference: - FRAME Support: https://crates.parity.io/frame_support/metadata/index.html - Knowledge Base: https://substrate.dev/docs/en/knowledgebase/runtime/metadata

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the metadata at.

Response

200OK

successful operation

Get the runtime metadata in decoded, JSON form.

curl -X GET 'https://ksm-playbook.nownodes.io/runtime/metadata'

const response = await fetch('https://ksm-playbook.nownodes.io/runtime/metadata', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/runtime/metadata')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/runtime/metadata')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/runtime/metadata', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/runtime/metadata";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/runtime/metadata', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/runtime/metadata')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/runtime/metadata')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get the requested version of runtime metadata in decoded, JSON form.

GET

https://ksm-playbook.nownodes.io/runtime/metadata/{metadataVersion}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the requested version of runtime metadata as a JSON object. Substrate Reference: - FRAME Support: https://crates.parity.io/frame_support/metadata/index.html - Knowledge Base: https://substrate.dev/docs/en/knowledgebase/runtime/metadata

Parameters

metadataVersionstringrequiredpath

The version of metadata. The input is expected in a vX format, where X represents the version number (e.g. v14, v15).

atstring<unsignedInteger or $hex>query

Block at which to retrieve the metadata at.

Response

200OK

successful operation

Get the requested version of runtime metadata in decoded, JSON form.

curl -X GET 'https://ksm-playbook.nownodes.io/runtime/metadata/{metadataVersion}'

const response = await fetch('https://ksm-playbook.nownodes.io/runtime/metadata/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/runtime/metadata/{metadataVersion}')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/runtime/metadata/{metadataVersion}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/runtime/metadata/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/runtime/metadata/{metadataVersion}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/runtime/metadata/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/runtime/metadata/{metadataVersion}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/runtime/metadata/{metadataVersion}')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get the available versions of runtime metadata.

GET

https://ksm-playbook.nownodes.io/runtime/metadata/versions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the available versions of runtime metadata. Substrate Reference: - FRAME Support: https://crates.parity.io/frame_support/metadata/index.html - Knowledge Base: https://substrate.dev/docs/en/knowledgebase/runtime/metadata

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the metadata versions at.

Response

200OK

successful operation

Get the available versions of runtime metadata.

curl -X GET 'https://ksm-playbook.nownodes.io/runtime/metadata/versions'

const response = await fetch('https://ksm-playbook.nownodes.io/runtime/metadata/versions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/runtime/metadata/versions')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/runtime/metadata/versions')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/runtime/metadata/versions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/runtime/metadata/versions";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/runtime/metadata/versions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/runtime/metadata/versions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/runtime/metadata/versions')
request = Net::HTTP::Get.new(uri)

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

200

[
  "string"
]

Get the runtime wasm blob.

GET

https://ksm-playbook.nownodes.io/runtime/code

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the runtime Wasm blob in hex format.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the runtime wasm blob at.

Response

200OK

successful operation

Get the runtime wasm blob.

curl -X GET 'https://ksm-playbook.nownodes.io/runtime/code'

const response = await fetch('https://ksm-playbook.nownodes.io/runtime/code', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/runtime/code')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/runtime/code')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/runtime/code', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/runtime/code";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/runtime/code', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/runtime/code')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/runtime/code')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "code": "string"
}

Get version information of the Substrate runtime.

GET

https://ksm-playbook.nownodes.io/runtime/spec

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns version information related to the runtime.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve runtime version information at.

Response

200OK

successful operation

Get version information of the Substrate runtime.

curl -X GET 'https://ksm-playbook.nownodes.io/runtime/spec'

const response = await fetch('https://ksm-playbook.nownodes.io/runtime/spec', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/runtime/spec')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/runtime/spec')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/runtime/spec', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/runtime/spec";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/runtime/spec', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/runtime/spec')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/runtime/spec')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "authoringVersion": "string",
  "chainType": "{\"live\": null}",
  "implVersion": "string",
  "specName": "string",
  "specVersion": "string",
  "transactionVersion": "string",
  "properties": {}
}

transaction

Submit a transaction to the node's transaction pool.

POST

https://ksm-playbook.nownodes.io/transaction

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Accepts a valid signed extrinsic. Replaces /tx from versions < v1.0.0.

Body

application/json

txstring<hex>

Response

200OK

successful operation

400Bad Request

failed to parse or submit transaction

Submit a transaction to the node's transaction pool.

curl -X POST 'https://ksm-playbook.nownodes.io/transaction' \
  -H 'Content-Type: application/json' \
  -d '{
    "tx": "string"
  }'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

payload = {
  "tx": "string"
}

response = requests.post('https://ksm-playbook.nownodes.io/transaction', json=payload)
data = response.json()

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

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/transaction";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

payload = {
  "tx": "string"
}

response = requests.post('https://ksm-playbook.nownodes.io/transaction', json=payload)
data = response.json()

require 'net/http'
require 'json'

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

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

Request Body

{
  "tx": "string"
}

{
  "hash": "string"
}

{
  "code": 0,
  "error": "string",
  "transaction": "string",
  "cause": "string",
  "stack": "string"
}

Dry run an extrinsic.

POST

https://ksm-playbook.nownodes.io/transaction/dry-run

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Use the dryRun call to simulate the submission of a transaction without executing it so that you can check for potential errors and validate the expected outcome.

Body

application/json

atstring<unsignedInteger>

txstring<hex>

senderAddressstring<ss58>

Response

200OK

successful operation

400Bad Request

failed to dry-run transaction

Dry run an extrinsic.

curl -X POST 'https://ksm-playbook.nownodes.io/transaction/dry-run' \
  -H 'Content-Type: application/json' \
  -d '{
    "at": "string",
    "tx": "string",
    "senderAddress": "string"
  }'

const response = await fetch('https://ksm-playbook.nownodes.io/transaction/dry-run', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "at": "string",
      "tx": "string",
      "senderAddress": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/transaction/dry-run')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "at": "string",
    "tx": "string",
    "senderAddress": "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": "string",
  "tx": "string",
  "senderAddress": "string"
}

response = requests.post('https://ksm-playbook.nownodes.io/transaction/dry-run', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/transaction/dry-run', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "at": "string",
      "tx": "string",
      "senderAddress": "string"
    }),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/transaction/dry-run";
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": "string",
    "tx": "string",
    "senderAddress": "string"
  });
console.log(result);

const response = await fetch('https://ksm-playbook.nownodes.io/transaction/dry-run', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "at": "string",
      "tx": "string",
      "senderAddress": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "at": "string",
  "tx": "string",
  "senderAddress": "string"
}

response = requests.post('https://ksm-playbook.nownodes.io/transaction/dry-run', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/transaction/dry-run')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "at": "string",
    "tx": "string",
    "senderAddress": "string"
  }'

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

Request Body

{
  "at": "string",
  "tx": "string",
  "senderAddress": "string"
}

{
  "resultType": "DispatchOutcome",
  "result": {
    "actualWeight": "string",
    "paysFee": "string"
  }
}

{
  "code": 0,
  "error": "string",
  "transaction": "string",
  "cause": "string",
  "stack": "string"
}

Receive a fee estimate for a transaction.

POST

https://ksm-playbook.nownodes.io/transaction/fee-estimate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Send a serialized transaction and receive back a naive fee estimate. Note: partialFee does not include any tips that you may add to increase a transaction's priority. See the reference on compute_fee. Replaces /tx/fee-estimate from versions < v1.0.0. Substrate Reference: - RuntimeDispatchInfo: https://crates.parity.io/pallet_transaction_payment_rpc_runtime_api/struct.RuntimeDispatchInfo.html - query_info: https://crates.parity.io/pallet_transaction_payment/struct.Module.html#method.query_info - compute_fee: https://crates.parity.io/pallet_transaction_payment/struct.Module.html#method.compute_fee

Body

application/json

txstring<hex>

Response

200OK

successful operation

400Bad Request

fee estimation failure

Receive a fee estimate for a transaction.

curl -X POST 'https://ksm-playbook.nownodes.io/transaction/fee-estimate' \
  -H 'Content-Type: application/json' \
  -d '{
    "tx": "string"
  }'

const response = await fetch('https://ksm-playbook.nownodes.io/transaction/fee-estimate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "tx": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/transaction/fee-estimate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "tx": "string"
  }'

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

import requests

payload = {
  "tx": "string"
}

response = requests.post('https://ksm-playbook.nownodes.io/transaction/fee-estimate', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/transaction/fee-estimate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "tx": "string"
    }),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/transaction/fee-estimate";
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({
    "tx": "string"
  });
console.log(result);

const response = await fetch('https://ksm-playbook.nownodes.io/transaction/fee-estimate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "tx": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "tx": "string"
}

response = requests.post('https://ksm-playbook.nownodes.io/transaction/fee-estimate', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/transaction/fee-estimate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "tx": "string"
  }'

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

Request Body

{
  "tx": "string"
}

{
  "weight": {
    "refTime": "string",
    "proofSize": "string"
  },
  "class": "Normal",
  "partialFee": "string"
}

{
  "code": 0,
  "at": {
    "hash": "string"
  },
  "error": "string",
  "transaction": "string",
  "block": "string",
  "cause": "string",
  "stack": "string"
}

Get all the network information needed to construct a transaction offline.

GET

https://ksm-playbook.nownodes.io/transaction/material

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the material that is universal to constructing any signed transaction offline. Replaces /tx/artifacts from versions < v1.0.0.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the transaction construction material.

noMetabooleanfalsequery

DEPRECATED! This is no longer supported

metadatastringquery

Specifies the format of the metadata to be returned. Accepted values are 'json', and 'scale'. 'json' being the decoded metadata, and 'scale' being the SCALE encoded metadata. When metadata is not inputted, the metadata field will be absent.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

Get all the network information needed to construct a transaction offline.

curl -X GET 'https://ksm-playbook.nownodes.io/transaction/material'

const response = await fetch('https://ksm-playbook.nownodes.io/transaction/material', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/transaction/material')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/transaction/material')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/transaction/material', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/transaction/material";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/transaction/material', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/transaction/material')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/transaction/material')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "genesisHash": "string",
  "chainName": "string",
  "specName": "string",
  "specVersion": "string",
  "txVersion": "string",
  "metadata": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get all the network information needed to construct a transaction offline and the version of metadata specified in `metadataVersion`.

GET

https://ksm-playbook.nownodes.io/transaction/material/{metadataVersion}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all the materials necessary for constructing any signed transactions offline.

Parameters

metadataVersionstringrequiredpath

The version of metadata. The input is expected in a vX format, where X represents the version number (e.g. v14, v15). By default, metadata is outputted in 'json' format, unless the metadata query parameter is provided, in which case it can be either in 'json' or 'scale' format.

atstring<unsignedInteger or $hex>query

Block at which to retrieve the transaction construction material.

metadatastringquery

Specifies the format of the metadata to be returned. Accepted values are 'json', and 'scale'. 'json' being the decoded metadata, and 'scale' being the SCALE encoded metadata.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

Get all the network information needed to construct a transaction offline and the version of metadata specified in `metadataVersion`.

curl -X GET 'https://ksm-playbook.nownodes.io/transaction/material/{metadataVersion}'

const response = await fetch('https://ksm-playbook.nownodes.io/transaction/material/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/transaction/material/{metadataVersion}')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/transaction/material/{metadataVersion}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/transaction/material/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/transaction/material/{metadataVersion}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/transaction/material/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/transaction/material/{metadataVersion}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/transaction/material/{metadataVersion}')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "genesisHash": "string",
  "chainName": "string",
  "specName": "string",
  "specVersion": "string",
  "txVersion": "string",
  "metadata": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

paras

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] List all registered paras (parathreads & parachains).

GET

https://ksm-playbook.nownodes.io/paras

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all registered parachains and parathreads with lifecycle info.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve paras list at.

Response

200OK

successful operation

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] List all registered paras (parathreads & parachains).

curl -X GET 'https://ksm-playbook.nownodes.io/paras'

const response = await fetch('https://ksm-playbook.nownodes.io/paras', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/paras')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/paras', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/paras";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/paras', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/paras')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "paras": [
    {
      "paraId": "string",
      "paraLifecycle": "onboarding",
      "onboardingAs": "parachain"
    }
  ]
}

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get general information about the current lease period.

GET

https://ksm-playbook.nownodes.io/paras/leases/current

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an overview of the current lease period, including lease holders.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve current lease period info at.

currentLeaseHoldersbooleantruequery

Wether or not to include the currentLeaseHolders property. Inclusion of the property will likely result in a larger payload and increased response time.

Response

200OK

successful operation

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get general information about the current lease period.

curl -X GET 'https://ksm-playbook.nownodes.io/paras/leases/current'

const response = await fetch('https://ksm-playbook.nownodes.io/paras/leases/current', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/leases/current')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/paras/leases/current')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/paras/leases/current', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/paras/leases/current";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/paras/leases/current', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/paras/leases/current')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/leases/current')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "leasePeriodIndex": "string",
  "endOfLeasePeriod": "string",
  "currentLeaseHolders": [
    "string"
  ]
}

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get the status of the current auction.

GET

https://ksm-playbook.nownodes.io/paras/auctions/current

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an overview of the current auction. There is only one auction at a time. If there is no auction most fields will be null. If the current auction phase is in vrfDelay and you are looking to retrieve the latest winning bids, it is advised to query one block before finishEnd in the endingPeriod phase for that auction as there technically are no winners during the vrfDelay and thus the field is null.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve auction progress at.

Response

200OK

successful operation

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get the status of the current auction.

curl -X GET 'https://ksm-playbook.nownodes.io/paras/auctions/current'

const response = await fetch('https://ksm-playbook.nownodes.io/paras/auctions/current', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/auctions/current')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/paras/auctions/current')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/paras/auctions/current', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/paras/auctions/current";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/paras/auctions/current', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/paras/auctions/current')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/auctions/current')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "beginEnd": "string",
  "finishEnd": "string",
  "phase": "startPeriod",
  "auctionIndex": "string",
  "leasePeriods": [
    "string"
  ],
  "winning": [
    {
      "bid": {
        "accountId": "string",
        "paraId": "string",
        "amount": "string"
      },
      "leaseSet": [
        "string"
      ]
    }
  ]
}

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] List all stored crowdloans.

GET

https://ksm-playbook.nownodes.io/paras/crowdloans

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all the crowdloans and their associated paraIds.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the list of paraIds that have crowdloans at.

Response

200OK

successful operation

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] List all stored crowdloans.

curl -X GET 'https://ksm-playbook.nownodes.io/paras/crowdloans'

const response = await fetch('https://ksm-playbook.nownodes.io/paras/crowdloans', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/crowdloans')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/paras/crowdloans')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/paras/crowdloans', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/paras/crowdloans";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/paras/crowdloans', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/paras/crowdloans')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/crowdloans')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "funds": [
    {
      "paraId": "string",
      "fundInfo": {
        "depositor": "string",
        "verifier": "string",
        "deposit": "string",
        "raised": "string",
        "end": "string",
        "cap": "string",
        "lastConstribution": "preEnding",
        "firstPeriod": "string",
        "lastPeriod": "string",
        "trieIndex": "string"
      }
    }
  ]
}

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get crowdloan information for a `paraId`.

GET

https://ksm-playbook.nownodes.io/paras/{paraId}/crowdloan-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns crowdloan's fundInfo and the set of leasePeriods the crowdloan` covers.

Parameters

paraIdnumberrequiredpath

paraId to query the crowdloan information of.

atstring<unsignedInteger or $hex>query

Block at which to retrieve info at.

Response

200OK

successful operation

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get crowdloan information for a `paraId`.

curl -X GET 'https://ksm-playbook.nownodes.io/paras/{paraId}/crowdloan-info'

const response = await fetch('https://ksm-playbook.nownodes.io/paras/{paraId}/crowdloan-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/{paraId}/crowdloan-info')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/paras/{paraId}/crowdloan-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/paras/{paraId}/crowdloan-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/paras/{paraId}/crowdloan-info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/paras/{paraId}/crowdloan-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/paras/{paraId}/crowdloan-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/{paraId}/crowdloan-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "fundInfo": {
    "depositor": "string",
    "verifier": "string",
    "deposit": "string",
    "raised": "string",
    "end": "string",
    "cap": "string",
    "lastConstribution": "preEnding",
    "firstPeriod": "string",
    "lastPeriod": "string",
    "trieIndex": "string"
  },
  "leasePeriods": [
    "string"
  ]
}

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get current and future leases as well as the lifecycle stage for a given `paraId`.

GET

https://ksm-playbook.nownodes.io/paras/{paraId}/lease-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of leases that belong to the paraId as well as the paraId's current lifecycle stage.

Parameters

paraIdnumberrequiredpath

paraId to query the crowdloan information of.

atstring<unsignedInteger or $hex>query

Block at which to retrieve para's leases at.

Response

200OK

successful operation

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get current and future leases as well as the lifecycle stage for a given `paraId`.

curl -X GET 'https://ksm-playbook.nownodes.io/paras/{paraId}/lease-info'

const response = await fetch('https://ksm-playbook.nownodes.io/paras/{paraId}/lease-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/{paraId}/lease-info')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/paras/{paraId}/lease-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/paras/{paraId}/lease-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/paras/{paraId}/lease-info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/paras/{paraId}/lease-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/paras/{paraId}/lease-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/{paraId}/lease-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "paraLifecycle": "onboarding",
  "onboardingAs": "parachain",
  "leases": [
    {
      "leasePeriodIndex": "string",
      "account": "string",
      "deposit": "string"
    }
  ]
}

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get the heads of the included (backed and considered available) parachain candidates at the specified block height or at the most recent finalized head otherwise.

GET

https://ksm-playbook.nownodes.io/paras/head/included-candidates

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object with all the parachain id's as keys, and their headers as values.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve para's heads at.

Response

200OK

successful operation

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get the heads of the included (backed and considered available) parachain candidates at the specified block height or at the most recent finalized head otherwise.

curl -X GET 'https://ksm-playbook.nownodes.io/paras/head/included-candidates'

const response = await fetch('https://ksm-playbook.nownodes.io/paras/head/included-candidates', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/head/included-candidates')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/paras/head/included-candidates')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/paras/head/included-candidates', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/paras/head/included-candidates";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/paras/head/included-candidates', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/paras/head/included-candidates')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/head/included-candidates')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "paraId": {
    "hash": "string",
    "number": "string",
    "parentHash": "string",
    "stateRoot": "string",
    "extrinsicsRoot": "string",
    "digest": {
      "logs": [
        {
          "type": "string",
          "index": "string",
          "value": [
            "string"
          ]
        }
      ]
    }
  }
}

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get the heads of the backed parachain candidates at the specified block height or at the most recent finalized head otherwise.

GET

https://ksm-playbook.nownodes.io/paras/head/backed-candidates

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object with all the parachain id's as keys, and their headers as values.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve para's heads at.

Response

200OK

successful operation

[DEPRECATION NOTE: PHASED OUT ENDPOINT IN FAVOR OF CORETIME] Get the heads of the backed parachain candidates at the specified block height or at the most recent finalized head otherwise.

curl -X GET 'https://ksm-playbook.nownodes.io/paras/head/backed-candidates'

const response = await fetch('https://ksm-playbook.nownodes.io/paras/head/backed-candidates', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/head/backed-candidates')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/paras/head/backed-candidates')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/paras/head/backed-candidates', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/paras/head/backed-candidates";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/paras/head/backed-candidates', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/paras/head/backed-candidates')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/paras/head/backed-candidates')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "paraId": {
    "hash": "string",
    "number": "string",
    "parentHash": "string",
    "stateRoot": "string",
    "extrinsicsRoot": "string",
    "digest": {
      "logs": [
        {
          "type": "string",
          "index": "string",
          "value": [
            "string"
          ]
        }
      ]
    }
  }
}

trace

[Experimental - subject to breaking change.] Get traces for the most recently finalized block.

GET

https://ksm-playbook.nownodes.io/experimental/blocks/head/traces

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns traces (spans and events) of the most recently finalized block from RPC state_straceBlock. Consult the RPC docs for conceptual info.

Response

200OK

successful operation

[Experimental - subject to breaking change.] Get traces for the most recently finalized block.

curl -X GET 'https://ksm-playbook.nownodes.io/experimental/blocks/head/traces'

const response = await fetch('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/experimental/blocks/head/traces";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/experimental/blocks/head/traces', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "blockHash": "string",
  "events": [
    {
      "data": {
        "stringValues": {
          "key": "string",
          "method": "string",
          "result": "string"
        }
      },
      "parentId": "string",
      "target": "string"
    }
  ],
  "parentHash": "string",
  "spans": [
    {
      "id": "string",
      "name": "string",
      "parentId": "string",
      "target": "string",
      "wasm": true
    }
  ],
  "storageKeys": "string",
  "tracingTargets": "string"
}

[Experimental - subject to breaking change.] Get traces for the given `blockId`.

GET

https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns traces (spans and events) of the specified block from RPC state_straceBlock. Consult the RPC docs for conceptual info.

Parameters

blockIdstringrequiredpath

Block identifier, as the block height or block hash.

Response

200OK

successful operation

[Experimental - subject to breaking change.] Get traces for the given `blockId`.

curl -X GET 'https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces'

const response = await fetch('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "blockHash": "string",
  "events": [
    {
      "data": {
        "stringValues": {
          "key": "string",
          "method": "string",
          "result": "string"
        }
      },
      "parentId": "string",
      "target": "string"
    }
  ],
  "parentHash": "string",
  "spans": [
    {
      "id": "string",
      "name": "string",
      "parentId": "string",
      "target": "string",
      "wasm": true
    }
  ],
  "storageKeys": "string",
  "tracingTargets": "string"
}

[Experimental - subject to breaking change.] Get the operations from the most recently finalized block.

GET

https://ksm-playbook.nownodes.io/experimental/blocks/head/traces/operations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the operations from the most recently finalized block. Operations represent one side of a balance change. For example if Alice transfers 100unit to Bob there will be two operations; 1) Alice - 100 2) Bob + 100.

Given account A and A's balance at block k0 (Ak0), if we sum all the operations for A from block k1 through kn against Ak0, we will end up with A's balance at block kn (Akn). Thus, operations can be used to audit that balances change as expected.

This is useful for Substrate based chains because the advanced business logic can make it difficult to ensure auditable balance reconciliation based purely on events. Instead of using events one can use the operations given from this endpoint.

Note - each operation corresponds to a delta of a single field of the system::AccountData storage item (i.e free, reserved, misc_frozen and fee_frozen). Note - operations are assigned a block execution phase (and extrinsic index for those in the apply extrinsic phase) based on an "action group". For example all the operations for 1 extrinsic will be in the same action group. The action groups can optionally be fetched with the action query param for closer auditing. Note - There are no 0 value operations (e.g. a transfer of 0, or a transfer to itself)

To learn more about operation and action group creation please consult this diagram

Parameters

actionsbooleanfalsequery

Whether or not to include action groups.

Response

200OK

successful operation

[Experimental - subject to breaking change.] Get the operations from the most recently finalized block.

curl -X GET 'https://ksm-playbook.nownodes.io/experimental/blocks/head/traces/operations'

const response = await fetch('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces/operations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces/operations')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces/operations')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces/operations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/experimental/blocks/head/traces/operations";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/experimental/blocks/head/traces/operations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces/operations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/experimental/blocks/head/traces/operations')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "operations": [
    {
      "phase": {
        "variant": "onInitialize",
        "extrinsicIndex": "string"
      },
      "parentSpanId": {
        "name": "string",
        "target": "string",
        "id": "string"
      },
      "primarySpanId": {
        "name": "string",
        "target": "string",
        "id": "string"
      },
      "eventIndex": "string",
      "address": "string",
      "storage": {
        "pallet": "string",
        "item": "string",
        "field1": "string",
        "field2": "string"
      },
      "amount": {
        "values": "string",
        "currency": {
          "symbol": "KSM"
        }
      }
    }
  ]
}

[Experimental - subject to breaking change.] Get the operations from the specified block.

GET

https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces/operations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

To learn more about operation and action group creation please consult this diagram

Parameters

blockIdstringrequiredpath

Block identifier, as the block height or block hash.

actionsbooleanfalsequery

Whether or not to include action groups.

Response

200OK

successful operation

[Experimental - subject to breaking change.] Get the operations from the specified block.

curl -X GET 'https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces/operations'

const response = await fetch('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces/operations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces/operations')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces/operations')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces/operations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces/operations";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces/operations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces/operations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/experimental/blocks/{blockId}/traces/operations')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "operations": [
    {
      "phase": {
        "variant": "onInitialize",
        "extrinsicIndex": "string"
      },
      "parentSpanId": {
        "name": "string",
        "target": "string",
        "id": "string"
      },
      "primarySpanId": {
        "name": "string",
        "target": "string",
        "id": "string"
      },
      "eventIndex": "string",
      "address": "string",
      "storage": {
        "pallet": "string",
        "item": "string",
        "field1": "string",
        "field2": "string"
      },
      "amount": {
        "values": "string",
        "currency": {
          "symbol": "KSM"
        }
      }
    }
  ]
}

staking

Get staking information for a Stash account.

GET

https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about a Stash account's staking activity. Replaces /staking/{address} from versions < v1.0.0. The Stash account can be either a validator or nominator account.

Parameters

accountIdstring<SS58>requiredpath

SS58 address of the account. Must be a Stash account.

atstring<unsignedInteger or $hex>query

Block at which to query the staking info for the specified account.

includeClaimedRewardsstring<boolean>truequery

When set to false, the claimedRewards field is not included in the response.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

account not found

Get staking information for a _Stash_ account.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-info'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-info')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{accountId}/staking-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-info')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "rewardDestination": "Staked",
  "controller": "string",
  "numSlashingSpans": "string",
  "nominations": {
    "targets": [
      "string"
    ],
    "submittedIn": "string",
    "suppressed": true
  },
  "staking": {
    "stash": "string",
    "total": "string",
    "active": "string",
    "unlocking": "string",
    "claimedRewards": [
      {
        "era": "string",
        "status": "claimed"
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get payout information for a Stash account.

GET

https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-payouts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns payout information for the last specified eras. If specifying both the depth and era query params, this endpoint will return information for (era - depth) through era. (i.e. if depth=5 and era=20 information will be returned for eras 16 through 20). N.B. You cannot query eras less then current_era - HISTORY_DEPTH. N.B. The nominator* fields correspond to the address being queried, even if it is a validator's Stash address. This is because a validator is technically nominating itself.

Parameters

accountIdstring<SS58>requiredpath

SS58 address of the account. Must be a Stash account.

atstring<unsignedInteger or $hex>query

Block at which to query staking payouts.

depthstring<unsignedInteger>1query

The number of eras to query for payouts of. Must be less than or equal to HISTORY_DEPTH. In cases where era - (depth -1) is less than 0, the first era queried will be 0.

erastring<unsignedInteger>`active_era - 1`query

The era to query at.

unclaimedOnlystring<boolean>truequery

Only return unclaimed rewards.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

404Not Found

account not found

Get payout information for a _Stash_ account.

curl -X GET 'https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-payouts'

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-payouts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-payouts')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-payouts')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-payouts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-payouts";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/accounts/{accountId}/staking-payouts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-payouts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/accounts/{accountId}/staking-payouts')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "erasPayouts": [
    {
      "era": "string",
      "totalEraRewardPoints": "string",
      "totalEraPayout": "string",
      "payouts": [
        {
          "validatorId": "string",
          "nominatorStakingPayout": "string",
          "claimed": true,
          "totalValidatorRewardPoints": "string",
          "validatorCommission": "string",
          "totalValidatorExposure": "string",
          "nominatorExposure": "string"
        }
      ]
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get progress on the general Staking pallet system.

GET

https://ksm-playbook.nownodes.io/pallets/staking/progress

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information on the progress of key components of the staking system and estimates of future points of interest. Replaces /staking-info from versions < v1.0.0.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve a staking progress report.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

Get progress on the general Staking pallet system.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/staking/progress'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/staking/progress')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/staking/progress')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/staking/progress";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/staking/progress')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/staking/progress')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "activeEra": "string",
  "forceEra": "ForceNone",
  "nextActiveEraEstimate": "string",
  "nextSessionEstimate": "string",
  "unappliedSlashes": [
    {
      "validator": "string",
      "own": "string",
      "others": [
        "string"
      ],
      "reporters": [
        "string"
      ],
      "payout": "string"
    }
  ],
  "electionStatus": {
    "status": {},
    "toggleEstimate": "string"
  },
  "idealValidatorCount": "string",
  "validatorSet": [
    "string"
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Get all validators (active/waiting) of a specific chain.

GET

https://ksm-playbook.nownodes.io/pallets/staking/validators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

atstring<unsignedInteger or $hex>query

Block at which to retrieve the list of validators.

Response

200OK

successful operation

400Bad Request

invalid blockId supplied for at query param

Get all validators (active/waiting) of a specific chain.

curl -X GET 'https://ksm-playbook.nownodes.io/pallets/staking/validators'

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/staking/validators')
request = Net::HTTP::Get.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.get('https://ksm-playbook.nownodes.io/pallets/staking/validators')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/pallets/staking/validators";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    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://ksm-playbook.nownodes.io/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/pallets/staking/validators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/pallets/staking/validators')
request = Net::HTTP::Get.new(uri)

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

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "validators": [
    {
      "address": "string",
      "status": "string"
    }
  ],
  "validatorsToBeChilled": [
    {
      "address": "string",
      "status": "string"
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "stack": "string",
  "level": "string"
}

Documentation

How to migrate to NOWNodes

Authentication

NODE

accounts

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

blocks

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

contracts

Authorizations

Body

Parameters

Response

coretime

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters