←
Calc17,501 posts
Calc avatar

Calc

@Calcutat

Friendship | FOCG | STARKS | AI | Quantum Contributing @starkwareltd @LootRealms @daydreamsagents views are my own

◷ Joined April 2021▧ 2,302 Photos and videos
Calc avatar
⟳ Calc retweeted
Calc@Calcutat·Nov 16

theyre bullposting recreating starknet from first principles again

Over the past few weeks I've gone from thinking leanPCS is total bull to being a total bull. So let me explain some of these buzzwords in more detail. At the core, 8288 is about hyper-scaling data and execution for any computation that needs to get performed on a piece of data once, the chain learns the answer, and then we never need to see that data again. This sounds very specific, but it includes most "heavy" things happening on Ethereum: * Signatures * STARKs * Merkle branches * FHE computation * ... Really the first two are the most important. Once we go quantum-safe, signatures get bigger (65 bytes ECDSA -> 1-6 kB WOTS/SPHINCS depending on params) and ZKPs get much bigger (200-1000 bytes with groth16, PLONK, etc -> 128 kB with STARKs). This is unsustainable to put on chain, and 8288 fixes this. 8288 works by aggregating STARKs in the mempool. First, you as a user generate the STARK or SPHINCS signature or PCS opening (more on that last one later), and publish it. Then, each node listens. Each tick, each node takes all of the new objects that it has seen, and generates a STARK containing a list of "claims": "pubkey P has signed message M" "program X run on data D has output Y" "p(X) = Y for some polynomial P whose hash is H" and a proof that it has seen a signature, STARK or PCS opening verifying those claims. So the only information getting re-broadcasted is: (i) hashes of inputs and outputs (~64-96 bytes per claim) (ii) a single STARK proof per tick These aggregate proofs themselves get re-aggregated, and eventually you get to a single "master proof" in the block, that verifies that all of those statements are true. And so the only other data that has to actually go on chain is the statements (the (P, M), (X, D, Y), (X, Y, H) tuples I described above), not the actual signatures or proofs. This gets put into a specialized frame type. Now, let's get into the leanSPHINCS vs leanSTARK vs leanPCS part. The core distinction is: *what is the underlying object that the user is creating?* In leanSPHINCS, it's a signature, and specifically this particular type of purely-hash-based signature: ethresear.ch/t/sphincs-minus… If we add leanSPHINCS, then users will be able to make quantum-safe accounts, and pay only a little bit of gas (4096 for the 64 bytes) for each signature. So we get scalable quantum-safety for regular accounts, multisigs, etc. But it's only one specific signature scheme, you can't do anything else. In leanSTARK, it's a STARK. This means it's fully general: the user runs whatever computation they want, and publish a STARK of it. So you can use it for: * Any signature scheme (including eg. lattice-based ones if you like those) * A multisig that hides its internal logic * Privacy protocols * Private account abstraction: authorization logic that depends on some value hidden elsewhere in the state, so you can have one key that controls all your accounts without publicly linking them to each other Basically, it's a free for all, in the same way the EVM is a free for all. But leanSTARK has a practical downside. The protocol would have to specify the language in which users write their programs (we call this the "ISA"). So we would have to agree on that language. This is a really big deal - it's the first big case of "Ethereum moving beyond the EVM" - and so it's likely to take time to agree on the details of it, especially since the ISA would be hard to upgrade. There are benefits to taking longer on this, figuring out the ideal ISA, and then even giving access to it inside regular contracts. LeanPCS is the third option. PCS stands for "polynomial commitment scheme": a proof that P(x) = y. The most important thing to know about PCSes is that they are by far the most important "hard" component of a STARK (see here: vitalik.eth.limo/general/202… ). If you have a "magic PCS oracle" (which from the EVM's point of view, 8288 is), you can verify a STARK in ~20-40k gas. The most important gain with PCS is that there is far less that we need to choose. Specifying a PCS only requires specifying a field, and there is a natural option: the 128 bit binary field (technically, we can go more general than that, and say the 2^k-bit binary recursive tower field, going up to 256) LeanPCS is less efficient than leanSTARK onchain, because you would have to put multiple claims to prove one thing. But it's arguably more efficient offchain, because you have much more flexibility to choose proof systems. But most importantly, leanPCS gives you the same generality as leanSTARK, in a way that could potentially be implemented very quickly. And once we figure out the ISA, we can add leanSTARK later. So there is a route to getting "the cryptographic proof singularity" much faster than any of us expected, and that route runs through 8288 with leanPCS. firefly.social/post/x/212092…

Calc avatar
Calc@Calcutat·Nov 9

its been like 3 months of anthropic dominance

Introducing Claude Fable 5.2 and Claude Mythos 5.2, designed to tackle the most daunting technical challenges. They’re capable collaborators on ambitious projects in many fields, and show improvements in areas like coding, reasoning, and vision.

0:19
BirthdayBoi avatar
⟳ Calc retweeted
BirthdayBoi@BirthdayBoi·Nov 5

I’m playing the new @LootRealms Frontier - Devcon Edition! New to Realms games, but I’m having a blast, and it’s completely free. Even cooler: I’m nowhere near the top of the leaderboard, yet I grabbed 1,200 $LORDS (~$8) just from exploring the map.

Post attachment
Calc avatar
Calc@Calcutat·Nov 5

AI bros just know that when they make yall one of these next cycle it is the absolute giga bottom

Post attachment

Top of the Democratic agenda on day 1 needs to be a pause on advanced AI development, regulation of this out of control industry, and a ban on artificial superintelligence.

Calc avatar
Calc@Calcutat·Nov 4

bottom gud coins, non scams, real builders top bundler cabal, snipers, scams

Tradeguru 🧠 avatar
⟳ Calc retweeted
Tradeguru 🧠@tradeguru·Nov 3

The post-quantum path @Starknet is taking is revealing more serious loopholes in blockchain design than I thought. StarkWare built a framework from NIST's 'general crypto-agility guidance' to test how agile blockchains are, and only one chain scored 8/8. Bitcoin itself passes 7 of the 8 tests, tied for second among the 10 chains scored, yet it faces one of the hardest migrations. NIST wrote the guidance but doesn't rate chains, so StarkWare built the 8 questions and scored the networks itself. It's a bit technical, but let's review it. ➥ Based on NIST's guidance on crypto agility, the 8 questions ask whether a chain can replace its cryptography and keep running: 1. Can an existing account switch to a new signature without a network upgrade? 2. Can its formats handle bigger keys and signatures? 3. Can one cryptographic part be replaced without redesigning the rest? 4. Can old and new signing run side by side undedr migration? 5. Has the transition been tested? 6. Can an attacker be stopped from forcing a weaker algorithm? 7. Can the old algorithm be switched off after migration? 8. Can existing data be migrated? A point only counts if the path works today under current rules. Anything that needs a future upgrade scores zero. Across 10 networks the scores are @Starknet 8, @Bitcoin 7, @Algorand 7, @NEARProtocol 7, @QRLedger 6, @Zcash 6, @ethereum 3, @solana 2, @Optimism 2 and @RobinhoodCrypto 1. ➥ The test that separates Starknet from the 7s is the first one. On Starknet every account is a smart contract, so a wallet can replace its signature check and keep its address and funds. StarkWare confirmed this with @ready_co. A coin on the Bitcoin network has to move to a new address to use new cryptography, and NEAR and Algorand accounts can only choose schemes the protocol has already switched on, nothing more. What I respect most is what the score does not claim. It is not a security rating. QRLedger scores 6 yet shows lower exposure on the same Hub, because its signatures are already hash-based. Starknet's standard accounts still sign with elliptic curves, and its post-quantum Falcon-512 account is an unaudited mainnet demo that ordinary users can't adopt yet. So my takeaway is that being able to change and having already changed are two different things, and a chain needs both. Next, I'll break down where Starknet stands on the second. For now, what's your take on this?

Post attachment

1/ Bitcoin passes 7 of our 8 cryptographic-agility checks. So why does it still face one of the hardest post-quantum migrations? Because upgrading the network's cryptography is one thing. Moving everyone's BTC is another 🧵

Post attachment
StarkWare avatar
⟳ Calc retweeted
StarkWare@StarkWareLtd·Nov 3

Anthropic is using cryptography StarkWare’s founders co-invented to prove which AI model answered you. With FlashProve, you can verify that a specific model produced an output while keeping its weights private. The report cites the original STARK paper, highlights the use of STARKs on @Starknet, and references formal verification work on Cairo and the S-two AIR. StarkWare co-founder Alessandro Chiesa is one of the report’s co-authors. Another big validation for our Proving System. The same cryptographic ideas that help scale blockchains are now helping make AI inference verifiable.

0:54
sam avatar
⟳ Calc retweeted
sam@8am1am·Nov 3

Anthropic used STARKs, specifically. zCASH deployed SNARKs, elliptic-curve based The confidence is impressive, because Anthropic used the proving system StarkWare has been pioneering since 2020. not just any SNARKs, STARKs.

Eli Ben-Sasson | Starknet.io avatar
⟳ Calc retweeted
Eli Ben-Sasson | Starknet.io@EliBenSasson·Nov 3

Anthropic @AnthropicAI ❤️ zkSTARKs: In collaboration with @StarkWareLtd co-founder Prof. Alessandro Chiesa and other brilliant researchers, Anthropic just open sourced a zk STARK system for proving the integrity of LLM inferencing, bringing us closer to verifiable AI. As we said long ago (since 2018), zkSTARKs are the end-game: highest scale, best security (post-quantum). Now, also AI agile and supporting AI integrity. anthropic.com/research/prova…

Calc avatar
Calc@Calcutat·Nov 3

on formal verification

Calc@CalcutatOct 30

Subtle Starknet bullpost - FV & Open source We have spent several years pushing the most robust level of fv in the industry, verifying most of the Starknet stack. That covers the prover encoding the Cairo VM, core CairoZero functions, the compiler’s building blocks, and the STRK20 pool, all including no double-spends. All open source. See more: starkware.co/blog/strk20-for… - distributed All VC unlocks end in march 2027 🫡

Eli Ben-Sasson | Starknet.io avatar
⟳ Calc retweeted
Eli Ben-Sasson | Starknet.io@EliBenSasson·Nov 3

The challenge: we prepare for the threats we know are already here. We prepare for the ones we know are coming. But what do we do about threats we can't anticipate just yet? The answer: We maintain crypto agility. We have to build systems that can adapt quickly and easily, even to threats we haven't anticipated yet. Good article. Read 👇

StarkWare @StarkWareLtd Nov 3 Article Why Quantum Security Is Not Enough to Secure Your Blockchain For decades, the quantum question was when a quantum computer may arrive. In 2026 a second question took over: how fast is the math moving? AI is now helping find cheaper attacks and new proofs at a

Calc avatar
Calc@Calcutat·Nov 3

> The AI labs themselves are using @Starknet tech and formal verification to enable trust in their models Everyone will use our tech and be happy

Post attachment

StarkWare @StarkWareLtd Nov 3 Article Why Quantum Security Is Not Enough to Secure Your Blockchain For decades, the quantum question was when a quantum computer may arrive. In 2026 a second question took over: how fast is the math moving? AI is now helping find cheaper attacks and new proofs at a