Actors and Blockchains, Together

The FastSet protocol represents a fundamental departure from traditional blockchain architectures by abandoning the requirement of strong consistency -- the property that forces all transactions into a single, globally agreed-upon sequence. Instead, FastSet draws inspiration from the actor model of concurrent computation and recent breakthroughs demonstrating that total ordering is unnecessary to prevent double-spending attacks. The protocol allows a set of clients to settle verifiable claims consistently using a set of validators, where validators replicate the global state but need not communicate with each other. This design enables embarrassingly parallel settlement of arbitrary verifiable claims, including payments, digital asset transfers, verifiable computations, and more. The paper proves the protocol correct despite its massively parallel nature, establishing security, determinism, monotonicity, and liveness properties.

At its core, FastSet generalizes the payment system protocol FastPay by introducing the concept of a claim as any statement that is independently verifiable. Claims encompass a remarkably broad range of operations: facts ("I am Joe Smith"), oracle data ("the price of gold is 100 USD"), computational results ("Python program fibonacci on input 10 evaluates to 55"), game moves, votes, and traditional payments. For simplicity and generality, FastSet assumes a global state replicated in each validator, where a claim $c$ is valid in state $s$ (written $c \downarrow_s$), and processing it yields a new state $\llbracket c \rrbracket s$. These notations extend naturally to sequences of claims $c_1 c_2 \ldots c_k$, where validity means each claim is valid in the state produced by processing the previous ones.

The critical abstraction enabling FastSet's parallelism is weak independence. Two claims $c$ and $c'$ are weakly independent, written $c \| c'$, if and only if for any state $s$, whenever both $c \downarrow_s$ and $c' \downarrow_s$, then both orderings are valid and produce the same result: $c\,c' \downarrow_s$, $c'\,c \downarrow_s$, and $\llbracket c\,c' \rrbracket s = \llbracket c'\,c \rrbracket s$. This weakens the classic notion of independence from concurrency theory (Mazurkiewicz traces) by requiring commutativity only in states where both claims are already valid. Payments by different clients are weakly independent because the order in which an account receives payments is irrelevant -- a key insight from recent work on cryptocurrency consensus numbers. Other examples include commutative operations on shared locations (voting, reputation systems), updates to CRDTs (Conflict-free Replicated Data Types), and accesses to disjoint storage.

The FastSet protocol operates as a seven-step process assuming $3f + 1$ validators with at most $f$ Byzantine, where a quorum is any subset of $2f + 1$ validators. A client $a$ signs a message $m := \langle c_1 c_2 \ldots c_k, n \rangle_a$ containing its claims and a nonce $n$. Verifiers approve the message, and a proxy broadcasts it to validators. Each validator $v$ checks signatures, nonce $v(a).nonce = n$, verifier quorum, the pending condition $v(a).pending \subseteq \{m\}$, and claim validity $c_1 c_2 \ldots c_k \downarrow_{v.state}$. Upon validation, the validator signs the message and returns it. Once a validator quorum is reached, a certificate $\langle m \rangle_\#$ is created and broadcast. Validators then add the message to a $v.presettled$ set and process it when ready, updating their state to $v.state := \llbracket c_1 c_2 \ldots c_k \rrbracket v.state$.

The formal correctness proof of FastSet establishes four key properties. Security ensures that only one certificate per client per nonce can be generated, preventing double-spending -- this follows from the pigeonhole principle on quorum overlap among honest validators. Determinism (Theorem 2) proves that interleaving equivalent claim sequences $\gamma \equiv \gamma'$ are weakly equivalent $\gamma \Downarrow \gamma'$, meaning the processing order is irrelevant. Monotonicity (Theorem 3) states that for any $a$-maximal interleaving cut $\gamma \sqsubseteq_a \gamma'$, if $\gamma\,c \downarrow_s$ for $c \in Claim_a$, then $\gamma'\,c \downarrow_s$ -- once a claim is valid, it remains valid regardless of other clients' activities. Liveness (Theorem 4) guarantees that validators never get stuck: if compatible sequences $\gamma \triangle \gamma'$ exist with $\gamma' \not\sqsubseteq \gamma$, then there exists a claim that can extend $\gamma$ while maintaining compatibility.

FastSet is not strongly consistent, but it achieves strong eventual consistency (SEC): any two validators that have received the same (possibly interleaved) claim updates will be in the same state, regardless of interleaving order.

The paper introduces SETL (pronounced "settle"), an actor-inspired scripting language for generating claims on FastSet. SETL distinguishes between user-driven accounts (controlled by key pairs, free to issue any claims) and contract-based accounts (governed by fixed SETL scripts). Through a series of Web3-relevant examples, the paper demonstrates practical applications: multi-signature accounts using templates like MULTISIG[SIGNERS,QUORUM]: do(C) { verify(SIGNERS,QUORUM); C }, voting contracts where order of votes is irrelevant, escrow contracts with buyer/seller/agent interactions, non-native token contracts with balance maps, and even full blockchain/appchain implementations as SETL contracts. Each example is carefully designed to preserve the weak independence property.

Perhaps most remarkably, FastSet supports verifiable computing for arbitrary programming languages and VMs. A language or VM is itself a claim on FastSet, and programs are settled similarly. The VERIFIED_COMPUTE template takes a language, verifiers, and quorum as parameters, allowing clients to submit computation results along with proofs that are verified by specialized service providers. This means FastSet can serve as a universal settlement layer: blockchains become clients that generate verifiable computational claims, execution layers like MegaETH become fast claim generators, and the validators merely check signatures and update state. As the authors conclude, "FastSet should not be regarded as the foundation for the next blockchain. It should be regarded as the Web3 infrastructure on which the next wave of blockchains and verifiable computing applications will be built."

The protocol can be extended in several directions, including gossip communication among validators for more efficient claim broadcasting using technologies like Optimum and set reconciliation, committee-based approaches similar to Algorand for further parallelization, and integration with fast execution technologies. FastSet's theoretical contribution lies in demonstrating that the tyranny of sequentiality imposed by blockchain consensus can be abolished while preserving the essential security guarantees of decentralized systems. The separation of verification from settlement, combined with the weak independence abstraction, opens the door to a truly concurrent, safe, and scalable infrastructure for digital assets that can handle the millions of transactions per second demanded by AI agents and modern applications.