Axelar API - Deprecated Methods

v1.5.3

Base URL

https://axelar.nownodes.ioAxelar API (API Changelog 1.4.10 to 1.5.3)

API Changelog 1.4.10 to 1.5.3 - Axelar API deprecated methods. These methods were available in version 1.4.10 and are no longer served in version 1.5.3. Each method is documented in full, in the format of the 1.4.10 API reference.

API Changelog 1.4.10 to 1.5.3 / Deprecated methods

MsgService

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

chainobject

Show child attributes

namestring

supports_foreign_assetsboolean

key_typestringKEY_TYPE_UNSPECIFIEDKEY_TYPE_NONEKEY_TYPE_THRESHOLDKEY_TYPE_MULTISIGKEY_TYPE_UNSPECIFIED

modulestring

addr_prefixstring

native_assetsArray<object>

Show child attributes

denomstring

min_amountstring<byte>

cosmos_chainstring

ibc_pathstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/add_cosmos_based_chain

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

chainstring

contract_addressstring

payloadstring<byte>

feeobject

Show child attributes

amountobject

Show child attributes

denomstring

amountstring

recipientstring<byte>

refund_recipientstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/call_contract

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

deposit_addressstring<byte>

denomstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/confirm_deposit

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/execute_pending_transfers

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

{
  "sender": "dGVzdA=="
}

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

recipient_addrstring

recipient_chainstring

assetstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/link

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{
  "deposit_addr": "string"
}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

chainstring

assetobject

Show child attributes

denomstring

min_amountstring<byte>

limitstring<byte>

windowstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/register_asset

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

fee_collectorstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/register_fee_collector

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

chainstring

idstring<uint64>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/retry_ibc_transfer

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/route_ibc_transfers

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

{
  "sender": "dGVzdA=="
}

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

idstring

payloadstring<byte>

feegranterstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/axelarnet/route_message

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

namestring

key_typestringKEY_TYPE_UNSPECIFIEDKEY_TYPE_NONEKEY_TYPE_THRESHOLDKEY_TYPE_MULTISIGKEY_TYPE_UNSPECIFIED

paramsstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/add_chain

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

tx_idstring<byte>

amountstring<byte>

burner_addressstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/confirm_deposit

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

Deprecated: use ConfirmGatewayTxs instead

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

tx_idstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

Deprecated: use ConfirmGatewayTxs instead

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

tx_idsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/confirm_gateway_txs

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

tx_idstring<byte>

assetobject

Show child attributes

chainstring

namestring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/confirm_token

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

tx_idstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/confirm_transfer_key

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/create_burn_tokens

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

assetobject

Show child attributes

chainstring

namestring

token_detailsobject

Show child attributes

token_namestring

symbolstring

decimalsinteger<uint32>

capacitystring<byte>

addressstring<byte>

daily_mint_limitstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/create_deploy_token

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/create_pending_transfers

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

key_idstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/create_transfer_operatorship

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

recipient_addrstring

assetstring

recipient_chainstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/link

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{
  "deposit_addr": "string"
}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

event_idstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/retry-failed-event

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

addressstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/set_gateway

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

chainstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/evm/sign_commands

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

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

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the multisig module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

chainstring

key_idstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/rotate_key

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the multisig module exposes only a reduced set of endpoints.

Body

*/*

senderstring

key_idstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/start_keygen

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the multisig module exposes only a reduced set of endpoints.

Body

*/*

senderstring

key_idstring

pub_keystring<byte>

signaturestring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/submit_pub_key

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the multisig module exposes only a reduced set of endpoints.

Body

*/*

senderstring

sig_idstring<uint64>

signaturestring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/submit_signature

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the multisig module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/v1beta1/keygen_opt_in

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

{
  "sender": "dGVzdA=="
}

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the multisig module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/multisig/v1beta1/keygen_opt_out

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

{
  "sender": "dGVzdA=="
}

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the nexus module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

chainsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/activate_chain

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the nexus module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

chainsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/deactivate_chain

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the nexus module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

chainsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/deregister_chain_maintainer

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the nexus module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

fee_infoobject

Show child attributes

chainstring

assetstring

fee_ratestring<byte>

min_feestring<byte>

max_feestring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/register_asset_fee

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the nexus module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

chainsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/register_chain_maintainer

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the nexus module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

chainstring

limitobject

Show child attributes

denomstring

amountstring

windowstring

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/nexus/set_transfer_rate_limit

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the reward module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

inner_messageobject

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/reward/refund_message

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

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

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

DeactivateProxy defines a method for deregistering a proxy account.

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the snapshot module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

DeactivateProxy defines a method for deregistering a proxy account.

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

{
  "sender": "dGVzdA=="
}

{}

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

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the snapshot module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

proxy_addrstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

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

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire tss module was removed from the API in version 1.5.3.

Body

*/*

senderstring<byte>

key_idsArray<string>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/tss/heartbeat

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{}

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

POST

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the vote module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

poll_idstring<uint64>

voteobject

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/vote/vote

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

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

Request Body

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

{
  "log": "string"
}

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

QueryService

PendingIBCTransferCount queries the pending ibc transfers for all chains

GET

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the axelarnet module exposes only a reduced set of endpoints.

Response

200OK

A successful response.

default

An unexpected error response

PendingIBCTransferCount queries the pending ibc transfers for all chains

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/v1beta1/ibc_transfer_count')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/axelarnet/v1beta1/ibc_transfer_count')
request = Net::HTTP::Get.new(uri)

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

{
  "transfers_by_chain": {}
}

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

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

GET

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringrequiredpath

idstringrequiredpath

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

Response

200OK

A successful response.

default

An unexpected error response

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

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/batched_commands/{chain}/{id}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/batched_commands/{chain}/{id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/batched_commands/{chain}/{id}')
request = Net::HTTP::Get.new(uri)

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

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

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

BurnerInfo queries the burner info for the specified address

GET

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

addressstring<byte>query

Response

200OK

A successful response.

default

An unexpected error response

BurnerInfo queries the burner info for the specified address

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/burner_info')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/burner_info')
request = Net::HTTP::Get.new(uri)

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

{
  "chain": "string",
  "burner_info": {
    "burner_address": "dGVzdA==",
    "token_address": "dGVzdA==",
    "destination_chain": "string",
    "symbol": "string",
    "asset": "string",
    "salt": "dGVzdA=="
  }
}

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

Bytecode queries the bytecode of a specified gateway at the specified chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/bytecode/{chain}/{contract}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringrequiredpath

contractstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

Bytecode queries the bytecode of a specified gateway at the specified chain

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/bytecode/{chain}/{contract}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/bytecode/{chain}/{contract}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/bytecode/{chain}/{contract}')
request = Net::HTTP::Get.new(uri)

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

{
  "bytecode": "string"
}

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

Chains queries the available evm chains

GET

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

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

statusstringCHAIN_STATUS_UNSPECIFIEDCHAIN_STATUS_ACTIVATEDCHAIN_STATUS_DEACTIVATEDCHAIN_STATUS_UNSPECIFIEDquery

Response

200OK

A successful response.

default

An unexpected error response

Chains queries the available evm chains

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/chains')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/chains')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/chains')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "chains": [
    "string"
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Command queries the command of a chain provided the command id

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/command_request

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringquery

idstringquery

Response

200OK

A successful response.

default

An unexpected error response

Command queries the command of a chain provided the command id

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/command_request'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/command_request', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/command_request')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/command_request')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/command_request', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/command_request";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/command_request', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/command_request')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/command_request')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "id": "string",
  "type": "string",
  "params": {},
  "key_id": "string",
  "max_gas_cost": 0
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ConfirmationHeight queries the confirmation height for the specified chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{chain}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

ConfirmationHeight queries the confirmation height for the specified chain

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{chain}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/confirmation_height/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "height": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DepositState queries the state of the specified deposit

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringquery

paramsobjectquery

Response

200OK

A successful response.

default

An unexpected error response

DepositState queries the state of the specified deposit

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/deposit_state')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "status": "DEPOSIT_STATUS_UNSPECIFIED"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ERC20Tokens queries the ERC20 tokens registered for a chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringrequiredpath

typestringTOKEN_TYPE_UNSPECIFIEDTOKEN_TYPE_INTERNALTOKEN_TYPE_EXTERNALTOKEN_TYPE_UNSPECIFIEDquery

Response

200OK

A successful response.

default

An unexpected error response

ERC20Tokens queries the ERC20 tokens registered for a chain

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/erc20_tokens/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "tokens": [
    {
      "asset": "string",
      "symbol": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Event queries an event at the specified chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringrequiredpath

event_idstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

Event queries an event at the specified chain

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/event/{chain}/{event_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "event": {
    "chain": "string",
    "tx_id": "dGVzdA==",
    "index": "string",
    "status": "STATUS_UNSPECIFIED",
    "token_sent": {
      "sender": "dGVzdA==",
      "destination_chain": "string",
      "destination_address": "string",
      "symbol": "string",
      "amount": "dGVzdA=="
    },
    "contract_call": {
      "sender": "dGVzdA==",
      "destination_chain": "string",
      "contract_address": "string",
      "payload_hash": "dGVzdA=="
    },
    "contract_call_with_token": {
      "sender": "dGVzdA==",
      "destination_chain": "string",
      "contract_address": "string",
      "payload_hash": "dGVzdA==",
      "symbol": "string",
      "amount": "dGVzdA=="
    },
    "transfer": {
      "to": "dGVzdA==",
      "amount": "dGVzdA=="
    },
    "token_deployed": {
      "symbol": "string",
      "token_address": "dGVzdA=="
    },
    "multisig_ownership_transferred": {
      "pre_owners": [
        "dGVzdA=="
      ],
      "prev_threshold": "dGVzdA==",
      "new_owners": [
        "dGVzdA=="
      ],
      "new_threshold": "dGVzdA=="
    },
    "multisig_operatorship_transferred": {
      "new_operators": [
        "dGVzdA=="
      ],
      "new_threshold": "dGVzdA==",
      "new_weights": [
        "dGVzdA=="
      ]
    }
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GatewayAddress queries the address of axelar gateway at the specified chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{chain}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

GatewayAddress queries the address of axelar gateway at the specified chain

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{chain}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/gateway_address/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "address": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

KeyAddress queries the address of key of a chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringrequiredpath

key_idstringquery

Response

200OK

A successful response.

default

An unexpected error response

KeyAddress queries the address of key of a chain

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/key_address/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "key_id": "string",
  "addresses": [
    {
      "address": "string",
      "weight": "string"
    }
  ],
  "threshold": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/params/{chain}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/evm/v1beta1/params/{chain}

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/params/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/params/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/params/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/params/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/params/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/params/{chain}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/params/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/params/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/params/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "params": {
    "chain": "string",
    "confirmation_height": "string",
    "network": "string",
    "token_code": "dGVzdA==",
    "burnable": "dGVzdA==",
    "revote_locking_period": "string",
    "networks": [
      {
        "name": "string",
        "id": "dGVzdA=="
      }
    ],
    "voting_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "min_voter_count": "string",
    "commands_gas_limit": 0,
    "voting_grace_period": "string",
    "end_blocker_limit": "string",
    "transfer_limit": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

PendingCommands queries the pending commands for the specified chain

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{chain}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

PendingCommands queries the pending commands for the specified chain

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{chain}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/pending_commands/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "commands": [
    {
      "id": "string",
      "type": "string",
      "params": {},
      "key_id": "string",
      "max_gas_cost": 0
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

TokenInfo queries the token info for a registered ERC20 Token

GET

https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire evm module was removed from the API in version 1.5.3.

Parameters

chainstringrequiredpath

assetstringquery

symbolstringquery

addressstringquery

Response

200OK

A successful response.

default

An unexpected error response

TokenInfo queries the token info for a registered ERC20 Token

curl -X GET 'https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/evm/v1beta1/token_info/{chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "asset": "string",
  "details": {
    "token_name": "string",
    "symbol": "string",
    "decimals": 0,
    "capacity": "dGVzdA=="
  },
  "address": "string",
  "confirmed": true,
  "is_external": true,
  "burner_code_hash": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

LatestDepositAddress queries the a deposit address by recipient

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the nexus module exposes only a reduced set of endpoints.

Parameters

recipient_addrstringrequiredpath

recipient_chainstringrequiredpath

deposit_chainstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

LatestDepositAddress queries the a deposit address by recipient

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/latest_deposit_address/{recipient_addr}/{recipient_chain}/{deposit_chain}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "deposit_addr": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

RecipientAddress queries the recipient address for a given deposit address

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the nexus module exposes only a reduced set of endpoints.

Parameters

deposit_chainstringrequiredpath

deposit_addrstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

RecipientAddress queries the recipient address for a given deposit address

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/recipient_address/{deposit_chain}/{deposit_addr}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "recipient_addr": "string",
  "recipient_chain": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

TransferRateLimit queries the transfer rate limit for a given chain and asset. If a rate limit is not set, nil is returned.

GET

https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{chain}/{asset}

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the nexus module exposes only a reduced set of endpoints.

Parameters

chainstringrequiredpath

assetstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response

TransferRateLimit queries the transfer rate limit for a given chain and asset. If a rate limit is not set, nil is returned.

curl -X GET 'https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{chain}/{asset}'

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{chain}/{asset}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{chain}/{asset}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{chain}/{asset}')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{chain}/{asset}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{chain}/{asset}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{chain}/{asset}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{chain}/{asset}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/nexus/v1beta1/transfer_rate_limit/{chain}/{asset}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "transfer_rate_limit": {
    "limit": "dGVzdA==",
    "window": "string",
    "incoming": "dGVzdA==",
    "outgoing": "dGVzdA==",
    "time_left": "string",
    "from": "dGVzdA==",
    "to": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://axelar.nownodes.io/axelar/tss/v1beta1/params

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). The entire tss module was removed from the API in version 1.5.3.

Response

200OK

A successful response.

default

An unexpected error response

GET /axelar/tss/v1beta1/params

curl -X GET 'https://axelar.nownodes.io/axelar/tss/v1beta1/params'

const response = await fetch('https://axelar.nownodes.io/axelar/tss/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/tss/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://axelar.nownodes.io/axelar/tss/v1beta1/params')
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/tss/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/tss/v1beta1/params";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/tss/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://axelar.nownodes.io/axelar/tss/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/tss/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "params": {
    "key_requirements": [
      {
        "key_role": "KEY_ROLE_UNSPECIFIED",
        "key_type": "KEY_TYPE_UNSPECIFIED",
        "min_keygen_threshold": {
          "numerator": "string",
          "denominator": "string"
        },
        "safety_threshold": {
          "numerator": "string",
          "denominator": "string"
        },
        "key_share_distribution_policy": "KEY_SHARE_DISTRIBUTION_POLICY_UNSPECIFIED",
        "max_total_share_count": "string",
        "min_total_share_count": "string",
        "keygen_voting_threshold": {
          "numerator": "string",
          "denominator": "string"
        },
        "sign_voting_threshold": {
          "numerator": "string",
          "denominator": "string"
        },
        "keygen_timeout": "string",
        "sign_timeout": "string"
      }
    ],
    "suspend_duration_in_blocks": "string",
    "heartbeat_period_in_blocks": "string",
    "max_missed_blocks_per_window": {
      "numerator": "string",
      "denominator": "string"
    },
    "unbonding_locking_key_rotation_count": "string",
    "external_multisig_threshold": {
      "numerator": "string",
      "denominator": "string"
    },
    "max_sign_queue_size": "string",
    "max_simultaneous_sign_shares": "string",
    "tss_signed_blocks_window": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Msg

POST

https://axelar.nownodes.io/axelar/permission/deregister_controller

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the permission module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

controllerstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/permission/deregister_controller

curl -X POST 'https://axelar.nownodes.io/axelar/permission/deregister_controller' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/permission/deregister_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/deregister_controller')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/permission/deregister_controller', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/permission/deregister_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/permission/deregister_controller";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "*/*",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/permission/deregister_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/permission/deregister_controller', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/deregister_controller')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

{}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

POST

https://axelar.nownodes.io/axelar/permission/register_controller

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the permission module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

controllerstring<byte>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/permission/register_controller

curl -X POST 'https://axelar.nownodes.io/axelar/permission/register_controller' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/permission/register_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/register_controller')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/permission/register_controller', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/permission/register_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/permission/register_controller";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "*/*",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/permission/register_controller', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "controller": "dGVzdA=="
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

response = requests.post('https://axelar.nownodes.io/axelar/permission/register_controller', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/register_controller')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "controller": "dGVzdA=="
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "sender": "dGVzdA==",
  "controller": "dGVzdA=="
}

{}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

POST

https://axelar.nownodes.io/axelar/permission/update_governance_key

This method is no longer available in the Axelar API as of version 1.5.3 (it was available in version 1.4.10). In version 1.5.3 the permission module exposes only a reduced set of endpoints.

Body

*/*

senderstring<byte>

governance_keyobject

Show child attributes

thresholdinteger<uint32>

public_keysArray<object>

Response

200OK

A successful response.

default

An unexpected error response

POST /axelar/permission/update_governance_key

curl -X POST 'https://axelar.nownodes.io/axelar/permission/update_governance_key' \
  -H 'Content-Type: */*' \
  -d '{
    "sender": "dGVzdA==",
    "governance_key": {
      "threshold": 0,
      "public_keys": [
        {}
      ]
    }
  }'

const response = await fetch('https://axelar.nownodes.io/axelar/permission/update_governance_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "governance_key": {
        "threshold": 0,
        "public_keys": [
          {}
        ]
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/update_governance_key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "governance_key": {
      "threshold": 0,
      "public_keys": [
        {}
      ]
    }
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "sender": "dGVzdA==",
  "governance_key": {
    "threshold": 0,
    "public_keys": [
      {}
    ]
  }
}

response = requests.post('https://axelar.nownodes.io/axelar/permission/update_governance_key', json=payload)
data = response.json()

const response = await fetch('https://axelar.nownodes.io/axelar/permission/update_governance_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "governance_key": {
        "threshold": 0,
        "public_keys": [
          {}
        ]
      }
    }),
});

const data = await response.json();

const endpoint = "https://axelar.nownodes.io/axelar/permission/update_governance_key";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "*/*",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "sender": "dGVzdA==",
    "governance_key": {
      "threshold": 0,
      "public_keys": [
        {}
      ]
    }
  });
console.log(result);

const response = await fetch('https://axelar.nownodes.io/axelar/permission/update_governance_key', {
  method: 'POST',
  headers: {
    'Content-Type': '*/*',
  },
  body: JSON.stringify({
      "sender": "dGVzdA==",
      "governance_key": {
        "threshold": 0,
        "public_keys": [
          {}
        ]
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "dGVzdA==",
  "governance_key": {
    "threshold": 0,
    "public_keys": [
      {}
    ]
  }
}

response = requests.post('https://axelar.nownodes.io/axelar/permission/update_governance_key', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://axelar.nownodes.io/axelar/permission/update_governance_key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = '*/*'
request.body = '{
    "sender": "dGVzdA==",
    "governance_key": {
      "threshold": 0,
      "public_keys": [
        {}
      ]
    }
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "sender": "dGVzdA==",
  "governance_key": {
    "threshold": 0,
    "public_keys": [
      {}
    ]
  }
}

{}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Documentation

How to migrate to NOWNodes

API Changelog 1.4.10 to 1.5.3 / Deprecated methods

MsgService

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response

Body

Response