BitTorrent is a distributed peer-to-peer file distribution protocol that fragments a file into many small pieces, each uniquely hash-verified using hashing (either sha-1 or SHA-256). It allows clients (known as peers) to concurrently upload and download various pieces of the same file to and from each other without relying on a central server.
Each peer maintains a bitmap indicating which pieces it has and advertises this information to others via a process called peer exchange while a coordinating node called a tracker facilitates peer discovery using UDP or HTTP announces. That is to say, people can download different pieces of the same file from each other until they have a complete file. This is done for speed optimizations.
The protocol optimizes bandwidth through rarest-first piece selection, parallelism, and a tit-for-tat incentive mechanism that rewards high-throughput peers with prioritized data access, effectively transforming every downloader into an uploader to maximize global swarm efficiency and redundancy across volatile, fault-tolerant networks.
Contractless Adopts and Extends This Concept
In Contractless, we borrow these exact principles—not for file sharing, but for block propagation. Instead of broadcasting full blocks as soon as they are mined, a node first:
- Splits the block into multiple smaller fragments.
- Hashes each fragment individually and collectively (for verification).
- Packages these hashes into a compact torrent-like metadata file.
- Broadcasts this file to the network.
Once a peer validates this metadata, it starts downloading fragments—not from one node, but from many simultaneously. Other nodes do the same. This creates a distributed swarm where each node contributes to distributing the block, just like BitTorrent peers contribute to sharing files.
When all pieces are received and hash-verified, the full block is reassembled and added to the chain.
Elimination of Merkle Trees
Traditional blockchains rely on Merkle trees to ensure the integrity of transaction data within a block. Every transaction is hashed, and then pairs of hashes are combined recursively until a single Merkle root is produced. This root is included in the block header, allowing nodes to verify the validity of individual transactions without downloading the entire block.
In Contractless, we eliminate this structure entirely—because we don’t need it.
Our system treats the entire block like a torrent, breaking it into individually hashed fragments (just like pieces in BitTorrent). Each piece is cryptographically hashed using a custom skein hashing algorithm and it gets recorded in the block's torrent metadata file.
Once all pieces are downloaded, the entire block is reconstructed and its full-block hash is compared to the expected value. If even a single byte is altered, the hash won't match providing end-to-end tamper detection.
This model achieves the same integrity guarantees that Merkle trees offer, but with several key advantages:
- No need for hierarchical hash calculations: each piece stands on its own.
- Faster validation: peers can hash-verify fragments as they arrive, instead of waiting to compute tree branches.
- Distributed trust: pieces are fetched from multiple nodes and verified independently, making it harder for any single node to inject a malicious payload.
- Complete hash transparency: every fragment’s hash is explicitly declared and checked, giving you Merkle-like granularity without the tree structure.
In essence, our torrent-based hash model replaces the Merkle tree with a flat but secure hash map, where every piece is verifiable and the final block hash seals the deal. It’s simpler, faster, and more naturally aligned with decentralized, parallel distribution.
Why It Matters
- Massive sync speed increases: Nodes don’t wait on one source—they pull from many at once.
- Efficient bandwidth usage: Each node contributes only partial data, reducing load and latency.
- Fewer orphan blocks: Hash mismatches can be detected instantly at the piece level, making invalid or tampered blocks easier to identify and isolate.
- Scales with block size: As blocks grow larger, torrent-style distribution becomes not just useful—but essential.
- Faster Block Generation: There is no need to generate a merkle root hash based on all the transactions selected to go into a block.
- Faster Block Proofing: Transactions can be pre-validated and do not need to be validated again to create a merkle root hash.
This architecture enables Contractless to remain lightweight, scalable, and fault-tolerant even as transaction volumes grow. It's one of the core innovations that sets us apart from traditional blockchains stuck in linear sync bottlenecks.
