Pinned Tweet
🌟 The AAStar community has been shortlisted for the @gitcoin 21 Asia Round! 🚀 We are committed to advancing Ethereum Account Abstraction, and every bit of support brings us closer to our goal!✨
Let's contribute to a decentralized future together! 💪 #AAStar #GitCoin21
PQ signature Aggregator: 8288
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…
1
AAStar retweeted
Every transaction your wallet sends, held until you check it.
TxGate: a local RPC gate that decodes the signed tx itself, flags unlimited approvals, and broadcasts only after you approve.
github.com/BlockEase/TxGate
Thanks @0xYamashi
Music: Omni by Punch Deck (CC BY)
Frames in Trasaction?
A lot of important progress on Frames (EIP-8141) has been quietly happening over the last few months. Highly recommend reading this, also the updated EIP eips.ethereum.org/EIPS/eip-8…
firefly.social/post/x/209626…
15
Yeah, we are alive, hah, just do some freelance jobs to make a living and then contribute to the open source project again. So we launch a new org from AuraAI to iDoris.ai.
🤖 Made with AI
28
AAStar retweeted
Two weeks ago, Ethereum researchers met in Berlin to continue charting the protocol's long-term trajectory, following along discussions with client teams in Svalbard in April.
The updated strawmap is at strawmap.org, and I attached a picture of it to this post.
My own high-level takeaways:
* "Lean Ethereum" is not a single one-shot upgrade, it is a collection of improvements that will come online to the Ethereum network over the course of three or four years. But make no mistake, this IS the third major iteration of Ethereum in the same way that the Merge was the second. Almost every major piece of the protocol will be replaced:
- Verification through recursive STARKs, rather than direct re-execution. Recursive STARKs become an enshrined first-class core component of the protocol
- Replacing everything quantum-vulnerable with quantum-safe alternatives
- Consensus: decoupled available chain and finality, one or two-round finality. Theoretically optimal security properties, simpler than today, and faster than today
- Multidimensional gas
- State: not just tree structure, but what *types* of state are available
- Changes to client architecture
...
At the same time, simplification, cleanup and future-proofing. And this will all be done in a way that minimizes disruption to existing application. We've done this before (the Merge), we can do it again.
* H-star (aka Hegota) is probably Ethereum's last thematically "pre-Lean" fork. Starting from I-star, most of everything we do will have a very strong "Lean" feel to it in one way or another.
* Privacy is no longer an afterthought, it is a first class goal. When designing Frames, the mempool, additions to the state tree, we explicitly ask the question "okay, how do quantum-safe, intermediary-free privacy protocol transactions go through this, and what is the overhead?"
* Formal verification of everything for security.
* FV also makes us much more comfortable with canonicalization (having pieces of the protocol that are directly defined as a piece of bytecode expressed in some language). evm-asm is being written in part to become a canonical proof system for the EVM.
* Quantum safety has shifted up a LOT in priority. This adds a lot of work (eg. finalizing a quantum-safe blobs design has become urgent; this work has already been ongoing for months)
* Probably the single most disruptive part of the plan is the changes to state. There is growing consensus around leaving present-day-style "dynamic state" mostly unchanged, but scaling it only a medium amount, and adding new types of state that are more scalability-friendly (eg. no need for builders to sync/store all of it) but more restrictive, and that will scale a large amount.
eg. possible Ethereum in 2030: 2 TB of present-day-style (dynamic) state, and 100 TB of new-style (scalable but restrictive) state
This "new-style" state would work very well for ERC20s, NFTs, many defi use cases, but not eg. highly "central" objects like Uniswap contracts, or onchain order books, or other complex things (which are crucial for Ethereum but which only take up a small percentage of state)
Hence, it will not be *necessary* to rewrite any apps, but it will be *very cost-effective* to eg. rewrite an ERC20 token into a newer design that uses a new type of UTXO storage that is currently being explored, so that it will have >10x lower txfees.
Design of these new state types (current ideas: keyed nonces, ring buffers, UTXOs, statically accessible state, temp state) is an area where we will need a lot of feedback from application developers (incl. privacy-friendly application developers) and probably several rounds of rethinking and iteration.
* In the context of a much larger total state size, we need to figure out the incentive issues around who stores this state and what motivates them to. Even saying "each node stores 1%" is not good enough - why do they store that 1% and why are they willing to serve it? This is being elevated as a first-class research area.
* Ethereum will need to have a "VM" other than EVM in one form or another - at the very least, we need something like leanISA for recursive STARKs - and the gains are large in exposing it to users so that we support programmable privacy and better scalability. Right now, the most likely contenders are leanISA and RISC-V.
My own ideal is that in this world, we adjust the protocol so that the EVM becomes a high-level-language compiler-level feature, and the protocol only "sees" RISC-V / leanISA directly. But this is still far away.
* Gas limit increases, blob increases and slot time decreases will happen many times over the next ~5 years. We expect a large gas limit increase with Glasterdam. Each step of increased scale or decreased slot time is a matter of getting to the point where it is safe to do it, which comes from a combination of client optimization and protocol changes.
Ethereum is CROPS.
Ethereum is scaling.
Ethereum is reinventing itself.
Onward.
🎉🎉🎉YAA测试时发现使用KMS的eoa做guardian逻辑有问题(kms会丢失、 宕机、跑路等等),新增了基于Google,iCloud的passkey做guardian的功能,AirAccount合约测试通过并发布成功 ~!
56
🚀SuperPaymaster v5.3.3-beta 上线 Sepolia 🛡️ ERC-4337 社区无 Gas 基础设施 —— 用社区代币代付用户 Gas,无需 ETH。支持人类+AI Agent 双通道 Gas 赞助。完成 8 项安全审计修复,向主网推进。 → github.com/AAStarCommunity/S… ,blog.mushroom.cv/blog/superp…
12
🚀AirAccount v0.17.2-beta.3 上线 Sepolia!没有密码,没有助记词。 指纹登录 → 链上签名 丢手机 → 3个守护人投票找回 给 AI agent → 有边界的临时钥匙 大额转账 → 自动升级为多签 github.com/AAStarCommunity/a…;blog.mushroom.cv/blog/airacc…
14
🚀 AirAccount KMS Beta2 (v0.20.0):TEE 私钥管理 + WebAuthn + AWS KMS API。安全审计全过、SuperPaymaster gasless 签名端点、NXP i.MX93 真机部署、100% E2E (34/34)。私钥永不出 TEE。开源 Apache 2.0 👉 github.com/AAStarCommunity/A… 详情:blog.mushroom.cv/blog/airacc…
34
Ready to launch?🚀 Beta is coming!!! Full Capbilities SuperPaymaster, Full Stage2 AirAccount and High Perfamance KMS. And... ALSO SERVICE for AGENTS🤖!!!:
4
A lot of “gasless UX” isn’t really decentralized 🫠
It just swaps one dependency for another:
no ETH in the user’s wallet → trust a Paymaster server to sign your sponsorship.
1
41
SuperPaymaster is interesting because it moves that logic onchain:
Gas Card / SBT + deterministic policy checks instead of offchain signer authority.
The key idea isn’t “make gas disappear.” ⛽️
It’s: make sponsorship verifiable. 🔍
1
22

















