ZetaChain - gRPC Gateway docs

v1.0.0

Base URL

https://zetachain.nownodes.io

Documentation for the API of ZetaChain.

Authentication

api-keyAuthapiKey

API Key: api-key in header

MAINNET / API Referense

Authority

Queries Policies

GET

https://zetachain.nownodes.io/zeta-chain/authority/policies

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries Policies

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/authority/policies'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/authority/policies', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/authority/policies')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/authority/policies')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/authority/policies', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/authority/policies";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/authority/policies', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/authority/policies')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/authority/policies')
request = Net::HTTP::Get.new(uri)

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

{
  "policies": {
    "items": [
      {
        "policy_type": "groupEmergency",
        "address": "string"
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Crosschain

Queries a list of send items.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/cctx

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_totalbooleanquery

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.reversebooleanquery

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.

Queries a list of send items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/cctx'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/cctx";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx')
request = Net::HTTP::Get.new(uri)

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

{
  "CrossChainTx": [
    {
      "creator": "string",
      "index": "string",
      "zeta_fees": "string",
      "relayed_message": "string",
      "cctx_status": {
        "status": "PendingInbound",
        "status_message": "string",
        "lastUpdate_timestamp": "string",
        "isAbortRefunded": true
      },
      "inbound_tx_params": {
        "sender": "string",
        "sender_chain_id": "string",
        "tx_origin": "string",
        "coin_type": "Zeta",
        "asset": "string",
        "amount": "string",
        "inbound_tx_observed_hash": "string",
        "inbound_tx_observed_external_height": "string",
        "inbound_tx_ballot_index": "string",
        "inbound_tx_finalized_zeta_height": "string",
        "tx_finalization_status": "NotFinalized"
      },
      "outbound_tx_params": [
        {
          "receiver": "string",
          "receiver_chainId": "string",
          "coin_type": "Zeta",
          "amount": "string",
          "outbound_tx_tss_nonce": "string",
          "outbound_tx_gas_limit": "string",
          "outbound_tx_gas_price": "string",
          "outbound_tx_hash": "string",
          "outbound_tx_ballot_index": "string",
          "outbound_tx_observed_external_height": "string",
          "outbound_tx_gas_used": "string",
          "outbound_tx_effective_gas_price": "string",
          "outbound_tx_effective_gas_limit": "string",
          "tss_pubkey": "string",
          "tx_finalization_status": "NotFinalized"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a send by nonce.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{chainID}/{nonce}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainIDstring<int64>requiredpath

noncestring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a send by nonce.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{chainID}/{nonce}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{chainID}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{chainID}/{nonce}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{chainID}/{nonce}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{chainID}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{chainID}/{nonce}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{chainID}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{chainID}/{nonce}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{chainID}/{nonce}')
request = Net::HTTP::Get.new(uri)

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

{
  "CrossChainTx": {
    "creator": "string",
    "index": "string",
    "zeta_fees": "string",
    "relayed_message": "string",
    "cctx_status": {
      "status": "PendingInbound",
      "status_message": "string",
      "lastUpdate_timestamp": "string",
      "isAbortRefunded": true
    },
    "inbound_tx_params": {
      "sender": "string",
      "sender_chain_id": "string",
      "tx_origin": "string",
      "coin_type": "Zeta",
      "asset": "string",
      "amount": "string",
      "inbound_tx_observed_hash": "string",
      "inbound_tx_observed_external_height": "string",
      "inbound_tx_ballot_index": "string",
      "inbound_tx_finalized_zeta_height": "string",
      "tx_finalization_status": "NotFinalized"
    },
    "outbound_tx_params": [
      {
        "receiver": "string",
        "receiver_chainId": "string",
        "coin_type": "Zeta",
        "amount": "string",
        "outbound_tx_tss_nonce": "string",
        "outbound_tx_gas_limit": "string",
        "outbound_tx_gas_price": "string",
        "outbound_tx_hash": "string",
        "outbound_tx_ballot_index": "string",
        "outbound_tx_observed_external_height": "string",
        "outbound_tx_gas_used": "string",
        "outbound_tx_effective_gas_price": "string",
        "outbound_tx_effective_gas_limit": "string",
        "tss_pubkey": "string",
        "tx_finalization_status": "NotFinalized"
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a send by index.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{index}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

indexstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a send by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{index}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{index}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{index}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{index}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{index}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{index}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{index}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{index}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/cctx/{index}')
request = Net::HTTP::Get.new(uri)

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

{
  "CrossChainTx": {
    "creator": "string",
    "index": "string",
    "zeta_fees": "string",
    "relayed_message": "string",
    "cctx_status": {
      "status": "PendingInbound",
      "status_message": "string",
      "lastUpdate_timestamp": "string",
      "isAbortRefunded": true
    },
    "inbound_tx_params": {
      "sender": "string",
      "sender_chain_id": "string",
      "tx_origin": "string",
      "coin_type": "Zeta",
      "asset": "string",
      "amount": "string",
      "inbound_tx_observed_hash": "string",
      "inbound_tx_observed_external_height": "string",
      "inbound_tx_ballot_index": "string",
      "inbound_tx_finalized_zeta_height": "string",
      "tx_finalization_status": "NotFinalized"
    },
    "outbound_tx_params": [
      {
        "receiver": "string",
        "receiver_chainId": "string",
        "coin_type": "Zeta",
        "amount": "string",
        "outbound_tx_tss_nonce": "string",
        "outbound_tx_gas_limit": "string",
        "outbound_tx_gas_price": "string",
        "outbound_tx_hash": "string",
        "outbound_tx_ballot_index": "string",
        "outbound_tx_observed_external_height": "string",
        "outbound_tx_gas_used": "string",
        "outbound_tx_effective_gas_price": "string",
        "outbound_tx_effective_gas_limit": "string",
        "tss_pubkey": "string",
        "tx_finalization_status": "NotFinalized"
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/convertGasToZeta

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainIdstring<int64>query

gasLimitstringquery

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/crosschain/convertGasToZeta

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/convertGasToZeta'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/convertGasToZeta', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/convertGasToZeta')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/convertGasToZeta')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/convertGasToZeta', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/convertGasToZeta";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/convertGasToZeta', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/convertGasToZeta')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/convertGasToZeta')
request = Net::HTTP::Get.new(uri)

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

{
  "outboundGasInZeta": "string",
  "protocolFeeInZeta": "string",
  "ZetaBlockHeight": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of gasPrice items.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice

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_totalbooleanquery

pagination.reversebooleanquery

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.

Queries a list of gasPrice items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice')
request = Net::HTTP::Get.new(uri)

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

{
  "GasPrice": [
    {
      "creator": "string",
      "index": "string",
      "chain_id": "string",
      "signers": [
        "string"
      ],
      "block_nums": [
        "string"
      ],
      "prices": [
        "string"
      ],
      "median_index": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a gasPrice by index.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice/{index}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

indexstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a gasPrice by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice/{index}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice/{index}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice/{index}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice/{index}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice/{index}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice/{index}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice/{index}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice/{index}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/gasPrice/{index}')
request = Net::HTTP::Get.new(uri)

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

{
  "GasPrice": {
    "creator": "string",
    "index": "string",
    "chain_id": "string",
    "signers": [
      "string"
    ],
    "block_nums": [
      "string"
    ],
    "prices": [
      "string"
    ],
    "median_index": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a InTxHashToCctx data by index.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

inTxHashstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a InTxHashToCctx data by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}')
request = Net::HTTP::Get.new(uri)

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

{
  "CrossChainTxs": [
    {
      "creator": "string",
      "index": "string",
      "zeta_fees": "string",
      "relayed_message": "string",
      "cctx_status": {
        "status": "PendingInbound",
        "status_message": "string",
        "lastUpdate_timestamp": "string",
        "isAbortRefunded": true
      },
      "inbound_tx_params": {
        "sender": "string",
        "sender_chain_id": "string",
        "tx_origin": "string",
        "coin_type": "Zeta",
        "asset": "string",
        "amount": "string",
        "inbound_tx_observed_hash": "string",
        "inbound_tx_observed_external_height": "string",
        "inbound_tx_ballot_index": "string",
        "inbound_tx_finalized_zeta_height": "string",
        "tx_finalization_status": "NotFinalized"
      },
      "outbound_tx_params": [
        {
          "receiver": "string",
          "receiver_chainId": "string",
          "coin_type": "Zeta",
          "amount": "string",
          "outbound_tx_tss_nonce": "string",
          "outbound_tx_gas_limit": "string",
          "outbound_tx_gas_price": "string",
          "outbound_tx_hash": "string",
          "outbound_tx_ballot_index": "string",
          "outbound_tx_observed_external_height": "string",
          "outbound_tx_gas_used": "string",
          "outbound_tx_effective_gas_price": "string",
          "outbound_tx_effective_gas_limit": "string",
          "tss_pubkey": "string",
          "tx_finalization_status": "NotFinalized"
        }
      ]
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of InTxHashToCctx items.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx

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_totalbooleanquery

pagination.reversebooleanquery

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.

Queries a list of InTxHashToCctx items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx')
request = Net::HTTP::Get.new(uri)

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

{
  "inTxHashToCctx": [
    {
      "in_tx_hash": "string",
      "cctx_index": [
        "string"
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a InTxHashToCctx by index.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx/{inTxHash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

inTxHashstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a InTxHashToCctx by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx/{inTxHash}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx/{inTxHash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx/{inTxHash}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx/{inTxHash}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx/{inTxHash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx/{inTxHash}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx/{inTxHash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx/{inTxHash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxHashToCctx/{inTxHash}')
request = Net::HTTP::Get.new(uri)

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

{
  "inTxHashToCctx": {
    "in_tx_hash": "string",
    "cctx_index": [
      "string"
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackerByChain/{chain_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chain_idstring<int64>requiredpath

pagination.keystring<byte>query

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

pagination.offsetstring<uint64>query

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

pagination.limitstring<uint64>query

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

pagination.count_totalbooleanquery

pagination.reversebooleanquery

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.

GET /zeta-chain/crosschain/inTxTrackerByChain/{chain_id}

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackerByChain/{chain_id}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackerByChain/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackerByChain/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackerByChain/{chain_id}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackerByChain/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackerByChain/{chain_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackerByChain/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackerByChain/{chain_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackerByChain/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

{
  "inTxTracker": [
    {
      "chain_id": "string",
      "tx_hash": "string",
      "coin_type": "Zeta"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackers

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_totalbooleanquery

pagination.reversebooleanquery

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.

GET /zeta-chain/crosschain/inTxTrackers

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackers'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackers', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackers')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackers')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackers', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackers', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/inTxTrackers')
request = Net::HTTP::Get.new(uri)

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

{
  "inTxTracker": [
    {
      "chain_id": "string",
      "tx_hash": "string",
      "coin_type": "Zeta"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of lastBlockHeight items.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight

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_totalbooleanquery

pagination.reversebooleanquery

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.

Queries a list of lastBlockHeight items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight')
request = Net::HTTP::Get.new(uri)

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

{
  "LastBlockHeight": [
    {
      "creator": "string",
      "index": "string",
      "chain": "string",
      "lastSendHeight": "string",
      "lastReceiveHeight": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a lastBlockHeight by index.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight/{index}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

indexstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a lastBlockHeight by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight/{index}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight/{index}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight/{index}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight/{index}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight/{index}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight/{index}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight/{index}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight/{index}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/lastBlockHeight/{index}')
request = Net::HTTP::Get.new(uri)

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

{
  "LastBlockHeight": {
    "creator": "string",
    "index": "string",
    "chain": "string",
    "lastSendHeight": "string",
    "lastReceiveHeight": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of lastMetaHeight items.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/lastZetaHeight

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of lastMetaHeight items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/lastZetaHeight'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/lastZetaHeight', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/lastZetaHeight')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/lastZetaHeight')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/lastZetaHeight', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/lastZetaHeight";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/lastZetaHeight', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/lastZetaHeight')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/lastZetaHeight')
request = Net::HTTP::Get.new(uri)

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

{
  "Height": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of OutTxTracker items.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker

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_totalbooleanquery

pagination.reversebooleanquery

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.

Queries a list of OutTxTracker items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker')
request = Net::HTTP::Get.new(uri)

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

{
  "outTxTracker": [
    {
      "index": "string",
      "chain_id": "string",
      "nonce": "string",
      "hash_list": [
        {
          "tx_hash": "string",
          "tx_signer": "string",
          "proved": true
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a OutTxTracker by index.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker/{chainID}/{nonce}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainIDstring<int64>requiredpath

noncestring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a OutTxTracker by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker/{chainID}/{nonce}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker/{chainID}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker/{chainID}/{nonce}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker/{chainID}/{nonce}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker/{chainID}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker/{chainID}/{nonce}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker/{chainID}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker/{chainID}/{nonce}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTracker/{chainID}/{nonce}')
request = Net::HTTP::Get.new(uri)

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

{
  "outTxTracker": {
    "index": "string",
    "chain_id": "string",
    "nonce": "string",
    "hash_list": [
      {
        "tx_hash": "string",
        "tx_signer": "string",
        "proved": true
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTrackerByChain/{chain}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chainstring<int64>requiredpath

pagination.keystring<byte>query

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

pagination.offsetstring<uint64>query

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

pagination.limitstring<uint64>query

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

pagination.count_totalbooleanquery

pagination.reversebooleanquery

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.

GET /zeta-chain/crosschain/outTxTrackerByChain/{chain}

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTrackerByChain/{chain}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTrackerByChain/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTrackerByChain/{chain}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTrackerByChain/{chain}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTrackerByChain/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTrackerByChain/{chain}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTrackerByChain/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTrackerByChain/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/outTxTrackerByChain/{chain}')
request = Net::HTTP::Get.new(uri)

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

{
  "outTxTracker": [
    {
      "index": "string",
      "chain_id": "string",
      "nonce": "string",
      "hash_list": [
        {
          "tx_hash": "string",
          "tx_signer": "string",
          "proved": true
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of pending cctxs.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctx

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chain_idstring<int64>query

limitinteger<int64>query

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of pending cctxs.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctx'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctx', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctx')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctx')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctx', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctx";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctx', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctx')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctx')
request = Net::HTTP::Get.new(uri)

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

{
  "CrossChainTx": [
    {
      "creator": "string",
      "index": "string",
      "zeta_fees": "string",
      "relayed_message": "string",
      "cctx_status": {
        "status": "PendingInbound",
        "status_message": "string",
        "lastUpdate_timestamp": "string",
        "isAbortRefunded": true
      },
      "inbound_tx_params": {
        "sender": "string",
        "sender_chain_id": "string",
        "tx_origin": "string",
        "coin_type": "Zeta",
        "asset": "string",
        "amount": "string",
        "inbound_tx_observed_hash": "string",
        "inbound_tx_observed_external_height": "string",
        "inbound_tx_ballot_index": "string",
        "inbound_tx_finalized_zeta_height": "string",
        "tx_finalization_status": "NotFinalized"
      },
      "outbound_tx_params": [
        {
          "receiver": "string",
          "receiver_chainId": "string",
          "coin_type": "Zeta",
          "amount": "string",
          "outbound_tx_tss_nonce": "string",
          "outbound_tx_gas_limit": "string",
          "outbound_tx_gas_price": "string",
          "outbound_tx_hash": "string",
          "outbound_tx_ballot_index": "string",
          "outbound_tx_observed_external_height": "string",
          "outbound_tx_gas_used": "string",
          "outbound_tx_effective_gas_price": "string",
          "outbound_tx_effective_gas_limit": "string",
          "tss_pubkey": "string",
          "tx_finalization_status": "NotFinalized"
        }
      ]
    }
  ],
  "totalPending": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of pending cctxs within rate limit.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctxWithinRateLimit

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

limitinteger<int64>query

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of pending cctxs within rate limit.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctxWithinRateLimit'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctxWithinRateLimit', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctxWithinRateLimit')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctxWithinRateLimit')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctxWithinRateLimit', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctxWithinRateLimit";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctxWithinRateLimit', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctxWithinRateLimit')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/pendingCctxWithinRateLimit')
request = Net::HTTP::Get.new(uri)

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

{
  "cross_chain_tx": [
    {
      "creator": "string",
      "index": "string",
      "zeta_fees": "string",
      "relayed_message": "string",
      "cctx_status": {
        "status": "PendingInbound",
        "status_message": "string",
        "lastUpdate_timestamp": "string",
        "isAbortRefunded": true
      },
      "inbound_tx_params": {
        "sender": "string",
        "sender_chain_id": "string",
        "tx_origin": "string",
        "coin_type": "Zeta",
        "asset": "string",
        "amount": "string",
        "inbound_tx_observed_hash": "string",
        "inbound_tx_observed_external_height": "string",
        "inbound_tx_ballot_index": "string",
        "inbound_tx_finalized_zeta_height": "string",
        "tx_finalization_status": "NotFinalized"
      },
      "outbound_tx_params": [
        {
          "receiver": "string",
          "receiver_chainId": "string",
          "coin_type": "Zeta",
          "amount": "string",
          "outbound_tx_tss_nonce": "string",
          "outbound_tx_gas_limit": "string",
          "outbound_tx_gas_price": "string",
          "outbound_tx_hash": "string",
          "outbound_tx_ballot_index": "string",
          "outbound_tx_observed_external_height": "string",
          "outbound_tx_gas_used": "string",
          "outbound_tx_effective_gas_price": "string",
          "outbound_tx_effective_gas_limit": "string",
          "tss_pubkey": "string",
          "tx_finalization_status": "NotFinalized"
        }
      ]
    }
  ],
  "total_pending": "string",
  "current_withdraw_window": "string",
  "current_withdraw_rate": "string",
  "rate_limit_exceeded": true
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/protocolFee

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/crosschain/protocolFee

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/protocolFee'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/protocolFee', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/protocolFee')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/protocolFee')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/protocolFee', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/protocolFee";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/protocolFee', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/protocolFee')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/protocolFee')
request = Net::HTTP::Get.new(uri)

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

{
  "feeInZeta": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries the rate limiter flags

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterFlags

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries the rate limiter flags

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterFlags'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterFlags', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterFlags')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterFlags')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterFlags', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterFlags";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterFlags', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterFlags')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterFlags')
request = Net::HTTP::Get.new(uri)

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

{
  "rateLimiterFlags": {
    "enabled": true,
    "window": "string",
    "rate": "string",
    "conversions": [
      {
        "zrc20": "string",
        "rate": "string"
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries the input data of rate limiter.

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterInput

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

limitinteger<int64>query

windowstring<int64>query

Response

200OK

A successful response.

default

An unexpected error response.

Queries the input data of rate limiter.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterInput'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterInput', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterInput')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterInput')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterInput', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterInput";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterInput', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterInput')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/rateLimiterInput')
request = Net::HTTP::Get.new(uri)

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

{
  "height": "string",
  "cctxs_missed": [
    {
      "creator": "string",
      "index": "string",
      "zeta_fees": "string",
      "relayed_message": "string",
      "cctx_status": {
        "status": "PendingInbound",
        "status_message": "string",
        "lastUpdate_timestamp": "string",
        "isAbortRefunded": true
      },
      "inbound_tx_params": {
        "sender": "string",
        "sender_chain_id": "string",
        "tx_origin": "string",
        "coin_type": "Zeta",
        "asset": "string",
        "amount": "string",
        "inbound_tx_observed_hash": "string",
        "inbound_tx_observed_external_height": "string",
        "inbound_tx_ballot_index": "string",
        "inbound_tx_finalized_zeta_height": "string",
        "tx_finalization_status": "NotFinalized"
      },
      "outbound_tx_params": [
        {
          "receiver": "string",
          "receiver_chainId": "string",
          "coin_type": "Zeta",
          "amount": "string",
          "outbound_tx_tss_nonce": "string",
          "outbound_tx_gas_limit": "string",
          "outbound_tx_gas_price": "string",
          "outbound_tx_hash": "string",
          "outbound_tx_ballot_index": "string",
          "outbound_tx_observed_external_height": "string",
          "outbound_tx_gas_used": "string",
          "outbound_tx_effective_gas_price": "string",
          "outbound_tx_effective_gas_limit": "string",
          "tss_pubkey": "string",
          "tx_finalization_status": "NotFinalized"
        }
      ]
    }
  ],
  "cctxs_pending": [
    {
      "creator": "string",
      "index": "string",
      "zeta_fees": "string",
      "relayed_message": "string",
      "cctx_status": {
        "status": "PendingInbound",
        "status_message": "string",
        "lastUpdate_timestamp": "string",
        "isAbortRefunded": true
      },
      "inbound_tx_params": {
        "sender": "string",
        "sender_chain_id": "string",
        "tx_origin": "string",
        "coin_type": "Zeta",
        "asset": "string",
        "amount": "string",
        "inbound_tx_observed_hash": "string",
        "inbound_tx_observed_external_height": "string",
        "inbound_tx_ballot_index": "string",
        "inbound_tx_finalized_zeta_height": "string",
        "tx_finalization_status": "NotFinalized"
      },
      "outbound_tx_params": [
        {
          "receiver": "string",
          "receiver_chainId": "string",
          "coin_type": "Zeta",
          "amount": "string",
          "outbound_tx_tss_nonce": "string",
          "outbound_tx_gas_limit": "string",
          "outbound_tx_gas_price": "string",
          "outbound_tx_hash": "string",
          "outbound_tx_ballot_index": "string",
          "outbound_tx_observed_external_height": "string",
          "outbound_tx_gas_used": "string",
          "outbound_tx_effective_gas_price": "string",
          "outbound_tx_effective_gas_limit": "string",
          "tss_pubkey": "string",
          "tx_finalization_status": "NotFinalized"
        }
      ]
    }
  ],
  "total_pending": "string",
  "past_cctxs_value": "string",
  "pending_cctxs_value": "string",
  "lowest_pending_cctx_height": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/crosschain/zetaAccounting

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/crosschain/zetaAccounting

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/crosschain/zetaAccounting'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/zetaAccounting', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/zetaAccounting')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/zetaAccounting')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/zetaAccounting', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/crosschain/zetaAccounting";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/crosschain/zetaAccounting', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/crosschain/zetaAccounting')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/crosschain/zetaAccounting')
request = Net::HTTP::Get.new(uri)

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

{
  "aborted_zeta_amount": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Emissions

Queries a list of GetEmmisonsFactors items.

GET

https://zetachain.nownodes.io/zeta-chain/emissions/get_emissions_factors

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of GetEmmisonsFactors items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/emissions/get_emissions_factors'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/emissions/get_emissions_factors', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/emissions/get_emissions_factors')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/emissions/get_emissions_factors')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/emissions/get_emissions_factors', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/emissions/get_emissions_factors";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/emissions/get_emissions_factors', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/emissions/get_emissions_factors')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/emissions/get_emissions_factors')
request = Net::HTTP::Get.new(uri)

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

{
  "reservesFactor": "string",
  "bondFactor": "string",
  "durationFactor": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of ListBalances items.

GET

https://zetachain.nownodes.io/zeta-chain/emissions/list_addresses

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of ListBalances items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/emissions/list_addresses'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/emissions/list_addresses', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/emissions/list_addresses')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/emissions/list_addresses')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/emissions/list_addresses', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/emissions/list_addresses";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/emissions/list_addresses', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/emissions/list_addresses')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/emissions/list_addresses')
request = Net::HTTP::Get.new(uri)

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

{
  "undistributed_observer_balances_address": "string",
  "undistributed_tss_balances_address": "string",
  "emission_module_address": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Parameters queries the parameters of the module.

GET

https://zetachain.nownodes.io/zeta-chain/emissions/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Parameters queries the parameters of the module.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/emissions/params'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/emissions/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/emissions/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://zetachain.nownodes.io/zeta-chain/emissions/params')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/emissions/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/emissions/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://zetachain.nownodes.io/zeta-chain/emissions/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/emissions/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/emissions/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_bond_factor": "string",
    "min_bond_factor": "string",
    "avg_block_time": "string",
    "target_bond_ratio": "string",
    "validator_emission_percentage": "string",
    "observer_emission_percentage": "string",
    "tss_signer_emission_percentage": "string",
    "duration_factor_constant": "string",
    "observer_slash_amount": "string",
    "ballot_maturity_blocks": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of ShowAvailableEmissions items.

GET

https://zetachain.nownodes.io/zeta-chain/emissions/show_available_emissions/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

addressstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of ShowAvailableEmissions items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/emissions/show_available_emissions/{address}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/emissions/show_available_emissions/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/emissions/show_available_emissions/{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://zetachain.nownodes.io/zeta-chain/emissions/show_available_emissions/{address}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/emissions/show_available_emissions/{address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/emissions/show_available_emissions/{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://zetachain.nownodes.io/zeta-chain/emissions/show_available_emissions/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/emissions/show_available_emissions/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/emissions/show_available_emissions/{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)

{
  "amount": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Fungible

Code hash query the code hash of a contract.

GET

https://zetachain.nownodes.io/zeta-chain/fungible/code_hash/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

addressstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Code hash query the code hash of a contract.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/fungible/code_hash/{address}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/code_hash/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/code_hash/{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://zetachain.nownodes.io/zeta-chain/fungible/code_hash/{address}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/code_hash/{address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/fungible/code_hash/{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://zetachain.nownodes.io/zeta-chain/fungible/code_hash/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/fungible/code_hash/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/code_hash/{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)

{
  "code_hash": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of ForeignCoins items.

GET

https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins

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_totalbooleanquery

pagination.reversebooleanquery

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.

Queries a list of ForeignCoins items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins')
request = Net::HTTP::Get.new(uri)

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

{
  "foreignCoins": [
    {
      "zrc20_contract_address": "string",
      "asset": "string",
      "foreign_chain_id": "string",
      "decimals": 0,
      "name": "string",
      "symbol": "string",
      "coin_type": "Zeta",
      "gas_limit": "string",
      "paused": true,
      "liquidity_cap": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a ForeignCoins by index.

GET

https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins/{index}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

indexstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a ForeignCoins by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins/{index}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins/{index}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins/{index}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins/{index}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins/{index}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins/{index}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins/{index}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins/{index}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/foreign_coins/{index}')
request = Net::HTTP::Get.new(uri)

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

{
  "foreignCoins": {
    "zrc20_contract_address": "string",
    "asset": "string",
    "foreign_chain_id": "string",
    "decimals": 0,
    "name": "string",
    "symbol": "string",
    "coin_type": "Zeta",
    "gas_limit": "string",
    "paused": true,
    "liquidity_cap": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries the address of a gas stability pool on a given chain.

GET

https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_address

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries the address of a gas stability pool on a given chain.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_address'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_address', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_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://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_address')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_address', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_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://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_address', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_address')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_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)

{
  "cosmos_address": "string",
  "evm_address": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries the balance of a gas stability pool on a given chain.

GET

https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_balance/{chain_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chain_idstring<int64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries the balance of a gas stability pool on a given chain.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_balance/{chain_id}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_balance/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_balance/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_balance/{chain_id}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_balance/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_balance/{chain_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_balance/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_balance/{chain_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/gas_stability_pool_balance/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

{
  "balance": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries SystemContract

GET

https://zetachain.nownodes.io/zeta-chain/fungible/system_contract

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries SystemContract

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/fungible/system_contract'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/system_contract', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/system_contract')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/fungible/system_contract')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/system_contract', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/fungible/system_contract";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/fungible/system_contract', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/fungible/system_contract')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/fungible/system_contract')
request = Net::HTTP::Get.new(uri)

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

{
  "SystemContract": {
    "system_contract": "string",
    "connector_zevm": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Lightclient

GET

https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers

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_totalbooleanquery

pagination.reversebooleanquery

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.

GET /zeta-chain/lightclient/block_headers

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers')
request = Net::HTTP::Get.new(uri)

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

{
  "block_headers": [
    {
      "height": "string",
      "hash": "dGVzdA==",
      "parent_hash": "dGVzdA==",
      "chain_id": "string",
      "header": {
        "ethereum_header": "dGVzdA==",
        "bitcoin_header": "dGVzdA=="
      }
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers/{block_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

block_hashstring<byte>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/lightclient/block_headers/{block_hash}

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers/{block_hash}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers/{block_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://zetachain.nownodes.io/zeta-chain/lightclient/block_headers/{block_hash}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers/{block_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://zetachain.nownodes.io/zeta-chain/lightclient/block_headers/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers/{block_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/block_headers/{block_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)

{
  "block_header": {
    "height": "string",
    "hash": "dGVzdA==",
    "parent_hash": "dGVzdA==",
    "chain_id": "string",
    "header": {
      "ethereum_header": "dGVzdA==",
      "bitcoin_header": "dGVzdA=="
    }
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state

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_totalbooleanquery

pagination.reversebooleanquery

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.

GET /zeta-chain/lightclient/chain_state

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state')
request = Net::HTTP::Get.new(uri)

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

{
  "chain_state": [
    {
      "chain_id": "string",
      "latest_height": "string",
      "earliest_height": "string",
      "latest_block_hash": "dGVzdA=="
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state/{chain_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chain_idstring<int64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/lightclient/chain_state/{chain_id}

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state/{chain_id}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state/{chain_id}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state/{chain_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state/{chain_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/chain_state/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

{
  "chain_state": {
    "chain_id": "string",
    "latest_height": "string",
    "earliest_height": "string",
    "latest_block_hash": "dGVzdA=="
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/lightclient/header_enabled_chains

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/lightclient/header_enabled_chains

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/lightclient/header_enabled_chains'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/header_enabled_chains', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/header_enabled_chains')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/header_enabled_chains')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/header_enabled_chains', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/lightclient/header_enabled_chains";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/header_enabled_chains', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/header_enabled_chains')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/header_enabled_chains')
request = Net::HTTP::Get.new(uri)

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

{
  "header_enabled_chains": [
    {
      "chain_id": "string",
      "enabled": true
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/lightclient/header_supported_chains

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/lightclient/header_supported_chains

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/lightclient/header_supported_chains'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/header_supported_chains', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/header_supported_chains')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/header_supported_chains')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/header_supported_chains', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/lightclient/header_supported_chains";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/header_supported_chains', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/header_supported_chains')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/header_supported_chains')
request = Net::HTTP::Get.new(uri)

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

{
  "header_supported_chains": [
    {
      "chain_id": "string",
      "enabled": true
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/lightclient/prove

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chain_idstring<int64>query

tx_hashstringquery

proof.ethereum_proof.keysArray<string>query

proof.ethereum_proof.valuesArray<string>query

proof.bitcoin_proof.tx_bytesstring<byte>query

proof.bitcoin_proof.pathstring<byte>query

proof.bitcoin_proof.indexinteger<int64>query

block_hashstringquery

tx_indexstring<int64>query

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/lightclient/prove

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/lightclient/prove'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/prove', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/prove')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/prove')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/prove', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/lightclient/prove";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/lightclient/prove', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/lightclient/prove')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/lightclient/prove')
request = Net::HTTP::Get.new(uri)

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

{
  "valid": true
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Observer

Queries a tSS by index.

GET

https://zetachain.nownodes.io/zeta-chain/observer/TSS

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries a tSS by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/TSS'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/TSS', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/TSS')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/TSS')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/TSS', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/TSS";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/TSS', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/TSS')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/TSS')
request = Net::HTTP::Get.new(uri)

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

{
  "TSS": {
    "tss_pubkey": "string",
    "tss_participant_list": [
      "string"
    ],
    "operator_address_list": [
      "string"
    ],
    "finalizedZetaHeight": "string",
    "keyGenZetaHeight": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of VoterByIdentifier items.

GET

https://zetachain.nownodes.io/zeta-chain/observer/ballot_by_identifier/{ballot_identifier}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ballot_identifierstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of VoterByIdentifier items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/ballot_by_identifier/{ballot_identifier}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/ballot_by_identifier/{ballot_identifier}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/ballot_by_identifier/{ballot_identifier}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/ballot_by_identifier/{ballot_identifier}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/ballot_by_identifier/{ballot_identifier}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/ballot_by_identifier/{ballot_identifier}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/ballot_by_identifier/{ballot_identifier}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/ballot_by_identifier/{ballot_identifier}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/ballot_by_identifier/{ballot_identifier}')
request = Net::HTTP::Get.new(uri)

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

{
  "ballot_identifier": "string",
  "voters": [
    {
      "voter_address": "string",
      "vote_type": "SuccessObservation"
    }
  ],
  "observation_type": "EmptyObserverType",
  "ballot_status": "BallotFinalized_SuccessObservation"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of VoterByIdentifier items.

GET

https://zetachain.nownodes.io/zeta-chain/observer/blame_by_chain_and_nonce/{chain_id}/{nonce}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chain_idstring<int64>requiredpath

noncestring<int64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of VoterByIdentifier items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/blame_by_chain_and_nonce/{chain_id}/{nonce}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_chain_and_nonce/{chain_id}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_chain_and_nonce/{chain_id}/{nonce}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_chain_and_nonce/{chain_id}/{nonce}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_chain_and_nonce/{chain_id}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/blame_by_chain_and_nonce/{chain_id}/{nonce}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_chain_and_nonce/{chain_id}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_chain_and_nonce/{chain_id}/{nonce}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_chain_and_nonce/{chain_id}/{nonce}')
request = Net::HTTP::Get.new(uri)

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

{
  "blame_info": [
    {
      "index": "string",
      "failure_reason": "string",
      "nodes": [
        {
          "pub_key": "string",
          "blame_data": "dGVzdA==",
          "blame_signature": "dGVzdA=="
        }
      ]
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of VoterByIdentifier items.

GET

https://zetachain.nownodes.io/zeta-chain/observer/blame_by_identifier/{blame_identifier}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

blame_identifierstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of VoterByIdentifier items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/blame_by_identifier/{blame_identifier}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_identifier/{blame_identifier}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_identifier/{blame_identifier}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_identifier/{blame_identifier}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_identifier/{blame_identifier}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/blame_by_identifier/{blame_identifier}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_identifier/{blame_identifier}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_identifier/{blame_identifier}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/blame_by_identifier/{blame_identifier}')
request = Net::HTTP::Get.new(uri)

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

{
  "blame_info": {
    "index": "string",
    "failure_reason": "string",
    "nodes": [
      {
        "pub_key": "string",
        "blame_data": "dGVzdA==",
        "blame_signature": "dGVzdA=="
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of chainNonces items.

GET

https://zetachain.nownodes.io/zeta-chain/observer/chainNonces

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_totalbooleanquery

pagination.reversebooleanquery

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.

Queries a list of chainNonces items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/chainNonces'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/chainNonces";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces')
request = Net::HTTP::Get.new(uri)

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

{
  "ChainNonces": [
    {
      "creator": "string",
      "index": "string",
      "chain_id": "string",
      "nonce": "string",
      "signers": [
        "string"
      ],
      "finalizedHeight": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a chainNonces by index.

GET

https://zetachain.nownodes.io/zeta-chain/observer/chainNonces/{index}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

indexstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a chainNonces by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/chainNonces/{index}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces/{index}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces/{index}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces/{index}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces/{index}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/chainNonces/{index}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces/{index}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces/{index}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/chainNonces/{index}')
request = Net::HTTP::Get.new(uri)

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

{
  "ChainNonces": {
    "creator": "string",
    "index": "string",
    "chain_id": "string",
    "nonce": "string",
    "signers": [
      "string"
    ],
    "finalizedHeight": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/observer/crosschain_flags

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/observer/crosschain_flags

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/crosschain_flags'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/crosschain_flags', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/crosschain_flags')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/crosschain_flags')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/crosschain_flags', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/crosschain_flags";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/crosschain_flags', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/crosschain_flags')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/crosschain_flags')
request = Net::HTTP::Get.new(uri)

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

{
  "crosschain_flags": {
    "isInboundEnabled": true,
    "isOutboundEnabled": true,
    "gasPriceIncreaseFlags": {
      "epochLength": "string",
      "retryInterval": "string",
      "gasPriceIncreasePercent": 0,
      "gasPriceIncreaseMax": 0,
      "maxPendingCctxs": 0
    },
    "blockHeaderVerificationFlags": {
      "isEthTypeChainEnabled": true,
      "isBtcTypeChainEnabled": true
    }
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of VoterByIdentifier items.

GET

https://zetachain.nownodes.io/zeta-chain/observer/get_all_blame_records

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_totalbooleanquery

pagination.reversebooleanquery

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.

Queries a list of VoterByIdentifier items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/get_all_blame_records'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_all_blame_records', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/get_all_blame_records')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/get_all_blame_records')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_all_blame_records', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/get_all_blame_records";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_all_blame_records', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/get_all_blame_records')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/get_all_blame_records')
request = Net::HTTP::Get.new(uri)

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

{
  "blame_info": [
    {
      "index": "string",
      "failure_reason": "string",
      "nodes": [
        {
          "pub_key": "string",
          "blame_data": "dGVzdA==",
          "blame_signature": "dGVzdA=="
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of GetChainParams items.

GET

https://zetachain.nownodes.io/zeta-chain/observer/get_chain_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.

Queries a list of GetChainParams items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_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://zetachain.nownodes.io/zeta-chain/observer/get_chain_params')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/get_chain_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://zetachain.nownodes.io/zeta-chain/observer/get_chain_params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_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)

{
  "chain_params": {
    "chain_params": [
      {
        "chain_id": "string",
        "confirmation_count": "string",
        "gas_price_ticker": "string",
        "in_tx_ticker": "string",
        "out_tx_ticker": "string",
        "watch_utxo_ticker": "string",
        "zeta_token_contract_address": "string",
        "connector_contract_address": "string",
        "erc20_custody_contract_address": "string",
        "outbound_tx_schedule_interval": "string",
        "outbound_tx_schedule_lookahead": "string",
        "ballot_threshold": "string",
        "min_observer_delegation": "string",
        "is_supported": true
      }
    ]
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of GetChainParamsForChain items.

GET

https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params_for_chain/{chain_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chain_idstring<int64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of GetChainParamsForChain items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params_for_chain/{chain_id}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params_for_chain/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params_for_chain/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params_for_chain/{chain_id}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params_for_chain/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params_for_chain/{chain_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params_for_chain/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params_for_chain/{chain_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/get_chain_params_for_chain/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

{
  "chain_params": {
    "chain_id": "string",
    "confirmation_count": "string",
    "gas_price_ticker": "string",
    "in_tx_ticker": "string",
    "out_tx_ticker": "string",
    "watch_utxo_ticker": "string",
    "zeta_token_contract_address": "string",
    "connector_contract_address": "string",
    "erc20_custody_contract_address": "string",
    "outbound_tx_schedule_interval": "string",
    "outbound_tx_schedule_lookahead": "string",
    "ballot_threshold": "string",
    "min_observer_delegation": "string",
    "is_supported": true
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of GetTssAddress items.

GET

https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address/{bitcoin_chain_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

bitcoin_chain_idstring<int64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of GetTssAddress items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address/{bitcoin_chain_id}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address/{bitcoin_chain_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address/{bitcoin_chain_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address/{bitcoin_chain_id}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address/{bitcoin_chain_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address/{bitcoin_chain_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address/{bitcoin_chain_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address/{bitcoin_chain_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address/{bitcoin_chain_id}')
request = Net::HTTP::Get.new(uri)

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

{
  "eth": "string",
  "btc": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

finalized_zeta_heightstring<int64>requiredpath

bitcoin_chain_idstring<int64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/get_tss_address_historical/{finalized_zeta_height}/{bitcoin_chain_id}')
request = Net::HTTP::Get.new(uri)

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

{
  "eth": "string",
  "btc": "string"
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Query if a voter has voted for a ballot

GET

https://zetachain.nownodes.io/zeta-chain/observer/has_voted/{ballot_identifier}/{voter_address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ballot_identifierstringrequiredpath

voter_addressstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Query if a voter has voted for a ballot

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/has_voted/{ballot_identifier}/{voter_address}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/has_voted/{ballot_identifier}/{voter_address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/has_voted/{ballot_identifier}/{voter_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://zetachain.nownodes.io/zeta-chain/observer/has_voted/{ballot_identifier}/{voter_address}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/has_voted/{ballot_identifier}/{voter_address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/has_voted/{ballot_identifier}/{voter_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://zetachain.nownodes.io/zeta-chain/observer/has_voted/{ballot_identifier}/{voter_address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/has_voted/{ballot_identifier}/{voter_address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/has_voted/{ballot_identifier}/{voter_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)

{
  "has_voted": true
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a keygen by index.

GET

https://zetachain.nownodes.io/zeta-chain/observer/keygen

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries a keygen by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/keygen'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/keygen', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/keygen')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/keygen')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/keygen', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/keygen";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/keygen', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/keygen')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/keygen')
request = Net::HTTP::Get.new(uri)

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

{
  "keygen": {
    "status": "PendingKeygen",
    "granteePubkeys": [
      "string"
    ],
    "blockNumber": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of nodeAccount items.

GET

https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount

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_totalbooleanquery

pagination.reversebooleanquery

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.

Queries a list of nodeAccount items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount')
request = Net::HTTP::Get.new(uri)

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

{
  "NodeAccount": [
    {
      "operator": "string",
      "granteeAddress": "string",
      "granteePubkey": {
        "secp256k1": "string",
        "ed25519": "string"
      },
      "nodeStatus": "Unknown"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a nodeAccount by index.

GET

https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount/{index}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

indexstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Queries a nodeAccount by index.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount/{index}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount/{index}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount/{index}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount/{index}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount/{index}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount/{index}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount/{index}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount/{index}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/nodeAccount/{index}')
request = Net::HTTP::Get.new(uri)

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

{
  "node_account": {
    "operator": "string",
    "granteeAddress": "string",
    "granteePubkey": {
      "secp256k1": "string",
      "ed25519": "string"
    },
    "nodeStatus": "Unknown"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of ObserversByChainAndType items.

GET

https://zetachain.nownodes.io/zeta-chain/observer/observer_set

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of ObserversByChainAndType items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/observer_set'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/observer_set', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/observer_set')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/observer_set')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/observer_set', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/observer_set";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/observer_set', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/observer_set')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/observer_set')
request = Net::HTTP::Get.new(uri)

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

{
  "observers": [
    "string"
  ]
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces

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_totalbooleanquery

pagination.reversebooleanquery

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.

GET /zeta-chain/observer/pendingNonces

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces')
request = Net::HTTP::Get.new(uri)

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

{
  "pending_nonces": [
    {
      "nonce_low": "string",
      "nonce_high": "string",
      "chain_id": "string",
      "tss": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces/{chain_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

chain_idstring<int64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/observer/pendingNonces/{chain_id}

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces/{chain_id}'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces/{chain_id}')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces/{chain_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces/{chain_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/pendingNonces/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

{
  "pending_nonces": {
    "nonce_low": "string",
    "nonce_high": "string",
    "chain_id": "string",
    "tss": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/observer/supportedChains

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

GET /zeta-chain/observer/supportedChains

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/supportedChains'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/supportedChains', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/supportedChains')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/supportedChains')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/supportedChains', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/supportedChains";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/supportedChains', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/supportedChains')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/supportedChains')
request = Net::HTTP::Get.new(uri)

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

{
  "chains": [
    {
      "chain_name": "empty",
      "chain_id": "string",
      "network": "eth",
      "network_type": "mainnet",
      "vm": "no_vm",
      "consensus": "ethereum",
      "is_external": true
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

GET

https://zetachain.nownodes.io/zeta-chain/observer/tssHistory

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_totalbooleanquery

pagination.reversebooleanquery

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.

GET /zeta-chain/observer/tssHistory

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/observer/tssHistory'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/tssHistory', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/tssHistory')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/tssHistory')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/tssHistory', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/observer/tssHistory";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/observer/tssHistory', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/observer/tssHistory')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/observer/tssHistory')
request = Net::HTTP::Get.new(uri)

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

{
  "tss_list": [
    {
      "tss_pubkey": "string",
      "tss_participant_list": [
        "string"
      ],
      "operator_address_list": [
        "string"
      ],
      "finalizedZetaHeight": "string",
      "keyGenZetaHeight": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Zetacore

Queries all gas stability pool balances.

GET

https://zetachain.nownodes.io/zeta-chain/zetacore/fungible/gas_stability_pool_balance

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries all gas stability pool balances.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/zetacore/fungible/gas_stability_pool_balance'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/zetacore/fungible/gas_stability_pool_balance', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/zetacore/fungible/gas_stability_pool_balance')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/zetacore/fungible/gas_stability_pool_balance')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/zetacore/fungible/gas_stability_pool_balance', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/zetacore/fungible/gas_stability_pool_balance";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/zetacore/fungible/gas_stability_pool_balance', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/zetacore/fungible/gas_stability_pool_balance')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/zetacore/fungible/gas_stability_pool_balance')
request = Net::HTTP::Get.new(uri)

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

{
  "balances": [
    {
      "chain_id": "string",
      "balance": "string"
    }
  ]
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Queries a list of ShowObserverCount items.

GET

https://zetachain.nownodes.io/zeta-chain/zetacore/observer/show_observer_count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Queries a list of ShowObserverCount items.

curl -X GET 'https://zetachain.nownodes.io/zeta-chain/zetacore/observer/show_observer_count'

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/zetacore/observer/show_observer_count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/zetacore/observer/show_observer_count')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/zetacore/observer/show_observer_count')
data = response.json()

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/zetacore/observer/show_observer_count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://zetachain.nownodes.io/zeta-chain/zetacore/observer/show_observer_count";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://zetachain.nownodes.io/zeta-chain/zetacore/observer/show_observer_count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://zetachain.nownodes.io/zeta-chain/zetacore/observer/show_observer_count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zetachain.nownodes.io/zeta-chain/zetacore/observer/show_observer_count')
request = Net::HTTP::Get.new(uri)

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

{
  "last_observer_count": {
    "count": "string",
    "last_change_height": "string"
  }
}

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Documentation

How to migrate to NOWNodes

Authentication

MAINNET / API Referense

Authority

Authorizations

Response

Crosschain

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

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Response

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Response

Emissions

Authorizations

Response

Authorizations

Response

Authorizations

Response