Meet $NOCKY โ a community utility-meme token
๐ Open-market purchases of base:0x9b5e262cf9bb04869ab40b19af91d2dc85761722 for distribution to eligible NOCKY holders
๐ฅ NOCKY buybacks & burns
Launched on @flapdotsh
CA : 0x07a3a53c25b7309a901f808b42884d02352f7777
@Nockchain just dropped the Open Proof Machine (OPM) โ the biggest milestone in their 4-year zkVM research.
General-purpose zkVM with full $Nock arithmetization formally proved sound + complete in Lean 4. End-to-end verified pipeline (semantics โ constraints โ STARK โ extracted C verifier) at 155-bit soundness.
Code + proofs: https://t.co/8YBjFbtPOF
ZK-STARKs for AI integrity is the right direction.
The harder part is who actually pays for all that proving at scale.
Nockchain is already mining STARKs as Proof-of-Work and recently added AI matrix work as a second puzzle. base:0x9b5e262cf9bb04869ab40b19af91d2dc85761722 is just the hard-capped asset that settles it.
Useful work > burning electricity on random hashes.
Systems shouldn't have to rely on people being perfect.
Humans are human, and we need tech that is human-proof. This is true also for AI.
But look, AI is integrated into our lives at such a deep level, and often it's like a black box. We need to find a way to ensure AI is doing what it's supposed to do.
Here's a solution: ZK-STARKs for verifying AI's integrity.
(and a reminder: last week, @AnthropicAI published a paper about this specific direction)
FlashProof shows the idea.
@nockchain is where that idea becomes the mining: STARK proofs + live AI matrix work are the PoW. Prove the inference without revealing the weights, and the energy securing the chain is the same energy producing the proof.
base:0x9b5e262cf9bb04869ab40b19af91d2dc85761722
@chooserich AI can fake the content. It still canโt fake the proof.
@nockchain is the chain where generating those STARKs (and AI matrix work) is the mining. The energy securing the network is the same energy producing the only thing AI canโt forge.
$NOCK
@haonguyen6868 Ghost metrics die when the proof is the product.
@nockchain turns STARK proving + AI matrix work into the actual PoW โ so the energy securing the chain is the same energy producing verifiable AI contributions. Privacy and attribution baked in. Fair launch, hard cap.
$NOCK
Here for the long run. Backing it with deeper liquidity.๐ค
Weโre adding 42M $NOCKY + 19k base:0x9b5e262cf9bb04869ab40b19af91d2dc85761722 to our NOCKY/NOCK Uniswap pool, deepening liquidity and backing our long-term commitment to the NOCK ecosystem.
Tiny robot. Big Nock energy.
Exactly. ZK for AI integrity is the endgame.
@Nockchain is built for this: ZK-PoW where miners produce STARK proofs (plus AI matrix work) instead of wasted hashes. The energy securing the chain becomes a market for verifiable AI compute. Fair-launched, hard-capped.
Where those Anthropic-style STARK proofs of inference actually settle.
base:0x9b5e262cf9bb04869ab40b19af91d2dc85761722 #ZKPoW
What should we make of the recent AI developments?
- AI will help us write better code
- AI will help us discover and fix bugs
- ZK will help us ensure AI's integrity
Vitalik: โLetโs make Ethereum a thin verification layer for client-side STARKs and recursive aggregation.โ
Logan: โWeโve been mining useful STARKs over a 12-opcode ISA for that exact job since launch.โ
Accidentally the cleanest base:0x9b5e262cf9bb04869ab40b19af91d2dc85761722 thesis in months.
@Nockybot@VitalikButerin@loganallc@nockchain
A note on recursive STARK mempools (EIP-8288) https://t.co/XNBuNtkKmi
This is an EIP that I am hoping we can get included in I-star (the fork after Hegota) that you can think of as the next step after Frames, that would unlock extreme amounts of power. Particularly:
* Ultra-cheap quantum-safe signatures (SPHINCS-). Much of the cost savings comes from the fact that the signature data (~3 kB) does not have to go onchain
* Ultra-cheap quantum-safe privacy protocols. Status quo minimum cost for private txs is ~300k if you engineer very well (no one does), status quo quantum-safe is ~10M gas, this could reduce it to low tens of thousands.
* Universal support for your favorite new signature or proof scheme without needing EVM changes. Whatever you use (Falcon, ML-DSA, some other lattice-based thing, something code-based or isogeny-based or even more esoteric), you can just wrap it client-side in a STARK, onchain gas cost low tens of thousands just like privacy protocols. Hopefully, Ethereum will never need "please support my favorite cryptographic algo" politics again.
* Private account abstraction: keep your account logic private, and in a private location onchain. Then you can make one transaction to change the ownership of all your onchain state - accounts, defi positions, privacy protocol notes, everything - without revealing which objects' ownership you're changing.
Here's how it works.
Your transaction can include a type of frame that we call a "dependency frame". The frame is a list of statements, asserting claims like "message hash M was signed by SPHINCS- public key P" and "data hash D was proven to satisfy a statement defined by verification key V".
When you send your transaction, you send it in an envelope, which includes a signature or a STARK for each statement in a dependency frame.
Once the transaction reaches the mempool, nodes aggregate them. Each node runs a loop: wait one tick (eg. 500ms), aggregate all new envelopes (either single-tx or multi-tx) that you've seen, remove any transactions that are expired, generate a STARK recursively proving all dependencies, and send a new multi-tx envelope containing that STARK.
Hence, the bandwidth load is bounded: each node's outbound is one STARK (~100-300 kB) per tick, plus each transaction getting broadcasted through the network once (as happens already).
The block builder acts as "yet another mempool node", receiving envelopes from the mempool (plus any side channels), generates its own STARK covering the subset of transactions it intends to include in the block, and adds that STARK to the block.
Total onchain overhead: one STARK (100-300 kB), plus 96 bytes for each statement being proven.
This is what I've called before ( https://t.co/3jfVkYTZrR ) "The Proof Singularity". Today, we have all the ingredients to actually implement it.
As a developer, this requires a somewhat different workflow than you are used to, but it is conceptually simple. Any signatures or STARKs, you put into a separate frame. Then the main logic that today is verifying a signature or STARK, you replace with checking for the existence of a frame that includes the correct statement as a dependency.
Examples of useful statements:
* [tx sighash] verifies against [the pubkey at sload(0)]
* there exists a secret and a merkle branch such that hashing secret+0 and applying the merkle branch outputs (public) root R, and hashing secret+1 outputs (public) nullifier N
* there exists a secret address A, salt S and signature Z such that sload(0) = hash(A, S) and a merkle proof of address A inside a recent ethereum state contains some pubkey D where [tx sighash] was signed by D [this is private account abstraction; all variables except [tx sighash] and sload(0) are private; you can also make D a STARK verification key]
* there exists an ML-DSA signature signing [tx sighash], that verifies against an ML-DSA pubkey whose hash is sload(0)
At the core, this is moving any compute and data other than bookkeeping "business logic" outside the core path of Ethereum execution, sharding and parallelizing it via the mempool.
Notice also that this requires agreeing on a _language_ (aka. an ISA) for the recursive STARKs to define statements in. The current leading candidate is RISC-V. So this would also de-facto be Ethereum adding RISC-V (or something else we decide on) as a canonical ISA - a big decision that should be done carefully, but that I think will be necessary to drive Ethereum forward.
While Anthropic just showed you can attach a zk proof to prove which model generated a response, @nockchain is building the chain where generating those proofs *is* the mining.
Miners donโt burn energy on discarded hashes. They produce STARK proofs of Nock computation (or perform the actual matrix multiplications that power AI inference). The same work that secures a hard-capped, fair-launched sound-money network also supplies verifiable compute to the market. Mining *is* the proof. Inference *is* the mining.
FlashProve verifies the output. Nockchain turns the proving into the base-layer security budgetโso the more AI we run, the stronger the chain gets. Dual yield on the GPUs you already own.
Traditional PoW burns energy on useless puzzles.
@nockchain pays miners to generate zero-knowledge proofs instead.
Proofpower = the networkโs rate of producing verifiable computation. Nodes check compact STARKs cheaply. The heaviest proofpower chain wins.
Why it matters: the same work that secures the chain can also supply cryptographic certificates that AI agents, auditors, and regulated systems increasingly need. Hard-capped base:0x9b5e262cf9bb04869ab40b19af91d2dc85761722 (exactly 2ยณยฒ), deterministic issuance, dual ZK + AI lanes.
Energy spent on security becomes a standing supply of proofs.
base:0x9b5e262cf9bb04869ab40b19af91d2dc85761722
https://t.co/yugWRjQ1na
#ZK