←
Bobbin's Threadbare1,768 posts
Bobbin's Threadbare avatar

Bobbin's Threadbare

@bobbinth

blockchains, zero-knowledge proofs, virtual machines. working on @0xMiden

◷ Joined September 2018▧ 34 Photos and videos
Bobbin's Threadbare avatar
Bobbin's Threadbare@bobbinth·Nov 17

Maybe a controversial opinion: "not your keys, not your coins" meme did vastly more harm than good for crypto. This doesn't mean that the idea of self-custody is bad (it is one of the core benefits of crypto), but rather that we should have built systems that do not require people to explicitly manage their private keys (and the expectation that most people can actually manage private keys securely is an unrealistic one to begin with). The bar to clear should be: a self-custodial system where: (1) you don't have to come in contact with a private key. (2) if your devise is fully compromised or your private key leaks due to a supply-chain attack or bad entropy or w/e - you don't loose your life savings.

Bobbin's Threadbare avatar
Bobbin's Threadbare@bobbinth·Nov 17

A very cool way not to enshrine a specific VM at the base layer - while still keeping STARK verification efficient

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…

OpenZeppelin avatar
⟳ Bobbin's Threadbare retweeted
OpenZeppelin@OpenZeppelin·Nov 16

On @0xMiden, a private multisig keeps a treasury’s balance, signers, and rules confidential. But since that state isn’t public, co-signers need a way to stay in sync. Keeping them in sync is Guardian, a non-custodial Private State Manager, co-designed by OpenZeppelin and Miden.

Miden@0xMidenNov 12

With a public multisig, anyone can look up the treasury’s balance. On Miden, teams can keep their reserves in a private treasury multisig while moving smaller amounts into separate accounts for payments, without exposing their full holdings.

Miden avatar
⟳ Bobbin's Threadbare retweeted
Miden@0xMiden·Nov 16

A public multisig can reveal what a treasury holds and which addresses control it. A private multisig on Miden gives attackers less to work with by design because they can’t look up the account onchain to see its balances or identify its signers. Our cofounder @schmiddominik1 explains why this matters for teams securing a treasury or governing a protocol.

1:30
Bread avatar
⟳ Bobbin's Threadbare retweeted
Bread@joinbread·Nov 13

setting up a wallet shouldn't need a recipe book step 1: passcode. step 2: pick a Guardian. step 3: write down your recovery phrase.

0:13
Miden avatar
⟳ Bobbin's Threadbare retweeted
Miden@0xMiden·Nov 15

How you roll out a blockchain is part of how you secure it. The cryptography behind proving systems has been studied and written about for years. The software implementing it is much younger, and audits cannot guarantee that every bug has been found. That is why Miden is rolling out gradually, starting with a limited set of participants on partner mainnet. Expanding access in stages helps us detect problems and limit their impact while we build confidence in the system. Our protocol engineer @mmagician explains the thinking behind that approach, and why protecting users’ funds shapes the pace of the rollout.

0:51
Bachi avatar
⟳ Bobbin's Threadbare retweeted
Bachi@julibachi·Nov 13

Easy, peasy, beautiful onboarding for @joinbread

0:13
ahmad avatar
⟳ Bobbin's Threadbare retweeted
ahmad@aesopsolo·Nov 13

A simple way to get your wallet set up with @joinbread

0:13
Miden avatar
⟳ Bobbin's Threadbare retweeted
Miden@0xMiden·Nov 13

We use our own private multisig to maintain high-impact smart contracts for our bridges, like the Circle's CCTP brigde used for our private stablecoin, USDCx.

0:42
Miden@0xMidenNov 12

With a public multisig, anyone can look up the treasury’s balance. On Miden, teams can keep their reserves in a private treasury multisig while moving smaller amounts into separate accounts for payments, without exposing their full holdings.

Miden avatar
⟳ Bobbin's Threadbare retweeted
Miden@0xMiden·Nov 12

With a public multisig, anyone can look up the treasury’s balance. On Miden, teams can keep their reserves in a private treasury multisig while moving smaller amounts into separate accounts for payments, without exposing their full holdings.

cutemoon avatar
⟳ Bobbin's Threadbare retweeted
cutemoon@cutemoon66·Nov 12

Darwin is now live on @0xMiden Partner Mainnet. It lets you buy a whole crypto basket with one token, and keep your position private. Right now you can buy the Blue Chip basket (BLUEDW): • ~50% WBTC • ~30% ETH • ~20% SOL You pay with USDCx and get the token in your own wallet. The vault holds the real coins. Gold, DeFi and Privacy baskets will go live soon. @darwin_market @joinbread

Post attachment
Miden avatar
⟳ Bobbin's Threadbare retweeted
Miden@0xMiden·Nov 12

On Miden, a treasury team can use a private multisig to approve transfers together. Looking up the account onchain won’t reveal its signers, which assets it holds, or how much of each. Our cofounder @schmiddominik1 explains how it works.

1:13
Miden avatar
⟳ Bobbin's Threadbare retweeted
Miden@0xMiden·Nov 9

Client-side proving is the holy grail of privacy.

1:15
Bobbin's Threadbare avatar
Bobbin's Threadbare@bobbinth·Nov 9

A token can have long-term value for one of two reasons: - It is backed by a business with revenue. - It becomes money. In the second case, SoV is one approach, but it'd surely be more beneficial if the token also had practical utility (e.g., it would have been great if Bitcoin was both SoV and a functional payment network).