▲▲▲

Paralelní Polis is a one-­of-­a-­kind nonprofit organization that brings together art, social sciences, and modern technologies. The ideas of liberty, independence, and innovative thinking and development of society are the main underlying foundations the whole project is built upon.

The project intends to remain state-free as it operates entirely without support from the government, and most of the funds come from voluntary contributions of our donors and partly from commercial activities such as running a unique co­working space and the world’s first bitcoin-­only cafe.

It was founded by members of a contemporary-­art group Ztohoven, and Slovak and Czech hacker­spaces. Its main goal is to promote economic, social, and digital freedom. We try to be a vocal voice of freedom in order to shape the public discourse, and ultimately work towards a freer future.

We are more of a research project, I would say, but we are getting a test in next October And it works quite different to other products, I would say.

But yeah, basically, what are we actually doing?

So, Ethereum, we think, is still our best bet, as you all know.

Basically, when you look at the amount staked and the number of professional active developers, then you can see that all of those chains basically, they are quite the same.

in the POS, like I don't want to get into that discussion now, and

not to build, not to tap into that ecosystem, not to build on that.

However, the EVM, so the underlying backbone of Ethereum, is limiting the applications that we can build so far.

So Ethereum, basically, the EVM processes state changes sequentially.

So 1 transaction at a time, 1 block after another, but all with always a global lock.

So actually it's like sequential processing.

And if PayPal would have been built on top of Ethereum or using Ethereum, then you would all see that.

But from its internal structure, the global account states, it's very hard to get privacy on the EVM.

It's not suitable for applications that require very high throughput.

And transactions and accounts are always publicly available and visible.

think of a DEX or yeah, a DEX that should work somehow like a stock exchange, or simply buying coffee in the morning with crypto, need very fast and cheap transactions.

We need it to have at least partial privacy in the sense of privacy as we have it in PayPal at least and

way better wallet security and good user experience.

So the question obviously is, how can we use Ethereum but not the EVM?

For us, and the answer kind of obvious, I think, since the rise of the roll-ups.

So we have Polygon Miden here as an example of a 0 knowledge roll-up that can tap into the Ethereum ecosystem, but with different features.

So basically we have a 0 knowledge roll-up that's not running on the EVM.

And the goal is that you can create applications that are at the moment infeasible on Ethereum or EVM-like systems.

And how we do it basically is we prioritize in our virtual machine the zero-knowledge protocol over the usability.

I think most important is client-side proving.

So basically the Miden users will be able to create zero-knowledge proofs on their machines.

So with that, you get privacy, obviously, when

you use a zero-knowledge proof of your own state change, then no 1 knows what's happening on your own state.

They just will always know everything is correct, but they don't know what's happening.

And it also enables very low-cost computations, because if I use a zero-knowledge proof then in like in contrast to a normal blockchain the state does not need to be recomputed by every node in the network they all just check a proof.

That's actually quite cool, because then I can run very complex computations that are super cheap.

I get concurrency, and that hopefully leads to high throughput applications.

And in Miden, you can update and recall transactions

that we think leads to user-friendly devs.

But let me explain to you how it works, and then I can show you, or we can create some zero-knowledge proofs together.

Maiden to other systems, on Maiden there are accounts and nodes.

And accounts you can think of as in Ethereum, like an Ethereum account.

And nodes are quite like bank notes, and both can carry assets.

And those accounts, they send notes to each other when they want to exchange assets.

So I give you a banknote, and this banknote basically carries the value when I hand it over to you.

And these accounts, they can do that asynchronously.

They can asynchronously produce and consume notes.

And When an account consumes or produces a node, we call that a transaction.

That is actually quite different, but this is why we can create user-generated zero-knowledge proofs.

Basically, when you look at that, that's what we mean with a transaction.

So Alice here, she has 10 Matic and 5 Ether, and she wants to consume a node of 5 Ether.

For these 5 Ether, she needs to pay 5 Matic,

which is quite a nice exchange rate given that today's...

So okay, she consumes this node, and this is her account state in the lower right.

And the transaction, basically, which is defined as a state transition of 1 single account So as a result we have Alice account in a new state Having 5 matic and 10 ether and she produces She has produced a note with 5 matic and that goes probably to the sender of the first node or whatever.

The important point here is a transaction always involves only 1 account.

Because for every transaction in Miden, there's always a stack proof.

There's always a zero-knowledge proof for these transactions.

That basically, because it was always only 1 account, the stack proof can be created by the owner of the account alone because he doesn't need information of the states of the others.

Like when I produce a node single-handedly or consume it and create it, I can create a zero-knowledge proof of it.

And these zero-knowledge proofs can be created by the users in parallel,

and then they get batched together using recursive verification and

But this is basically as it works with other zero-node show labs as well.

And then at the end you have 1 big proof on Ethereum that proves the global state of the network.

But different to other zero-node show labs is that these transaction proofs basically can be done by users

and not only by 1 single centralized entity or so called a prover and that's how you can keep, you can stay private basically.

Okay so my actual time is over but I would want to show you.

So you can take out your phone and can scan this.

So let's create a zero-noise proof together, Meaning that it looks like this.

We are working on a cool compiler for Move or Rust.

So, when you scroll down, this is the program that we are going to prove.

It's a super simple program and it's way simpler than a transaction, but just as an example.

So in this language that we have at the moment, here it adds 1 and 2 together with 0 inputs.

Like this runs in a browser and it should be done in 200 milliseconds.

Like, is someone over 1 minute on your mobile phone when you prove it?

Okay, so it should be quite quick and this is the result, so it's 3.

The result of adding 1 and 2 together and then you can now, you can verify the proof.

OK, so now you can verify it, and you can look at the proof.

So it's actually like a super long hex thingy.

the future that also people can in their browser create their own proofs.

Like their proofs of consuming and producing a set of nodes and then only sending this proof.

verifier, and this is how we basically get very high throughput, because these can be done in parallel, and privacy at the end.

And yeah, happy to discuss or take questions or I can show you more slides of the design or are there any questions?

Then thanks a lot and have fun at the conference.


Speaker 0: Hello, hello, hello. Nice. Okay. Let's check. Okay, yeah.

I'm Dominic. I'm from Polygon

Speaker 1: Maiden, basically. Polygon has 3 different ZK products, and

Speaker 2: 1 of it is Polygon Miden. We are more of a research project, I would say, but we are getting a test in next October And it works quite different to other products, I would say.

Speaker 1: But yeah, basically, what are we actually doing? So, Ethereum, we think, is still our best bet, as you all know. Basically, when you look at the amount staked and the number of professional active developers, then you can see that all of those chains basically, they are quite the same. But Ethereum is outstanding. So Ethereum is by far the safest chain

Speaker 2: in the POS, like I don't want to get into that discussion now, and

Speaker 1: it has the largest developer community.

Speaker 0: So, it would be stupid

Speaker 1: not to build, not to tap into that ecosystem, not to build on that. However, the EVM, so the underlying backbone of Ethereum, is limiting the applications that we can build so far. So Ethereum, basically, the EVM processes state changes sequentially. So 1 transaction at a time, 1 block after another, but all with always a global lock. So actually it's like sequential processing.

And if PayPal would have been built on top of Ethereum or using Ethereum, then you would all see that. Like this is my personal PayPal account. So the EVM is very hard on privacy. So you can try to get around that. But from its internal structure, the global account states, it's very hard to get privacy on the EVM.

And so yeah, that's our thought process. So the EVM is somehow limited. It's not suitable for applications that require very high throughput. Complex computations are quite costly. And transactions and accounts are always publicly available and visible.

Speaker 2: But real-world use cases, like let's

Speaker 1: think of a DEX or yeah, a DEX that should work somehow like a stock exchange, or simply buying coffee in the morning with crypto, need very fast and cheap transactions. We probably need parallel execution. We need it to have at least partial privacy in the sense of privacy as we have it in PayPal at least and

Speaker 2: way better wallet security and good user experience.

Speaker 1: So the question obviously is, how can we use Ethereum but not the EVM? For us, and the answer kind of obvious, I think, since the rise of the roll-ups. So we have Polygon Miden here as an example of a 0 knowledge roll-up that can tap into the Ethereum ecosystem, but with different features. So basically we have a 0 knowledge roll-up that's not running on the EVM. And the goal is that you can create applications that are at the moment infeasible on Ethereum or EVM-like systems.

And how we do it basically is we prioritize in our virtual machine the zero-knowledge protocol over the usability. So that's it. But I will explain how it is. What is actually new? I think most important is client-side proving.

So basically the Miden users will be able to create zero-knowledge proofs on their machines. And with that,

Speaker 2: we almost have it. So with that, you get privacy, obviously, when

Speaker 1: you use a zero-knowledge proof of your own state change, then no 1 knows what's happening on your own state. They just will always know everything is correct, but they don't know what's happening. And it also enables very low-cost computations, because if I use a zero-knowledge proof then in like in contrast to a normal blockchain the state does not need to be recomputed by every node in the network they all just check a proof. That's actually quite cool, because then I can run very complex computations that are super cheap. I get concurrency, and that hopefully leads to high throughput applications.

And in Miden, you can update and recall transactions

Speaker 2: that we think leads to user-friendly devs. But let me explain to you how it works, and then I can show you, or we can create some zero-knowledge proofs together.

Speaker 1: So Basically, what's different on

Speaker 2: Maiden to other systems, on Maiden there are accounts and nodes.

Speaker 1: And accounts you can think of as in Ethereum, like an Ethereum account. And nodes are quite like bank notes, and both can carry assets. And those accounts, they send notes to each other when they want to exchange assets. This is much like cash works. So I give you a banknote, and this banknote basically carries the value when I hand it over to you.

And these accounts, they can do that asynchronously. They can asynchronously produce and consume notes. And When an account consumes or produces a node, we call that a transaction. That is actually quite different, but this is why we can create user-generated zero-knowledge proofs. Basically, when you look at that, that's what we mean with a transaction.

So Alice here, she has 10 Matic and 5 Ether, and she wants to consume a node of 5 Ether. For these 5 Ether, she needs to pay 5 Matic,

Speaker 2: which is quite a nice exchange rate given that today's...

Speaker 1: But whatever. So okay, she consumes this node, and this is her account state in the lower right. And the transaction, basically, which is defined as a state transition of 1 single account So as a result we have Alice account in a new state Having 5 matic and 10 ether and she produces She has produced a note with 5 matic and that goes probably to the sender of the first node or whatever. We don't know. But this is a transaction, right?

The important point here is a transaction always involves only 1 account. Because for every transaction in Miden, there's always a stack proof. There's always a zero-knowledge proof for these transactions. Now you can combine these things. That basically, because it was always only 1 account, the stack proof can be created by the owner of the account alone because he doesn't need information of the states of the others.

Like when I produce a node single-handedly or consume it and create it, I can create a zero-knowledge proof of it.

Speaker 2: And these zero-knowledge proofs can be created by the users in parallel,

Speaker 1: and then they get batched together using recursive verification and

Speaker 2: put into a block. But this is basically as it works with other zero-node show labs as well. And then at the end you have 1 big proof on Ethereum that proves the global state of the network. But different to other zero-node show labs is that these transaction proofs basically can be done by users

Speaker 1: and not only by 1 single centralized entity or so called a prover and that's how you can keep, you can stay private basically.

Speaker 2: Yeah, like let me check the time. Okay so my actual time is over but I would want to show you. I also started a bit later. Can I watch my time?

Speaker 1: OK, So maybe I can show you this. So you can take out your phone and can scan this. And this is our playground, basically. I want

Speaker 2: to show you how it works.

Speaker 1: So this is the MaidenVM

Speaker 2: in the browser, basically. The MaidenVM is written in Rust. It can be compiled to Wasm. So let's create a zero-noise proof together, Meaning that it looks like this. It is a bit hard to use at the moment.

We are working on a cool compiler for Move or Rust. 1 second. So, when you scroll down, this is the program that we are going to prove. It's a super simple program and it's way simpler than a transaction, but just as an example. So in this language that we have at the moment, here it adds 1 and 2 together with 0 inputs.

And I can now prove it. Like this runs in a browser and it should be done in 200 milliseconds. I don't know. Like, is someone over 1 minute on your mobile phone when you prove it? You click prove.

Okay, so how long was it?

Speaker 0: 400,

Speaker 2: yeah. Okay, so it should be quite quick and this is the result, so it's 3. The result of adding 1 and 2 together and then you can now, you can verify the proof. Okay, verification failed. Never do a live demo.

1 second. Mine verified. It should. Yeah, I think I just checked something. OK, so now you can verify it, and you can look at the proof.

So it's actually like a super long hex thingy.

Speaker 1: But this is basically how we envision in

Speaker 2: the future that also people can in their browser create their own proofs.

Speaker 1: Like their proofs of consuming and producing a set of nodes and then only sending this proof.

Speaker 2: This proof here to the

Speaker 1: verifier, and this is how we basically get very high throughput, because these can be done in parallel, and privacy at the end.

Speaker 2: And yeah, happy to discuss or take questions or I can show you more slides of the design or are there any questions? Good. Then thanks a lot and have fun at the conference. Www.microsoft.com.ca

See all Parallel Polis transcripts on Youtube

Build high-throughput and private applications on Ethereum / Dominik Schmid