Axelar - gRPC Gateway docs

v1.0.0

Base URL

https://axelar.nownodes.io

A REST interface for state queries, legacy transactions

Authentication

api-keyAuthapiKey

API Key: api-key in header

API Reference

QueryService

Key returns the key corresponding to a given key ID. If no key is found, it returns the grpc NOT_FOUND error.

GET

https://axelar.nownodes.io/axelar/multisig/v1beta1/key

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

key_idstringquery

Response

200OK

A successful response.

default

An unexpected error response

Key returns the key corresponding to a given key ID. If no key is found, it returns the grpc NOT_FOUND error.

curl -X GET 'https://axelar.nownodes.io/axelar/multisig/v1beta1/key'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/key', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/key')
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://axelar.nownodes.io/axelar/multisig/v1beta1/key')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/key', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/v1beta1/key";
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://axelar.nownodes.io/axelar/multisig/v1beta1/key', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/multisig/v1beta1/key')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/key')
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)

{
  "key_id": "string",
  "state": "KEY_STATE_UNSPECIFIED",
  "started_at": "string",
  "started_at_timestamp": "2024-01-15T09:30:00Z",
  "threshold_weight": "dGVzdA==",
  "bonded_weight": "dGVzdA==",
  "participants": [
    {
      "address": "string",
      "weight": "dGVzdA==",
      "pub_key": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

KeyID returns the key ID of a key assigned to a given chain. If no key is assigned, it returns the grpc NOT_FOUND error.

GET

https://axelar.nownodes.io/axelar/multisig/v1beta1/key_id/{chain}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

KeyID returns the key ID of a key assigned to a given chain. If no key is assigned, it returns the grpc NOT_FOUND error.

curl -X GET 'https://axelar.nownodes.io/axelar/multisig/v1beta1/key_id/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/key_id/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/key_id/{chain}')
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://axelar.nownodes.io/axelar/multisig/v1beta1/key_id/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/key_id/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/v1beta1/key_id/{chain}";
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://axelar.nownodes.io/axelar/multisig/v1beta1/key_id/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/multisig/v1beta1/key_id/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/key_id/{chain}')
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)

{
  "key_id": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

KeygenSession returns the keygen session info for a given key ID. If no key is found, it returns the grpc NOT_FOUND error.

GET

https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_session

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

key_idstringquery

Response

200OK

A successful response.

default

An unexpected error response

KeygenSession returns the keygen session info for a given key ID. If no key is found, it returns the grpc NOT_FOUND error.

curl -X GET 'https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_session'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_session', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_session')
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://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_session')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_session', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_session";
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://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_session', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_session')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_session')
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)

{
  "started_at": "string",
  "started_at_timestamp": "2024-01-15T09:30:00Z",
  "expires_at": "string",
  "completed_at": "string",
  "grace_period": "string",
  "state": "MULTISIG_STATE_UNSPECIFIED",
  "keygen_threshold_weight": "dGVzdA==",
  "signing_threshold_weight": "dGVzdA==",
  "bonded_weight": "dGVzdA==",
  "participants": [
    {
      "address": "string",
      "weight": "dGVzdA==",
      "pub_key": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

NextKeyID returns the key ID assigned for the next rotation on a given chain. If no key rotation is in progress, it returns the grpc NOT_FOUND error.

GET

https://axelar.nownodes.io/axelar/multisig/v1beta1/next_key_id/{chain}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

NextKeyID returns the key ID assigned for the next rotation on a given chain. If no key rotation is in progress, it returns the grpc NOT_FOUND error.

curl -X GET 'https://axelar.nownodes.io/axelar/multisig/v1beta1/next_key_id/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/next_key_id/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/next_key_id/{chain}')
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://axelar.nownodes.io/axelar/multisig/v1beta1/next_key_id/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/next_key_id/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/v1beta1/next_key_id/{chain}";
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://axelar.nownodes.io/axelar/multisig/v1beta1/next_key_id/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/multisig/v1beta1/next_key_id/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/next_key_id/{chain}')
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)

{
  "key_id": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/multisig/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/multisig/v1beta1/params

curl -X GET 'https://axelar.nownodes.io/axelar/multisig/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/params')
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://axelar.nownodes.io/axelar/multisig/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/v1beta1/params";
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://axelar.nownodes.io/axelar/multisig/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/multisig/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/params')
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)

{
  "params": {
    "keygen_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "signing_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "keygen_timeout": "string",
    "keygen_grace_period": "string",
    "signing_timeout": "string",
    "signing_grace_period": "string",
    "active_epoch_count": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Assets queries the assets registered for a chain

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/assets/{chain}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

Assets queries the assets registered for a chain

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/assets/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/assets/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/assets/{chain}')
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://axelar.nownodes.io/axelar/nexus/v1beta1/assets/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/assets/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/assets/{chain}";
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://axelar.nownodes.io/axelar/nexus/v1beta1/assets/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/assets/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/assets/{chain}')
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)

{
  "assets": [
    "string"
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ChainMaintainers queries the chain maintainers for a given chain

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_maintainers/{chain}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

ChainMaintainers queries the chain maintainers for a given chain

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_maintainers/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_maintainers/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_maintainers/{chain}')
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://axelar.nownodes.io/axelar/nexus/v1beta1/chain_maintainers/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_maintainers/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_maintainers/{chain}";
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://axelar.nownodes.io/axelar/nexus/v1beta1/chain_maintainers/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_maintainers/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_maintainers/{chain}')
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)

{
  "maintainers": [
    "dGVzdA=="
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ChainState queries the state of a registered chain on the network

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_state/{chain}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

ChainState queries the state of a registered chain on the network

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_state/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_state/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_state/{chain}')
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://axelar.nownodes.io/axelar/nexus/v1beta1/chain_state/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_state/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_state/{chain}";
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://axelar.nownodes.io/axelar/nexus/v1beta1/chain_state/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_state/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/chain_state/{chain}')
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)

{
  "state": {
    "chain": {
      "name": "string",
      "supports_foreign_assets": true,
      "key_type": "KEY_TYPE_UNSPECIFIED",
      "module": "string"
    },
    "activated": true,
    "assets": [
      {
        "denom": "string",
        "is_native_asset": true
      }
    ],
    "maintainer_states": [
      {
        "address": "dGVzdA==",
        "missing_votes": {
          "true_count_cache": {
            "cumulative_value": [
              "string"
            ],
            "index": 0,
            "max_size": 0
          }
        },
        "incorrect_votes": {
          "true_count_cache": {
            "cumulative_value": [
              "string"
            ],
            "index": 0,
            "max_size": 0
          }
        },
        "chain": "string"
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Chains queries the chains registered on the network

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/chains

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

statusstringCHAIN_STATUS_UNSPECIFIEDCHAIN_STATUS_ACTIVATEDCHAIN_STATUS_DEACTIVATEDCHAIN_STATUS_UNSPECIFIEDquery

Response

200OK

A successful response.

default

An unexpected error response

Chains queries the chains registered on the network

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/chains'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/chains', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/chains')
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://axelar.nownodes.io/axelar/nexus/v1beta1/chains')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/chains', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/chains";
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://axelar.nownodes.io/axelar/nexus/v1beta1/chains', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/chains')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/chains')
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)

{
  "chains": [
    "string"
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ChainsByAsset queries the chains that support an asset on the network

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/chains_by_asset/{asset}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

assetstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

ChainsByAsset queries the chains that support an asset on the network

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/chains_by_asset/{asset}'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/chains_by_asset/{asset}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/chains_by_asset/{asset}')
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://axelar.nownodes.io/axelar/nexus/v1beta1/chains_by_asset/{asset}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/chains_by_asset/{asset}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/chains_by_asset/{asset}";
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://axelar.nownodes.io/axelar/nexus/v1beta1/chains_by_asset/{asset}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/chains_by_asset/{asset}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/chains_by_asset/{asset}')
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)

{
  "chains": [
    "string"
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

FeeInfo queries the fee info by chain and asset

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/fee

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringquery

assetstringquery

Response

200OK

A successful response.

default

An unexpected error response

FeeInfo queries the fee info by chain and asset

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/fee'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/fee', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/fee')
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://axelar.nownodes.io/axelar/nexus/v1beta1/fee')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/fee', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/fee";
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://axelar.nownodes.io/axelar/nexus/v1beta1/fee', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/fee')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/fee')
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)

{
  "fee_info": {
    "chain": "string",
    "asset": "string",
    "fee_rate": "dGVzdA==",
    "min_fee": "dGVzdA==",
    "max_fee": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

FeeInfo queries the fee info by chain and asset

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/fee_info/{chain}/{asset}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

assetstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

FeeInfo queries the fee info by chain and asset

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/fee_info/{chain}/{asset}'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/fee_info/{chain}/{asset}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/fee_info/{chain}/{asset}')
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://axelar.nownodes.io/axelar/nexus/v1beta1/fee_info/{chain}/{asset}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/fee_info/{chain}/{asset}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/fee_info/{chain}/{asset}";
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://axelar.nownodes.io/axelar/nexus/v1beta1/fee_info/{chain}/{asset}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/fee_info/{chain}/{asset}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/fee_info/{chain}/{asset}')
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)

{
  "fee_info": {
    "chain": "string",
    "asset": "string",
    "fee_rate": "dGVzdA==",
    "min_fee": "dGVzdA==",
    "max_fee": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/message

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

idstringquery

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/nexus/v1beta1/message

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/message'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/message', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/message')
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://axelar.nownodes.io/axelar/nexus/v1beta1/message')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/message', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/message";
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://axelar.nownodes.io/axelar/nexus/v1beta1/message', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/message')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/message')
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)

{
  "message": {
    "id": "string",
    "sender": {
      "chain": {
        "name": "string",
        "supports_foreign_assets": true,
        "key_type": "KEY_TYPE_UNSPECIFIED",
        "module": "string"
      },
      "address": "string"
    },
    "recipient": {
      "chain": {
        "name": "string",
        "supports_foreign_assets": true,
        "key_type": "KEY_TYPE_UNSPECIFIED",
        "module": "string"
      },
      "address": "string"
    },
    "payload_hash": "dGVzdA==",
    "status": "STATUS_UNSPECIFIED",
    "asset": {
      "denom": "string",
      "amount": "string"
    },
    "source_tx_id": "dGVzdA==",
    "source_tx_index": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/nexus/v1beta1/params

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/params')
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://axelar.nownodes.io/axelar/nexus/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/params";
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://axelar.nownodes.io/axelar/nexus/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/params')
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)

{
  "params": {
    "chain_activation_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "chain_maintainer_missing_vote_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "chain_maintainer_incorrect_vote_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "chain_maintainer_check_window": 0
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

TransferFee queries the transfer fee by the source, destination chain, and amount. If amount is 0, the min fee is returned

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

source_chainstringquery

destination_chainstringquery

amountstringquery

Response

200OK

A successful response.

default

An unexpected error response

TransferFee queries the transfer fee by the source, destination chain, and amount. If amount is 0, the min fee is returned

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee')
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://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee";
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://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee')
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)

{
  "fee": {
    "denom": "string",
    "amount": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

TransferFee queries the transfer fee by the source, destination chain, and amount. If amount is 0, the min fee is returned

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee/{source_chain}/{destination_chain}/{amount}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

source_chainstringrequiredpath

destination_chainstringrequiredpath

amountstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

TransferFee queries the transfer fee by the source, destination chain, and amount. If amount is 0, the min fee is returned

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee/{source_chain}/{destination_chain}/{amount}'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee/{source_chain}/{destination_chain}/{amount}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee/{source_chain}/{destination_chain}/{amount}')
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://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee/{source_chain}/{destination_chain}/{amount}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee/{source_chain}/{destination_chain}/{amount}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee/{source_chain}/{destination_chain}/{amount}";
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://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee/{source_chain}/{destination_chain}/{amount}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee/{source_chain}/{destination_chain}/{amount}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_fee/{source_chain}/{destination_chain}/{amount}')
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)

{
  "fee": {
    "denom": "string",
    "amount": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

TransfersForChain queries transfers by chain

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/transfers_for_chain/{chain}/{state}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

statestringTRANSFER_STATE_UNSPECIFIEDTRANSFER_STATE_PENDINGTRANSFER_STATE_ARCHIVEDTRANSFER_STATE_INSUFFICIENT_AMOUNTrequiredpath

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

count_total is set to true to indicate that the result set should include a count of the total number of items available for pagination in UIs. count_total is only respected when offset is used. It is ignored when key is set.

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

TransfersForChain queries transfers by chain

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/transfers_for_chain/{chain}/{state}'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfers_for_chain/{chain}/{state}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfers_for_chain/{chain}/{state}')
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://axelar.nownodes.io/axelar/nexus/v1beta1/transfers_for_chain/{chain}/{state}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfers_for_chain/{chain}/{state}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/transfers_for_chain/{chain}/{state}";
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://axelar.nownodes.io/axelar/nexus/v1beta1/transfers_for_chain/{chain}/{state}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfers_for_chain/{chain}/{state}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfers_for_chain/{chain}/{state}')
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)

{
  "transfers": [
    {
      "recipient": {
        "chain": {
          "name": "string",
          "supports_foreign_assets": true,
          "key_type": "KEY_TYPE_UNSPECIFIED",
          "module": "string"
        },
        "address": "string"
      },
      "asset": {
        "denom": "string",
        "amount": "string"
      },
      "id": "string",
      "state": "TRANSFER_STATE_UNSPECIFIED"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validatorstringquery

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/reward/v1beta1/inflation_rate

curl -X GET 'https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate'

const response = await fetch('https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate')
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://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate";
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://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate')
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)

{
  "inflation_rate": "dGVzdA=="
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate/{validator}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validatorstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/reward/v1beta1/inflation_rate/{validator}

curl -X GET 'https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate/{validator}'

const response = await fetch('https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate/{validator}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate/{validator}')
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://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate/{validator}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate/{validator}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate/{validator}";
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://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate/{validator}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate/{validator}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/reward/v1beta1/inflation_rate/{validator}')
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)

{
  "inflation_rate": "dGVzdA=="
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/reward/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/reward/v1beta1/params

curl -X GET 'https://axelar.nownodes.io/axelar/reward/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/axelar/reward/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/reward/v1beta1/params')
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://axelar.nownodes.io/axelar/reward/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/reward/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/reward/v1beta1/params";
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://axelar.nownodes.io/axelar/reward/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/reward/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/reward/v1beta1/params')
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)

{
  "params": {
    "external_chain_voting_inflation_rate": "dGVzdA==",
    "key_mgmt_relative_inflation_rate": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/snapshot/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/snapshot/v1beta1/params

curl -X GET 'https://axelar.nownodes.io/axelar/snapshot/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/axelar/snapshot/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/snapshot/v1beta1/params')
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://axelar.nownodes.io/axelar/snapshot/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/snapshot/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/snapshot/v1beta1/params";
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://axelar.nownodes.io/axelar/snapshot/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/snapshot/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/snapshot/v1beta1/params')
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)

{
  "params": {
    "min_proxy_balance": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/vote/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/vote/v1beta1/params

curl -X GET 'https://axelar.nownodes.io/axelar/vote/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/axelar/vote/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/vote/v1beta1/params')
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://axelar.nownodes.io/axelar/vote/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/vote/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/vote/v1beta1/params";
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://axelar.nownodes.io/axelar/vote/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/vote/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/vote/v1beta1/params')
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)

{
  "params": {
    "default_voting_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "end_blocker_limit": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params returns the parameters of the feepolicy module.

GET

https://axelar.nownodes.io/axelar/feepolicy/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

Params returns the parameters of the feepolicy module.

curl -X GET 'https://axelar.nownodes.io/axelar/feepolicy/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/axelar/feepolicy/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/feepolicy/v1beta1/params')
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://axelar.nownodes.io/axelar/feepolicy/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/feepolicy/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/feepolicy/v1beta1/params";
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://axelar.nownodes.io/axelar/feepolicy/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/feepolicy/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/feepolicy/v1beta1/params')
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)

{
  "params": {}
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns list of Authorization, granted to the grantee by the granter.

GET

https://axelar.nownodes.io/cosmos/authz/v1beta1/grants

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

granterstringquery

granteestringquery

msg_type_urlstringquery

pagination.keystring<byte>query

pagination.offsetstring<uint64>query

pagination.limitstring<uint64>query

pagination.count_totalbooleanquery

pagination.reversebooleanquery

Response

200OK

A successful response.

default

An unexpected error response

Returns list of Authorization, granted to the grantee by the granter.

curl -X GET 'https://axelar.nownodes.io/cosmos/authz/v1beta1/grants'

const response = await fetch('https://axelar.nownodes.io/cosmos/authz/v1beta1/grants', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/authz/v1beta1/grants')
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://axelar.nownodes.io/cosmos/authz/v1beta1/grants')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/authz/v1beta1/grants', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/authz/v1beta1/grants";
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://axelar.nownodes.io/cosmos/authz/v1beta1/grants', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/authz/v1beta1/grants')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/authz/v1beta1/grants')
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)

{
  "grants": [
    {
      "authorization": {},
      "expiration": "2024-01-15T09:30:00Z"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Grants returns list of Authorization, granted to the grantee by the granter for a specific msg type.

GET

https://axelar.nownodes.io/cosmos/authz/v1beta1/grants/granter/{granter}/grantee/{grantee}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

granterstringrequiredpath

granteestringrequiredpath

msg_type_urlstringquery

pagination.keystring<byte>query

pagination.offsetstring<uint64>query

pagination.limitstring<uint64>query

pagination.count_totalbooleanquery

pagination.reversebooleanquery

Response

200OK

A successful response.

default

An unexpected error response

Grants returns list of Authorization, granted to the grantee by the granter for a specific msg type.

curl -X GET 'https://axelar.nownodes.io/cosmos/authz/v1beta1/grants/granter/{granter}/grantee/{grantee}'

const response = await fetch('https://axelar.nownodes.io/cosmos/authz/v1beta1/grants/granter/{granter}/grantee/{grantee}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/authz/v1beta1/grants/granter/{granter}/grantee/{grantee}')
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://axelar.nownodes.io/cosmos/authz/v1beta1/grants/granter/{granter}/grantee/{grantee}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/authz/v1beta1/grants/granter/{granter}/grantee/{grantee}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/authz/v1beta1/grants/granter/{granter}/grantee/{grantee}";
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://axelar.nownodes.io/cosmos/authz/v1beta1/grants/granter/{granter}/grantee/{grantee}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/authz/v1beta1/grants/granter/{granter}/grantee/{grantee}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/authz/v1beta1/grants/granter/{granter}/grantee/{grantee}')
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)

{
  "grants": [
    {
      "authorization": {},
      "expiration": "2024-01-15T09:30:00Z"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Query

GovernanceKey returns the multisig governance key

GET

https://axelar.nownodes.io/axelar/permission/v1beta1/governance_key

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

GovernanceKey returns the multisig governance key

curl -X GET 'https://axelar.nownodes.io/axelar/permission/v1beta1/governance_key'

const response = await fetch('https://axelar.nownodes.io/axelar/permission/v1beta1/governance_key', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/v1beta1/governance_key')
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://axelar.nownodes.io/axelar/permission/v1beta1/governance_key')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/permission/v1beta1/governance_key', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/permission/v1beta1/governance_key";
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://axelar.nownodes.io/axelar/permission/v1beta1/governance_key', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/permission/v1beta1/governance_key')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/v1beta1/governance_key')
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)

{
  "governance_key": {
    "threshold": 0,
    "public_keys": [
      {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/permission/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/permission/v1beta1/params

curl -X GET 'https://axelar.nownodes.io/axelar/permission/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/axelar/permission/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/v1beta1/params')
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://axelar.nownodes.io/axelar/permission/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/permission/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/permission/v1beta1/params";
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://axelar.nownodes.io/axelar/permission/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/permission/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/v1beta1/params')
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)

{
  "params": {}
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Accounts returns all the existing accounts

GET

https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Since: cosmos-sdk 0.43

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

Accounts returns all the existing accounts

curl -X GET 'https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts'

const response = await fetch('https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts')
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://axelar.nownodes.io/cosmos/auth/v1beta1/accounts')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts";
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://axelar.nownodes.io/cosmos/auth/v1beta1/accounts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts')
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)

{
  "accounts": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Account returns account details based on address.

GET

https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

addressstringrequiredpath

address defines the address to query for.

Response

200OK

A successful response.

default

An unexpected error response

Account returns account details based on address.

curl -X GET 'https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts/{address}'

const response = await fetch('https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts/{address}')
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://axelar.nownodes.io/cosmos/auth/v1beta1/accounts/{address}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts/{address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts/{address}";
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://axelar.nownodes.io/cosmos/auth/v1beta1/accounts/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/auth/v1beta1/accounts/{address}')
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)

{
  "account": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ModuleAccountByName returns the module account info by module name

GET

https://axelar.nownodes.io/cosmos/auth/v1beta1/module_accounts/{name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

namestringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

ModuleAccountByName returns the module account info by module name

curl -X GET 'https://axelar.nownodes.io/cosmos/auth/v1beta1/module_accounts/{name}'

const response = await fetch('https://axelar.nownodes.io/cosmos/auth/v1beta1/module_accounts/{name}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/auth/v1beta1/module_accounts/{name}')
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://axelar.nownodes.io/cosmos/auth/v1beta1/module_accounts/{name}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/auth/v1beta1/module_accounts/{name}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/auth/v1beta1/module_accounts/{name}";
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://axelar.nownodes.io/cosmos/auth/v1beta1/module_accounts/{name}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/auth/v1beta1/module_accounts/{name}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/auth/v1beta1/module_accounts/{name}')
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)

{
  "account": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params queries all parameters.

GET

https://axelar.nownodes.io/cosmos/auth/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

Params queries all parameters.

curl -X GET 'https://axelar.nownodes.io/cosmos/auth/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/cosmos/auth/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/auth/v1beta1/params')
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://axelar.nownodes.io/cosmos/auth/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/auth/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/auth/v1beta1/params";
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://axelar.nownodes.io/cosmos/auth/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/auth/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/auth/v1beta1/params')
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)

{
  "params": {
    "max_memo_characters": "string",
    "tx_sig_limit": "string",
    "tx_size_cost_per_byte": "string",
    "sig_verify_cost_ed25519": "string",
    "sig_verify_cost_secp256k1": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

AllBalances queries the balance of all coins for a single account.

GET

https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

addressstringrequiredpath

address is the address to query balances for.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

AllBalances queries the balance of all coins for a single account.

curl -X GET 'https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}'

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}')
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://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}";
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://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}')
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)

{
  "balances": [
    {
      "denom": "string",
      "amount": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Balance queries the balance of a single coin for a single account.

GET

https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}/by_denom

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

addressstringrequiredpath

address is the address to query balances for.

denomstringquery

denom is the coin denom to query balances for.

Response

200OK

A successful response.

default

An unexpected error response

Balance queries the balance of a single coin for a single account.

curl -X GET 'https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}/by_denom'

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}/by_denom', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}/by_denom')
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://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}/by_denom')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}/by_denom', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}/by_denom";
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://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}/by_denom', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}/by_denom')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/balances/{address}/by_denom')
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)

{
  "balance": {
    "denom": "string",
    "amount": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DenomsMetadata queries the client metadata for all registered coin denominations.

GET

https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

DenomsMetadata queries the client metadata for all registered coin denominations.

curl -X GET 'https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata'

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_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://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_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://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_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)

{
  "metadatas": [
    {
      "description": "string",
      "denom_units": [
        {
          "denom": "string",
          "exponent": 0,
          "aliases": [
            "string"
          ]
        }
      ],
      "base": "string",
      "display": "string",
      "name": "string",
      "symbol": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DenomsMetadata queries the client metadata of a given coin denomination.

GET

https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata/{denom}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringrequiredpath

denom is the coin denom to query the metadata for.

Response

200OK

A successful response.

default

An unexpected error response

DenomsMetadata queries the client metadata of a given coin denomination.

curl -X GET 'https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata/{denom}'

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata/{denom}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata/{denom}')
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://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata/{denom}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata/{denom}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata/{denom}";
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://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata/{denom}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata/{denom}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/denoms_metadata/{denom}')
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)

{
  "metadata": {
    "description": "string",
    "denom_units": [
      {
        "denom": "string",
        "exponent": 0,
        "aliases": [
          "string"
        ]
      }
    ],
    "base": "string",
    "display": "string",
    "name": "string",
    "symbol": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params queries the parameters of x/bank module.

GET

https://axelar.nownodes.io/cosmos/bank/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

Params queries the parameters of x/bank module.

curl -X GET 'https://axelar.nownodes.io/cosmos/bank/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/params')
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://axelar.nownodes.io/cosmos/bank/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/bank/v1beta1/params";
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://axelar.nownodes.io/cosmos/bank/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/bank/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/params')
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)

{
  "params": {
    "send_enabled": [
      {
        "denom": "string",
        "enabled": true
      }
    ],
    "default_send_enabled": true
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

SpendableBalances queries the spenable balance of all coins for a single account.

GET

https://axelar.nownodes.io/cosmos/bank/v1beta1/spendable_balances/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

addressstringrequiredpath

address is the address to query spendable balances for.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

SpendableBalances queries the spenable balance of all coins for a single account.

curl -X GET 'https://axelar.nownodes.io/cosmos/bank/v1beta1/spendable_balances/{address}'

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/spendable_balances/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/spendable_balances/{address}')
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://axelar.nownodes.io/cosmos/bank/v1beta1/spendable_balances/{address}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/spendable_balances/{address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/bank/v1beta1/spendable_balances/{address}";
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://axelar.nownodes.io/cosmos/bank/v1beta1/spendable_balances/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/bank/v1beta1/spendable_balances/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/spendable_balances/{address}')
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)

{
  "balances": [
    {
      "denom": "string",
      "amount": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

TotalSupply queries the total supply of all coins.

GET

https://axelar.nownodes.io/cosmos/bank/v1beta1/supply

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

TotalSupply queries the total supply of all coins.

curl -X GET 'https://axelar.nownodes.io/cosmos/bank/v1beta1/supply'

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/supply', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/supply')
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://axelar.nownodes.io/cosmos/bank/v1beta1/supply')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/supply', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/bank/v1beta1/supply";
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://axelar.nownodes.io/cosmos/bank/v1beta1/supply', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/bank/v1beta1/supply')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/supply')
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)

{
  "supply": [
    {
      "denom": "string",
      "amount": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

SupplyOf queries the supply of a single coin.

GET

https://axelar.nownodes.io/cosmos/bank/v1beta1/supply/{denom}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringrequiredpath

denom is the coin denom to query balances for.

Response

200OK

A successful response.

default

An unexpected error response

SupplyOf queries the supply of a single coin.

curl -X GET 'https://axelar.nownodes.io/cosmos/bank/v1beta1/supply/{denom}'

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/supply/{denom}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/supply/{denom}')
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://axelar.nownodes.io/cosmos/bank/v1beta1/supply/{denom}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/bank/v1beta1/supply/{denom}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/bank/v1beta1/supply/{denom}";
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://axelar.nownodes.io/cosmos/bank/v1beta1/supply/{denom}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/bank/v1beta1/supply/{denom}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/bank/v1beta1/supply/{denom}')
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)

{
  "amount": {
    "denom": "string",
    "amount": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

CommunityPool queries the community pool coins.

GET

https://axelar.nownodes.io/cosmos/distribution/v1beta1/community_pool

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

CommunityPool queries the community pool coins.

curl -X GET 'https://axelar.nownodes.io/cosmos/distribution/v1beta1/community_pool'

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/community_pool', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/community_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://axelar.nownodes.io/cosmos/distribution/v1beta1/community_pool')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/community_pool', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/distribution/v1beta1/community_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://axelar.nownodes.io/cosmos/distribution/v1beta1/community_pool', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/distribution/v1beta1/community_pool')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/community_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)

{
  "pool": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DelegationTotalRewards queries the total rewards accrued by a each validator.

GET

https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addressstringrequiredpath

delegator_address defines the delegator address to query for.

Response

200OK

A successful response.

default

An unexpected error response

DelegationTotalRewards queries the total rewards accrued by a each validator.

curl -X GET 'https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards'

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards')
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://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards";
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://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards')
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)

{
  "rewards": [
    {
      "validator_address": "string",
      "reward": [
        {
          "denom": "string",
          "amount": "string"
        }
      ]
    }
  ],
  "total": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DelegationRewards queries the total rewards accrued by a delegation.

GET

https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addressstringrequiredpath

delegator_address defines the delegator address to query for.

validator_addressstringrequiredpath

validator_address defines the validator address to query for.

Response

200OK

A successful response.

default

An unexpected error response

DelegationRewards queries the total rewards accrued by a delegation.

curl -X GET 'https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}'

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}')
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://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}";
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://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}')
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)

{
  "rewards": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DelegatorValidators queries the validators of a delegator.

GET

https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addressstringrequiredpath

delegator_address defines the delegator address to query for.

Response

200OK

A successful response.

default

An unexpected error response

DelegatorValidators queries the validators of a delegator.

curl -X GET 'https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators'

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/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://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/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://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/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)

{
  "validators": [
    "string"
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DelegatorWithdrawAddress queries withdraw address of a delegator.

GET

https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addressstringrequiredpath

delegator_address defines the delegator address to query for.

Response

200OK

A successful response.

default

An unexpected error response

DelegatorWithdrawAddress queries withdraw address of a delegator.

curl -X GET 'https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address'

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address')
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://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address";
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://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address')
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)

{
  "withdraw_address": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params queries params of the distribution module.

GET

https://axelar.nownodes.io/cosmos/distribution/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

Params queries params of the distribution module.

curl -X GET 'https://axelar.nownodes.io/cosmos/distribution/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/params')
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://axelar.nownodes.io/cosmos/distribution/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/distribution/v1beta1/params";
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://axelar.nownodes.io/cosmos/distribution/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/distribution/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/params')
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)

{
  "params": {
    "community_tax": "string",
    "base_proposer_reward": "string",
    "bonus_proposer_reward": "string",
    "withdraw_addr_enabled": true
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ValidatorCommission queries accumulated commission for a validator.

GET

https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/commission

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validator_addressstringrequiredpath

validator_address defines the validator address to query for.

Response

200OK

A successful response.

default

An unexpected error response

ValidatorCommission queries accumulated commission for a validator.

curl -X GET 'https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/commission'

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/commission', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/commission')
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://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/commission')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/commission', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/commission";
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://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/commission', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/commission')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/commission')
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)

{
  "commission": {
    "commission": [
      {
        "denom": "string",
        "amount": "string"
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ValidatorOutstandingRewards queries rewards of a validator address.

GET

https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validator_addressstringrequiredpath

validator_address defines the validator address to query for.

Response

200OK

A successful response.

default

An unexpected error response

ValidatorOutstandingRewards queries rewards of a validator address.

curl -X GET 'https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards'

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards')
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://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards";
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://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards')
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)

{
  "rewards": {
    "rewards": [
      {
        "denom": "string",
        "amount": "string"
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ValidatorSlashes queries slash events of a validator.

GET

https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/slashes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validator_addressstringrequiredpath

validator_address defines the validator address to query for.

starting_heightstring<uint64>query

starting_height defines the optional starting height to query the slashes.

ending_heightstring<uint64>query

starting_height defines the optional ending height to query the slashes.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

ValidatorSlashes queries slash events of a validator.

curl -X GET 'https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/slashes'

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/slashes', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/slashes')
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://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/slashes')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/slashes', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/slashes";
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://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/slashes', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/slashes')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/distribution/v1beta1/validators/{validator_address}/slashes')
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)

{
  "slashes": [
    {
      "validator_period": "string",
      "fraction": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Allowance returns fee granted to the grantee by the granter.

GET

https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowance/{granter}/{grantee}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

granterstringrequiredpath

granter is the address of the user granting an allowance of their funds.

granteestringrequiredpath

grantee is the address of the user being granted an allowance of another user's funds.

Response

200OK

A successful response.

default

An unexpected error response

Allowance returns fee granted to the grantee by the granter.

curl -X GET 'https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowance/{granter}/{grantee}'

const response = await fetch('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowance/{granter}/{grantee}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowance/{granter}/{grantee}')
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://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowance/{granter}/{grantee}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowance/{granter}/{grantee}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowance/{granter}/{grantee}";
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://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowance/{granter}/{grantee}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowance/{granter}/{grantee}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowance/{granter}/{grantee}')
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)

{
  "allowance": {
    "granter": "string",
    "grantee": "string",
    "allowance": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Allowances returns all the grants for address.

GET

https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowances/{grantee}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

granteestringrequiredpath

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

Allowances returns all the grants for address.

curl -X GET 'https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowances/{grantee}'

const response = await fetch('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowances/{grantee}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowances/{grantee}')
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://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowances/{grantee}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowances/{grantee}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowances/{grantee}";
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://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowances/{grantee}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowances/{grantee}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/allowances/{grantee}')
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)

{
  "allowances": [
    {
      "granter": "string",
      "grantee": "string",
      "allowance": {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

AllowancesByGranter returns all the grants given by an address Since v0.46

GET

https://axelar.nownodes.io/cosmos/feegrant/v1beta1/issued/{granter}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

granterstringrequiredpath

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

AllowancesByGranter returns all the grants given by an address Since v0.46

curl -X GET 'https://axelar.nownodes.io/cosmos/feegrant/v1beta1/issued/{granter}'

const response = await fetch('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/issued/{granter}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/issued/{granter}')
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://axelar.nownodes.io/cosmos/feegrant/v1beta1/issued/{granter}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/issued/{granter}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/feegrant/v1beta1/issued/{granter}";
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://axelar.nownodes.io/cosmos/feegrant/v1beta1/issued/{granter}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/issued/{granter}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/feegrant/v1beta1/issued/{granter}')
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)

{
  "allowances": [
    {
      "granter": "string",
      "grantee": "string",
      "allowance": {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

AllEvidence queries all evidence.

GET

https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

AllEvidence queries all evidence.

curl -X GET 'https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence'

const response = await fetch('https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence')
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://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence";
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://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence')
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)

{
  "evidence": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Evidence queries evidence based on evidence hash.

GET

https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence/{evidence_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

evidence_hashstring<byte>requiredpath

evidence_hash defines the hash of the requested evidence.

Response

200OK

A successful response.

default

An unexpected error response

Evidence queries evidence based on evidence hash.

curl -X GET 'https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence/{evidence_hash}'

const response = await fetch('https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence/{evidence_hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence/{evidence_hash}')
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://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence/{evidence_hash}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence/{evidence_hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence/{evidence_hash}";
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://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence/{evidence_hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence/{evidence_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/evidence/v1beta1/evidence/{evidence_hash}')
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)

{
  "evidence": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params queries all parameters of the gov module.

GET

https://axelar.nownodes.io/cosmos/gov/v1/params/{params_type}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

params_typestringrequiredpath

params_type defines which parameters to query for, can be one of "voting", "tallying" or "deposit".

Response

200OK

A successful response.

default

An unexpected error response

Params queries all parameters of the gov module.

curl -X GET 'https://axelar.nownodes.io/cosmos/gov/v1/params/{params_type}'

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/params/{params_type}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/params/{params_type}')
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://axelar.nownodes.io/cosmos/gov/v1/params/{params_type}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/params/{params_type}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/gov/v1/params/{params_type}";
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://axelar.nownodes.io/cosmos/gov/v1/params/{params_type}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/gov/v1/params/{params_type}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/params/{params_type}')
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)

{
  "voting_params": {
    "voting_period": "string"
  },
  "deposit_params": {
    "min_deposit": [
      {
        "denom": "string",
        "amount": "string"
      }
    ],
    "max_deposit_period": "string"
  },
  "tally_params": {
    "quorum": "dGVzdA==",
    "threshold": "dGVzdA==",
    "veto_threshold": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Proposals queries all proposals based on given status.

GET

https://axelar.nownodes.io/cosmos/gov/v1/proposals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

proposal_statusstringPROPOSAL_STATUS_UNSPECIFIEDPROPOSAL_STATUS_DEPOSIT_PERIODPROPOSAL_STATUS_VOTING_PERIODPROPOSAL_STATUS_PASSEDPROPOSAL_STATUS_REJECTEDPROPOSAL_STATUS_FAILEDPROPOSAL_STATUS_UNSPECIFIEDquery

proposal_status defines the status of the proposals.

PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.
PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.
PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.
PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.
PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.
PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.

voterstringquery

voter defines the voter address for the proposals.

depositorstringquery

depositor defines the deposit addresses from the proposals.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

Proposals queries all proposals based on given status.

curl -X GET 'https://axelar.nownodes.io/cosmos/gov/v1/proposals'

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals')
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://axelar.nownodes.io/cosmos/gov/v1/proposals')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/gov/v1/proposals";
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://axelar.nownodes.io/cosmos/gov/v1/proposals', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/gov/v1/proposals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals')
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)

{
  "proposals": [
    {
      "proposal_id": "string",
      "content": {
        "type_url": "string",
        "value": "dGVzdA=="
      },
      "status": "PROPOSAL_STATUS_UNSPECIFIED",
      "final_tally_result": {
        "yes": "string",
        "abstain": "string",
        "no": "string",
        "no_with_veto": "string"
      },
      "submit_time": "2024-01-15T09:30:00Z",
      "deposit_end_time": "2024-01-15T09:30:00Z",
      "total_deposit": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "voting_start_time": "2024-01-15T09:30:00Z",
      "voting_end_time": "2024-01-15T09:30:00Z"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Proposal queries proposal details based on ProposalID.

GET

https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

proposal_idstring<uint64>requiredpath

proposal_id defines the unique id of the proposal.

Response

200OK

A successful response.

default

An unexpected error response

Proposal queries proposal details based on ProposalID.

curl -X GET 'https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}'

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_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)

{
  "proposal": {
    "proposal_id": "string",
    "content": {
      "type_url": "string",
      "value": "dGVzdA=="
    },
    "status": "PROPOSAL_STATUS_UNSPECIFIED",
    "final_tally_result": {
      "yes": "string",
      "abstain": "string",
      "no": "string",
      "no_with_veto": "string"
    },
    "submit_time": "2024-01-15T09:30:00Z",
    "deposit_end_time": "2024-01-15T09:30:00Z",
    "total_deposit": [
      {
        "denom": "string",
        "amount": "string"
      }
    ],
    "voting_start_time": "2024-01-15T09:30:00Z",
    "voting_end_time": "2024-01-15T09:30:00Z"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Deposits queries all deposits of a single proposal.

GET

https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

proposal_idstring<uint64>requiredpath

proposal_id defines the unique id of the proposal.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

Deposits queries all deposits of a single proposal.

curl -X GET 'https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits'

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits')
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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits";
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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits')
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)

{
  "deposits": [
    {
      "proposal_id": "string",
      "depositor": "string",
      "amount": [
        {
          "denom": "string",
          "amount": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Deposit queries single deposit information based proposalID, depositAddr.

GET

https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

proposal_idstring<uint64>requiredpath

proposal_id defines the unique id of the proposal.

depositorstringrequiredpath

depositor defines the deposit addresses from the proposals.

Response

200OK

A successful response.

default

An unexpected error response

Deposit queries single deposit information based proposalID, depositAddr.

curl -X GET 'https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor}'

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor}')
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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor}";
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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor}')
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)

{
  "deposit": {
    "proposal_id": "string",
    "depositor": "string",
    "amount": [
      {
        "denom": "string",
        "amount": "string"
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

TallyResult queries the tally of a proposal vote.

GET

https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/tally

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

proposal_idstring<uint64>requiredpath

proposal_id defines the unique id of the proposal.

Response

200OK

A successful response.

default

An unexpected error response

TallyResult queries the tally of a proposal vote.

curl -X GET 'https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/tally'

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/tally', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/tally')
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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/tally')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/tally', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/tally";
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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/tally', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/tally')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/tally')
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)

{
  "tally": {
    "yes": "string",
    "abstain": "string",
    "no": "string",
    "no_with_veto": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Votes queries votes of a given proposal.

GET

https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

proposal_idstring<uint64>requiredpath

proposal_id defines the unique id of the proposal.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

Votes queries votes of a given proposal.

curl -X GET 'https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes'

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes')
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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes";
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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes')
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)

{
  "votes": [
    {
      "proposal_id": "string",
      "voter": "string",
      "option": "VOTE_OPTION_UNSPECIFIED",
      "options": [
        {
          "option": "VOTE_OPTION_UNSPECIFIED",
          "weight": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Vote queries voted information based on proposalID, voterAddr.

GET

https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

proposal_idstring<uint64>requiredpath

proposal_id defines the unique id of the proposal.

voterstringrequiredpath

voter defines the oter address for the proposals.

Response

200OK

A successful response.

default

An unexpected error response

Vote queries voted information based on proposalID, voterAddr.

curl -X GET 'https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter}'

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter}')
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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter}";
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://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter}')
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)

{
  "vote": {
    "proposal_id": "string",
    "voter": "string",
    "option": "VOTE_OPTION_UNSPECIFIED",
    "options": [
      {
        "option": "VOTE_OPTION_UNSPECIFIED",
        "weight": "string"
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

AnnualProvisions current minting annual provisions value.

GET

https://axelar.nownodes.io/cosmos/mint/v1beta1/annual_provisions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

AnnualProvisions current minting annual provisions value.

curl -X GET 'https://axelar.nownodes.io/cosmos/mint/v1beta1/annual_provisions'

const response = await fetch('https://axelar.nownodes.io/cosmos/mint/v1beta1/annual_provisions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/mint/v1beta1/annual_provisions')
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://axelar.nownodes.io/cosmos/mint/v1beta1/annual_provisions')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/mint/v1beta1/annual_provisions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/mint/v1beta1/annual_provisions";
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://axelar.nownodes.io/cosmos/mint/v1beta1/annual_provisions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/mint/v1beta1/annual_provisions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/mint/v1beta1/annual_provisions')
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)

{
  "annual_provisions": "dGVzdA=="
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Inflation returns the current minting inflation value.

GET

https://axelar.nownodes.io/cosmos/mint/v1beta1/inflation

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

Inflation returns the current minting inflation value.

curl -X GET 'https://axelar.nownodes.io/cosmos/mint/v1beta1/inflation'

const response = await fetch('https://axelar.nownodes.io/cosmos/mint/v1beta1/inflation', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/mint/v1beta1/inflation')
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://axelar.nownodes.io/cosmos/mint/v1beta1/inflation')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/mint/v1beta1/inflation', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/mint/v1beta1/inflation";
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://axelar.nownodes.io/cosmos/mint/v1beta1/inflation', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/mint/v1beta1/inflation')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/mint/v1beta1/inflation')
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)

{
  "inflation": "dGVzdA=="
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params returns the total set of minting parameters.

GET

https://axelar.nownodes.io/cosmos/mint/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

Params returns the total set of minting parameters.

curl -X GET 'https://axelar.nownodes.io/cosmos/mint/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/cosmos/mint/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/mint/v1beta1/params')
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://axelar.nownodes.io/cosmos/mint/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/mint/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/mint/v1beta1/params";
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://axelar.nownodes.io/cosmos/mint/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/mint/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/mint/v1beta1/params')
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)

{
  "params": {
    "mint_denom": "string",
    "inflation_rate_change": "string",
    "inflation_max": "string",
    "inflation_min": "string",
    "goal_bonded": "string",
    "blocks_per_year": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params queries a specific parameter of a module, given its subspace and key.

GET

https://axelar.nownodes.io/cosmos/params/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

subspacestringquery

subspace defines the module to query the parameter for.

keystringquery

key defines the key of the parameter in the subspace.

Response

200OK

A successful response.

default

An unexpected error response

Params queries a specific parameter of a module, given its subspace and key.

curl -X GET 'https://axelar.nownodes.io/cosmos/params/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/cosmos/params/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/params/v1beta1/params')
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://axelar.nownodes.io/cosmos/params/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/params/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/params/v1beta1/params";
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://axelar.nownodes.io/cosmos/params/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/params/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/params/v1beta1/params')
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)

{
  "param": {
    "subspace": "string",
    "key": "string",
    "value": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params queries the parameters of slashing module

GET

https://axelar.nownodes.io/cosmos/slashing/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

Params queries the parameters of slashing module

curl -X GET 'https://axelar.nownodes.io/cosmos/slashing/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/cosmos/slashing/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/slashing/v1beta1/params')
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://axelar.nownodes.io/cosmos/slashing/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/slashing/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/slashing/v1beta1/params";
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://axelar.nownodes.io/cosmos/slashing/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/slashing/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/slashing/v1beta1/params')
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)

{
  "params": {
    "signed_blocks_window": "string",
    "min_signed_per_window": "dGVzdA==",
    "downtime_jail_duration": "string",
    "slash_fraction_double_sign": "dGVzdA==",
    "slash_fraction_downtime": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

SigningInfos queries signing info of all validators

GET

https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

SigningInfos queries signing info of all validators

curl -X GET 'https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos'

const response = await fetch('https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos')
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://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos";
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://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos')
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)

{
  "info": [
    {
      "address": "string",
      "start_height": "string",
      "index_offset": "string",
      "jailed_until": "2024-01-15T09:30:00Z",
      "tombstoned": true,
      "missed_blocks_counter": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

SigningInfo queries the signing info of given cons address

GET

https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos/{cons_address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

cons_addressstringrequiredpath

cons_address is the address to query signing info of

Response

200OK

A successful response.

default

An unexpected error response

SigningInfo queries the signing info of given cons address

curl -X GET 'https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos/{cons_address}'

const response = await fetch('https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos/{cons_address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos/{cons_address}')
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://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos/{cons_address}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos/{cons_address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos/{cons_address}";
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://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos/{cons_address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos/{cons_address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/slashing/v1beta1/signing_infos/{cons_address}')
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)

{
  "val_signing_info": {
    "address": "string",
    "start_height": "string",
    "index_offset": "string",
    "jailed_until": "2024-01-15T09:30:00Z",
    "tombstoned": true,
    "missed_blocks_counter": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DelegatorDelegations queries all delegations of a given delegator address.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/delegations/{delegator_addr}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addrstringrequiredpath

delegator_addr defines the delegator address to query for.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

DelegatorDelegations queries all delegations of a given delegator address.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/delegations/{delegator_addr}'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegations/{delegator_addr}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegations/{delegator_addr}')
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://axelar.nownodes.io/cosmos/staking/v1beta1/delegations/{delegator_addr}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegations/{delegator_addr}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/delegations/{delegator_addr}";
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://axelar.nownodes.io/cosmos/staking/v1beta1/delegations/{delegator_addr}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegations/{delegator_addr}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegations/{delegator_addr}')
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)

{
  "delegation_responses": [
    {
      "delegation": {
        "delegator_address": "string",
        "validator_address": "string",
        "shares": "string"
      },
      "balance": {
        "denom": "string",
        "amount": "string"
      }
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Redelegations queries redelegations of given address.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addrstringrequiredpath

delegator_addr defines the delegator address to query for.

src_validator_addrstringquery

src_validator_addr defines the validator address to redelegate from.

dst_validator_addrstringquery

dst_validator_addr defines the validator address to redelegate to.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

Redelegations queries redelegations of given address.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations')
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://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations";
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://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations')
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)

{
  "redelegation_responses": [
    {
      "redelegation": {
        "delegator_address": "string",
        "validator_src_address": "string",
        "validator_dst_address": "string",
        "entries": [
          {
            "creation_height": "string",
            "completion_time": "2024-01-15T09:30:00Z",
            "initial_balance": "string",
            "shares_dst": "string"
          }
        ]
      },
      "entries": [
        {
          "redelegation_entry": {
            "creation_height": "string",
            "completion_time": "2024-01-15T09:30:00Z",
            "initial_balance": "string",
            "shares_dst": "string"
          },
          "balance": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DelegatorUnbondingDelegations queries all unbonding delegations of a given delegator address.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addrstringrequiredpath

delegator_addr defines the delegator address to query for.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

DelegatorUnbondingDelegations queries all unbonding delegations of a given delegator address.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations')
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://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations";
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://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations')
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)

{
  "unbonding_responses": [
    {
      "delegator_address": "string",
      "validator_address": "string",
      "entries": [
        {
          "creation_height": "string",
          "completion_time": "2024-01-15T09:30:00Z",
          "initial_balance": "string",
          "balance": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DelegatorValidators queries all validators info for given delegator address.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addrstringrequiredpath

delegator_addr defines the delegator address to query for.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

DelegatorValidators queries all validators info for given delegator address.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/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://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/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://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/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)

{
  "validators": [
    {
      "operator_address": "string",
      "consensus_pubkey": {
        "type_url": "string",
        "value": "dGVzdA=="
      },
      "jailed": true,
      "status": "BOND_STATUS_UNSPECIFIED",
      "tokens": "string",
      "delegator_shares": "string",
      "description": {
        "moniker": "string",
        "identity": "string",
        "website": "string",
        "security_contact": "string",
        "details": "string"
      },
      "unbonding_height": "string",
      "unbonding_time": "2024-01-15T09:30:00Z",
      "commission": {
        "commission_rates": {
          "rate": "string",
          "max_rate": "string",
          "max_change_rate": "string"
        },
        "update_time": "2024-01-15T09:30:00Z"
      },
      "min_self_delegation": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DelegatorValidator queries validator info for given delegator validator pair.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addrstringrequiredpath

delegator_addr defines the delegator address to query for.

validator_addrstringrequiredpath

validator_addr defines the validator address to query for.

Response

200OK

A successful response.

default

An unexpected error response

DelegatorValidator queries validator info for given delegator validator pair.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}')
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://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}";
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://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}')
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)

{
  "validator": {
    "operator_address": "string",
    "consensus_pubkey": {
      "type_url": "string",
      "value": "dGVzdA=="
    },
    "jailed": true,
    "status": "BOND_STATUS_UNSPECIFIED",
    "tokens": "string",
    "delegator_shares": "string",
    "description": {
      "moniker": "string",
      "identity": "string",
      "website": "string",
      "security_contact": "string",
      "details": "string"
    },
    "unbonding_height": "string",
    "unbonding_time": "2024-01-15T09:30:00Z",
    "commission": {
      "commission_rates": {
        "rate": "string",
        "max_rate": "string",
        "max_change_rate": "string"
      },
      "update_time": "2024-01-15T09:30:00Z"
    },
    "min_self_delegation": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

HistoricalInfo queries the historical info for given height.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/historical_info/{height}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

heightstring<int64>requiredpath

height defines at which height to query the historical info.

Response

200OK

A successful response.

default

An unexpected error response

HistoricalInfo queries the historical info for given height.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/historical_info/{height}'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/historical_info/{height}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/historical_info/{height}')
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://axelar.nownodes.io/cosmos/staking/v1beta1/historical_info/{height}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/historical_info/{height}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/historical_info/{height}";
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://axelar.nownodes.io/cosmos/staking/v1beta1/historical_info/{height}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/historical_info/{height}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/historical_info/{height}')
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)

{
  "hist": {
    "header": {
      "version": {
        "block": "string",
        "app": "string"
      },
      "chain_id": "string",
      "height": "string",
      "time": "2024-01-15T09:30:00Z",
      "last_block_id": {
        "hash": "dGVzdA==",
        "part_set_header": {
          "total": 0,
          "hash": "dGVzdA=="
        }
      },
      "last_commit_hash": "dGVzdA==",
      "data_hash": "dGVzdA==",
      "validators_hash": "dGVzdA==",
      "next_validators_hash": "dGVzdA==",
      "consensus_hash": "dGVzdA==",
      "app_hash": "dGVzdA==",
      "last_results_hash": "dGVzdA==",
      "evidence_hash": "dGVzdA==",
      "proposer_address": "dGVzdA=="
    },
    "valset": [
      {
        "operator_address": "string",
        "consensus_pubkey": {
          "type_url": "string",
          "value": "dGVzdA=="
        },
        "jailed": true,
        "status": "BOND_STATUS_UNSPECIFIED",
        "tokens": "string",
        "delegator_shares": "string",
        "description": {
          "moniker": "string",
          "identity": "string",
          "website": "string",
          "security_contact": "string",
          "details": "string"
        },
        "unbonding_height": "string",
        "unbonding_time": "2024-01-15T09:30:00Z",
        "commission": {
          "commission_rates": {
            "rate": "string",
            "max_rate": "string",
            "max_change_rate": "string"
          },
          "update_time": "2024-01-15T09:30:00Z"
        },
        "min_self_delegation": "string"
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Parameters queries the staking parameters.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

Parameters queries the staking parameters.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/params')
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://axelar.nownodes.io/cosmos/staking/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/params";
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://axelar.nownodes.io/cosmos/staking/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/params')
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)

{
  "params": {
    "unbonding_time": "string",
    "max_validators": 0,
    "max_entries": 0,
    "historical_entries": 0,
    "bond_denom": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Pool queries the pool info.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/pool

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

Pool queries the pool info.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/pool'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/pool', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/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://axelar.nownodes.io/cosmos/staking/v1beta1/pool')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/pool', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/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://axelar.nownodes.io/cosmos/staking/v1beta1/pool', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/pool')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/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)

{
  "pool": {
    "not_bonded_tokens": "string",
    "bonded_tokens": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Validators queries all validators that match the given status.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/validators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

statusstringquery

status enables to query for validators matching a given status.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

Validators queries all validators that match the given status.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/validators'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/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://axelar.nownodes.io/cosmos/staking/v1beta1/validators')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/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://axelar.nownodes.io/cosmos/staking/v1beta1/validators', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/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)

{
  "validators": [
    {
      "operator_address": "string",
      "consensus_pubkey": {
        "type_url": "string",
        "value": "dGVzdA=="
      },
      "jailed": true,
      "status": "BOND_STATUS_UNSPECIFIED",
      "tokens": "string",
      "delegator_shares": "string",
      "description": {
        "moniker": "string",
        "identity": "string",
        "website": "string",
        "security_contact": "string",
        "details": "string"
      },
      "unbonding_height": "string",
      "unbonding_time": "2024-01-15T09:30:00Z",
      "commission": {
        "commission_rates": {
          "rate": "string",
          "max_rate": "string",
          "max_change_rate": "string"
        },
        "update_time": "2024-01-15T09:30:00Z"
      },
      "min_self_delegation": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Validator queries validator info for given validator address.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validator_addrstringrequiredpath

validator_addr defines the validator address to query for.

Response

200OK

A successful response.

default

An unexpected error response

Validator queries validator info for given validator address.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}')
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://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}";
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://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}')
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)

{
  "validator": {
    "operator_address": "string",
    "consensus_pubkey": {
      "type_url": "string",
      "value": "dGVzdA=="
    },
    "jailed": true,
    "status": "BOND_STATUS_UNSPECIFIED",
    "tokens": "string",
    "delegator_shares": "string",
    "description": {
      "moniker": "string",
      "identity": "string",
      "website": "string",
      "security_contact": "string",
      "details": "string"
    },
    "unbonding_height": "string",
    "unbonding_time": "2024-01-15T09:30:00Z",
    "commission": {
      "commission_rates": {
        "rate": "string",
        "max_rate": "string",
        "max_change_rate": "string"
      },
      "update_time": "2024-01-15T09:30:00Z"
    },
    "min_self_delegation": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ValidatorDelegations queries delegate info for given validator.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validator_addrstringrequiredpath

validator_addr defines the validator address to query for.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

ValidatorDelegations queries delegate info for given validator.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations')
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://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations";
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://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations')
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)

{
  "delegation_responses": [
    {
      "delegation": {
        "delegator_address": "string",
        "validator_address": "string",
        "shares": "string"
      },
      "balance": {
        "denom": "string",
        "amount": "string"
      }
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Delegation queries delegate info for given validator delegator pair.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validator_addrstringrequiredpath

validator_addr defines the validator address to query for.

delegator_addrstringrequiredpath

delegator_addr defines the delegator address to query for.

Response

200OK

A successful response.

default

An unexpected error response

Delegation queries delegate info for given validator delegator pair.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}')
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://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}";
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://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}')
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)

{
  "delegation_response": {
    "delegation": {
      "delegator_address": "string",
      "validator_address": "string",
      "shares": "string"
    },
    "balance": {
      "denom": "string",
      "amount": "string"
    }
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

UnbondingDelegation queries unbonding info for given validator delegator pair.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validator_addrstringrequiredpath

validator_addr defines the validator address to query for.

delegator_addrstringrequiredpath

delegator_addr defines the delegator address to query for.

Response

200OK

A successful response.

default

An unexpected error response

UnbondingDelegation queries unbonding info for given validator delegator pair.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation')
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://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation";
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://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation')
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)

{
  "unbond": {
    "delegator_address": "string",
    "validator_address": "string",
    "entries": [
      {
        "creation_height": "string",
        "completion_time": "2024-01-15T09:30:00Z",
        "initial_balance": "string",
        "balance": "string"
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ValidatorUnbondingDelegations queries unbonding delegations of a validator.

GET

https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validator_addrstringrequiredpath

validator_addr defines the validator address to query for.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

ValidatorUnbondingDelegations queries unbonding delegations of a validator.

curl -X GET 'https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations'

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations')
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://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations";
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://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations')
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)

{
  "unbonding_responses": [
    {
      "delegator_address": "string",
      "validator_address": "string",
      "entries": [
        {
          "creation_height": "string",
          "completion_time": "2024-01-15T09:30:00Z",
          "initial_balance": "string",
          "balance": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

AppliedPlan queries a previously applied upgrade plan by its name.

GET

https://axelar.nownodes.io/cosmos/upgrade/v1beta1/applied_plan/{name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

namestringrequiredpath

name is the name of the applied plan to query for.

Response

200OK

A successful response.

default

An unexpected error response

AppliedPlan queries a previously applied upgrade plan by its name.

curl -X GET 'https://axelar.nownodes.io/cosmos/upgrade/v1beta1/applied_plan/{name}'

const response = await fetch('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/applied_plan/{name}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/applied_plan/{name}')
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://axelar.nownodes.io/cosmos/upgrade/v1beta1/applied_plan/{name}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/applied_plan/{name}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/upgrade/v1beta1/applied_plan/{name}";
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://axelar.nownodes.io/cosmos/upgrade/v1beta1/applied_plan/{name}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/applied_plan/{name}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/applied_plan/{name}')
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)

{
  "height": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

CurrentPlan queries the current upgrade plan.

GET

https://axelar.nownodes.io/cosmos/upgrade/v1beta1/current_plan

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

CurrentPlan queries the current upgrade plan.

curl -X GET 'https://axelar.nownodes.io/cosmos/upgrade/v1beta1/current_plan'

const response = await fetch('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/current_plan', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/current_plan')
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://axelar.nownodes.io/cosmos/upgrade/v1beta1/current_plan')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/current_plan', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/upgrade/v1beta1/current_plan";
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://axelar.nownodes.io/cosmos/upgrade/v1beta1/current_plan', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/current_plan')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/current_plan')
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)

{
  "plan": {
    "name": "string",
    "time": "2024-01-15T09:30:00Z",
    "height": "string",
    "info": "string",
    "upgraded_client_state": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ModuleVersions queries the list of module versions from state.

GET

https://axelar.nownodes.io/cosmos/upgrade/v1beta1/module_versions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Since: cosmos-sdk 0.43

Parameters

module_namestringquery

module_name is a field to query a specific module consensus version from state. Leaving this empty will fetch the full list of module versions from state.

Response

200OK

A successful response.

default

An unexpected error response

ModuleVersions queries the list of module versions from state.

curl -X GET 'https://axelar.nownodes.io/cosmos/upgrade/v1beta1/module_versions'

const response = await fetch('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/module_versions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/module_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://axelar.nownodes.io/cosmos/upgrade/v1beta1/module_versions')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/module_versions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/upgrade/v1beta1/module_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://axelar.nownodes.io/cosmos/upgrade/v1beta1/module_versions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/module_versions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/upgrade/v1beta1/module_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)

{
  "module_versions": [
    {
      "name": "string",
      "version": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Axelarnet

Params queries the parameters of the axelarnet module

GET

https://axelar.nownodes.io/axelar/axelarnet/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

Params queries the parameters of the axelarnet module

curl -X GET 'https://axelar.nownodes.io/axelar/axelarnet/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/v1beta1/params')
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://axelar.nownodes.io/axelar/axelarnet/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/v1beta1/params";
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://axelar.nownodes.io/axelar/axelarnet/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/axelarnet/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/v1beta1/params')
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)

{
  "params": {
    "route_timeout_window": "string",
    "transfer_limit": "string",
    "end_blocker_limit": "string",
    "call_contracts_proposal_min_deposits": [
      {
        "chain": "string",
        "min_deposits": [
          {}
        ]
      }
    ],
    "chain_maintainer_missing_vote_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "chain_maintainer_incorrect_vote_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "chain_maintainer_check_window": 0
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {}
  ]
}

Service

GetLatestBlock returns the latest block.

GET

https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/latest

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

GetLatestBlock returns the latest block.

curl -X GET 'https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/latest'

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/latest', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/latest')
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://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/latest')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/latest', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/latest";
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://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/latest', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/latest')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/latest')
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)

{
  "block_id": {
    "hash": "dGVzdA==",
    "part_set_header": {
      "total": 0,
      "hash": "dGVzdA=="
    }
  },
  "block": {
    "header": {
      "version": {
        "block": "string",
        "app": "string"
      },
      "chain_id": "string",
      "height": "string",
      "time": "2024-01-15T09:30:00Z",
      "last_block_id": {
        "hash": "dGVzdA==",
        "part_set_header": {
          "total": 0,
          "hash": "dGVzdA=="
        }
      },
      "last_commit_hash": "dGVzdA==",
      "data_hash": "dGVzdA==",
      "validators_hash": "dGVzdA==",
      "next_validators_hash": "dGVzdA==",
      "consensus_hash": "dGVzdA==",
      "app_hash": "dGVzdA==",
      "last_results_hash": "dGVzdA==",
      "evidence_hash": "dGVzdA==",
      "proposer_address": "dGVzdA=="
    },
    "data": {
      "txs": [
        "dGVzdA=="
      ]
    },
    "evidence": {
      "evidence": [
        {
          "duplicate_vote_evidence": {
            "vote_a": {
              "type": "SIGNED_MSG_TYPE_UNKNOWN",
              "height": "string",
              "round": 0,
              "block_id": {
                "hash": "dGVzdA==",
                "part_set_header": {
                  "total": 0,
                  "hash": "dGVzdA=="
                }
              },
              "timestamp": "2024-01-15T09:30:00Z",
              "validator_address": "dGVzdA==",
              "validator_index": 0,
              "signature": "dGVzdA=="
            },
            "vote_b": {
              "type": "SIGNED_MSG_TYPE_UNKNOWN",
              "height": "string",
              "round": 0,
              "block_id": {
                "hash": "dGVzdA==",
                "part_set_header": {
                  "total": 0,
                  "hash": "dGVzdA=="
                }
              },
              "timestamp": "2024-01-15T09:30:00Z",
              "validator_address": "dGVzdA==",
              "validator_index": 0,
              "signature": "dGVzdA=="
            },
            "total_voting_power": "string",
            "validator_power": "string",
            "timestamp": "2024-01-15T09:30:00Z"
          },
          "light_client_attack_evidence": {
            "conflicting_block": {
              "signed_header": {
                "header": {
                  "version": {
                    "block": "string",
                    "app": "string"
                  },
                  "chain_id": "string",
                  "height": "string",
                  "time": "2024-01-15T09:30:00Z",
                  "last_block_id": {
                    "hash": "dGVzdA==",
                    "part_set_header": {
                      "total": 0,
                      "hash": "dGVzdA=="
                    }
                  },
                  "last_commit_hash": "dGVzdA==",
                  "data_hash": "dGVzdA==",
                  "validators_hash": "dGVzdA==",
                  "next_validators_hash": "dGVzdA==",
                  "consensus_hash": "dGVzdA==",
                  "app_hash": "dGVzdA==",
                  "last_results_hash": "dGVzdA==",
                  "evidence_hash": "dGVzdA==",
                  "proposer_address": "dGVzdA=="
                },
                "commit": {
                  "height": "string",
                  "round": 0,
                  "block_id": {
                    "hash": "dGVzdA==",
                    "part_set_header": {
                      "total": 0,
                      "hash": "dGVzdA=="
                    }
                  },
                  "signatures": [
                    {
                      "block_id_flag": "BLOCK_ID_FLAG_UNKNOWN",
                      "validator_address": "dGVzdA==",
                      "timestamp": "2024-01-15T09:30:00Z",
                      "signature": "dGVzdA=="
                    }
                  ]
                }
              },
              "validator_set": {
                "validators": [
                  {
                    "address": "dGVzdA==",
                    "pub_key": {
                      "ed25519": "dGVzdA==",
                      "secp256k1": "dGVzdA=="
                    },
                    "voting_power": "string",
                    "proposer_priority": "string"
                  }
                ],
                "proposer": {
                  "address": "dGVzdA==",
                  "pub_key": {
                    "ed25519": "dGVzdA==",
                    "secp256k1": "dGVzdA=="
                  },
                  "voting_power": "string",
                  "proposer_priority": "string"
                },
                "total_voting_power": "string"
              }
            },
            "common_height": "string",
            "byzantine_validators": [
              {
                "address": "dGVzdA==",
                "pub_key": {
                  "ed25519": "dGVzdA==",
                  "secp256k1": "dGVzdA=="
                },
                "voting_power": "string",
                "proposer_priority": "string"
              }
            ],
            "total_voting_power": "string",
            "timestamp": "2024-01-15T09:30:00Z"
          }
        }
      ]
    },
    "last_commit": {
      "height": "string",
      "round": 0,
      "block_id": {
        "hash": "dGVzdA==",
        "part_set_header": {
          "total": 0,
          "hash": "dGVzdA=="
        }
      },
      "signatures": [
        {
          "block_id_flag": "BLOCK_ID_FLAG_UNKNOWN",
          "validator_address": "dGVzdA==",
          "timestamp": "2024-01-15T09:30:00Z",
          "signature": "dGVzdA=="
        }
      ]
    }
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GetBlockByHeight queries block for given height.

GET

https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/{height}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

heightstring<int64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response

GetBlockByHeight queries block for given height.

curl -X GET 'https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/{height}'

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/{height}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/{height}')
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://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/{height}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/{height}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/{height}";
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://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/{height}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/{height}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/blocks/{height}')
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)

{
  "block_id": {
    "hash": "dGVzdA==",
    "part_set_header": {
      "total": 0,
      "hash": "dGVzdA=="
    }
  },
  "block": {
    "header": {
      "version": {
        "block": "string",
        "app": "string"
      },
      "chain_id": "string",
      "height": "string",
      "time": "2024-01-15T09:30:00Z",
      "last_block_id": {
        "hash": "dGVzdA==",
        "part_set_header": {
          "total": 0,
          "hash": "dGVzdA=="
        }
      },
      "last_commit_hash": "dGVzdA==",
      "data_hash": "dGVzdA==",
      "validators_hash": "dGVzdA==",
      "next_validators_hash": "dGVzdA==",
      "consensus_hash": "dGVzdA==",
      "app_hash": "dGVzdA==",
      "last_results_hash": "dGVzdA==",
      "evidence_hash": "dGVzdA==",
      "proposer_address": "dGVzdA=="
    },
    "data": {
      "txs": [
        "dGVzdA=="
      ]
    },
    "evidence": {
      "evidence": [
        {
          "duplicate_vote_evidence": {
            "vote_a": {
              "type": "SIGNED_MSG_TYPE_UNKNOWN",
              "height": "string",
              "round": 0,
              "block_id": {
                "hash": "dGVzdA==",
                "part_set_header": {
                  "total": 0,
                  "hash": "dGVzdA=="
                }
              },
              "timestamp": "2024-01-15T09:30:00Z",
              "validator_address": "dGVzdA==",
              "validator_index": 0,
              "signature": "dGVzdA=="
            },
            "vote_b": {
              "type": "SIGNED_MSG_TYPE_UNKNOWN",
              "height": "string",
              "round": 0,
              "block_id": {
                "hash": "dGVzdA==",
                "part_set_header": {
                  "total": 0,
                  "hash": "dGVzdA=="
                }
              },
              "timestamp": "2024-01-15T09:30:00Z",
              "validator_address": "dGVzdA==",
              "validator_index": 0,
              "signature": "dGVzdA=="
            },
            "total_voting_power": "string",
            "validator_power": "string",
            "timestamp": "2024-01-15T09:30:00Z"
          },
          "light_client_attack_evidence": {
            "conflicting_block": {
              "signed_header": {
                "header": {
                  "version": {
                    "block": "string",
                    "app": "string"
                  },
                  "chain_id": "string",
                  "height": "string",
                  "time": "2024-01-15T09:30:00Z",
                  "last_block_id": {
                    "hash": "dGVzdA==",
                    "part_set_header": {
                      "total": 0,
                      "hash": "dGVzdA=="
                    }
                  },
                  "last_commit_hash": "dGVzdA==",
                  "data_hash": "dGVzdA==",
                  "validators_hash": "dGVzdA==",
                  "next_validators_hash": "dGVzdA==",
                  "consensus_hash": "dGVzdA==",
                  "app_hash": "dGVzdA==",
                  "last_results_hash": "dGVzdA==",
                  "evidence_hash": "dGVzdA==",
                  "proposer_address": "dGVzdA=="
                },
                "commit": {
                  "height": "string",
                  "round": 0,
                  "block_id": {
                    "hash": "dGVzdA==",
                    "part_set_header": {
                      "total": 0,
                      "hash": "dGVzdA=="
                    }
                  },
                  "signatures": [
                    {
                      "block_id_flag": "BLOCK_ID_FLAG_UNKNOWN",
                      "validator_address": "dGVzdA==",
                      "timestamp": "2024-01-15T09:30:00Z",
                      "signature": "dGVzdA=="
                    }
                  ]
                }
              },
              "validator_set": {
                "validators": [
                  {
                    "address": "dGVzdA==",
                    "pub_key": {
                      "ed25519": "dGVzdA==",
                      "secp256k1": "dGVzdA=="
                    },
                    "voting_power": "string",
                    "proposer_priority": "string"
                  }
                ],
                "proposer": {
                  "address": "dGVzdA==",
                  "pub_key": {
                    "ed25519": "dGVzdA==",
                    "secp256k1": "dGVzdA=="
                  },
                  "voting_power": "string",
                  "proposer_priority": "string"
                },
                "total_voting_power": "string"
              }
            },
            "common_height": "string",
            "byzantine_validators": [
              {
                "address": "dGVzdA==",
                "pub_key": {
                  "ed25519": "dGVzdA==",
                  "secp256k1": "dGVzdA=="
                },
                "voting_power": "string",
                "proposer_priority": "string"
              }
            ],
            "total_voting_power": "string",
            "timestamp": "2024-01-15T09:30:00Z"
          }
        }
      ]
    },
    "last_commit": {
      "height": "string",
      "round": 0,
      "block_id": {
        "hash": "dGVzdA==",
        "part_set_header": {
          "total": 0,
          "hash": "dGVzdA=="
        }
      },
      "signatures": [
        {
          "block_id_flag": "BLOCK_ID_FLAG_UNKNOWN",
          "validator_address": "dGVzdA==",
          "timestamp": "2024-01-15T09:30:00Z",
          "signature": "dGVzdA=="
        }
      ]
    }
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GetNodeInfo queries the current node info.

GET

https://axelar.nownodes.io/cosmos/base/comet/v1beta1/node_info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

GetNodeInfo queries the current node info.

curl -X GET 'https://axelar.nownodes.io/cosmos/base/comet/v1beta1/node_info'

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/node_info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/node_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://axelar.nownodes.io/cosmos/base/comet/v1beta1/node_info')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/node_info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/base/comet/v1beta1/node_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://axelar.nownodes.io/cosmos/base/comet/v1beta1/node_info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/node_info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/node_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)

{
  "default_node_info": {
    "protocol_version": {
      "p2p": "string",
      "block": "string",
      "app": "string"
    },
    "default_node_id": "string",
    "listen_addr": "string",
    "network": "string",
    "version": "string",
    "channels": "dGVzdA==",
    "moniker": "string",
    "other": {
      "tx_index": "string",
      "rpc_address": "string"
    }
  },
  "application_version": {
    "name": "string",
    "app_name": "string",
    "version": "string",
    "git_commit": "string",
    "build_tags": "string",
    "go_version": "string",
    "build_deps": [
      {
        "path": "string",
        "version": "string",
        "sum": "string"
      }
    ],
    "cosmos_sdk_version": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GetSyncing queries node syncing.

GET

https://axelar.nownodes.io/cosmos/base/comet/v1beta1/syncing

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

GetSyncing queries node syncing.

curl -X GET 'https://axelar.nownodes.io/cosmos/base/comet/v1beta1/syncing'

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/syncing', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/syncing')
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://axelar.nownodes.io/cosmos/base/comet/v1beta1/syncing')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/syncing', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/base/comet/v1beta1/syncing";
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://axelar.nownodes.io/cosmos/base/comet/v1beta1/syncing', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/syncing')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/syncing')
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)

{
  "syncing": true
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GetLatestValidatorSet queries latest validator-set.

GET

https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/latest

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

GetLatestValidatorSet queries latest validator-set.

curl -X GET 'https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/latest'

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/latest', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/latest')
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://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/latest')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/latest', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/latest";
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://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/latest', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/latest')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/latest')
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)

{
  "block_height": "string",
  "validators": [
    {
      "address": "string",
      "pub_key": {
        "type_url": "string",
        "value": "dGVzdA=="
      },
      "voting_power": "string",
      "proposer_priority": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GetValidatorSetByHeight queries validator-set at a given height.

GET

https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/{height}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

heightstring<int64>requiredpath

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalboolean<boolean>query

pagination.reverseboolean<boolean>query

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response

GetValidatorSetByHeight queries validator-set at a given height.

curl -X GET 'https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/{height}'

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/{height}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/{height}')
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://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/{height}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/{height}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/{height}";
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://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/{height}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/{height}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/comet/v1beta1/validatorsets/{height}')
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)

{
  "block_height": "string",
  "validators": [
    {
      "address": "string",
      "pub_key": {
        "type_url": "string",
        "value": "dGVzdA=="
      },
      "voting_power": "string",
      "proposer_priority": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Documentation

How to migrate to NOWNodes

Authentication

API Reference

QueryService

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

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

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Query

Authorizations

Response

Authorizations

Response

Authorizations