# Examples:

# Get a transaction by hash from the full node HTTP API:


curl http://x:api-key@127.0.0.1:14037/tx/\
  4674eb87021d9e07ff68cfaaaddfb010d799246b8f89941c58b8673386ce294f


# Get a raw transaction by hash from the full node RPC API:


curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{ \
    "method": "getrawtransaction", \
    "params": [ "4674eb87021d9e07ff68cfaaaddfb010d799246b8f89941c58b8673386ce294f"] \
  }'


# Get a transaction by hash from the "primary" wallet HTTP API:


curl http://x:api-key@127.0.0.1:14039/wallet/primary/tx/\
  4674eb87021d9e07ff68cfaaaddfb010d799246b8f89941c58b8673386ce294f


# Get a transaction by hash from the wallet RPC API:


curl http://x:api-key@127.0.0.1:14039 \
  -X POST \
  --data '{ \
    "method": "gettransaction", \
    "params": [ "4674eb87021d9e07ff68cfaaaddfb010d799246b8f89941c58b8673386ce294f" ] \
  }'

# default regtest port is 14037 (may be reconfigured by user), API key is required in URL
curl http://x:api-key@127.0.0.1:14037/

cli --api-key=api-key --network=regtest info

# store API key and network type in environment variables:
export HSD_API_KEY=api-key
export HSD_NETWORK=regtest
cli info

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

// network type derived from hsd object, client object stores API key
const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const clientinfo = await client.getInfo();
  console.log(clientinfo);
})();

# With curl you just send HTTP Requests based on further docs
curl http://127.0.0.1:14037/ # will get info from regtest

# You can configure it by passing arguments:
hsd-cli --network=regtest info
hsd-cli info --network=regtest

# Or use environment variables (Starting with HSD_)
export HSD_NETWORK=regtest
export HSD_API_KEY=$YOUR-API-KEY
hsd-cli info

# Example hsd.conf syntax:
network: main
prefix: ~/.hsd
api-key: <api-key>
index-tx: true

const {NodeClient, WalletClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const walletOptions = {
  port: network.walletPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);
const wallet = new WalletClient(walletOptions);

curl http://x:api-key@127.0.0.1:14037/

hsd-cli info

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const clientinfo = await client.getInfo();
  console.log(clientinfo);
})();

{
  "version": "2.0.1",
  "network": "regtest",
  "chain": {
    "height": 1,
    "tip": "6b054a7a561fdfa7c2f11550db4d5341d101be044df24dd58c465b2abac94c3f",
    "treeRoot": "0000000000000000000000000000000000000000000000000000000000000000",
    "progress": 0.6125905181398805,
    "state": {
      "tx": 2,
      "coin": 1360,
      "value": 237416588368270,
      "burned": 0
    }
  },
  "pool": {
    "host": "0.0.0.0",
    "port": 14038,
    "identitykey": "aorsxa4ylaacshipyjkfbvzfkh3jhh4yowtoqdt64nzemqtiw2whk",
    "agent": "/hsd:2.0.1/",
    "services": "1",
    "outbound": 0,
    "inbound": 0
  },
  "mempool": {
    "tx": 0,
    "size": 0,
    "claims": 0,
    "airdrops": 0,
    "orphans": 0
  },
  "time": {
    "uptime": 3,
    "system": 1581299165,
    "adjusted": 1581299165,
    "offset": 0
  },
  "memory": {
    "total": 78,
    "jsHeap": 11,
    "jsHeapTotal": 29,
    "nativeHeap": 49,
    "external": 14
  }
}

curl http://x:api-key@127.0.0.1:14037/mempool

hsd-cli mempool

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const mempool = await client.getMempool();
  console.log(mempool);
})().catch((err) => {
  console.error(err.stack);
});

[
  "2ef8051e6c38e136ba4d195c048e78f9077751758db710475fa532b9d9489324",
  "bc3308b61959664b71ac7fb8e9ee17d13476b5a32926f512882851b7631884f9",
  "53faa103e8217e1520f5149a4e8c84aeb58e55bdab11164a95e69a8ca50f8fcc",
  "fff647849be7408faedda377eea6c37718ab39d656af8926e0b4b74453624f32",
  "b3c71dd8959ea97d41324779604b210ae881cdaa5d5abfcbfb3502a0e75c1283",
  ...
]

curl http://x:api-key@127.0.0.1:14037/mempool/invalid

> no CLI command available

// no JS client function available

{
  "items": 161750,
  "size": 5175951,
  "entries": 0,
  "n": 20,
  "limit": 60000,
  "tweak": 3433901487
}

hash=8e4c9756fef2ad10375f360e0560fcc7587eb5223ddf8cd7c7e06e60a1140b15
curl http://x:api-key@127.0.0.1:14037/mempool/invalid/$hash

> no CLI command available

// no JS client function available

{
  "invalid": false
}

let blockHash, blockHeight;

blockHash='ae3895cf597eff05b19e02a70ceeeecb9dc72dbfe6504a50e9343a72f06a87c5';
blockHeight='0';

curl http://x:api-key@127.0.0.1:14037/block/$blockHash # by hash
curl http://x:api-key@127.0.0.1:14037/block/$blockHeight # by height

hsd-cli block $blockHash # by hash
hsd-cli block $blockHeight # by height

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const blockByHeight = await client.getBlock(blockHeight);
  const blockByHash = await client.getBlock(blockHash);
  console.log("By height: \n", blockByHeight);
  console.log("By hash: \n", blockByHash);
})();

{
  "hash": "ae3895cf597eff05b19e02a70ceeeecb9dc72dbfe6504a50e9343a72f06a87c5",
  "height": 0,
  "depth": 2,
  "version": 0,
  "prevBlock": "0000000000000000000000000000000000000000000000000000000000000000",
  "merkleRoot": "8e4c9756fef2ad10375f360e0560fcc7587eb5223ddf8cd7c7e06e60a1140b15",
  "witnessRoot": "1a2c60b9439206938f8d7823782abdb8b211a57431e9c9b6a6365d8d42893351",
  "treeRoot": "0000000000000000000000000000000000000000000000000000000000000000",
  "reservedRoot": "0000000000000000000000000000000000000000000000000000000000000000",
  "time": 1580745080,
  "bits": 545259519,
  "nonce": 0,
  "extraNonce": "000000000000000000000000000000000000000000000000",
  "mask": "0000000000000000000000000000000000000000000000000000000000000000",
  "txs": [
    {
      "hash": "9553240e6f711271cfccf9407c9348996e61cb3bd39adbc2ec258ff940ff22c6",
      "witnessHash": "49880b0f9dd1b0b5dd43f6d64803276d54717e5f98b71d82bf170cb4dd0c2388",
      "fee": 0,
      "rate": 0,
      "mtime": 1581299280,
      "index": 0,
      "version": 0,
      "inputs": [
        {
          "prevout": {
            "hash": "0000000000000000000000000000000000000000000000000000000000000000",
            "index": 4294967295
          },
          "witness": [
            "50b8937fc5def08f9f3cbda7e5f08c706edb80aba5880c000000000000000000",
            "2d5de58609d4970fb548f85ad07a87db40e054e34cc81c951ca995a58f674db7",
            "10d748eda1b9c67b94d3244e0211677618a9b4b329e896ad90431f9f48034bad",
            "e2c0299a1e466773516655f09a64b1e16b2579530de6c4a59ce5654dea45180f"
          ],
          "sequence": 4294967295,
          "address": null
        }
      ],
      "outputs": [
        {
          "value": 2002210000,
          "address": "rs1q7q3h4chglps004u3yn79z0cp9ed24rfrhvrxnx",
          "covenant": {
            "type": 0,
            "action": "NONE",
            "items": []
          }
        }
      ],
      "locktime": 0,
      "hex": "00000000010000000000000000000000000000000000000000000000000000000000000000ffffffffffffffff01d04c5777000000000014f0237ae2e8f860f7d79124fc513f012e5aaa8d23000000000000042050b8937fc5def08f9f3cbda7e5f08c706edb80aba5880c000000000000000000202d5de58609d4970fb548f85ad07a87db40e054e34cc81c951ca995a58f674db72010d748eda1b9c67b94d3244e0211677618a9b4b329e896ad90431f9f48034bad20e2c0299a1e466773516655f09a64b1e16b2579530de6c4a59ce5654dea45180f"
    }
  ]
}

let blockHash, blockHeight;

blockHash='ae3895cf597eff05b19e02a70ceeeecb9dc72dbfe6504a50e9343a72f06a87c5';
blockHeight='0';

curl http://x:api-key@127.0.0.1:14037/header/$blockHash # by hash
curl http://x:api-key@127.0.0.1:14037/header/$blockHeight # by height

# None available

// None available

{
  "hash": "ae3895cf597eff05b19e02a70ceeeecb9dc72dbfe6504a50e9343a72f06a87c5",
  "height": 0,
  "depth": 2,
  "version": 0,
  "prevBlock": "0000000000000000000000000000000000000000000000000000000000000000",
  "merkleRoot": "8e4c9756fef2ad10375f360e0560fcc7587eb5223ddf8cd7c7e06e60a1140b15",
  "witnessRoot": "1a2c60b9439206938f8d7823782abdb8b211a57431e9c9b6a6365d8d42893351",
  "treeRoot": "0000000000000000000000000000000000000000000000000000000000000000",
  "reservedRoot": "0000000000000000000000000000000000000000000000000000000000000000",
  "time": 1580745080,
  "bits": 545259519,
  "nonce": 0,
  "extraNonce": "000000000000000000000000000000000000000000000000",
  "mask": "0000000000000000000000000000000000000000000000000000000000000000",
  "chainwork": "0000000000000000000000000000000000000000000000000000010001000100"
}

let tx;

tx='010000000106b014e37704109fefe2c5c9f4227d68840c3497fc89a9832db8504df039a6c7000000006a47304402207dc8173fbd7d23c3950aaf91b1bc78c0ed9bf910d47a977b24a8478a91b28e69022024860f942a16bc67ec54884e338b5b87f4a9518a80f9402564061a3649019319012103cb25dc2929ea58675113e60f4c08d084904189ab44a9a142179684c6cdd8d46affffffff0280c3c901000000001976a91400ba915c3d18907b79e6cfcd8b9fdf69edc7a7db88acc41c3c28010000001976a91437f306a0154e1f0de4e54d6cf9d46e07722b722688ac00000000';

curl http://x:api-key@127.0.0.1:14037/broadcast \
  -H 'Content-Type: application/json' \
  -X POST \
  --data '{ "tx": "'$tx'" }'

hsd-cli broadcast $tx

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.broadcast(tx);
  console.log(result);
})();

{
  "success": true
}

let claim;

claim='310d030300003000010002a30001080101030803010001acffb409bcc939f...';

curl http://x:api-key@127.0.0.1:14037/claim \
  -H 'Content-Type: application/json' \
  -X POST \
  --data '{ "claim": "'$claim'" }'

> no CLI command available

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.broadcastClaim(claim);
  console.log(result);
})();

{
  "success": true
}

let blocks;

blocks=3

curl http://x:api-key@127.0.0.1:14037/fee?blocks=$blocks

hsd-cli fee $blocks

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.estimateFee(blocks);
  console.log(result);
})();

{
  "rate": 13795
}

let height;

height=1000;

curl http://x:api-key@127.0.0.1:14037/reset \
  -H 'Content-Type: application/json' \
  -X POST \
  --data '{ "height": '$height' }'

hsd-cli reset $height

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.reset(height);
  console.log(result);
})();

{
  "success": true
}

let hash, index;

hash='7d142b878b7894fb916280d0bee0b5c4f8970e1adbc9d1a2e9057a0b8187b709';
index=0;

curl http://x:api-key@127.0.0.1:14037/coin/$hash/$index

hsd-cli coin $hash $index

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.getCoin(hash, index);
  console.log(result);
})();

{
  "version": 0,
  "height": 0,
  "value": 2002210000,
  "address": "rs1q7q3h4chglps004u3yn79z0cp9ed24rfrhvrxnx",
  "covenant": {
    "type": 0,
    "action": "NONE",
    "items": []
  },
  "coinbase": true,
  "hash": "9553240e6f711271cfccf9407c9348996e61cb3bd39adbc2ec258ff940ff22c6",
  "index": 0
}

let address;

address='rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5';

curl http://x:api-key@127.0.0.1:14037/coin/address/$address

hsd-cli coin $address

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.getCoinsByAddress(address);
  console.log(result);
})();

[
  {
    "version": 0,
    "height": 69,
    "value": 2000000000,
    "address": "rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5",
    "covenant": {
      "type": 0,
      "action": "NONE",
      "items": []
    },
    "coinbase": true,
    "hash": "fcc1f0656b5e6a0856abf21424579b87c30bc30b89a3c3925923052cb636d80b",
    "index": 0
  },
  {
    "version": 0,
    "height": 74,
    "value": 2000000000,
    "address": "rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5",
    "covenant": {
      "type": 0,
      "action": "NONE",
      "items": []
    },
    "coinbase": true,
    "hash": "ffaab95b75c3db650191920a69915e480ced19a8f58cba867382fc8163654299",
    "index": 0
  }
]

let address0, address1;

address0='rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5';
address1='rs1qcxuurryemelaj64k6rswn8x9aa8nd9nafa47ag';

curl http://x:api-key@127.0.0.1:14037/coin/address \
  -H 'Content-Type: application/json' \
  -X POST \
  --data '{ "addresses":[ "'$address0'", "'$address1'" ]}'

No CLI Option.

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.getCoinsByAddresses([address0, address1]);
  console.log(result);
})().catch((err) => {
  console.error(err.stack);
});

[
  {
    "version": 0,
    "height": 69,
    "value": 2000000000,
    "address": "rs1qcxuurryemelaj64k6rswn8x9aa8nd9nafa47ag",
    "covenant": {
      "type": 0,
      "action": "NONE",
      "items": []
    },
    "coinbase": true,
    "hash": "fcc1f0656b5e6a0856abf21424579b87c30bc30b89a3c3925923052cb636d80b",
    "index": 0
  },
  {
    "version": 0,
    "height": 74,
    "value": 2000000000,
    "address": "rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5",
    "covenant": {
      "type": 0,
      "action": "NONE",
      "items": []
    },
    "coinbase": true,
    "hash": "ffaab95b75c3db650191920a69915e480ced19a8f58cba867382fc8163654299",
    "index": 0
  }
]

let txhash;

txhash='4674eb87021d9e07ff68cfaaaddfb010d799246b8f89941c58b8673386ce294f';

curl http://x:api-key@127.0.0.1:14037/tx/$txhash

hsd-cli tx $txhash

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.getTX(txhash);
  console.log(result);
})().catch((err) => {
  console.error(err.stack);
});

{
  "hash": "ffaab95b75c3db650191920a69915e480ced19a8f58cba867382fc8163654299",
  "witnessHash": "23103d0e91632760a69a8abfb80c0589caf1acfde829b219372d2cd595153f3a",
  "fee": 0,
  "rate": 0,
  "mtime": 1581299437,
  "height": 74,
  "block": "19f0de035bfdb5482eb148f49be7e4427ebbcf0b7522665766154e0873637e18",
  "time": 1581299449,
  "index": 0,
  "version": 0,
  "inputs": [
    {
      "prevout": {
        "hash": "0000000000000000000000000000000000000000000000000000000000000000",
        "index": 4294967295
      },
      "witness": [
        "6d696e656420627920687364",
        "e591dce4a94f7b28",
        "0000000000000000"
      ],
      "sequence": 3610282069,
      "address": null
    }
  ],
  "outputs": [
    {
      "value": 2000000000,
      "address": "rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5",
      "covenant": {
        "type": 0,
        "action": "NONE",
        "items": []
      }
    }
  ],
  "locktime": 74,
  "hex": "00000000010000000000000000000000000000000000000000000000000000000000000000ffffffff558830d701009435770000000000140f1fa7047677f37a78bbe0f28be3b095f85e391900004a000000030c6d696e65642062792068736408e591dce4a94f7b28080000000000000000",
  "confirmations": 28
}

let address;

address='rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5';

curl http://x:api-key@127.0.0.1:14037/tx/address/$address

hsd-cli tx $address

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.getTXByAddress(address);
  console.log(result);
})().catch((err) => {
  console.error(err.stack);
});

[
  {
    "hash": "ffaab95b75c3db650191920a69915e480ced19a8f58cba867382fc8163654299",
    "witnessHash": "23103d0e91632760a69a8abfb80c0589caf1acfde829b219372d2cd595153f3a",
    "fee": 0,
    "rate": 0,
    "mtime": 1581299437,
    "height": 74,
    "block": "19f0de035bfdb5482eb148f49be7e4427ebbcf0b7522665766154e0873637e18",
    "time": 1581299449,
    "index": 0,
    "version": 0,
    "inputs": [
      {
        "prevout": {
          "hash": "0000000000000000000000000000000000000000000000000000000000000000",
          "index": 4294967295
        },
        "witness": [
          "6d696e656420627920687364",
          "e591dce4a94f7b28",
          "0000000000000000"
        ],
        "sequence": 3610282069,
        "address": null
      }
    ],
    "outputs": [
      {
        "value": 2000000000,
        "address": "rs1qpu06wprkwleh579mureghcasjhu9uwge6pltn5",
        "covenant": {
          "type": 0,
          "action": "NONE",
          "items": []
        }
      }
    ],
    "locktime": 74,
    "hex": "00000000010000000000000000000000000000000000000000000000000000000000000000ffffffff558830d701009435770000000000140f1fa7047677f37a78bbe0f28be3b095f85e391900004a000000030c6d696e65642062792068736408e591dce4a94f7b28080000000000000000",
    "confirmations": 28
  },
  ...
]

let address0, address1;

address0='rs1q7rvnwj3vaqxrwuv87j7xc6ye83tpevfkvhzsap';
address1='rs1qx38r5mjzlxfus9yx7nhx3mrg00sv75xc5mksk5';

 curl http://x:api-key@127.0.0.1:14037/tx/address \
  -H 'Content-Type: application/json' \
  -X POST \
  --data '{ "addresses":[ "'$address0'", "'$address1'" ]}'

No CLI Option.

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.getTXByAddresses([address0, address1]);
  console.log(result);
})();

[
  {
    "hash": "f64f1a1bea51883ef365ac5008656f0eecedfa58c0215e97a0f2c5046ebb73c0",
    "witnessHash": "f9429e86143084392a9d23d0680bf7570ddc7e2bfe51405d44a554dbad8ab51d",
    "fee": 0,
    "rate": 0,
    "mtime": 1528329693,
    "height": 3,
    "block": "be818dc2e986f872118e2c4d2995d14beb03edada40a448d24daf7b62cc272cf",
    "time": 1528329693,
    "index": 0,
    "version": 0,
    "inputs": [
      {
        "prevout": {
          "hash": "0000000000000000000000000000000000000000000000000000000000000000",
          "index": 4294967295
        },
        "witness": [
          "6d696e65642062792068736b64",
          "72bc06c17f58df4e",
          "0000000000000000"
        ],
        "sequence": 816606577,
        "address": null
      }
    ],
    "outputs": [
      {
        "value": 500000000,
        "address": "rs1q7qumafugfglg268djelwr7ps4l2uh2vsdpfnuc",
        "covenant": {
          "type": 0,
          "items": []
        }
      }
    ],
    "locktime": 3,
    "hex": "00000000010000000000000000000000000000000000000000000000000000000000000000ffffffff030d6d696e65642062792068736b640872bc06c17f58df4e080000000000000000716dac30010065cd1d000000000014f039bea7884a3e8568ed967ee1f830afd5cba990000003000000",
    "confirmations": 1
  },
  {
    "hash": "4674eb87021d9e07ff68cfaaaddfb010d799246b8f89941c58b8673386ce294f",
    "witnessHash": "337189c003cf9c2ea413b5b6041c5b9e62f5fdfafcdd6cb54d5829c6cd59dd77",
    "fee": 2800,
    "rate": 20000,
    "mtime": 1528329716,
    "height": -1,
    "block": null,
    "time": 0,
    "index": -1,
    "version": 0,
    "inputs": [
      {
        "prevout": {
          "hash": "2277cbd9dd1c2552f9998e6861c7fd6866b9a48fa94ec85f03697390e8fa5d4b",
          "index": 0
        },
        "witness": [
          "ef5ae8c401a69123b69da2922514ff62a76a040abb615e79453ad8172a31916c65c82ecebf15d40678b3c749411908e9aaeed1785b23789c746e5f17d11bb4c801",
          "02deb957b2e4ebb246e1ecb27a4dc7d142504e70a420adb3cf40f9fb5d3928fdf9"
        ],
        "sequence": 4294967295,
        "coin": {
          "version": 0,
          "height": 2,
          "value": 500000000,
          "address": "rs1q7qumafugfglg268djelwr7ps4l2uh2vsdpfnuc",
          "covenant": {
            "type": 0,
            "items": []
          },
          "coinbase": true
        }
      }
    ],
    "outputs": [
      {
        "value": 100000000,
        "address": "rs1q7rvnwj3vaqxrwuv87j7xc6ye83tpevfkvhzsap",
        "covenant": {
          "type": 0,
          "items": []
        }
      },
      {
        "value": 399997200,
        "address": "rs1qx38r5mjzlxfus9yx7nhx3mrg00sv75xc5mksk5",
        "covenant": {
          "type": 0,
          "items": []
        }
      }
    ],
    "locktime": 0,
    "hex": "00000000012277cbd9dd1c2552f9998e6861c7fd6866b9a48fa94ec85f03697390e8fa5d4b000000000241ef5ae8c401a69123b69da2922514ff62a76a040abb615e79453ad8172a31916c65c82ecebf15d40678b3c749411908e9aaeed1785b23789c746e5f17d11bb4c8012102deb957b2e4ebb246e1ecb27a4dc7d142504e70a420adb3cf40f9fb5d3928fdf9ffffffff0200e1f505000000000014f0d9374a2ce80c377187f4bc6c68993c561cb13600001079d717000000000014344e3a6e42f993c81486f4ee68ec687be0cf50d8000000000000",
    "confirmations": 5
  }
]

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{ "method": "<method>", "params": [...] "id": "some-id" }'

hsd-cli rpc <method> <params>

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('<method>', [ <params> ]);
  console.log(result);
})();

{"result": resultObject ,"error": errorObject, "id": passedID}

curl http://x:api-key@127.0.0.1:14037/ \
  -H 'Content-Type: application/json' \
  -X POST \
  --data '{ "method": "stop" }'

hsd-cli rpc stop

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('stop');
  console.log(result);
})();

"Stopping."

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{ "method": "getinfo" }'

hsd-cli rpc getinfo

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('getinfo');
  console.log(result);
})();

{
  "version": "0.0.0",
  "protocolversion": 70015,
  "walletversion": 0,
  "balance": 0,
  "blocks": 205,
  "timeoffset": 0,
  "connections": 3,
  "proxy": "",
  "difficulty": 4.6565423739069247e-10,
  "testnet": true,
  "keypoololdest": 0,
  "keypoolsize": 0,
  "unlocked_until": 0,
  "paytxfee": 0.0002,
  "relayfee": 0.00001,
  "errors": ""
}

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{ "method": "getmemoryinfo" }'

hsd-cli rpc getmemoryinfo

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('getmemoryinfo');
  console.log(result);
})();

{
  "total": 72,
  "jsHeap": 14,
  "jsHeapTotal": 17,
  "nativeHeap": 54,
  "external": 12
}

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "setloglevel",
    "params": [ "none" ]
  }'

hsd-cli rpc setloglevel none

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('setloglevel', [ 'none' ]);
  console.log(result);
})();

null

let address;

address='rs1q7rvnwj3vaqxrwuv87j7xc6ye83tpevfkvhzsap';

curl http://x:api-key@127.0.0.1:14037/ \
  -X POST \
  --data '{
    "method": "validateaddress",
    "params": [ "'$address'" ]
  }'

hsd-cli rpc validateaddress $address

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('validateaddress', [ address ]);
  console.log(result);
})();

{
  "isvalid": true,
  "address": "rs1q7rvnwj3vaqxrwuv87j7xc6ye83tpevfkvhzsap",
  "isscript": false,
  "isspendable": true,
  "witness_version": 0,
  "witness_program": "f0d9374a2ce80c377187f4bc6c68993c561cb136"
}

let nrequired, pubkey0, pubkey1, pubkey2;

nrequired=2;
pubkey0='02e3d6bb36b0261628101ee67abd89d678522dc1199912512f814e70803652f395';
pubkey1='03d7ded41bb871936bf4d411371b25d706c572f28ef8d2613b45392e9f9c4348a5';
pubkey2='034bc2280e68d3bdd0ef0664e0ad2949a467344d8e59e435fe2d9be81e39f70f76';

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "createmultisig",
    "params": [ '$nrequired', [ "'$pubkey0'", "'$pubkey1'", "'$pubkey2'" ] ]
  }'

hsd-cli rpc createmultisig $nrequired '[ "'$pubkey0'", "'$pubkey1'", "'$pubkey2'" ]'

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('createmultisig', [ nrequired, [ pubkey0, pubkey1, pubkey2 ] ]);
  console.log(result);
})();

{
  "address": "rs1qlt977782vv7xxy45xgp9yzhtp90v6e5az9p05q7q8d2072m77xese5xxfl",
  "redeemScript": "522102e3d6bb36b0261628101ee67abd89d678522dc1199912512f814e70803652f39521034bc2280e68d3bdd0ef0664e0ad2949a467344d8e59e435fe2d9be81e39f70f762103d7ded41bb871936bf4d411371b25d706c572f28ef8d2613b45392e9f9c4348a553ae"
}

let privkey, message;

privkey='ENced8VD7YWkzPC8FTJ3gTTq4pQhF2PF79QS51mgZq7BgCfiEP5A';
message='hello';

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "signmessagewithprivkey",
    "params": [ "'$privkey'", "'$message'"]
  }'

hsd-cli rpc signmessagewithprivkey $privkey $message

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('signmessagewithprivkey', [ privkey, message ]);
  console.log(result);
})();

"arjD5y4glPea270IiExx04E+tTvryHKhWZcA2oy8svVHr9q/AvGA647UF2ICaIGJHazbRyyj3draiNnBns9aWQ=="

let address, signature, message;

address='rs1q7qumafugfglg268djelwr7ps4l2uh2vsdpfnuc';
signature='arjD5y4glPea270IiExx04E+tTvryHKhWZcA2oy8svVHr9q/AvGA647UF2ICaIGJHazbRyyj3draiNnBns9aWQ==';
message='hello';

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "verifymessage",
    "params": [ "'$address'", "'$signature'", "'$message'" ]
  }'

hsd-cli rpc verifymessage $address $signature "$message"

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('verifymessage', [ address, signature, message ]);
  console.log(result);
})();

true

let name, signature, message;

name='handshake';
signature='arjD5y4glPea270IiExx04E+tTvryHKhWZcA2oy8svVHr9q/AvGA647UF2ICaIGJHazbRyyj3draiNnBns9aWQ==';
message='hello';

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "verifymessagewithname",
    "params": [ "'$name'", "'$signature'", "'$message'" ]
  }'

hsd-cli rpc verifymessagewithname $name $signature "$message"

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('verifymessagewithname', [ name, signature, message ]);
  console.log(result);
})();

true

let timestamp;

timestamp=1503058155;

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "setmocktime",
    "params": [ '$timestamp' ]
  }'

hsd-cli rpc setmocktime $timestamp

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('setmocktime', [ timestamp ]);
  console.log(result);
})();

null

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "pruneblockchain",
    "params": []
  }'

hsd-cli rpc pruneblockchain

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('pruneblockchain');
  console.log(result);
})();

let blockhash;

blockhash='52d7beaf4c7f392bef2744167c7f4db4bb4113b2635496edcf2d1c94128696aa';

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "invalidateblock",
    "params": [ "'$blockhash'" ]
  }'

hsd-cli rpc invalidateblock $blockhash

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('invalidateblock', [ blockhash ]);
  console.log(result);
})();

let blockhash;

blockhash='1896e628f8011b77ea80f4582c29c21b3376183683f587ee863050376add3891'

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "reconsiderblock",
    "params": [ "'$blockhash'" ]
  }'

hsd-cli rpc reconsiderblock $blockhash

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('reconsiderblock', [ blockhash ]);
  console.log(result);
})().catch((err) => {
  console.error(err.stack);
});

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{ "method": "getblockchaininfo" }'

hsd-cli rpc getblockchaininfo

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('getblockchaininfo');
  console.log(result);
})();

{
  "chain": "regtest",
  "blocks": 101,
  "headers": 101,
  "bestblockhash": "76fb75dcb6d27b167dac8c01ad9e4fc68490bd9c3515cda02a20db412bf23930",
  "treeRoot": "0000000000000000000000000000000000000000000000000000000000000000",
  "difficulty": 4.6565423739069247e-10,
  "mediantime": 1581299452,
  "verificationprogress": 1,
  "chainwork": "00000000000000000000000000000000000000000000000000000000000000cc",
  "pruned": false,
  "softforks": {
    "hardening": {
      "status": "defined",
      "bit": 0,
      "startTime": 1581638400,
      "timeout": 1707868800
    },
    "testdummy": {
      "status": "defined",
      "bit": 28,
      "startTime": 0,
      "timeout": 4294967295
    }
  },
  "pruneheight": null
}

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{ "method": "getbestblockhash" }'

hsd-cli rpc getbestblockhash

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('getbestblockhash');
  console.log(result);
})();

"498d003ecfc60ee829cdc3640dc305583057d88e2c38a7d57dbe0f92aa2bb512"

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{ "method": "getblockcount" }'

hsd-cli rpc getblockcount

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('getblockcount');
  console.log(result);
})();

98

let blockhash, details, verbose;

blockhash='76fb75dcb6d27b167dac8c01ad9e4fc68490bd9c3515cda02a20db412bf23930';
verbose=1;
details=0;

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "getblock",
    "params": [ "'$blockhash'", '$verbose', '$details' ]
  }'

hsd-cli rpc getblock $blockhash $verbose $details

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('getblock', [ blockhash, verbose, details ]);
  console.log(result);
})();

{
  "hash": "76fb75dcb6d27b167dac8c01ad9e4fc68490bd9c3515cda02a20db412bf23930",
  "confirmations": 1,
  "strippedsize": 319,
  "size": 351,
  "weight": 1308,
  "height": 101,
  "version": 0,
  "versionHex": "00000000",
  "merkleroot": "67f0c36f0a12f276cdd0feb26dacf1bb93df31b9df68c4be09c7ac8231e76794",
  "witnessroot": "c8a4848c5d4b3b669ff5642ecfc5ab146d928d174c8d708d252a635819b4ccce",
  "treeroot": "0000000000000000000000000000000000000000000000000000000000000000",
  "reservedroot": "0000000000000000000000000000000000000000000000000000000000000000",
  "mask": "0000000000000000000000000000000000000000000000000000000000000000",
  "coinbase": [
    "6d696e656420627920687364",
    "efc784672034e0ec",
    "0000000000000000"
  ],
  "tx": [
    "d43a1192315124dcddf3b59902dd6bfef9cf6bcfbb07377e1b69ab1919f99d4e"
  ],
  "time": 1581299453,
  "mediantime": 1581299452,
  "bits": 545259519,
  "difficulty": 4.6565423739069247e-10,
  "chainwork": "00000000000000000000000000000000000000000000000000000000000000cc",
  "previousblockhash": "21ff4a8264d4b23db3b6a0d870e16d5e49c2b1f8c87b9b79ea342808a2914ed0",
  "nextblockhash": null
}

let blockhash, details, verbose;

blockheight=101;
verbose=1;
details=0;

curl http://x:api-key@127.0.0.1:14037 \
  -X POST \
  --data '{
    "method": "getblockbyheight",
    "params": [ '$blockheight', '$verbose', '$details' ]
  }'

hsd-cli rpc getblockbyheight $blockheight $verbose $details

const {NodeClient} = require('hs-client');
const {Network} = require('hsd');
const network = Network.get('regtest');

const clientOptions = {
  port: network.rpcPort,
  apiKey: 'api-key'
}

const client = new NodeClient(clientOptions);

(async () => {
  const result = await client.execute('getblockbyheight', [ blockheight, verbose, details ]);
  console.log(result);
})();