Register and share your invite link to earn from video plays and referrals.

Search results for WOTSS_中間総括
WOTSS_中間総括 community
One keyword maps to one global community path.
Create community
People
Not Found
Tweets including WOTSS_中間総括
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: 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: ). 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.
Show more
0
287
1.5K
192
Forward to community
Happy weekend fam, Post-Quantum Cryptography could become one of the next major security narratives in crypto. NIST has already finalized its first PQC standards, while Ethereum, Bitcoin and several other ecosystems are exploring how to prepare for quantum threats. I think this narrative deserves more attention, especially as AI and quantum computing continue to advance. Here's why: – most major blockchains still rely on elliptic-curve signatures, which could become vulnerable to sufficiently powerful quantum computers. – Shor's algorithm could potentially break these signatures, putting exposed public keys and associated funds at risk. – NIST has standardized PQC algorithms such as ML-DSA, SLH-DSA and ML-KEM, giving the industry a clearer path toward migration. – upgrading blockchain security could create demand for new wallets, custody solutions, signature systems and migration infrastructure. Ofc, this threat isn't expected to materialize overnight. No publicly demonstrated quantum computer can currently break Bitcoin or Ethereum's production signatures at scale. But preparing major blockchain networks could take years. 20 tokens I'm tracking around the Post-Quantum narrative: Post-Quantum Cryptography could become one of the next major security narratives in crypto. NIST has already finalized its first PQC standards, while Ethereum, Bitcoin and several other ecosystems are exploring how to prepare for quantum threats. I think this narrative deserves more attention, especially as AI and quantum computing continue to advance. Here's why: – most major blockchains still rely on elliptic-curve signatures, which could become vulnerable to sufficiently powerful quantum computers. – Shor's algorithm could potentially break these signatures, putting exposed public keys and associated funds at risk. – NIST has standardized PQC algorithms such as ML-DSA, SLH-DSA and ML-KEM, giving the industry a clearer path toward migration. – upgrading blockchain security could create demand for new wallets, custody solutions, signature systems and migration infrastructure. Ofc, this threat isn't expected to materialize overnight. No publicly demonstrated quantum computer can currently break Bitcoin or Ethereum's production signatures at scale. But preparing major blockchain networks could take years. 20 tokens I'm tracking around the Post-Quantum narrative: [1] base:0x37696cd8f723ce541ac376f79fc109080e505ba3 – quantum-resistant L1 using XMSS since 2018. [2] algorand:native – Falcon-based State Proofs already live, with broader PQ initiatives. [3] $CKB – flexible cryptographic architecture with PQ signature support. [4] abelian:native – PQ-focused L1 combining lattice-based cryptography and privacy. [5] $CELL – modular blockchain infrastructure focused on PQ cryptography. [6] $QANX – EVM-compatible blockchain developing PQ security. [7] $MCM – early PQ blockchain using WOTS+ signatures. [8] $NAORIS – decentralized security infrastructure focused on PQ protection. [9] $STRK – STARK proofs offer a quantum-resistant foundation, while account signatures remain a separate challenge. [10] $ZEC – privacy ecosystem exploring long-term cryptographic resilience. [11] $NXS – security-focused blockchain with signature-chain architecture. [12] $QUBIC – quantum computing-related ecosystem, with a less direct PQC investment thesis. [13] minima:native – decentralized blockchain with quantum-related security ambitions. [14] $QTC – Quantus, a PQ-focused blockchain project. [15] $FHE – Mind Network, focused on encrypted computation rather than native PQ signatures. [16] $QONE – quantum-security and migration-focused infrastructure. [17] $AME – smaller blockchain project associated with PQ security claims. [18] $GEEQ – security-focused blockchain infrastructure. [19] solana:AUuCEHQ7sm2i5GmaHrpE961voWcTY8U6mgrkhcV7pump – QuStream, a smaller project making quantum-security claims. [20] $TDC – Tidecoin, an early hash-based PQ blockchain project. These projects are at very different stages. Some already use PQ signatures, others offer partial protection, while several remain roadmap-driven or only indirectly exposed to the narrative. My view: I would prioritize projects with actual cryptographic implementations over those relying mainly on quantum-related marketing. base:0x37696cd8f723ce541ac376f79fc109080e505ba3 and algorand:native are worth a closer look from a technical perspective. $STRK is also interesting because of its STARK-based architecture, although quantum-resistant proofs alone don't make an entire blockchain quantum-safe. I also think established ecosystems such as $ETH could benefit from a successful transition toward PQ security. The real opportunity may extend beyond individual L1 tokens into wallets, custody, interoperability and security infrastructure.
Show more
I don't recommend anyone scramble to move their funds to new wallets today. But we should take the risks to cryptography from AI-accelerated math seriously, and minimize our exposure to not just quantum-vulnerable cryptography, but also potentially AI-vulnerable cryptography. The core new area of risk from this viewpoint is, unfortunately, ML-DSA / FHE / lattices. (and it's also another reason, along with quantum, why ECDSA might fall even faster than expected, hence the "fresh address" recommendation) So far most people have been in the mode of thinking "elliptic curves broken, hashes safe, lattices safe". But there is a good chance that the concrete security of lattices will take serious hits from the next two years of AI math. The basic threat model is: factoring is something that naively takes 2^(n/2) time, but over decades smart people have found and optimized number field sieves, and degraded that to 2^O(n^(1/3)), which is why RSA keys and signatures need to be ~400 bytes (and not 64 bytes). What if there are skeletons in the closet like that, both for elliptic curves and lattices, that we are simply not smart enough to discover - but bots soon will be? This is a major part of the reason why for the past year ethereum's lean roadmap has been going in the "hash-only" direction: no lattices, no ML-DSA, no Falcon, no lattice-based commitments inside ZK proofs, etc. Signatures in lean ethereum are all hash-based, either WOTS or SPHINCS-. For signatures and proofs, we already know how to go hash-only. The bigger challenge is for *public-key encryption* - and this goes far beyond blockchains. Secure communication, anonymizing protocols, lots of things need public-key encryption. And unfortunately there are long-standing mathematical theorems showing why public-key encryption cannot be done with hashes alone. You have to have some kind of trapdoor object that has at least one form of usable "structure" - either group theory (incl. isogenies) or lattices or code-based or potentially in the future even more newfangled and spooky things (local mixing?). But for anything that has structure, you should assume that AI will make at least some progress in breaking that structure. Here, one reasonable inference is that if you want to make something plausibly long-term secure, multiply the key sizes by 10. To me that's a very plausible world and something not at all extreme to predict. If AI will bring us 50 years of math in 2 years, then that 50 years of math may very plausibly include a "naive factoring -> GNFS" level of improvement to our ability to break lattices. In that world, lattices will still exist, but they will have to be significantly bigger to guarantee the same level of safety. And at those new larger sizes, hash-based constructions will beat lattice-based constructions on concrete efficiency in every use case where hash-based constructions are possible at all. Theoretically, of course it's possible that hashes are broken too (eg. P = NP would imply that). But I think P = NP is very unlikely. And intuitively, it's much more likely that a mathematical object has exactly no exploitable structure (like hashes are intended to), than that a mathematical object has exactly ~3 forms of exploitable structure (for elliptic curves: associativity, Schoof, pairings) and not some secret fourth form of structure we have not yet discovered that greatly degrades its security (for elliptic curves, ECDLP and pairing security). Similar for LWE, SVP, RLWE and the zoo of lattice problems. For this reason, we do not yet see any reason to worry and start padding the byte size of hashes (if we start to worry more, we would pad the round count first before doing anything to the byte size). Concrete TLDR, my own personal views: * Hash-based > lattice-based, in those situations where hash-based is possible at all * For anything lattice-based, be much more paranoid on param sizes. Remember that blockchains are only a small portion of the cryptography story; this point goes far beyond blockchains and applies to eg. access to websites, secure messaging, Tor / VPNs ... * For privacy protocols, strongly favor NOT putting encrypted notes onchain. Instead, send them offchain through some third-party mechanism. * If it's not difficult for you, keeping your funds in addresses which have not yet been used to make a transaction is a good idea. If it's easy for you, do it. **But be careful about migrations; I personally have lost more money in botched migrations than I have lost in all hacks combined**. * For multisig wallets, doing confirmations offchain is better than onchain, because this way the signatures of signer wallets do not get exposed to the public, so if ECDSA falls to AI much faster than expected, at least the multisig "gracefully degrades" to a 1-of-1 where the 1 is whoever was gathering the signatures - a much better place to be than "anyone can take the money"
Show more
0
1.2K
11.2K
1.9K
Forward to community