Program 03 · PhysarumChain

A blockchain that routes like a living network.

PhysarumChain is a Layer-1 blockchain that uses the same path-finding algorithm nature evolved in slime mold to route transactions between nodes. Built-in exchange, real Ed25519 cryptography, smart contracts, and a JavaScript SDK you can drop into any app today.

MKB · Native coin · Chain ID 0x504859534152554D · Try the testnet →

Active nodes 49 Tx/s 577 Routes 0

Live simulation

PHYSARUM ROUTING · LIVE BIOLOGICAL PATHFINDING

What it is

A complete blockchain, without the complexity.

Most blockchains pick a routing algorithm and bake it in forever. PhysarumChain borrows from biology instead. Physarum polycephalum — a single-celled organism that has no brain — solves the shortest-path problem between food sources by growing tubes and keeping the ones that carry the most flow. We run the same algorithm on our peer-to-peer network.

Every node in the network maintains a conductivity score for each connection it knows about. Routes that carry a lot of traffic grow stronger. Routes that go idle fade away. The result is a network that self-organises around load without a central coordinator, and recovers from failures automatically.

On top of that routing layer sits everything you need for a real blockchain: Ed25519 signed transactions, a native coin (MKB), a built-in token standard, a decentralised exchange, smart contracts with a full stack machine, and Merkle proofs so light clients can verify state without downloading the whole chain.

How it works

Seven layers. One coherent system.

01 PHYSARUM ROUTING P2P LAYER

Network paths that grow themselves.

When your node sends a transaction, it doesn't flood the network with copies. It follows the conductivity scores it has already learned. The path with the best track record gets the traffic. As traffic accumulates, that path strengthens. Idle paths decay.

This is the Physarum equation at work: dD/dt = |Q|^α − μD, where D is conductivity, Q is flow, α=0.6 keeps strong and moderate routes both viable, and μ=0.008 lets dead routes fade in about 125 steps. The network converges to efficient topology by itself.

AlgorithmPhysarum polycephalum — the same path-finding slime mold uses in nature.
Self-healsWhen a node goes offline, its conductivity scores decay to zero and traffic reroutes automatically.
No floodsDirected routing — no broadcast storms, traffic scales with node count.

Conductivity 0.73 Paths alive 0 Decay μ 0.008

Live

CONDUCTIVITY · LIVE α=0.6 · μ=0.008

02 CGA ADDRESSES Cl(4,1) MATH

Addresses built from 5-dimensional geometry.

Most blockchains derive addresses by hashing a public key. PhysarumChain does that too — but each address also maps to a null vector in Cl(4,1) Conformal Geometric Algebra, a 32-component space that encodes position and orientation in 5D projective space.

Why does this matter? Geometric proximity in that space corresponds to routing distance. Nodes that are close in CGA space can relay transactions to each other with lower latency. The address is already a coordinate, not just an identifier.

Dimension32-component multivectors in Cl(4,1) — 5-dimensional conformal space.
Derived fromSHA-256 of your Ed25519 public key, first 20 bytes — standard and secure.
Routing useGeometric proximity guides peer selection at the P2P layer.

Multivector Cl(4,1) Components 32 Grade-2 norm 0.41

Live

CGA SPACE · LIVE NULL VECTOR LATTICE

03 BUILT-IN DEX AMM · SWAP

Swap tokens without leaving the chain.

PhysarumChain ships with a built-in automated market maker. You don't deploy a contract to create a liquidity pool — you call a native RPC method. The AMM math runs directly on-chain using 128-bit integers so there are no overflow bugs at large pool sizes.

Create a token, add liquidity, and start trading in three API calls. The DEX also feeds conductivity data back to the Physarum routing layer — high-volume trading pairs get stronger routes between the nodes that host their liquidity.

ModelConstant-product AMM (x·y=k) — the same formula used by Uniswap v2.
Safety128-bit integer math throughout — no floating-point rounding in pool calculations.
TokensFour token types: Standard, Wrapped, LP, and Meme. Up to 7-character symbols.

Pools 0 active Volume 0 MKB Ratio 1.00

Live

AMM · LIVE x · y = k

04 REAL CRYPTOGRAPHY Ed25519 · CLF-SIGN

Ed25519 on every transaction. 103× faster on the P2P layer.

Every transaction is signed with Ed25519 via OpenSSL. The signature covers your address, the recipient, the amount, the fee, a nonce, and the Chain ID — so a valid transaction on one network can never be replayed on another.

At the P2P layer we go further. Node authentication uses CLF-Sign v1, our Clifford-algebra Schnorr scheme. It runs 103 times faster than standard Ed25519 verification at the node handshake level, which matters when a node is verifying hundreds of peer connections per second.

Tx signingEd25519 via OpenSSL — industry standard, hardware-accelerated, auditable.
P2P authCLF-Sign v1 — Clifford Schnorr, 103× faster verification at handshake.
Replay guardCHAIN_ID=0x504859534152554D baked into every signature — cross-chain replay is structurally impossible.

// Build and sign a transaction
const tx = await wallet.buildTransaction({
  to: "a1b2c3...",
  amount: PhysarumRPC.mkbToGrains(10),
  fee: 100_000n
});
const hash = await rpc.sendTransaction(tx);
        

Sig scheme Ed25519 P2P auth CLF-Sign Speedup 103×

Live

CRYPTOGRAPHY · LIVE SIGNING STREAM

05 SMART CONTRACTS PVM · 40 OPCODES

A stack machine for on-chain logic.

PhysarumVM (PVM) is a 64-bit stack machine with 40 opcodes and gas metering built in. Storage reads cost 50 gas, storage writes cost 200, token transfers cost 100. You get deterministic execution, a hard stack limit of 1024 entries, and bytecode up to 64 KB.

Contracts are first-class objects. They have their own balances, their own persistent key-value storage, and they can transfer MKB to any address. Deploy with a single RPC call. Your contract address is deterministic — SHA-256 of your address and nonce.

Machine64-bit stack, max depth 1024 — deterministic, sandboxed, gas-metered.
Gas costsSLOAD=50, SSTORE=200, TRANSFER=100, BALANCE=20 — predictable and transparent.
DeployOne RPC call — address is SHA-256(sender ∥ nonce), no coordination required.

Opcode	Cost	Description
SSTORE	200	Write a value to contract storage
SLOAD	50	Read a value from contract storage
TRANSFER	100	Send MKB to an address
BALANCE	20	Read an account balance
LOG	30	Emit an event
Arithmetic	1	ADD, SUB, MUL, DIV, MOD, AND, OR, XOR…

Opcodes 40 Stack depth 1024 Max bytecode 64 KB

Live

PVM · LIVE STACK EXECUTION

06 MERKLE PROOFS LIGHT CLIENT

Verify any balance without downloading the chain.

Every block contains a state root — the top of a binary Merkle tree built from all account balances. If you want to verify that an address holds a certain balance, you only need the block header and a short proof: a list of sibling hashes that lets you reconstruct the root.

The light client keeps only 228-byte block headers. Each header is signed by the block producer, so a mobile wallet or a browser app can verify proofs without trusting a third party. The chain is auditable from a phone.

State rootBinary sorted Merkle tree over all balances — one root per block, in the header.
Proof sizeO(log n) hashes — a chain with 1 million accounts needs only 20 hashes per proof.
Header size228 bytes — a light client syncs gigabytes of state from kilobytes of headers.

Tree depth 20 Header 228 bytes Proof O(log n)

Live

MERKLE TREE · LIVE STATE PROOFS

Transactions / second

569

Measured with full Ed25519 signing included. No shortcuts.

Test coverage

256

Tests across 7 suites — cryptography, consensus, P2P, DEX, contracts, Merkle.

Transaction size

208 B

Fixed 208-byte transaction struct. No variable-length encoding surprises.

CLF-Sign speedup

103×

Clifford Schnorr P2P authentication versus standard Ed25519 verify.

Security attacks blocked

40 / 40

Double-spend, replay, forgery, overflow, race — all blocked in suite 5.

Testnet nodes

50-node simulation: valid chains 50/50 on every run.

Finality depth

6 blocks

A transaction is final after 6 confirmations. Configurable per deployment.

Bloom filter

1 MB

3-hash bloom for double-spend detection. Cross-node merge supported.

Tools & ecosystem

Everything you need to build on it today.

01 · JS SDK

Build apps in one file.

physarum.js is a single JavaScript module with no required build step. Create wallets, sign transactions, call every RPC method, and subscribe to live block events via WebSocket. Works in Node.js and the browser.

import { PhysarumWallet, PhysarumRPC } from './sdk/physarum.js';
const w = PhysarumWallet.fromRandom();
const rpc = new PhysarumRPC('http://localhost:8545');
const bal = await rpc.getBalance(w.address);
        

02 · Web Wallet

A self-custody wallet that lives in the browser.

The web wallet lets you generate keypairs, view balances, send MKB, and interact with tokens — all from a single HTML file. Keys stay in sessionStorage, never leave your device, and you don't need to install anything.

03 · Testnet Faucet

Get test tokens immediately.

The faucet holds 500,000 MKB on testnet. Paste your address and receive tokens in seconds. The faucet wallet is fully transparent — its address and genesis allocation are published in the genesis file.

04 · Token Launchpad

Launch a token in three clicks.

The PumpFun-style launchpad lets you create tokens, seed liquidity pools, and watch live price charts on the built-in DEX — all from a single page. No Solidity, no deployment scripts, no bridges.

05 · Block Explorer

Inspect every block, transaction, and account.

Query blocks by height, look up transaction hashes, check account balances with full Merkle proof verification, and browse DEX pool state — all via the JSON-RPC API with 31 documented methods.

06 · Docker

Run a full node in one command.

The Dockerfile sets up a complete node with RPC on port 8545, WebSocket on 8546, and metrics on 9090. Environment variables control every parameter — ports, peers, fees, Physarum dynamics, data directory.

docker run -e PHYSARUM_RPC_PORT=8545 \
  -p 8545:8545 physarumchain/node
        

RPC API

31 methods. One endpoint.

Method	Description
physarum_healthCheck	Node health and version
physarum_getBalance	Account balance in grains
physarum_sendRawTransaction	Submit a signed transaction
physarum_getBlock	Block by height — includes all transactions
physarum_getTransaction	Transaction receipt by hash
physarum_getStateRoot	Merkle state root for any block
physarum_getStateProof	Merkle proof for an account balance
physarum_getLightHeaders	Compact 228-byte headers for light clients
dex_addLiquidity	Add liquidity to a trading pair
dex_swap	Swap tokens through the best available route
token_create	Create a new token
pvm_sendContractTx	Deploy or call a smart contract
pvm_estimateGas	Estimate execution cost before sending
+19 more methods — see the full reference in sdk/physarum.js

Design principles

Three choices that set it apart.

Biology over brute force.

Classical networks route by flooding or by static tables. Physarum routing learns from traffic and self-organises. No routing committee. No configuration. The network finds good paths on its own.

Everything on-chain.

The exchange, the token standard, and the virtual machine ship as part of the core node — not as contracts you deploy on top. Less attack surface. No bridge risk. One binary, full stack.

Real numbers, honest benchmarks.

The 569 TPS figure includes full Ed25519 signing. The 256 test count is real. The 40/40 security attacks blocked is reproducible — run the suite yourself in under two minutes.

Get started

Run a node. Build an app. Try it today.

The full source, the SDK, the wallet, and the faucet are all here. Clone the repo, build in one command, and have a running node in under five minutes. The testnet faucet will fund your first wallet immediately.

Open Web Wallet→ Testnet Faucet→ Token Launchpad→