High Level Summary

• Solves trilemma of privacy, verifiability and censorship resistance (using p2p network)

• Network —> oblivious sharded hypergraph database

  • With Database OS system on top which provides services to build applications

• 3 Levels —> communication, query planner, storage

Communication Layer

Planted Clique Addressing Scheme

• A graph (dots and lines) has a subset called a clique (all dots with same connections to each other)

  • This subset is difficult to find if you’re autistic and impossible if you’re not

  • If you make a clique by amending a graph (I guess that’s allowed, but it feels like cheating) then this is called a planted clique.

    • Don’t even bother trying to distinguish between a random graph and one that has a planted clique, you can’t

Triple-Ratchet Protocol

• Extension to double ratchet (I should have guessed)

• Asynchronous DKG ratchet to provide group key as counterparty receiver key plugged into double-ratchet algo’s Diffie-Hellman process.

  • That’s an actual sentence in the paper. This (derogative) loves stringing big words together. Now I have to spend 20 min using my Intel Pentium 3 processor brain to try to understand it.

    • Uses a triple ratchet in a double ratchet to get a group key. No I don’t know what either of these ratchet’s are, let’s keep reading.

    • My eyes are glazing over. Going to just try to understand through osmosis. Seems to be we’re trying to get a group key where not all the homies have to be online.

• Ok so it was about trying to get a group key where the homies don’t have to be online and they key is only for homies. Don’t know what we’re doing with this group key, but we can make it now.

Shuffled Lattice Routing Protocol

• Anonymity is hard. Shuffling. Lattice. Ok so the goal is to make things anonymous. What things? Let’s find out.

  • Our messages. That’s what we’re trying to make anonymous. We’re in the communication layer. Duh.

• We’re doing a bunch of math on the comms until it looks like gibberish to someone. Oh wait it’s coming together. That planted clique. Ok wait we can do this.

• The random planted clique is a group, and the make a key, and prob sign it so we know it was homies only, then they do the lattice shuffle so no one can tell who this set of homies are. Gossip layer is prob how they talk to each other xoxo.

Gossip Layer

• It totally was how they talk to each other. We’re using GossipSub. Oh wait no, we’re throwing on a filter called bloom. So now it’s BlossomSub. Triple Double ratchet vibes here.

  • SLRP cluster under BlossomSub is where to go if you want to try to understand. Good luck

Query Planner Layer

• Ok so this is a paragraph at the end. I guess there’s stuff we need to know.

Storage Layer

• The next step looks like it’s the storage layer.

• Built as a Verifiable Delay Function driven proof of storage with query processing proof of validity. I’m just going to throw this picture in and we can try to decipher it together.

  

• We can do this team.

• Ok so a VDF is a function that is a sequence, so processed one after another, you can verify the result faster than you can calculate it and the result is unique.

• But of course that’s not good enough for us. We don’t want the basic VDF. We want the upgraded Wesolowski VDF. The basic ones uses prime numbers but this one uses imaginary quadratic field. Of course we’d use that one. Prime numbers for security? Bleh. Imaginary numbers are way stronger.

• And we’re using the bloom clock from the messages in our last section as inputs to our VDF. So our clock filter is now merged with merkle proof selection. So that’s basically our hashed data.

• Ok so hashed data, plus the time stamps into VDF so that’s how we know the order. VDF is doing the job of a blockchain in terms of setting the order.

• No I don’t know what this all means, but it feels like I have a sense of the individual pieces even if idk exactly how they all fit together. That’s got to count for something.

Oblivious Hypergraph

• Ok I’ve heard this buzzword a lot from Cassie and it sounds cool af. Maybe now we can understand it.

• Nope. Not a chance. Ok I’ll try again for a bit. You know what it is. She’s putting the words in a sequence that don’t normally go together. But you understand the words so you think I should understand it. But then they combine and your brain short circuits.

• Oh wait the next paragraph has a nice first sentence. A hypergraph is a graph where the the lines can connect more than two dots. So they have an intersection point that’s not a dot (even though I guess technically there is a dot where they intersect. These types of lines (edges) are called hyper edges.

• Ok this is useful because there are higher level relationships you can show in a hypergraph, so you can model any database over one. So it’s a useful tool for representing and querying such a database.

• It’s not that the hypergraph is better, but being able to generalize it means you can have a query pattern that can be made oblivious. So the nodes that are evaluating the queries don’t know who made the query or where or how it got there.

• Ok that’s easy enough. Hyper graphs are the dots and lines except a line can connect 2 or more dots instead of just one line between two dots like in a normal graph. Which is useful if you want to make it hard to know where a message came from or what path it took. Simple enough.

• Ok the next section says simple OT (oblivious transfer) and I’m going to skip it because if there’s one thing we should have learned is we don’t do the vanilla version of anything. Give us the kinky.

• Right on queue, Correlated OT, a variant of OT. Instead of sending a singular choice, the choices themselves are implicitly correlated. This choice is random because of course it is. We know the drill at this point.

• For Quilibrium we’re using Ferret: Fast Extension for Correlated OT with Small Communication. Pretty self explanatory sounding name, bless you Ferret.

• RDF to Hypergraph. Idk, can’t figure it out. Good luck, section 4.3, godspeed.

• Ok so now we know the roles of query planner and evaluator are separated. Someone to I guess figure out the path and one to get the result and through the magic of the above stuff it gets done and verified.

• It’s Turing complete. Cool. Next section is the Operating System. So by seeing the oblivious hypergraph in action I’m thinking we can get a better sense of how it works.

Operating System

• Ok, so on hypergraph trying to do familiar things. File system, schedular, IPC, etc.. Here is the picture. Universal resources, initially the account resource is where we’d store the balance of individual holders’ of the network’s reward tokens.

  

• Ok RDF is just relationships in a database. So now we have to do it on a hypergraph, which I guess what the last section was about, (very) roughly speaking.

• Ok so the final section is just going over those orange boxes but the picture does a good enough job.

Conclusion

• Ok, so the feeling is like staring at a bunch of puzzle pieces. I see some possibilities. Where the colours match, the edge pieces. A sense of what the final picture might look like. But the entire puzzle is very much unsolved.

• That’s ok though. I think even seeing more of the network implemented should make it easier to put the pieces we have together.

• This was me operating on a Pentium 3 processor brain. I mean as smooth as it gets. I encourage you to read the paper yourself. Especially if you have a math background. Understanding the hieroglyphics section I’m sure would make it all a lot easier to follow.

• It’s been long enough that I no longer understand them, and am frankly too lazy to put in the effort to try. It is what it is.