Core Platform · V12 (V11 API) · The Hyperscalable, Miningless Decentralized Blockchain for RWAT · status as of 2026-10-20
Aurigraph DLT is an enterprise, permissioned distributed-ledger platform for tokenizing real-world assets (RWA) and running programmable Active Contracts against them, with a post-quantum-hardened cryptographic posture and a first-class integration SDK. It combines a HyperRAFT++ CFT Raft consensus engine backed by a memory-mapped Write-Ahead Log (today running in SIMULATE mode on a single application node — real multi-node consensus is planned, see §2.2), embedded RocksDB ledger stores, and a NIST Level 5 post-quantum cryptographic layer (ML-DSA-87 signatures, ML-KEM-1024 key encapsulation) built on BouncyCastle 1.86. The platform exposes a REST surface on port 9003 and a gRPC/HTTP2 surface on port 9004, returns RFC 7807 structured errors, and authenticates its enterprise portal through Google OAuth (primary) with a Keycloak fallback. This paper describes the architecture, the cryptographic design, the tokenization and Active-Contracts model, the security and compliance posture, and the developer platform — and is explicit about which figures are engineering targets versus measured behavior.
SIMULATE
Enterprises that want to represent assets, credits, and instruments on a ledger face a recurring set of obstacles that general-purpose public blockchains do not solve well:
Aurigraph DLT is designed as a compliant, auditable substrate for exactly these needs. It is a permissioned ledger: validators and business nodes are enrolled, consensus is reached across a known network, and every value-changing operation is gated by an explicit authorization model. The remainder of this paper walks through how each layer addresses the problem above.
Aurigraph V12 is a Quarkus 3.27 application on Java 25, organized under the io.aurigraph.v11 package namespace. All REST endpoints live under /api/v11/*.
io.aurigraph.v11
/api/v11/*
┌───────────────────────────────────────────────────────────┐ │ Clients Enterprise Portal (React 19 / Vite 7) · SDK │ └───────────────────────────────────────────────────────────┘ │ HTTPS ┌───────────────────────────────────────────────────────────┐ │ Edge NGINX gateway (TLS; /api/v11/* → backend, / → SPA)│ └───────────────────────────────────────────────────────────┘ │ ┌───────────────────────────────────────────────────────────┐ │ V12 Quarkus backend (io.aurigraph.v11) │ │ API JAX-RS /api/v11/* · gRPC services :9004 │ │ Auth Google OAuth (primary) · Keycloak (fallback) │ │ SDK API-key filter + scope checker + tier/quota │ │ Domain registry · nodes · RWA · Active Contracts · SDK │ │ Consensus HyperRAFT++ → log replication → WAL │ │ Crypto QuantumCryptoService (real PQC) · PqcWallet │ │ Storage PostgreSQL + Redis · embedded RocksDB (×3) │ └───────────────────────────────────────────────────────────┘ │ │ │ Battua (gRPC) QVAPT quantum-os OpenBao KMS canonical crypto (QRNG sidecar, off) (AppRole secrets)
The consensus engine is HyperRAFTConsensusService ("HyperRAFT++"), a RAFT-derived engine hardened for crash-fault tolerance (CFT). In production it currently runs in SIMULATE mode (aurigraph.consensus.mode=SIMULATE): one application node, votes not cast by independent validators, and this is disclosed on the public API. It composes four collaborators:
HyperRAFTConsensusService
aurigraph.consensus.mode=SIMULATE
LeaderElection
buildSignedVote
isVoteAuthentic
LogReplication
nextIndex
n/2 + 1
ConsensusMetrics
On a value proposal, entries are replicated across followers, then persisted to the Write-Ahead Log (WAL writes occur after replication), then metered.
Honesty note. An earlier class, QuantumConsensus, was a simulation scaffold whose "signatures" were byte-length placeholders. It has been removed from the production source (AV11-3553). Consensus-layer post-quantum signing is now real code but not yet active: ML-DSA-87 signing of every replicated Raft log entry is merged (AV11-3757) and dormant while production consensus runs in SIMULATE mode, and vote signatures run in dual-accept phase (Ed25519 still accepted). See §3.
QuantumConsensus
Planned real consensus (AV11-3775, SPEC-CONSENSUS-REAL-001 S3–S6). The design that replaces SIMULATE commits on a quorum of q = ⌈2N/3⌉ validators, with N ≥ 7 and odd in production. Validators are deliberately lightweight — mobile-class processes with a RocksDB store, many of which can run inside one native Quarkus/GraalVM container for test and evaluation — and in production at most f = ⌊(N−1)/3⌋ validators of a channel may share a failure domain, so no single host, rack or region can hold a blocking minority. This is a plan, not shipped behaviour.
The WAL (consensus.wal.*) provides crash-safe durability with a design tuned for throughput:
consensus.wal.*
MemoryMappedWalFile
MappedByteBuffer
ParallelFlushManager
CommitBatcher
RecoveryManager
WalReader
WalCompactionService
Aurigraph persists state across two tiers:
V229
@Entity
V12
Flyway is the sole schema authority — Hibernate DDL generation is disabled in every profile. The three embedded RocksDB stores are the node store (per-nodeId directory, path-traversal-guarded), the wallet store (per-process, wallet transaction history), and the validator-state store (per-process, column-family layout, default off). Because these stores are node-local, each instance requires its own persistent volume.
nodeId
:9003
application/problem+json
type
title
status
detail
instance
errorCode
traceId
requestId
:9004
Aurigraph's target is that every public-key operation uses NIST FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) or FIPS 205 (SLH-DSA), at NIST Category 5 by default, and that every classical algorithm still in use is a named exception. Status as of 2026-10-20:
dlt.aurigraph.io:443
REQUIRE_MLDSA
SecP384r1MLKEM1024
The full status table is in the Post-Quantum Cryptography white paper.
Real PQC is implemented in QuantumCryptoServiceImpl and PqcWalletService using the BouncyCastle 1.86 lightweight API (bcprov/bcpkix/bcutil-jdk18on):
QuantumCryptoServiceImpl
PqcWalletService
bcprov
bcpkix
bcutil-jdk18on
SLHDSASigner
The security level defaults to 5 for both the Dilithium and Kyber configuration keys, and must not drop below L3 in production. Notably, BouncyCastle derives verification parameters from the key object itself (its embedded MLDSAParameters / MLKEMParameters), so raising the level is a safe operation and previously-issued keys still verify.
MLDSAParameters
MLKEMParameters
PQC wallets are provisioned by PqcWalletService with an ML-DSA-87 keypair, with addresses derived via Keccak. EVM-compatible wallets use secp256k1 (a named classical exception).
The lightweight API is used deliberately rather than JCA getInstance(...), because the JCA provider service map is frozen at GraalVM native-image build time. The migration from BouncyCastle's pre-FIPS Dilithium, Kyber and SPHINCS+ classes to the FIPS-named ML-DSA, ML-KEM and SLH-DSA classes is complete (SLHDSASigner, AV11-3552); no pqc.legacy class remains in src/main.
getInstance(...)
pqc.legacy
src/main
Key material is generated from a classical CSPRNG by default. An optional quantum-random-number-generator (QRNG) seam (QuantumEntropyClient, IBM-Quantum adapter) can supply attested entropy, but it is default-OFF (aurigraph.crypto.qrng.enabled=false) and fail-safe: on any failure — disabled, unreachable, short response — the client returns null and the caller falls back to the CSPRNG, so a compromised or unavailable QRNG can never weaken key material. The QRNG implementation itself has been moved out to the separate QVAPT repository; V12 retains only client consumers.
QuantumEntropyClient
aurigraph.crypto.qrng.enabled=false
null
Battua is the organization's canonical wallet/crypto service. Aurigraph defines a CryptoOps interface and a gRPC client (BattuaQuantumCryptoClient → battua-app:8090) so that signing, verification, and KEM can be delegated to Battua. The current production mode is in-process BouncyCastle; the gRPC delegation path is built and available but is not yet the active production path pending call-site migration. This is documented transparently as a design-versus-reality state, not asserted as shipped consolidation.
CryptoOps
BattuaQuantumCryptoClient
battua-app:8090
The registry family under /api/v11/registry/* manages assets, tokens, contracts, channels, and KYC. The RWA domain is the platform's largest (65+ entity types), spanning asset-class metadata (real estate, commodities, art, IP, private debt/equity, royalty streams, trade finance, water rights), valuation, custody, fractional shares, derived tokens with yield distribution, and sector compliance records (carbon/EU-ETS, ESG/SFDR, gold). Specialized stacks include composite tokens, carbon/dMRV minting, and Digital Product / battery passports.
/api/v11/registry/*
The tokenization chain is:
RWA asset → metadata → valuation → custody → fractional/derived tokens → yield events ↑ sector compliance records attach per asset class
Active Contracts bind business logic and legal (Ricardian) terms to token lifecycle transitions. A contract template is instantiated as an Active Contract instance; per-state automation executes when the instance transitions between states.
Automation is template-faithful. ActiveContractAutomationExecutor observes contract-transition events and, on state entry, executes the template's declarative automation: rules — minting the declared symbol (with {{PARAM}} placeholders resolved from contract parameters), the quantityFromParam value (not a hard-coded quantity of 1), and one token per MINT_* rule (MINT_PRIMARY, MINT_DERIVED, MINT_SECONDARY). A generic binder backs off (SKIPPED_AUTOMATION) whenever a template is automated, so exactly one path mints.
ActiveContractAutomationExecutor
automation:
symbol
{{PARAM}}
quantityFromParam
MINT_*
MINT_PRIMARY
MINT_DERIVED
MINT_SECONDARY
SKIPPED_AUTOMATION
The Ricardian contract is the legal spine: active_contracts carry a mandatory Ricardian link (schema CHECK, migration V156), Ricardian contracts embed a signer public key and a canonical form, and signing uses ML-DSA-87 with keys resolving from a per-DID keypair store (signing is refused if the DID's key is not ML-DSA-87, AV11-3761). A library of 37 seeded ISO-aligned templates (LADM, UBL 2.1, Dublin Core, IPTC, EXIF across Global/India/UK/US/EU/Singapore) is loaded at startup. Stated plainly, as of 2026-10-20: the engine (templates, state machine, automation minting) is real; multi-party ML-DSA signing is being fixed (AV11-3840); and anchoring the contract to the ledger, signature-gated activation, and the prose + parameters + code triple hash are not yet done (epic AV11-3863) — DocumentFingerprint produces an anchor-ready Merkle root but nothing anchors it yet. AI-assisted legal analysis (Legal-BERT) degrades to a keyword fallback when the hosted model is unavailable, and the public AI endpoints are being moved to fail closed with HTTP 503 until a model is deployed (AV11-3856..3859). Contract instances are reactive (Uni<Response>) and gate mutating routes with method-level @RolesAllowed:
active_contracts
CHECK
DocumentFingerprint
Uni<Response>
@RolesAllowed
GET /api/v11/registries/contract-instances/{id} → read (open) PUT /api/v11/registries/contract-instances/{id}/activate → @RolesAllowed(ENTERPRISE, ADMIN) PUT /api/v11/registries/contract-instances/{id}/execute → @RolesAllowed(USER, ENTERPRISE, ADMIN) POST /api/v11/registries/contract-instances/{id}/classify → @RolesAllowed(ENTERPRISE, ADMIN)
The platform enforces a deny-by-default posture on value, mint, and key operations. Even where a resource carries a permissive class-level default for read routes, every state-changing operation is individually gated by a per-method @RolesAllowed or an SDK scope check. This is a deliberate pattern hardening against accidental exposure of mint/value endpoints.
PortalGoogleOAuthService
invalid_issuer
POST /api/v11/auth/google/exchange
aurdlt
KeycloakAuthFilter
SecurityContext
httpOnly
Secure
SameSite
CompliancePipelineOrchestrator
Third-party organizations integrate through organization-registered, role-gated, scope-enforced API keys under /api/v11/sdk/orgs:
/api/v11/sdk/orgs
POST /sdk/orgs
OWNER > ADMIN > MEMBER
POST /sdk/orgs/{orgId}/keys
Authorization: ApiKey <organizationId>:<apiKey>
.../users
A 13-scope catalog is partitioned into 7 auto-approved read-only scopes (registry:read, dmrv:read, stats:read, channels:read, contracts:read, health:read, ai:read) and 6 admin-gated mutating scopes (registry:write, dmrv:write, mint:token, contracts:write, channels:write, ai:chat). Enforcement is layered: SdkApiKeyAuthFilter authenticates the key and publishes its scopes as request roles; SdkScopeChecker.requireScope(...) gates each endpoint, returning an RFC 7807 403 on insufficient scope; and a tier/quota filter applies per-partner rate limits.
registry:read
dmrv:read
stats:read
channels:read
contracts:read
health:read
ai:read
registry:write
dmrv:write
mint:token
contracts:write
channels:write
ai:chat
SdkApiKeyAuthFilter
SdkScopeChecker.requireScope(...)
// Insufficient-scope error (RFC 7807) { "type": "https://dlt.aurigraph.io/errors/ERR_SDK_AUTH_004", "title": "Insufficient scope", "status": 403, "detail": "API key lacks required scope 'mint:token'", "errorCode": "ERR_SDK_AUTH_004", "traceId": "…", "requestId": "…" }
The Enterprise Portal (React 19 / Vite 7 / TypeScript, Zustand state) provides landing, Google-primary login, organization administration, and the operational console, served as a static bundle behind NGINX.
For the full multi-language SDK (TypeScript, Java, Python, mobile), scope model, sandbox, and semver policy, see the companion Aurigraph DLT SDK whitepaper.
The following are design goals and in-flight work, not shipped guarantees:
revm
EVM_BYTECODE
8472
8471
forge
cast
BatchSizeOptimizer
/api/v11/stats
target_tps: 2,000,000
current_tps
/api/v11/ai/dlt-model/*
Aurigraph DLT brings together the pieces enterprises actually need to put regulated, long-lived assets on a ledger: a CFT Raft consensus engine with durable, high-throughput WAL persistence; hybrid ML-KEM key exchange (X25519MLKEM768) live at the public TLS edge, with classical certificates; ML-DSA/SLH-DSA implemented in the crypto service and not active in production, with classical exceptions named; a rich RWA tokenization and Active-Contracts model with a Ricardian legal spine; a deny-by-default security posture with visible compliance exceptions; and a governed developer platform with scope-enforced organization keys. Equally important is the platform's discipline about honesty — clearly separating real cryptographic guarantees from simulation scaffolds, and design targets from measured results. That combination — a post-quantum migration stated precisely, enterprise governance, and verifiable claims — is what makes Aurigraph a credible substrate for the tokenized asset economy.
docs/PRD.md
docs/Architecture.md
docs/DetailedDesign.md
docs/DatabaseDesign.md
aurigraph-v12/pom.xml
This document is a technical whitepaper, last reconciled against the Aurigraph-DLT V12 branch (8b00dcf38) and dlt.aurigraph.io on 2026-10-20. Hard technical claims are grounded in the code-verified platform docs cited above; forward-looking items in §7 are labelled as design goals. Throughput and finality figures are engineering/capability targets unless a published benchmark states otherwise.
8b00dcf38
dlt.aurigraph.io
Explore: About · Products · Features · Whitepapers · Sustainability · Tokenized carbon credits · Real-world asset tokenization · SDK · Blog · Plain-text site index · Sitemap · Contact: contact@aurigraph.io