IPFS Virtual Meetups, 26 Mar 2021

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Ceramic: Open Sourcing the World’s Information with Joel Thorstensson

Description

Ceramic is a decentralized protocol and processing network for performing stateful computations over streams of data. Ceramic enables identities and information to be open sourced and easily shared across organizational boundaries and application contexts in the same way that blockchains have done for finance and Git has done for software.

For more information on IPFS
- visit the project website: https://ipfs.io
- or follow IPFS on Twitter: https://twitter.com/IPFS

Join your local IPFS meetup to attend our next event: https://www.meetup.com/pro/ipfs/

Sign up to get IPFS news, including releases, ecosystem updates, and community announcements in your inbox, each Tuesday: http://eepurl.com/gL2Pi5

A

Hi everyone, I'm joel and I'm a co-founder of three box labs today, I'm going to be talking about ceramic and how we see it open sourcing, the world's information and kind of diving into what we mean by programmable streams and how it all relates to identity cool. So what is the world of open source information like what would that look like? um So we think that, like um we really need to de-silo of all information in the world or like a lot of information needs to be decided.

A

So how can we share information like across or organizational or application boundaries, and it seems like this kind of system needs to really be based on public key uh cryptography, um like danielle kind of mentioned, a bunch already.

A

um We we see this, that this can be achieved with stateful streams, and what this really means is streams of events and then processing on top of that, so we get a state um and and in ceramic. What this looks like is that we have individual streams that are separate from each other, and so you don't have to like compute like a global state of the entire network um and yeah.

A

So this is kind of a minimal build building block for interoperable information, and if we have this, we can kind of create a global data environment where we can share these streams globally.

A

The commits or the events of the logs of the streams can, though, originate locally, so I created my online machine and it's like propagated throughout the network, uh and ideally, we also have like multiple different data structures that are supported and I'll kind of go get into that a little bit more soon.

A

um So the goals of ceramic is really to facilitate this in a scalable way. So, basically, we want to be able to handle the world's mutable information um and obviously it would be preferable if this is quite low latency um we want, we want it to be flexible.

A

So um if we want to be able to support like a bunch of different types of information, we can't really use like have one data structure and like one state representation, it needs to be like support for various different formats and types of data and streams and yeah different ways to represent the state as well.

A

um And if you compare, if you look at a blockchain right now like uh they have a global state, which means that you can have one big state machine and everything needs to happen within that state and that's kind of cool in kind of the world of financial stuff, you could do flash loans and things like that which is kind of to get it totally mind-blowing.

A

um But but if we're working with like information, we don't really need that kind of composability of messaging in in the same way all the time. So we want to be able to have like local consensus of this, these different streams independently of each other. So we don't need to like coordinate everything together at once uh so yeah, so we would use uh consensus by stream and and potentially they can also make make this work offline, uh yeah so we're so this is kind of the goals of surrounding so where we're at right now.

A

So we have a you know: public network that is kind of global. uh Has these local per stream consensus and.

A

We're really working on right now is like making the the minute uh making that go, live and and kind of then focusing on like scaling out this and like allowing more different types of stream, uh processing and stuff um all right. So, let's dive into like what is a stream, and why is that? What what do we want to do with it? um So we we call them.

A

We like to refer to them as like a stream of commits, and um essentially this you can think of the each commit as a an event which is signed and or it can also be like verifiable in some other way, like a blockchain anchor, uh but essentially it's unit. It's a commit that contains some kind of data that allows you to update the state of um the state that the stream represents.

A

We give each each of these streams like a unique identifier.

A

I'm going to refer to the stream ids currently in the ceramic implementation, they're called document ids, but streams since we're using the streams language, it's more appropriate um and in theory, these comments. Commit streams can be like any type of ipld data structure, uh so like any type of ipld dag, so it could be used to represent like dags um or just like straight. You know append only logs currently in the ceramic implementation.

A

uh We have like one uh one log, so there's no like branching and support yet there's something that we're gonna add in the future. um Yeah each stream is processed independently, so you can kind of parallelize this quite well uh yeah and here in to the right.

A

We have an example of like a genesis commit which is like the first creation of the stream and then like an anchor commit anchors it into like a blockchain, and then signature commits contains like patches or other types of modifications or like other types of like data events, and then there's stream, processors and- and this really governs how the state progresses as their new commits or events they come in and they define what is a valid commit and they also define like consensus rules if there's like a divergence or yeah different.

A

Opposing views like what what's what's valid, like is the signature from a d80. That's like allowed to make the update or not um and finally, to like make this really work. Well, especially in an environment where we have the ids, and we need to have this kind of secure, key rotation that danielle talked about.

A

We use, checkpointing and, and really this could be done in various different ways. Right now, we anchor periodically into ethereum, and uh these anchors can be matched. We can like take updates from a bunch of different streams and anchor them into ethereum with like one transaction, but in there you can do it in other blockchains or potentially using some kind of committee.

A

um So ceramic is a completely decentralized network where a ceramic node is based on ipfs and ethereum. So ipfs and ip lead store kind of the the commits and the stream and ethereum to do the anchoring. uh Then we use libidip to gossip, the tips of the stream, so the tips basically mean. What's the latest update and I can also make queries for like hey, I have this stream id like. How can I can you give me the latest update and I can verify just an individual stream locally.

A

I don't need to care about the whole state of the entire network, so we can make extremely light clients, um but we have a global namesake space and each stream id is global. So I can look that up from anywhere.

A

Streams can depend on other streams, so I'm gonna in an example later and talk about. We can have schemas that are enforced on some streams as they like apply updates. We can also have links to between streams. They can link each each other in the state, so we can like kind of start, creating a graph of information uh once these streams are being processed um and finally like how do we persist the the state of uh or sorry the the logs like these logs, that keep growing like um how are they backed up?

A

So you have like a bunch of different options like you can store this log in as three uh or you can sort on a remote, ipfs node. Obviously, it's stored on the local ceramic ipfs node or you can back it up to file point or some other kind of data persistence network.

A

um So in ceramic we have this concept of stream processors or doctypes, as they're currently called in the implementation.

A

There's two dock types that are supported right now, but you can kind of implement your own custom, so tiles is use the json document that optionally has this json schema enforcement that I talked about before so the json schema. I can live in another another tile and then be enforced once you update the tile and the conflict resolution we use here for tiles is if there are two separate branches of of the tile, the commit log which we saw up here so the two branches of this log.

A

What essentially happens is the the one branch that was like anchored earliest is the branch that will be the canonical branch, and this also makes it possible to do security. Revocation uh the 10 link is interesting because in different blockchain systems, so like ethereum, valcoin and polkadot, like cosmos, you have blockchain accounts but they're, not really the ids, but with a type 10 link. We allow you to like link a blockchain account to a um the id, and this can be like cryptographically proven uh and it's pretty cool.

A

It works quite nicely to just tie together the the whole blockchain ecosystem into like this.

A

The ide ecosystem and yeah you can create any type of custom, duct type right now, you're limited to this earliest anchor wins um conflict resolution, um uh but yeah that in the future we hope to like make that into a like a more broad um conflict resolution strategy, where you can use things like crtts and stuff like that, to enable this to be used in the more kind of uh better you basically better get a better user experience out of out of the system, all right. So, uh let's dive into identity on ceramic.

A

So uh the ids is the account model of ceramic. So um in tiles uh and like the main way you can access like the public and like request signatures from a user in the ceramic when you're, creating doctypes or when you're using tiles, is the 80s and facilitators to request signatures and decryption and stuff from the wallet we have defined eip2844, which is a way to like interact with the wallet request.

A

Signatures request this decryption and ceramic is really dad agnostic so, like any uh dad method that conforms to the standard uh plus minus, like some some specifics of so you can use the ids in a trustless manner, um and we have some. The id methods that are right now natively supported key did is one of them. It's like the most simple d80, that's just like a public key pair um 380 is a dld method, that's built on ceramic using uh ceramic tile, so it's just like basically putting a document into ceramic tile.

A

uh Recently we started working on something called nft did and that's kind of cool. You can build basically an identity that where the owner of the nft is the one who has access to write and read stuff, so you can basically have this transferable or tradable identity, um which is quite neat and we're also working with some some some teams to add support for org identities, so like that's on chain, dowse or organizations, so like noses, safe and molotow to give those types of organizations the 80s um and yes quickly.

A

The way we represent signatures in commits is using a standard called like jose, which is like um a standard for signed encrypted. Json objects works quite nicely with the 80s and in the future it could be potentially other uh signed data formats that work nicely with the ads as well, but thai jose works pretty well for now and is standardized within ipfs and jose is standardized within.

A

Ietf all right, so what are some use cases especially like as they relate to identity, so publishing you can publish stuff and they will get. You know you get that persistence of, like things being anchored on chains. You get this proof of publication, which is useful for your, like scientific publishing. Journalism.

A

Commenting is interesting because, like a lot of dows, especially in in the blockchain ecosystem, really want to be able to make comments and know that they were made by the right person at the specific time. So they can reason about the governance process and and related to that. Off-Chain voting is also like an implication that we have been exploring a bunch so do doing stuff like conviction, voting and quadratic coding, quadratic voting.

A

It's really important to have like some kind of sense of strong identity or like identity reputation, um which kind of ties neatly into the next thing, which is identity index, and I won't really. I don't think I really have time to go into that. But uh michael is talking about that in his talk right after this, um and just because, like ceramics based on on these streams that you have some processing on, you can imagine like a bunch of different applications.

A

Based on this, like potentially like service orchestrations, you have some kind of global event logs for um things that are going on in in different areas of the world, potentially um or yeah analytics like it's really kind of a lot of stuff that you could potentially build on it all right. So uh ceramic is currently in in a test net phase, um but we have an early launch program.

A

So if you want to check it out- and you know- try to build on it and be one of the first people to be on the mainnet, you should check out the early launch program and yeah check out our documentation for like diving in and trying to build cool stuff on.

A