Storage-based Consensus Paradigm

Definition

The Storage-based Consensus Paradigm (SCP) is a new consensus model defined as follows:

As long as the input and execution process of a deterministic computation are fully recorded in an immutable, traceable, and permanently available storage system, then no matter where the computation is executed, anyone can verify its correctness, achieving trustlessness.

In this model, trust does not come from "who" executed the computation or "where" it was executed, but from the fact that anyone can verify how it was executed.

Background and Origins

Traditional blockchains derive their security from a simple but expensive rule: every node must repeat the same computation and reach consensus.

• Bitcoin requires all nodes to hash continuously to prevent cheating.
• Ethereum makes every node run the same smart contracts to ensure global state consistency.

While secure, this model is highly inefficient:

• Massive computational power is wasted on redundant work
• The network must stay tightly synchronized, limiting TPS
• It struggles to support compute-heavy tasks like AI inference or big data analysis

SCP is designed to solve this core contradiction between security and performance.

Inspiration: The Turing Machine

SCP’s design can be explained using the analogy of a Turing Machine.

A Turing Machine consists of two parts: a finite state machine (control logic) and a tape (stores all input and intermediate state). The machine reads and writes on the tape, executing step by step according to deterministic rules.

If the tape is public, immutable, and universally accessible, then anyone can replay the Turing Machine’s execution to verify the result—no need to trust the original executor.

In the SCP model:

• The local node acts as the Turing Machine’s state machine, responsible for computation
• The permanent storage layer is the "tape", recording the input and the full execution process

As long as the tape is publicly verifiable and immutable, the computation is truly trustless.

In HyMatrix, this “tape” is implemented using Arweave as the primary storage network. Arweave provides decentralized, tamper-proof, low-cost permanent storage—ideal for recording execution logs over the long term.

In theory, the “tape” could also be implemented using Bitcoin or Ethereum blockchains, but the cost and limited storage make them impractical for large-scale logs. Thus, Arweave is a more feasible choice.

Core Idea

The central question SCP asks is:

“Do we really need everyone to re-execute the same computation?”

The answer is no. What users care about is not who runs the computation, but whether the result is correct and verifiable.

Under SCP, execution is free-form. Nodes can compute anywhere, anytime, using any hardware, without requiring global synchronization.

The only requirement is: nodes must produce a verifiable, structured execution log.

This log is not just a result. It's more like a full execution recording, capturing:

• Inputs and parameters
• Call context and metadata
• Every step and its order in the execution

Anyone can download the log and replay the execution locally in the same environment to verify the node’s computation was correct and compliant.

Formal Description

We can express the SCP consensus model as follows:

• Let F be a deterministic computation function that takes inputs and produces a unique output.
• Let I be the input data.
• Let P be the execution process, which includes call context, parameters, step sequences, and timestamps.

When a node completes execution locally, it produces a log:

L = (I, P)

This log must satisfy the following properties:

1. Immutability: Once written to storage, it cannot be modified or deleted.
2. Traceability: The log includes complete I and P, sufficient for any verifier to independently replay the full computation.
3. Availability: The log must be publicly accessible at any time.

In SCP, the role of the consensus layer is to ensure that L meets these properties. Any verifier V can retrieve L and replay the execution in the same virtual environment.

The replay function in SCP is used to validate original computation by re-executing the steps described in the log. We can write the optimized form as:

F(extract_I(L)) = replay(L)

Where:

• F is the deterministic function representing the computation logic.
• L = (I, P) is the log containing input I and execution trace P.
• extract_I(L) extracts the input from the log.
• replay(L) uses both I and P to replay the full execution.

This emphasizes the integrity of L: a verifier can retrieve L from storage and input it directly to replay. Since F is deterministic and L satisfies immutability, traceability, and availability, the replayed result will match the original output—enabling verification without trusting the original node.

The Magic of Simplification

Put simply, SCP (Storage-based Consensus Paradigm) is a new method of establishing trust.

In traditional blockchains, building trust means everyone has to recalculate everything—which is slow and wasteful.

SCP says: let one node do the work, but record everything like a video.

These execution logs are stored in a tamper-proof, globally accessible location (e.g. Arweave).

Anyone who wants to verify can download the logs and replay the computation. As long as the inputs and process are real, the result must be correct.

The key is: no need to re-execute—just verify whether the original computation was valid.

As a result:

• Nodes can compute freely, in parallel, and efficiently
• The network still remains trustless and verifiable

In short: SCP enables scalable, decentralized computation that is both efficient and verifiable by anyone.