The Divi Smart Sidechain brings the full power of Ethereum smart contracts to DIVI — without changing a single line of the main chain.
Why? No smart contracts. The UTXO model means simple transfers only — and that's a feature, not a bug. But it leaves an entire world of programmable money on the table.
Same DIVI. New powers. Zero risk to the main chain.
Main chain is completely untouched. Zero protocol changes. Zero risk to existing holders or masternodes.
Any Ethereum smart contract works. Solidity developers can build on Divi immediately — no new language required.
Every wDIVI is backed by real DIVI locked in the bridge. Fully redeemable at any time, no slippage, no algorithmic risk.
An 80% stake-weighted threshold of validators must agree before any bridge action. Economic security at protocol level.
Built on Base — Coinbase's Ethereum L2. Battle-tested infrastructure, sub-cent fees, and access to the entire Ethereum ecosystem of tooling, wallets, and developers. Not an experiment — built on proven rails.
A cryptographically hardened two-way peg using threshold BLS signatures and on-chain coordination.
A technical deep-dive into the protocols, cryptography, and architecture connecting Divi to the EVM world.
OP_RETURN payload: XCHAIN:<chainID>:<hash>:<data>The Divi core was modified to support 599-byte OP_RETURN outputs (up from Bitcoin's 80-byte limit). This enables embedding structured cross-chain messages directly in UTXO transactions.
Messages follow the DVBS (Divi Bridge Standard) format: a 4-byte chain identifier, SHA-256 integrity hash, and arbitrary payload — all verifiable by any node without special software.
Every bridge intent is immutably recorded on-chain, creating a tamper-proof audit trail that relayers simply read and forward.
Validators sign bridge messages using BLS12-381 — the same elliptic curve used by Ethereum 2.0's Beacon Chain for validator attestations. It provides 128-bit security.
The key innovation: signatures are aggregatable. Twenty validator signatures compress into a single 48-byte proof. Verification cost on the EVM is constant — O(1) — regardless of how many validators signed.
Individual validator keys are generated via Shamir Secret Sharing — a t-of-n threshold scheme where no single validator ever holds the full signing key.
Authorization is based on economic stake, not validator count. The threshold requires 80% of total staked DIVI to approve any bridge operation.
This makes the system immune to Sybil attacks — spinning up 100 cheap VPS validators is useless if they hold no stake. An attacker must acquire and lock real economic value.
Validators are identified from deterministic PoS snapshots. Stake changes are reflected in real-time threshold recalculations, keeping the security model adaptive.
Bridge contracts use OpenZeppelin's UUPS (Universal Upgradeable Proxy Standard) pattern, enabling security patches without migrating funds or user state.
Four distinct roles — ADMIN, VALIDATOR, RELAYER, PAUSER — are enforced on-chain via OpenZeppelin AccessControl. No single key can do everything.
Rate limiting caps daily bridge volume and per-address throughput. An emergency circuit breaker can halt all operations in a single transaction if anomalies are detected.
A TypeScript relayer service watches both chains via RPC polling (~1s intervals). When it detects a lock on Divi or a burn on Base, it triggers the cross-chain flow.
The coordinator service orchestrates multi-validator signing. It collects partial signatures in parallel (<50ms total), validates stake weights, aggregates via BLS, and submits the final transaction.
Failed or offline validators are handled gracefully — the threshold scheme requires only 80% participation, so the system degrades without failing.
A custom UTXO transaction builder constructs Divi-native transactions with OP_RETURN data for the bridge. It handles input selection, fee estimation, and change output generation.
For withdrawals (Base → Divi), the builder creates unlock transactions signed with the aggregated BLS key, releasing locked DIVI back to the user's address on the main chain.
Average transaction size: 437 bytes. OP_RETURN payload: 199 bytes (33% of the 599-byte limit), leaving room for protocol evolution.
Every Ethereum validator uses BLS12-381 for block attestations. 1M+ validators, $100B+ secured. The exact same curve and aggregation scheme used in our bridge.
Cosmos connects 50+ chains using a relayer model similar to ours — watchers detect events, build proofs, and submit them cross-chain. Our relayer follows the same pattern.
Polygon's PoS bridge uses stake-weighted validator sets to checkpoint state to Ethereum — the same economic security model. Our 80% threshold mirrors their approach.
Both networks use BLS12-381 for their consensus layers. Zcash uses it for Sapling proofs, Filecoin for storage miner signatures. Battle-tested cryptography.
Major crypto custodians use Shamir-based key splitting (or MPC derivatives) to secure billions in assets. No single party holds the complete key — exactly our approach.
The biggest DeFi protocols use OpenZeppelin's UUPS proxy pattern and role-based access control to manage $10B+ in smart contracts — the same patterns in our bridge.
Not mockups. Not whitepapers. Working smart contracts and frontends, right now.
Designed to defend real value. Not a toy — a hardened production system.
| Model | Annual Cost | Attack Vector | Status |
|---|---|---|---|
| Count-based threshold (naive) | $1,020/year | Spin up 80% of validators cheaply | Vulnerable |
| Stake-weighted threshold (ours) | $606,000+ | Must acquire 80% of total stake | Hardened |
128-bit security level — the same curve Ethereum 2.0 uses to secure $100B+. Aggregatable signatures compress any number of validators into a single 48-byte proof for gas-efficient on-chain verification.
Validator keys are split into shares using Shamir's scheme — the same technique Fireblocks and BitGo use to custody billions. No single validator ever holds the full signing key. Signing happens without ever reconstructing it.
Authorization requires 80% of staked value, not validator count. Spinning up 1,000 cheap VPS nodes is useless without stake. This mirrors Polygon's checkpoint system — economic security, not infrastructure security.
Nonce tracking in the smart contract ensures every bridge message can only be processed once. Combined with chain ID binding, transactions cannot be replayed across networks or resubmitted.
The same proxy pattern used by Aave, Compound, and Uniswap — security patches deploy without migrating funds. Implementation upgrades require multi-sig authorization with timelock.
Four distinct roles — Admin, Validator, Relayer, Pauser — enforced on-chain via OpenZeppelin AccessControl. No single key can mint, pause, and upgrade. Separation of duties at the protocol level.
A Pauser role can halt all bridge operations in a single transaction if anomalous behavior is detected — large unexpected withdrawals, signature mismatches, or oracle failures.
Daily volume caps and per-address limits prevent catastrophic draining even in a worst-case key compromise. Limits can be adjusted via governance without redeploying contracts.
Rigorous engineering. Every number earned.
From prototype to production. A clear, achievable timeline.
The contracts are written. The dApps are running. The architecture is documented. What happens next depends on the community.