📢For years, we've been building in the shadows. No noise, no empty promises — just code, code, and more code. 💻
Why the silence on the marketing side? Because before speaking loud, we had to build solid. Your privacy and your security deserve nothing less. 🔒
Soon, we'll be ready. And that day, it won't be our victory — it will be ours, together. The victory of a community that believed in a different web: free, private, and one that truly rewards those who bring it to life. ✨
Thank you for being here since day one. The best is yet to come. 🚀
#W3F #Web3 #Privacy #Blockchain #Crypto #DeFi #Decentralization #Security #Community #BuildInPublic #Web3Community #PrivacyMatters #CryptoNews #Tokenization #SelfCustody
Last month we said we’d lift the hood on how we use AI at Proton, and start releasing and open sourcing the tools we use internally at Proton.
Today’s Lumo update is the start of that.
Desktop, Connectors, Schedules, and Skills, are all tools we built for our own teams first.
#Web3 promised freedom. It gave us transparent wallets where everyone sees everything.
#ZeroKnowledge fixes that: prove without revealing.
✅ Your identity, not your data
✅ Compliance, without surveillance
Proud that @Web3Fusion is part of [@PROTOCOL]. #Privacy isn't a feature. It's the foundation. 🔐
You can’t trust your VPN.
Most VPNs ask you to replace trust in your ISP with trust in another company.
At Cypherpunk Congress, @SCBuergel (@gnosis_ | @hoprnet) explained why that model is broken, and how decentralized VPNs and mixnets could finally deliver on the promise of online privacy.
If you ever used a "social login" for your crypto wallet, you will want to research this topic 👇 further to protect your funds.
Self custody = self responsibility. 🙏
User funds are safe!
It does look like a hack on Binance. Appreciate the quick freeze from Tether (~$971m) and Circle (~$823m).
I don't manage Binance (.com) anymore, but as a shareholder, I expect all user funds will be fully covered.
Jordi Baylina (@jbaylina) x @ziskvm has helped build across donations, independent infrastructure, digital identity and cryptography.
Now working on ZisK, Jordi Baylina develops open-source infrastructure for zero-knowledge proofs: tools that let software verify claims while limiting what information needs to be disclosed.
That experience matters beyond blockchain development. More private credentials and independently verifiable systems need foundations other people can inspect and build upon.
Jordi joins Ethereum Cypherpunk Congress 3.
2 Nov · Mumbai · Free entry
https://t.co/9RPG6N9Z0P
Introducing post-quantum rewards on Web3Fusion: every claim signed with ML-DSA-65 (NIST FIPS 204), key derived on your device. Quantum-ready from day one. Beta coming soon. #PostQuantum#Starknet
Follow us 🫶
Beta available soon 🚀
One of Web3Fusion's three features. A community truth engine: every case is settled by evidence, not clicks. You vote by bringing proof.
Evidence is kept on IPFS, decentralized storage. Verified humans, validators, and a verdict that can't be bought.
Proof of humanity, two ways: scan your passport chip, or prove an exchange account with zkPass. Zero-knowledge proofs only: no ID upload, nothing stored on our side.
One human, one account. Fewer bots.
Beta coming soon 🚀
Follow us 🫡
Session has been selected for @OctantApp’s Epoch 13 Privacy Round, with a 100 ETH matching pool.
Funds raised in this round will help deploy Session Protocol v2 with PFS and post-quantum protection.
Allocations open October 14 to 21. https://t.co/TkXZP57FX3
Welcoming @zERC20io as a sponsor of CYPHERPUNK CONGRESS 3 🎊
zERC20 enables private ERC-20 transfers across EVM chains, all while working with the wallets users already know and love.
Let’s advance a more sovereign internet together: https://t.co/tmQC59hroB
It's an increasingly common take that AI hacking means cybersecurity is doomed.
I disagree. I think cybersecurity is naturally defense-favoring once people get their shit together. And anyone who continues to hold cryptocurrency (including me, ~90% of my net worth) is implicitly making that bet.
Here's why I am making that bet.
First, the oversimplified punchy one-line statement:
If AI can prove Navier-Stokes and FLT, then AI can prove the statement "this program is secure" as a mathematical theorem. Even if the program is very complicated.
Now, the nuance:
(See also: https://t.co/6YPWgVT7rO )
The word "secure" is hiding all kinds of skeletons in the closet in terms of what it actually means. What does it mean for Signal (the encrypted messenger) to be "secure"?
The most basic definition you might think of is: no one who doesn't hold the recipient's secret key can read the contents of the message.
But:
* Did you remember to include _other_ critical forms of security? Can the adversary forge messages? Can the attacker prevent messages from reaching the recipient? Can they cause your client to crash by sending malformed messages?
* Have you made sure that your model of the adversary includes attackers that interfere with the protocol actively and not just passively? And attackers that interfere by replaying messages to you or the recipient that either of you sent over the wire at any point earlier?
* What if the adversary hacked (or _is_) the Signal server?
* How did you learn which public key belongs to the recipient in the first place? What if that process was tampered with?
* What if your device gets hacked at some point in the past or future - is your message still safe then?
* What if your key leaks because of a bug in your operating system? Or because you got a bugged version of the Signal client? Or what if the database is corrupted?
* Or the libraries, interpreter or compiler of the programming language you wrote it in?
* What if your key leaks because tiny perturbations in perceptible signals generated by the hardware leak mathematical relationships that can extract the key a few hundredths of a bit at a time?
* Are you hiding the *size* of the payload? Does that matter?
* You're definitely not hiding the identity of the sender and the recipient, and the exact time each message was sent (think: not just time-of-day, but also time deltas between one message and the next). Is that not enough to deduce a lot of important facts about what relationships you have, and what *kinds* of conversations you are having?
So ... even definitions can be over a thousand lines of code, and need deep careful thought to figure them out.
Working on making definitions more human-readable is of extreme importance - it's perhaps the only "high-level language" that matters right now.
But even still, even despite all of the above, for security-critical components, the definition is a much smaller attack surface than the implementation. Verifying that the definition is adequate is a much more tractable task than scanning over the code directly - and can become even more tractable with better tooling.
Definitions are also _additive_: if two groups have two different definitions A and B, then, well, you can just prove that the program satisfies both A and B. Code is not additive in this way: if a program is A + B, a bug in A _or_ B can sink the whole thing. Definitions are additive. And if you can't satisfy A and B at the same time, you've isolated the most important philosophical issue for your project to spend its next few weeks grappling with.
Sometimes, definitions are not much smaller than the implementation - UI components might be one example. But for many of the most critical components - message-passing protocols, sandboxes, cryptography like SNARKs and FHE - the asymmetry is real.
Historically, a large class of failures with this approach have come from people only verifying a small portion of their code, that they self-declared to be the security-critical portion, and ignoring the rest - and it turns out that something in the rest of the code is security-critical too.
This was reasonable back when verification was difficult and scarce. The solution today: sorry, you have to verify over literally your entire program, including database, networking, any caching layers, everything. Modern AI can do it.
So it's not about "the good guys find all the vulnerabilities before the bad guys do" - that could maybe work too, after all a finite program only has a finite number of vulns, but it's riskier - it's specifically an asymmetric strategy of making code that is much more resilient in the first place.
This is the kind of direction that Ethereum is going in for the next few years. There is no future for blockchains - especially blockchains with scalability and privacy - without doing this. We need to make software actually secure. And we have already made a lot of progress.
Today, we are announcing a partnership with @mozilla to bring privacy, control and choice to people using AI to browse online. 🦊🐈
https://t.co/Bsd6N4jNdV
iOS 27 breaks DNS based adblockers such as @NextDNS, @AdGuard or Pi-hole unless you disable connectivity assist. Spread the word!
Settings > Wi-Fi > Connectivity Assist
📢For years, we've been building in the shadows. No noise, no empty promises — just code, code, and more code. 💻
Why the silence on the marketing side? Because before speaking loud, we had to build solid. Your privacy and your security deserve nothing less. 🔒
Soon, we'll be ready. And that day, it won't be our victory — it will be ours, together. The victory of a community that believed in a different web: free, private, and one that truly rewards those who bring it to life. ✨
Thank you for being here since day one. The best is yet to come. 🚀
#W3F #Web3 #Privacy #Blockchain #Crypto #DeFi #Decentralization #Security #Community #BuildInPublic #Web3Community #PrivacyMatters #CryptoNews #Tokenization #SelfCustody
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.