Introduction to Ardor API
Welcome to the Ardor Blockchain-as-a-Service platform API reference documentation. This documentation is intended for developers from all horizons who want to explore with Ardor platform, build Decentrealized Applications (Dapps), leverage and integrate their own solutions to a public blockchain with huge flexibility like Ardor.
All the interactions with Ardor blockchain are done using HTTP requests and the responses are delivered as JSON objects. Thus, Ardor API can be used universally with any langage of your choice. In the what follows, shell and Javascript langages will be used to demonstrate the usage of the API, but other sdks are in development.
If you want to interactivally test the API with more recent blockchain data, we recommend you to:
- Download the Ardor wallet here
- Follow the installation instructions
- Launch the Ardor wallet (can be found as Ardor Server too on Windows) and wait for the wallet to sync
- Go to http://localhost:27876/test
- Scroll to the call you want to test, set the call parameters and explore the results on the side.
We provide you here with some general notes when using the API, before going in detail with the description of each available call.
When using the API, you may encounter in many places the usage of nxt either in the calls or in parameters and this is due to the fact that Ardor blockchain is an evolution of the Nxt blockchain that resulted in the creation of a new blockchain because of architecture changes introducing the Parent-ChildChain designed for high scalability. Nevertheless, many parts of the Nxt code source are shared between Nxt and Ardor and when you communicate with an Ardor server (using the API calls) then you can be ensured that all your interactions are with Ardor system and not Nxt system.
Javascript API testing
testArdor.js content:
var config = {
"comment": "Node JS module configuration file",
"url": "http://localhost:27876",
"secretPhrase": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
"recipientPublicKey": "5b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c27",
"isTestNet": true,
"chain": "2",
"adminPassword": ""
};
// Importing the package
ardor = require("ardor-blockchain");
// Initializing the object with meta parameters
ardor.init(config);
ardor.load(function(NRS) {
// Request data
var data = {
account : "ARDOR-HWZW-5TT6-U68F-H26L8"
};
// Request query and response
NRS.sendRequest("getAccountProperties", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
Api response in console:
/usr/local/bin/node --inspect-brk=28964 testArdor.js
Debugger listening on ws://127.0.0.1:28964/b0cd1c8b-bbbe-4105-b43d-28b228e6ccef
Debugger attached.
Test finished
testArdor.js:29
Started
nrs.node.bridge.js:45
done loading server constants
nrs.constants.js:139
2018-08-16T06:46:32.731Z Send request getAccountPublicKey to url https://testardor.jelurida.com/nxt?requestType=getAccountPublicKey id=0
nrs.console.js:39
2018-08-16T06:46:32.931Z {"publicKey":"5b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c27","requestProcessingTime":0}
As stated before, you can call the Ardor API both from shell and Javascript, we provide here we a simple demonstration of how you can achieve your testing in javascript.
- Download the Ardor wallet from official ardor website, then follow the installation instructions and please chose TestNet for your first tests
- Create an empty project:
mkdir test-ardor-blockchain | cd test-ardor-blockchain - Install the package for this project:
npm install --save <ArdorInstallationFolder>/html/www/js/ - Create a simple js in the
test-ardor-blockchainfolder and paste the javascript code on it - Start your Ardor node in order to execute the calls locally, otherwise you have to change the url in the js script to point the remote node
- Run you script and you will get the desired response.
Flexible Account IDs
All API requests that require an account ID accept either an account number or the corresponding Reed-Solomon address (ARDR-XXXX-XXXX-XXXX-XXXXX).
Creating Unsigned Transactions
All API requests that create a new transaction will accept either a secretPhrase or a publicKey parameter:
- If secretPhrase is supplied, a transaction is created, signed at the server, and broadcast by the server as usual.
- If only a publicKey parameter is supplied as a 64-digit (32-byte) hex string, the transaction will be prepared by the server and returned in the JSON response as transactionJSON without a signature. This JSON object along with secretPhrase can then be supplied to Sign Transaction as unsignedTransactionJSON and the resulting signed transactionJSON can then be supplied to Broadcast Transaction. This sequence allows for:
- Offline signing of transactions so that secretPhrase never needs to be exposed and increases security of account holdings
- Voucher requests where a merchant can build the payment request and costumer signing it on his own device
- unsignedTransactionBytes may be used instead of unsigned transactionJSON when there is no encrypted message. Messages to be encrypted require the secretPhrase for encryption and so cannot be included in unsignedTransactionBytes.
Escrow Operations
All API requests that create a new transaction will accept an optional referencedTransactionFullHash parameter which creates a chained transaction, meaning that the new transaction cannot be confirmed unless the referenced transaction is also confirmed. This feature allows a simple way of transaction escrow:
- Alice prepares and signs a transaction A, but doesn't broadcast it by setting the broadcast parameter to false. She sends to Bob the unsignedTransactionBytes, the fullHash of the transaction, and the signatureHash. All of those are included in the JSON returned by the API request.
Warning: Make sure not to send the signed transactionBytes, or the signature itself, as then Bob can just broadcast transaction A himself.
- Bob prepares, signs and broadcasts transaction B, setting the referencedTransactionFullHash parameter to the fullHash of A provided by Alice. He can verify that this hash indeed belongs to the transaction he expects from Alice, by using Calculate Full Hash, which takes unsignedTransactionByte*s and *signatureHash (both of which Alice has also sent to Bob). He can also use Parse Transaction to decode the unsigned bytes and inspect all transaction fields.
- Transaction B is accepted in the unconfirmed transaction pool, but as long as A is still missing, B will not be confirmed, i.e. will not be included in the blockchain. If A is never submitted, B will eventually expire -- so Bob should make sure to set a long enough deadline, such as the maximum of 32767 minutes(~23 days).
- Once in the unconfirmed transactions pool, Bob has no way of recalling B back. So now Alice can safely submit her transaction A, by just broadcasting the signedTransactionBytes she got in the first step. Transaction A will get included in the blockchain first, and in the next block Bob's transaction B will also be included.
Note that while the above scheme is good enough for a simple escrow, the blockchain does not enforce that if A is included, B will also be included. It may happen due to forks and blockchain reorganization, that B never gets a chance to be included and expires unconfirmed, while A still remains in the blockchain. However, it is not practically possible for Bob to intentionally cause such chain of events and to prevent B from being confirmed.
Prunable Data
Prunable data can be removed from the blockchain without affecting the integrity of the blockchain. When a transaction containing prunable data is created, only the 32-byte sha256 hash of the prunable data is included in the transactionBytes, not the prunable data itself. The non-prunable signed transactionBytes are used to verify the signature and to generate the transaction's fullHash and ID; when the prunable part of the transaction is removed at a later time, none of these operations are affected.
Prunable data has a predetermined minimum lifetime of two weeks (24 hours on the Testnet) from the timestamp of the transaction. Transactions and blocks received from peer nodes are not accepted if prunable data is missing before this time has elapsed. After this time has elapsed, prunable data is no longer included with transactions and blocks transmitted to peer nodes, and is no longer included in the transaction JSON returned by general-purpose API calls such as Get Transaction; the only way to retrieve it, if still available, is through special-purpose API calls such as Get Prunable Message.
Expired prunable data remains stored in the blockchain until removed at the same time derived tables are trimmed, which occurs automatically every 1000 blocks by default. Use Trim Derived Tables to remove expired prunable data immediately.
Prunable data can be preserved on a node beyond the predetermined minimum lifetime by setting the nxt.maxPrunableLifetime property to a larger value than two weeks or to -1 to preserve it indefinitely. To force the node to include such preserved prunable data when transactions and blocks are transmitted to peer nodes, set the nxt.includeExpiredPrunables property to true, thus making it an archival node.
Currently, there are two varieties of prunable data in the Ardor system: prunable Arbitrary Messages and Tagged Data. Both varities have a maximum prunable data length of 42 kilobytes
Properties Files
The behavior of some API calls is affected by property settings loaded from files in the <WorkingDirectory>/ardor/conf directory during Ardor server intialization. This directory contains the nxt-default.properties and logging-default.properties files, both of which contain default property settings along with documentation. A few of the property settings can be obtained while the server is running through the Get Blockchain Status and Get State calls.
It is recommended not to modify default properties files because they can be overwritten during software updates. Instead, properties in the default files can be overridden by including them in optional nxt.properties and logging.properties files in the same directory. For example, a nxt.properties file can be created with the contents:
nxt.isTestnet=true
This causes the Nxt server to connect to the Testnet instead of the Mainnet.
Admin Password
Some API functions take an adminPassword parameter, which must match the nxt.adminPassword property unless the nxt.disableAdminPassword property is set to true or the API server only listens on the localhost interface (when the nxt.apiServerHost property is set to 127.0.0.1).
All Debug Operations require adminPassword since they require some kind of privilege. On some functions adminPassword is used so you can override maximum allowed value for lastIndex parameter, which is set to 100 by default by the nxt.maxAPIRecords property. Giving you the option to retrieve more than 100 objects per request.
Roaming and Light Client Modes
The remote node to use when in roaming and light client modes is selected randomly, but can be changed manually in the UI, or using the new set API Proxy Peer API, or forced to a specific peer using the nxt.forceAPIProxyServerURL property.
Remote nodes can be blacklisted from the UI, or using the Blacklist API Proxy Peer API. This blacklisting is independent from peer blacklisting. The API proxy blacklisting period can be set using the nxt.apiProxyBlacklistingPeriod property (default 1800000 milliseconds).
API requests that require sending the secret phrase, shared key, or admin password to the server, for features like forging, shuffling, or running a funding monitor, are disabled when in roaming or light client mode.
Accounts
This chapter focuses on all API calls that can help you interact with an account, identify its information and many other actions including: sending Ardor to an account, getting his balances, or more advanced interactions like properties and control features.
Account Information
The set of API calls bellow allow you to request many informations about an account. These are general information about the blocks generated by an account or all currencies and assets created by this account. Historical trades and balances are given in their corresponding sections below.
GetAccountId
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "publicKey=f3831afb0cfbaca8e9fca6523d0b23d14aa2e6f9ac1726f12c30acd4d622bb0a" "http://localhost:27876/nxt?requestType=getAccountId"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
publicKey: "f3831afb0cfbaca8e9fca6523d0b23d14aa2e6f9ac1726f12c30acd4d622bb0a"
};
NRS.sendRequest("getAccountId", data, function (response) {
NRS.logConsole("Account id is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"accountRS": "ARDOR-8MVA-XCVR-3JC9-2C7C3",
"publicKey": "f3831afb0cfbaca8e9fca6523d0b23d14aa2e6f9ac1726f12c30acd4d622bb0a",
"requestProcessingTime": 1,
"account": "47475721164246888"
}
Get an account ID given a secret passphrase or public key.
POST http://localhost:27876/nxt?requestType=getAccountId&publicKey=<PublicKEY>
| Parameter | Type | Description |
|---|---|---|
| secretPhrase | string | Secret phrase of the account. Optional |
| publicKey | string | Public key of the account. Mandatory if secretPhrase is not set. |
GetAccountPublicKey
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-8MVA-XCVR-3JC9-2C7C3" "http://localhost:27876/nxt?requestType=getAccountPublicKey"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-8MVA-XCVR-3JC9-2C7C3"
};
NRS.sendRequest("getAccountPublicKey", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"publicKey": "f3831afb0cfbaca8e9fca6523d0b23d14aa2e6f9ac1726f12c30acd4d622bb0a",
"requestProcessingTime": 0
}
Get the public key associated with an account ID
POST http://localhost:27876/nxt?requestType=getAccountPublicKey&account=<AccountID>
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountLedger
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-XK2L-Z7NK-VNKM-AZYVT" "http://localhost:27876/nxt?requestType=getAccountLedger"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-XK2L-Z7NK-VNKM-AZYVT"
};
NRS.sendRequest("getAccountLedger", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"entries": [
{
"holdingTypeIsUnconfirmed": true,
"chain": 2,
"change": "150000000000",
"holdingTypeCode": 1,
"eventType": "ORDINARY_PAYMENT",
"ledgerId": "119534",
"eventHash": "f49a6b4b8450b0cd4c9454be9c4540318acccf5927895bdf5b5eaa8622e5d435",
"holding": "2",
"isTransactionEvent": true,
"balance": "1399418754307",
"holdingType": "UNCONFIRMED_COIN_BALANCE",
"accountRS": "ARDOR-XK2L-Z7NK-VNKM-AZYVT",
"block": "7794716992135705008",
"event": "14821434902807550708",
"account": "10155581947047232530",
"height": 291612,
"timestamp": 17312462
}
],
"requestProcessingTime": 1
}
The GetAccountLedger API will return entries from the account ledger. The account ledger tracks all account changes as determined by the nxt.ledgerAccounts, nxt.ledgerLogUnconfirmed and nxt.ledgerTrimKeep properties.
POST http://localhost:27876/nxt?requestType=getAccountLedger&account=<Account>...
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| event | number | Event ID. |
| eventType | string | A string representing the event type. |
| holdingType | number | A number representing the holding type (0 for Coin, 1 for Asset, 2 for Currency). |
| holding | number | Holding ID. |
| includeTransactions | boolean | Specify TRUE to include the transaction associated with the ledger entry. The default is false. |
| includeHoldingInfo | boolean | Specify TRUE to include the corresponding asset or currency info (name, decimals) with each ledger entry. The default is false. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountLedgerEntry
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "ledgerId=119533" "http://localhost:27876/nxt?requestType=getAccountLedgerEntry"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
ledgerId : "119533"
};
NRS.sendRequest("getAccountLedgerEntry", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"holdingTypeIsUnconfirmed": true,
"chain": 1,
"change": "250000",
"holdingTypeCode": 1,
"eventType": "BLOCK_GENERATED",
"requestProcessingTime": 0,
"ledgerId": "119533",
"holding": "1",
"isTransactionEvent": false,
"balance": "4000397523847250",
"holdingType": "UNCONFIRMED_COIN_BALANCE",
"accountRS": "ARDOR-8ZW9-BEW7-8QHM-2F67L",
"block": "7794716992135705008",
"event": "7794716992135705008",
"account": "654303200082624391",
"height": 291612,
"timestamp": 17312462
}
The GetAccountLedgerEntry API will return an entry from the account ledger. The account ledger tracks all account changes as determined by the nxt.ledgerAccounts, nxt.ledgerLogUnconfirmed and nxt.ledgerTrimKeep properties.
POST http://localhost:27876/nxt?requestType=getAccountLedgerEntry&account=<LedgerId>&...
| Parameter | Type | Description |
|---|---|---|
| ledgerId | number | Ledger entry identifier. |
| includeTransaction | boolean | Specify TRUE to include the transaction associated with the ledger entry. The default is false. |
| includeHoldingInfo | boolean | Specify TRUE to include the corresponding asset or currency info (name, decimals) with each ledger entry. The default is false. |
GetAccountAssetCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-APM5-TLV8-J3KY-6T3JG" "http://localhost:27876/nxt?requestType=getAccountAssetCount"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-APM5-TLV8-J3KY-6T3JG"
};
NRS.sendRequest("getAccountAssetCount", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"requestProcessingTime": 0,
"numberOfAssets": 1
}
Get the number of assets owned by an account given the account ID.
POST http://localhost:27876/nxt?requestType=getAccountAssetCount&account=<Account>&...
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| height | number | Blockchain height at which to retrieve data. Default is most recent block. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountAssets
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-APM5-TLV8-J3KY-6T3JG&includeAssetInfo=true" "http://localhost:27876/nxt?requestType=getAccountAssets"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-APM5-TLV8-J3KY-6T3JG",
includeAssetInfo : "true"
};
NRS.sendRequest("getAccountAssets", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"accountAssets": [
{
"quantityQNT": "50000000",
"unconfirmedQuantityQNT": "45000000",
"decimals": 2,
"name": "PeterTest",
"asset": "10260918643336798387"
}
],
"requestProcessingTime": 0
}
Get the assets owned by a given account in reverse quantity order.
POST http://localhost:27876/nxt?requestType=getAccountAssets&account=<Account>
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| asset | number | Asset ID. |
| height | number | Blockchain height at which to retrieve data. Default is most recent block. |
| includeAssetInfo | boolean | true if asset information is to be included. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountBlockCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-58JH-YGLD-DG25-CRVXC" "http://localhost:27876/nxt?requestType=getAccountBlockCount"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-58JH-YGLD-DG25-CRVXC"
};
NRS.sendRequest("getAccountBlockCount", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"numberOfBlocks": 39820,
"requestProcessingTime": 19
}
Get the number of blocks forged by an account.
POST http://localhost:27876/nxt?requestType=getAccountBlockCount&account=<Account>
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountBlockIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-58JH-YGLD-DG25-CRVXC" "http://localhost:27876/nxt?requestType=getAccountBlockIds"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-58JH-YGLD-DG25-CRVXC"
};
NRS.sendRequest("getAccountBlockIds", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"blockIds": [
"7409020034992101127",
"13666155946130133077",
"4975664708626217006",
"2199995861210647044",
"6521768284282833921",
"5504690544075001287",
"8762183737529636830",
"15988735212005877218",
"17493377939700851941",
"12852214148045438169",
"10731698312306022748",
"15713302678722688366",
...
]
}
Get the block IDs of all blocks forged (generated) by an account in reverse block height order,
POST http://localhost:27876/nxt?requestType=getAccountBlockIds&account<Account>
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| timestamp | number | Earliest block (in seconds since the genesis block) to retrieve. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountBlocks
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-58JH-YGLD-DG25-CRVXC" "http://localhost:27876/nxt?requestType=getAccountBlocks"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-58JH-YGLD-DG25-CRVXC"
};
NRS.sendRequest("getAccountBlocks", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"blocks": [
{
"previousBlockHash": "442815b217f5968e9aff697124306d0c46d3f54a16e6202790673f7f0e4d3397",
"generationSignature": "093adf3623af440118ce29a06412e731418538fae717366a1cc9591967cb13f8",
"generator": "11923130426810538511",
"generatorPublicKey": "bfbce25fe31e375c1784ef932cdd9daf8f4635e25092ea4cb60d15e220d06a1d",
"baseTarget": "875595407",
"payloadHash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
"generatorRS": "ARDOR-58JH-YGLD-DG25-CRVXC",
"nextBlock": "3484461649184375611",
"numberOfTransactions": 0,
"blockSignature": "1e472bfbd0431ea3537a574ad82a77bed533fff5890e09af14b03c8bd182fd0158a8a6702b0c6bf642a08f970b6ee7fb4caa5694d8ebb83f625dd703e5fd4fc6",
"transactions": [],
"version": 3,
"previousBlock": "10274669082013149252",
"cumulativeDifficulty": "32260533261737103",
"totalFeeFQT": "0",
"block": "7409020034992101127",
"height": 315152,
"timestamp": 18717512
},
...
]
}
Get all blocks forged (generated) by an account in reverse block height order.
POST http://localhost:27876/nxt?requestType=getAccountBlocks&account=<Account>
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| timestamp | number | Earliest block (in seconds since the genesis block) to retrieve. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| includeTransactions | boolean | Specify TRUE to include the transaction associated with the ledger entry. The default is false. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountCurrencyCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-VS8T-QYQS-SK9H-5BYBB" "http://localhost:27876/nxt?requestType=getAccountCurrencyCount"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-VS8T-QYQS-SK9H-5BYBB"
};
NRS.sendRequest("getAccountCurrencyCount", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"numberOfCurrencies": 1,
"requestProcessingTime": 0
}
Get the number of currencies issued by a given account.
POST http://localhost:27876/nxt?requestType=getAccountCurrencyCount&account=<Account>
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| height | number | Blockchain height at which to retrieve data. Default is most recent block. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountCurrencies
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-VS8T-QYQS-SK9H-5BYBB&includeCurrencyInfo=true" "http://localhost:27876/nxt?requestType=getAccountCurrencies"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-VS8T-QYQS-SK9H-5BYBB",
includeCurrencyInfo : "true"
};
NRS.sendRequest("getAccountCurrencies", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"accountCurrencies": [
{
"chain": 2,
"issuerAccountRS": "ARDOR-VS8T-QYQS-SK9H-5BYBB",
"unitsQNT": "700000000",
"code": "TPET",
"unconfirmedUnitsQNT": "700000000",
"decimals": 3,
"name": "TestPet",
"currency": "8973592331691074726",
"issuanceHeight": 0,
"type": 35,
"issuerAccount": "3794223001810886873"
}
],
"requestProcessingTime": 0
}
Get the currencies issued by a given account.
POST http://localhost:27876/nxt?requestType=getAccountCurrencies&account=<Account>
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| currency | number | Currency ID. |
| height | number | Blockchain height at which to retrieve data. Default is most recent block. |
| includeCurrencyInfo | boolean | true if several currency information properties is to be included. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountLessors
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-VS8T-QYQS-SK9H-5BYBB" "http://localhost:27876/nxt?requestType=getAccountLessors"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-VS8T-QYQS-SK9H-5BYBB"
};
NRS.sendRequest("getAccountLessors", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"lessors": [],
"accountRS": "ARDOR-VS8T-QYQS-SK9H-5BYBB",
"requestProcessingTime": 0,
"account": "3794223001810886873",
"height": 315183
}
Get the lessors (accounts leasing their forging balance) to an account.
POST http://localhost:27876/nxt?requestType=getAccountLessors&account=<Account>
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| height | number | Blockchain height at which to retrieve data. Default is most recent block. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountPhasedTransactionCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-VS8T-QYQS-SK9H-5BYBB" "http://localhost:27876/nxt?requestType=getAccountPhasedTransactionCount"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-VS8T-QYQS-SK9H-5BYBB"
};
NRS.sendRequest("getAccountPhasedTransactionCount", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"requestProcessingTime": 0,
"numberOfPhasedTransactions": 0
}
Get the number of pending phased transactions associated with an account given the account ID.
POST http://localhost:27876/nxt?requestType=getAccountPhasedTransactionCount&chain=<ChainId>&account=<Account>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| account | number or RS | An account ID. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountPhasedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-VS8T-QYQS-SK9H-5BYBB" "http://localhost:27876/nxt?requestType=getAccountPhasedTransactions"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-VS8T-QYQS-SK9H-5BYBB"
};
NRS.sendRequest("getAccountPhasedTransactions", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"requestProcessingTime": 0,
"transactions": []
}
Get pending phased transactions associated with an account given the account ID in reverse chronological creation order.
POST http://localhost:27876/nxt?requestType=getAccountPhasedTransactions&chain=<ChainId>&account=<Account>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| account | number or RS | An account ID. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetUnconfirmedTransactionIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L8&account=ARDOR-492G-A5YD-FUGZ-C6N2B" "http://localhost:27876/nxt?requestType=getUnconfirmedTransactionIds"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8",
account : "ARDOR-492G-A5YD-FUGZ-C6N2B"
};
NRS.sendRequest("getUnconfirmedTransactionIds", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"requestProcessingTime": 1,
"unconfirmedTransactionIds": [
"7939835860691128054"
]
}
Get a list of unconfirmed transaction IDs associated with an account.
POST http://localhost:27876/nxt?requestType=getUnconfirmedTransactionIds&chain=2&account=<Account1>&account=<Account2>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| account | number or RS | An account ID. First account to monitor. |
| account | number or RS | An account ID. Second account to monitor. |
| account | number or RS | An account ID. Third account to monitor, you can add as many accounts as you want. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetUnconfirmedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L8&account=ARDOR-492G-A5YD-FUGZ-C6N2B" "http://localhost:27876/nxt?requestType=getUnconfirmedTransactions"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8",
account : "ARDOR-492G-A5YD-FUGZ-C6N2B"
};
NRS.sendRequest("getUnconfirmedTransactions", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"unconfirmedTransactions": [
{
"senderPublicKey": "5b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c27",
"isBundled": true,
"chain": 2,
"signature": "c8edc854fe2fba9d1b95fc81b006dffa4b1ab041eeb1d26ef217bbdd14002406d8a4851d15ebc6893de25b1fcee3cca88a400c898153202a6251eb80c3acea5f",
"feeNQT": "10000",
"type": 0,
"fullHash": "1f007e0ee4675228e4b1ff50def20403f46a1d7fb2ec7dc8271b38b8a12bae3d",
"version": 1,
"fxtTransaction": "0",
"phased": false,
"ecBlockId": "2329106975025976796",
"signatureHash": "025c171e9d1d80b4ad5cabc836cb48aed050ed8764dcdec4f0e32f8d2ca050de",
"attachment": {
"version.OrdinaryPayment": 0
},
"senderRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"subtype": 0,
"amountNQT": "500000000",
"sender": "17530402417794348028",
"recipientRS": "ARDOR-492G-A5YD-FUGZ-C6N2B",
"recipient": "11854182583844805646",
"ecBlockHeight": 230000,
"deadline": 15,
"timestamp": 19115098,
"height": 2147483647
}
],
"requestProcessingTime": 0
}
Get a list of unconfirmed transactions associated with an account.
POST http://localhost:27876/nxt?requestType=getUnconfirmedTransactions&chain=2&account=<Account1>&account=<Account2>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| account | number or RS | An account ID. First account to monitor. |
| account | number or RS | An account ID. Second account to monitor. |
| account | number or RS | An account ID. Third account to monitor, you can add as many accounts as you want. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetCurrenciesByIssuer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-63EF-NL2A-WWNC-6JL6N&includeCounts=true" "http://localhost:27876/nxt?requestType=getCurrenciesByIssuer"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-63EF-NL2A-WWNC-6JL6N",
includeCounts : "true"
};
NRS.sendRequest(" getCurrenciesByIssuer", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"requestProcessingTime": 1,
"currencies": [
[
{
"currentReservePerUnitNQT": "0",
"chain": 2,
"types": [
"EXCHANGEABLE",
"MINTABLE"
],
"code": "CDMNT",
"currentSupplyQNT": "1000000000000",
"creationHeight": 309813,
"minDifficulty": 65,
"numberOfTransfers": 0,
"description": "Mintable test currency 27 July 2018",
"minReservePerUnitNQT": "0",
"initialSupplyQNT": "1000000000000",
"issuanceHeight": 0,
"type": 17,
"maxSupplyQNT": "100000000000000",
"maxDifficulty": 250,
"accountRS": "ARDOR-63EF-NL2A-WWNC-6JL6N",
"decimals": 6,
"name": "CDTest1Mnt",
"reserveSupplyQNT": "0",
"currency": "5149676163378732196",
"account": "5337417175848322445",
"algorithm": 2
}
]
]
}
Get currencies issued by one or multiple accounts in reverse creation order.
POST http://localhost:27876/nxt?requestType=getCurrenciesByIssuer&account=<Account>&includeCounts=<TrueFalse>&...
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| account | number or RS | An account ID. |
| account | number or RS | An account ID. |
| includeCounts | boolean | true if number of transfers is to be included. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAssetsByIssuer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-HWZW-5TT6-U68F-H26L8&includeCounts=true" "http://localhost:27876/nxt?requestType=getAssetsByIssuer"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-HWZW-5TT6-U68F-H26L8",
includeCounts : "true"
};
NRS.sendRequest("getAssetsByIssuer", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"assets": [
[
{
"quantityQNT": "1",
"numberOfAccounts": 1,
"accountRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"decimals": 0,
"numberOfTransfers": 2,
"name": "TerrainPar",
"description": "26 Rue Nantes\r\nddsfdsfqsfddsqfqs",
"hasPhasingAssetControl": false,
"asset": "14829545266509418230",
"account": "17530402417794348028"
},
{
"quantityQNT": "10000000000",
"numberOfAccounts": 3,
"accountRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"decimals": 2,
"numberOfTransfers": 7,
"name": "BigUp",
"description": "BigUp project Asset for all kinds of investors and committed peope to BigUp",
"hasPhasingAssetControl": true,
"asset": "779342883283236213",
"account": "17530402417794348028"
}
]
],
"requestProcessingTime": 1
}
Get assets issued by one or multiple accounts in reverse creation order.
POST http://localhost:27876/nxt?requestType=getAssetsByIssuer&account=<Account>&includeCounts=<TrueFalse>&...
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| account | number or RS | An account ID. |
| account | number or RS | An account ID. |
| includeCounts | boolean | true if number of transfers is to be included. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetBlockchainTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L8" "http://localhost:27876/nxt?requestType=getBlockchainTransactions"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8"
};
NRS.sendRequest("getBlockchainTransactions", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"requestProcessingTime": 1,
"transactions": [
{
"senderPublicKey": "5b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c27",
"chain": 2,
"signature": "e713f575e10b158606c271fc7e15679f900054492a0951c693ba7be58ab35306d2d24f292223eb0c16931b52d6813c6f75fda64a64498aedd0b0ba56e6a72699",
"feeNQT": "10000",
"transactionIndex": 1,
"type": 5,
"confirmations": 17,
"fullHash": "3e7cbee99d7acd21ff96c5812a1f3554bbe6e4dac6e32fc173d3b81fc6805cfe",
"version": 1,
"fxtTransaction": "7263024814050473804",
"phased": false,
"ecBlockId": "2329106975025976796",
"signatureHash": "36cc5de41f9250c400425e9495d9efd05a20779d88d8c231b943cda3a1100723",
"attachment": {
"initialSellSupplyQNT": "0",
"buyRateNQTPerUnit": "10000000",
"expirationHeight": 329703,
"sellRateNQTPerUnit": "20000000",
"totalSellLimitQNT": "0",
"totalBuyLimitQNT": "100000000",
"version.PublishExchangeOffer": 1,
"currency": "5149676163378732196",
"initialBuySupplyQNT": "100000000"
},
"senderRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"subtype": 4,
"amountNQT": "0",
"sender": "17530402417794348028",
"ecBlockHeight": 230000,
"block": "7786070529799360378",
"blockTimestamp": 19496942,
"deadline": 15,
"timestamp": 19496833,
"height": 328267
},
...
]
}
Get the transactions associated with an account in reverse block timestamp order.
POST http://localhost:27876/nxt?requestType=getBlockchainTransactions&chain=<Chain>&account=<Account>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| account | number or RS | An account ID. |
| timestamp | number | Earliest block (in seconds since the genesis block) to retrieve. |
| type | string | Type of transactions to retrieve. |
| subtype | string | Subtype of transactions to retrieve. |
| numberOfConfirmations | number | Minimum confirmation number of blocks. |
| withMessage | boolean | true to retrieve only only transactions having a message attachment, either non-encrypted or decryptable by the account. |
| phasedOnly | boolean | true to retrieve only nonphased transactions. |
| nonPhasedOnly | boolean | true to retrieve only nonphased transactions. |
| includeExpiredPrunable | boolean | true' to retrieve pruned data if available. |
| includePhasingResult | boolean | true to retrieve execution status of each phased transaction. |
| executedOnly | boolean | true to exclude phased transactions that are not yet executed |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
SetAccountInfo
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&name=ArdorCommunity&description=Test+SetAccountInfo&publicKey=5b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c27&passPhrase=xxxxxxxxxx" "http://localhost:27876/nxt?requestType=setAccountInfo"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
name : "ArdorCommunity",
description : "Test SetAccountInfo",
secretPhrase : "xxxxxxxxxx",
publicKey : "5b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c27"
};
NRS.sendRequest("setAccountInfo", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"minimumFeeFQT": "200000000",
"signatureHash": "5ece8129f69c513c9117a1217358fedd5ff3834028e9cf8582cd5a7b9759c38c",
"transactionJSON": {
"senderPublicKey": "5b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c27",
"chain": 2,
"signature": "3db02a823ead11afa82b20cd2c97451967808d05037cb32b4b0914866f9daa00854691662776178cbe79abf2d05ed27af3553e6911393a22d24e657a8c5c4006",
"feeNQT": "200000000",
"type": 10,
"fullHash": "764e5f9da83f24742a664465465762726b979c351d9ee4d2fba93f9d00748876",
"version": 1,
"fxtTransaction": "0",
"phased": false,
"ecBlockId": "9132963265459034843",
"signatureHash": "5ece8129f69c513c9117a1217358fedd5ff3834028e9cf8582cd5a7b9759c38c",
"attachment": {
"name": "ArdorCommunity",
"description": "Test SetAccountInfo",
"version.AccountInfo": 1
},
"senderRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"subtype": 0,
"amountNQT": "0",
"sender": "17530402417794348028",
"ecBlockHeight": 321182,
"deadline": 15,
"timestamp": 19116494,
"height": 2147483647
},
"unsignedTransactionBytes": "020000000a0001ceb123010f005b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c270000000000000000000000000000000000c2eb0b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009ee60400db9a6090b3cdbe7e00000000010e4172646f72436f6d6d756e697479130054657374205365744163636f756e74496e666f000000000000000000000000000000000000000000000000000000000000000000000000",
"broadcasted": true,
"requestProcessingTime": 6,
"transactionBytes": "020000000a0001ceb123010f005b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c270000000000000000000000000000000000c2eb0b000000003db02a823ead11afa82b20cd2c97451967808d05037cb32b4b0914866f9daa00854691662776178cbe79abf2d05ed27af3553e6911393a22d24e657a8c5c40069ee60400db9a6090b3cdbe7e00000000010e4172646f72436f6d6d756e697479130054657374205365744163636f756e74496e666f000000000000000000000000000000000000000000000000000000000000000000000000",
"fullHash": "764e5f9da83f24742a664465465762726b979c351d9ee4d2fba93f9d00748876"
}
Set account information. POST only. This call inherit from Create Transaction Request, thus it also inherit all its parameters but they are optional.
POST http://localhost:27876/nxt?requestType=setAccountInfo&chain=<Chain>&name=<Name>&description=<Description>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| name | string | Name to associate with the account. |
| description | string | A description to associate with the account. |
| secretPhrase | string | Secret phrase of the account. It's optional, but needed for broadcasting |
| publicKey | string | Public key of the account. If secretPhrase is not set than it's required |
| feeNQT | number | Fee (in NQT) of the transaction. If not specified, the response will provide the minimal fee that should be included. |
Additional common parameters are given in the Create Transaction Call.
Account Properties
Account properties are an important feature of the Ardor platform. Indeed, you can set a property to your account or to another account you don't control, and this property can be used later to condition the execution of certain transactions. The properties can represent anything from an Adress, a Phone Number, an Social Security Number or an abstract property you only can understand. The set of application is unlimited, but the account properties build the foundation for a unique Digital Identity in a public environment or a KYC in a corportate environment.
SetAccountProperty
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&recipient=1&property=myTestAccount&value=propValue&secretPhrase=xxxxxxxxx&feeNQT=10000000" "http://localhost:27876/nxt?requestType=setAccountProperty"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
recipient : "1",
property : "myTestAccount",
value : "propValue",
secretPhrase : "xxxxxxxxx",
feeNQT : "10000000"
};
NRS.sendRequest("setAccountProperty", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"minimumFeeFQT": "10000000",
"signatureHash": "75426ef36800e6d18d10a58698570d05e5c0ee9c70b6e682d4203ed970eef33c",
"transactionJSON": {
"senderPublicKey": "5b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c27",
"chain": 2,
"signature": "1dec874b9fa9bcb693fc97777c902e743ef518e237b779beb62a03f12136ec060ca042d673d64454d0b42f18f358937e57e81cd370e4ada7634f8a057cd1dbcc",
"feeNQT": "10000000",
"type": 10,
"fullHash": "1367b14eaa80da5141757e0fdf2f53168500c7649a9d98dd421d7fc5c8084e2e",
"version": 1,
"fxtTransaction": "0",
"phased": false,
"ecBlockId": "18026044117309167588",
"signatureHash": "75426ef36800e6d18d10a58698570d05e5c0ee9c70b6e682d4203ed970eef33c",
"attachment": {
"property": "testProperty",
"value": "testValue",
"version.AccountProperty": 1
},
"senderRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"subtype": 1,
"amountNQT": "0",
"sender": "17530402417794348028",
"recipientRS": "ARDOR-492G-A5YD-FUGZ-C6N2B",
"recipient": "11854182583844805646",
"ecBlockHeight": 332716,
"deadline": 15,
"timestamp": 19803191,
"height": 2147483647
},
"unsignedTransactionBytes": "020000000a0101372c2e010f005b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c270e1cb1fc408482a40000000000000000809698000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ac130500e497bb5d9e5f29fa00000000010c7465737450726f7065727479097465737456616c7565000000000000000000000000000000000000000000000000000000000000000000000000",
"broadcasted": true,
"requestProcessingTime": 4,
"transactionBytes": "020000000a0101372c2e010f005b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c270e1cb1fc408482a4000000000000000080969800000000001dec874b9fa9bcb693fc97777c902e743ef518e237b779beb62a03f12136ec060ca042d673d64454d0b42f18f358937e57e81cd370e4ada7634f8a057cd1dbccac130500e497bb5d9e5f29fa00000000010c7465737450726f7065727479097465737456616c7565000000000000000000000000000000000000000000000000000000000000000000000000",
"fullHash": "1367b14eaa80da5141757e0fdf2f53168500c7649a9d98dd421d7fc5c8084e2e"
}
Set account property. POST only.
POST http://localhost:27876/nxt?requestType=setAccountProperty&chain=<Chain>&recipient=<Account>&property=<Property>&value=<Value>&secretPhrase=<Phrase>&feeNQT=<Fee>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| recipient | number or RS | Account ID of the recipient. |
| property | string | the name of the account property. |
| value | ||
| secretPhrase | string | Secret phrase of the account. Of the setter account. |
Additional common parameters are given in the Create Transaction Call.
GetAccountProperties
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "recipient=ARDOR-492G-A5YD-FUGZ-C6N2B" "http://localhost:27876/nxt?requestType=getAccountProperties"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
recipient: "ARDOR-492G-A5YD-FUGZ-C6N2B"
};
NRS.sendRequest("getAccountProperties", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"recipientRS": "ARDOR-492G-A5YD-FUGZ-C6N2B",
"recipient": "11854182583844805646",
"requestProcessingTime": 0,
"properties": [
{
"setterRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"property": "Birth Date",
"setter": "17530402417794348028",
"value": "01/01/1988"
},
{
"setterRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"property": "Citizenship",
"setter": "17530402417794348028",
"value": "French"
},
{
"setterRS": "ARDOR-492G-A5YD-FUGZ-C6N2B",
"property": "isBigUpAdvisor",
"setter": "11854182583844805646",
"value": "False"
},
{
"setterRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"property": "myTestAccount",
"setter": "17530402417794348028",
"value": null
},
{
"setterRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"property": "testProperty",
"setter": "17530402417794348028",
"value": "testValue"
}
]
}
Get the Account properties for a specific account or setter.
POST http://localhost:27876/nxt?requestType=getAccountProperties&recipient=<Account>&...
| Parameter | Type | Description |
|---|---|---|
| recipient | number or RS | Account ID of the recipient. |
| property | string | the name of the account property. |
| setter | ||
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
DeleteAccountProperty
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&recipient=ARDOR-492G-A5YD-FUGZ-C6N2B&property=testProperty&secretPhrase=xxxxxxxxx&feeNQT=1000000" "http://localhost:27876/nxt?requestType=deleteAccountProperty"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
recipient : "ARDOR-492G-A5YD-FUGZ-C6N2B",
property : "testProperty",
secretPhrase : "xxxxxxxxx",
feeNQT : "1000000"
};
NRS.sendRequest("deleteAccountProperty", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"minimumFeeFQT": "1000000",
"signatureHash": "0f105f6c1f38922d66afedb0d9960e4cd3314eadf47e43e37aeb39b0be1a7b11",
"transactionJSON": {
"senderPublicKey": "5b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c27",
"chain": 2,
"signature": "c669a08446ebb6ef42bfa07a06a73206741811c817db417e5a9448d1d3c2ea0115bbb2da4f207d88495eaed3601fd03fb99bcd9f783fd6878ebc11cb3304ec73",
"feeNQT": "1000000",
"type": 10,
"fullHash": "046878b10dc18c1b374eb24e0d81b73f9635ce519b223ced9c7a7600e1de7314",
"version": 1,
"fxtTransaction": "0",
"phased": false,
"ecBlockId": "13155601693445406119",
"signatureHash": "0f105f6c1f38922d66afedb0d9960e4cd3314eadf47e43e37aeb39b0be1a7b11",
"attachment": {
"property": "5898168130948130579",
"version.AccountPropertyDelete": 1
},
"senderRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"subtype": 2,
"amountNQT": "0",
"sender": "17530402417794348028",
"recipientRS": "ARDOR-492G-A5YD-FUGZ-C6N2B",
"recipient": "11854182583844805646",
"ecBlockHeight": 332743,
"deadline": 15,
"timestamp": 19804527,
"height": 2147483647
},
"unsignedTransactionBytes": "020000000a02016f312e010f005b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c270e1cb1fc408482a4000000000000000040420f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c7130500a73d57f0091692b600000000011367b14eaa80da51000000000000000000000000000000000000000000000000000000000000000000000000",
"broadcasted": true,
"requestProcessingTime": 3,
"transactionBytes": "020000000a02016f312e010f005b3bd8d211c2c792b75e1840ca4af4ba3aa8e5c5dc5ee5487af29766789b5c270e1cb1fc408482a4000000000000000040420f0000000000c669a08446ebb6ef42bfa07a06a73206741811c817db417e5a9448d1d3c2ea0115bbb2da4f207d88495eaed3601fd03fb99bcd9f783fd6878ebc11cb3304ec73c7130500a73d57f0091692b600000000011367b14eaa80da51000000000000000000000000000000000000000000000000000000000000000000000000",
"fullHash": "046878b10dc18c1b374eb24e0d81b73f9635ce519b223ced9c7a7600e1de7314"
}
Delete a previously set Account Property. POST Only.
POST http://localhost:27876/nxt?requestType=deleteAccountProperty&chain=<Chain>&recipient=<Account>&property=<Property>&secretPhrase=<Phrase>&feeNQT=<Fee>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| recipient | number or RS | Account ID of the recipient. |
| property | string | the name of the account property. |
| secretPhrase | string | Secret phrase of the account. |
| feeNQT | number | Fee (in NQT) of the transaction. |
Account Balances
The accounts balances API calls allow you to monitor the account holding or display them in you dApp.
GetBalance
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L8" "http://localhost:27876/nxt?requestType=getBalance"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8"
};
NRS.sendRequest("getBalance", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"unconfirmedBalanceNQT": "3496611077300",
"balanceNQT": "3496611077300",
"requestProcessingTime": 0
}
Get the balance of an account.
POST http://localhost:27876/nxt?requestType=getBalance&chain=<Chain>&account=<Account>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| account | number or RS | An account ID. |
| height | number | Blockchain height at which to retrieve data. Default is most recent block. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetBalances
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-HWZW-5TT6-U68F-H26L8&chain=1&chain=2&chain=3" "http://localhost:27876/nxt?requestType=getBalances"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : ["1", "2", "3"],
account : "ARDOR-HWZW-5TT6-U68F-H26L8"
};
NRS.sendRequest("getBalances", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"balances": {
"1": {
"unconfirmedBalanceNQT": "975883500000",
"balanceNQT": "975883500000"
},
"2": {
"unconfirmedBalanceNQT": "3496611077300",
"balanceNQT": "3496611077300"
},
"3": {
"unconfirmedBalanceNQT": "0",
"balanceNQT": "0"
}
},
"requestProcessingTime": 1
}
Get the balance of an account on different childchain. You need to specify at least one chain id.
POST http://localhost:27876/nxt?requestType=getBalances&account<Account>&chain=<Chain>&chain=<Chain>&chain=<Chain>&...
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| height | number | Blockchain height at which to retrieve data. Default is most recent block. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetGuaranteedBalance
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-HWZW-5TT6-U68F-H26L8&numberOfConfirmations=10" "http://localhost:27876/nxt?requestType=getGuaranteedBalance"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-HWZW-5TT6-U68F-H26L8",
numberOfConfirmations : "10"
};
NRS.sendRequest("getGuaranteedBalance", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"guaranteedBalanceNQT": "975883500000",
"requestProcessingTime": 1
}
Get the balance of an account that is confirmed at least a specified number of blocks in the past.
POST http://localhost:27876/nxt?requestType=getGuaranteedBalance&account=<Account>&...
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| numberOfConfirmations | number | Minimum confirmation number of blocks. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetEffectiveBalance
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-HWZW-5TT6-U68F-H26L8" "http://localhost:27876/nxt?requestType=getEffectiveBalance"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-HWZW-5TT6-U68F-H26L8"
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"forgedBalanceFQT": "0",
"guaranteedBalanceFQT": "975883500000",
"effectiveBalanceFXT": 9758,
"requestProcessingTime": 1
}
Get the Effective balance of an account. The effective balance is used to compute the forging probability of an account, and it refers to the stable balance of an account during the last 24h or 1440 blocks.
POST http://localhost:27876/nxt?requestType=getEffectiveBalance&account=<Account>
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| height | number | Blockchain height at which to retrieve data. Default is most recent block. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
SendMoney
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&recipient=ARDOR-HWZW-5TT6-U68F-H26L8&amountNQT=1000000000&publicKey=f3831afb0cfbaca8e9fca6523d0b23d14aa2e6f9ac1726f12c30acd4d622bb0a" "http://localhost:27876/nxt?requestType=sendMoney"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",//Ignis
recipient : "ARDOR-HWZW-5TT6-U68F-H26L8",
amountNQT : "1000000000",// 1 Ignis = 10^8 NQT, here 10 Ignis
publicKey : "f3831afb0cfbaca8e9fca6523d0b23d14aa2e6f9ac1726f12c30acd4d622bb0a"//publicKey of the sender
};
NRS.sendRequest("sendMoney", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"minimumFeeFQT": "1000000",
"transactionJSON": {
"senderPublicKey": "f3831afb0cfbaca8e9fca6523d0b23d14aa2e6f9ac1726f12c30acd4d622bb0a",
"chain": 2,
"feeNQT": "10000",
"type": 0,
"version": 1,
"fxtTransaction": "0",
"phased": false,
"ecBlockId": "4227293255025921221",
"attachment": {
"version.OrdinaryPayment": 0
},
"senderRS": "ARDOR-8MVA-XCVR-3JC9-2C7C3",
"subtype": 0,
"amountNQT": "1000000000",
"sender": "47475721164246888",
"recipientRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"recipient": "17530402417794348028",
"ecBlockHeight": 324627,
"deadline": 15,
"timestamp": 19323665,
"height": 2147483647
},
"unsignedTransactionBytes": "0200000000000111db26010f00f3831afb0cfbaca8e9fca6523d0b23d14aa2e6f9ac1726f12c30acd4d622bb0afcf347721e8048f300ca9a3b0000000010270000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013f40400c58c397bd15caa3a00000000000000000000000000000000000000000000000000000000000000000000000000000000",
"broadcasted": false,
"requestProcessingTime": 2,
"bundlerRateNQTPerFXT": "1000000"
}
Send a coin (ARDR, Ignis, Bitswift, AEUR, ...) to an account. POST only. The coin to be sent is determined by its chain Id: Coin Name | Chain Id --------- | -------- ARDR | 1 Ignis | 2 Bitswift | 3 AEUR | 4 ... | ...
POST http://localhost:27876/nxt?requestType=sendMoney&chain=<Chain>&recipient=<Recipient>&amountNQT=<Amount>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| recipient | number or RS | Account ID of the recipient. |
| amountNQT | number | Amount (in NQT) in the transaction. |
| secretPhrase | string | Secret phrase of the account. If not specified, publicKey has to be, then the response will be an unsigned transaction and will not be broadcasted. |
| publicKey | string | Public key of the account. required if secretPhrase is not provided. |
| feeNQT | number | Fee (in NQT) of the transaction. If not specified, the response will provide the minimal fee that should be included. |
Additional common parameters are given in the Create Transaction Call.
Account Trades
These API calls allow to closely monitory an account trading activity. This feature is apperciated in the case of Algorithmic Trading.
GetAccountCurrentAskOrderIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L&asset=779342883283236213" "http://localhost:27876/nxt?requestType=getAccountCurrentAskOrderIds"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8",
asset : "779342883283236213"
};
NRS.sendRequest("getAccountCurrentAskOrderIds", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"askOrdersskOrders": [],
"requestProcessingTime": 0
}
Get current ask asset order IDs given an account ID in reverse block height order.
POST http://localhost:27876/nxt?requestType=getAccountCurrentAskOrderIds&chain=<Chain>&account=<Account>&asset=<Asset>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| account | number or RS | An account ID. |
| asset | number | Asset ID. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountCurrentAskOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L&asset=779342883283236213" "http://localhost:27876/nxt?requestType=getAccountCurrentAskOrders"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8",
asset : "779342883283236213"
};
NRS.sendRequest("getAccountCurrentAskOrders", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"askOrdersskOrders": [],
"requestProcessingTime": 0
}
et current ask asset orders given an account ID in reverse block height order.
POST http://localhost:27876/nxt?requestType=getAccountCurrentAskOrders&chain=<Chain>&account=<Account>&asset=<Asset>&...
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| asset | number | Asset ID. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountCurrentBidOrderIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L&asset=779342883283236213" "http://localhost:27876/nxt?requestType=getAccountCurrentBidOrderIds"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8",
asset : "779342883283236213"
};
NRS.sendRequest("getAccountCurrentBidOrderIds", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"bidOrderIds": [
"6614742097871009077"
],
"requestProcessingTime": 0
}
Get current bid asset order IDs given an account ID in reverse block height order.
POST http://localhost:27876/nxt?requestType=getAccountCurrentBidOrderIds&chain=<Chain>&account=<Account>&asset=<Asset>&...
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| asset | number | Asset ID. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountCurrentBidOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L8&asset=779342883283236213" "http://localhost:27876/nxt?requestType=getAccountCurrentBidOrders"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8",
asset : "779342883283236213"
};
NRS.sendRequest("getAccountCurrentBidOrders", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"bidOrders": [
{
"quantityQNT": "2000",
"orderFullHash": "35756c40e448cc5b1a07aca5f9dde14a167459b1a3bc0e07a050e35bde8b062f",
"transactionHeight": 325352,
"accountRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"priceNQTPerShare": "1000000",
"transactionIndex": 1,
"asset": "779342883283236213",
"type": "bid",
"account": "17530402417794348028",
"order": "6614742097871009077",
"height": 325352
}
],
"requestProcessingTime": 0
}
Get current bid asset order given an account ID in reverse block height order.
POST http://localhost:27876/nxt?requestType=getAccountCurrentBidOrders&chain=<Chain>&account=<Account>&asset=<Asset>&...
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
| asset | number | Asset ID. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetAccountExchangeRequests
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L8¤cy=5337417175848322445" "http://localhost:27876/nxt?requestType=getAccountExchangeRequests"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8",
currency : "5337417175848322445"
};
NRS.sendRequest("getAccountExchangeRequests", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"exchangeRequests": [],
"requestProcessingTime": 0
}
Get the exchange requests associated with a given account and/or currency in reverse chronological order (or in expected order of execution for expected requests).
POST http://localhost:27876/nxt?requestType=getAccountExchangeRequests&chain=<Chain>&account=<Account>¤cy=<Currency>&includeCurrencyInfo=<TrueFalse>...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| account | number or RS | An account ID. |
| currency | number | Currency ID. |
| includeCurrencyInfo | boolean | true if several currency information properties is to be included. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
Account Votes
The API calls below allow you to monitor the voting activity of an account.
GetPolls
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L8" "http://localhost:27876/nxt?requestType=getPolls"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8"
};
NRS.sendRequest("getPolls", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"polls": [
{
"minRangeValue": 0,
"votingModel": 2,
"description": "Vote for BigUp compagny actoin plan",
"finished": true,
"poll": "17465897093281664390",
"minNumberOfOptions": 1,
"holding": "779342883283236213",
"minBalance": "100",
"accountRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"name": "BigUp Action Plan",
"options": [
"Buid Client side",
"Build Server side",
"Start Both"
],
"finishHeight": 7854,
"maxNumberOfOptions": 1,
"minBalanceModel": 2,
"account": "17530402417794348028",
"maxRangeValue": 1,
"timestamp": 344422
},
{
"minRangeValue": 0,
"votingModel": 0,
"description": "Who should reign the world?",
"finished": true,
"poll": "13371434558082231003",
"minNumberOfOptions": 1,
"minBalance": "0",
"accountRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"name": "Presendential Election",
"options": [
"A Dictator",
"A Liberal",
"An Alien"
],
"finishHeight": 7909,
"maxNumberOfOptions": 1,
"minBalanceModel": 0,
"account": "17530402417794348028",
"maxRangeValue": 1,
"timestamp": 244957
}
],
"requestProcessingTime": 1
}
Get poll details in reverse creation order.
POST http://localhost:27876/nxt?requestType=getPolls&chain=<Chain>&account=<Account>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| account | number or RS | An account ID. |
| timestamp | number | Earliest block (in seconds since the genesis block) to retrieve. |
| includeFinished | boolean | true to include completed polls. |
| finishedOnly | boolean | true to exclude not yet executed, phased transactions. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
GetVoterPhasedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&account=ARDOR-HWZW-5TT6-U68F-H26L8" "http://localhost:27876/nxt?requestType=getVoterPhasedTransactions"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
account : "ARDOR-HWZW-5TT6-U68F-H26L8"
};
NRS.sendRequest("getVoterPhasedTransactions", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"requestProcessingTime": 1,
"transactions": []
}
Get pending phased transactions which include a whitelist in reverse chronological creation order. These transactions can be considered transaction approval requests.
POST http://localhost:27876/nxt?requestType=getVoterPhasedTransactions&chain=<Chain>&account=<Account>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| account | number or RS | An account ID. |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
Account Funding
COIN, ASSET and CURRENCY balances can be monitored. If a balance falls below the threshold, a transaction will be submitted to transfer units from the funding account to the monitored account. A transfer will remain pending if the number of blocks since the previous transfer transaction is less than the monitor interval.
The recipient accounts are identified by the specified account property. Each account that has this property set by the funding account will be monitored for changes. The property value can be either: - Omitted - Consist of a JSON string containing one or more values in the format: {"amount":long,"threshold":long,"interval":integer}.
This way you can setup a general monitor (if value is omitted) or specific monitor for each account (by specifying the json value).
StartFundingMonitor
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&holdingType=1&holding=779342883283236213&property=myTestAccount&amount=100&threshold=10&interval=15&secretPhrase=xxxxxxxxxx&feeRateNQTPerFXT=1" "http://localhost:27876/nxt?requestType=startFundingMonitor"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
holdingType : "1",
holding : "779342883283236213",
property : "myTestAccount",
amount : "100",
threshold : "10",
interval : "15",
secretPhrase : "xxxxxxxxxx",
feeRateNQTPerFXT : "1"
};
NRS.sendRequest("startFundingMonitor", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"started": true,
"requestProcessingTime": 13
}
Starts a funding monitor that will transfer COIN, ASSET or CURRENCY from the funding account to a recipient account when the amount held by the recipient account drops below the threshold. The funding account is identified by the secret phrase. POST Only.
POST http://localhost:27876/nxt?requestType=startFundingMonitor&chain=<Chain>&holdingType=<Type>&holding=<Id>&property=<Prop>&amount=<Amount>&threshold=<Threshold>&interval=<Interval>&secretPhrase=<Phrase>&feeRateNQTPerFXT=<Fee>
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| holdingType | number | A number representing the holding type (0 for Coin, 1 for Asset, 2 for Currency). |
| holding | number | Holding ID. The Id of the coin, asset or currency. |
| property | string | the name of the account property. |
| amount | number | Amount to fund the recipient account with (in NQT or QNT). |
| threshold | number | Threshold amount under which a funding transaction will be created. |
| interval | number | Number of blocks to wait after before funding the recipient. |
| secretPhrase | string | Secret phrase of the account. |
| feeRateNQTPerFXT | If not set, the transaction will not be broadcasted |
StopFundingMonitor
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&holdingType=1&holding=779342883283236213&property=myTestAccount&secretPhrase=xxxxxxxxxx" "http://localhost:27876/nxt?requestType=stopFundingMonitor"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
holdingType : "1",
holding : "779342883283236213",
property : "myTestAccount",
secretPhrase : "xxxxxxxxxx"
};
NRS.sendRequest("stopFundingMonitor", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"stopped": 1,
"requestProcessingTime": 1
}
Stop a previously started funding monitor.
POST http://localhost:27876/nxt?requestType=stopFundingMonitor&chain=<Chain>&holdingType=<Type>&holding=<Id>&property=<Prop>&account=<Account>&secretPhrase=<Phrase>&adminPassword=<Password>
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| holdingType | number | A number representing the holding type (0 for Coin, 1 for Asset, 2 for Currency). |
| holding | number | Holding ID. The Id of the coin, asset or currency. |
| property | string | the name of the account property. Stops monitoring of all account with this property. |
| account | number or RS | An account ID. Stops mointoring only for this account. |
| secretPhrase | string | Secret phrase of the account. If provided, it's used to stop a single monitor by holder of the account. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. Used to stop a single monitor or all monitor |
GetFundingMonitor
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "chain=2&holdingType=1&holding=779342883283236213&property=myTestAccount&secretPhrase=xxxxxxxxxx&includeMonitoredAccounts=true" "http://localhost:27876/nxt?requestType=getFundingMonitor"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
chain : "2",
holdingType : "1",
holding : "779342883283236213",
property : "myTestAccount",
secretPhrase : "xxxxxxxxxx",
includeMonitoredAccounts : "true"
};
NRS.sendRequest("getFundingMonitor", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"requestProcessingTime": 1,
"monitors": [
{
"holding": "779342883283236213",
"amount": "100",
"monitoredAccounts": [
{
"amount": "100",
"accountRS": "ARDOR-492G-A5YD-FUGZ-C6N2B",
"threshold": "10",
"interval": 15,
"account": "11854182583844805646"
}
],
"holdingType": 1,
"accountRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"property": "myTestAccount",
"threshold": "10",
"interval": 15,
"account": "17530402417794348028",
"feeRateNQTPerFXT": "1"
}
]
}
Get a funding monitor and the monitored accounts.
POST http://localhost:27876/nxt?requestType=getFundingMonitor&chain=<Chain>&holdingType=<Type>&holding=<Id>&property=<Prop>&secretPhrase=<Phrase>&...
| Parameter | Type | Description |
|---|---|---|
| chain | number | Chain ID (Ignis=2, BITSWIFT=3, AEUR=4 ...). |
| holdingType | number | A number representing the holding type (0 for Coin, 1 for Asset, 2 for Currency). |
| holding | number | Holding ID. |
| property | string | the name of the account property. |
| secretPhrase | string | Secret phrase of the account. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| includeMonitoredAccounts | boolean | true to include account info of the monitored accounts. |
| account | number or RS | An account ID. Specific account |
Account Util functions
The API calls below allow to do a global search for an account with a keyword description or to get RS format of an account.
RsConvert
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "account=ARDOR-HWZW-5TT6-U68F-H26L8" "http://localhost:27876/nxt?requestType=rsConvert"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
account : "ARDOR-HWZW-5TT6-U68F-H26L8"
};
NRS.sendRequest("rsConvert", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"accountRS": "ARDOR-HWZW-5TT6-U68F-H26L8",
"accountLongId": "-916341655915203588",
"requestProcessingTime": 0,
"account": "17530402417794348028"
}
Get both the Reed-Solomon account address and the account number given an account ID.
POST http://localhost:27876/nxt?requestType=rsConvert&account=<Account>
| Parameter | Type | Description |
|---|---|---|
| account | number or RS | An account ID. |
SearchAccounts
The request:
curl -X POST -d "query=" "http://localhost:27876/nxt?requestType=searchAccounts" -k -H "Content-Type: application/x-www-form-urlencoded"
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
query : "community AND culture"
};
NRS.sendRequest("searchAccounts", data, function (response) {
NRS.logConsole(JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
{
"accounts": [
{
"accountRS": "ARDOR-969E-APWA-MU85-8Z8AQ",
"name": "PVH Culture Foundation",
"description": "The PVH Culture Foundation is a fund to promote the artistic creation in the world of the crypotcurrencies, especialy in the Nxt community.",
"account": "7719415250780655852"
}
],
"requestProcessingTime": 39
}
Get accounts having a name or description that match a given query in reverse relevance order.
POST http://localhost:27876/nxt?requestType=searchAccounts&query=<Query>
| Parameter | Type | Description |
|---|---|---|
| query | string | Full text query on the account fields name (S) and description (S) in the standard Lucene syntax |
| firstIndex | number | Zero-based index to the first block to retrieve. |
| lastIndex | number | Zero-based index to the first block to retrieve. |
| adminPassword | string | Admin password, used for restricted actions & in debug functions. |
| requireBlock | number | Block ID of a block that must be present in the blockchain during execution. |
| requireLastBlock | number | Block ID of a block that must be last in the blockchain during execution. |
Account Control
Account control API calls allow you to apply different controls over your account like phasing, multiSig approvals or max spending limits.
Set Controls
leaseBalance
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
setPhasingOnlyControl
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
View Controls
getAllPhasingOnlyControls
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPhasingOnlyControl
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Transactions
Signing & Sending
signTransaction
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
sendTransaction
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
broadcastTransaction
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
calculateFullHash
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
parseTransaction
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
retrievePrunedTransaction
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Explore transactions
getTransaction
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getTransactionBytes
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getUnconfirmedTransactionIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getUnconfirmedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getBlockchainTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExecutedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getFxtTransaction
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getReferencingTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Coin Exchange
The Coin Exchange feature is specific to Ardor architecture. Indeed, Ardor is based on the Parent-ChildChain architecture, thus the parent chain have its own coin ARDR, and each childchain have its own coin too, like IGNIS, BITSWIFT, AEUR ...etc. The coin exchange allow users to exchange chilchain coins against the ARDR parent chain coin without going throw an exeternal exchange.
The API calls below help you achieve this.
Orders Setting
exchangeCoins
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
cancelCoinExchange
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Orders Discovery
getCoinExchangeOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCoinExchangeOrderIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCoinExchangeOrder
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCoinExchangeTrades
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCoinExchangeTrade
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedCoinExchangeOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedCoinExchangeOrderCancellations
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
simulateCoinExchange
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Decentralized Asset Exchange
This chapter focus on all the API calls available for the Asset Exchange feature. From asset issuance to decentralized exchange of the issued assets and many other services, these calls can help setup and monitor everything.
Asset Creation
issueAsset
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
transferAsset
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
increaseAssetShares
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
dividendPayment
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
deleteAssetShares
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
setPhasingAssetControl
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPhasingAssetControl
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Asset Holders
getAssetAccountCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAssetAccounts
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Asset Exchange
placeAskOrder
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
cancelAskOrder
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
placeBidOrder
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
cancelBidOrder
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAskOrderIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAskOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAskOrder
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getBidOrderIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getBidOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getBidOrder
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAllOpenAskOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAllOpenBidOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAllTrades
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Asset Trades
getTrades
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getLastTrades
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getOrderTrades
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedAskOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedAssetDeletes
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedAssetTransfers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedBidOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedOrderCancellations
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Account's Assets
getAccountAssetCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAccountAssets
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAccountCurrentAskOrderIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAccountCurrentAskOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAccountCurrentBidOrderIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAccountCurrentBidOrders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Assets Discovery
searchAssets
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAllAssets
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAssetIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAssets
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAsset
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAssetDividends
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAssetHistory
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAssetPhasedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAssetTransfers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAssetsByIssuer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Decentralized Digital Goods
The Digital Goods, or DGS for abreviation, is an interesting feature available for each childchain and give it the possibility to build a Decentralized market place in an easy and smooth way.
The API calls below allow this market place to achieve all the necessary actions.
DGS Lisiting
dgsListing
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
dgsDelisting
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
dgsDelivery
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
dgsFeedback
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
DGS Actions
dgsPriceChange
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
dgsPurchase
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
dgsQuantityChange
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
dgsRefund
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSPendingPurchases
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSExpiredPurchases
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
DGS Purchases
getDGSGoodsPurchaseCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSGoodsPurchases
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSPurchaseCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSPurchases
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSPurchase
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
DGS Discovery
getDGSGoodsCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSGoods
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSGood
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSTagCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSTags
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSTagsLike
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
searchDGSGoods
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Decentralized Monetary System
The Ardor Monetary System features a special asset class currency secured by the Ardor network and blockchain. Virtual currencies with a variety of customizable properties can be created in minutes.
The API calls below help create and also exchange and manage your created virtual currency.
Currency Issuance
issueCurrency
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
transferCurrency
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
currencyMint
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
currencyReserveClaim
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
currencyReserveIncrease
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
canDeleteCurrency
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
deleteCurrency
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Currency Holders
getCurrencyAccountCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCurrencyAccounts
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCurrencyFounders
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Account Currencies
getAccountCurrencyCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAccountCurrencies
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAccountExchangeRequests
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Currency Exchange
currencyBuy
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
currencySell
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getBuyOffers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getSellOffers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAllCurrencies
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAllExchanges
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAvailableToBuy
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAvailableToSell
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCurrenciesByIssuer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCurrencyIds
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCurrencies
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCurrency
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
searchCurrencies
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCurrencyPhasedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCurrencyTransfers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExchanges
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExchangesByExchangeRequest
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExchangesByOffer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedBuyOffers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedCurrencyTransfers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedExchangeRequests
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getExpectedSellOffers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getLastExchanges
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getMintingTarget
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getOffer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
publishExchangeOffer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Decentralized Messaging
Messages is a way for Ardor accounts to exchange information or data over the blockchain without using a secondary channel. The messages can be encrypted and are prunable from the blockchain history.
The base implementation allows for the transmission of simple, unencrypted text messages between accounts, but since the messages are truly "arbitrary" the range of possible applications is vast. Secure messaging, torrent applications, voting systems, data storage systems and even simple distributed applications have been suggested.
Send & Read
sendMessage
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
readMessage
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Encrypted Messages
encryptTo
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
decryptFrom
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getSharedKey
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Prunable Messages
getAllPrunableMessages
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPrunableMessages
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPrunableMessage
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
downloadPrunableMessage
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
verifyPrunableMessage
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Decentralized Voting System
Create & Vote
createPoll
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
castVote
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Explore votes
getPolls
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPoll
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPollResult
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPollVotes
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPollVote
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
searchPolls
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Decentralized Data Storage
Up/Downloading Data
uploadTaggedData
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
downloadTaggedData
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
verifyTaggedData
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
searchTaggedData
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
detectMimeType
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Exploring Data
getAllTaggedData
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAccountTaggedData
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getChannelTaggedData
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDataTagCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDataTags
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDataTagsLike
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getTaggedData
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Decentralized Alias
Alias are a way to substitute one piece of text by another, so that keywords or keyphrases can be used to represent other things, for example you substitute a server IP address by a text representing the name of a domain, or an Ardor account address by the name of its holder.
Get & Set Alias
In order to set an alias or search for existing ones, you can use the API calls below.
setAlias
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAliasCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAlias
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAliases
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAliasesLike
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Exchange Alias
Alias can be set, bought and sold, and the API calls can help you achieve this.
buyAlias
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
sellAlias
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
deleteAlias
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Privacy & Suffling
Shuffling Setup
shufflingCreate
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
shufflingCancel
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
shufflingProcess
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
shufflingRegister
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
shufflingVerify
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
startShuffler
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
stopShuffler
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Suffling Monitoring
getAllShufflings
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAccountShufflings
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAssignedShufflings
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getHoldingShufflings
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getShufflers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getShuffling
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getShufflingParticipants
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Blocks
Blocks are the series of constituent elements of the Blockchain. These API calls helps monitor the blockchain activity by exploring these blocks and their content.
Blocks discovery
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getBlocks
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getBlock
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getBlockId
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getBlockchainStatus
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getECBlock
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Forging
In Proof-of-Stake consensus algorithms, Forging is the process of building and validating transaction blocks, which equivalent to Mining in Proof-of-Work, with the exception that forgers are rewarded only from transaction fees and there is no new generation of forging coin (ARDR is this case).
The API calls below allow you to
Forge & Bundle
leaseBalance
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
startForging
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
stopForging
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
startBundler
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
stopBundler
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Forgers
getBundlers
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAllBundlerRates
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getBundlerRates
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getForging
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
blacklistBundler
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
bundleTransactions
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getGuaranteedBalance
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getNextBlockGenerators
The request:
curl "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Node & Network
Node Info
getBlockchainStatus
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getConstants
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPlugins
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getState
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getTime
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
eventRegister
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
eventWait
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Network & Peers
getMyInfo
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
addPeer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPeers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPeer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
setAPIProxyPeer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
blacklistAPIProxyPeer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
blacklistPeer
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Phasing
Phasing approval
approveTransaction
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
parsePhasingParams
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Phased transactions
getAccountPhasedTransactionCount
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAccountPhasedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAssetPhasedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getCurrencyPhasedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getLinkedPhasedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Phased votes
getPhasingPollVotes
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPhasingPollVote
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getPhasingPoll
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getVoterPhasedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Search
Global Search
searchAccounts
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
searchAssets
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
searchCurrencies
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
searchDGSGoods
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
searchPolls
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
searchTaggedData
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Like Search
getAliasesLike
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDGSTagsLike
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getDataTagsLike
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Utils
Tokens
decodeFileToken
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
decodeToken
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
generateFileToken
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
generateToken
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Expressions & Codes
evaluateExpression
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
hash
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
fullHashToId
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
encodeQRCode
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
decodeQRCode
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
detectMimeType
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
hexConvert
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
longConvert
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
rsConvert
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
Debugging
scan
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
dumpPeers
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
fullReset
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
popOff
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
luceneReindex
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
retrievePrunedData
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
setLogging
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getLog
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getStackTraces
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
shutdown
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
clearUnconfirmedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAllBroadcastedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
getAllWaitingTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
rebroadcastUnconfirmedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
requeueUnconfirmedTransactions
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |
trimDerivedTables
The request:
curl -k -H "Content-Type: application/x-www-form-urlencoded" -X POST -d "" "http://localhost:27876/nxt?requestType="
var ardor = require('ardor-blockchain');
ardor.init(config);
ardor.load(function(NRS) {
var data = {
};
NRS.sendRequest("", data, function (response) {
NRS.logConsole("Response is:" + JSON.stringify(response));
});
});
The above request returns the following JSON structured response:
[
]
Call Description
GET http://localhost:27876/nxt?requestType=
| Parameter | Type | Description |
|---|---|---|
| param | type | description |
| param | type | description |
| param | type | description |