I want to share a conceptual approach we are exploring for the Contractless blockchain—an alternative to traditional smart contracts that leans heavily on deterministic logic, protocol-level enforcement, and open interoperability.
The Problem with Current Smart Contracts
Ethereum and its derivatives introduced the world to smart contracts, but they are far from perfect:
- They are deeply tied to a specific virtual machine (e.g., EVM).
- Standards (like ERC-20, ERC-721) are platform-dependent.
- Contracts are written in code and require interpretation at runtime.
- Cross-chain portability is virtually nonexistent.
We're looking to redesign the concept of contracts entirely by eliminating the idea of execution environments and replacing them with deterministic validation models.
Enter: Custom Contract Structs
The Contractless model proposes allowing users to create custom structs, where all logic is encoded upfront as deterministic rules. Here’s a basic idea of what one might look like:
pub struct ContractStruct {
pub txtype: u8, // 1 byte: value 15 indicates custom struct
pub contract: String, // Hex-encoded validation rules
pub ... // User-defined fields (u8, u16, u32, u64, string, etc.)
}
The contract field defines how to interpret and validate the remaining fields. There is no VM. No Turing-complete scripting. Every rule is enforced by the node software deterministically. If it passes validation, it enters the chain. If not, it is discarded.
Think HTML, Not EVM
The long-term vision is to treat validation logic the way we treat web standards:
- Define the rules in a decentralized, open, blockchain-agnostic Contract Validation Standards Group.
- Publish versioned schemas that clients (like nodes) can use to validate transactions.
- Allow contracts to be interoperable across blockchains that adopt the same standards, just like HTML renders the same across browsers.
Just as browsers interpret the DOM without executing arbitrary binary code, Contractless nodes would interpret and enforce contract structs without executing arbitrary logic.
Why This Matters
- Security: No arbitrary execution = drastically reduced attack surface.
- Speed: Validation becomes a binary decision tree, not interpreted code.
- Portability: A contract can be understood across any chain implementing the spec.
- Simplicity: Contracts become declarative, like data schemas.
A Call for Collaboration
This is still in the idea phase. But we're laying the groundwork for something radically different from the dominant smart contract paradigm.
If you're interested in helping define the standards, brainstorm validation languages, or explore applications of this model, we welcome your insight.
The goal is simple: Make smart contracts as open, deterministic, and universal as HTML.
