Promise-based client for interacting and building services on top of the Logos network
npm i @logosnetwork/logos-rpc-client
To setup a direct connection to a Logos node do the following
const LogosRPC = require('@logosnetwork/logos-rpc-client')
const logos = new LogosRPC({url: 'http://3.215.28.211:55000'})
You may also proxy your RPC calls through another server
const LogosRPC = require('@logosnetwork/logos-rpc-client')
const logos = new LogosRPC({url: 'http://3.215.28.211:55000', proxyURL: 'https://pla.bs'})
To setup a proxy server include something similar to the following in your server
app.post('/rpc', async (req, res) => {
let targetURL = req.body.targetURL
delete req.body.targetURL
const response = await axios.post(`${targetURL}/`, req.body)
res.send(response.data)
})
Simply follow the same steps are seen above and use one of the current delegates found here: delegate list sorted by their delegate id.
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.
logos.changeServer(`http://${delegateList[delegateId]}:55000`)
To enable some helpful logs, pass debug: true
as a paramater in the constructor object.
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()
await logos.account(PRIVATE_KEY).send(0.01, RECIPIENT_ADDRESS)
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)
logos.accounts.info(account: 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:
logos.transactions.info(hashOrHahes: 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)
Allows you to retrieve information on request blocks
logos.requestBlocks.history(count: string | number, delegateIndex: string | number, hash: string)
logos.requestBlocks.get(hashes: [string])
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])
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: 'http://3.215.28.211:55000', proxyURL: 'https://pla.bs'})
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.
logos.work.generate(hash: string)
logos.work.validate(work: string, hash: string)
logos.available()
logos.deterministicKey(seed: string, index?: string | number)
logos.changeServer(nodeURL: string, proxyURL?: string)
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})