Kadena Workshop I C J Freeman

[Music] Hi, I'm CJ, developer relations a Kadana. This is a tutorial suitable for both absolute beginners and seasoned EVM contract developers in order to give a step-by-step walkthrough of using our scaffold framework to develop on our brand new EVM chains. Before we get started, I'll take you over to Kadena's founder, Stuart Popejoy, and chief technical officer, John Wiggley, in order to give you a comprehensive overview as to the benefits of deploying with our unique multi-chain architecture. When that's done, we'll go directly into the scaffold tutorial that will allow you to get your contracts deployed on chain within just 20 minutes. If you're already familiar with Cadana architecture, you can skip directly to the working tutorial at around the 21 minute mark.

If you're watching this on YouTube and find the walkthrough either too fast or too slow, remember you can edit the playback speed to 0.75 to view it slower or 1.25 to view it faster. Over to Stuart and John [Music] Welcome ETH Denver. We are Cadana layer 1 proofof work blockchain and we want to talk to you about scaling EVM with parallel chains.

Great. So, um, a little bit about us. As John mentioned, we run a, uh, parallel chain, uh, proofof work blockchain and, um, a little bit about me. Uh, my name is Stuart Popejoy. I'm a co-founder and the CEO.

And, uh, my I've been in technology since the '9s. And my, uh, relevant background here is I was a founding director of the JP Morgan Blockchain Center of Excellence.

And my name is John Wiggley. I'm chief technology officer at Cadana. I've actually been in engineering now for 36 years. And my team and I are responsible for the chain web and pack technologies that we'll be introducing. And prior to joining Kadana, I worked in blockchain at Definity on the internet computer.

So we're going to talk about how we're taking uh the technology we've developed at Cadenna and how we're going to bring it to the EVM ecosystem. But to kind of set the stage, I want to talk a little about scaling which is obviously a topic that everybody's interested in and just to get into it and you know and what are the what's the promise and what's the peril in terms of scaling EVM technologies. So, first thing we wanted to do is that when John and I think about scaling, having been in this industry a long time, I've been in tech a long time, we think of scaling very specifically as something where you have a resource that you that when you need to scale, you can throw more of that resource and there's no limit on how much of that resource you can throw at it. So for instance you have a website it you know you have bunch bunch of users coming in you can throw more machines at it you can throw more nodes at it and there's no limit to that uh in order to be able to accommodate your use case right if you on the other hand say you've got the world's fastest uh single node machine and it can go to whatever TPS once you hit that top TPS you're not going to be able to go further unless you have something that you can then throw at it to handle the next kind of burst of uh traffic or what have you. Um so today what we see with Ethereum of course is that we're using rollups and L2 uh layer 2 and layer 3 technologies to scale and the progress has really been tremendous.

Um we got more blobs coming into uh in into the Ethereum mainet and it's really been successful um enabling the Ethereum ecosystem to handle more traffic. Um so there's a lot to like but there have been some drawbacks. Um and and the main thing is with kind of decentralization and simplicity in the sense that I think the reason why a lot of us are attracted to working in blockchain tech is that the idea is that in in some way it should be centralized and it should be simple uh what you're trying to do or how or more specifically how you do it. So let's do a reality check. what what is this scaling approach uh what are some of the perils that we've encountered and the first one is complexity and fragmentation and that means that developers uh and projects when they want to build adapt and scale adapt have to make a risky choice of choosing amongst uh diverse layer 2 uh platforms or even run a layer 2 themselves uh run a validator network themselves there's a lot of uh complexity involved in scaling ing your app and potential fragmentation.

The second problem that is people are very aware of is that uh is centralization has creeped in um as people you know want to get stuff out to market that actually delivers on the layer 2 and roll up promise they have had to cut some corners with decentralization with sequencers etc. And uh this has you know it's something Vitalic has talked about and it's something that is uh it's regrettable and worse there's no kind of relief immediately in sight for how we're going to address the centralization issues. And then the last one is that decentralization is more than just a value. It's it actually adds up to real world uh problems such as censorship and fraud. uh when you have a small group of actors who might control a particular platform.

So uh I like to look at decentralization as actually a security guarantee. When things are decentralized, you're actually more secure. So what is the technology we've built to address these problems? Uh we call it chain web. So in chain web, the expandable resource, if you could go to the next slide please, is parallel chains.

So, we built this as a blockchain network that can grow with adoption and utilization pretty much forever without bound. Um, in our network, the expandable resource that Stuart was talking about is our parallel chains. This is a this is an environment in which there's no master chain. There's no hub. They're all equally independent of each other.

And this is the only network of its kind right now in the blockchain landscape. Now, these parallel chains are unique in that they act as an oracle of each other's history. We use a mathematical construct called an expander graph that allows each chain to operate fully in parallel completely independently. Yet, after a certain block depth, they each see the fullness of each other's history. That way if an event occurs on chain A, chain B can validate a proof of occurrence by looking into its own history and seeing the history of chain A and being able to directly validate that proof.

So this has the unique property that as chains are added while efficiency and throughput increase it actually becomes more resistant to attack. And this leverages the smooth divisibility of proofof work. I mentioned at the beginning that we're a proofof work layer 1 blockchain and we chose that for its simplicity and some of the built-in security and decentralization guarantees we got we get with it but it aids us as well in our parallel chain environment because as chains increase and we're we're able to increase them at any time the divisibility of labor is also an advantage. The miners are ne now able to mine across a growing and growing pool of chains. So the hash rate distributes smoothly across all the chains which eliminates minor competition and means that the energy utilization per transaction can actually go down as the TPS is going up.

So some of the real world benefits of chain web is that this has been running in operation in production without interruption for now 5 years. So this is not a w this is not an idea or a promise of technology. This is technology that has been serving our community for quite a while now. Um and it hasn't been a walk in the park. We have been attacked.

We have had hash rate disruptions. But the benefits of proof of work have shown through every time. So this is a technology that's proven and it's here today. In this environment, gas has stayed cheap, congestion has remained manageable, and it means you don't have to run any kind of node or validator network separate from the core consensus of the proofof work blockchain itself. The second technology piece to our uh environment is we call it pacted.

It's both a smart contract language but also a set of protocols. And what Pack does is it leverages this secure and effortless crosschain environment that I told you built on the expander graph and allows us to design and deliver a parallel bridging protocol across these chains. This allow allows scenarios for example where you can do true burn and mint. So I can transfer tokens from chain A to chain B where I am burning the tokens on A, minting on B and achieving a complete zero sum for balances across all chains. And this is done effortlessly.

You can think of it as a as a kind of bridging in which no oracle is needed and no validator network is needed. It's an intrinsic built-in concept for our chains. This means that builders on our network do not have to worry about congestions or gas spikes. Now, a lot of networks that are new do have low gas fees. So, we're not new in that respect.

But as businesses know, when you build on any network, gas becomes expensive with utilization. So, as your user base increases, as utilization of your app increases, even as external events on the network happen that have nothing to do with your app, but represent a huge demand on the network, your business can suddenly face gas spikes that price your users out of your business model. and we are able to provide an environment in which that does not happen. So five years into this journey, we're now ready for the next step. Stuart, thanks John.

So we're here today to announce chain web EVM and uh we're really excited to be at ETH Denver because uh you know EVM is what everybody's using and it's the technology that we're all you know using every day and very excited about and and want to succeed. Um so today the cadenna network runs 20 chains. We launched actually with 10 and then we forked to 20 chains uh doubling our throughput. So later this year we are going to once again double our chain count but the new chains 20 chains coming on are going to be running fully standard EVM solidity ABI uh that developers know and are used to and are and work seamlessly with all the existing great tools like hard hat etc. Um and uh not only that, so that gets you EVM, which you know, and and is familiar to developers, but on top of that, we've also introduced a we're introducing a e uh we're working on a draft EIP that brings the protocol that uh John was describing for secure sharing of assets across these chains.

uh the mint and in the case of uh specifically ERC20 you have uh the ability to mint burn uh from one chain to the next and the thing to understand there is that this is a unique scaling technology in blockchain because um normally when you move things off of a chain and onto another chain you have to uh lock mint on the other chain and then release and this is a this is a different technology where you actually maintain the same overall balance balance of coins over all of the chains. Uh so this is something new for the EVM ecosystem and indeed there's no architecture like there's no parallel chain architecture like this outside of Cadenna in blockchain today. So it's something that uh it's going to be a new experience for developers and that's where the EIP is going to be very important not to mention our experience uh working with this protocol intact. Um the other important thing to note is that this is not uh vaporware. This is not a roadmap item.

This is something that we are introducing a developer preview today that where you have a you have our chain web consensus running in a devkit with two EVM chains so that you can deploy contracts right onto that and start testing out these parallel chain protocols yourself today. Um so we have a little demo for you. It's not a demo, it's a video because we're not crazy.

Um, Stuart, before you go on to that, one point I wanted to make really stress because you might hear the term parallel execution from other other uh, vendors. I want to distinguish this from parallel chains. So you can think of parallel execution just like threading on a single CPU where you're able to submit multiple jobs that could exist and run concurrently on the CPU, but the CPU at the at the end still has to sequentially sequence the updates to memory that happen as a result of the work being done on these threads. In a parallel chain environment, that's more like having multiple CPUs that are all making their own updates to memory at the exact same time. So this is true parallelism rather than some sort of optimistic threading scenario.

Yeah, that's a good point.

Okay, so I've cloned the repo. I've created a directory, cloned the repo, seed into into scaffold container. I've then opened it up in my IDE and now we can get started. As you can see, the quick start requisites uh should all be pre-installed before this. Now we're just going to start by installing our dependencies.

As we can see started. This is you may be slightly slow for you. I'll skip forward. But yeah, it might take you a minute or two to get these dependencies. And just while this is going on, I'm going to use the terminal just in the side to make it more clear as to what we're actually running because we're going to be running simulated chains and we're also going to be running our front end.

Okay. And the dependencies are done. So let's actually let's start up our chain. So if you have experience with hard hat in the past, then you'll know that yarn chain is going to simulate a chain. It's going to spin you up a local chain preund with prefunded accounts.

We've actually included within this repo our own plugins. You can see that require that allow you to simulate multiple chains with the same command. So um these are all you don't need to install these as you can see they're all they're already um included. So let's run yarn chain. I'm as you can see I'm running this in a terminal next to me so we can give it a better um idea.

And here's the difference. Right. So you can see chain one here. Chain one accounts all preunded. And you can see chain zero.

So we we've actually got two separate chains being spun up here through our through our plugin. So they're they're already up. So now let's try and interact with them. We're going to leave this terminal open. We're going to start a new terminal.

Let's get into hackathon and let's cd back into this repo and we are going to deploy our contracts. So our chains are now up and running. Now we want to deploy our contracts on them. So we're going to deploy them. Maybe if there's some errors here, ignore them.

Oh no, there's no errors. Fantastic. Um and where where is our contract? So our contracts are going to be sat within our contracts folder within our packages. We have our package for hard hat and our package for next.

js. If you want to imagine it in a simple simple terms, our hard hat package is going to do all of the our simulated onchain stuff and our real onchain stuff and our next.js is include some hooks to work with those and allow us to have a a working front end. So this is the contract we've deployed. very simple little uh let's get rid of that for now.

Very simple little uh little little contract. Uh it's got some functions here that we can interact with and we'll we'll we'll do that in a second. So our contracts are deployed. Let's go back to our chains and see if they actually you know if they did deploy. So as you can see before it was here.

Now we've deployed our contracts. We've actually managed to see some changes. New block height. Fantastic. Worked.

So now we have our contracts deployed. How do we interact with them? We want to we want to get this front end up and we want to work with our Nex.js package. So let's follow the readme as it goes.

So third terminal. So we have this is our chains that we've got spun up already. We want to keep that going and we can just do it in this terminal because it's not doing anything at the moment. Let's Yeah. Yes.

Let's copy our EMV file from CD into NextJ into packages packages CD and let's go into Nex.js and let's copy that example into a new EMV. And you'll see that we now have an EMV file. Fantastic. There's um you know a basic config there.

We don't need to worry about that for now. readme. So, let's start up our front end in that same terminal. As I said, it's not doing anything. Let's start our front end.

And it's ready. Our front end, it was that quick. Let's go view it. So, let's spin up a local host. You see it's compiling here.

So, our chains are still on with our deployed contracts. Our front end's now compiling. The first time you do this, it will take a little bit of time. Perfect. Great.

Okay. Yeah. Um, ignore the index DB at the moment. You may not see that error because that probably fixed. Okay.

So, we're in our front end. Let's um go to our Let me just make this a bit bigger. You'll see a debug contracts tab here. Let's go to debug. And again, you're going to have to compile that page.

And great, what do we have? We have our contract deployed. And we have our our greeting build on Kadana as we can see within our contract. Now, as you say, as I say, this is just a scaffold. So, this is all going to be changed, right?

This is this is a contract that it's going to be your DAP and your front end can be edited at will. Um, if I were you, I would give your IDE AI agent of choice some context in terms of your packages. So, I would give it the hard hat context. I would give it the next.js pack uh package text and then you'll be able to deploy, you know, edit at will, get a nice sexy front end spun up, get some cool contracts done, but that's for down the line.

So, yeah. So, we can see we got a counter there for our greetings. We can see it's got a withdraw function blah blah blah blah blah. Great. So, let's let's actually interact with it.

How are we going to interact with this uh with the with this with our browser based wallet. So, let's connect our wallet. I'm going to connect it here. And as we can see, it's given us uh a little uh might be a met mask error there. It will ask you to connect.

Right, it I've I've already added local host chain zero. I'll just intersperse this with a little tutorial so you can actually see how to add local host locost to your metam mask without editing your network um within here because I know Metam Mask have changed it. So, let's actually go ahead and and interact with this this contract, right? So, let's start a new greeting. There we go.

Let's give it some value. Blah blah blah. Let's actually send that message message. As you can see, we're we're interacting with the uh local host and we're going to have to pay it a little bit of KDA in order to do it. Transaction complete.

That was very fast. We should see something on here. Yeah, we see some activity here. Welcome to the hackathon set a greeting. Fantastic.

Now, if we want to, we can check the address the the counter. We can read that public variable there because it has a has a built-in getter. Bang. Result one. Perfect.

So we're actually now interacting with our contract you you know within the front end which is which is absolutely fantastic. Okay. So we played around on localhost and we've edited our contract however we want. We've edited our front end however we want. And now we're ready to take this DAP to a test net environment.

So let's go back to our readme. We'll just do it from here for now. and we'll run these um yeah we'll run out against the test net chain. So first of all we'll go back to cursor and we'll look into our packages. So now we actually actually have to edit a few environmental variables and when you're dealing if you're an experienced developer with with smart contracts and deploying on chain you'll know it's really really really important to keep your private key safe and certain other variables like your API keys etc.

So in our hard hat package, we have an example EMV here. Um really the one we're not going to need this alchemy API key for today. So you'll just need um to change this private key. As you can see, this is the actual this is the private key that we've been working with on local host. So we're going to change this now and keep make our own.

First of all, let's uh copy this. So let's follow the readme. So first of all, let's copy this EMV example. Yep. Great.

So we just copied the So we have some variables we can we can change in here. Now this is quite important. What I've actually done is funded the deterministic address that we use for hard hat account one on both chains. I've funded it with test net KDA on our test net chains. Now, when you get round to this, who knows?

These this KDA may be used up. It may um have been taken away by someone. And obviously, if you're deploying your own contracts, you're going to want control of that private key and control of your own contracts. But if you did just want to test and deploy something onto testn net really quick just to make sure you you're doing it right or you want to just test out the network then you can actually leave this private key as is. I mean I wouldn't recommend it.

But if you're just trying to prototype as quick as possible, you could. So for the purpose of this tutorial, I'm actually not going to change this private key. But when you're doing it for real, put in your private key there and don't show anyone. Now that's the EMV we change within the hard hat package. There is another EMV we need to change within our front end next.

js package. So the front end actually points to our test net chains. So as you can see we're in the next.js package within our packages folder and we've navigated down to the EMV file. Now we can see that this variable here is true and it's pointing us to use local host.

So, what we'll actually like to do is to change that to false. Save. Make sure you save that. And you might be able to see here we've just had a reload on our front end just as we did it. So, what does that mean?

Let's have a little look at our front end. Let's go back over to it. Oh, and now it's saying run network just like we had before when we were trying to add local host. So, let's click it this time. Ah, now it's given us a couple more options.

It's given us the option to add all of the container test nets. So, we're going to go straight over to test net chain 20. It will ask you to approve and add that if you haven't added it before. I already have it. And as I said, I' I've funded this already.

So, if you don't change that uh in that private key within the hard hat EMV, then this you'll get the same. I'll fund it a little bit more as we go on. And hopefully you can use this. But as I say, if you're deploying your own contracts and you need control over them with ownership, then you won't be using this. But yeah, we we're on we're actually on test net chain 20.

So let's have a little look at the debug contracts and we've seen no contracts. So why have we seen no contracts? That's because we've already deployed our contracts, but only to our local host. This is still running now. We actually don't need this running anymore because we're not even connected to it.

So we can actually get rid of that now. But we have no contracts. So we what we need to do is deploy our contracts actually on testn net. So our last command we used to deploy our contracts was deploy local host. So yarn deploy local host which is already set up for you.

So that's going to deploy those contracts within your contracts folder on to localhost when you've got your chains running. Now we'd like to actually deploy those contracts on testn net. So what command do we use? We use this new command yarn deploy test net. So where are we?

We're in hard hat. So let's actually CD out of this to our root. And now we're going to deploy on test net. Let's see what happens. Switching using the private key generating some typings for these.

And what this is actually doing is it's verifying your contracts onchain as well. So we'll have a little look shortly on the block explorer, but this is all built in. You don't need to worry about it. When your contracts are deployed, they will be verified and you'll be able to see them in human readable form on the block explorer. Now, we're doing a couple of things here, so this could take a little bit of time.

And we're working with not just one chain, as you may be used to with these frameworks. We're working with five at once. So everything takes a little bit longer to work with all five chains. And we're done. So let's go over to our front.

Oh, I was already on the debug debug page. So if you run the debug page, you'll see it. But it no longer says no contracts found. It actually shows us the contract where it was deployed, the deterministic address. Fantastic.

And we've got a new greeting. Hello from testnet. So we're actually all set up with a front end that points to test net. We're connected. We have some balance.

So we can actually interact with that contract on chain. So let's set a new greeting. Let's go. We are live. Let's give it some value and let's try and see if we can actually deploy something or make a transaction on test net.

Oh, question local. Yeah, cool. So, we've sent a transaction now. Let's have a little look. Set greeting and we're working with the with chain 20 in this case.

a little bit of time and we're done. Transaction done. So, we've actually in real time changed the state on testn net set the greeting and if we want this should work. We can have a little look at the activity on the hard testing. We can click it.

Should be able to view this on our block explorer too. Great. And look what we can look what we can see. We can see all the details for this. We can see the transaction hash.

We can see what what we called. So let's have a little look at the contract we interacted with. Right. Okay. So this is the contract we actually deployed.

And as I said, we've already verified this contract. And look, this is the contract that we have in our contracts folder within hard. So all this will match up and this will be your contract. So already verified. You don't need to do anything.

And that's it. Thank you for watching wherever you're watching from either at the hackathon or YouTube or ETH global site. Um I'll put some links on the screen right now just in case there's no no links within the description of YouTube or the ETH global page is no longer available. I'll actually put a QR code as well just to a developer portal page where we have information about our grant program and developer advocate programs etc etc. [Music]