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

MsgService

POST

https://axelar.nownodes.io/axelar/axelarnet/add_cosmos_based_chain

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainobject

Show child attributes

namestring

supports_foreign_assetsboolean<boolean>

key_typestringKEY_TYPE_UNSPECIFIEDKEY_TYPE_NONEKEY_TYPE_THRESHOLDKEY_TYPE_MULTISIGKEY_TYPE_UNSPECIFIED

modulestring

addr_prefixstring

native_assetsArray<object>

Show child attributes

denomstring

is_native_assetboolean<boolean>

cosmos_chainstring

ibc_pathstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/add_cosmos_based_chain

curl -X POST 'https://axelar.nownodes.io/axelar/axelarnet/add_cosmos_based_chain' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": {
      "name": "string",
      "supports_foreign_assets": true,
      "key_type": "KEY_TYPE_UNSPECIFIED",
      "module": "string"
    },
    "addr_prefix": "string",
    "native_assets": [
      {
        "denom": "string",
        "is_native_asset": true
      }
    ],
    "cosmos_chain": "string",
    "ibc_path": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/add_cosmos_based_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": {
        "name": "string",
        "supports_foreign_assets": true,
        "key_type": "KEY_TYPE_UNSPECIFIED",
        "module": "string"
      },
      "addr_prefix": "string",
      "native_assets": [
        {
          "denom": "string",
          "is_native_asset": true
        }
      ],
      "cosmos_chain": "string",
      "ibc_path": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/add_cosmos_based_chain')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": {
      "name": "string",
      "supports_foreign_assets": true,
      "key_type": "KEY_TYPE_UNSPECIFIED",
      "module": "string"
    },
    "addr_prefix": "string",
    "native_assets": [
      {
        "denom": "string",
        "is_native_asset": true
      }
    ],
    "cosmos_chain": "string",
    "ibc_path": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": {
    "name": "string",
    "supports_foreign_assets": True,
    "key_type": "KEY_TYPE_UNSPECIFIED",
    "module": "string"
  },
  "addr_prefix": "string",
  "native_assets": [
    {
      "denom": "string",
      "is_native_asset": True
    }
  ],
  "cosmos_chain": "string",
  "ibc_path": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/add_cosmos_based_chain', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/add_cosmos_based_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": {
        "name": "string",
        "supports_foreign_assets": true,
        "key_type": "KEY_TYPE_UNSPECIFIED",
        "module": "string"
      },
      "addr_prefix": "string",
      "native_assets": [
        {
          "denom": "string",
          "is_native_asset": true
        }
      ],
      "cosmos_chain": "string",
      "ibc_path": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/add_cosmos_based_chain";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": {
      "name": "string",
      "supports_foreign_assets": true,
      "key_type": "KEY_TYPE_UNSPECIFIED",
      "module": "string"
    },
    "addr_prefix": "string",
    "native_assets": [
      {
        "denom": "string",
        "is_native_asset": true
      }
    ],
    "cosmos_chain": "string",
    "ibc_path": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/add_cosmos_based_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": {
        "name": "string",
        "supports_foreign_assets": true,
        "key_type": "KEY_TYPE_UNSPECIFIED",
        "module": "string"
      },
      "addr_prefix": "string",
      "native_assets": [
        {
          "denom": "string",
          "is_native_asset": true
        }
      ],
      "cosmos_chain": "string",
      "ibc_path": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": {
    "name": "string",
    "supports_foreign_assets": True,
    "key_type": "KEY_TYPE_UNSPECIFIED",
    "module": "string"
  },
  "addr_prefix": "string",
  "native_assets": [
    {
      "denom": "string",
      "is_native_asset": True
    }
  ],
  "cosmos_chain": "string",
  "ibc_path": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/add_cosmos_based_chain', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/add_cosmos_based_chain')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": {
      "name": "string",
      "supports_foreign_assets": true,
      "key_type": "KEY_TYPE_UNSPECIFIED",
      "module": "string"
    },
    "addr_prefix": "string",
    "native_assets": [
      {
        "denom": "string",
        "is_native_asset": true
      }
    ],
    "cosmos_chain": "string",
    "ibc_path": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": {
    "name": "string",
    "supports_foreign_assets": true,
    "key_type": "KEY_TYPE_UNSPECIFIED",
    "module": "string"
  },
  "addr_prefix": "string",
  "native_assets": [
    {
      "denom": "string",
      "is_native_asset": true
    }
  ],
  "cosmos_chain": "string",
  "ibc_path": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/axelarnet/call_contract

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

contract_addressstring

payloadstring<byte>

feeobject

Show child attributes

amountobject

Coin defines a token with a denomination and an amount.

NOTE: The amount field is an Int which implements the custom method signatures required by gogoproto.

Show child attributes

denomstring

amountstring

recipientstring<byte>

refund_recipientstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/call_contract

curl -X POST 'https://axelar.nownodes.io/axelar/axelarnet/call_contract' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "contract_address": "string",
    "payload": "dGVzdA==",
    "fee": {
      "amount": {
        "denom": "string",
        "amount": "string"
      },
      "recipient": "dGVzdA==",
      "refund_recipient": "dGVzdA=="
    }
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/call_contract', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "contract_address": "string",
      "payload": "dGVzdA==",
      "fee": {
        "amount": {
          "denom": "string",
          "amount": "string"
        },
        "recipient": "dGVzdA==",
        "refund_recipient": "dGVzdA=="
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/call_contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "contract_address": "string",
    "payload": "dGVzdA==",
    "fee": {
      "amount": {
        "denom": "string",
        "amount": "string"
      },
      "recipient": "dGVzdA==",
      "refund_recipient": "dGVzdA=="
    }
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "contract_address": "string",
  "payload": "dGVzdA==",
  "fee": {
    "amount": {
      "denom": "string",
      "amount": "string"
    },
    "recipient": "dGVzdA==",
    "refund_recipient": "dGVzdA=="
  }
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/call_contract', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/call_contract', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "contract_address": "string",
      "payload": "dGVzdA==",
      "fee": {
        "amount": {
          "denom": "string",
          "amount": "string"
        },
        "recipient": "dGVzdA==",
        "refund_recipient": "dGVzdA=="
      }
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/call_contract";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "contract_address": "string",
    "payload": "dGVzdA==",
    "fee": {
      "amount": {
        "denom": "string",
        "amount": "string"
      },
      "recipient": "dGVzdA==",
      "refund_recipient": "dGVzdA=="
    }
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/call_contract', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "contract_address": "string",
      "payload": "dGVzdA==",
      "fee": {
        "amount": {
          "denom": "string",
          "amount": "string"
        },
        "recipient": "dGVzdA==",
        "refund_recipient": "dGVzdA=="
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "contract_address": "string",
  "payload": "dGVzdA==",
  "fee": {
    "amount": {
      "denom": "string",
      "amount": "string"
    },
    "recipient": "dGVzdA==",
    "refund_recipient": "dGVzdA=="
  }
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/call_contract', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/call_contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "contract_address": "string",
    "payload": "dGVzdA==",
    "fee": {
      "amount": {
        "denom": "string",
        "amount": "string"
      },
      "recipient": "dGVzdA==",
      "refund_recipient": "dGVzdA=="
    }
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "contract_address": "string",
  "payload": "dGVzdA==",
  "fee": {
    "amount": {
      "denom": "string",
      "amount": "string"
    },
    "recipient": "dGVzdA==",
    "refund_recipient": "dGVzdA=="
  }
}

{}

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

POST

https://axelar.nownodes.io/axelar/axelarnet/confirm_deposit

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

deposit_addressstring<byte>

denomstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/confirm_deposit

curl -X POST 'https://axelar.nownodes.io/axelar/axelarnet/confirm_deposit' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "deposit_address": "dGVzdA==",
    "denom": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/confirm_deposit', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "deposit_address": "dGVzdA==",
      "denom": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/confirm_deposit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "deposit_address": "dGVzdA==",
    "denom": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "deposit_address": "dGVzdA==",
  "denom": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/confirm_deposit', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/confirm_deposit', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "deposit_address": "dGVzdA==",
      "denom": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/confirm_deposit";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "deposit_address": "dGVzdA==",
    "denom": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/confirm_deposit', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "deposit_address": "dGVzdA==",
      "denom": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "deposit_address": "dGVzdA==",
  "denom": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/confirm_deposit', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/confirm_deposit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "deposit_address": "dGVzdA==",
    "denom": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "deposit_address": "dGVzdA==",
  "denom": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/axelarnet/execute_pending_transfers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/execute_pending_transfers

curl -X POST 'https://axelar.nownodes.io/axelar/axelarnet/execute_pending_transfers' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/execute_pending_transfers', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/execute_pending_transfers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/execute_pending_transfers', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/execute_pending_transfers', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/execute_pending_transfers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/execute_pending_transfers', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/execute_pending_transfers', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/execute_pending_transfers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/axelarnet/link

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

recipient_addrstring

recipient_chainstring

assetstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/link

curl -X POST 'https://axelar.nownodes.io/axelar/axelarnet/link' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "recipient_addr": "string",
    "recipient_chain": "string",
    "asset": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/link', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "recipient_addr": "string",
      "recipient_chain": "string",
      "asset": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/link')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "recipient_addr": "string",
    "recipient_chain": "string",
    "asset": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "recipient_addr": "string",
  "recipient_chain": "string",
  "asset": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/link', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/link', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "recipient_addr": "string",
      "recipient_chain": "string",
      "asset": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/link";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "recipient_addr": "string",
    "recipient_chain": "string",
    "asset": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/link', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "recipient_addr": "string",
      "recipient_chain": "string",
      "asset": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "recipient_addr": "string",
  "recipient_chain": "string",
  "asset": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/link', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/link')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "recipient_addr": "string",
    "recipient_chain": "string",
    "asset": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "recipient_addr": "string",
  "recipient_chain": "string",
  "asset": "string"
}

{
  "deposit_addr": "string"
}

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

POST

https://axelar.nownodes.io/axelar/axelarnet/register_asset

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

assetobject

Show child attributes

denomstring

is_native_assetboolean<boolean>

limitstring<byte>

windowstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/register_asset

curl -X POST 'https://axelar.nownodes.io/axelar/axelarnet/register_asset' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "asset": {
      "denom": "string",
      "is_native_asset": true
    },
    "limit": "dGVzdA==",
    "window": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/register_asset', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "asset": {
        "denom": "string",
        "is_native_asset": true
      },
      "limit": "dGVzdA==",
      "window": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/register_asset')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "asset": {
      "denom": "string",
      "is_native_asset": true
    },
    "limit": "dGVzdA==",
    "window": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "asset": {
    "denom": "string",
    "is_native_asset": True
  },
  "limit": "dGVzdA==",
  "window": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/register_asset', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/register_asset', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "asset": {
        "denom": "string",
        "is_native_asset": true
      },
      "limit": "dGVzdA==",
      "window": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/register_asset";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "asset": {
      "denom": "string",
      "is_native_asset": true
    },
    "limit": "dGVzdA==",
    "window": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/register_asset', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "asset": {
        "denom": "string",
        "is_native_asset": true
      },
      "limit": "dGVzdA==",
      "window": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "asset": {
    "denom": "string",
    "is_native_asset": True
  },
  "limit": "dGVzdA==",
  "window": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/register_asset', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/register_asset')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "asset": {
      "denom": "string",
      "is_native_asset": true
    },
    "limit": "dGVzdA==",
    "window": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "asset": {
    "denom": "string",
    "is_native_asset": true
  },
  "limit": "dGVzdA==",
  "window": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/axelarnet/register_fee_collector

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

fee_collectorstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/register_fee_collector

curl -X POST 'https://axelar.nownodes.io/axelar/axelarnet/register_fee_collector' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "fee_collector": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/register_fee_collector', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "fee_collector": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/register_fee_collector')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "fee_collector": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "fee_collector": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/register_fee_collector', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/register_fee_collector', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "fee_collector": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/register_fee_collector";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "fee_collector": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/register_fee_collector', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "fee_collector": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "fee_collector": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/register_fee_collector', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/register_fee_collector')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "fee_collector": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "fee_collector": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/axelarnet/retry_ibc_transfer

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

idstring<uint64>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/retry_ibc_transfer

curl -X POST 'https://axelar.nownodes.io/axelar/axelarnet/retry_ibc_transfer' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "id": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/retry_ibc_transfer', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "id": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/retry_ibc_transfer')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "id": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "id": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/retry_ibc_transfer', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/retry_ibc_transfer', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "id": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/retry_ibc_transfer";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "id": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/retry_ibc_transfer', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "id": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "id": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/retry_ibc_transfer', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/retry_ibc_transfer')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "id": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "id": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/axelarnet/route_ibc_transfers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/route_ibc_transfers

curl -X POST 'https://axelar.nownodes.io/axelar/axelarnet/route_ibc_transfers' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/route_ibc_transfers', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/route_ibc_transfers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/route_ibc_transfers', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/route_ibc_transfers', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/route_ibc_transfers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/route_ibc_transfers', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/route_ibc_transfers', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/route_ibc_transfers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/axelarnet/route_message

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

idstring

payloadstring<byte>

feegranterstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/route_message

curl -X POST 'https://axelar.nownodes.io/axelar/axelarnet/route_message' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "id": "string",
    "payload": "dGVzdA==",
    "feegranter": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/route_message', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "id": "string",
      "payload": "dGVzdA==",
      "feegranter": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/route_message')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "id": "string",
    "payload": "dGVzdA==",
    "feegranter": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "id": "string",
  "payload": "dGVzdA==",
  "feegranter": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/route_message', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/route_message', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "id": "string",
      "payload": "dGVzdA==",
      "feegranter": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/axelarnet/route_message";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "id": "string",
    "payload": "dGVzdA==",
    "feegranter": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/axelarnet/route_message', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "id": "string",
      "payload": "dGVzdA==",
      "feegranter": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "id": "string",
  "payload": "dGVzdA==",
  "feegranter": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/axelarnet/route_message', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/route_message')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "id": "string",
    "payload": "dGVzdA==",
    "feegranter": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "id": "string",
  "payload": "dGVzdA==",
  "feegranter": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/add_chain

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

namestring

key_typestringKEY_TYPE_UNSPECIFIEDKEY_TYPE_NONEKEY_TYPE_THRESHOLDKEY_TYPE_MULTISIGKEY_TYPE_UNSPECIFIED

paramsstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/add_chain

curl -X POST 'https://axelar.nownodes.io/axelar/evm/add_chain' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "name": "string",
    "key_type": "KEY_TYPE_UNSPECIFIED",
    "params": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/add_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "name": "string",
      "key_type": "KEY_TYPE_UNSPECIFIED",
      "params": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/add_chain')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "name": "string",
    "key_type": "KEY_TYPE_UNSPECIFIED",
    "params": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "name": "string",
  "key_type": "KEY_TYPE_UNSPECIFIED",
  "params": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/add_chain', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/add_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "name": "string",
      "key_type": "KEY_TYPE_UNSPECIFIED",
      "params": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/add_chain";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "name": "string",
    "key_type": "KEY_TYPE_UNSPECIFIED",
    "params": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/add_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "name": "string",
      "key_type": "KEY_TYPE_UNSPECIFIED",
      "params": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "name": "string",
  "key_type": "KEY_TYPE_UNSPECIFIED",
  "params": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/add_chain', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/add_chain')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "name": "string",
    "key_type": "KEY_TYPE_UNSPECIFIED",
    "params": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "name": "string",
  "key_type": "KEY_TYPE_UNSPECIFIED",
  "params": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/confirm_deposit

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

tx_idstring<byte>

amountstring<byte>

burner_addressstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/confirm_deposit

curl -X POST 'https://axelar.nownodes.io/axelar/evm/confirm_deposit' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA==",
    "amount": "dGVzdA==",
    "burner_address": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_deposit', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA==",
      "amount": "dGVzdA==",
      "burner_address": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/confirm_deposit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA==",
    "amount": "dGVzdA==",
    "burner_address": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA==",
  "amount": "dGVzdA==",
  "burner_address": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/confirm_deposit', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_deposit', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA==",
      "amount": "dGVzdA==",
      "burner_address": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/confirm_deposit";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA==",
    "amount": "dGVzdA==",
    "burner_address": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_deposit', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA==",
      "amount": "dGVzdA==",
      "burner_address": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA==",
  "amount": "dGVzdA==",
  "burner_address": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/confirm_deposit', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/confirm_deposit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA==",
    "amount": "dGVzdA==",
    "burner_address": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA==",
  "amount": "dGVzdA==",
  "burner_address": "dGVzdA=="
}

{}

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

Deprecated: use ConfirmGatewayTxs instead

POST

https://axelar.nownodes.io/axelar/evm/confirm_gateway_tx

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

tx_idstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

Deprecated: use ConfirmGatewayTxs instead

curl -X POST 'https://axelar.nownodes.io/axelar/evm/confirm_gateway_tx' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_gateway_tx', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/confirm_gateway_tx')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/confirm_gateway_tx', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_gateway_tx', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/confirm_gateway_tx";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_gateway_tx', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/confirm_gateway_tx', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/confirm_gateway_tx')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/confirm_gateway_txs

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

tx_idsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/confirm_gateway_txs

curl -X POST 'https://axelar.nownodes.io/axelar/evm/confirm_gateway_txs' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_ids": [
      "dGVzdA=="
    ]
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_gateway_txs', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_ids": [
        "dGVzdA=="
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/confirm_gateway_txs')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_ids": [
      "dGVzdA=="
    ]
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_ids": [
    "dGVzdA=="
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/confirm_gateway_txs', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_gateway_txs', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_ids": [
        "dGVzdA=="
      ]
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/confirm_gateway_txs";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_ids": [
      "dGVzdA=="
    ]
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_gateway_txs', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_ids": [
        "dGVzdA=="
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_ids": [
    "dGVzdA=="
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/confirm_gateway_txs', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/confirm_gateway_txs')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_ids": [
      "dGVzdA=="
    ]
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_ids": [
    "dGVzdA=="
  ]
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/confirm_token

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

tx_idstring<byte>

assetobject

Show child attributes

chainstring

namestring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/confirm_token

curl -X POST 'https://axelar.nownodes.io/axelar/evm/confirm_token' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA==",
    "asset": {
      "chain": "string",
      "name": "string"
    }
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_token', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA==",
      "asset": {
        "chain": "string",
        "name": "string"
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/confirm_token')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA==",
    "asset": {
      "chain": "string",
      "name": "string"
    }
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA==",
  "asset": {
    "chain": "string",
    "name": "string"
  }
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/confirm_token', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_token', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA==",
      "asset": {
        "chain": "string",
        "name": "string"
      }
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/confirm_token";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA==",
    "asset": {
      "chain": "string",
      "name": "string"
    }
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_token', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA==",
      "asset": {
        "chain": "string",
        "name": "string"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA==",
  "asset": {
    "chain": "string",
    "name": "string"
  }
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/confirm_token', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/confirm_token')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA==",
    "asset": {
      "chain": "string",
      "name": "string"
    }
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA==",
  "asset": {
    "chain": "string",
    "name": "string"
  }
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/confirm_transfer_key

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

tx_idstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/confirm_transfer_key

curl -X POST 'https://axelar.nownodes.io/axelar/evm/confirm_transfer_key' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_transfer_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/confirm_transfer_key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/confirm_transfer_key', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_transfer_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/confirm_transfer_key";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/confirm_transfer_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "tx_id": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/confirm_transfer_key', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/confirm_transfer_key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "tx_id": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "tx_id": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/create_burn_tokens

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/create_burn_tokens

curl -X POST 'https://axelar.nownodes.io/axelar/evm/create_burn_tokens' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_burn_tokens', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/create_burn_tokens')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/create_burn_tokens', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_burn_tokens', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/create_burn_tokens";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_burn_tokens', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/create_burn_tokens', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/create_burn_tokens')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/create_deploy_token

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

assetobject

Show child attributes

chainstring

namestring

token_detailsobject

Show child attributes

token_namestring

symbolstring

decimalsinteger<int64>

capacitystring<byte>

addressstring<byte>

daily_mint_limitstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/create_deploy_token

curl -X POST 'https://axelar.nownodes.io/axelar/evm/create_deploy_token' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "asset": {
      "chain": "string",
      "name": "string"
    },
    "token_details": {
      "token_name": "string",
      "symbol": "string",
      "decimals": 0,
      "capacity": "dGVzdA=="
    },
    "address": "dGVzdA==",
    "daily_mint_limit": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_deploy_token', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "asset": {
        "chain": "string",
        "name": "string"
      },
      "token_details": {
        "token_name": "string",
        "symbol": "string",
        "decimals": 0,
        "capacity": "dGVzdA=="
      },
      "address": "dGVzdA==",
      "daily_mint_limit": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/create_deploy_token')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "asset": {
      "chain": "string",
      "name": "string"
    },
    "token_details": {
      "token_name": "string",
      "symbol": "string",
      "decimals": 0,
      "capacity": "dGVzdA=="
    },
    "address": "dGVzdA==",
    "daily_mint_limit": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "asset": {
    "chain": "string",
    "name": "string"
  },
  "token_details": {
    "token_name": "string",
    "symbol": "string",
    "decimals": 0,
    "capacity": "dGVzdA=="
  },
  "address": "dGVzdA==",
  "daily_mint_limit": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/create_deploy_token', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_deploy_token', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "asset": {
        "chain": "string",
        "name": "string"
      },
      "token_details": {
        "token_name": "string",
        "symbol": "string",
        "decimals": 0,
        "capacity": "dGVzdA=="
      },
      "address": "dGVzdA==",
      "daily_mint_limit": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/create_deploy_token";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "asset": {
      "chain": "string",
      "name": "string"
    },
    "token_details": {
      "token_name": "string",
      "symbol": "string",
      "decimals": 0,
      "capacity": "dGVzdA=="
    },
    "address": "dGVzdA==",
    "daily_mint_limit": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_deploy_token', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "asset": {
        "chain": "string",
        "name": "string"
      },
      "token_details": {
        "token_name": "string",
        "symbol": "string",
        "decimals": 0,
        "capacity": "dGVzdA=="
      },
      "address": "dGVzdA==",
      "daily_mint_limit": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "asset": {
    "chain": "string",
    "name": "string"
  },
  "token_details": {
    "token_name": "string",
    "symbol": "string",
    "decimals": 0,
    "capacity": "dGVzdA=="
  },
  "address": "dGVzdA==",
  "daily_mint_limit": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/create_deploy_token', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/create_deploy_token')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "asset": {
      "chain": "string",
      "name": "string"
    },
    "token_details": {
      "token_name": "string",
      "symbol": "string",
      "decimals": 0,
      "capacity": "dGVzdA=="
    },
    "address": "dGVzdA==",
    "daily_mint_limit": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "asset": {
    "chain": "string",
    "name": "string"
  },
  "token_details": {
    "token_name": "string",
    "symbol": "string",
    "decimals": 0,
    "capacity": "dGVzdA=="
  },
  "address": "dGVzdA==",
  "daily_mint_limit": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/create_pending_transfers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/create_pending_transfers

curl -X POST 'https://axelar.nownodes.io/axelar/evm/create_pending_transfers' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_pending_transfers', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/create_pending_transfers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/create_pending_transfers', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_pending_transfers', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/create_pending_transfers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_pending_transfers', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/create_pending_transfers', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/create_pending_transfers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/create_transfer_operatorship

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

key_idstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/create_transfer_operatorship

curl -X POST 'https://axelar.nownodes.io/axelar/evm/create_transfer_operatorship' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "key_id": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_transfer_operatorship', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "key_id": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/create_transfer_operatorship')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "key_id": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "key_id": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/create_transfer_operatorship', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_transfer_operatorship', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "key_id": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/create_transfer_operatorship";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "key_id": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/create_transfer_operatorship', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "key_id": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "key_id": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/create_transfer_operatorship', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/create_transfer_operatorship')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "key_id": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "key_id": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/link

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

recipient_addrstring

assetstring

recipient_chainstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/link

curl -X POST 'https://axelar.nownodes.io/axelar/evm/link' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "recipient_addr": "string",
    "asset": "string",
    "recipient_chain": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/link', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "recipient_addr": "string",
      "asset": "string",
      "recipient_chain": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/link')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "recipient_addr": "string",
    "asset": "string",
    "recipient_chain": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "recipient_addr": "string",
  "asset": "string",
  "recipient_chain": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/link', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/link', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "recipient_addr": "string",
      "asset": "string",
      "recipient_chain": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/link";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "recipient_addr": "string",
    "asset": "string",
    "recipient_chain": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/link', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "recipient_addr": "string",
      "asset": "string",
      "recipient_chain": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "recipient_addr": "string",
  "asset": "string",
  "recipient_chain": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/link', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/link')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "recipient_addr": "string",
    "asset": "string",
    "recipient_chain": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "recipient_addr": "string",
  "asset": "string",
  "recipient_chain": "string"
}

{
  "deposit_addr": "string"
}

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

POST

https://axelar.nownodes.io/axelar/evm/retry-failed-event

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

event_idstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/retry-failed-event

curl -X POST 'https://axelar.nownodes.io/axelar/evm/retry-failed-event' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "event_id": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/retry-failed-event', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "event_id": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/retry-failed-event')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "event_id": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "event_id": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/retry-failed-event', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/retry-failed-event', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "event_id": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/retry-failed-event";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "event_id": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/retry-failed-event', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "event_id": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "event_id": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/retry-failed-event', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/retry-failed-event')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "event_id": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "event_id": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/set_gateway

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

addressstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/set_gateway

curl -X POST 'https://axelar.nownodes.io/axelar/evm/set_gateway' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "address": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/set_gateway', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "address": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/set_gateway')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "address": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "address": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/set_gateway', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/set_gateway', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "address": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/set_gateway";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "address": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/set_gateway', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "address": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "address": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/set_gateway', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/set_gateway')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "address": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "address": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/evm/sign_commands

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/sign_commands

curl -X POST 'https://axelar.nownodes.io/axelar/evm/sign_commands' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/sign_commands', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/sign_commands')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/sign_commands', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/sign_commands', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/sign_commands";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/sign_commands', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/evm/sign_commands', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/sign_commands')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string"
}

{
  "batched_commands_id": "dGVzdA==",
  "command_count": 0
}

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

POST

https://axelar.nownodes.io/axelar/multisig/rotate_key

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

key_idstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/rotate_key

curl -X POST 'https://axelar.nownodes.io/axelar/multisig/rotate_key' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "key_id": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/rotate_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "key_id": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/rotate_key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "key_id": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "key_id": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/rotate_key', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/rotate_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "key_id": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/rotate_key";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "key_id": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/rotate_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "key_id": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "key_id": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/rotate_key', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/rotate_key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "key_id": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "key_id": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/multisig/start_keygen

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring

key_idstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/start_keygen

curl -X POST 'https://axelar.nownodes.io/axelar/multisig/start_keygen' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "string",
    "key_id": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/start_keygen', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "string",
      "key_id": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/start_keygen')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "string",
    "key_id": "string"
  }'

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

import requests

payload = {
  "sender": "string",
  "key_id": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/start_keygen', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/start_keygen', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "string",
      "key_id": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/start_keygen";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/start_keygen', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "string",
      "key_id": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "string",
  "key_id": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/start_keygen', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/start_keygen')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "string",
    "key_id": "string"
  }'

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

Request Body

{
  "sender": "string",
  "key_id": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/multisig/submit_pub_key

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring

key_idstring

pub_keystring<byte>

signaturestring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/submit_pub_key

curl -X POST 'https://axelar.nownodes.io/axelar/multisig/submit_pub_key' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "string",
    "key_id": "string",
    "pub_key": "dGVzdA==",
    "signature": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/submit_pub_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "string",
      "key_id": "string",
      "pub_key": "dGVzdA==",
      "signature": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/submit_pub_key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "string",
    "key_id": "string",
    "pub_key": "dGVzdA==",
    "signature": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "string",
  "key_id": "string",
  "pub_key": "dGVzdA==",
  "signature": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/submit_pub_key', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/submit_pub_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "string",
      "key_id": "string",
      "pub_key": "dGVzdA==",
      "signature": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/submit_pub_key";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "string",
    "key_id": "string",
    "pub_key": "dGVzdA==",
    "signature": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/submit_pub_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "string",
      "key_id": "string",
      "pub_key": "dGVzdA==",
      "signature": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "string",
  "key_id": "string",
  "pub_key": "dGVzdA==",
  "signature": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/submit_pub_key', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/submit_pub_key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "string",
    "key_id": "string",
    "pub_key": "dGVzdA==",
    "signature": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "string",
  "key_id": "string",
  "pub_key": "dGVzdA==",
  "signature": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/multisig/submit_signature

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring

sig_idstring<uint64>

signaturestring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/submit_signature

curl -X POST 'https://axelar.nownodes.io/axelar/multisig/submit_signature' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "string",
    "sig_id": "string",
    "signature": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/submit_signature', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "string",
      "sig_id": "string",
      "signature": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/submit_signature')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "string",
    "sig_id": "string",
    "signature": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "string",
  "sig_id": "string",
  "signature": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/submit_signature', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/submit_signature', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "string",
      "sig_id": "string",
      "signature": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/submit_signature";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "string",
    "sig_id": "string",
    "signature": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/submit_signature', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "string",
      "sig_id": "string",
      "signature": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "string",
  "sig_id": "string",
  "signature": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/submit_signature', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/submit_signature')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "string",
    "sig_id": "string",
    "signature": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "string",
  "sig_id": "string",
  "signature": "dGVzdA=="
}

{}

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

POST

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/v1beta1/keygen_opt_in

curl -X POST 'https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_in' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_in', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_in')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_in', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_in', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_in";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_in', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_in', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_in')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA=="
}

{}

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

POST

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/v1beta1/keygen_opt_out

curl -X POST 'https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_out' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_out', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_out')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_out', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_out', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_out";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_out', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_out', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/multisig/v1beta1/keygen_opt_out')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/nexus/activate_chain

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/activate_chain

curl -X POST 'https://axelar.nownodes.io/axelar/nexus/activate_chain' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/activate_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/activate_chain')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/nexus/activate_chain', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/activate_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/activate_chain";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/activate_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/nexus/activate_chain', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/activate_chain')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

{}

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

POST

https://axelar.nownodes.io/axelar/nexus/deactivate_chain

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/deactivate_chain

curl -X POST 'https://axelar.nownodes.io/axelar/nexus/deactivate_chain' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/deactivate_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/deactivate_chain')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/nexus/deactivate_chain', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/deactivate_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/deactivate_chain";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/deactivate_chain', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/nexus/deactivate_chain', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/deactivate_chain')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

{}

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

POST

https://axelar.nownodes.io/axelar/nexus/deregister_chain_maintainer

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/deregister_chain_maintainer

curl -X POST 'https://axelar.nownodes.io/axelar/nexus/deregister_chain_maintainer' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/deregister_chain_maintainer', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/deregister_chain_maintainer')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/nexus/deregister_chain_maintainer', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/deregister_chain_maintainer', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/deregister_chain_maintainer";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/deregister_chain_maintainer', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/nexus/deregister_chain_maintainer', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/deregister_chain_maintainer')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

{}

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

POST

https://axelar.nownodes.io/axelar/nexus/register_asset_fee

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

fee_infoobject

Show child attributes

chainstring

assetstring

fee_ratestring<byte>

min_feestring<byte>

max_feestring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/register_asset_fee

curl -X POST 'https://axelar.nownodes.io/axelar/nexus/register_asset_fee' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "fee_info": {
      "chain": "string",
      "asset": "string",
      "fee_rate": "dGVzdA==",
      "min_fee": "dGVzdA==",
      "max_fee": "dGVzdA=="
    }
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/register_asset_fee', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "fee_info": {
        "chain": "string",
        "asset": "string",
        "fee_rate": "dGVzdA==",
        "min_fee": "dGVzdA==",
        "max_fee": "dGVzdA=="
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/register_asset_fee')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "fee_info": {
      "chain": "string",
      "asset": "string",
      "fee_rate": "dGVzdA==",
      "min_fee": "dGVzdA==",
      "max_fee": "dGVzdA=="
    }
  }'

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

import requests

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

response = requests.post('https://axelar.nownodes.io/axelar/nexus/register_asset_fee', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/register_asset_fee', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "fee_info": {
        "chain": "string",
        "asset": "string",
        "fee_rate": "dGVzdA==",
        "min_fee": "dGVzdA==",
        "max_fee": "dGVzdA=="
      }
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/register_asset_fee";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "fee_info": {
      "chain": "string",
      "asset": "string",
      "fee_rate": "dGVzdA==",
      "min_fee": "dGVzdA==",
      "max_fee": "dGVzdA=="
    }
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/register_asset_fee', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "fee_info": {
        "chain": "string",
        "asset": "string",
        "fee_rate": "dGVzdA==",
        "min_fee": "dGVzdA==",
        "max_fee": "dGVzdA=="
      }
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://axelar.nownodes.io/axelar/nexus/register_asset_fee', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/register_asset_fee')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "fee_info": {
      "chain": "string",
      "asset": "string",
      "fee_rate": "dGVzdA==",
      "min_fee": "dGVzdA==",
      "max_fee": "dGVzdA=="
    }
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "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=="
    }
  ]
}

POST

https://axelar.nownodes.io/axelar/nexus/register_chain_maintainer

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/register_chain_maintainer

curl -X POST 'https://axelar.nownodes.io/axelar/nexus/register_chain_maintainer' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/register_chain_maintainer', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/register_chain_maintainer')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/nexus/register_chain_maintainer', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/register_chain_maintainer', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/register_chain_maintainer";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/register_chain_maintainer', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chains": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/nexus/register_chain_maintainer', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/register_chain_maintainer')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chains": [
      "string"
    ]
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chains": [
    "string"
  ]
}

{}

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

POST

https://axelar.nownodes.io/axelar/nexus/set_transfer_rate_limit

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

chainstring

limitobject

Coin defines a token with a denomination and an amount.

NOTE: The amount field is an Int which implements the custom method signatures required by gogoproto.

Show child attributes

denomstring

amountstring

windowstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/set_transfer_rate_limit

curl -X POST 'https://axelar.nownodes.io/axelar/nexus/set_transfer_rate_limit' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "chain": "string",
    "limit": {
      "denom": "string",
      "amount": "string"
    },
    "window": "string"
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/set_transfer_rate_limit', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "limit": {
        "denom": "string",
        "amount": "string"
      },
      "window": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/set_transfer_rate_limit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "limit": {
      "denom": "string",
      "amount": "string"
    },
    "window": "string"
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "limit": {
    "denom": "string",
    "amount": "string"
  },
  "window": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/nexus/set_transfer_rate_limit', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/set_transfer_rate_limit', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "limit": {
        "denom": "string",
        "amount": "string"
      },
      "window": "string"
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/set_transfer_rate_limit";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "chain": "string",
    "limit": {
      "denom": "string",
      "amount": "string"
    },
    "window": "string"
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/set_transfer_rate_limit', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "chain": "string",
      "limit": {
        "denom": "string",
        "amount": "string"
      },
      "window": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "chain": "string",
  "limit": {
    "denom": "string",
    "amount": "string"
  },
  "window": "string"
}

response = requests.post('https://axelar.nownodes.io/axelar/nexus/set_transfer_rate_limit', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/set_transfer_rate_limit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "chain": "string",
    "limit": {
      "denom": "string",
      "amount": "string"
    },
    "window": "string"
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "chain": "string",
  "limit": {
    "denom": "string",
    "amount": "string"
  },
  "window": "string"
}

{}

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

POST

https://axelar.nownodes.io/axelar/reward/refund_message

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

inner_messageobject

Any contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message.

Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.

Example 1: Pack and unpack a message in C++.

Copied!

Foo foo = ...;
Any any;
any.PackFrom(foo);
...
if (any.UnpackTo(&foo)) {
  ...
}

Example 2: Pack and unpack a message in Java.

Copied!

Foo foo = ...;
Any any = Any.pack(foo);
...
if (any.is(Foo.class)) {
  foo = any.unpack(Foo.class);
}

Example 3: Pack and unpack a message in Python.

Copied!

foo = Foo(...)
any = Any()
any.Pack(foo)
...
if any.Is(Foo.DESCRIPTOR):
  any.Unpack(foo)
  ...

Example 4: Pack and unpack a message in Go

Copied!

 foo := &pb.Foo{...}
 any, err := anypb.New(foo)
 if err != nil {
   ...
 }
 ...
 foo := &pb.Foo{}
 if err := any.UnmarshalTo(foo); err != nil {
   ...
 }

The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".

JSON

The JSON representation of an Any value uses the regular representation of the deserialized, embedded message, with an additional field @type which contains the type URL. Example:

Copied!

package google.profile;
message Person {
  string first_name = 1;
  string last_name = 2;
}

{
  "@type": "type.googleapis.com/google.profile.Person",
  "firstName": <string>,
  "lastName": <string>
}

If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field value which holds the custom JSON in addition to the @type field. Example (for message [google.protobuf.Duration][]):

Copied!

{
  "@type": "type.googleapis.com/google.protobuf.Duration",
  "value": "1.212s"
}

Show child attributes

type_urlstring

A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in path/google.protobuf.Duration). The name should be in a canonical form (e.g., leading "." is not accepted).

In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme http, https, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:

If no scheme is provided, https is assumed.
An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error.
Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)

Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.

Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics.

valuestring<byte>

Must be a valid serialized protocol buffer of the above specified type.

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/reward/refund_message

curl -X POST 'https://axelar.nownodes.io/axelar/reward/refund_message' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "inner_message": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/reward/refund_message', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "inner_message": {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/reward/refund_message')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "inner_message": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "inner_message": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

response = requests.post('https://axelar.nownodes.io/axelar/reward/refund_message', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/reward/refund_message', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "inner_message": {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/reward/refund_message";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "inner_message": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/reward/refund_message', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "inner_message": {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "inner_message": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

response = requests.post('https://axelar.nownodes.io/axelar/reward/refund_message', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/reward/refund_message')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "inner_message": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "inner_message": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

{
  "data": "dGVzdA==",
  "log": "string"
}

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

DeactivateProxy defines a method for deregistering a proxy account.

POST

https://axelar.nownodes.io/axelar/snapshot/deactivate_proxy

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

DeactivateProxy defines a method for deregistering a proxy account.

curl -X POST 'https://axelar.nownodes.io/axelar/snapshot/deactivate_proxy' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/snapshot/deactivate_proxy', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/snapshot/deactivate_proxy')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/snapshot/deactivate_proxy', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/snapshot/deactivate_proxy', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/snapshot/deactivate_proxy";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://axelar.nownodes.io/axelar/snapshot/deactivate_proxy', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/snapshot/deactivate_proxy', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/snapshot/deactivate_proxy')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA=="
}

{}

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

RegisterProxy defines a method for registering a proxy account that can act in a validator account's stead.

POST

https://axelar.nownodes.io/axelar/snapshot/register_proxy

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

proxy_addrstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

RegisterProxy defines a method for registering a proxy account that can act in a validator account's stead.

curl -X POST 'https://axelar.nownodes.io/axelar/snapshot/register_proxy' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "proxy_addr": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/snapshot/register_proxy', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "proxy_addr": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/snapshot/register_proxy')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "proxy_addr": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "proxy_addr": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/snapshot/register_proxy', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/snapshot/register_proxy', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "proxy_addr": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/snapshot/register_proxy";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "proxy_addr": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/snapshot/register_proxy', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "proxy_addr": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "proxy_addr": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/snapshot/register_proxy', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/snapshot/register_proxy')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "proxy_addr": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "proxy_addr": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/tss/heartbeat

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

key_idsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/tss/heartbeat

curl -X POST 'https://axelar.nownodes.io/axelar/tss/heartbeat' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "key_ids": [
      "string"
    ]
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/tss/heartbeat', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "key_ids": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/tss/heartbeat')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "key_ids": [
      "string"
    ]
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "key_ids": [
    "string"
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/tss/heartbeat', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/tss/heartbeat', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "key_ids": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/tss/heartbeat";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "key_ids": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/tss/heartbeat', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "key_ids": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "key_ids": [
    "string"
  ]
}

response = requests.post('https://axelar.nownodes.io/axelar/tss/heartbeat', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/tss/heartbeat')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "key_ids": [
      "string"
    ]
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "key_ids": [
    "string"
  ]
}

{}

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

POST

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

poll_idstring<uint64>

voteobject

Any contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message.

Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.

Example 1: Pack and unpack a message in C++.

Copied!

Foo foo = ...;
Any any;
any.PackFrom(foo);
...
if (any.UnpackTo(&foo)) {
  ...
}

Example 2: Pack and unpack a message in Java.

Copied!

Foo foo = ...;
Any any = Any.pack(foo);
...
if (any.is(Foo.class)) {
  foo = any.unpack(Foo.class);
}

Example 3: Pack and unpack a message in Python.

Copied!

foo = Foo(...)
any = Any()
any.Pack(foo)
...
if any.Is(Foo.DESCRIPTOR):
  any.Unpack(foo)
  ...

Example 4: Pack and unpack a message in Go

Copied!

 foo := &pb.Foo{...}
 any, err := anypb.New(foo)
 if err != nil {
   ...
 }
 ...
 foo := &pb.Foo{}
 if err := any.UnmarshalTo(foo); err != nil {
   ...
 }

JSON

The JSON representation of an Any value uses the regular representation of the deserialized, embedded message, with an additional field @type which contains the type URL. Example:

Copied!

package google.profile;
message Person {
  string first_name = 1;
  string last_name = 2;
}

{
  "@type": "type.googleapis.com/google.profile.Person",
  "firstName": <string>,
  "lastName": <string>
}

Copied!

{
  "@type": "type.googleapis.com/google.protobuf.Duration",
  "value": "1.212s"
}

Show child attributes

type_urlstring

If no scheme is provided, https is assumed.
An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error.
Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)

Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.

Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics.

valuestring<byte>

Must be a valid serialized protocol buffer of the above specified type.

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/vote/vote

curl -X POST 'https://axelar.nownodes.io/axelar/vote/vote' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "poll_id": "string",
    "vote": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/vote/vote', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "poll_id": "string",
      "vote": {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/vote/vote')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "poll_id": "string",
    "vote": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "poll_id": "string",
  "vote": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

response = requests.post('https://axelar.nownodes.io/axelar/vote/vote', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/vote/vote', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "poll_id": "string",
      "vote": {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/vote/vote";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "poll_id": "string",
    "vote": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/vote/vote', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "poll_id": "string",
      "vote": {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "poll_id": "string",
  "vote": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

response = requests.post('https://axelar.nownodes.io/axelar/vote/vote', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/vote/vote')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "poll_id": "string",
    "vote": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "poll_id": "string",
  "vote": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

{
  "log": "string"
}

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

QueryService

PendingIBCTransferCount queries the pending ibc transfers for all chains

GET

https://axelar.nownodes.io/axelar/axelarnet/v1beta1/ibc_transfer_count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response

PendingIBCTransferCount queries the pending ibc transfers for all chains

curl -X GET 'https://axelar.nownodes.io/axelar/axelarnet/v1beta1/ibc_transfer_count'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/v1beta1/ibc_transfer_count')
request = Net::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_by_chain": {}
}

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

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

GET /axelar/axelarnet/v1beta1/params

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",
        "contract_address": "string",
        "min_deposits": [
          {
            "denom": "string",
            "amount": "string"
          }
        ]
      }
    ]
  }
}

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

BatchedCommands queries the batched commands for a specified chain and BatchedCommandsID if no BatchedCommandsID is specified, then it returns the latest batched commands

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/batched_commands/{chain}/{id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

idstringrequiredpath

id defines an optional id for the commandsbatch. If not specified the latest will be returned

Response

200OK

A successful response.

default

An unexpected error response

BatchedCommands queries the batched commands for a specified chain and BatchedCommandsID if no BatchedCommandsID is specified, then it returns the latest batched commands

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/batched_commands/{chain}/{id}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "id": "string",
  "data": "string",
  "status": "BATCHED_COMMANDS_STATUS_UNSPECIFIED",
  "key_id": "string",
  "execute_data": "string",
  "prev_batched_commands_id": "string",
  "command_ids": [
    "string"
  ],
  "proof": {
    "addresses": [
      "string"
    ],
    "weights": [
      "string"
    ],
    "threshold": "string",
    "signatures": [
      "string"
    ]
  }
}

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

BurnerInfo queries the burner info for the specified address

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/burner_info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

addressstring<byte>query

Response

200OK

A successful response.

default

An unexpected error response

BurnerInfo queries the burner info for the specified address

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/burner_info'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "chain": "string",
  "burner_info": {
    "burner_address": "dGVzdA==",
    "token_address": "dGVzdA==",
    "destination_chain": "string",
    "symbol": "string",
    "asset": "string",
    "salt": "dGVzdA=="
  }
}

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

Bytecode queries the bytecode of a specified gateway at the specified chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/bytecode/{chain}/{contract}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

contractstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

Bytecode queries the bytecode of a specified gateway at the specified chain

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/bytecode/{chain}/{contract}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/bytecode/{chain}/{contract}')
request = Net::HTTP::Get.new(uri)

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

{
  "bytecode": "string"
}

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

Chains queries the available evm chains

GET

https://axelar.nownodes.io/axelar/evm/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 available evm chains

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/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=="
    }
  ]
}

Command queries the command of a chain provided the command id

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/command_request

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringquery

idstringquery

Response

200OK

A successful response.

default

An unexpected error response

Command queries the command of a chain provided the command id

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/command_request'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/command_request')
request = Net::HTTP::Get.new(uri)

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

{
  "id": "string",
  "type": "string",
  "params": {},
  "key_id": "string",
  "max_gas_cost": 0
}

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

ConfirmationHeight queries the confirmation height for the specified chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{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

ConfirmationHeight queries the confirmation height for the specified chain

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "height": "string"
}

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

DepositState queries the state of the specified deposit

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringquery

params.tx_idstring<byte>query

params.burner_addressstring<byte>query

Response

200OK

A successful response.

default

An unexpected error response

DepositState queries the state of the specified deposit

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "status": "DEPOSIT_STATUS_UNSPECIFIED"
}

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

ERC20Tokens queries the ERC20 tokens registered for a chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

typestringTOKEN_TYPE_UNSPECIFIEDTOKEN_TYPE_INTERNALTOKEN_TYPE_EXTERNALTOKEN_TYPE_UNSPECIFIEDquery

Response

200OK

A successful response.

default

An unexpected error response

ERC20Tokens queries the ERC20 tokens registered for a chain

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "tokens": [
    {
      "asset": "string",
      "symbol": "string"
    }
  ]
}

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

Event queries an event at the specified chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

event_idstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

Event queries an event at the specified chain

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "event": {
    "chain": "string",
    "tx_id": "dGVzdA==",
    "index": "string",
    "status": "STATUS_UNSPECIFIED",
    "token_sent": {
      "sender": "dGVzdA==",
      "destination_chain": "string",
      "destination_address": "string",
      "symbol": "string",
      "amount": "dGVzdA=="
    },
    "contract_call": {
      "sender": "dGVzdA==",
      "destination_chain": "string",
      "contract_address": "string",
      "payload_hash": "dGVzdA=="
    },
    "contract_call_with_token": {
      "sender": "dGVzdA==",
      "destination_chain": "string",
      "contract_address": "string",
      "payload_hash": "dGVzdA==",
      "symbol": "string",
      "amount": "dGVzdA=="
    },
    "transfer": {
      "to": "dGVzdA==",
      "amount": "dGVzdA=="
    },
    "token_deployed": {
      "symbol": "string",
      "token_address": "dGVzdA=="
    },
    "multisig_ownership_transferred": {
      "pre_owners": [
        "dGVzdA=="
      ],
      "prev_threshold": "dGVzdA==",
      "new_owners": [
        "dGVzdA=="
      ],
      "new_threshold": "dGVzdA=="
    },
    "multisig_operatorship_transferred": {
      "new_operators": [
        "dGVzdA=="
      ],
      "new_threshold": "dGVzdA==",
      "new_weights": [
        "dGVzdA=="
      ]
    }
  }
}

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

GatewayAddress queries the address of axelar gateway at the specified chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{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

GatewayAddress queries the address of axelar gateway at the specified chain

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "address": "string"
}

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

KeyAddress queries the address of key of a chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

key_idstringquery

Response

200OK

A successful response.

default

An unexpected error response

KeyAddress queries the address of key of a chain

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{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",
  "addresses": [
    {
      "address": "string",
      "weight": "string"
    }
  ],
  "threshold": "string"
}

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

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/params/{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

GET /axelar/evm/v1beta1/params/{chain}

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "params": {
    "chain": "string",
    "confirmation_height": "string",
    "network": "string",
    "token_code": "dGVzdA==",
    "burnable": "dGVzdA==",
    "revote_locking_period": "string",
    "networks": [
      {
        "name": "string",
        "id": "dGVzdA=="
      }
    ],
    "voting_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "min_voter_count": "string",
    "commands_gas_limit": 0,
    "voting_grace_period": "string",
    "end_blocker_limit": "string",
    "transfer_limit": "string"
  }
}

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

PendingCommands queries the pending commands for the specified chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{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

PendingCommands queries the pending commands for the specified chain

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "commands": [
    {
      "id": "string",
      "type": "string",
      "params": {},
      "key_id": "string",
      "max_gas_cost": 0
    }
  ]
}

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

TokenInfo queries the token info for a registered ERC20 Token

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstringrequiredpath

assetstringquery

symbolstringquery

addressstringquery

Response

200OK

A successful response.

default

An unexpected error response

TokenInfo queries the token info for a registered ERC20 Token

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "asset": "string",
  "details": {
    "token_name": "string",
    "symbol": "string",
    "decimals": 0,
    "capacity": "dGVzdA=="
  },
  "address": "string",
  "confirmed": true,
  "is_external": true,
  "burner_code_hash": "string"
}

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

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=="
    }
  ]
}

LatestDepositAddress queries the a deposit address by recipient

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

recipient_addrstringrequiredpath

recipient_chainstringrequiredpath

deposit_chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

LatestDepositAddress queries the a deposit address by recipient

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}')
data = response.json()

require 'net/http'
require 'json'

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

{
  "deposit_addr": "string"
}

{
  "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=="
    }
  ]
}

RecipientAddress queries the recipient address for a given deposit address

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

deposit_chainstringrequiredpath

deposit_addrstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

RecipientAddress queries the recipient address for a given deposit address

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "recipient_addr": "string",
  "recipient_chain": "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

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=="
    }
  ]
}

TransferRateLimit queries the transfer rate limit for a given chain and asset. If a rate limit is not set, nil is returned.

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{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

TransferRateLimit queries the transfer rate limit for a given chain and asset. If a rate limit is not set, nil is returned.

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "transfer_rate_limit": {
    "limit": "dGVzdA==",
    "window": "string",
    "incoming": "dGVzdA==",
    "outgoing": "dGVzdA==",
    "time_left": "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/tss/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/tss/v1beta1/params

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/tss/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": {
    "key_requirements": [
      {
        "key_role": "KEY_ROLE_UNSPECIFIED",
        "key_type": "KEY_TYPE_UNSPECIFIED",
        "min_keygen_threshold": {
          "numerator": "string",
          "denominator": "string"
        },
        "safety_threshold": {
          "numerator": "string",
          "denominator": "string"
        },
        "key_share_distribution_policy": "KEY_SHARE_DISTRIBUTION_POLICY_UNSPECIFIED",
        "max_total_share_count": "string",
        "min_total_share_count": "string",
        "keygen_voting_threshold": {
          "numerator": "string",
          "denominator": "string"
        },
        "sign_voting_threshold": {
          "numerator": "string",
          "denominator": "string"
        },
        "keygen_timeout": "string",
        "sign_timeout": "string"
      }
    ],
    "suspend_duration_in_blocks": "string",
    "heartbeat_period_in_blocks": "string",
    "max_missed_blocks_per_window": {
      "numerator": "string",
      "denominator": "string"
    },
    "unbonding_locking_key_rotation_count": "string",
    "external_multisig_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "max_sign_queue_size": "string",
    "max_simultaneous_sign_shares": "string",
    "tss_signed_blocks_window": "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=="
    }
  ]
}

Msg

POST

https://axelar.nownodes.io/axelar/permission/deregister_controller

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

controllerstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/permission/deregister_controller

curl -X POST 'https://axelar.nownodes.io/axelar/permission/deregister_controller' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/permission/deregister_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/deregister_controller')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/permission/deregister_controller', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/permission/deregister_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/permission/deregister_controller";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/permission/deregister_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/permission/deregister_controller', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/deregister_controller')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/permission/register_controller

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

controllerstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/permission/register_controller

curl -X POST 'https://axelar.nownodes.io/axelar/permission/register_controller' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/permission/register_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/register_controller')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

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

import requests

payload = {
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/permission/register_controller', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/permission/register_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/permission/register_controller";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/permission/register_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/permission/register_controller', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/register_controller')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

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

Request Body

{
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

{}

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

POST

https://axelar.nownodes.io/axelar/permission/update_governance_key

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

*/*

senderstring<byte>

governance_keyobject

LegacyAminoPubKey specifies a public key type which nests multiple public keys and a threshold, it uses legacy amino address rules.

Show child attributes

thresholdinteger<int64>

public_keysArray<object>

Show child attributes

type_urlstring

If no scheme is provided, https is assumed.
An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error.
Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)

Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.

Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics.

valuestring<byte>

Must be a valid serialized protocol buffer of the above specified type.

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/permission/update_governance_key

curl -X POST 'https://axelar.nownodes.io/axelar/permission/update_governance_key' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "governance_key": {
      "threshold": 0,
      "public_keys": [
        {
          "type_url": "string",
          "value": "dGVzdA=="
        }
      ]
    }
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/permission/update_governance_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "governance_key": {
        "threshold": 0,
        "public_keys": [
          {
            "type_url": "string",
            "value": "dGVzdA=="
          }
        ]
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/update_governance_key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "governance_key": {
      "threshold": 0,
      "public_keys": [
        {
          "type_url": "string",
          "value": "dGVzdA=="
        }
      ]
    }
  }'

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

import requests

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

response = requests.post('https://axelar.nownodes.io/axelar/permission/update_governance_key', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/permission/update_governance_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "governance_key": {
        "threshold": 0,
        "public_keys": [
          {
            "type_url": "string",
            "value": "dGVzdA=="
          }
        ]
      }
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/permission/update_governance_key";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "governance_key": {
      "threshold": 0,
      "public_keys": [
        {
          "type_url": "string",
          "value": "dGVzdA=="
        }
      ]
    }
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/permission/update_governance_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "governance_key": {
        "threshold": 0,
        "public_keys": [
          {
            "type_url": "string",
            "value": "dGVzdA=="
          }
        ]
      }
    }),
});

const data = await response.json();

import requests

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

response = requests.post('https://axelar.nownodes.io/axelar/permission/update_governance_key', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/update_governance_key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "governance_key": {
      "threshold": 0,
      "public_keys": [
        {
          "type_url": "string",
          "value": "dGVzdA=="
        }
      ]
    }
  }'

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

Request Body

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

{}

{
  "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/v1beta1/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/v1beta1/params/{params_type}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/gov/v1beta1/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=="
    }
  ]
}

UpgradedConsensusState queries the consensus state that will serve as a trusted kernel for the next version of this chain. It will only be stored at the last height of this chain. UpgradedConsensusState RPC not supported with legacy querier This rpc is deprecated now that IBC has its own replacement (https://github.com/cosmos/ibc-go/blob/2c880a22e9f9cc75f62b527ca94aa75ce1106001/proto/ibc/core/client/v1/query.proto#L54)

GET

https://axelar.nownodes.io/cosmos/upgrade/v1beta1/upgraded_consensus_state/{last_height}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

last_heightstring<int64>requiredpath

last height of the current chain must be sent in request as this is the height under which next consensus state is stored

Response

200OK

A successful response.

default

An unexpected error response

UpgradedConsensusState queries the consensus state that will serve as a trusted kernel for the next version of this chain. It will only be stored at the last height of this chain. UpgradedConsensusState RPC not supported with legacy querier This rpc is deprecated now that IBC has its own replacement (https://github.com/cosmos/ibc-go/blob/2c880a22e9f9cc75f62b527ca94aa75ce1106001/proto/ibc/core/client/v1/query.proto#L54)

curl -X GET 'https://axelar.nownodes.io/cosmos/upgrade/v1beta1/upgraded_consensus_state/{last_height}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "upgraded_consensus_state": "dGVzdA=="
}

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

Service

GetLatestBlock returns the latest block.

GET

https://axelar.nownodes.io/cosmos/base/tendermint/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/tendermint/v1beta1/blocks/latest'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/base/tendermint/v1beta1/blocks/latest')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/tendermint/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/tendermint/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/tendermint/v1beta1/blocks/{height}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/base/tendermint/v1beta1/blocks/{height}')
data = response.json()

require 'net/http'
require 'json'

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/tendermint/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/tendermint/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/tendermint/v1beta1/validatorsets/latest'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/base/tendermint/v1beta1/validatorsets/latest')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/cosmos/base/tendermint/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/tendermint/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/tendermint/v1beta1/validatorsets/{height}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/cosmos/base/tendermint/v1beta1/validatorsets/{height}')
data = response.json()

require 'net/http'
require 'json'

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

MsgService

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response