The Nexa is designed for horizontal scaling and can seamlessly scale to terabyte blocks and beyond, all on modest commodity hardware.
The Xoken Nexa node is built from ground up for truly unlimited block sizes. It leverages the unique strengths of Cassandra distributed NoSQL database & Neo4j graph database.
Cassandra is a distributed wide column store database & is perfect for handling large volumes of data across many commodity servers, providing high availability with no single point of failure. The major part of Bitcoin blockchain adapts well to the denormalized model that is designed per API requirements.
Cassandra distributed database offers 'highly availability' & 'cheap writes'. Also, 'eventual consistency' is not a concern because the chain itself is eventually consistent (Nakamoto consensus).
The well-designed distributed node architecture is future-proof and allows h/w to be incrementally added to the distributed node setup.
Neo4j is a native graph database from top to bottom, with native graph storage and processing. By treating graph relationships as first-class citizens.
This speciality if leveraged for certain niche areas such as inserting Merkle trees & querying Merkle proofs efficiently. This is achieved with an innovative algorithm & data structure called the Transpose Merkle Tree (TMT).
While Neo4j is not natively distributed, when dealing with siloed data, such as Merkle trees across blocks, it virtually becomes a distributed graph database without the negative tradeoffs of the other native distributed graph DBs.
Serving SPV on high demand is now trivial with innovations such as Transpose Merkle Tree, highly parallel algorithms, invalidation free caching.
TMT is a data structure wherein interim nodes are transposed such that the walk from the leaf node to the root node essentially contains the Merkle branch/proof. This compact pre-ready data-structure can be persisted efficiently and can readily serve Merkle branches.
It includes a highly efficient algorithm to compute the TMT with only O(3 log n) space complexity (primary memory). This allows the Nexa node to potentially ingest (w/ partial validation) a Tera-byte block with a tiny memory footprint.
More importantly, a low resource server can trivially serve hundreds of Merkle proofs per minute. The Nexa node can dish out Merkle proofs for 1TB block just as easily as an 1MB block.
Haskell's lazy evaluation is exploited to implement streaming IO that can ingest an infinite stream of transactions with little RAM.
Smart algorithms & data-structures translate to a highly nimble API, yet being frugal on hardware resources, and deliver cost savings.