Node.js Nano Node

Partial (light, leech) Node for Nano currency (Formerly Raiblocks) for Node.js.

Examples:

• Pending: How to listen for new pending blocks on a specific account
• Receive: How to publish a block
• Pull: How to fetch an account blockchain history
• Votes: How to listen for representative votes
• State Blocks: How to listen for state blocks

Table of Contents

• Installation
• class NanoNode extends EventEmitter
  • Events Emitted
  • Properties
  • constructor(port)
  • publish(msg, accountKey, callback)
  • fetchAccount(publicKey, callback)
  • Static parseMessage(buf, minimalConfirmAck)
  • Static renderMessage(msg, accountKey)
  • Static keyFromAccount(account)
  • Static accountFromKey(key)
  • Static accountPair(seed, index)

Installation

npm install --save nano-node

class NanoNode extends EventEmitter

Events Emitted

Properties

May be set after construction.

constructor(port)

• port <Integer> Optional, random if unspecified

Create a new listening UDP service.

publish(msg, accountKey, callback)

• msg <Object> Required, message definition, supports types keepalive, publish, confirm_req. May also pass fully rendered messages as Buffer.
• accountKey <String> If publish message and no signature provided, pass account private key as hex string for block signing.
• callback <Function> Optional, callback function

Publish a message to known peers. Known peers are managed automatically. Upon receiving a message, the peer is added to the top of the list. Up to maxPeers peers are kept.

Returns only on publish and confirm_req messages: hex block hash

Publishing regular keepalive messages is important to continure receiving messages:

const NanoNode = require('nano-node');
const node = new NanoNode();
setInterval(() => {
  console.log('Sending keepalive to ', node.peers.length, 'peers...');
  node.publish({type: 'keepalive'});
}, 30000);

Message Properties

Publish Body Object Properties

fetchAccount(publicKey, callback)

• publicKey <String> Required, account public key to fetch block history
• callback <Function> error, result

Connect to known peers over TCP and send a bulk_pull message for a single account. Wait until timeout from tcpTimeout property, then determine the longest valid chain returned.

Without a full lattice database, the balance of an account can not be determined unless the frontier block is a send block.

Result object properties:

Static parseMessage(buf, minimalConfirmAck)

• buf <Buffer> Required, full UDP message
• minimalConfirmAck <Boolean> Optional, default: true. Only parse account value of vote (confirm_ack) messages

Returns an object with the properties of the message

Static renderMessage(msg, accountKey)

Useful for obtaining a block's hash without publishing it yet.

• msg <Object> Required, message properties as described above
• accountKey <String> Required to sign blocks for publish, confirm_req messages, otherwise provide signature property

Returns an object { message: <Buffer>, hash: <String|null> } hash is block hash if available

Static keyFromAccount(account)

• account <String> Required, account address to convert

Return the public key for a given address

Static accountFromKey(key)

• key <String> Required, public key to convert

Return the address for a given account public key

Static accountPair(seed, index)

• seed <String|Buffer> Required, wallet seed as 32 byte Buffer or 64 character hex string
• index <Number> Required, 32-bit unsigned integer specifying account index

Returns an object {privateKey: <String>, publicKey: <String>, address: <string>}

License

MIT