Anna (00:00:07):
Welcome to zero knowledge. A podcast where we talk about the latest in zero knowledge research and the decentralized web. The show is hosted by me, Anna,

Fredrik (00:00:18):
and me, Fredrik.

Anna (00:00:27):
This week, I catch up with Illia from Near to talk about what's new in the network since our last conversation last year. We also chat about the long and challenging road to launching a POS network, sharded versus non-sharded blockchains and Near's plans to provide an ideal spot for blockchain developers. But before we start in, I want to say thank you to this week sponsor Trail of Bits. Trail of Bits has published a guide for building secure contracts with their Crytic offering. Crytic is a SaaS-based Github application created by Trail of Bits. It continuously assures that your Ethereum smart contracts are safe and functional. It reports build status on every commit and runs a suite of security analysis so you can get immediate security feedback. Check out the guide, which I've added in the show notes for tips on how to build security into your dApps from the start, as well as how to use the trail of its suite of tools for automated vulnerability detection. So thank you once again, Trail of Bits. Now here is my interview with Illia from Near.

Anna (00:01:26):
So today I'm sitting with Illia from Near. Illia has been on the show before with his co-founder Alex, last year. You might want to check out that episode where we talk about, you know, how they got from, from where they were to Near at that point. Welcome Illia.

Illia (00:01:42):
Thanks for inviting me. Hi, everyone.

Anna (00:01:44):
In that show, we actually did talk about your background. We covered like sort of the work you had done before at Google and how you got started with Near. So in this episode, I think what would be really interesting to hear is what's been happening since then. We're now a year later, what's happening in the world of Near.

Illia (00:02:03):
So I mean, there's a bunch of stuff happened. I mean, there's a world stuff, right? Obviously everybody's living through a kind of devastating epidemic around the world and like it did affect kind of in one ways. I mean, obviously there's a lot of negative negative sides, but there's also a positive side, which is kind of our team and that everybody around the world, right. When kind of thing to decentralized mode and really like, everybody's more interested in what's going on online. And what's like where they can find a community and work together, uh, to something that really like changes the world.

Anna (00:02:40):
It's a really good point that like, it's true that this has really turned like what was a decentralized focused industry, but we'd still all meet in person. And often offices still existed where everybody would get together. Now it's even more truly decentralized with, even if you live in the same city as your team, you're actually going to be working from your little pod, which is your house. And people have like gone to, you know, they've gone back to their parents' home or they've gone back to their home towns because why stay in these centers? It's super interesting to think of it that way. What else has happened though in the world of Near like you, the big change has happened, right?

Illia (00:03:18):
Yeah. So, I mean, we went from kind of like discussing how we're going to build to, you know, having, having the protocol lunched. So, and pretty much now having developers and community building on top of it.

Anna (00:03:30):
So you've launched the network. How has that been?

Illia (00:03:34):
It is very fricking hard. Um, there's I think like we've repeatedly miscalculated how much work it is. Right. Even like, I mean, there's obviously a technical work and we build from scratch a lot. So, uh, there's been a lot of, kind of just work, making sure that all works. But then after that, there's the community piece, there's economics and talking distribution piece, there is a kind of regulatory, you know, foundation companies, uh, piece around that as well. And kind of all of that together, right? Like you, all those kind of underestimate how much work it is there, like outside of what, you know, you think you're doing. And, uh, I mean, just part of it, why like every single protocol has been late, right. From our original kind of expectations. But, it's a lot of work, a lot of sleepless nights, especially given like I'm, I'm in Shanghai, so the time zones are hard, but, yeah, really kind of pushing forward to spin.

Illia (00:04:32):
I mean, it's fun and exciting because, you know, you actually building something that's like affecting the whole world and, you know, runs around the world. Right. But at the same time he has, there's a lot of, kind of small details that need to come right for these all to work. Like I think like in last episode we talked about how much we evolved since like we started, right? So, so last episode was about like a year in and I think we changed our protocol at least like three times by that time and.

Anna (00:04:58):
since then, or by them.

Illia (00:05:00):
by then, by then. And, and big part of it was like, we started pretty much, like we came from building kind of, you know, centralized solution, like distributed by centralized solutions. And obviously, you know, decentralized space has a lot of its own challenges.

Illia (00:05:14):
Uh, and really a lot of it has been learning and kind of, you know, the researching and working with other folks on this. Since then, I think most of the design is the same, uh, there's obviously a lot of like small details that kind of got refined as we built them. Some DDoS are actually still getting refined. Like I think it's the same as any protocol in reality is like, the work is never done, but, uh, but like the kind of high-level construction is pretty much the same. It was built like last year. And then like since then, it's pretty much been in like in testing and then production, uh, over time.

Anna (00:05:49):
Cool. In that episode, we actually did a comparison of like sharded blockchains. We talked about sort of the different ways that they were built and how near is built a little bit differently where instead of having something like a relay chain or beacon chain as a central point between equal chains, it is mainly that beacon chain or, or relay chain. Is that still the case?

Illia (00:06:09):
Pretty much. Yeah. So like conceptually, it's just one chain and then each block is kind of sharded. And so it just like, among other things allows us to like increase and decrease number of shards somewhat like easily. Uh, I mean obviously like there's a lot of technical issues, like how to do it, but, uh, like, because from perspective of a user or a developer, this is just one chain. They don't need to think about sharding. Right. And so all of that kind of complexity has been handled on like layer deep, right. In, on infrastructure layer. And it's kind of been like our like design principles that we're trying to hide kind of a lot of like blockchain complexity from user and developer. And, uh, sometimes it's actually like backfired because especially when we have crypto developers, so crypto users who are familiar with like Ethereum coming in and they're like, wait, but where is my public key? Or where's my address? And it's like, well actually, yeah, yeah. They used to the things and like ours kind of works more like regular stuff. And so sometimes we kind of, yeah, we need to give them a little bit more like for crypto users in crypto developers, we need to give them a little bit more too.

Anna (00:07:17):
That's so funny. You, you almost have to like diminish the UX experience so that it feels real.

Illia (00:07:23):
Yeah, exactly. Yeah. Like where like, wait, where's my keys. Like, how did I know this is like cryptos, like, well, uh, I mean you can go into explore and look at like, you know, dig in and they're like, yes, there's shards there, but like do you care?

Anna (00:07:37):
One topic that's come up like just a few times in the last month or so, on this show is just this question of data availability on the L1s. I know that in the last episode we actually did touch on it, but I, I don't, I don't know. I don't really understand how data availability works or will work in Near. Do you mind actually sharing that with me again?

Illia (00:07:58):
So the idea is that, so let's say you have, you know, for simplicity, you have a hundred validators and you have 10 shards. So there's a 10 validators, any shard that lends out gets the transactions for their shard. They split it in 10, we call them parts and send it to validate as in other shards. So the constructions that's used is called a erasure coding. And so this is a construction that if you take some piece of data and, uh, you can encoded in parts. And one third of the parts is enough to reconstruct the whole original data, right? So, so this is kind of a ways that's used, like for data reconstruction, for signal reconstruction. And so this is used by us and Polkadot, and Lazy Ledger and bunch of other, as a people, uh, in, in this crypto space.

Illia (00:08:50):
And so, so what this allows us to do right, is that even if one shard is malicious, even if, like in our case, we rely even if one third is offline and one third is malicious. You can still recover all of the data from all the shards from the left, left one third of the validators, of the stake. And so this provides a data ability for all the shards, which means that even if something went malicious, right? Even if, if like, because it's the smallest subset of validators in your shard, you can always just go straight to the data and proves that, that thing went wrong and kind of roll, roll back, cause the whole chain. And so this construction, again, it's like, it's, it's very similar to how, uh, Polkadot, for example, does set specific piece, but in our case, because it's kind of considered one chain, we actually embeds us property directly into the chains, consensus and kind of chain rule.

Illia (00:09:41):
So, which means that the chain that has been built, like by definition, it needs to have this property of data, the ability, otherwise, the people who don't see the available data, like who didn't receive the parts from other shards, they'll just not accept the block, until they receives this data. So, which means like the kind as chain been built, you know, that because people built on top of it, right. And they approved the kind of block itself. They have holes of relevant data for this thing. And so, so kind of the data availability, like properties are the same as, as the properties of the kind of security on the chain itself, which is a little bit different actually from, from, I think like what Polkadot properties are on data availability and definitely different from, for example, even Ethereum, data they'll go to, like, for example, the roll-ups putting data on Ethereum 1, the attack cost is actually a 50% attack. Right. Because you can just for cause the chain from a different level. Right. And so just means that it's the kind of properties of, of data availability are actually like their cost of attack is different from the kind of cost of the, you know, day itself, uh, protocol.

Anna (00:10:51):
And like the security model, I guess

Illia (00:10:53):
The security model is different. Yeah. So we, we tried to align all those models together of like the security of the protocols, security of data availability and everything into kind of one properties that people can like reason about.

Anna (00:11:05):
Hmm. Do you actually envision a roll-up type system also existing on Near though? Cause I know with like, you know, they, if you look at the ETH roadmap, the idea of roll-ups also being kind of a permanent feature of an end game, do you also think of it that way?

Illia (00:11:21):
So I actually like what we've built and actually with Polkadot built, I actually call it that "realistic roll-up" because what happens is like this shard - or in case of Polkadot a Parachain - they kind of run this as an operator and they send it to the like in our case to everybody else, or in case of Polkadot to the Relay Chain and that relay chain executes it right away and verifies that the block is correct right away and acknowledges that it's good. And in Optimistic case, you wait 7 days and this is realistic case and you run it right away and say its good. And now everyone can you use it. And you can have cross-parachain or cross-shard communication right away. So from this perspective this is like a roll-up, and that's why I am saying that the properties underneath are very similar that you get.

Illia (00:12:06):
Now zero knowledge has a different properties. ZK roll-ups have properties of zero knowledge of like, first of all, scaling is a computation, a lot more and privacy. Right. You can actually execute some on data that may be not available at the, at the moment.

Anna (00:12:22):
Sometimes. Yeah. I.

Illia (00:12:23):
t's like this, this is the problem on zero knowledge roll-ups it's like, it's a very, like, it's, it's a big space of yeah, of a lot of stuff you can do. Yeah. So that I think is actually will exist in its own right. Because there's so much more use cases you can do that. Like it's not, it's not your normal kind of, you know, receive transactions, execute, you know, post it on chain, right. Like there's a lot more stuff we can do, including you can actually have a realistic kind of zero knowledge where you put transactions onchain first, and then you execute zero knowledge and commit to the result onchain.

Illia (00:12:56):
Like right now, zero knowledge like roll-ups, because a kind as a transactional throughput of the like of a Ethereum, is not enough to like accept transactions, they would accept transactions on their own, but it's actually not a good design because that means you have kind of a centralization point of receiving transactions. And also this has actually some possible potential legal implications, right. Because they may be like, it's similar to if like a centralized exchange received, you know, trades somebody's money and then settles on chain, right? Like centralized exchanges are enforced on the, they can do and the ones that cannot do. So, like actually roll-ups potentially right, if, say two, if the number of operators is too small, may get into the same problem. But if you use a kind of Unchained data availability first to like collect transactions, you don't need to execute them because maybe the data is actually like just a commitment hashes. Like you don't reveal the data you want to execute on. You just reveal the kind of desire to execute on and the ownership. And then the zero knowledge kind of operator pulls the data operate, like runs it and then commits to the state and commits maybe it as a result. Like that kind of system is very interesting because it allows to do like, you know, dark pools and kind of, uh DEXs and all this new stuff in, in a very like, kind of censorship resistant and private way.

Anna (00:14:15):
How does that operate or though? Like, so you just described it, like the operator is still there. Why is that no longer a point of centralization?

Illia (00:14:24):
Because any other operator can do the same job, right? Like it's a very different where like, I need to send transactions to this IP address or whatever it, this domain and I send transaction through the chain, right. So any of the nodes can receive it. And I agree on this as a transaction and then any other operator can do the kind of the like private execution. Uh, and like, at least from my perspective, and again, like, we don't know what's a legal requirements, et cetera, but like, from my perspective, in this sense, right. Like I can run an operator, you can run an operator. Right. And then like, we, we can kind of like whichever is operator gets it first and executes it. Right. That's, that's the one that does it, like, there's also like as, SGX stuff that can be used, but yeah, from perspective of like, you know what, for example, right now, like if you're doing StarkWare, right. You need to send transactions to StarkWare, they will be receiving that...

Anna (00:15:13):
There is a committee somewhere in there as well, but, and it's...

Illia (00:15:17):
Well, there commitees for data availability, their committee's for data availability post-factor. Like, after you commit to the result, but like, so sending transactions, like somebody needs to receive transactions. It's either, you know, a decentralized network or a centralised kind of entity, like there's two options. So as, as they need to build their own decentralized network to receive transactions and come and agree on commiting them.

Anna (00:15:36):
What you just described as, as operators, they almost start to take a role. Like they have to be incentivized somehow to do this. And so they're like sub-validators or something that you've talked about, like the validators that are, are also going to be existing on various shards. Could these be the same roles? Like, do they have to be independent of the system?

Illia (00:15:56):
So they don't need to be, so this is idea of like off-chain workers actually. Okay. So, so this idea of offchain worker where the job is like committed onchain and paid onchain, but you do some work and you commit to the result, like on chain, but you do the work off chain, right. So it's not, you don't need a committee. And so zero knowledge like provable work is actually very well suited for this because you don't need a committee. Like, the result itself is a proof that you've done their work correctly. Right. So that does really cool thing because yeah, like, I mean, from my perspective, it can be like a piece of software that reads from the chain that the input and what it needs to run, executes it and then commits to chain back what it does. Right.

Illia (00:16:36):
So then anybody can run this worker and there can be like pools of these workers like, and yes, validators can be running this job as well, but it would be kind of a separate service. You can, you can set up this thing for pretty much anything. Right. In theory, you can have like a, you know, MapReduce job where everybody's like pools some different pieces of data, executes and then commits to the result onchain. Uh, and like you, you cross reference that, you know, as a job that's actually done correctly and, you know, the results matches.

Anna (00:17:04):
Have that role, the off-chain worker. Is that something that Near would actually build? Or is that just something that is a concept that exists?

Illia (00:17:11):
So we haven't published this yet, but we're actually working on like a, I would say like a five-year roadmap. Which is not just like, not just for what we building, but like what's the ecosystem should build, uh, including a bunch of like different applications of kind of Open Web, right. And so this includes like the off-chain workers and like off-chain storage is kind of pieces of that like ecosystem because they will powering kind of this new use cases. So for example, Nuypher is really cool thing and they, it took them, I don't know, like two years, I think to build it because they needed to build their own infra for the off-chain workers. So is there is, are existing pool of off-chain workers. Their work would be just to put the contract to do like, it's the same contract I have right now, but also just write some piece of code, piece of WebAssemby that everybody can run. But like they needed to actually run their own testnets. They needed to do all this stuff because they built the whole stack themselves. And so the idea is like to have this kind of common infra, that would pretty much feed into it. Right. And use like different pieces of infrastructure.

Anna (00:18:14):
This is so interesting to hear Nucypher put in that context. I didn't think of their role as doing that, but now I'm like, Oh, that's like, cause I always learned about the tech. I didn't really understand how it fit into everything else, but that's really cool to hear. I wanted to ask you something else about sort of the general system, stateless clients. This is something we just, on the last episode, had a Alin Tomescu to talk about this kind of research into stateless clients. And I just wondered if you're thinking about that. If that's also research, you're paying attention to what that would actually mean for Near?

Illia (00:18:50):
I've, I've been having actually these conversation it's because, uh, I actually got a little bit into, well, some discussions on Twitter about like ETH1, ETH2, and, uh, so I've been talking with some folks who are working on this. Um, and we also have a episode of our whiteboard series about Turbogeth, unrelated topic. So I think like stateless clients are actually really great for protocol developer side. So as, as a protocol developer, stateless clients are great, amazing because you actually removing a lot of needs from kind of on the side of a protocol and you kind of pushing it all on, on somebody else to deal with. Right. The problem is that like, as a developer of who wants to build on top of the protocol. As soon as I start thinking about like, well, how am I going to handle this, it becomes like super complicated because it means that somewhere there needs to be like data available, right.

Illia (00:19:44):
We'd go back to like, what does the data availability layer looks like? And, uh, on top of it, it's not just, it needs to be available. It needs to be really fast. So, so like kind of the on-chain data availability, the reason it's fast is because all those people are super motivated otherwise it's going to get slashed. Right. But like, as soon as you say, well, the validate is actually don't care about data anymore. Right? They're just like, you know, you just received transactions. It was all the data as they need, they execute it, and they're done. On the side of like developing this client and protocol is easy and it also removes big, big chunk of like economic issues, which is like how to like how to charge for storing data onchain. But now you have this whole, like this problem didn't, didn't disappear from his ecosystem, it just moved to somebody else to deal with. Right. So now you'll have like things like, for example, let's say, let's talk about ETH1. Let's say ETH1 transitions to stateless world, now you have Infura, The Graph, like all those systems now still need to maintain the data because they will need to still feed, like give data to their users. And so now they need to do it. And if to go down, which you know, they do, well, everybody's completely like screwed because like where else can it get to get data? You can not go to miners anymore. They don't have data. Like you really need like one of those guys to actually work. And so, so obviously there'll be archival nodes, which will have data. But again, like there's no, like we already know there's no motivation to run archival node in the first place.

Illia (00:21:10):
So the only people who are on archival nodes are Infura, The Graph and like other kind of data providers. And so, so you kind of like, you remove this problem, but I haven't seen at least yet a solution for this problem on the other side, right. How´s users will be giving, getting access to this data because to send a transaction, now you do need to get like all of the Merkle path, right. To your balance. Right. For example, even in the simple case, like I want to send you some ETH, I need to get the Merkle pass to my accounts. Right. So I need to maintain that information. So like somewhere I need to pull it something from somewhere. So part of part of like, I'm trying to get in more with some folks who are like working on this, uh, personally, and also our team is talking, but I think like, it's thought yet like fully thought out from perspective of like how it will affect the whole ecosystem.

Anna (00:21:59):
Yeah. And also just, just going back to that episode from last week, we actually did bank, this distinction between stateless clients and stateless validators. Validation, rather in what you just talked about, would you also put stateless validation in there or is that a sort of different angle from what we...?

Illia (00:22:15):
I would say like, I mean, stateless this validation is what you want, because the reason, for example, we can not change number of shards dynamically also time is because we have validators us need to get state, right? Like, I'm like, why I'm saying, like, if, if we were rent stateless, it would solve so many problems for us. Like we've thought about it. Right. And we actually have, we have falls a stateless, like clients stuff built because challenges that actually challenges that actually validated in the stateless manner. Like we, you send the transactions and you send the state effectors and we can validate this in a stateless matter, like across the whole network. Like we already built all that. The problem is if, yeah, if we shifted that then like, well, who, who has data? Right. Like, so, so, so there is like, there's this missing piece, I think, which, I mean, I'm actually interested in like maybe Ethereum, there's some folks in Ethereum who already sorted out.

Illia (00:23:06):
So like I'm really interested to learn from them in this case. Uh, but I've, I haven't seen yet like a clear plan. Why like what's the motivation to maintain this data kind of somewhere else and feed and also serve it right. In a way it's actually like something like file coin, right? Or like some data storage solution maybe like closer to how then this needs to function, but then like file coin, serving data, and file coin itself has all the problems. Right. Do you need to pay for it to get data. Well, how do I pay for it to get data? If to pay, I need a data to send a transaction and it's like ... anyway. There's like a lot of this kind of interesting questions, like how to design this in like really working way.

Anna (00:23:46):
I had Anatoly on from Solana with guest host Georgios also a few months ago. And he had this extreme anti-sharding sentiment. And as like a team that's very focused on sharding. I always like, cause we had that interview and I left it. We never... I haven't quite. I haven't had a chance to really revisit that, but I want to hear sort of a counterbalance argument from you. I'm sure. You know his argument, right? Like you are friends.

Illia (00:24:14):
Yeah. We worked across, across the road from each other actually in San Francisco. So, uh, yeah, I think so. So there's like a snarky answer, which is, uh, if Anatoly is right then the mainframe is enough to like one mainframe is how Google and Facebook should be running their infrastructure. Right.

Anna (00:24:34):
But experience proves otherwise.

Illia (00:24:37):
Yes. Yes. There's kind of two conceptual reasons. Right? One conceptual reason is that: Yes, you can rely on like a very optimized, you know, pieces of hardware that's like can kind of scale up in, in big ways, but this piece of hardware will always be expensive. Right. And kind of his point is like, you know, Moore's law double every, every two years. And like the bleeding edge would be super expensive. Not a lot of people can afford it, but also you need like very fast network, like the fastest network possible. And on top of it, it's still only double every two years. And kind of, if you think from like Facebook adoption, Google adoption, like adoption, we want right now, the adoption we have right now, sadly like we don't want double every two years, right. We want, you know, like 10 X in, you know, in a year or something like we want, you know, billions of people using this.

Illia (00:25:30):
And obviously the billions of people can not fit on one computer at least, like not, not in the foreseeable future. So that's kind of one side and, and it's kind of like, like there's a usage of one side and there's centralization on other side. Right? So centralization part is like, there's only that many people who can afford to run this hardware. And so sharding solves this problem, sharding says like "well, we will run on kind on less sophisticated hardware, like it still, reasonable hardware, at least right now." Well the stateless validation can be actually less sophisticated, but, like "we can actually scale up and, and we also don't need to have everybody like receiving all the transactions all the time. So we do the need to have huge bandwidth requirements either. Uh, and instead, you know, we kind of scale out."

Illia (00:26:15):
So that, that is like one part. And the other part is actually very interesting, which is like Solano is built on, is actually different from how Ethereum is built. It's different from how other, like, like one chain network's built. It's actually built in very similar way as we built it because they, like, they want to parallelise as much as possible. They want to use all its hardware, which has a lot of CPUs, which is a lot of things. And so Ethereum is actually not built like that. Ethereum, is kind of one process running stuff, Solana parallelises execution of multiple contracts. Otherwise you can not achieve, you know, actual performance with like more CPU's and more hard drives, which is actually actually what sharding is. Sharding is literally parallelising stuff. Yeah. It's just like, it's done on one machine instead of done in multiple machines. And so, so the kind of like all the issues like we have on, on kind of like composability and some other like, and how users need to like work with the stuff. They actually, have of them as well.

Anna (00:27:10):
It almost sounds like the parallelization moves up a level in the sharding system.

Illia (00:27:17):
Yeah, exactly. Yeah. So we were just like, well, if everything's is parallelised, how do we solve this? Right. And, and, and like, the interesting thing is like, we can say, well, let's just try more shards on the, on the same machines, like all machines run all shards, and then we kind of get Solana to like to a big extent. Uh, and then, so, so we actually have this, like the way we were rolling out sharding. So we start, I mean, we can go into that a little bit more, but you can actually, like in reality, say, well, some, some shards will be running together. Right. It's just like, they need to run on more sophisticated hardware and some shards can like scale out. Right. And so in this way, you can actually combine this like different like requirements and different environments a little bit, uh, while still maintaining the same developer experience.

Anna (00:28:02):
Or you're in, in Near, are the shards homogenous, are they identical?

Illia (00:28:07):
Yes and no...

Anna (00:28:09):
What?

Illia (00:28:16):
We started with everything's homogeneous, and actually like the interesting thing, because the way we actually shard blocks, not, not, there's an interesting, like mind shift. You can think of it, every account and contract on Near is its own shard. And instead we grouped them into batches for optimizing processing. Right. So if you have your own contracts or your own account, it actually lives on some shard. And then we just groups, them kind of batch them in a way such that, uh, you know, you don't waste resources. Right? Yeah. And those, so that's idea like the blog, every transaction kind of comes into its own shard, but then you just batch them to execute them into the shards that you kind of described as the shards. Yeah, yeah. Into the actual, like physical shards. Right. And so, and from like from perspective, like Solana actually works kind of the same way.

Illia (00:29:09):
It's like every, every contract and account is actually runs in parallel. Right. And then, uh, they're just like batched, you can think of, it's like batched them on machine. And now that's why we can actually change number of shards very easily. We just re-batch, where the accounts are on which shards. So this is very different from how, like, for example, obviously like Polkadot, and, but also in how the other sharding networks think of it because you have like pretty much in other sharding networks or in Ethereum 2/Serenity design you kind of have an account on every shard in a way and you need to send money to yourself and the other shard and like your wallet needs to show it somehow. And it's like super complicated, like for a user, like now I need to think of like, well, do I have money on that account?

Illia (00:29:52):
Do I have DAI on that account? If I want to, like, you know, use Maker on that shard and so, so we kind of removed all that. We said, well, like from a user perspective, like you don't need to think about it. You just have one account. And we just say, well, it's a contract cross-account communication, all of this is a cross-shard communication. Even if they right now are in the same shard. This allows us to rebatch things. And it kind of makes everything in a way homogenous, because like everybody runs the same thing. But now the interesting thing is, well, actually, because each contract is its own shard in a way, you can say, well, one contract will be something else. So for example, we're going to be launching EVM as a contract on Near. So EVM, like Ethereum Virtual Machine, with all the accounts and contracts will be launched as a one contract on Near. And so inside it, you have all this like Ethereum contracts and accounts and everything. Right. And like, you can think of it as like launching...

Anna (00:30:55):
And then on top of that, you'd have solidity code running, so you basically have solidity code running ON an EVM, On the actual... Okay.

Illia (00:31:05):
Exactly. And like, you can think of it as actually, this is what a Polkadot is. Like your, your one substrate chain is really just one contract that then runs on relay chain. Like your parachains are just contracts that run on relay chain.

Anna (00:31:18):
Yeah. And then the parachain could be like EVM compatible.

Illia (00:31:23):
So, so, so this is what to be launching right now is like EVM is. And so it actually will not be its own like physical shard right away, because it's not worth it. Right. Right now we will not have in the beginning enough processing, but as it grows, as users grows on that EVM, it actually can pop up into some physical shard. So it depends on the usage, not on, on how we want it. But also means that anybody else can say like, well, I want an Oracle shard or whatever. And you know, you deploy a contract that does that. And then maybe like we are thinking about adding like our ability to pre-pay for some specific gas limit. So that you say, well, I want this much gas be like allocated for me. And then, so based on that, you may allocate it like into its own shard or like into its own mini shard.

Anna (00:32:11):
Are the shards specific sizes, like, is there a limit to the size of a shard? And so you could almost like buy the entire one?

Illia (00:32:18):
Yeah. So that's kind of the idea. Is like each shard is really like, what we benchmark in is, so we want like a one second blocks. So you need to execute like, within like the shard execution should take like 0.8-0.9. It's like, it tries to balance it. So it fits plus data distribution, everything. And we have like, obviously gas estimation for everything to kind of how to fit time on basic hardware, to the execution. And so this is, this is kind of your limit, how much one shard can have. And so into this, we kind of package all the, all the contracts that can fit. And yeah, so you can say like, "Hey, I want, I call shards for myself." Uh, so we, we, we don't have this implemented yet, but like, it's kind of like, our system allows us to do that because you can just say like, I want to prepay for this much gas for my contract or set of contracts. And then like when you send transactions to those, right. They'll kind of go into its own like physical processing. And so this is very valuable for articles, for example, because Oracle's, don't want to be kind of squeezed by somebody else, like even intermittently. And so they may prepay, like, they don't need like a full shard space, but they'd be prepaid for some amount of capacity to just like always have, have enough processing.

Anna (00:33:27):
Okay. So I think now would be a really good time to go back to something you teased out at the beginning of this idea of like, you've launched this new network. I want to hear a little bit more about like, what that means for Near? Like, what is launching to mainnet? Do you have this entire system like ready? Poof - Presto? Are there steps? Are there stages?

Illia (00:33:49):
Yeah. So we actually have had the idea, a bunch of stages and probably going to have a bunch

Anna (00:33:54):
Or phases. What do we call them?

Illia (00:33:56):
Yeah, I think, I think it's been a, it's been a thing now. So one thing is like launching network is super freaking hard. Like there's a multiple complicated parts. And I would say we also, like, I mean, we underestimated how much work it is, multiple times, to be honest. Right.

Anna (00:34:16):
Okay.

Illia (00:34:18):
Like were like, okay, now we know what it is. And then like, no, that actually there's a bunch of more work that you didn't think of. And so, yeah. I mean, I'm, this is big part why I'm like, like, it's so hard to launch networks, even, even if you have all the code ready, it's so much easier to just launch an app on an existing network. So, I mean, this is like just kind of like I've been having this back ...

Anna (00:34:36):
This is a warning to all those L1s that are coming up.

Illia (00:34:42):
Yeah. But also like people who are trying to like, you know, launch like their own cosmos network or even a parachain is like, "yes, the framework solved a lot of problems for you, but there's still a lot of work that's kind of there to do to get it off the ground."

Anna (00:34:57):
Would you say most of that is like lives in the community side of things or is that like a technical challenge?

Illia (00:35:03):
There's technical, there's a kind of economic, community, communication, like technical. I mean, obviously like we built all of our code base from scratch, so there's just a lot of technical thing, which kind of we got ourselves into. Uh, but then even after that, right. If you think of it, like just coordinating a bunch of validators and getting them to be like running the same software, you know, making sure that everything works, networking, firewalls, all this stuff. And obviously now we have like this layer of professional validators. So let me, let me walk through kind of how we've been launching. Right. So I think like kind of a general practice now is, has this like incentivized Testnet the first time we started, this was actually like end of November last year. So like a year ago. And so it was like a Stake Wars kind of idea.

Illia (00:35:49):
We wanted to kind of validate us to like battle against each other and try to find vulnerabilities. And what happened is our software was not ready at all. Right. Uh, like it wasn't battling agains't each other. It was like...

Anna (00:36:11):
Getting it to work?

Illia (00:36:13):
Yeah. The part is like, we weren't just like, "Hey, you know, we wrote some code. It's ready to go." No, we had like bunch of testing. We had our own internal networks, we had all this stuff and, you know, it seemed like it's ready, but like the real world is just so much more unpredictable than what you have kind of in the lab. And so we actually stopped our Stake Wars, and we were like "Thanks everyone, this was very ... informative! We gonna take the time to actually analyse and find our core process issues in how we do things"

Illia (00:36:41):
And so this led to like multiple changes on kind of how we do software development, like pull requests, reviews. How we do release process, how we do testing and kind of what kind of testing we do as well. And so this, like, we kind of revamped the whole process and restarted, like, I mean, was that we kind of fixed a lot of problems and found a lot of problems and restarted Stake Wars again, um, in like February, March this year. And so with that it actually worked way better, but some people were like, it works too well. Like why are you guys launching so late?

Anna (00:37:19):
But you had learned a lesson that you, there were edge cases you had to really try out for, look out for.

Illia (00:37:25):
Because if you have like very like non baked software, you get a lot of the same problems all the time, and it actually stresses people out, like kind of actually developing.

Illia (00:37:36):
Right. And it's really hard to like, communicate around it. So now, like, it was kind of registered for a process. It was like very easy because we're like, well, we've got to be like hard forking to network every "this much". So like, if there's issues, if that's what stop is like, okay, fine. We've got to restart. And like, is, this is also like lessons learned obviously like from Cosmos ecosystem. So like Zaki's recommendation, et cetera, being kind of incorporated into this. So that started. And even then there was a lot of like really funky problems that kind of came up. Right. And so each funky problem we saw, we kind of incorporated it into our lab testing. So we have this like, uh, we call it the Nayduck, a testing suite. There's like 120, 130 like scenarios. And so this is not like unit tests or integration tests. This is a full cluster - spinning up a cluster of nodes and doing something with them and seeing that everything works. So like, you spin up a cluster, you send malicious flocks, you spin up a cluster, you drop nodes, you restart nodes. You like hammer them with transactions. You like do all kinds of stuff. Uh, you know, you change Epochs, you'll kind of remove validators and like add validators, all those like scenarios.

Anna (00:38:47):
Is this something that you built or is this something that's standard? Is this like an existing tool set?

Illia (00:38:53):
We have built this, this is actually, this is actually Alex's experience from memSQLl, which we should have adopted way earlier, but it's good we adopted. I think it's a standard thing for like in decentralized development environment. And I was actually surprised, I've been talking with the open Ethereum team, and Ethereum actually has a version of this, but it's a kind of, it doesn't seem like it's actually being like fully used. Uh, so actually I actually super, like, I'm going to put some boundaries for people to like, to use Nayduck, to use our infra, to run Ethereum clients on it, to test, uh, kind of their scenarios as well.

Anna (00:39:32):
Interesting.

Illia (00:39:32):
Um, because I think like this is a, yeah, this is very powerful framework to kind to test this like very complicated setups. I think like they have the for ETH2, but actually for ETH1, like Ethereum foundation has a framework, but like, I don't think it's been like exercising a lot of the, a lot of the like kind of more networking level problems.

Illia (00:39:51):
Like I think that the frameworks they have right now is mostly for consensus part. But anyway, but this idea, like it, it actually helped us a lot, right, to kind of standardize how kind of developers can test, like can get like battle-tested their code before, before, uh, submitting it. And so it helped a lot, but still we had all kinds of like random, weird stuff happening. Like one of the validators had like some CPU instruction missing on their like somewhat new CPU. And that led to like a fork of the network. Right.

Anna (00:40:22):
And all the edge cases are going to have to think about, Oh my goodness.

Illia (00:40:26):
And then we also had like upgradability stuff. So we introduced upgradability. It came kind of late. Like we were already like in like during this process at like, we were pretty like stable and so introduced upgradability because we were like, well, as we launch mainnet, right, we want to continue evolving the protocol. And it's important that like, it's pretty easy to do. Right. And so introduced kind of like a protocol level upgradability and that on its own that a bunch of stuff, because actually, like, we haven't really tested it well in this lab. And so when, you know, when the network upgraded and like some people didn't, and then there's like, you know, all kinds of fun stuff that happened. So yeah. So a lot of just like edge cases and random, weird stuff that happened that what we did right. We just took it and we implemented it in Nayduch and just like kept building up the library of just like kind of stress test for the network. So, so that's been like the summer let's just say. And so with that, right, We call it a betanet. So betanet was our network where pretty much it was hard forking all the time, so it wasn't for developers. Was for validators to just like hammer at it. Like, we had 100+ people hammering at it all the time, it was professional validators but also people from the community who were like "I want to figure out how to run nodes, let me try it". So learned a lot, figured out a lot and then transitioned them to our official Testnet.

Illia (00:41:53):
So our Testnet actually the interesting history for it. This testnet has been running since April 2019. So it's the same network that's been hard forked and upgraded into what it runs right now, without changing state. So like if you deployed some contract in April 2019, it's still there.

Anna (00:42:11):
Wow.

Illia (00:42:11):
And so it took us a lot of work to, to make those work. But, but... So because of this, like some, we had like a, you know, a group of developers who have been developing Near. And so there've been kind of using this testnet, so we introduced kind of validators to that network. And like, by that time, everybody already learned kind of how to, how to do the work, how to like how to validate what it involves, kind of like we have smart contracts staking. So it's like a little bit more interesting and, but also complicated, for validators.

Illia (00:42:41):
But, uh, yeah, so this is like, then we ran testnets for a while, making sure that that operates properly. And so then in parallel, actually we launched a Proof of Authority version or like kind of permissioned version of mainnet. And so we did that in like end of April, beginning of May. And the idea was there's actually a chicken and egg problem of - a lot of tooling needs mainnet to start being built. And at the same time we needed a lot of tooling for mainnet. Like a wallet, Explorer, all of the stuff. Right. We wanted to test it on mainnet, but like, it needed mainnet to be tested. Right. And like, you know,

Anna (00:43:22):
What does it need mainnet to be tested? Is it's like, couldn't you test that on a testnet? Like all the accounts and all that stuff?

Illia (00:43:28):
So we tested everything on testnet, obviously. But like for a lot of like actual, you know, real stuff you still want like still kind of acceptance testing on mainnet. Right. And the same thing for like token distribution, like some, uh, like kind of other stuff, because like obviously is, uh, like some accounts are different. The keys will be different. All the staff will be different. So we kind of like launched this PoA so we can start like getting some developers to, to like really deploy to mainnet and actually test everything. And there's still was like kind of operated by us. And so there's a lot of constraints, but what it allows us to do is actually not needing this like, Oh, today everybody's starting mainnet. It was like now that you know how testnet works. You can actually onboard a mainnet. So we had like the slow process of validators coming in through pretty much August, September and September 24th is where we stopped validating completely a mainnet. Right. So it was kind of not like a step function where it's like, okay, today, you know, everything's launched it. It was like a smooth function where it's like, you know, started off as like Near Foundation and then over like, all those validators were kind of external.

Anna (00:44:34):
Yeah. And I should say like the Zero Knowledge Validator, which I've mentioned a few times on the show is a validator on Near. And that is actually where I started to see more about the Near network. It was probably like, you know, earlier on this summer. So I did see a little bit of betanet to testnet to mainnet. I guess this is the big challenge for the rollout, is having.... I mean, has, has anyone tried? I don't, I don't know if Cosmos did it this way, but like, has anyone tried to go straight in like launch mainnet with validators day one?

Illia (00:45:05):
So I think like everybody's in recent days, like maybe like in, in 17, beginning of 18 is different, but like Cosmos, Polkadot and us, we all launched is kind of "restricted tokens". So we did not allow to transfer tokens. And we gave this decision to the community itself. The cosmos did start was like already a set of validators on day one, us and Polkadot have kind of, uh...

Anna (00:45:32):
POA version to public, yeah.

Illia (00:45:36):
And cosmos, I mean, a big reason is like all the validators, like Cosmos has been building this validator community for two years. So like to a big extent, like us being able to build it like quicker is the reason because Cosmos sorta paved a lot of work for a lot of, a lot of us. Yeah. And, uh, so they had like this people who were kind of were ready to go and they'd been doing this for two years and, and uh, like it was like on day one, they had had all of them kind of ready to go. In our case. Yeah. We kind of build them up like, and trained them and a big part of it. Like we, our system is pretty different. Like we have different account model. We have, you know, smart contract staking. We do have sharding. Like there's like some other stuff that's kind of, uh, like interestingly different. And it was like really good to have, like people kind of test everything before the, you know, like, I think like if we tried to launch it on day one, it would have been like a pretty, pretty dramatic like mess. Yeah,

Anna (00:46:34):
No, definitely. There was like these small steps and like educating the validators as they go, as you were rolling it out, they were like parts that we had to do to get to get on board. Um, are you let, let's talk a little bit about like building these validators, this, this group, how did you go about putting that together? Was it like existing validators? Like what was your thinking around it?

Illia (00:46:57):
Yeah, so it was, as I said, like combination, it was existing kind of professional validators who already been doing this on like Cosmos, some were doing this on Tezos . It's pretty small community at the end right. So we like connected to most of them one way or another. So, uh, we kind of been talking to them before and we just invited them to like beta net when, when it started. And at the same time we made it open. Right. So we said like, Hey, anybody can apply. We actually had like over 300 something applications when we just launched it. And so there's like big part of, it was like this professional ones, but also like there's a lot more people who are kind of like "I'm a developer who is just interested in this stuff" or " I am a developer who has already been validating!"

Illia (00:47:48):
And so, so this is a group of people they were kind of, I would say, newer to like doing validating in general, but at the end, like, you know, they gave a lot of feedback as well because they were people, people who are maybe less, like they're newer, so they have a fresh eyes so they can give, give kind of more... And also they were writing like all kinds of different hardware. Like, as I said, a lot of people are writing in cloud, but a lot of people were running like dedicated hardware. It was like all kinds of random, random things like, like Docker is not working and stuff like this. There, we had like a set of challenges where: kind of through doing them, you kind of learn how everything works and you also write documentation or tutorials for other people. So it's kind of like...

Anna (00:48:28):
Fire training by fire.

Illia (00:48:31):
Training by fire?

Illia (00:48:31):
But also like, like the, the thing that trying to do is find this people who are like, who are excited and willing to do it and use them kind of as an amplifier. Right. So like I was mentioned as like a fractal model is I think like, obviously like as a, as a kind of core team and as like, as now the network launched, so to kind of our role, you know, it's still pushing infra stuff, but at the end it is a network of the community. So we want kind of in a community, people who around whom there'll be kind of keep growing the network and ideally it will spin up its own like kind of like mini ecosystems. Right. And so, so we, we, we've been kind of doing that on validator side. And we also started doing this on, kind of community side.

Illia (00:49:15):
So we have this guild program, which is really around, like, if you were interested in creating a community around some topic, which is related to Near in some way, right? Like, like we can actually like help you and fund you and, you know, give you tools and, and kind of a place and everything to, to grow that. Right. So ideally, you know, like there'll be meta guilds, which will spin up into a bunch of other guilds and stuff like this. Like, so that's been kind of growing, like we have really cool CreateBase guild running by Mintbase, which is like about NFTs on Near, right. It just had a treasure actually, uh, yesterday inside, uh, like, uh, kind of this VR experience.

Anna (00:49:55):
Oh yeah. I saw that. Neat. I didn't get a chance to do it. I love that connection though: NFTs to VR.

Illia (00:50:02):
But yeah, so this is ideas like, you know, in validators kind of has the same thing.

Illia (00:50:05):
So one of the validators like, uh, has he has been running Russian community for Near and now he's like, he built already like two applications on Near as well. Right. So, and, and kind of like from there, like from the Russian communities, there's also like new validators spun out, that actually like, you know, kind of doing their own like ecosystem stuff and then work. So, so really trying grow from there, whereas like, you know, the educate kind of next generations and next generation becomes like a, you know, on its own kind of, uh, evangelists in the, in the system.

Anna (00:50:37):
Now a little bit about like, to go forward on this community topic, like, how are you incentivizing people to actually build on Near? Like, why build on Near, when there's all these other L1s that we've talked about? What's the benefit? And I feel like, I mean, you guys especially have really worked on, on making this, the developer experience. I'm curious to hear what you say.

Illia (00:50:58):
Yeah. So I think there is kind of few levels of this, right? So the reason why we started this right, was because we wanted to build something ourselves.... in kind of this blockchain space and realized like how hard it is. And also, I mean, obviously like scalability being one kind of hard part and also just building is another hard part. Uh, so we focused a lot on kind of reducing this barrier to entry and to be honest, like we're not there yet. Like there's still a lot of work to do. Right. I mean, we we've, we solved some problems since there's still lots of problems that we like, we still identifying as we bring any more developers in and seeing kind of their feedback, but to kind of the goal right, the aim is to, yeah, to make this experience really smooth for a new developer, both from existing crypto and from like open source or even from kind of people who build software and other spaces.

Illia (00:51:50):
Like, you have those great moments where people like coming from Ethereum ecosystem and say like, "Holy shit, this is so much easier. And like, you know, I I'm like up and running in, in one day and already deployed something on Testnet". Right. And you're like, yes, this is great. And then you have other people who come in and it's like, "Where's the graph, where's the, yeah." And you're like, yes, we, we kind of, we have like our day zero was, you know, November, like, uh, October 13. Right. So give us some time. Right. So, so you have this kind of, uh, like there is still a lot of work, but you know, we have like this early, early confirmation that they're on the right path. Now. So this was like a kind of basic thing. The other thing is, and this is why, like, this is my belief, I believe, in, in kind of blockchain, the first place.

Illia (00:52:35):
Right. And we really like to kind of re-frame this as open web, because I think I actually, like, uh, I saw Vitalik tweeted yesterday was like, "Oh, how do we rename the crypto space?" Right. Uh, and like, what does the names like? And the thing is like web3 is, is like, it's cool for like, just like geeks, but it's not really means much for people. And there's this concept of "Open web" which existed for 15 years and Google, Mozilla been pushing for it like a while ago. And this is idea of really removing "walled gardens". This is the idea of really like, kind of enabling people to interact with web without kind of boundaries and, you know, and centralized powers. And it's, it's, it's like back then when Google was kind of fighting with Microsoft was fighting with Adobe, was flash, was all those things. They were like pushing for it. And now when they kind of there...

Anna (00:53:28):
Let´s put up a little bit the walls, but yeah, but it sounds like this is so in line with the open source community, the open source spirit, decentralization...this is super cool.

Illia (00:53:37):
But then you go to open source people and you say like, Hey, why are you guys no building on blockchain? They were like, "Blockchain? Isn't that, that thing's a whole scam thing that's been, you know, in 17." And so, so the idea is actually bridging this gap of like open source developers who are building a lot of really cool software and not getting paid for it, or getting paid by big companies. And bridging this gap where we have this token economics, we have this instruments for like Ownership Economy for all those things and bringing them together. And so to do that, we have few pieces. One is on the protocol level. And so this is this "Contract Rewards" kind of economic piece that we built in into protocol where a percentage of transaction fees goes to the kind of contracts that are, you know, serving the user. Right. And so this allows like, as you build libraries, as you build pieces, like services and pieces of software onchain, they actually accrue value. Like, and they can be distributed to developer, to like maybe a DAO or something like, like developer can decide how they can be distributed. Um, but this allows to have a business model around open source.

Anna (00:54:42):
And this is super different from what exists right now, where you have developers who will produce some sort of very, very important tool or code, like some, some kind of middleware, I don't know if that's the right term, but you know, like something that will be used by other profit-making entities, but there's no way to fund it. And there's no reason to maintain it. This is kind of trying to solve for that. It sounds like.

Illia (00:55:02):
Exactly. Yeah. I mean, even if you think of it, like Uniswap is like originally, right. As, as a piece of software, didn't have a token, it didn't have an economics, like the developers of UniSwap actually were not able to kind of take a fee even off of this thing, like for regulatory reason, but like all the people with money for benefiting. Right. And it's kind of like, it's, it's very mind mind-boggling. And part of it is I think like this, I call it ownership, like ownership economy, right? This whole liquidity mining and all this stuff has kind of this idea of distributed ownership of something. And so this is a very powerful concept that can be used across the whole space. The kind of this idea I've been pitching, which is like, let's, let's imagine we're building instant messenger and you can actually distribute tokens to people who are bringing more people into this instant messenger.

Illia (00:55:47):
Right. It's like, so, so you can leverage the same, like kind of liquidity mining patterns and like distribute to people who are adding value to your network, like to whatever network it is, instant messenger, you know, gig economy, whatever, like a marketplace for NFTs, right. You can leverage the same patterns everywhere. So this is kind of the second layer of economics, which is - I'm actually like I'm writing blog posts about those. But like, I mean, all of this is like, this is not news. I'm just kind of trying to summarize it into like a pattern and then give people some tools so they can do it. - And so this is built on top of kind of just like open source libraries and services, which then will be accruing part of the value from there.

Anna (00:56:25):
That sounds like something that would be really appealing to that, to that community. Is there anything else that you've done that makes it sort of easier to build on Near?

Illia (00:56:34):
One piece that we've, uh, we started working actually way, like long ago we actually started working Elsa last year, somewhere around this time, is a bridge to Ethereum. And our original, like from the beginning, we were like, uh, you can do kind of a multisig approach where, you know, like few people sign, but just creates such a big like vulnerability in the whole system, that like, we wanted something that's like trustless and decentralized from the start. So Anton, who is a co-founder of 1inch, uh, back then, whereas working on like how to do this. And so he figured out the way kind of piecing together, some works at Kyber network did and some like kind of new stuff on our side. And we actually changed our protocol a little bit like, which, like, I mean, some technical parts, right, how our blocks are gonna..., Et cetera, to enable this new, like rainbow bridge between Ethereum and Near in a fully trustless manner.

Illia (00:57:31):
So, so this thing, like it's pretty much, we actually have a private beta, uh, that's coming out. And so we had a, like, it's been running on Testnet. We had security reviews. We had the hackathon was a bunch of people building on top of it. And so the idea is that allows you in a trustless manner to connect us to networks, to transfer assets, tokens, and NFTS, whatever you want. And also to really do anything you want, you can call contracts on the otherside, you can like prove that some piece of data exists on the other chain. Like you can actually read data from some other contracts, uh, on the other chain without even having to call a transaction on the other side. So it's very like versatile protocol. It actually works also with like other networks, like anything that has like, as a smart contract that can be programmed, like Cosmos, and Polka- Substrate networks, like you can actually link using the same protocol. You can link to them as well. And so there's like few folks are working with a few other chains to see how, how to do that. But like, with Ethereum specifically this allows the developers of Near to leverage all the kind of assets from start. For example, if you building some new assets, so new marketplaces, you can kind of leverage the assets from Ethereum, or you can bring your assets to Ethereum and, and leverage the existing exchanges, et cetera. So it creates this like very interoperable system.

Anna (00:58:49):
Is this bridge, is it a mint and burn or a lock and unlock?

Illia (00:58:56):
Uh, well, it's actually depends on what you're doing. So, so there's the bridge itself is actually like it's a three layer architecture. And so on the top, like first two layers are providing the proving infrastructure. Is it prove that some information or something happened on the other chain. And then on a 3rd layer is we call it "connected layer". And this is where you, as a developer can define whatever you want. And so, for example, for token / ERC 20, like Near's version of it, it's a lock, you know, mint and burn, unlock kind of model, but you can also build your own, like if it's not like an existing token, but a new token that you want to deploy on both sides, it can be mint burn on both sides, or it can be whatever you want. Right.

Illia (00:59:41):
You can also, like, I don´t know, like you can have pools, you can have like, so, so some people actually already working on a cross chain pool, which like, is, is.... like Instead of having like kind of ERC 20 that you send, you actually maintaining balances that kind of are joint balance between those two things. And you just kind of settling underneath how things are. For example, Ampleforth, like we have a bountie with Ampleforth. And with Ampleforth, you cannot like just, you know, send tokens directly because you know, the balance, the rebase can change your amounts. So you actually need to handle it a little bit differently on this connector level. And so on the connector level is really where developers can go crazy and develop kind of lots of cool stuff there, including like liquidity mining connector that, you know, as you deposit more funds, you know, you maybe get like another token or stuff like these.

Anna (01:00:29):
So you just mentioned sort of these three layers and that there's this proof layer. Do you know if there's a chance to put like ZKPs in that proof layer? Or do you think of using that? Or is that totally off the table?

Illia (01:00:40):
No, no, no. It's totally on the table. It's totally like we have, I actually have a bounty

Anna (01:00:45):
As, as the ZK podcast and ZK Validator. These are the questions I need to ask.

Illia (01:00:51):
So we have a bounty actually out for building a zero knowledge, uh, or like succinct proof for our light client. So one of the issues with the Ethereum is that Ethereum, it's expensive and it's actually pretty limited on how much computation you could do. Like our light client, I mean, we made it very cheap, but still costs like pretty, pretty expensive to verify the signatures. So we actually like, yeah, like our lightclient can be succinctly proved was, was a zero-knowledge proof. And that's what actually speed up the connectivity between Near and Ethreum very much. And then on top of it, yeah. Any, any other proofs, like there's a, there's a bunch of proofs that, uh, flying around can also be like, uh, compressed with a recursive zero knowledge proof. So yes, for sure. There's a lot, there's a lot of cool, cool, cool stuff there to do. So yeah, if anybody like on this podcast is interested in excited to build something like this, Reach out! We have like funding to do that. And I mean, we also can connect you to all the people in this ecosystem who are working on this!

Anna (01:01:53):
Very cool. Well, listen, Illia, I want to say thank you so much for coming back on the show and sharing this update with us.

Illia (01:02:00):
Yeah. Thanks a lot. I mean, thanks for supporting us as well with the Zero Knowledge Validator and yeah. Thanks for great questions.

Anna (01:02:07):
Cool. And to our listeners. Thanks for listening.