Skip to content


Switch branches/tags

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time

Logos Network Logo
Logos Network

Logos RPC Client

Promise-based client for interacting and building services on top of the Logos network


npm i @logosnetwork/logos-rpc-client

Your own Logos Node

To setup a direct connection to a Logos node do the following

const LogosRPC = require('@logosnetwork/logos-rpc-client')
const logos = new LogosRPC({url: ''})

You may also proxy your RPC calls through another server

const LogosRPC = require('@logosnetwork/logos-rpc-client')
const logos = new LogosRPC({url: '', proxyURL: ''})

To setup a proxy server include something similar to the following in your server'/rpc', async (req, res) => {
  let targetURL = req.body.targetURL
  delete req.body.targetURL
  const response = await`${targetURL}/`, req.body)

Remote Logos Node

Simply follow the same steps are seen above and use one of the current delegates found here: delegate list sorted by their delegate id.

Delegate Load Balancing

When building for production you must select the proper delegate for publishing your transactions. If you do not select the proper delegate you will incur a 5 second transaction confirmation penalty. This is an incentive to load balance the requests to the 32 delegates equally.

Here is an example of how to calculate the proper delegate id given an ACCOUNT_ID.

let delegateID = null

//Check the most recent 
//on the account who wants to publish
if (accountFrontier === '0000000000000000000000000000000000000000000000000000000000000000') {
    // If the frontier doesn't exist We use the 
    // last two digits of the hexadecimal hash 
    // of the public key mod 32 to give us a 
    // random distribution
    delegateID = parseInt(publicKey.slice(-2), 16) % 32
} else {
    // When the account has a previous transaction 
    // we use the last two digits of the hexadecimal hash
    // mod 32 to give us a random distribution
    delegateID = parseInt(accountFrontier.slice(-2), 16) % 32

Once you have the delegate id you can find the delegate from the delegate list here.


Debug mode

To enable some helpful logs, pass debug: true as a paramater in the constructor object.

Working with accounts

Generate an account

It's easy to generate a new random account. You'll get the account's private and public keys along with its address.

const {privateKey, publicKey, address} = await logos.key.create()

Send funds

await logos.account(PRIVATE_KEY).send(0.01, RECIPIENT_ADDRESS)

Full list of methods

All methods return native or Bluebird promises and are fully compatible with async/await.


Account methods take a single account string or in some cases, an array of accounts.

  • logos.accounts.toAddress(publicKey: string)
  • logos.accounts.reasonBalance(account: string)
  • logos.accounts.logosBalance(account: string)
  • logos.accounts.balances(accounts: string[])
  • logos.accounts.blockCount(account: string)
  • logos.accounts.history(account: string, count?: number)
  • string)


Used for generating accounts and extrapolating public keys/addresses from private keys.

  • logos.key.create()
  • logos.key.expand(privateKey: string)


Has a method to get information about transactions:

  • string | string[], details?: boolean)

Method to construct a transaction:

  • logos.transactions.createSend(block: SendBlock)

And a method to publish a constructed block to the network:

  • logos.transactions.publish(block: string)

Request Blocks

Allows you to retrieve information on request blocks

  • logos.requestBlocks.history(count: string | number, delegateIndex: string | number, hash: string)
  • logos.requestBlocks.get(hashes: [string])

Micro Epochs

Allows you to retrieve information on micro epochs

  • logos.microEpochs.history(count: string | number, hash: string)
  • logos.microEpochs.get(hashes: [string])


Allows you to retrieve information on epochs

  • logos.epochs.history(count: string | number, hash: string)
  • logos.epochs.get(hashes: [string])

Unit Converter

Allows you to convert LOGOS amounts to and from their reason values. Reason is the smallest unit of the Logos currency.

const LogosRPC = require('@logosnetwork/logos-rpc-client')
const logos = new LogosRPC({url: '', proxyURL: ''})
let amountInReason = logos.convert.toReason('1', 'LOGOS')
import { convert } from '@logosnetwork/logos-rpc-client'
let amountInReason = convert.toReason('1', 'LOGOS')
let amountInLogos = convert.fromReason('1000000000000000000000000000000', 'LOGOS')
// Converter can also be used to convert token values
// or in this example bitcoin into satoshis
let bitcoinsInSatoshis = convert.fromTo('1', 8, 0)
// You can use the fromTo function for the example above also
amountInReason = convert.fromTo('1', 30, 0) // '1000000000000000000000000000000' Reason
amountInLogos = convert.fromTo('1000000000000000000000000000000', 0, 30) // '1' LOGOS
  • logos.convert.toReason(amount: string | number, denomination: 'LOGOS')
  • logos.convert.fromReason(amount: string, denomination: 'LOGOS')
  • logos.convert.fromTo(amount: string, currentDec: number, preferedDec: number)


Allows you to generate and validate Proof of Work for a given block hash.

  • string)
  • string, hash: string)


  • logos.available()
  • logos.deterministicKey(seed: string, index?: string | number)
  • logos.changeServer(nodeURL: string, proxyURL?: string)

Calling RPC directly

If there's a method missing, or if you prefer to call RPC directly, you can use logos.rpc. You'll still get the full benefit of type checking and return types for applicable RPC calls.

await logos.rpc('account_info', {account})


Promise-based client for interacting and building services with the Logos network







No releases published


No packages published