lotusd, the Lotus node

Technology, measured

What the Lotus node does and how fast it does it. Every figure on this page was measured on our own software, or is read from the mainnet nodes while you look at it, and each one says where it comes from.

Download lotusd See the figures

Shipped in a published release, running on our mainnet nodes From Napoleon in the code today, a network rule from 21 December 2026 12.4.17 in the next release, not published yet
A turtle swimming through a night sky of planets and stars above lotus flowers
Block height
—
Lotus mainnet
Network hashrate
—
LotusHash
Nodes in our swarm
—
— agree on the pool ledger
Node version
—
lotusd, on the node that answered

Read from the public API of the mainnet nodes as the page loads5. A dash means they could not be reached; nothing else on the page depends on them.

New in 12.4.16, running on mainnet

Released on 17 November 2026 and running on all ten of our mainnet nodes since 03:21 UTC that day. No change to the network rules: a 12.4.16 node validates, relays and mines exactly like 12.4.15, only faster.

158 ms 78 ms

Connecting a block of 6,000 transactions

Block and undo data written in one call, the UTXO set change hashed on several cores, the block’s transactions cleared from the mempool in one pass. Node without the explorer index.

Shipped Source 3 Source 10

77.5 ms 21.4 ms

Hashing the UTXO set change of that block

Up to 8 slices hashed in parallel and multiplied together. The result is bit-identical to the serial hash, so every Napoleon UTXO commitment is unchanged: the proof and the tests that compare whole states ship with the source. Writing the state to disk: 86 → 31 ms.

Shipped Source 10

444 ms 207 ms

Connecting a block of 9,700 transactions, explorer on

Explorer and module indexes are written by a worker off the validation lock, in the same order and with the same database contents. A fresh node is fully indexed 1.7 to 2.3 times sooner. Checking the scripts of that block: 18–25 ms.

Shipped Source 3 Source 1

29,900–39,500 tx/s

Signed transactions, one call per batch

sendrawtransactions takes up to 1,000 transactions: decoded, checked and verified on several threads with batch Schnorr, then admitted in one pass, optionally all or nothing. 2.2 to 2.7 times the JSON-RPC batches of the same run.

Shipped Source 3 Source 9

0.38 ms

A block template, 6,000 transactions waiting

The light template, from a cache and without the main lock: 1.9 kB in place of 3.4 MB. With 12 clients asking at once: 12,700 templates per second, against 167–313 for the full template.

Shipped Source 3 Source 9

31 ms 7.7 ms

Clearing a block’s transactions from the mempool

6,000 of 10,000 waiting transactions removed in one pass. A mined chain of 2,000 transactions that spend each other: 1,050 → 51 ms.

Shipped Source 10 Source 3

1.2 s

A UTXO snapshot from three servers

2 million unspent outputs fetched in parallel chunks, each checked against the manifest, against 4.6–5.5 s from a single server. A server that sends a bad chunk is dropped.

Shipped Source 10

1.05 ms 0.32 ms

Writing a block’s undo data

Serialized once in memory and written in one call; read back in 0.49 ms instead of 1.03. Same bytes on disk: a 12.4.15 node reads the files unchanged.

Shipped Source 10

~35/h 0

Pool links dropped for “invalid shares”, mainnet

Honest pool nodes are no longer disconnected for answering with shares that are not their own; the node that saw the most dropped about 35 links an hour before 12.4.16. Links no longer freeze when two nodes restart and catch up at once, and no block is lost across a restart.

Shipped Source 11 Source 3

Shipped

Thin share relay

A thin node, which keeps no history, can serve GPU miners with jobs from a full pool node and forward their shares to it (-thinrelay). The full nodes verify every share and keep every pool decision; a relay is never counted as a pool member.3

Shipped

SHA-256 on ARM

On 64-bit ARM processors with SHA2 instructions, SHA-256 uses them, checked against the generic code when the node starts.3

Shipped

Block selection by fee rate, opt-in

An O(N log N) selector that takes each transaction on its own fee rate, a child only after its parents (-blockselector=feerate), and chains of 500 transactions (-limitancestorcount=500). Block assembly: 130–134 ms against 136–143 ms, with the mempool lock held about half as long. Off by default until every node runs 12.4.16.3

Shipped

Pool, Node and Network views

The node’s web pages show each mining figure for a named scope, a merged hashrate of the three proofs of work with a LotusHash badge on native figures, and history kept per algorithm in SQLite.3

Throughput we measured

One node, out of the box: the explorer index and every module switched on. Every transaction carries a real Schnorr signature and goes through the same checks as on mainnet.

15,000–20,100 tx/s

Signed transactions, sent one by one

6,000 single sendrawtransaction calls from 8 clients. Median answer: 0.36–0.43 ms per call.

Shipped Source 1

58,000–87,500 req/s

Light reads, 12 clients

Chain and mempool summaries answered without taking a lock since 12.4.15, 99 % of them in under 0.35 ms. With writers running at the same time: 74,080 req/s. On 12.4.14: 18,678 req/s.

Shipped Source 2

17,200–27,600 tx/s

Signed transactions, in JSON-RPC batches

Batches of 50 to 500 over the standard JSON-RPC interface. A burst of 4,000: 19,700–26,900 tx/s. Chains of 1,000 transactions spending each other: 14,700–19,800 tx/s.

Shipped Source 1

0.1–0.2 s per hop

A burst of 500 transactions between our nodes

Down from about 2 s in 12.4.14. A single transaction crosses two hops in 0.10–0.20 s; a burst of 5,000 in 0.5–0.9 s. Peers we do not know keep a deliberate 2 s delay that protects the network against floods.

Shipped Source 2

16,000 tx/s

Syncing a chain from another node

52,611 transactions in 123 blocks validated and indexed in 3.3 s, two nodes syncing at once, on 12.4.14. Since 12.4.16 a fresh node is fully indexed 1.7 to 2.3 times sooner.

Shipped Source 1 Source 3

How it was measured. Release builds of lotusd on a private Lotus chain with mainnet's transaction format and mempool settings. One laptop, an Intel Core i9-14900HX (24 cores, 32 threads, 31 GB), which was running other builds at the same time: allow 25 % either way. Ranges are the spread over repeated runs. Signing is done beforehand and never timed.

For scale. Transactions on Lotus mainnet in the last 24 hours: —. The node's ceiling sits thousands of times above what the network asks of it today, so the work now goes into what users feel: sync time, block propagation and the slowest answers of the API. With 12 clients hammering the heaviest calls, the slowest answer went from over 1 s in 12.4.14 to under 150 ms in 12.4.152.

Validation speed

Signatures are checked in batches and on every core, before a transaction ever waits for the node's main lock.

46,765 sig/s

Schnorr signatures, one core

Verified 512 at a time. One by one: 28,972 per second. The batch is 1.6 times faster.

Source 4

134,000 inputs/s

Block scripts, 4 threads

Against 105,000 without batching. On one thread: 36,200 against 27,900.

Source 4

1.94 GB/s

SHA-256, one core

With the processor's SHA instructions, picked automatically at start: 0.52 ns per byte.

Source 4

120 ms

Assembling a block

From a mempool of about 21,000 transactions. With 92 pool miners paid in the coinbase: 123 ms.

Source 4

Shipped

Batch Schnorr verification

The Schnorr signatures of a block, and of groups of incoming transactions, are verified together with one multi-scalar multiplication (Strauss and Pippenger). A batch that fails is checked again signature by signature, so the verdict is exactly the one of serial checking.6

Shipped

Parallel mempool pre-verification

Scripts of incoming transactions are verified on several threads, outside the main lock, before they are admitted one by one by unchanged code. It makes relay admission about 1.6 times faster.1

Shipped

Signature cache in 16 shards

Threads that verify at the same time do not queue behind one lock: the cache of already-checked signatures is split into 16 independently locked parts.6

Shipped

A cold block costs little more

A block of 10,462 transactions the node has never seen, with an empty mempool and an empty signature cache: its scripts are verified in 48–57 ms on all cores.1

UTXO set and sync

A new node does not have to replay the whole history before it is useful, and it does not have to take anyone's word to skip it.

From Napoleon

The UTXO set, committed by proof of work

Every block carries in its coinbase a MuHash3072 digest of the complete set of unspent outputs (UTXOs) as of ten blocks earlier. From the Napoleon upgrade a block without it, or with a wrong one, is invalid. Since 12.4.13 a node keeps that digest up to date as blocks arrive.7

Shipped

A snapshot every 100 blocks

Full nodes write a snapshot of the UTXO set at every height that is a multiple of 100 and serve it to peers in chunks of 4 MiB. The latest on mainnet, at block 1,427,000: 6,157,472 unspent outputs in 256 MB.65

Shipped

Start from a snapshot, verify everything anyway

A node loads a snapshot, follows the tip within minutes, then re-validates the whole history in the background. Measured: a set of 1.0 million unspent outputs loaded and hashed in 3.4 s, which puts mainnet's 6.2 million UTXOs, holding about 2.09 billion XPI, at about 21 s on the same machine.6

Shipped

Thin mode

A node without the history: it proves the unspent outputs it needs from peers that serve proofs, and checks every answer against its own header chain. It comes with a thin wallet (compact block filters, BIP157/158) and can be a member of the mining pool. A thin node runs on mainnet next to our full nodes.6

Peer-to-peer network

25–32 % fewer bytes

zstd compression between nodes, on by default

Share of the traffic saved on compressed links, measured on four mainnet nodes on 16 November 2026.

Shipped Source 8

2.16 ms

To compress a block

And 0.29 ms to decompress it. A block is compressed once and the same bytes go to every peer. Peers without zstd get the plain protocol, byte for byte.

Shipped Source 4

3 peers at once

Compact block download

When the first peer is slow to send the missing transactions, a second and a third are asked in parallel. In the test where the first peer never answers, the block connects at once instead of after a 140 s timeout.

Shipped Source 6

~112 ms ~50 ms

A pool block reaching outside nodes

A block found by the pool is pushed to every peer the moment it is validated. In a race between two blocks found at nearly the same time, outside nodes kept the pool’s block 87 % of the time instead of 28 %; between our own nodes the median arrival went from 24 to 16 ms. Measured on a private test chain.

Shipped Source 6

Shipped

WebSocket and TLS on the P2P port

A node accepts peers over WebSocket on its ordinary P2P port and connects out over ws:// and wss://, with TLS 1.2 and 1.3 built into the binary. A WebSocket peer is an ordinary peer in every limit.6

Shipped

Headers pre-sync

A chain of headers is only stored once the peer has shown it carries enough work, so a node cannot be made to fill its memory or disk with cheap fake headers.6

Shipped

Introducer for nodes behind NAT

Reachable nodes introduce two nodes that are both behind a home router, so they can connect to each other directly. More links between more nodes, with no port to open.6

Shipped

Adaptive stalling timeout

During first sync the time a peer gets to deliver a block grows from 2 s up to 64 s when peers stall and shrinks back as blocks arrive. A node on a slow link stops dropping one peer after another.6

Mining

The node is the pool. There is no separate pool server, no pool wallet and no account.

Pool hashrate
—
pool FRENCHBTC
Miners
—
on the pool now
Pool blocks, 24 h
—
of — on the chain
Pool fee
—
of the block reward
Proof of workBlocks, last 720Hashrate, in LotusHash termsStatus
LotusHash (GPU)——Shipped
SHA-256d (Bitcoin ASICs)——From Napoleon
Scrypt (Litecoin ASICs)——From Napoleon

Live from the mainnet nodes5. The two merged-mining rows stay at zero until the rule activates.

From Napoleon

Merged mining with Bitcoin and Litecoin

A Lotus block can be proven by a SHA-256d or a Scrypt block header, so the same ASICs mine Lotus alongside their own chain. One parent header proves exactly one Lotus block, and the work is scaled so that one ASIC counts as one GPU: a factor of 181,000 for SHA-256d and 5 for Scrypt.7

Shipped

Stratum inside the node

Miners connect straight to a node: Stratum v1 with one listener per algorithm, a share difficulty that adapts to each machine, and Stratum over WebSocket for miners that run in a browser tab. Work is pushed; nothing polls.6

Shipped

A pool that pays in the block

Each block found pays the miners of the last shares (PPLNS) directly in its coinbase, up to 92 miners per block. The share ledger is gossiped between the nodes over the P2P network and kept in SQLite; no node holds anyone's Lotus.6 The pool, live

Shipped

Templates for outside pools

A template server over NNG answers from a cache, without assembling a block or taking the main lock. Through its public listener, someone else's stratum server can join anonymously and its miners become full members of the same payout.6

Shipped

One GPU miner, one desktop app

The Lotus Miner app is published for Windows, macOS and Linux, its command-line miner for Linux. Since 12.4.16 one binary and one container image serve NVIDIA and AMD cards, chosen with --backend, and nothing is mined to a built-in address: without your own address the miner stops and says how to give one. AMD has not been tested on real hardware yet: we had no AMD card.3

Taproot

1,189,225 block

Taproot is valid on mainnet since 21 December 2025

Pay-to-Taproot outputs have been part of the consensus rules since that block, with the Second Samuel upgrade.

Shipped Source 3

lotus_J… addresses

Taproot addresses everywhere

Since 12.4.16: create, receive on and spend from a Taproot address in the node wallet and the web wallet (path m/86'/10605'/0'/0/i, same recovery phrase), mine to one solo or on the pool, and read it in the explorer and the GPU miner. Legacy addresses stay the default; Taproot is a choice.

Shipped Source 3

A platform in one binary

Indexes, API, explorer and wallet are part of the node. There is no second service to install and keep in step.

Shipped

Chain modules

The node indexes the protocols that live on the chain as it validates: SLP and ALP tokens, the eMPP transport, RANK votes (the Social pages), POKR and BLOB. Each has its own SQLite database.6

Shipped

Explorer on SQLite

Blocks, transactions, addresses, balances and history are indexed in SQLite by the node itself. The explorer of this site is that index, read live.6

Shipped

REST API with OpenAPI

Every node serves /api/v1, described by an OpenAPI 3.1 document at /api/v1/openapi.json, plus a push feed over WebSocket. API reference6

Shipped

Dashboard and wallet, embedded

The node serves its own dashboard and a wallet that installs as an app on a phone or a desktop, under one navigation. Keys are created and used for signing in the browser and never leave the device.6

Shipped

A web wallet, hosted

The same wallet, served by our nodes for anyone: open the web wallet. Non-custodial: back up your 12 words, they are the only copy.

Releases

Shipped

Binaries for every desktop system

Version … is public for Linux, Windows and macOS: the node and its tools, the GPU miner and the Lotus Miner app, with a SHA256SUMS file. Downloads

Shipped

Container images

The same versions as public images: ghcr.io/lotusdevorg/lotusd, the tools and the GPU miner, each tagged with the version, its line and latest.6

Shipped

Built and tested by CI

Every release is built for the three systems by the same pipeline that runs the unit and functional tests; the whole functional suite runs every night.6 Release notes are public with each version.

Coming in 12.4.17

In preparation, not released. What is below is what the code and its notes say today; figures are projections until the release is measured.

12.4.17

Pool traffic between our nodes: about −94 %, projected

Pool gossip is almost all of the traffic between our nodes, and most of it repeats jobs and shares the other node already holds. A node will say what it holds before a catch-up, send a new job as the few bytes that changed, and stop asking for a catch-up at every pool block. Same ledger, same digest; 12.4.15 and 12.4.16 nodes keep receiving whole jobs.12

12.4.17

Node state in one SQLite database

Mempool, address book, bans and anchors move from flat files into node.sqlite. The mempool is saved every 15 minutes instead of only at a clean shutdown, and a crash in the middle of a save leaves the previous one whole.12

12.4.17

Berkeley DB removed

Wallets are SQLite only. An old wallet.dat is converted the first time it is opened, record for record and checked, encrypted keys staying encrypted; the original is kept beside it, untouched.12

12.4.17

One thin mode, and a pool database without pauses

In progress: the thin-mode variants unified into one, and the pool database cleaned up in short steps instead of an hourly pause that could hold back the node. Both are on development branches, not yet in the release.12

Sources

Nothing on this page is an estimate unless it says so. Each number points to one of these.

  1. Benchmark of 16 November 2026, lotusd 12.4.14. Release build on Lotus regtest, -checkmempool=0 as on mainnet, signed Schnorr pay-to-public-key-hash transactions, 8 client processes on persistent connections, 1 to 3 repetitions per configuration. Intel Core i9-14900HX laptop, load average 5 to 10 from other work.
  2. Measurements of lotusd 12.4.15 with the benchmark kit shipped in the source tree (contrib/bench/), same machine, and the 12.4.15 release notes (relay between fleet nodes, lock-free reads, slowest answers).
  3. lotusd 12.4.16 release notes, published 17 November 2026: block storage and UTXO set hashing, asynchronous indexer (regtest, same binary with -asyncindex=0 and 1), batch submission and light templates, pool fixes, thin share relay, Taproot addresses, one GPU miner.
  4. lotus-bench, the node's own micro-benchmark program, 12.4.14 release build, same machine, one core unless stated.
  5. The public API of the mainnet nodes, read by your browser: /api/v1/stats/cards, /node, /pool-public/summary, /mining/network, /utxo-snapshots and /network/peers on givelotus.org.
  6. The lotusd documentation, shipped with the source of version 12.4.15: utxo-snapshot.md, thin-mode.md, p2p-zstd.md, p2p-websocket.md, stratum.md, browser-miner.md, pool-payouts.md, nng-public.md, pool-nng-bridge.md, api-v1.md, wallet-pwa.md, ci.md, protocols/ and the list of changes in FORK.md; and the release notes of each version.
  7. The Napoleon rules: the Napoleon page and the 12.4.13 release notes. Activation when the chain's median time reaches 21 December 2026, 20:50 UTC.
  8. zstd saving. For each peer that compresses in both directions, a node counts the bytes compression saved. The figure is saved bytes divided by what the traffic would have been without compression, over those links, since the node last started. Read on four mainnet nodes on 16 November 2026: 25.0 %, 31.3 %, 31.7 % and 31.9 %. When the nodes can be reached, the page shows the value of the node that answers you.
  9. Measurements of 16 November 2026 for 12.4.16 (batch submission, light block template): regtest, signed transactions, 8 client processes, 12 readers for the template, same laptop under heavier load (load average 15 to 29). Each figure is compared with the old path in the same run. Summarised in the 12.4.16 release notes; the kit is contrib/bench in the source.
  10. The list of changes of lotusd 12.4.16 (doc/FORK.md at tag v12.4.16, rows “Batched block and undo I/O”, “UTXO set hash in parallel slices” with its proof of equality, “Bulk mempool removal on block connect”, “Parallel multi-server snapshot download”): lotus-bench and the block benchmark of contrib/bench without the explorer index, regtest, same laptop, allow 25 %.
  11. Measurement on our ten mainnet nodes, 17 November 2026, during and after the 12.4.16 rollout: pool peer disconnections for invalid shares per hour, per node, before and after; links of restarted nodes.
  12. lotusd 12.4.17 in preparation: its draft release notes on the release/12.4.17 branch (node state in SQLite, Berkeley DB removed, pool gossip) and doc/pool-job-delta.md, whose traffic measurements of 16 November 2026 give the projection (job deltas and catch-up dedup applied to the measured byte shares; not a measurement of 12.4.17); development branches for the unified thin mode and the pool database clean-up.