Architecture
Nockchain is a blockchain, meaning that it consists of a series of ordered timestamped blocks which include globally consistent transaction data. Blocks are produced by miners competing to solve a proof puzzle to bundle transactions and win a block reward. Transactions result from users and applications interacting with the chain's native $NOCK token either directly or via consensus apps.
A user interacts with Nockchain via the nockchain program, which is either configured to mine or simply to sync and observe. This nockchain program is a NockApp app communicating with the universe of other nockchain instances. (This is what happens out of the box from github.com/zorp-corp/nockchain.) A wallet, which shows address balances and builds and signs transactions, is a NockApp talking to a local Nockchain instance to obtain chain state.
Mining pools exist and can use various strategies to distribute the block rewards among participants.
Running a Node
Notes and Transactions
A note is a UTXO, or Unspent Transaction Output. For instance, a $NOCK transfer consists of a signed transaction with input and output addresses.
Nockchain does not have proof-of-stake-style accounts: all data and assets live within notes onchain. Notes may declare intents, conditions under which they may be spent (see Intents for details). App rollup operators or onchain intent-solvers may execute these intents in batches, providing a proof that all conditions in the batch were satisfied (see Rollups for details).
Using a WalletBlocks and Block Height
A block consists of a header and a nonce over a tree of Merklized transactions. Blocks are ordered and the longest block height is considered canonical.
Proofs and Proofpower
A proof is a demonstration of the consistency of a set of transactions with the Nockchain global chain status at a given block height. A zero-knowledge proof (ZKP) proves a statement or computation is correct without requiring knowledge of any of the underlying details.
The basic metric of Nockchain's capability and security is its "proofpower", or the sum total of proofs per second generated by miners operating on the network at any given time. Sufficient honest mining power from genesis onwards protects against selfish mining and secures the network. The Nock ZKVM has the guarantee that there is only one valid computational transcript exists for each puzzle instance, preventing unfair advantages that break the protocol's security assumptions.
Miners
Miners are network nodes who secure the network by providing proofpower—their ZKPoW competition checks and confirms the security of the network and its transactions.
Intents
Intents are declarative conditions under which a note may be spent which allow for offchain applications to interact with onchain assets and data. Intents are expressed through a comprehensive set of native lockscripts:
Signature locks (Schnorr signatures)
Timelocks
Hashlocks
ZK-proof lock
Merkle proof lock
Fraud proof lock
Similar to Taproot scripts, basic lockscripts may be combined in a Merklized Abstract Syntax Tree of OR statements, any of which may be satisfied to spend the note.
A critical component of blockchain usability is atomicity—ensuring multiple actions occur completely or not at all—and composability, the ability of applications to interact and build upon each other seamlessly. Nockchain approaches atomicity and composability by leveraging an intent-based transaction model rather than direct smart contract invocations. Users or applications express high-level intents, specifying desired outcomes without explicitly scripting every intermediate step onchain. Offchain application logic then processes these intents, producing state updates and cryptographic proofs demonstrating correct intent fulfillment. Multiple intents across different offchain applications can be aggregated into a single cryptographic proof. When posted to the Nockchain settlement layer, these aggregated proofs simultaneously and atomically update the state for all related intents, effectively emulating synchronous atomic composability in an asynchronous, proof-based model. Nockchain acts as a shared sequencer—a single settlement layer—for all its app rollups. Shared sequencing enables aggregation of transactions in batches and atomic composability.
Rollups
All data and assets live within notes onchain. Notes may declare intents, conditions under which they may be spent. App-rollup operators or onchain intent-solvers may execute these intents in batches, providing a proof that all conditions in the batch were satisfied. A cornerstone of Nockchain’s design is its native support for composability of intents across applications. Multiple intents from independent offchain apps are aggregated into batched proofs with explicit dependency chains, ensuring atomicity: either all dependent intents within a combined proof succeed, or none do. Nockchain’s settlement layer verifies aggregated proofs atomically, allowing large batches of notes to be spent or modified simultaneously with minimal onchain execution.
Developers write their state machines in Jock or Hoon, compile to Nock and let the framework handle persistence, networking and proof generation. Developers no longer optimize gas at every line of code; cost is dominated by the size of the proof and the bytes they store on chain. Users interact with a single wallet and never wonder which network holds the deepest liquidity or lowest fees.
Nockchain’s offchain app rollup model achieves significant scaling advantages by delegating computation offchain, greatly increasing throughput and computation capability beyond traditional onchain smart contract limits. User experiences benefit from instant offchain responsiveness through pre-confirmations, effectively masking the underlying longer settlement latency. Atomicity and composability are addressed through intent-based aggregation, enabling powerful cross-app interactions without sacrificing the atomic guarantees essential for secure and predictable blockchain interactions. While introducing novel tradeoffs, this model provides a scalable and efficient alternative to the traditional smart contract approach.
Nockchain pushes the execution of application logic entirely offchain, employing zero-knowledge proofs (ZKPs) for cryptographic verification of correct computation. Developers execute application-specific logic offchain, then produce succinct proofs of correctness that are subsequently verified onchain. Because validators only check these proofs instead of re-running computations, Nockchain dramatically improves scalability, removing the centralizing linear execution bottleneck. Offchain apps handle computation independently and in parallel, significantly increasing throughput and allowing far more computationally intensive operations without burdening the onchain settlement layer.
However, this improved scalability and efficiency introduces a latency tradeoff. Onchain smart contract systems typically offer predictable latency; users submit transactions and wait only for a block confirmation—often seconds to a minute—to achieve finality. Nockchain, operating similarly to Bitcoin in block intervals of approximately ten minutes, inherently has higher onchain settlement latency. This choice is intentional, prioritizing chain stability and a low orphan rate over faster finality. Yet this longer block interval is carefully mitigated from the user’s perspective through preconfirmations. Because app logic executes instantly offchain, applications built on Nockchain can deliver immediate feedback to users. Users experience near-instant responses to their interactions, such as trades, game actions, or state updates, despite the longer underlying settlement times. As such, Nockchain leverages offchain execution to provide users with responsive, low-latency interfaces that resemble Web2-like interactions, even though underlying onchain finality remains slower.
Last updated