FabricX Quickstart: 4-Party Arma BFT in chaindeploy
Written by David Viejo
FabricX, the next-generation Hyperledger Fabric architecture, replaces the monolithic peer with independently scalable microservices and swaps Raft consensus for Arma BFT. Initial benchmarks from the Linux Foundation Decentralized Trust (April 2026) clock the Fabric-X ordering service at 400,000+ TPS with a 4-party, 4-shard deployment. That throughput unlocks workloads classic Fabric never could touch — high-frequency tokenization, real-time payments, market-data ledgers. The catch? The setup is genuinely hard. Eight microservices, four parties, mutual TLS everywhere, an Arma genesis block, and a Postgres committer database — all wired up correctly before the first transaction.
chaindeploy automates that wiring. The quickstart card spins up the canonical 4-party FabricX network, generates all certs, writes the genesis block, and joins every node — in roughly 60 seconds.
TL;DR: chaindeploy's FabricX quickstart provisions a 4-party Arma BFT network in under a minute — 4 organizations, 4 orderer groups, 4 committers, and the genesis block. Same architecture as Fabric-X's 400,000+ TPS benchmark (Linux Foundation Decentralized Trust, 2026), on your laptop.
If you're new to FabricX itself, our What Is Fabric-X guide covers the architecture changes. This post is the hands-on companion: what the quickstart actually does, screen by screen.
Prerequisites: This guide assumes you already have ChainLaunch running locally or on a VPS. If you don't, our installing ChainLaunch on a Hetzner VPS with deploy.sh walkthrough takes a clean Ubuntu box to a TLS-secured dashboard in under 5 minutes — and the same script works on macOS or local Linux for evaluation.
The chaindeploy FabricX quickstart provisions a complete 4-party Arma BFT committee in a single click. Each party runs its own orderer group (4 microservices: router, batcher, consenter, assembler) plus a committer node, totaling 17 containers behind the scenes — a topology that matches the FabricX integration tests shipped in pkg/nodes/fabricx/fabricx_integration_test.go. Compare that to the classic Fabric Raft ceiling of around 3,500 TPS (ACM, 2024), and the architectural payoff becomes clear.
I've stood up FabricX networks the manual way — generating certs with cryptogen-x, hand-rolling Arma genesis configs, writing docker-compose files for 17 services. It's a full afternoon of YAML if everything goes right, longer if it doesn't. The quickstart compresses that into a form you fill out in 30 seconds.
Here's the sidebar Quick Start view in chaindeploy, with cards for Hyperledger Besu, classic Hyperledger Fabric, and FabricX (MVP) marked PREVIEW:
The FabricX card spells out exactly what gets created: 4 organizations (Party1–Party4 MSP), 4 orderer groups + 4 committers, and a fully formed genesis block with all nodes joined. No optional steps, no manual cert wrangling.
Free resource
87% of Blockchain Projects Die Before Production — Readiness Scorecard
Score your project across 5 dimensions: infrastructure, key management, monitoring, DR, and team readiness. Know exactly where the gaps are before they kill your timeline.
Click the FabricX card on the Quick Start dashboard, or navigate directly to /networks/fabricx/quickstart. According to the Hyperledger Foundation's 2025 Annual Report, Fabric remains the most-deployed enterprise blockchain framework at over 35% of permissioned networks — and FabricX is positioned as the throughput-focused successor most enterprises will eventually migrate to.
The quickstart page presents a single, opinionated form:
Three decisions to make:
Network name — defaults to fabricx-quickstart. Pick something memorable; this becomes the directory name on disk.
Topology — Single MSP or Multi-MSP. Single MSP means one organization owns all 4 Arma parties (easiest for development). Multi-MSP means 4 distinct organizations form the BFT committee (closer to production).
Local development mode — leave checked on macOS or Windows with Docker Desktop. It rewrites the genesis block to use host.docker.internal so containers can reach each other.
The base port (default 21080) and Postgres host port (15437) are pre-filled to avoid collisions with classic Fabric peers running on standard ports. Click Provision 4-party network and chaindeploy executes the entire pipeline.
chaindeploy's FabricX quickstart enforces the canonical 4-party Arma committee shape because BFT consensus requires f = (n-1)/3 faulty parties tolerated. With 4 parties, the network survives 1 byzantine failure — the minimum for byzantine fault tolerance. Per the Hyperledger Foundation (2024) survey, 61% of enterprise blockchain deployments now run BFT consensus in production, up from 38% in 2022 (full breakdown in our consensus mechanisms comparison).
For each of the 4 parties, chaindeploy runs five stages: organization creation, orderer-group provisioning, committer provisioning, network genesis, and node-join. The same pipeline, executed manually, takes most teams days to weeks (IDC FutureScape, 2024) — and only 25% of blockchain proofs-of-concept ever reach production, with operational complexity cited as the top failure mode.
Here's the actual sequence chaindeploy runs, distilled from the quickstart source at chaindeploy/web/src/pages/networks/fabricx/quickstart.tsx:
Ensure organizations exist — Party1MSP through Party4MSP (or a single AcmeMSP for single-MSP mode). Generates root and TLS certs with EC P-256 keys.
Create orderer groups (stage 1) — for each party, certs and configs generated, but containers not started yet. Each group includes router, batcher, consenter, and assembler microservices.
Create committer nodes (stage 1) — Postgres database + committer process per party. Certs generated, no containers running.
Create the FabricX network — produces the Arma-consensus genesis block, encoding all 4 orderer groups, all 4 committers, channel name (arma), and on-chain namespace policies.
Join each of the 17 nodes — writes the genesis block to each node's data directory, then starts containers in dependency order.
Endorsement in FabricX is handled by token-sdk-x, not by chaindeploy-managed nodes. The quickstart provisions orderer groups + committers only — the endorser layer is your responsibility.
Once provisioning completes, you land on the network detail page. Here's what gammanet (one of my test networks) looks like:
The summary tiles tell the story at a glance: chain height, transaction count, total nodes broken down by role, and namespace count. The network topology section below lists every orderer-group microservice (router, batcher, consenter, assembler — 4 of each, one per party) plus the committer.
FabricX collapses classic Fabric's multi-channel isolation into a single channel with on-chain namespaces. According to the Linux Foundation Decentralized Trust (April 2026), this single-channel-with-namespaces model is what lets the Fabric-X ordering service hit sustained throughput of 100,000+ TPS at sub-2-second end-to-end latency — multi-channel topologies couldn't share Arma's batched consensus pipeline efficiently.
A namespace is a cryptographic boundary inside the channel. Each namespace has its own submitter organization, its own chaincode binding, and its own access policy. Two namespaces in the same FabricX channel can't read or write each other's state — same isolation guarantee classic Fabric used separate channels to provide, but without the operational overhead of running separate orderer sets per channel.
To create a namespace, click the Namespaces tab on a FabricX network detail page:
The list shows every namespace on the channel, with submitter org, on-chain status, and creation timestamp. Click + Create namespace to launch the create dialog:
Three fields:
Namespace name — lowercase, hyphenated. Becomes part of every state key written under this namespace (e.g., supply-chain/asset:abc123).
Submitter organization — picks the MSP whose identity signs the namespace-create transaction. Only that org's clients can later add chaincode bindings to this namespace.
Wait for finality — checked by default. The dialog stays open until Arma consensus commits the create-namespace transaction across all 4 parties.
Click Create. chaindeploy submits the namespace-create envelope through the chosen organization's signing identity, the Arma orderer batches and orders it, and within a couple of seconds the new namespace appears in the list with status COMMITTED.
Free resource
87% of Blockchain Projects Die Before Production — Readiness Scorecard
Score your project across 5 dimensions: infrastructure, key management, monitoring, DR, and team readiness. Know exactly where the gaps are before they kill your timeline.
The 4-party quickstart network is meant for development, integration tests, and benchmarking — not production. According to enterprise blockchain market research (2025), the enterprise blockchain market is projected to reach $145.9 billion by 2030 at a 47.4% CAGR — and FabricX is positioned to capture the high-throughput slice that classic Fabric can't reach.
Three concrete next steps once your network is up:
Wire up token-sdk-x — FabricX relies on token-sdk-x for endorsement. Point it at the 4 orderer routers (default ports 20000, 20100, 20200, 20300) and the 4 committers. The fabric-smart-client sample apps work against single-MSP setups out of the box.
Create per-workload namespaces — instead of running one monolithic chaincode, split your domain into namespaces (e.g., payments, supply-chain, kyc). Each namespace gets independent access policies and chaincode bindings, while sharing the channel's Arma ordering throughput.
Stress-test against the quickstart shape — once your namespaces are wired, hammer the network with the load generator that ships with fabric-smart-client. The 4-party shape is the same one used in IBM Research's Arma paper, so your numbers stay comparable to published benchmarks.
You can see all FabricX nodes across networks from the chaindeploy nodes page, filtered to the FabricX tab:
Every node carries a status pill (RUNNING in green), its party number, MSP, role, and host port. Click any node for logs, container details, or to stop/restart.
FabricX decomposes the monolithic Fabric peer into separate microservices (router, batcher, consenter, assembler, committer), replaces Raft consensus with Arma BFT, and uses on-chain namespaces instead of multi-channel isolation. Classic Fabric peaks around 3,500 TPS on Raft; FabricX has been benchmarked at 400,000+ TPS with 4 parties and 4 shards (Linux Foundation Decentralized Trust, 2026).
FabricX is in MVP/preview state — chaindeploy explicitly labels its quickstart card "PREVIEW". The Hyperledger Foundation incubates it alongside classic Fabric, and the April 2026 roadmap targets ultra-scalability use cases. Use it today for development, benchmarking, and pilots — not yet for regulated production workloads where classic Fabric remains the safer choice.
Arma BFT requires at least 3f + 1 nodes to tolerate f byzantine failures. Four parties is the smallest committee that survives one byzantine failure — the minimum for meaningful BFT. The Hyperledger Fabric-X paper (2026) reports peak throughput at 4 parties with 4 shards, making this shape both the minimum-viable and the throughput-optimal configuration for evaluation.
Yes. Uncheck Local development mode on the quickstart form. With it unchecked, chaindeploy uses your machine's external IP in the genesis block instead of host.docker.internal. On Linux, where containers can reach the host directly, this is the correct setting. On macOS or Windows running Docker Desktop, leave it checked.
Each namespace acts as an isolation boundary for one or more chaincodes. The submitter organization signs the namespace-create transaction, then binds chaincode definitions to the namespace via separate transactions. Reads and writes against state keys within a namespace are isolated from other namespaces — the same effect as classic Fabric's multi-channel pattern, without the operational cost of running separate orderer sets per channel.
The chaindeploy FabricX quickstart turns a multi-hour manual setup into a 60-second click. You get a complete 4-party Arma BFT network with all 17 microservices wired correctly, a genesis block already on disk, and a UI for creating namespaces against the running channel. That's the same network shape used in IBM Research's Arma benchmarks, the same shape pkg/nodes/fabricx/fabricx_integration_test.go exercises, and the same shape you'd ship to a staging environment.
Three things to do next:
Walk through the quickstart yourself at localhost:3100/networks/fabricx/quickstart after chainlaunch serve
Compare the throughput your laptop hits against the Arma published benchmarks — even a quickstart deployment runs the real Arma consensus, so the numbers are honest
87% of Blockchain Projects Die Before Production — Readiness Scorecard
Score your project across 5 dimensions: infrastructure, key management, monitoring, DR, and team readiness. Know exactly where the gaps are before they kill your timeline.
