Open Source · MIT Licensed

Private transactions.
Instant finality.

NexaFlow is a next-generation cryptocurrency that keeps your financial life private. Confidential amounts, unlinkable payments, and sub-5-second finality — all powered by Cython-optimized cryptography and Byzantine-fault-tolerant consensus.

Get Started Learn More ↓
~1,000 TPS throughput
< 5s Finality
940+ Tests passing
100B NXF supply
Why NexaFlow

Built for the real world

Every piece of NexaFlow was designed with practical, everyday use in mind — from the cryptography all the way up to the developer experience.

Confidential Transactions

Transaction amounts are hidden behind Pedersen commitments and verified with zero-knowledge range proofs. Nobody can see how much you sent or received.

Instant Finality

The RPCA consensus algorithm provides deterministic finality in under 5 seconds. No more waiting for block confirmations — your transaction is final, period.

Ring Signatures

LSAG ring signatures let you prove authorization without revealing which key actually signed. Your identity stays hidden in a crowd of decoys.

Stealth Addresses

Every payment generates a unique one-time address. Even if someone knows your public key, they can't link your transactions together on-chain.

High Performance

Core cryptographic operations are compiled to native C via Cython. The result: ~5,000 range proofs per second and ~1,000 transactions per second on commodity hardware.

Trust Lines & DEX

Issue IOUs, set credit limits, and trade across currencies with the built-in decentralized exchange and multi-hop payment path finding.

Privacy

Your money. Your business.

NexaFlow was built from scratch with privacy at its core — not bolted on as an afterthought. Here's what happens when you send a confidential payment.

1

Stealth Address Derivation

The sender derives a unique one-time address from the recipient's public view and spend keys. This address appears only once on the ledger and can't be linked back to the recipient.

2

Amount Commitment

The payment amount is sealed inside a Pedersen commitment: C = v·G + b·H. Validators can verify the math checks out without ever knowing the actual value.

3

Range Proof

A zero-knowledge range proof proves the committed amount is non-negative. This prevents anyone from creating coins out of thin air while keeping the amount completely hidden.

4

Ring Signature

The sender signs the transaction using an LSAG ring signature over a set of decoy public keys. Nobody can tell which member of the ring is the actual signer.

5

Key Image & Broadcast

A deterministic key image prevents double-spending without revealing who spent. The transaction is broadcast to the network, validated, and included in the next consensus round.

What the world sees

A one-time address, a commitment (not an amount), a valid proof, and a ring signature. That's it. No sender identity, no recipient identity, no transaction amount — just cryptographic proof that everything adds up.

Tokenomics

Designed to hold value

NXF uses a deflationary fee-burning model. Every transaction permanently reduces the supply, while staking interest is the only way new coins enter circulation.

Supply Mechanics

100 billion NXF Minted at genesis — one-time initial supply
Fee Burning Every transaction fee is permanently destroyed
Interest Minting Staking rewards are newly minted when positions mature
No Other Minting No block rewards, no inflation schedule, no admin mint

Economic Dynamics

  • ↓
    Deflationary pressure

    Every transaction shrinks the total supply through fee burning. Higher network activity means faster deflation.

  • ↑
    Inflationary pressure

    Staking interest adds new coins. The rate adjusts dynamically based on how much NXF is staked network-wide.

  • ↔
    Self-balancing equilibrium

    Under normal activity, burn rate exceeds minting — making NXF structurally deflationary over time.

Staking

Earn while you hold

Lock your NXF to earn interest. Longer commitments mean higher yields — and the dynamic multiplier adjusts rates based on network demand.

Flexible No lock
2%

Base APY

  • Withdraw any time
  • No penalty
  • Compound manually
30 Days 30-day lock
5%

Base APY

  • Higher base yield
  • Early cancel available
  • Penalty decreases over time
Popular
90 Days 90-day lock
8%

Base APY

  • Great risk/reward balance
  • Dynamic multiplier up to 2×
  • Early cancel with time decay
180 Days 180-day lock
12%

Base APY

  • Premium returns
  • Longer commitment bonus
  • Reduced penalty at maturity
365 Days 1-year lock
15%

Base APY

  • Maximum yield tier
  • Up to 2× demand multiplier
  • Strongest network security

Dynamic APY: Base rates are scaled by a demand multiplier (0.5×–2×) based on the network staking ratio. When fewer tokens are staked, the multiplier rises to attract capital. Target staking ratio: 30%.

Under the Hood

Serious engineering

NexaFlow is built on proven cryptographic primitives and a clean, auditable codebase. Here's what powers it behind the scenes.

RPCA Consensus

Byzantine-fault-tolerant consensus inspired by the Ripple Protocol Consensus Algorithm. Validators propose, vote with escalating thresholds (50% → 80%), and finalize — typically in 2–4 seconds.

n ≥ 3f+1 validators · round-robin leader · equivocation detection

Cython Core

Performance-critical modules — cryptography, transactions, ledger state, consensus, and privacy primitives — are written in Cython and compiled to native C for maximum throughput.

crypto_utils.pyx · transaction.pyx · ledger.pyx · privacy.pyx

secp256k1 Cryptography

All digital signatures use the same elliptic curve as Bitcoin. ECDSA for authentication, Pedersen commitments for amount hiding, and BLAKE2b-256 for all hashing.

ECDSA · Pedersen · LSAG · Bulletproofs · BLAKE2b

Mutual TLS Networking

Peer-to-peer communication is secured with mutual TLS authentication. Each node presents a certificate tied to its validator identity, preventing MITM and Sybil attacks.

mTLS · JSON-over-TCP · gossip protocol · rate limiting

REST API

Every node exposes a full HTTP API built on aiohttp. Submit transactions, query balances, inspect the order book, and manage staking — all through clean REST endpoints.

aiohttp · API-key auth · CORS · token-bucket rate limits

SQLite Persistence

Ledger state is durably stored in SQLite with optional in-memory mode. The storage layer handles accounts, trust lines, closed ledgers, and confidential outputs.

accounts · trust lines · UTXO index · key images · ledger headers
Developer Experience

Simple, readable Python

NexaFlow's API is designed for humans. Create wallets, send confidential payments, and scan for incoming funds in just a few lines of code. The heavy cryptography happens in Cython under the hood.

  • Type-hinted, well-documented API
  • 940+ tests across 31 modules
  • Works with Python 3.9–3.13
  • PyQt6 desktop GUI included
confidential_payment.py 
from nexaflow_core.wallet import Wallet
from nexaflow_core.ledger import Ledger

# Create wallets
sender    = Wallet.create()
recipient = Wallet.create()

# Initialize ledger
ledger = Ledger(
    total_supply=100_000_000_000.0,
    genesis_account="rGenesis"
)
ledger.create_account(sender.address, 1_000.0)

# Send a confidential payment
tx = sender.sign_confidential_payment(
    recipient.view_public_key,
    recipient.spend_public_key,
    amount=50.0,
    fee=0.001,
)
ledger.apply_payment(tx)

# Recipient scans for their outputs
found = recipient.scan_confidential_outputs(ledger)
# Only the recipient can see the amount
Quick Start

Up and running in minutes

NexaFlow runs on any system with Python 3.9+ and a C compiler. Clone, install, and launch your first node.

1

Clone & Install

git clone https://github.com/nexaflow-ledger/nexaflow-src.git
cd nexaflow-src

python -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"
python setup.py build_ext --inplace
2

Run a Node

python run_node.py --node-id alice --port 9001

That's it. You've got a validator node running locally with the interactive CLI.

3

Launch a Test Network

# Two-node network
./scripts/start_both.sh

# Or use Docker for a three-node cluster
make docker-up
4

Use the API

curl http://localhost:8080/status
curl http://localhost:8080/balance/rAliceAddress
curl -X POST http://localhost:8080/tx/payment \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_KEY" \
  -d '{"to": "rBob", "amount": 100}'
View on GitHub Full Documentation Read the White Paper
Roadmap

What's next

Phase 1 — Foundation

Core Protocol

Cython-optimized cryptography, RPCA consensus, confidential transactions, trust lines, DEX engine, staking, wallet encryption, REST API, Docker deployment, 940+ tests.

Completed
Phase 2 — Launch

Genesis & Validator Onboarding

Public genesis event, initial validator set, official desktop and CLI wallets, security audit, and comprehensive developer documentation.

In Progress
Phase 3 — Growth

Ecosystem Expansion

Mobile wallets, exchange listings, analytics tooling, enhanced DEX features, and community governance proposals.

Planned
Phase 4 — Scale

Advanced Features

Sharding for horizontal scalability, private smart contracts, cross-chain bridges, and institutional-grade APIs.

Planned

Ready to build with NexaFlow?

Join the community, run a node, and help shape the future of private digital payments.

Get the Code Contribute