DOLI
A Peer-to-Peer Electronic Cash System Built by Agents, for an Agentic Era
Consensus weight emerges from bonded capital anchored by sequential time — not trust, not scale, and not purchasable acceleration.
Website: doli.network | Explorer: explorer.doli.network | Marketplace: doli.network/marketplace.html | Whitepaper: WHITEPAPER.md
What is DOLI?
DOLI is a cryptocurrency where the scarce resource is time — the one resource that cannot be accumulated, parallelized, or purchased. One second passes at the same rate for an individual as for a nation-state.
DOLI is built entirely by OMEGA, a multi-agent AI workflow system where specialized agents — architect, developer, reviewer, auditor, QA — collaborate through shared institutional memory. Every line of code passes through multiple validation layers before it reaches the chain. This isn't a blockchain with an AI wrapper bolted on; it's a blockchain engineered from genesis by agents, with every design decision made for machine-readability first.
- No premine, no ICO, no treasury. Every coin comes from block rewards.
- No mining pools needed. The protocol is the pool — epoch rewards are distributed on-chain to all qualified producers.
- No special hardware. Any CPU can participate. A $5/month VPS is sufficient.
- Equal ROI for all. A producer with 1 bond earns the same percentage return as one with 3,000 bonds.
Agent-Native by Design
Most blockchains were designed for human developers reading docs. Their errors are cryptic strings, their state is implicit, and their scheduling is opaque. Retrofitting good agent design onto a mature chain is extremely painful — Ethereum has been trying for years.
DOLI was designed during the agentic transition. Every interface speaks the language agents understand: structured data, stable codes, explicit state, and deterministic timing.
Structured Errors for Self-Correction
47 machine-readable error codes with structured JSON responses. When a transaction fails, agents don't parse strings — they read error_code, understand the failure, and self-correct:
{
"code": -32002,
"message": "validation failed: insufficient funds",
"data": {
"error_code": "INSUFFICIENT_FUNDS",
"stage": "mempool_validation",
"inputs": 500,
"outputs": 1000
}
}
Every error carries a stage field (deserialization, mempool, mempool_validation) so agents know exactly where in the pipeline the failure occurred.
Explicit State via UTXO Model
Unlike account-based chains where agents must simulate the entire state transition to predict outcomes, DOLI's UTXO model makes every coin an individually queryable object. An agent can call getUtxos, select specific coins by outpoint, know the exact state before broadcasting, and get told which specific UTXO failed and why. No gas estimation guessing. No state simulation.
Deterministic Scheduling
getSlotSchedule tells agents exactly which producer handles which slot. getProducerSchedule shows when a specific producer is next up. Timing is predictable, not probabilistic.
Agent-Readable Skills
DOLI ships with 20 skill files committed to the repository — structured knowledge maps that give any AI agent deep understanding of the codebase. Each skill covers a domain (consensus, networking, storage, RPC, CLI, wallet, etc.) with indexed entry points, data flows, constraints, and patterns. An agent can grep the SKILLS-INDEX for any keyword and jump directly to the relevant code section.
These aren't documentation written for humans to skim. They're machine-optimized navigation data: @INDEX headers for offset-based loading, line-range references for surgical reads, and cross-domain dependency maps. Any agent — not just OMEGA — can use them to understand, operate, debug, and extend the blockchain.
How It Works
Block production is a deterministic round-robin over the active producer list frozen at each epoch boundary (at most 50 producers, ranked by registration seniority, liveness-filtered each epoch): every listed producer gets the same number of slots regardless of bond count. Epoch rewards scale linearly with bonds and production frequency carries no economic weight — ensuring identical ROI percentage for all participants.
Rewards accumulate into an epoch pool (360 blocks, ~1 hour) and are distributed proportionally by bond weight to all producers who proved continuous presence via on-chain liveness attestations.
Programmable outputs without a virtual machine: NFTs, fungible tokens, AMM pools, lending, and cross-chain bridges are native UTXO output types with declarative spending conditions — no gas, no EVM, no shared mutable state.
| System | Scarce Resource | Selection | Min Hardware | Pools Needed |
|---|
| Bitcoin | Energy | Lottery (hashpower) | ASIC ($5,000+) | Yes |
| Ethereum | Capital (32 ETH) | Lottery (stake) | Server ($100K+) | Yes |
| Solana | Capital (stake) | Stake-weighted | $10K+ server | Yes |
| DOLI | Time | Deterministic bond-weighted | Any CPU ($5/mo) | Built-in |
Quick Start
A basic VPS with 2 cores, 2 GB RAM, and 20 GB SSD (~$4/month) is all you need.
# 0. Remove previous installation (if any)
sudo doli service stop 2>/dev/null; sudo rm -f /usr/bin/doli /usr/bin/doli-node
# 1. Install
curl -sSfL https://doli.network/install.sh | sudo sh
# 2. Create wallet + BLS key
doli init
# 3. Start the node
sudo doli service install
# 4. Verify your node is synced
doli chain
# 5. Request 10.000001 DOLI from the faucet (one per person, to a new empty address)
# Join the DOLI Discord (https://discord.gg/uGzCvxGYC) and run /faucet
# Open the private link it sends you and submit your address (doli info)
# A human approves every claim before it is paid
# 6. Verify you received the DOLI
doli balance
# 7. Register as producer
doli producer register --bonds 1
Permission model: Wallet commands (doli send, doli balance) never need sudo. System commands (doli service install, doli upgrade, doli snap) do.
Full guide: doli.network/guide.html
Build from Source
git clone https://github.com/doli-network/doli.git
cd doli
cargo build --release
sudo cp target/release/doli-node target/release/doli /usr/bin/
Architecture
DOLI is implemented as a Rust workspace:
| Crate | Description |
|---|
crypto | BLAKE3 hashing, Ed25519 + BLS12-381 signatures, bech32m addresses |
doli-core | Transactions (30 types), validation, consensus parameters, conditions, EpochState |
storage | RocksDB state database, block store, UTXO set, producer set |
network | libp2p P2P networking, gossipsub, Kademlia DHT, sync engine |
mempool | Transaction pool with UTXO verification and chained tx support |
rpc | JSON-RPC server (45+ methods) |
bridge | Cross-chain atomic swap library (Bitcoin, Ethereum) |
wallet | Transaction builder, UTXO selection, key management |
updater | Auto-update system, hard fork scheduling |
doli-node | Full node binary |
doli-cli | Command-line wallet and utilities |
Protocol Parameters
| Parameter | Value |
|---|
| Block time | 10 seconds |
| Epoch | 360 slots (1 hour) |
| Era | 12,614,400 blocks (~4 years) |
| Total supply | 25,228,800 DOLI |
| Block reward (Era 1) | 1 DOLI |
| Halving | Every era (~4 years) |
| Bond unit | 10 DOLI |
| Max bonds/producer | 3,000 (30,000 DOLI) |
| Liveness threshold | 90% attestation per epoch |
| Unbonding period | 7 days |
| Slashing (double production) | 100% of bond |
| Hash function | BLAKE3-256 |
| Signatures | Ed25519 (transactions) + BLS12-381 (attestation aggregation) |
| Addresses | Bech32m (doli1...) |
Native DeFi
All financial primitives are compiled UTXO output types — no VM, no gas, no reentrancy:
| Primitive | Output Type | Description |
|---|
| Transfers | Normal | Standard P2PKH payments |
| Staking | Bond | Producer bonds with FIFO vesting |
| NFTs | UniqueAsset | On-chain art, royalties, batch minting |
| Tokens | FungibleAsset | User-issued fixed-supply tokens |
| AMM Pools | Pool + LPShare | Constant-product AMM (x*y=k), 0.3% fee |
| Lending | Collateral + LendingDeposit | Collateralized loans with TWAP oracle |
| Bridges | BridgeHTLC | Atomic swaps: BTC, ETH, BSC, LTC, XMR, ADA |
| Multisig | Multisig | N-of-M authorization |
| Timelocks | HTLC, Vesting | Hash + time locked outputs |
MEV and sandwich attacks are structurally impossible: the pool is a UTXO consumed atomically — two swaps referencing the same pool are mutually exclusive.
Documentation
Networks
| Network | Address Prefix | Purpose |
|---|
| Mainnet | doli1... | Production network |
| Testnet | tdoli1... | Public test network |
| Devnet | ddoli1... | Local development |
doli-node run # Mainnet (default)
doli-node --network testnet run # Testnet
doli-node --network devnet run # Devnet
License
MIT
"Time is the only fair currency."
D. Guanipa · [email protected] | I. Lozada · [email protected] | A. Lozada · [email protected]
