IBC-GO - gRPC Gateway docs

v1.0.0

Base URL

https://axelar.nownodes.io

A REST interface for state queries

Authentication

api-keyAuthapiKey

API Key: api-key in header

API Reference

Core

Channels queries all the IBC channels of a chain.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels

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

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

Channels queries all the IBC channels of a chain.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v1/channels')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v1/channels', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels')
request = Net::HTTP::Get.new(uri)

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

{
  "channels": [
    {
      "state": "STATE_UNINITIALIZED_UNSPECIFIED",
      "ordering": "ORDER_NONE_UNSPECIFIED",
      "counterparty": {
        "port_id": "string",
        "channel_id": "string"
      },
      "connection_hops": [
        "string"
      ],
      "version": "string",
      "port_id": "string",
      "channel_id": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  },
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

Channel queries an IBC Channel.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

Response

200OK

A successful response.

default

An unexpected error response

Channel queries an IBC Channel.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_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)

{
  "channel": {
    "state": "STATE_UNINITIALIZED_UNSPECIFIED",
    "ordering": "ORDER_NONE_UNSPECIFIED",
    "counterparty": {
      "port_id": "string",
      "channel_id": "string"
    },
    "connection_hops": [
      "string"
    ],
    "version": "string"
  },
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

ChannelClientState queries for the client state for the channel associated with the provided channel identifiers.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_state

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

Response

200OK

A successful response.

default

An unexpected error response

ChannelClientState queries for the client state for the channel associated with the provided channel identifiers.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_state'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_state', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_state')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_state', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_state', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_state')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_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)

{
  "identified_client_state": {
    "client_id": "string",
    "client_state": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  },
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

ChannelConsensusState queries for the consensus state for the channel associated with the provided channel identifiers.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_height}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

revision_numberstring<uint64>requiredpath

revision number of the consensus state

revision_heightstring<uint64>requiredpath

revision height of the consensus state

Response

200OK

A successful response.

default

An unexpected error response

ChannelConsensusState queries for the consensus state for the channel associated with the provided channel identifiers.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_height}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_height}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_height}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_height}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_height}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_height}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_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)

{
  "consensus_state": {
    "type_url": "string",
    "value": "dGVzdA=="
  },
  "client_id": "string",
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

NextSequenceReceive returns the next receive sequence for a given channel.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

Response

200OK

A successful response.

default

An unexpected error response

NextSequenceReceive returns the next receive sequence for a given channel.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence')
request = Net::HTTP::Get.new(uri)

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

{
  "next_sequence_receive": "string",
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

PacketAcknowledgements returns all the packet acknowledgements associated with a channel.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

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

packet_commitment_sequencesArray<string>query

list of packet sequences.

Response

200OK

A successful response.

default

An unexpected error response

PacketAcknowledgements returns all the packet acknowledgements associated with a channel.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements')
request = Net::HTTP::Get.new(uri)

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

{
  "acknowledgements": [
    {
      "port_id": "string",
      "channel_id": "string",
      "sequence": "string",
      "data": "dGVzdA=="
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  },
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

PacketAcknowledgement queries a stored packet acknowledgement hash.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

sequencestring<uint64>requiredpath

packet sequence

Response

200OK

A successful response.

default

An unexpected error response

PacketAcknowledgement queries a stored packet acknowledgement hash.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}')
request = Net::HTTP::Get.new(uri)

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

{
  "acknowledgement": "dGVzdA==",
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

PacketCommitments returns all the packet commitments hashes associated with a channel.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

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

PacketCommitments returns all the packet commitments hashes associated with a channel.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments')
request = Net::HTTP::Get.new(uri)

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

{
  "commitments": [
    {
      "port_id": "string",
      "channel_id": "string",
      "sequence": "string",
      "data": "dGVzdA=="
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  },
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

UnreceivedAcks returns all the unreceived IBC acknowledgements associated with a channel and sequences.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

packet_ack_sequencesArray<string>requiredpath

list of acknowledgement sequences

Response

200OK

A successful response.

default

An unexpected error response

UnreceivedAcks returns all the unreceived IBC acknowledgements associated with a channel and sequences.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks')
request = Net::HTTP::Get.new(uri)

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

{
  "sequences": [
    "string"
  ],
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

UnreceivedPackets returns all the unreceived IBC packets associated with a channel and sequences.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

packet_commitment_sequencesArray<string>requiredpath

list of packet sequences

Response

200OK

A successful response.

default

An unexpected error response

UnreceivedPackets returns all the unreceived IBC packets associated with a channel and sequences.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets')
request = Net::HTTP::Get.new(uri)

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

{
  "sequences": [
    "string"
  ],
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

PacketCommitment queries a stored packet commitment hash.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

sequencestring<uint64>requiredpath

packet sequence

Response

200OK

A successful response.

default

An unexpected error response

PacketCommitment queries a stored packet commitment hash.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}')
request = Net::HTTP::Get.new(uri)

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

{
  "commitment": "dGVzdA==",
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

PacketReceipt queries if a given packet sequence has been received on the queried chain

GET

https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

channel unique identifier

port_idstringrequiredpath

port unique identifier

sequencestring<uint64>requiredpath

packet sequence

Response

200OK

A successful response.

default

An unexpected error response

PacketReceipt queries if a given packet sequence has been received on the queried chain

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}')
request = Net::HTTP::Get.new(uri)

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

{
  "received": true,
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

ConnectionChannels queries all the channels associated with a connection end.

GET

https://axelar.nownodes.io/ibc/core/channel/v1/connections/{connection}/channels

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

connectionstringrequiredpath

connection unique identifier

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

ConnectionChannels queries all the channels associated with a connection end.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v1/connections/{connection}/channels'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/connections/{connection}/channels', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/connections/{connection}/channels')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v1/connections/{connection}/channels')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v1/connections/{connection}/channels', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v1/connections/{connection}/channels";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v1/connections/{connection}/channels', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v1/connections/{connection}/channels')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v1/connections/{connection}/channels')
request = Net::HTTP::Get.new(uri)

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

{
  "channels": [
    {
      "state": "STATE_UNINITIALIZED_UNSPECIFIED",
      "ordering": "ORDER_NONE_UNSPECIFIED",
      "counterparty": {
        "port_id": "string",
        "channel_id": "string"
      },
      "connection_hops": [
        "string"
      ],
      "version": "string",
      "port_id": "string",
      "channel_id": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  },
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

ClientStates queries all the IBC light clients of a chain.

GET

https://axelar.nownodes.io/ibc/core/client/v1/client_states

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

ClientStates queries all the IBC light clients of a chain.

curl -X GET 'https://axelar.nownodes.io/ibc/core/client/v1/client_states'

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/client_states', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/client_states')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/client/v1/client_states')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/client_states', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/client/v1/client_states";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/client/v1/client_states', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/client/v1/client_states')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/client_states')
request = Net::HTTP::Get.new(uri)

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

{
  "client_states": [
    {
      "client_id": "string",
      "client_state": {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

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

ClientState queries an IBC light client.

GET

https://axelar.nownodes.io/ibc/core/client/v1/client_states/{client_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

client state unique identifier

Response

200OK

A successful response.

default

An unexpected error response

ClientState queries an IBC light client.

curl -X GET 'https://axelar.nownodes.io/ibc/core/client/v1/client_states/{client_id}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/client_states/{client_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/client_states/{client_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/ibc/core/client/v1/client_states/{client_id}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/client_states/{client_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/client/v1/client_states/{client_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/ibc/core/client/v1/client_states/{client_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/client/v1/client_states/{client_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/client_states/{client_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)

{
  "client_state": {
    "type_url": "string",
    "value": "dGVzdA=="
  },
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

Status queries the status of an IBC client.

GET

https://axelar.nownodes.io/ibc/core/client/v1/client_status/{client_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

client unique identifier

Response

200OK

A successful response.

default

An unexpected error response

Status queries the status of an IBC client.

curl -X GET 'https://axelar.nownodes.io/ibc/core/client/v1/client_status/{client_id}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/client_status/{client_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/client_status/{client_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/ibc/core/client/v1/client_status/{client_id}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/client_status/{client_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/client/v1/client_status/{client_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/ibc/core/client/v1/client_status/{client_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/client/v1/client_status/{client_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/client_status/{client_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)

{
  "status": "string"
}

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

ConsensusStates queries all the consensus state associated with a given client.

GET

https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

client identifier

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

ConsensusStates queries all the consensus state associated with a given client.

curl -X GET 'https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_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/ibc/core/client/v1/consensus_states/{client_id}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_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/ibc/core/client/v1/consensus_states/{client_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_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)

{
  "consensus_states": [
    {
      "height": {
        "revision_number": "string",
        "revision_height": "string"
      },
      "consensus_state": {
        "type_url": "string",
        "value": "dGVzdA=="
      }
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

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

ConsensusStateHeights queries the height of every consensus states associated with a given client.

GET

https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/heights

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

client identifier

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

ConsensusStateHeights queries the height of every consensus states associated with a given client.

curl -X GET 'https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/heights'

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/heights', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/heights')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/client/v1/consensus_states/{client_id}/heights')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/heights', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/heights";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/client/v1/consensus_states/{client_id}/heights', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/heights')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/heights')
request = Net::HTTP::Get.new(uri)

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

{
  "consensus_state_heights": [
    {
      "revision_number": "string",
      "revision_height": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

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

ConsensusState queries a consensus state associated with a client state at a given height.

GET

https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_height}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

client identifier

revision_numberstring<uint64>requiredpath

consensus state revision number

revision_heightstring<uint64>requiredpath

consensus state revision height

latest_heightboolean<boolean>query

latest_height overrrides the height field and queries the latest stored ConsensusState.

Response

200OK

A successful response.

default

An unexpected error response

ConsensusState queries a consensus state associated with a client state at a given height.

curl -X GET 'https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_height}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_height}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_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/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_height}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_height}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_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/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_height}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_height}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_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)

{
  "consensus_state": {
    "type_url": "string",
    "value": "dGVzdA=="
  },
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

ClientConnections queries the connection paths associated with a client state.

GET

https://axelar.nownodes.io/ibc/core/connection/v1/client_connections/{client_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

client identifier associated with a connection

Response

200OK

A successful response.

default

An unexpected error response

ClientConnections queries the connection paths associated with a client state.

curl -X GET 'https://axelar.nownodes.io/ibc/core/connection/v1/client_connections/{client_id}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/client_connections/{client_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/client_connections/{client_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/ibc/core/connection/v1/client_connections/{client_id}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/client_connections/{client_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/connection/v1/client_connections/{client_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/ibc/core/connection/v1/client_connections/{client_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/connection/v1/client_connections/{client_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/client_connections/{client_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)

{
  "connection_paths": [
    "string"
  ],
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

Connections queries all the IBC connections of a chain.

GET

https://axelar.nownodes.io/ibc/core/connection/v1/connections

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

Connections queries all the IBC connections of a chain.

curl -X GET 'https://axelar.nownodes.io/ibc/core/connection/v1/connections'

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/connections', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/connections')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/connection/v1/connections')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/connections', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/connection/v1/connections";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/connection/v1/connections', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/connection/v1/connections')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/connections')
request = Net::HTTP::Get.new(uri)

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

{
  "connections": [
    {
      "id": "string",
      "client_id": "string",
      "versions": [
        {
          "identifier": "string",
          "features": [
            "string"
          ]
        }
      ],
      "state": "STATE_UNINITIALIZED_UNSPECIFIED",
      "counterparty": {
        "client_id": "string",
        "connection_id": "string",
        "prefix": {
          "key_prefix": "dGVzdA=="
        }
      },
      "delay_period": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  },
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

Connection queries an IBC connection end.

GET

https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

connection_idstringrequiredpath

connection unique identifier

Response

200OK

A successful response.

default

An unexpected error response

Connection queries an IBC connection end.

curl -X GET 'https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_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/ibc/core/connection/v1/connections/{connection_id}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_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/ibc/core/connection/v1/connections/{connection_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_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)

{
  "connection": {
    "client_id": "string",
    "versions": [
      {
        "identifier": "string",
        "features": [
          "string"
        ]
      }
    ],
    "state": "STATE_UNINITIALIZED_UNSPECIFIED",
    "counterparty": {
      "client_id": "string",
      "connection_id": "string",
      "prefix": {
        "key_prefix": "dGVzdA=="
      }
    },
    "delay_period": "string"
  },
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

ConnectionClientState queries the client state associated with the connection.

GET

https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/client_state

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

connection_idstringrequiredpath

connection identifier

Response

200OK

A successful response.

default

An unexpected error response

ConnectionClientState queries the client state associated with the connection.

curl -X GET 'https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/client_state'

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/client_state', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/client_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/ibc/core/connection/v1/connections/{connection_id}/client_state')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/client_state', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/client_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/ibc/core/connection/v1/connections/{connection_id}/client_state', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/client_state')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/client_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)

{
  "identified_client_state": {
    "client_id": "string",
    "client_state": {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  },
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

ConnectionConsensusState queries the consensus state associated with the connection.

GET

https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_height}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

connection_idstringrequiredpath

connection identifier

revision_numberstring<uint64>requiredpath

revision_heightstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response

ConnectionConsensusState queries the consensus state associated with the connection.

curl -X GET 'https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_height}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_height}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_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/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_height}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_height}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_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/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_height}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_height}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_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)

{
  "consensus_state": {
    "type_url": "string",
    "value": "dGVzdA=="
  },
  "client_id": "string",
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

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

Query

Params returns the querying grpc-gateway of the connection parameters.

GET

https://axelar.nownodes.io/ibc/core/connection/v1/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 querying grpc-gateway of the connection parameters.

curl -X GET 'https://axelar.nownodes.io/ibc/core/connection/v1/params'

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

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

const response = await fetch('https://axelar.nownodes.io/ibc/core/connection/v1/params', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/connection/v1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/connection/v1/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_expected_time_per_block": "string"
  }
}

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

Clients

ClientParams queries all parameters of the ibc client.

GET

https://axelar.nownodes.io/ibc/core/client/v1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

ClientParams queries all parameters of the ibc client.

curl -X GET 'https://axelar.nownodes.io/ibc/core/client/v1/params'

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

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

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/params', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/client/v1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/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)

200

{
  "params": {
    "allowed_clients": [
      "string"
    ]
  }
}

UpgradedClientStates queries the upgraded client state identified by the gov proposal.

GET

https://axelar.nownodes.io/ibc/core/client/v1/upgraded_client_states

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

UpgradedClientStates queries the upgraded client state identified by the gov proposal.

curl -X GET 'https://axelar.nownodes.io/ibc/core/client/v1/upgraded_client_states'

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/upgraded_client_states', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/upgraded_client_states')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/client/v1/upgraded_client_states')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/upgraded_client_states', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/client/v1/upgraded_client_states";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/client/v1/upgraded_client_states', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/client/v1/upgraded_client_states')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/upgraded_client_states')
request = Net::HTTP::Get.new(uri)

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

200

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

UpgradedConsensusStates queries the upgraded consensus state identified by the gov proposal.

GET

https://axelar.nownodes.io/ibc/core/client/v1/upgraded_consensus_states

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

UpgradedConsensusStates queries the upgraded consensus state identified by the gov proposal.

curl -X GET 'https://axelar.nownodes.io/ibc/core/client/v1/upgraded_consensus_states'

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/upgraded_consensus_states', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/upgraded_consensus_states')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/client/v1/upgraded_consensus_states')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/client/v1/upgraded_consensus_states', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/client/v1/upgraded_consensus_states";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/client/v1/upgraded_consensus_states', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/client/v1/upgraded_consensus_states')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/client/v1/upgraded_consensus_states')
request = Net::HTTP::Get.new(uri)

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

200

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

ChannelV2

NextSequenceSend returns the next send sequence for a given channel.

GET

https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/next_sequence_send

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

client unique identifier

Response

200OK

A successful response.

NextSequenceSend returns the next send sequence for a given channel.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/next_sequence_send'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/next_sequence_send', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/next_sequence_send')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v2/clients/{client_id}/next_sequence_send')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/next_sequence_send', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/next_sequence_send";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v2/clients/{client_id}/next_sequence_send', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/next_sequence_send')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/next_sequence_send')
request = Net::HTTP::Get.new(uri)

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

200

{
  "next_sequence_send": "string",
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

PacketCommitment queries a stored packet commitment hash.

GET

https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequence}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

client unique identifier

sequencestring<uint64>requiredpath

packet sequence

Response

200OK

A successful response.

PacketCommitment queries a stored packet commitment hash.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequence}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequence}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequence}')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequence}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequence}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequence}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequence}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequence}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequence}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "commitment": "dGVzdA==",
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

PacketCommitments returns all packet commitments associated with a client.

GET

https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

pagination.keystring<byte>query

pagination.offsetstring<uint64>query

pagination.limitstring<uint64>query

pagination.count_totalbooleanquery

pagination.reversebooleanquery

Response

200OK

A successful response.

PacketCommitments returns all packet commitments associated with a client.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v2/clients/{client_id}/packet_commitments')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v2/clients/{client_id}/packet_commitments', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments')
request = Net::HTTP::Get.new(uri)

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

200

{
  "commitments": [
    {
      "port_id": "string",
      "channel_id": "string",
      "sequence": "string",
      "data": "dGVzdA=="
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  },
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

PacketAcknowledgement queries a stored acknowledgement commitment hash.

GET

https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acks/{sequence}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

sequencestring<uint64>requiredpath

Response

200OK

A successful response.

PacketAcknowledgement queries a stored acknowledgement commitment hash.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acks/{sequence}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acks/{sequence}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acks/{sequence}')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v2/clients/{client_id}/packet_acks/{sequence}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acks/{sequence}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acks/{sequence}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v2/clients/{client_id}/packet_acks/{sequence}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acks/{sequence}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acks/{sequence}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "acknowledgement": "dGVzdA==",
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

PacketAcknowledgements returns all packet acknowledgements associated with a client.

GET

https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acknowledgements

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

pagination.keystring<byte>query

pagination.limitstring<uint64>query

packet_commitment_sequencesArray<string>query

list of packet sequences

Response

200OK

A successful response.

PacketAcknowledgements returns all packet acknowledgements associated with a client.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acknowledgements'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acknowledgements', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acknowledgements')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v2/clients/{client_id}/packet_acknowledgements')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acknowledgements', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acknowledgements";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v2/clients/{client_id}/packet_acknowledgements', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acknowledgements')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_acknowledgements')
request = Net::HTTP::Get.new(uri)

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

200

{
  "acknowledgements": [
    {
      "port_id": "string",
      "channel_id": "string",
      "sequence": "string",
      "data": "dGVzdA=="
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  },
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

PacketReceipt queries a stored packet receipt.

GET

https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_receipts/{sequence}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

sequencestring<uint64>requiredpath

Response

200OK

A successful response.

PacketReceipt queries a stored packet receipt.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_receipts/{sequence}'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_receipts/{sequence}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_receipts/{sequence}')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v2/clients/{client_id}/packet_receipts/{sequence}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_receipts/{sequence}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_receipts/{sequence}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v2/clients/{client_id}/packet_receipts/{sequence}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_receipts/{sequence}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_receipts/{sequence}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "received": true,
  "proof": "dGVzdA==",
  "proof_height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

UnreceivedPackets returns all the unreceived IBC packets associated with a client and sequences.

GET

https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequences}/unreceived_packets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

sequencesArray<string>requiredpath

list of packet sequences

Response

200OK

A successful response.

UnreceivedPackets returns all the unreceived IBC packets associated with a client and sequences.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequences}/unreceived_packets'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequences}/unreceived_packets', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequences}/unreceived_packets')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequences}/unreceived_packets')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequences}/unreceived_packets', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequences}/unreceived_packets";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequences}/unreceived_packets', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequences}/unreceived_packets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{sequences}/unreceived_packets')
request = Net::HTTP::Get.new(uri)

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

200

{
  "sequences": [
    "string"
  ],
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

UnreceivedAcks returns all the unreceived IBC acknowledgements associated with a client and sequences.

GET

https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

client_idstringrequiredpath

packet_ack_sequencesArray<string>requiredpath

list of acknowledgement sequences

Response

200OK

A successful response.

UnreceivedAcks returns all the unreceived IBC acknowledgements associated with a client and sequences.

curl -X GET 'https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks'

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/core/channel/v2/clients/{client_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks')
request = Net::HTTP::Get.new(uri)

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

200

{
  "sequences": [
    "string"
  ],
  "height": {
    "revision_number": "string",
    "revision_height": "string"
  }
}

Apps

EscrowAddress returns the escrow address for a particular port and channel id.

GET

https://axelar.nownodes.io/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_address

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

channel_idstringrequiredpath

unique channel identifier

port_idstringrequiredpath

unique port identifier

Response

200OK

A successful response.

default

An unexpected error response

EscrowAddress returns the escrow address for a particular port and channel id.

curl -X GET 'https://axelar.nownodes.io/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_address'

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_address', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_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/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_address')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_address', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_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/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_address', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_address')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_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)

{
  "escrow_address": "string"
}

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

DenomHash queries a denomination hash information.

GET

https://axelar.nownodes.io/ibc/apps/transfer/v1/denom_hashes/{trace}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

tracestringrequiredpath

The denomination trace ([port_id]/[channel_id])+/[denom]

Response

200OK

A successful response.

default

An unexpected error response

DenomHash queries a denomination hash information.

curl -X GET 'https://axelar.nownodes.io/ibc/apps/transfer/v1/denom_hashes/{trace}'

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/denom_hashes/{trace}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/denom_hashes/{trace}')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/apps/transfer/v1/denom_hashes/{trace}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/denom_hashes/{trace}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/apps/transfer/v1/denom_hashes/{trace}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/apps/transfer/v1/denom_hashes/{trace}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/apps/transfer/v1/denom_hashes/{trace}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/denom_hashes/{trace}')
request = Net::HTTP::Get.new(uri)

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

{
  "hash": "string"
}

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

Denoms queries all denominations

GET

https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

pagination.offsetstring<uint64>query

pagination.limitstring<uint64>query

pagination.count_totalbooleanquery

pagination.reversebooleanquery

Response

200OK

A successful response.

Denoms queries all denominations

curl -X GET 'https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms'

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms')
request = Net::HTTP::Get.new(uri)

response = Net::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/ibc/apps/transfer/v1/denoms')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "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/ibc/apps/transfer/v1/denoms', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms')
request = Net::HTTP::Get.new(uri)

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

200

{
  "denoms": [
    {
      "base": "string",
      "trace": [
        {
          "port_id": "string",
          "channel_id": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

Denom queries a denomination

GET

https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

hashstringrequiredpath

hash (in hex format) or denom (full denom with ibc prefix) of the on chain denomination.

Response

200OK

A successful response.

Denom queries a denomination

curl -X GET 'https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms/{hash}'

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms/{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/ibc/apps/transfer/v1/denoms/{hash}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms/{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/ibc/apps/transfer/v1/denoms/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/denoms/{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)

200

{
  "denom": {
    "base": "string",
    "trace": [
      {
        "port_id": "string",
        "channel_id": "string"
      }
    ]
  }
}

TotalEscrowForDenom returns the total amount of tokens in escrow based on the denom.

GET

https://axelar.nownodes.io/ibc/apps/transfer/v1/total_escrow/{denom}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringrequiredpath

The denomination, e.g. uatom or ibc/27394FB0...

Response

200OK

A successful response.

TotalEscrowForDenom returns the total amount of tokens in escrow based on the denom.

curl -X GET 'https://axelar.nownodes.io/ibc/apps/transfer/v1/total_escrow/{denom}'

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/total_escrow/{denom}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/total_escrow/{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/ibc/apps/transfer/v1/total_escrow/{denom}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/total_escrow/{denom}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/ibc/apps/transfer/v1/total_escrow/{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/ibc/apps/transfer/v1/total_escrow/{denom}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/apps/transfer/v1/total_escrow/{denom}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/total_escrow/{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)

200

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

Params queries all parameters of the ibc-transfer module.

GET

https://axelar.nownodes.io/ibc/apps/transfer/v1/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 of the ibc-transfer module.

curl -X GET 'https://axelar.nownodes.io/ibc/apps/transfer/v1/params'

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

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

const response = await fetch('https://axelar.nownodes.io/ibc/apps/transfer/v1/params', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/ibc/apps/transfer/v1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/ibc/apps/transfer/v1/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": true,
    "receive_enabled": true
  }
}

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

Documentation

How to migrate to NOWNodes

Authentication

API Reference

Core

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Query

Authorizations

Response