Technology - Dynamis

Post-Quantum Cryptography

Dynamis is built from the ground up with quantum-resistant cryptography using NIST-approved algorithms. We've implemented hardware-accelerated, vectorized versions for production-grade performance.

"Sarasate's Bow" — Vectorized Dilithium-3

Our custom Dilithium-3 implementation uses Java's Panama FFM (Foreign Function & Memory API) to call native C libraries with SIMD vectorization. Named after the virtuoso violinist, it achieves concert-level performance.

NIST FIPS 204

14,625 verifications/sec

Panama FFM native acceleration with SIMD vectorization for NTT operations.

Quantum-Safe

ML-DSA Level 3

NIST standardized digital signature algorithm, resistant to Shor's algorithm attacks.

"The Aerotech" — Vectorized BLAKE3

Our BLAKE3 implementation uses Panama FFM to call native libraries compiled with AVX-512 support, achieving throughput that's 5-7x faster than Java's built-in SHA-256.

High Throughput

~2,000 MB/s

Native BLAKE3 via Panama FFM, enabling high-frequency PoH at minimal CPU overhead.

Streaming

Tree-Based

BLAKE3's tree structure enables parallel hashing and incremental updates.

ML-KEM-768 (Kyber) — Key Encapsulation

For encrypted swaps and confidential transactions, we use ML-KEM-768 via Bouncy Castle's JCA provider with hardware acceleration where available.

Operation	Performance	Implementation
Key Encapsulation	~14,969 ops/sec	Bouncy Castle JCA
Dilithium-3 Verify	~14,625 ops/sec	Panama FFM Native
BLAKE3 Hashing	~2,000 MB/s	Panama FFM Native
AES-256-GCM	~15,000 ops/sec	Hardware AES-NI

Proof of History

Dynamis uses Proof of History — a cryptographic clock that provides deterministic ordering for all network events with nanosecond-resolution timestamps. Unlike Solana's VDF-style PoH, Dynamis uses discrete time ticks at a fixed frequency.

How It Works

A scheduler triggers PoH ticks at 1000 Hz (every millisecond)
Each tick: newHash = BLAKE3(previousHash || sequenceNumber)
Transactions carry nanosecond timestamps via System.nanoTime()
Within each tick, transactions are ordered by nanosecond precision
Checkpoints every 1000 ticks enable parallel verification

                // Discrete PoH tick (every 1ms)
                public void tick() {
                sequence++;
                currentHash = blake3(currentHash + sequence);
                }

                // Transactions carry nanosecond timestamps
                transaction.pohSequence = 1,234,567;
                transaction.timestamp = System.nanoTime(); // Nanosecond precision!
            

Key Characteristics

Parameter	Value
Tick Rate	1,000 Hz (discrete)
Timestamp Precision	Nanosecond
Block Time	~2 seconds (slots)
Hash Algorithm	BLAKE3 (vectorized)
Checkpoint Interval	Every 1,000 ticks

Nanosecond Precision Use Cases

DeFi

No-Snipe Auctions

Exact nanosecond endings eliminate "who bid first?" disputes.

Yield

Precise APY Calculation

Nanosecond-accurate yield accrual for staking and lending.

vs. Solana's VDF PoH

Solana's PoH is a Verifiable Delay Function — validators race to compute sequential hashes as fast as possible to "prove" elapsed time. Dynamis instead uses a fixed-frequency scheduler at 1000 Hz, combined with nanosecond timestamps for ordering within each tick.

Smart Contracts

Write contracts in Rust, compile to WebAssembly, and execute on a pure-Java WASM runtime (Chicory). This hybrid architecture combines Rust's safety with Java's enterprise ecosystem.

Why Rust + WASM?

Memory safety without garbage collection pauses
Predictable execution for reliable gas metering
Portable bytecode runs on any Chicory-compatible node
Existing Rust ecosystem and tooling

                // Rust smart contract example
                #![no_std]
                use dynamis_std::*;

                #[dynamis::contract]
                mod counter {
                pub fn increment() {
                let count = storage_get("count");
                storage_set("count", count + 1);
                log("Counter incremented!");
                }
                }
            

Host Functions

Storage

Read/write persistent state with storage_get and storage_set.

PoH Timestamp

Get current PoH sequence for verifiable time ordering.

Cryptography

BLAKE3 hashing, signature verification, address validation.

Events

Emit events for off-chain indexers and frontend updates.

Architecture

Dynamis runs on a modern Java 25 foundation (with Panama FFM for native crypto) using Quarkus for reactive, cloud-native deployment.

Component	Technology
Runtime	Java 25 (Panama FFM + Virtual Threads)
Framework	Quarkus 3.30.1
WASM Runtime	Chicory (Pure Java)
Database	PostgreSQL (Reactive)
Networking	HTTP/2, WebSockets, QUIC (experimental)
Deployment	Docker, Kubernetes, any cloud

Technology Deep-Dive