Austin Griffith I Beginners Track Welcome & Speedrun Ethereum Introduction I ETHGlobal Prague 2025

[Music] We're already live. Oh, hello world. Hearts, hearts, hearts. Okay. I am Austin Griffith.

Uh, I, uh, represent the Build Guild DAO and we are a collection of builders and teachers and curriculum writers and tool builders. I think maybe I said that already. Welcome to ETH Global Prague. Uh in this room is going to be three hours of content starting with beginner, then intermediate, and then advanced. Uh in this first hour, we're going to just look at the tools.

Uh get a look around at how to put your first contract out on Maine and uh how to get started learning. Uh in the second hour, we're going to do things like overcolateralized lending and prediction markets, which are um you know, where product market fit is now. And then in that last hour, we're going to have uh introduction to our capture the flag and our advanced security. And then maybe we'll play a little game where we can uh I don't know, maybe win some some money on chain or something like that. We're not real sure yet.

I'm going to have to vibe code it in the next hour or two. Okay, so let's get started. Uh, buildg guild is biddg.com. Kind of hard to find and type, but come find us at biddgiddle.

com. Uh, we we are developers, toolbuilders. We're always traveling around giving these kinds of workshops. Uh, and our main uh, piece of curriculum is speedrun Ethereum. So, if you go to speedrunthereum.

com, it starts really easy with like simple NFTTS and staking examples, but it gets a lot harder, and we'll get into that later. All of our curriculum, all of our tools, everything we build uh is built with Scaffold ETH2. It's sort of our tool of choice and it's great for rapid application prototyping. you can quickly build an app with your backend, your foundry or hard hat and your front end uh Nex.js and all those things are wired together.

Uh we even have really catered to the LLM. All of our documentation is in an LLM's full and you'll see here pretty soon that there's a really nice cursor rules that comes along with scaffold ETH. So even the non-coders in the room get excited because you can pull up scaffold ETH and cursor and yell at it and it will build you an onchain app and in a year it's going to be better than I am at building. So all of this is about to get very accessible to anyone who wants to vibe code apps. Uh we'll be doing a little less vibe coding and a little like hands-on and showing some code but those days are are numbered I think.

Okay. So, I think the goal here is to show you how to get your first few apps on chain. And uh we're going to use scaffold ETH 2 to do that. So, I'm going to copy this first command. It's mpx create ETH.

And I'm going to jump over here and paste it in. And I don't even know. We'll just call it first app, right? We're just going to make some quick little app. Uh you have the choice here with hard hat and foundry.

Um, I would say that uh the cracked advanced devs are using Foundry because they like to test their smart contracts in Solidity. Uh, I think app builders actually prefer hard hat still because you're writing your tests in JavaScript. You can test it in both languages, but hard hat still um the favorite of some builders. So, don't count hard hat out. Both of these are great and it's op it's awesome that our ecosystem has such good optionality.

I'm probably just going to randomly pick hard hat. It could be either one. Uh it doesn't really matter. So all we've done here is just go to scaffold e.io and we've copied this command.

Uh the docs are there and the GitHub is there and you can just kind of follow the the instructions right in the repo. It kind of gives you everything you need to go you need to do to get started this MPX create ETH and then we're going to run a chain. We're going to deploy and we're going to run a front end. I'll do all of that over here when this thing gets ready. Okay.

Uh CD into first. What do we call it? Frog. I kind of like that. Whatever that was.

Let's go see what frog is. Okay. And uh it says I need to run a few commands here. Yarn chain, yarn deploy, and yarn start. So let's do the chain first.

So what this is going to do is spin up a local blockchain. Whether you're using hard hat or foundry, we just have this simple command called yarn chain and that spins up a local blockchain. Then we're going to yarn start and that's going to spin up our local web server. So now we have a blockchain and a web server and they're kind of talking to each other. And let's get a look at what stock scaffold ETH looks like out of the box.

Wait, come back here. You pull that down. Bring it over here. Here we go. So, we're loading up localhost 3000 to get our first look at Scaffold ETH.

Here it is. The Scaffold ETH team is right here in the front row. So, if you have any Scaffold ETH questions, feel free to ask them uh at any time. We'll be around for the next three hours. So, hit us up.

Uh there's some interesting things that you get with Scaffold ETH out of the box. You'll notice this has this nice ENS avatar, a lot of components. Um, but also there are burner wallets. So, check this dude right here. This is a burner wallet.

It's basically a private key and local storage. Woo, that sounds scary. Why the heck would you have a private key in local storage? It's only for development. You're only using it locally.

Uh, you're only going to have fake money on it. Uh, so what it does though is it makes it really easy to make transactions. So you can just click click click and make transactions. It also makes it really easy for watch this. I'll make another one here.

I just created an incognito window. Oops, wrong thing here. It makes it really easy for testing, right? I was able to create notice like this is pink and purple guy and this is kind of like teal and pink guy. What it what it allows me to do is create all sorts of characters to play the game, right?

Like maybe I have a smart contract that only the owner can edit. Uh maybe this guy's the owner. I would test it by having him edit it and then having this guy edit it and make sure it fails. Right? So, you can create these accounts.

You can fund them with the faucet and you can just click click click make transactions which is a wonderful experience for tinkering. And that's the first thing we're going to do here. And this debug contracts tab is really the the magic zone for that. So, no contracts are deployed yet, but we've got burner wallets. We've got a debug.

Uh let's get in and deploy our uh first contract to our local blockchain. So if I do a yarn deploy with no other commands, it's going to put this template. Scaffold ETH comes with this nice template smart contract. It's going to yolo it all the way to our local chain. And then we get this nice interface.

So that that smart contract is a greeter smart contract. Let's go look at it. So I'm going to use cursor, but you could use code or any other whatever your IDE of choice is. And you'll notice that when you get in here and start looking at your code, there's those two packages, right? There's either hard hat or foundry, kind of your orchestration and deployment layer, and then there's Nex.

js, kind of your front-end layer. For now, let's dink around with that smart contract. Okay, so here it is. And uh it has a whole bunch of data types that you're probably used to. If you're a coder, you can kind of look at solidity and figure it out pretty quickly.

Um the best way in my mind to learn solidity is solidity by example. You can basically just go if you're a coder, you can go look at a bunch of examples and you can figure out how smart contracts store and and execute on information. For instance, like go learn a mapping and go figure out why you would use a mapping. And as soon as you kind of like see this code, you kind of see like, oh, this is a mapping from an address to a 256, which is an unsigned integer with 256 bits. But basically, this is a mapping from some address to some number or bas or said differently, any given address has a number associated to their address.

So, if you wanted to keep track of like a counter for each person, a mapping might be a good way to do that and you kind of just need to get into Solidity by example and click around and figure out the structure. Uh oh. Figure out the structure of Solidity uh as you go. Uh if if you're using Scaffold ETH, it has this really nice thing where let's just pull my map in here. You can kind of copy and paste that code and put it like right in here and hit save.

And then we can redeploy our contract. And what we'll see is this new my map show up over here. In just a minute, we're going to see our contract hot reload. There we go. There's the my map, right?

And it takes in some address and it's going to give us some number. I'll bet you it's zero. Okay, cool. So, this is kind of your interface to your contract. As you're tinkering and learning how to build uh solidity, you're kind of adding some things to your smart contract.

you're deploying and then you're jumping over here and tinkering with it, right? Let's just make like a uh something really uh let's see. U let's uh yeah, u 256. Boy, I don't code very much anymore. I usually just prompt uh uh the AI to do it, but let's just call this a dumb counter.

And we're going to start it at 41 for some reason. Okay. And then let's make a function that lets us ink the counter, right? And hopefully this thing just figures. Oh, it should have just like Oh, there we go.

Dumb counter plus one. Oh, decrement, too. Sure, sure, sure, sure. You know what? Yeah, I'm down.

Okay. And deploy. Right. So, this quick loop here where we're tinkering with Solidity, we're adding a few things, and then we're redeploying our contract to And now we can see that we've got this dumb counter here. And if we go over here, making sure we have money at the faucet.

Don't forget that cuz you'll get some errors if you don't have any gas. But once you do, you should be able to just come over here and let's increment our counter to 42. Boom. Right. Nice fast click.

No metam mask popups. None of no chain ID. Right. Right now, what we want to do is just test and understand how Solidity works and how our contract is working. And this lets you have that just tight dev loop.

And I you can click click click click click and you see that dumb counter going down. So this is I think like the very first step where you just kind of add some things to your smart contract and you tinker around and um that's that's basically the art of tinkering. I think maybe I'll give one more shout out to how to tinker. If we pick out some other concept here let's go if you look at solidity by example it has so many great uh examples. These are just basic syntax here, but if you keep scrolling, they have a bunch of uh application examples, a bunch of hacks, right?

You should learn all these hacks as you're building out. Uh and then even uh some DeFi stuff, right? Like what if we wanted to do a unis swap v2 swap? That's pretty rad, right? It's kind of has all the constants in here.

It looks like we're swapping from like we to die or something like that. Yep. And it shows you how to do the swap. So you can just kind of copy and paste this stuff right into scaffold eth or you could even use remix light. Watch this.

If I click this, it's going to kind of bring this stuff up in the browser. And this is uh from a friend at the build guild who has been building this. But here's your code right in a browser, right? We didn't even have to bring down scaffold ether or anything. But if you wanted to tinker with this real quick, you could pull that down from Solidity by example, deploy it to a lo local team instance, TEVM, I think, and then we could dink around with swapping if we wanted.

So that's all right in the browser without even having to have scaffold ETH. And that's down here at the bottom of Solidity by example. But this is really the gateway for tinkering with Solidity and getting your first contracts built. Uh Solidity by example, go check it out. It works great in combination with something like Scaffold ETH or Remix Light where you can just make some changes to your code and tinker with it.

Okay, so let's put a contract out on mainet, right? Let's do something. Let's build something. I think the the goal of this session is your first three apps on chain and so let's make something. Uh if if we're going to maybe the delegate is a good thing, right?

Let's uh let's say uh let me redeploy the contract. Let's see what we have first. This let's redeploy this kind of stock contract. It's kind of a greeter. I don't know if it's that important.

Uh but when you set a greeting, so if we set the greeting to hello world, it's going to like keep track of that greeting, right? But uh this is also if we look at the smart contract, this is a payable function. So it means people can pay into set the greeting. And it looks like if you set the greeting, we set some arbitrary premium flag to true. You can see how you could code up anything you really want here.

But let's test how this works. So it looks like we could send in uh maybe like, you know, 0.001 ETH. And here's another interesting concept that you're going to run into as you get into Ethereum, and that is uh decimals. and the fact that the EVM doesn't deal with decimals.

So you have to kind of multiply everything by 10 the 18 on the way in and then you kind of divide by 10 the 18 on the way out and that gives us like a fake decimal system. That's just one of those gotchas that you encounter when you're building on chain. But here we go. We're going to say hello world, but we're going to pay some money. And some interesting things are going to happen here.

As I send this in, we see the greeting, right? But we also see premium now flagged to true. But then something else really interesting here. There's money in the contract. Right now there's 26 cents in there.

Let's go a little bigger. Right. It's it's free. Let's So hello world three. Right.

Let's put a bunch of money in there. There we go. So now as this reloads, we should see Oh, did I not pay any money? Let's try that again. Hello world.

Let's do 0.1. That should be more money. Send that in. There we go.

We're watching for this to increment. There we go. Now there's more money in there. $262. That's much better.

Okay. So, let's pretend like we have this greeting contract. We have people paying into the greeting contract. Let's say we want to do like some artist royalties or something like that, right? Artist royalties on chain are are a a hot subject.

Let's maybe um come up with an address here, public, and we'll call call it the artist, right? And then maybe there's some function to set the artist. And if you're if you're, you know, looking at this, there's no modifiers added here. And a modifier kind of helps you add some things to the code, like checking to make sure that there's like an owner that sets this, right? And I'm not really thinking I want to set the owner.

I think I'm just going to let anyone set the artist. This is like insecure. You don't want to do that. Like if I just deploy a contract out there and I'm paying royalties to an artist, but anyone can set the artist, then people will be setting it to their address all the time. Uh but this is good for a good fun practice here to set the artist.

And then maybe we do something like uh like pay royalties, right? Sure. Whatever that is. And let's see, this would be something where I don't want it to be payable. I actually want the maybe this is withdraw royalties.

Okay. And what I want is for the artist to be able to withdraw the money from the contract. So we're going to make sure that the message sender is the artist and then we're going to send what I want to send is the uh balance, right? So it' be Yeah, there we go. Thank you.

Oh, I don't remember this anymore. I haven't written any code for a while. There we go. So, pretty pretty quick little function there that's going to say, "Hey, if you're clicking this button, we're going to make sure that you are the artist, but if you are the artist, we're going to send you the balance of the contract." So, let's go test it real quick, right?

Let's just go ahead and deploy that locally and let's test a few things, right? Let's make sure the artist can withdraw the money, but let's make sure like a bad guy can't withdraw the money. Okay, just like we were talking about earlier. Oh, we're going to need to set the artist up, too, right? Let's go ahead and create an incognito window and go to localhost.

And we'll use this address as our artist. Remember, this address is different than this one. Private key, local storage, all of that stuff I talked about earlier. But let's call this our artist. Here is our tortured artist with no money.

And they're wishing they can withdraw some royalties from this contract because they've made a beautiful piece of art and it's earned some some funding. And the artist would like to not be starving and have some food tonight. So, we need to maybe send some money in. Uh, hello artist. I love your work.

And here is a whole ETH. Yeah. Boom. Okay. Uh, wait.

Do I need to deploy? No. Okay. So, the ETH is in there. And now what we want is for just the artist to withdraw.

Oh, we haven't saved anything yet. What we need to do is set the artist. Okay. So, let's set the artist as this dude and we'll hit send. Notice that save is happening there.

Okay. So, now we've got an artist and we've got some money loaded up on our contract. We want that artist to be able to withdraw their funds. And uh my instinct is if I hit this withdraw button, the artist will Oh, withdraw royalties. Sorry, there's another withdraw function in the contract already.

Ignore that. We're gonna uh do this. It withdraw royalties. But first, I want to make sure that a bad guy can't withdraw the royalties. So, let's go to Oh, I guess this character.

We'll call this character could be our bad guy. Let's try doing a withdraw royalties as this guy. And it shouldn't work because the artist is this guy. And we have some code in here that says only the artist can withdraw. So, let's test it real quick before we put this thing all the way out on mainet.

And when I click this, it should say something like not the artist. Okay, cool. And let's go make sure that our tortured artist is able to withdraw. So, they have uh one ETH already, but they're about to get uh another ETH by just clicking this, I hope. And there we go.

Boom. It worked. Right. So, it checked to make sure that they were actually the artist and then it sent them the money. And now the artist has some money to go get dinner tonight.

uh good good to support local art and blockchain all at the same time. So we've tested our contract, we've built our first initial contract, we're able to write a little solidity. Uh what could we do in the front end, right? How could we get uh a front end to show up here? Well, if you go to the scaffold ETH docs, there is this interacting with your smart contract.

There's a use scaffold contract read. So that will read from the contract. And there's a use scaffold contract write that gives you this write async hook that lets you write to the contract. And basically you just use these two functions to communicate with your contract. So maybe we'll jump over to our front end now and write some simple little thing.

Who knows? Maybe we'll display the artist. Let's see. Let's get into our app and go to our page. Okay.

So, this is what are we going to call this? Uh, artist royalties. Great. Welcome to artist royalties. And, uh, maybe I'll clean out some other stuff here.

Who? Click too hard. Clean out some stuff here. And what we want to do is maybe have like a button. Uh, well, let's just hit save.

Let's see what it looks like first. Right. Okay. So, we've been spending all of our time over in the debug contracts and tinkering around. Now, it's time to jump over to the homepage and let's write some real front end, right?

So, we have welcome to artist royalties. It knows about who is connected here. And there's some hints there that we don't really need anymore. Let's take those out. There we go.

Okay. How's that look? There we go. Nice clean page. So, what I want to do is display the artist.

So, uh, if I were to do something like let's grab this and bring it down here and we'll say artist address. Okay. And that means we're going to need to read it from the contract, right? So, we'll go grab that read hook up here. Use scaffold contract read.

And we'll paste that in down here. And it already knows. Oh, I need to install this. Okay. Oh.

Oh, I put it in the wrong place. Man, I am letting AI just uh do everything for me these days. Okay, so use scaffold contract read. It's going to read your contract. And here's what's really nice.

As you're in here writing your code, you get these nice suggestions. It already knows about your smart contract. It knows all the values in your smart contract. And it can give us the artist. I didn't have to know any of that stuff.

I just kind of copy and pasted that from the docs and then selected it. And if we put that artist right there, now we have this variable in our front end that is tracked. And I'm going to get rid of these. They're kind of bugging me. I don't like those red lines.

Okay, cool. And if we go down here, we can just say artist right now. This is going to look pretty ugly, but let's go look at it. Oh, yeah. There we go.

Okay, so the artist address is displayed. Now, you might notice that is uh not the way you want to display addresses. What you want to do is wrap this in some kind of component that can make it at least look nice. If not ENS resolution, ENS avatar resolution and Scaval gives you that out of the box. If we do address address equals there we go.

Perfect. Thank you. And now look. Ah, doesn't that look so much nicer? Doesn't that look good?

So now we have uh our connected address. We have our artist address. Now let's let's write to it, right? Um, what kind of things could we write to? I think I've already lost my artist because I closed my window that had the artist private key in it.

But no worries, we'll just we'll do a quick write to the contract just to show these hooks. So, let's see. So, now I'm going to bring this in. This is the use contract, right? Okay.

Really really in the weeds here. Uh, this makes a a write contract async. And then we can come down here and grab this button here. and we'll paste it in here somewhere. Let's see.

Maybe right here. Okay. And maybe this is uh I don't know, withdraw royalties. I don't even know if I spelled it right. And what we're doing is we're doing a use contract async.

That's the thing that we brought in there. Okay. And we're going to call the function. What's the function name? Uh withdraw royalties.

Cool. And then we can pass in some arguments. I don't think we want any arguments. I don't think this is going to have any value. So we've just got the function that we're going to call.

Okay. Now we should have a button in our front end that lets us Oh, it's all the way over here. Okay. Uh center content center just Yeah. Yes.

Yes. Look at that. I just centered a div. It was so easy. AI is magic.

Okay. So, uh, this withdraw royalty should fail because we're not the artist. Yeah. Okay. But let's go set us as the artist in the debug just to do it real quick.

Okay. So, we're going to set us as the artist. Okay. And let's put a little money in there. Hey.

Hey, here's some money. 0.1. Okay. So, our contract is loaded up with money and we are the artist.

We can see that the connected address is the artist address and we have 4712. Oh, hey look, sorry, I didn't mean to click that, but this is a really cool thing to show off. As you're locally debugging, we have a whole block explorer built into scaffold ETH. Very nice. Okay, so we are connected as the artist.

There's uh, you know, $4,000 here. We should be able to withdraw royalties and we should see our money go up. And there we go. Okay, so we pulled down scaffold ETH, we tinkered with our smart contract. Maybe we used Solidity by example to help us out with some syntax.

Uh once we had our contract working the way we wanted it to, we started dinking around with our front end. Scaffold ETH comes with a whole bunch of handy components. There's that address component, but there's address input components and uh ether input components and all sorts of handy components that we've found at hackathons were needed. This is really our hackathon stack. This started as what do we need to build to be able to quickly ship apps at hackathons and this has really evolved into yes you can ship apps at hackathons but also you can ship production apps with scaffold eath also.

Uh but this should really help you get quickly something out into production or get a hackathon project finished. So we kind of have an app here. Now we would never show our users this debug contracts page probably. So, we'd probably do some cleaning up here. We'd probably make the front end a little bit better.

We'd do a little bit more, but we kind of have the basics here. We're we're reading from the contract. We're writing to the contract. Uh, these hooks are working pretty well. So, now it's time to deploy this thing to production.

We'd like to put this out on a real blockchain. So, what does that take? Well, there's going to be kind of like these two major steps. We're going to need to deploy the contract to some public network like an L2 or mainet and then we're going to need to deploy the the front end out to Verscell or to IPFS. So let's start with deploying the contract to a live network.

This yarn deploy command that we've been using before is here. But now there's this nice little flag you can add to it d- network and you can deploy to any network you want. Any EVM network is going to be here. Arbitum, Polygon, Optimism, any of those, even mainet you can do right here. This is going to fail for us because we don't have any money.

When when you want to deploy, you're going to need to generate a deployer account first. And we keep Patrick happy by encrypting our private key here. And then there we go. So, we just created a quick little deployer account. And we have the address for it.

And we're gonna send it a little bit of Am I on base already? Oh, I'm already on base. Perfect. We're gonna send it a little bit of bass. Okay.

And let's just do it in USD. How about like 50 cents just in case? Okay. So, we've created a deployer account. We've funded it with 50 cents of base.

And now we should be ready to yarn deploy-work base. And this should put our contract live on a live network that anyone can get to. Let's see what happens here. Boom. There's a there's a transaction ID and our contract is out on base.

You'll notice though that our app still thinks we're on hard hat. So, we need to do one quick change to the scaffold config to tell it to point to base now. Okay. Okay, so now it's out on base. Now watch this.

One quick save and our whole app is now uh live on base. So now I can't do burner wallets anymore. You really shouldn't do burner wallets uh on a real money network because that private key sitting in local storage is a little shaky. So it's going to have me like really connect my real wallet now. Okay.

And there we go. And our artist is set to zeros. Uh, but let's get in here and set our artist maybe to Vitalic real quick. Okay. And when I hit send here, I'm going to actually talk to the real contract, right?

I'm going to pay some real money now. And it's going to pop up. And it's going to say, "Hey, you're going to pay a penny here." But now, Vitalic should be our artist. And we should see that right there.

Okay. And then if we had some money in here, Vitalic could get in here and click withdraw royalties. I don't think he's probably hurting for ETH. He's probably got plenty. So, he probably won't do that.

Uh, but the app is basically ready. Uh, in terms of the smart contract and let's let's go look. Um, actually, I want to verify the contract. We deployed the contract, right? But I want to do a yarn verify.

This is one extra nice little thing. What it's going to do is it's going to take my source code and it's going to go to the block explorer and it's going to say, "Hey, for this bite code of this contract, here's the source code." And if you compile it, you'll get that same bite code. So now it's verified. So if I go look at the contract, so I'm just going to click this address here, since we put the app on base, everything switches over to base and it starts using base scan.

Okay, so our contract is live on base and it's here in the block explorer and everyone can see it and you can even go to the contract tab and look at the code of the contract. So this is super important. The verifiability of this contract is really important for users. You really shouldn't use an unverified contract. You really shouldn't put money into that.

Okay, so here is our front page. We're live on base. Our contract is verified. Now the last step is this front end is still on localhost. So what we need to do is a yarn versel.

Okay, yolo prod. And what that does is push our app to versel. And this will take a while to do. So we'll move on and we'll look at some other stuff. But once this is done, we're going to have a URL here that is a production URL that your friends can go to and you'll they'll be able to uh get artist royalties, I guess.

You know what? Whatever you end up building into your contract, you basically have an app ready to go. So, that was like not long. That was like probably 30 minutes. We were able to build the smart contract, build the front end, ship the smart contest it kind of ship the smart contract live on a live network, any live EVM network.

And now we're probably going to wait. The longest wait we'll have the whole time is waiting for Nex.js to ship the app. Uh while we're there, we can kind of talk about an alternative. Instead of deploying this to Versell or along with deploying this to Verscell, you could do a yarn IPFS.

And what that's going to do is take your front end and push it out to IPFS. And then you can incentivize your friends to pin that. And then all of a sudden your front end is this like hella distributed thing that anybody can get to. And your smart contract lives on a decentralized network. So it is going to be up forever and be tamperproof and all of that good stuff.

We get like composability from open source and blockchain. So that's it. That's basically the the kernel of everything we're going to do here. We we have scaffold ETH and we're able to quickly rapidly prototype these apps, tinker around with them, get them right, and get them deployed and get them in the hands of your users or, you know, a hackathon judge, right? Like of course your contract is probably going to be a little bit more advanced, your front end is probably going to be a little bit more uh mature, but really like within 30 minutes I've got an app that I can show a judge.

And judges love a good demo, right? Instead of a presentation with some slides when you can say my app is live at your app.xyz and you you know we're minutes away from that. That is a very powerful demonstration for the judges. And Scaffold ETH is a great way to get you there quickly.

So, while that app is finishing, uh, I'm going to bounce back over to our curriculum and start talking about, okay, sure, you know how to use Scaffold ETH. You know how to tinker with Solidity and build a few little things. What the heck do you build? You really do need to build a few things. You need to build a handful of apps to really get the aha moments of like what the heck actually works on blockchain and why would we need this expensive database to to give us this kind of credibly neutral always on kind of thing.

Well, there's a few things that you might build. One of the things that had early product market fit is NFTTS. NFTs are very simple. I I think if we take one step back and say tokens, ERC20 tokens, you can send those to people uh just those are fungeable. So five of those and five of those mixed together makes 10 and there's no difference between the two.

That's a fungeible asset. NFTts are nonfgeable tokens. Uh they're fun little collectibles that you can mint here. You don't have to write any code for this first quest and they'll teach you how to mint your uh first NFTts. uh but this one is probably one of the best first steps and that is uh building a staking app and I don't mean staking like validating staking I mean staking like we don't trust each other and we need some kind of coordination mechanism okay so imagine uh a handful of people want to purchase some asset let's say let's say we want to buy a house let's say that everyone in this room we want to buy a house together Okay.

But also, everyone in this room hates each other. Okay. And we don't trust each other. And we know that if if we wanted to buy a house, I could just coordinate it, right? Everybody here gives me 10 grand and I go buy the house.

But you guys don't trust me and I'm a bad guy. And if all you guys give me 10 grand, you're never going to see me again. I'm going to be out on a on an island somewhere or something, right? So what you need is some kind of mechanism, some kind of system that allows for people that don't trust each other to coordinate. And that's one of the great superpowers of Ethereum.

So this staking app is basically a bunch of people locking money up and if you get enough people together, the rules say you go on to buy the house or something. But an important element here is that you don't want people to get their money locked up or you don't want to be able to grief someone, right? If Shiv locks his money up and then I figure out how to like doss the whole system and then Shiv's money is locked forever, that's really bad. You don't want that property in your system. So, uh, the the way you might write this is, and you'll you'll get in and you can write this staking app, but it basically has some timestamp in the future and it says everybody can stake some amount.

There's some threshold where we call it a success. Basically, the price of the house. Let's say the price of the house is $200,000. We say anybody can stake. If we get to $200,000 by this timestamp, we call that a success.

and anyone can poke the contract to go buy the house with the 200,000. Uh but if we don't if it doesn't work, we need to be able to get our money back, right? And that's really important. You can kind of think of this like a state machine and we're in the staking state right now. And then after the time passes, there's a one transaction that happens that moves us into a success state where we go buy the house or a withdraw state where we were we were we weren't able to coordinate.

You can see how adversarial players can stake their money and if we get enough, we can buy it. But if we don't get enough, you're going to need to be able to withdraw. So, if we're in the withdraw period and you've staked money, we have to keep track of what everybody staked and let them withdraw the money. But this is it. This this is how you would play this coordination game.

And maybe it doesn't make sense for all of us. We kind of trust each other. Maybe I have enough reputation that you guys trust me. But once it scales out to the internet, trust does not scale, right? And and this is a kind of uh coordination mechanism that can help that trust scale.

So really the people that should be playing these coordination games are probably going to be large organizations, governments, and nation states. If Ethereum is successful in its vision, you can imagine multiple nation states staking their military budget on some kind of peace time. And if they don't do what they're supposed to do, there's some kind of Supreme Court multi-IG that can burn people's stake or uh distribute the stake to the the good players. So if if we get to where we want to go, it's not just us buying a house, but it's nation states coordinating for peace. Okay.

Now that we have nation states coordinating, let's talk about shitcoins. So, a token vendor is the next challenge that you'll take on. What you'll do is you'll mint a coin and then you'll mint a vendor. So, you have a second contract that holds your coins and then you have some price function that anybody can get into your vending machine and pay some amount of money and get some coins back. And it sounds pretty simple on the surface, but actually the ERC20 has this interesting approve pattern where you don't just like walk up to the machine and put your coin in.

You do this weird thing where you walk up to the machine and you tell your coin that the machine's able to take it and then you hit a button on the machine and the machine goes and gets the coin and brings it in. It's a strange pattern to get your your mind around and this challenge is meant to help you understand how that that pattern works, but this is really easy if you wanted to be, you know, take part in the ICO craze of 2017. This is all the code you would need to understand. And it's only challenge two of the speedrun and we have many more challenges to go on to randomness. On a public deterministic blockchain, randomness is particularly tricky because you can kind of see everything on chain, right?

And a lot of people like to use the previous block hash, which the block hash is a nice piece of entropy, but there are ways to game it. And in the dice game, what you do is actually create a contract that only rolls the dice if it's going to win because your contract can figure out what the previous block hash was right in that instance and only roll the dice if it's going to win. But this what this does is it kind of unlocks the ability to start thinking about actually using good randomness on chain and how commit reveal or VRF or some other randow things can help you get a good form of randomness and how you can start thinking about building onchain games. I think one of the most exciting areas for me as all these L2s come out is onchain gaming or even like kind of the cross-section of like DeFi and gaming. And I I'm really excited to see what people come up with in this next year as you know smart contract wallets, account abstraction, all of that and L2s come together.

It seems like we're getting to the point where mainstream audiences could start playing these things. Kind of in the past, self- custody was very hard. Self- custody is about to be very easy. People will be able to go to your app on their phone. They'll be able to use their fingerprint to create a wallet, use their fingerprint to sign a transaction, and they'll be able to do all this onchain cool stuff really easily.

Okay. Now, the the kind of final boss of level one is building a DEX. Now, a dex is uh to me it's just a beautifully elegant solution. Um back in the day, if you wanted to trade uh you would need to find a counterparty. Okay, so I don't even know what these are.

That looks like ETH and that looks like gold coins. Let's say you have uh three gold coins and you would like to trade them for one ETH. uh you would take your three gold coins and you would sign a message that says I'll give my three gold coins for someone that has some ETH and then there was what was called an order book and this order book was on a centralized database somewhere even though these signatures are cryptographically backed there's a central point of failure and we don't want any central points of failure in decentralization so while order books were handy the invention of the AMM the automated market maker uh really was the this really nice thing. And let me let me just provide an analogy for what uh a DEX is. If we think about out uh in the hallway kind of um a candy machine.

Let's imagine a candy machine, a vending machine out in the hall. Uh you know, you go there, you put in your dollar and you get some candy. Let's say this is kind of a weird machine where you can actually swap candy back for dollars for some reason. doesn't the the analogy doesn't completely work, but imagine that you could either put in a dollar or put in some candy and then get the opposite side of that, right? The way this works is unis swap or anyone who builds a deck.

They're basically building the hardware. They're building the machine, right? But they're not stocking the machine. That's a second person. That's a second player in this game or a second set of players.

So Uniswap comes along and they build the vending machine and they put it out in the hall. But what they do is they create these very clever rules. So they know that to make these swaps work, they need reserves of both sides. We need a whole bunch of candy and we need a whole bunch of cash and we need both of those things to live in the machine. And then if you think of kind of like a balance here, if someone comes along and puts some candy in, you need to balance that thing out by taking some ETH out or other way around.

Someone comes in and puts a bunch of cash or ETH and that that goes this way, right? Then we need to take some candy out, right? So anyone can walk up to this machine, put in either candy or ETH and get the other out. Uh but anyone can also provide liquidity, right? So the vending machine exists out in the hall and any of us can bring in both candy and cash and put them in the machine and as people trade between those two things we earn a fee.

We earn money by providing that liquidity. So this is called expansive. It's an expansive hyper structure. Boop boop boop boop boop boop boop. But it's expansive in that we need more liquidity and to incentivize that liquidity, we pay fees to whoever provided the liquidity.

So what happens here is the hardware is there, the rules are all written. Anyone can provide liquidity and they're going to earn fees on that liquidity. And the more liquidity is there, the better the swap is for the end user. And you're kind of seeing this thing now as like this almost like a public good. It's like a magic public machine, right?

A magic public vending machine where all the rules are written correctly. So both the LPs and the swappers are uh you know they have the best time with more reserves. But this is the kind of thing that you can build with a smart contract. And this is really like what unlocked a lot of things with DeFi summer and all of that stuff is once we had tokens, once we could swap onchain in a truly decentralized way without any central point of failure or um someone being able to take that down and censor it, then a whole bunch of other things exploded and liquidity tokens and all sorts of things happened. But you'll learn this DEX and it uses this thing called a constant product to figure out the price.

I want you to get in and look at the code. I'm not going to spoil it too much. We have a very simplified decks here. But by the end of this challenge, it should only take you maybe an hour or two to go through this challenge, maybe longer, but by this end of the challenge, you can basically build your own decks. And that we take out slippage.

There's some other things that you'll have to learn beyond that, but this is really the final boss of level one. You should know how to build a deck. And uh shilling the build guild for a little bit. Once you finish this on speedrun Ethereum, we're going to be waiting for you. Is Philip in here?

Philip is going to run the batch program and we have Telegram groups and every couple of weeks we take everybody that has finished the decks and we put them into these onboarding batches and we give you some ETH and we teach you how to do PRs and we uh kind of are trying to curate a little community of trying to help you take your next steps and either get hired somewhere or uh found your own product or uh anything in between. But we do have some harder challenges and we're going to get into that probably in the next 15 minutes. I think Kevin Jones is going to go next with overcolateralized lending. Okay. Stable Oh, you're going to go straight to stablecoin.

Okay, cool. Okay, so in the tech tree of Ethereum, you have uh Okay, let's let's start from the other end. Let's say product market fit. Stable coins have product market fit. There are many countries in the world where inflation is a big problem.

Uh even when I deal with onchain apps, if I have, you know, $10 of Ethereum uh when I go to bed and then when I wake up it's $12 or $6, that's kind of jarring and hard, right? And that's why stable coins are really interesting. And I think that stable coin micro payments, L2s, something here is is really going to take off with mainstream audiences. But a stable coin just uses some economic mechanisms to keep that coin stable. And you'll learn that in a little bit from Kevin Jones.

But what you need for stable coins is basically lending. What you need for lending is oracles. And you'll learn all of these steps along the way going through speedrun Ethereum. And then to go even deeper beyond the stable coins, we'll look at prediction markets. I think after Kevin Jones goes, we'll go to Philip and Philip will run us through how prediction markets work.

There's kind of a red car and a green car and they're going to be racing and you can buy yes tokens or no tokens and it it's basically deploying two meme coins with the promise to rug one for the other one eventually, which is a fun way to think about it. But speedrun Ethereum takes you all the way to layer twos, multi-IGs, and we even have like a ZK hello world coming up soon. So hopefully this tells you how to build your first app, how to tinker, how to get that thing out there. Uh the last thing I want to do is maybe spend the last 12 Oh, wait. Is our app up?

Let's go see if our app finally got deployed just to do it. Boop. There we go. There's our app. It's actually at a live URL.

So Vitalic could come in here and get his dollar or whatever we put in here. Uh we're we're not going to worry about that and assume that's not going to happen. Uh the last thing I want to show is vibe coding. So this is where it starts to get really interesting and really accessible for folks. But what I want to do is build uh same thing we just did here where we created this app.

But what I want to do is build uh I don't I don't even know maybe some quick I heard someone say bond markets earlier. Let's see if let's see if I can build a bond market in 11 minutes. I I won't be able to, of course, but uh let's see. So, we're going to MPX install uh Bond. Bondi, I like that.

Okay, Bond. Right. So, we're going to do the same thing. We're going to create a new project with Scaffold ETH called Bond. Uh as that fires up, I'm going to CD in.

And I'm going to open cursor again just like we did before. But this time, I'm not looking at code. I'm not looking at documentation. I'm not doing all the things that you probably should do as a builder. I'm going straight to this agent.

Now, the Scaffold ETH team has done something amazing. They've created this cursor rules file. So, they have this intricate knowledge of how to use Scaffold ETH, which brings together both your contract orchestration and your front end. There's no other project that brings those two together. And early in the days of Scaffold ETH when we were using it for hackathons, a lot of people didn't really like frameworks.

They'd like libraries because they like to have this nice thin I understand everything about my stack. But as we move into the world of AI and AI doing a lot of the building, I think frameworks are going to make a huge comeback because a framework is basically like a template for how to do everything. And an LLM loves a good template. like an LLM can see an example and understand everything about it rather than just a bunch of documentation. So what should we build here?

So I am going to tell this thing I'm not going to provide any context. I'm going to assume that scaffold ETH has this out of the box. All I've done so far is pull down scaffold ETH. Okay. So, I'd like to make a bond that lets people buy up um buy a total of 10 bonds.

Okay, I'm totally making this up. I've never done this before. I mean, I do this a lot with vibe coding, but I've never made a bond market before. Uh the initial price is 0.01 0 1 ETH and then they have have to keep that locked for instead of like one year we're going to say one minute and then they can withdraw it for 0.

011. Okay, that's basically a bond market. There's a lot of details in there that you probably would want to supply, but I'm not going to. I'm just going to let this thing kind of figure it out from here. This probably won't work.

You You usually want to kind of like try some things and figure out a nice descriptive way to oneshot something, but you do not have to be a developer anymore. You can just pull down scaffold ETH. You want to kind of know this concepts. Maybe you could vibe code through uh speedrun Ethereum so you know the concepts. But at this point, if you have a really good tool and a really good AI model, put that thing on agent mode.

Put that thing on YOLO and just describe what you want to build. Look at that. It's building our bond contract now. Now, about two years ago, what's happening right here would like be worth like a six-figure salary, right? Like now, we have Cloud 4.

0 that is just going to hopefully yolo this thing for us. But let's go look at it. Uh, actually, let me close down all this stuff. So we can not have these guys competing. Okay.

Okay. Oh, look. Our bond market contract is done. Right. So there's a bond price, there's a bond payout, there's a lock duration, there's max bonds.

We could look at the code, but I don't really want to. Okay. So what's it going to do here? Let's keep track of what else is it doing. Looks like it's working on the front end now.

What' you say? Deploy script. Oh. Oh, it's working on the deploy script. Okay.

Yep. Okay. So, it wrote the contract. Come on through. Come on through.

Yeah. Come on through. All good. I'm not I'm not even touching the keyboard here. It's just working.

So, it wrote our bond contract with the constraints that we wanted. It's writing a deploy file now to make sure that thing deploys. It maybe is writing a test file. It's going to test our bonds for us, too. Great.

Great tests. Cool. I'm so glad. And then this is going to write the front end also, right? Scaffold ETH knows about the front end.

Scaffold ETH knows about the contract. So, you know, I should have said don't write any tests, please. That would have sped this up. Like, hey, I'm on a I'm on a tight budget for time here. Please don't run any tests.

Uh uh uh I almost kind of want to stop it and tell it to I don't know. Let's see what it does here. Oh, it's fixing llinter errors. That's fine. But we don't have a front end yet, right?

Let me let me fire things up. You still need to know your yarn commands. I don't know how we're going to abstract that, but we will. Uh let's see. So, we have yarn chain, right?

That builds us a chain. We have yarn start and that gives us our front end. And then when our contract is ready, we'll yarn deploy. But let's see where we are here. Still fixing.

Oh, it's running the tests. Let's see how our uh how we did. Did our tests pass? Okay, I think we're happy. Excellent.

All the tests are passing, you guys. Okay, now it's trying to run chain. Now, it's time to stop it. Bad boy. Quit it.

Okay, we can we have the chain running ourselves already, I think. And that might have even killed the current chain. Let's see. Yarn compile. Does our our total vibecoded contract compile?

Uh yarn deploy. I don't think we should go all the way to base without even testing it, but let's try it locally first. Hey, our contract deployed. And it even gave us some nice output there. How about that?

All right, what do we have for a front end? Is there anything? Did it give us a front end? Let's see. Waiting for the front end to come.

Oh, there it is. Nope, there's no front end. I think we kind of wanted like a maybe can we have a can a homie get a buy a bond front end button please? Cool. So, normally that would have done that.

I obviously like my prompt was terrible, right? Uh being able to deal with LLMs, you should know that you need a very descriptive, very clear prompt. I did a very bad job of that. I kind of was like drunk driving a little bit there and just like if I need a bond market without a lot of the details that it needs. I think in the future this agent mode will prompt you a few more times like hey are you sure you want to do that?

What about this? But hopefully what we want there we go bond interface. That's good. So hopefully what we get is some kind of bond interface here where we can uh buy the bond and then we could watch for a minute to go by and then sell the bond back and earn our 0001 profit. Okay, any questions as we close out?

Uh Kevin will take over and do a stable coin next with all of these same stacks. Yes, sir. a portfolio for apps that have been built on Scaffold ETH. Um, if you get into the build guild, you'll start to discover some of these. I think our extensions page might be the best place to look for what you're looking for.

So, if you go to scaffolde.io/extensions, it's like a whole bunch of starter kits on top of the starter kit. So if you're looking to do subgraph or you know 712 or a ponder indexer my favorite uh is onchain kit coming from the the base team. What you can do here is with onchain kit it comes with a swap component. So like in we were in the Tokyo lobby when this first came out and I was so excited I I ran this command right here and seriously in 10 minutes I had a swap like freaking unis swap and a token.

So I selected the token and I swapped to the token all onchain like in the app. So these extensions will get you dangerously close to having a product. Um there are a bunch of apps that are built with scaffold ETH. You can find them like build guild and around. One good example while we're here is AI Ninja.

AI Ninja just gives you a a automatic interface to any smart contract. For instance, if you put the contract address in here, it'll figure it out. I'm just going to click on die here and I'm going to go check Vitalix's balance of die real quick. So balance of and it has all the cool things that scaffold ETH has like this nice uh address component. And if we say what is Vitalix die?

Wow. 17K. No 317K. Yo yo V. I hope that's not a hot wallet.

Okay, let's see how's our front end look. Uh, let's see. Maybe a reload over here. I noticed it was at a route, right? It was at some route.

I hope it Oh, slashb. Oh, maybe it built it in or gave me a link. Nope. Don't deploy, P, please. All right, stop that.

Stop that. Okay, let's just go to slashbonds. For some reason, it didn't put the front end. Oops. Bonds.

There we go. Here's our bond market. Look at that. We just made a DeFi like two minutes. Okay.

And let's see. Wrong network. We'll need to switch back to hard hat. And then I'm going to go ahead and grab some money from the faucet. So, I have exactly one ETH right now.

Oh, wait. It's not going to be able to pay me the extra money because there's not money in the contract, right? The money, the contract actually needs money in it to be able to pay. And that's not going to work. Uh, let's see.

I could yolo some funds to the contract maybe. Oh, yeah. Just give it Yeah, let's go to the faucet and just put an extra ETH in there. There we go. Perfect.

Wait, why does it have money in it already? Maybe they tested or something. Oh, yeah. It was It was smart enough to know that. Okay.

So, let's go buy a bond. We're going to go buy a bond. So, we have exactly one ETH. Let's pay attention to that. We're going to buy a bond.

Okay. Sure. Okay. Now, I think we need to wait one minute, right? Okay.

There's a little bit of a trick here where you uh the the time stamp is not going to increment. So, we'll have to wait for this to countdown and then I'll have to make another transaction to create a a new block which makes a new time stamp. So, a little tweaky thing here, but we basically just have to sit here for one minute and then uh I'll increment it and hopefully make my bond money back. Any more questions though? Oh yeah.

Over there. It starts at an entirely new um but you can do yarn fork and you can fork an existing chain too. You'll have to get into your hard hat or foundry and set what you're forking. I think it forks mainet by default. So if you just type yarn fork, it's just going to fork mainet.

But if you wanted to fork base or something else, you'd need to get in there and tweak it. But it's starting its own chain. But you can also fork another chain. So yarn chain starts your own chain. Yarn fork forks an existing chain.

One of the main things to look out for when it Oh boy. Okay. So it it just went off the rails there for a little bit and it started doing like too much and I give it full control. I'm like please sir, RMRF all you want. Right.

So So I I've given it too much control. Uh, but you need to watch for it to go off the rails because it'll start doing stuff that doesn't make sense and it'll get in a loop and doing that too much. But I think like this this is a moving target where in the next version maybe that doesn't happen but there's something new. So it's almost like you kind of just have to play with it and figure out, you know, where where you're comfortable and where you're not comfortable. I think uh big numbers are another thing.

It has a hard what I was talking about earlier about the EVM not doing decimals and we have like this 10 to the 18 10 the 18. A lot of times an LLM will have an off by 10 the 18 problem where it's saying one but it needs to be 1* 10 the 18. So that's one other thing to check. Other questions here. Yeah.

So the you know you said you're going to need to uh submit and execute another transaction. So the block time I just did. Yep. That's only for this test. That's on local host.

Yeah, it's just on local host. Normally in the real world, yes, we'd be ready to redeem. Okay, what do you guys think that this redeem is going to work? What are the odds? Let's see if we can redeem and make some money here on our bond.

We did, right? Wait, why do we have two? I think I hit the Oh, I hit the faucet there. So, I gained But basically, by buying that bond, we earned 0.00008 ETH and it was able to build that bond with all the correct rules.

Now, be careful. Don't put a million dollars in it, right? Like we just yoloed that pretty quickly. But hopefully this gives you an idea of how accessible it is to build onchain apps and how quick you can prototype and dink around. And you can do that with scaffold ETH and then you can build a bunch of things with speedrun Ethereum.

And in this room for the next two hours, we're going to go even deeper on some of the coolest concepts starting with stable coins with Kevin Jones. Thank you. [Music]