Yash Mourya

COMING SOON...V3

Big move: Meta is exploring USDC payments for creators across its platforms. If this rolls out to all 4B users, it becomes the largest crypto economy overnight. Thoughts👇 @solana @Meta

Launched Nexus 2 days ago. 100+ users already. Across India, USA, Egypt & Spain. 🌍 We’re just getting started. #buildinpublic #indiedev #startup

Today we launched the Nexus Talent Scanner (V2). It’s fast, clean, and built to make job discovery and scanning workflows feel effortless. Open source on GitHub — try it, explore the code, and contribute if you’re so inclined: yash514131.github.io/Nexus_Job_web/ #buildinpublic

Nexus v2 just dropped. Same 235 companies. New engine. Senior jobs: 260 → 3,197 Internships: 32 → 862 We didn't tweak it. We rebuilt it. This is v2. More coming. #Nexus

Just got selected for the DEV3PACK Hackathon! Excited to build, learn, and collaborate in the Web3 space. Let’s see what we can create 🔥 @dev3pack @solana @ElevenLabs @v0

@Red_Zetsu8 @shnav3105 DM me your email—I’ll send you the beta version. I’d love to get your feedback

@shnav3105 is this like an app or site?

I have started using this. Great way to relax and let the app do all the work. It's great to find an opportunity which you need. I use to find jobs like Product Managers.

@Red_Zetsu8 @shnav3105 It's an App

@shnav3105 Really appreciate this, Vaishnav! Glad it’s helping you discover opportunities more easily 🙌

Sit back, relax—Nexus finds your next Web3 job

Ethereum is going post quantum. pq.ethereum.org

Programs initialise....

a sleek multisig wallet for Solana, built entirely with Flutter! 🚀 Secure team/DAO treasury management on the fastest chain. Open-source vibes, mobile-first design. Check it out + feedback welcome! @solana @FlutterDev #Web3 #Crypto #Blockchain

@VitalikButerin @yq_acc Linearity in writing is a legacy constraint from speech, not an inherent property of thought. The fact that we're still debating "is this proper writing" for anything that isn't a paragraph is the same energy as people who argued hyperlinks would ruin literature.

.@yq_acc translated one of my recent posts from English to "English with better syntax highlighting". I encourage reading it, it's actually much more readable than my original post :D It's been fascinating to watch programming-language-style syntax structure and highlighting break out into written language. I feel like we've seen "traditional print media style prose" fall away over the past few years and get replaced by a much heavier emphasis on bullet points, diagrams, etc. These ideas that are fundamentally superior to linear written text, and the fact that programming languages, a medium without pre-existing cultural expectations, adopted them right from the beginning is evidence of this. Speech has to be linear, because our ears can't hear many things in parallel, but for a long time we've been hampered by the idea that our representation of written words has to simply be a direct linear representation of the speech. What if we go beyond that? What if we make the *structure* of an essay, either low-level grammar or higher-level ideas (which claims support which other claims, what ideas are placed in contrast to which other ideas, the temporal ordering of some process that is being described...), much more visible so that the reader's mind can subconsciously pick it up? In principle it can be very effective: if I make a statement X supported by A, B and C, and the reader immediately feels the most curiosity about B (or they already understand A and C, or...), then they can just skip straight to B. I hope that over the next few years we can see a lot more innovation in writing style. I'd even say break open the taboo, fictional work should also be open to these kinds of things (prose <-> graphic novel is a spectrum, not a binary) I also hope we can figure out standardized markdown extensions to make all these things nice and easy. I know of various textual diagramming languages, but it would be good to have a really good one that gets the same adoption and legitimacy that markdown has. x.com/yq_acc/status/…

@ethereum TCP/IP let machines find each other. DNS let humans name them. ERC-8004 does both — but for agents, and with accountability baked in from day one. The internet took 30 years to bolt on trust. The agent economy is starting with it.

Now, the quantum resistance roadmap. Today, four things in Ethereum are quantum-vulnerable: * consensus-layer BLS signatures * data availability (KZG commitments+proofs) * EOA signatures (ECDSA) * Application-layer ZK proofs (KZG or groth16) We can tackle these step by step: ## Consensus-layer signatures Lean consensus includes fully replacing BLS signatures with hash-based signatures (some variant of Winternitz), and using STARKs to do aggregation. Before lean finality, we stand a good chance of getting the Lean available chain. This also involves hash-based signatures, but there are much fewer signatures (eg. 256-1024 per slot), so we do not need STARKs for aggregation. One important thing upstream of this is choosing the hash function. This may be "Ethereum's last hash function", so it's important to choose wisely. Conventional hashes are too slow, and the most aggressive forms of Poseidon have taken hits on their security analysis recently. Likely options are: * Poseidon2 plus extra rounds, potentially non-arithmetic layers (eg. Monolith) mixed in * Poseidon1 (the older version of Poseidon, not vulnerable to any of the recent attacks on Poseidon2, but 2x slower) * BLAKE3 or similar (take the most efficient conventional hash we know) ## Data availability Today, we rely pretty heavily on KZG for erasure coding. We could move to STARKs, but this has two problems: 1. If we want to do 2D DAS, then our current setup for this relies on the "linearity" property of KZG commitments; with STARKs we don't have that. However, our current thinking is that it should be sufficient given our scale targets to just max out 1D DAS (ie. PeerDAS). Ethereum is taking a more conservative posture, it's not trying to be a high-scale data layer for the world. 2. We need proofs that erasure coded blobs are correctly constructed. KZG does this "for free". STARKs can substitute, but a STARK is ... bigger than a blob. So you need recursive starks (though there's also alternative techniques, that have their own tradeoffs). This is okay, but the logistics of this get harder if you want to support distributed blob selection. Summary: it's manageable, but there's a lot of engineering work to do. ## EOA signatures Here, the answer is clear: we add native AA (see eips.ethereum.org/EIPS/eip-8141 ), so that we get first-class accounts that can use any signature algorithm. However, to make this work, we also need quantum-resistant signature algorithms to actually be viable. ECDSA signature verification costs 3000 gas. Quantum-resistant signatures are ... much much larger and heavier to verify. We know of quantum-resistant hash-based signatures that are in the ~200k gas range to verify. We also know of lattice-based quantum-resistant signatures. Today, these are extremely inefficient to verify. However, there is work on vectorized math precompiles, that let you perform operations (+, *, %, dot product, also NTT / butterfly permutations) that are at the core of lattice math, and also STARKs. This could greatly reduce the gas cost of lattice-based signatures to a similar range, and potentially go even lower. The long-term fix is protocol-layer recursive signature and proof aggregation, which could reduce these gas overheads to near-zero. ## Proofs Today, a ZK-SNARK costs ~300-500k gas. A quantum-resistant STARK is more like 10m gas. The latter is unacceptable for privacy protocols, L2s, and other users of proofs. The solution again is protocol-layer recursive signature and proof aggregation. So let's talk about what this is. In EIP-8141, transactions have the ability to include a "validation frame", during which signature verifications and similar operations are supposed to happen. Validation frames cannot access the outside world, they can only look at their calldata and return a value, and nothing else can look at their calldata. This is designed so that it's possible to replace any validation frame (and its calldata) with a STARK that verifies it (potentially a single STARK for all the validation frames in a block). This way, a block could "contain" a thousand validation frames, each of which contains either a 3 kB signature or even a 256 kB proof, but that 3-256 MB (and the computation needed to verify it) would never come onchain. Instead, it would all get replaced by a proof verifying that the computation is correct. Potentially, this proving does not even need to be done by the block builder. Instead, I envision that it happens at mempool layer: every 500ms, each node could pass along the new valid transactions that it has seen, along with a proof verifying that they are all valid (including having validation frames that match their stated effects). The overhead is static: only one proof per 500ms. Here's a post where I talk about this: ethresear.ch/t/recursive-st… firefly.social/post/farcaster…

How can a group prove a bill is paid without revealing who paid it? 🕵️‍♂️ David Chaum’s protocol solves the anonymity puzzle. An outsider knows it’s covered, but the payer stays hidden! 🤫 #Cryptography #Privacy #Tech

Micet is LIVE on Firefox 🔥 A testnet-only Web3 wallet—Tired of mixing mainnet and testnet keys? 😭 keep test keys separate from mainnet, no risk to real funds. For Now Supports custom RPCs (e.g. Sepolia). Install & contribute on GitHub 👇 Website:yash514131.github.io/Micet/ #Web3

One year since my first UE5 CG trailer! ✨ Grateful for the magic of game dev. Thank you, Unreal Engine! Here's to 2026! 🚀❤️ #UnrealEngine #GameDev Perfect for tight limits—still nostalgic and celebratory! 🎉