The primary purpose of a blockchain is to serve as an immutable ledger of transactions that can be transparently accessed by anyone at any time. 

As blockchains like Ethereum, Solana, and Avalanche have expanded this purpose to also serve as a new kind of decentralized internet, the size and scale of data on these networks have exploded, leading to new kinds of problems known as ‘state bloat’. 

Simply put, as more transactions are recorded on a blockchain, more blocks are required to store those transactions. Blockchains are made up of a network of nodes whose job it is to validate transactions and record the state of the network (i.e the latest record of transactions, issued tokens, and account balances). Full nodes in particular are responsible for keeping an archive of the entire history of the blockchain dating back to its inception. 

Over time, the massive amounts of data that is accrued put stress on the network, making it more costly and increasing the amount of time it takes to set up a full node because of the size of the data that one needs to download. This ultimately impacts a blockchain’s performance and transaction speeds as nodes need to record an increasing amount of data with quickly decreasing storage capacity. 

This creates an interesting challenge where a blockchain must figure out how to offload some of its oldest records while still maintaining immutable proof of that data having existed somewhere on-chain. 

Accumulate solves the state bloat problem through its modular architecture design, which allows it to distribute data storage across its multiple chains, in addition to its anchoring solution, which makes it possible to store the state of one network as a hash on another network, including networks that are not native to Accumulate, such as Bitcoin or Ethereum. 

How Anchoring Is Used on Accumulate

With Anchoring, a cryptographic proof or hash containing batches of transactions from an Accumulate account chain is inserted into another chain like Bitcoin or Ethereum and validated by miners on those networks.  

Each ADI (accumulate digital identifier) is made up of a collection of independent sub-chains that are consolidated into a Block Validator Network or BVN. 

Block Validator Networks or BVNs produce hashes of transaction data that are anchored on the Directory Network (DN). The DN consolidates the records of all transactions that occur between the various ADI accounts and their various sub-chains, thereby allowing Accumulate to maintain a single unified state, even while existing as many fragmented networks running in parallel. 

The Accumulate Network also has a Root Anchor Chain and an Intermediary Anchor Chain. The Root Anchor chain records an anchor (i.e. a timestamp) once every block containing information from every account chain and system chain is updated during that block.  

The root anchor also produces a root hash for the BVN or DN of every major or minor block, with the root hash of the DN containing the state of the entire Accumulate Network. 

The intermediary Anchor chain collects an anchor from the root anchor chain of every BVN once per block, as well as another anchor from the DN root anchor chain also once per block. 

Every chain inside a BVN or DN is anchored to a root anchor chain and basically operates as a sidechain to the root anchor chain. 

Anchoring plays an important role in keeping the many chains on Accumulate in sync. It also enables the network to store data on other chains outside of the Accumulate network in order to mitigate state bloat and to also provide additional security guarantees.  

For example, through Accumulate, users can anchor high-value data on the most decentralized and secure networks like Bitcoin and Ethereum. The process of anchoring the data would be similar to paying for a transaction on either network, in which case the cost of anchoring the data would be the network fee or gas fee. 

Chains of chains architecture of Accumulate (with Anchoring to L1 Blockchain)

This is the equivalent of backing up your data on multiple hard drives that each have its own unique security system.

We can think of many use cases where data anchoring on other L1s could improve network scalability while also solving other important problems. 

For example, you could create a verifiable proof of asset ownership on other chains by anchoring data such as public key addresses or off-chain certificates. This could improve cross-chain lending capabilities as well as lending transactions between real-world entities and blockchain protocols. 

Furthermore, lending records that are over a year old could be turned into hashes and stored on other chains, removing the need for nodes on the mainchain to continue downloading and storing those records. This would reduce the accumulation of data that can lead to state bloat and keep the network running smoothly. 

Another use case that can arise from anchoring is the creation of a cross-chain directory or block explorer for hashed data records. This directory would provide users with an easy way to retrieve data from other chains that are no longer stored there, mitigating some of the potential challenges that would come from distributing data across multiple chains much easier to manage.  

Ultimately, Anchoring provides the perfect solution for Accumulate to solve the state bloat problem by offloading some of its oldest records unto its chains while still maintaining an immutable proof of that data’s existence. 

As blockchains continue to onboard new users and further explore commercial use cases like gaming, decentralized social media, etc, data accumulation and state bloat will become an increasing problem for networks to tackle.  

Accumulate architecture can not only serve as a great model for other blockchains to follow but also as a solution for blockchains to adopt in order to facilitate the anchoring of data unto other chains through our communication, audit, and identity layer.