One of the challenges that projects encounter when trying to scale decentralized systems is the question of how to increase complexity within the system without deferring back to centralization.
Typically, the more decentralized a system, the less complexity it can handle. This is because more complex operations require more sophisticated methods of coordination between disparate parts or stakeholders. On the other hand, a centralized system can handle much greater complexity because the sequence of actions needed to perform a task are all conducted from one single machine that does not need to defer to anything else to perform the task.
The same can be said for blockchain networks. As we’ve seen blockchain progress to accommodate more complex use cases such as gaming, trading, and social media, the kinds of infrastructures needed to support these use cases must increasingly become more centralized in order to handle the transaction volumes without slowing down or becoming more expensive.
One of the solutions to the decentralization & complexity dilemma is to modularize the network so that different parts can independently tackle a portion of a complex task, ultimately making it simple and therefore manageable by a decentralized system.
Accumulate adopts this design principle through its use of Major and Minor blocks.
Major and Minor blocks are essentially 2 parallel tracks for verifying transactions using a different set of protocols. Each block is configured to capture events that occurred on the blockchain at different speeds, periodically synchronizing with each other to coordinate consensus on the true state of operations on the network.
Accumulate’s Modular Architecture
As a reminder, Accumulate takes a novel approach to its own modular architecture.
Each ADI (Accumulate Digital Identifier) is made up of a collection of independent sub-chains managed by 4 account types (Token Accounts, Data Accounts, Key book & Key page accounts, and Scratch accounts).
Each account is like a continually expanding Merkle Tree, which is a hierarchical data structure that succinctly encodes large batches of data in the form of a Merkle root or hash.
Hashes are like certificates that allow you to verify the history of transactions within a Merkle Tree through simple computation. They also make it possible for the consensus layer (where nodes coordinate to validate transactions from each Accumulate account) to be separated from the data layer, where all validated transaction data is stored as a hash.
Block Validator Networks or BVNs are responsible for producing hashes, which are then tied together and summarized by a Directory Network (DN).
The Directory Network plays a critical role in Accumulate, consolidating the records of all transactions that occur between the 4 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.
Minor & Major Blocks
To understand minor and major blocks, imagine a camera (the minor block) that captures a bird flapping its wings at 1,000 frames per second (FPS), while another camera (the major block) captures the same bird walking at 10 FPS.
Naturally, the 1,000 FPS camera will capture the event in more detail than the 10 FPS camera. Using an open communication network, both cameras can display what they have captured, allowing the 1,000 FPS camera to relay any details that the 10 FPS camera missed as a result of capturing fewer snapshots.
Minor blocks capture second-by-second changes that occur for a set of accounts within a BVN.
Major blocks compile the data of these second-by-second changes relayed by minor blocks to form a broader picture of what changes occur for the same set of accounts within 12-hour increments.
This delegation of responsibilities allows for each block to have its own block time, which is the amount of time it takes to add a new block of transactions to a chain.
Blockchains like the Bitcoin network have just one block time since every block is part of a single network. This means that in order for a new block to be added, each transaction must be verified by all nodes on the network and then recorded by a single mining node that produces the new block, a process that takes up to 10 minutes.
Due to Accumulates modular architecture, blocks aren’t bound by a single set of protocols that apply to every other block in the network, but instead follow a different set of protocols with their own block times, which can be fast or slow depending on their specific objectives.
This structure allows Accumulate to process transactions at high speeds using chains that are optimized for faster block times while still maintaining a secure record of all transactions in the Account chain using a different chain that is optimized to record hashes of the first chain’s data using slower block times.
Going back to our camera example, while the 1,000 FPS camera may be able to capture every detail of the bird’s movements, the 10 FPS camera does a better job capturing the full event as it occurred (e.g where the bird took off, the person holding it, etc).
Furthermore, indexing blocks to different time scales can also help to reduce the required storage space by limiting the amount of minor block data that needs to be stored on-chain after a given period of time. For example, minor blocks may choose to discard data after 2 weeks, leaving only the hash of the data which was captured by the major block in 12-hour increments.
With the help of BVN, consensus can be coordinated between major and minor blocks that operate as independent blockchains with their own block times, allowing Accumulate to maintain a single unified state through the Directory Network.
Ultimately, major and minor blocks present a unique way for Accumulate to bypass the decentralization & complexity dilemma through the modularization of the block confirmation process. This is particularly impactful in recording changes made to the Signature and Transaction chains of each account, allowing there to be a faster and more secure method of recording on-chain activities between entities on a blockchain.