Casper Smart India Hackathon 2022 | Casper Workshop, 26 Sep 2022

Previous Meeting

Next Meeting

⏯

youtube image

►

From YouTube: Smart India Hackathon - Workshop #2 pt. 1 - Build a Fundraiser Contract

Description

In part 1 of the second workshop as part of the Smart India Hackathon, Rust developer Karan Dhareshwar presents a tutorial on how to build out a fundraiser contract that accepts donations and records the accounts that donated. He also gives an overview of writing and executing smart contract tests before deployment.

0:00 Introduction
0:50 Agenda
2:22 Overview of Fundraising Contract
3:20 Contents of a Contract Project Directory
7:19 Writing the Donation Entrypoint
12:10 Handling Errors
16:05 Writing Init Entrypoint
19:22 Count Donations by Account
26:47 URef Source Definition
29:42 Writing the Call Function
37:18 Contract Recap
37:39 Testing Example
39:14 Casper Documentation Overview
40:45 Debugging Failed Tests
51:20 Conclusion

Missed the first workshop? Find it here: https://youtu.be/9UvsgpXQVpk

A

So hi everyone and welcome to Casper's second Workshop as part of the smart India hackathon today we'll be showing you how to execute nft transfers. Query the balance of owner up and total number of nfts minted. Then we'll build out a front-end application to interact with our nft logic, but before we do that, uh Quran is going to take us through and show us the details on building smart contracts on Casper, so Quran. Take it away.

B

Hello, guys um yeah, so um my name is Quran uh I'm OK I'm, a software developer here at Casper, Labs um I've, been writing smart contracts on the Casper platform for about two years now, um or something close about um so today. Basically, what I would like to show um and what you guys through is the process of writing a smart contract, what it means to write a smart contract and some basic fundamentals around smart contracts.

B

That way uh when you look at the nft code, when you start building the front end around the nft and start interacting with the entry points of the contract or basically what we call the entry points are the functions of the contract. um You understand what's going on underneath the hood, um so with that said, I'm going to do now um is share my screen um and we're basic.

B

This is a contract that I previously written we're going to basically repeat a lot of this code, um but to show you what we're doing right now is we're going to have a contract um that has a purse over it's a this is a fundraiser contract.

B

Essentially, so what we're going to do is write an entry point that manages a purse, allows you to donate to that first, and this contract will basically keep a track of which account on the Casper network is donating, how much or how many times they've donated uh to this fundraiser contract. So to begin with, let me just walk uh everyone through how to start writing a contract. So um we provide this utility called cargo Casper cargo Casper, which allows you to basically set up your project.

B

It will automate the setup of the process of setting up your project directory, so I'm going to call my project donation or, let's go. Let's call it yeah, let's call it fundraiser, okay um and so we'll now open it in my IDE a.

B

Yes, there we go okay, this is okay, cool, okay, clean project. So when you run cargo Castle, what you'll see is you'll find two uh subdirectories one is the contact. um This is the con. This is the Smart contract. uh This is the folder.

B

Where we'll be writing this one contract um and this tests are tests that we will write to ensure that the workings of our contract are the way we expect them to to ensure that maybe um you know that'll help, help eliminate bugs and basically mention sure that the contract functions in a way that we expect it to you'll, see that this attaches just something much running through. Okay, so you'll see that the cargo tunnel, which is basically your dependencies and your manifests for this project, already comes kind of pre-written for you.

B

So it's already imported the two most fundamental libraries that you need to import. One is the Casper contract and the other is the Casper types. um The Casper contract is basically the API. You need to write a smart contract because, and then the typescript over here basically lets you access the types that are specific uh to the um test for platform I'm going to have to update my uh everyone can see my screen right, I hope uh just sound off. If.

A

B

Cool thank you. uh We just need to update the tool chain, which is what we're going to do first. So let's do that first I'm just going to go into another project of mine and copy the tool chain from there, so yeah and then we're.

C

Just going to paste.

B

This here makes life a little simpler now: okay, Friday, okay, so so now this this name dot RS, is um where we're going to write our smart contract um you'll see again that it's come pre-filled with a Hello, World type uh logic um we're going to get rid of most of this. So, let's just start by doing some cleanup over here.

B

um These errors are there, but we'll get to those later as well. You can see it's got some basic Imports for us as well.

B

um So let's start with lines, one and two we'll go from the top down, so you'll see that we've asserted these two flags want to say no stood and the other is saying no me. So what is the no stood um for those most of you may notice, um but a lot of the code that we use and we use on our normal. You know on our normal local, desktops or PCS, or laptops um help and use the standard Library.

B

um This is because an operating system has that Library so code that runs on our you know on our normal computers and actually use the standard library now the cause um on the castle platform. We have a pseudo trade, complete execution engine, or rather a virtual machine. um You don't get the standard Library. The standard Library won't be available to you.

B

So if you type to compile without this no Stitch flag and started running the code in a Casper execution, virtual machine you'll see that the code actually won't run because it requires this candid Library so because we are going to be operating in an environment in a runtime environment that doesn't provide the standard Library. We're using this nose to um another thing is the no main again.

B

This is something that you see in a lot of like just binary code right, there's, always like the main function, which we use as like the primary like entry point to the code. um Again, we're not going to be using that we're actually going to be writing our own, which is called call here, so we're basically telling the compiler yeah. We know that there's no main function, um but that's by Design.

B

We want it to be like that and again you can see we need to explicitly import the stood out of crate and the Alex string as we're in a notification environment, which is why we're using this Okay cool. So with that said, we're just going to start writing the code. To begin with, so, like I said, we want to write a function that will accept token and will act as a way for people to donate as part of the fundraising project. So we're going to start with this hash, no mango um this will come.

B

This will be like the first thing you write in term uh on top of any entry point that you write and I'll come to the keywords as the moment: I'm done. Writing them that okay! So what is this snow? Mangle flag mean um the no mango flag is basically telling the compiler that at the time of compilation, because this rust code that we're writing right now will eventually be compiled to pause.

B

um If we didn't provide the snow mango flag, atop our function, the compiler can take liberties with how it wants to represent the name of this function within the Watson byte code. So it can change it into something that may not be human breedable. Now the way the uh oh, my God, what is up with my mouse today, um the way um smart contract execution works is first you actually have to install the smart contract and Define the functions within the smart contract. So as part of installing the smart contract, what happens?

B

Is parts of the blossom are actually extracted out, and so this no mango flag. It ensures that this donate word within the like this donate human, readable donate is preserved within the wasm bytecode and it doesn't get mangled essentially that way when we install the smart contract, the installer of the smart contract, or rather the virtual machine that installs a smart contract on the Casper platform, knows what part of the was on bytecode to look at. So it looks at oh there's. This human readable string called donate within this wasn't bytecode.

B

This is the laws that I need to extract for this particular function within the smart contract um by the way, if anyone has questions as I'm going through this, please feel free to ask them um so in case there are questions, please feel free to ask okay.

B

Okay. So how do we write this? So we want to take in a accounts key that way we know who is donating to us. So what we're going to first say is: okay, let donating account.

B

um To accept arguments from the runtime we provide this thing called runtime get named org, so I'm going to call okay, okay right and now we can specify um a name for a runtime argument, which is what I'm going to do now and I'm going to call this say account or, let's call it donating account.

B

Let's just call it account. It would be easier once on the other side of the teams. Okay- and this is going to be a type key- a key is basically an identifier and there are multiple different types of keys. So if you can step into the definition of channel.

C

B

Okay, I'm just going to show you guys the actual source code itself. So here let me go to this.

B

So this is what I meant earlier when I said key, so you can see that there's this notion of a key here called account right. So uh the way the Casper blockchain works is um there's like a shared database right. It's like this huge database, which is essentially what we call Global state. So any data that you write as far as executing your smart contracts, and this could be things like nfts or something like that- must be stored underneath some key.

B

So all accounts are stored, underneath the key account like so each account has this account key. So all accounts are stored, underneath the account key there's another one for hash, which could be a smart.

A

B

um A URF which I'll get to later so essentially, what we're trying to say is: okay, there's going to be an account key that comes in and we're going to try and accept that account key whoops. Okay going back here all right. So then this is a donating account, key okay, and so basically, what we're going to say is we're going to check the first off that the team we received is actually an account. So let's do that! So if let- and this is Rusk syntax, this isn't anything um specific to our platform.

B

But this is how you can do something like this in.

A

B

Essentially, because a key can be one of say, eight different things right: we only care about the one out of the eight cases, so this is a way to just focus on the one case equals donating account, key okay, and so what we're going to do here is we're going to fetch it a purse which we haven't created yet so what we're going to say here is to do return purse here right, um but otherwise, if it's not a um key that we expect we're actually going to throw an error so first, for that we're going to actually have to write our own error.

B

So let's do that now. It's hub in um error.

C

B

And so basically, what this error over here that I'm writing now are basically our custom error codes.

B

um That way, also by the way if people are asking, please feel free to unmute and ask because I can't see chats if people are asking questions in chat I would rather you unmute and ask um the questions, because I can't read the chat as I'm going through this process. Okay, so what we're going to do is we're going to say um so we're going to create our first custom user error invalid key variant, I'm going to call this zero right and, as we add, more errors, this number Micro.

B

So um you know if you look at one of our NST contracts, which I can show you here um and if I go to the contract here, Source name error: you can see if we have close to some 106 errors here right.

B

um So what this allows us to essentially do um with these errors is basically when the contract fails. It'll return, a specific error code that has meaning to us so that one, the execution of the contract fails. If it does fail, we know exactly why it failed right. So if I go back to my code here, if I get the custom user error, zero I know that the invalid key varying for space right.

B

So then I can like kind of be very Surgical and very precise and know exactly where in my code, um that era was raised. Okay, moving on okay, so we have now have our.

C

B

That we wrote so what we're going to do is we're basically going to say runtime there is this function called revert over here. That, basically, um is like a panic of sorts.

B

um Basically, it's going to say: okay, stop the execution and roll back any kind of modifications you made through Global State, essentially so we're going to revert with the error error invalid key vary! That's what we're going to do here, okay, so cool! So for now, we've got the basics of our donate functions, ready we've we're missing a purse, so we need to actually create a first now there's many ways you can create a first, um but because of course, is something that handles token and token you know has a monetary value.

B

We have to be very careful about how we manage versus um purses are restricted to something called access rights, and so the access rights are taken from something called the name keys, so name keys are found on two objects within the Casper system.

B

Essentially so there's this account over here, so an account is something you know represents me or you, and so you can see that there's this account structure here and you can see that it has its name Keys here, name keys are basically um and if you can actually just step into it, you can see that they're, basically a mapping of a string name to a key, and the key is the same key. We were looking at earlier, okay, um and so what happens is at the time of execution.

B

These name keys are looked up and the access rights, essentially do you have access to this first is based on whether or not the purse, which is a type of view ref, which you can see here. You can see that it's actually, this main first is actually called a URF, so we're going to basically check if the UF is within this name keys. Now we wanted to be within the contracts name key. So what we're going to do is within an entry point, we're going to call something called we're going to make another entry point.

B

So again, I have to write the new mango flag over here, basically again reminding the compiler to not change the name of this function when it compiles it to possible. So we're going to call it init, and this will kind of like act as like a way for our contract to initialize things right, so we're first going to do. What we're going to do is we're going to make that donation. First, we're going to call it donation first, okay, which is essentially a URF and we're going to.

B

Do create first, okay, um and what will this? What this will do is it will create a purse for us now. What we need to do is persist it to our, or rather this contracts named key. So that way, the next time around, when the contract needs to either transfer out of this donation first or send this donation first, because somebody else could transfer into it has the access rights to do that. Essentially, it has the permissions to do that, so we're going to persist it to our name keys by using something called putkey.

B

So what we're going to do is we're going to call runtime foot key like this and we're going to call this donation right, because this is the donation first and we're just going to convert this into a key. If you just dot into that's more than enough.

B

Okay, um any questions so far we can take a break. I know, I've been I've, given a lot of information there, um but if anyone has any questions again feel free to pause. Now.

B

I had said at the start of this that we want to be able to track how many times a single person has donated to this contract, not the amount that they donated just how many times, they've basically called this function here to donate to the contract. So for that, we want something like a map right like this account to these many types.

B

um So for that we provide a capability called dictionary, so we're going to create a dictionary.

B

um The word dictionates is the same as it is in the where those uh the same in pythons, pythons or python also has its notion of dictionaries, but they operate in subtly different ways, so don't think they're equivalent, even though they have the same name anyways. So what I'm going to do is I'm going to first uh create the dictionary, so we're going to use the storage function or the storage part of the contract API and we're basically going to write new dictionary and we're going to call this new dictionary.

B

The Ledger sure like this, like this okay, so now what this will do is this will create this init function right, which is like kind of like the initializer for our contract. Well, basically,.

C

B

A purse it will persist the first that way the contract has permanent access to this first and we're also going to create a new dictionary titled the letter that way um as part of donations to this contract. We can track how many donations were made by how many accounts okay.

B

So now we can come back here so now that we have the first right. So let's do this. So what we'll do is we're going to say as part of just donating, we're just going to update the amount of donations you may there is a bit of a flaw in the logic, but for now, for the purposes of this demonstration, don't worry about it too much.

B

um So, basically, what we're going to do is we're going to say. Okay, this is a account because we're only accepting donations from accounts currently right. We could actually extend this model to accept donations from under contracts as well, but for now we're going to just focus on accepting donations from accounts.

B

um So what we're going to say is okay, um we're going to update the um number of donations. This account is made. So what we're going to say is: um let number off donations right, equals storage dictionary get okay. This dictionary get function basically lets us retrieve um the um well. You know it's like we're just going to get the value underneath in this dictionary, so we're going to say key account right and just give me one. Second I need to make sure that I'm getting what's wrong.

B

Right: aha, okay,.

B

I'm just going to copy this function for the sake of time all this function does is it basically looks up the dictionary value and then just updates it um as it needs to that's what we're going to do as you look at it sort of says: okay get me the cgrf get me the dictionary.

B

um If there was no value, then you know, this is a first-time donation, so just put the value one, because this is their first time donating um in the sum case. Okay they've donated previously so then updated by calling dictionary put and then updating the current number of donations plus one. That's essentially what we're doing here: okay, okay, so then we can use that function here. So instead of this we're just going to say.

B

Update letter of record and what we're going to say is.

B

Just making sure that I have described again.

B

What we're going to say is two string because, as you can see, this function over here takes in string value. So basically, when we do, we can look at the API of this as well. Can I.

B

Reach there we go so this is the same function, so you can see it takes in the seed URF, which is basically the access lock around the dictionary itself, and then you can see it takes in an item key, which is of the type stir um we look at dictionary get you can see, it takes in another seed, the same seed, URF, um and then it takes in an item key. So whatever is underneath that and keep.

C

B

Value stored under dictionary item key in the dictionary access by the dictionary see here, essentially, okay, so going back to our code that we're writing right now, it's a dictionary. Cdref we've got the item key okay, so all of that more or less.

C

B

So then, we've done the update of the dictionary server, updating, The.

A

Ledger record, as.

B

We go and as we continue to proceed so what we're going to do now is we're going to return the purse so that the person calling this donate function gets a person they can transfer to okay. So now what we're going to do is you're going to say runtime direct, which is basically the return function, um and first we need the first. Let's go get the first first, so let donating cars right, which is a? U ref, as we can see, equals run time get key this time around right because there we did putkey.

B

Now we just need to get the value underneath that key okay and we're going to say uh donation, because that's what how we saved it now, this I, don't think is I.

C

Don't like how my IDE is.

B

Not working around.

B

Okay, this is so strange, though: okay, fair enough, we'll just have to work through the errors when we get to them. Okay, so this get key. So we can just keep looking at the source code essentially to see if we're on the right track or not so we're going to look at.

B

Okay, so this gives us an option of key, so we need and remember that a key could also be a URF. So what we're going to do is we're going to basically turn the option of the key and try to turn it into the us if we can't turn it in the into a URF we're basically going to error out essentially so this chart gives us an option for Q, so we're going to say unwrap or revert width.

B

So this lets us revert with a very specific error, and so what we're going to say is we're going to say missing. Donation UF equals one. So that way, if we see you know a user error one, we know why that's happening it's because this, because we we don't have a handle on this, get key. So when this get key returns, something it returned actually nothing.

B

It returned the none um which means that this step was never called, which basically means that the contract is in the state that it can't essentially recover from which is bad. um So we're going to return with error, missing donation, URF right. So now it's a key I'm going to turn this into.

B

Right and this will give us our donation for zeroth donating first now, if you look at a Europe right and if we step into what a URF is defined as over here you'll see that it has this address, which is the address of the UF and certain access rights. Now an access rights is one of three things. So there's obviously there's no permissions. There's the read, write and add right. So what it means is, if you have a URF with read permissions. Basically all you can do is read the value underneath that URL.

B

If you have a uterus with right permissions, it means that you can write under the like. Essentially, you can modify the value of the URF. If you have ad permissions that you can add to the value underneath the Europe right, and so then you can start building any kind of combination.

B

So you have read, add, read, write, add, write and then all the permissions, which is read that right now the problem is, if we just gave away this purse as we're currently doing, we would be giving it away with read, add and write privileges, which is a problem, because what it means is once we gave this first away like as far as this one-time return call over here, we're actually giving it away with the right access like the w-r-I-t-e access rights alongside it, which means a person accepting this purse would get those right access with with them, which means they could modify the value underneath this first as they wanted to, which means say that you know a lot of people who were nice, people donated, and then they risk say um you know like a hundred dollars worth or like um like a thousand rupees worth or some value in terms of like actual money right.

B

If they have the right access on this first, they could actually like drain. The person themselves, essentially they'd, be able to steal all the money underneath this first, which we want to prevent. So how do we prevent that? Well, we know that we only want people to add or like donate, in fact, which is a very addictive process. So we only want people to be able to add to this person we're just going to say into which basically means this person we're giving it.

B

You only get the ad permissions alongside this first so that way they can only add to the person they can't essentially subtract from. It is the point here: um okay, so that's more or less um how you know so, we've got our two uh functions set up here. They'll do what we want. They'll, probably be a few errors here which we'll probably have to sort through, but now we actually um so this part of the like the code or more accurately, this part of the code is essentially what forms the smart contract right.

B

We've got kind of like the meat of the smart contract, or rather the skeleton right now we just need to kind of like create an installer for it. So that way, when we compile it to wasm, send it to the network, um we can actually install the contract and then use it later on right. So that's what this call function will do it'll act as the installer for our smart contract Okay.

B

So if so, for the let's just start by looking at how we create a contract right so let's say let underscore equals storage new contract. Believe it's in your contract.

B

It is in search Okay, so let's look at this function and see what it says: create a new contract stored at Key hash at version one you.

C

B

Upgrade this contract in the future. If you want to contact that stock, I.E cannot be upgraded, called new, lock contact instead, um and then you can see it talks about the various arguments that it means. If name keys are provided, we will apply them if hash is provided, we will put the contract hash in the current contact. Current contacts, name keys and the same thing with the view ref name, but you can see it takes these things called entry points right so recall at the start.

B

Right I was talking about um why we need this new mango flag, it's essentially to prevent this name donate, and this name in it from changing once a compilation takes place. Well, that's because we need to define the entry points here. um So let me just Define the first empty point, which is the init entry point, so I'm just going to call this in knit mg point.

B

Point continue: yeah, okay and so we're going to give it this. And if you look at the again, because my IDE.

A

B

B

Okay right, so look we look at the Constructor for this, so it takes in a name it takes in certain, like whatever arguments we need to provide it. What does it return the type of access and the basically the entry point type right um so for hours. First, entry point that we call init we're going to give it the name in France in it over a share like this.

B

So this is the key.

C

B

This is kind of like ties it all together, because we've defined an init entry point with the name in it. What happens is as part of installing this contract it'll look at this string here and go ah in it I'm supposed to look in the wasm byte code for something called init, so it'll look at the wasn't bytecode for this and see okay. This is caught in it. This is the wasn't related for this init entry point. Basically, what happens is as part of installing a contract.

B

We create a like a table of entry points name to the wall Zoom to be called, so it wasn't to be executed for each of those entry points, and so this is the mapping that we're doing so, the name to the wasm itself.

B

um It also takes in a set of parameters, but the cars are in init. Entry point actually doesn't take any runtime arguments like unlike art, donation entry point, which does we don't need to provide any um parameters here. It doesn't return anything here either. So you know our return type will be known or unit in the case of rust. So we're going to say CL type unit like that, and then um we have to now Define the type of entry point. It is I believe that's what it is. Chicken entry point access.

B

Okay, so we need the access and yeah so we're going to keep these as public and then entry point type is.

B

B

Just give me one second, um for the sake of getting things right, I'm just going to copy.

B

Okay, so that's one entry point that we write now because we have a second function here: we're going to write another function, so we're going to create another entry point. So we're going to call it donate entry point, and this follows essentially the same process.

B

So I'm going to say, entry point, new, um donate right and then this time we're going to change things around, because this thing takes in a key we're going to pass in parameter new, um the name which is account and then the type of it so CL type see because you're expecting this over here so say: you're expecting something like say a public key like this. um We would change this to be public key uh like that. But you know because it's key we're going to make it.

B

Okay, then um we do actually return something here, so we're gonna have to change the return type, so we're going to say CL type of uref, because we're returning approach, which is of the Type U ref, um and then the remainder of the two are essentially the same cool all right. So now we just have to say let fund fundraiser and three points is entry points in.

C

B

This has to be mutable because we're going to actually modify this value right and so then we're going.

A

To do fundraiser.

B

And we're going to say, add entry point the first game to find which is init over here like this and then another one entry point two donating okay, very cool, so now we've more or less finished. This is like the last few bits. So now we need the fundraiser. This gives us the fund Razer contract cash, which is the primary identifier for this contract and then we'll get a fundraiser contract version as well, and then what we're going to do is we're going to give it the fundraiser entry points and what were the other onions?

B

Let's go back here. Of course it's okay! We can just look at this here like this okay, so it takes in the hash name: keys. Well, we're not giving it any name key is here, so we can put this as none and then we want to say some string.

B

B

Fun razor track: okay and.

A

B

Some string from.

B

B

And that's essentially it. This is how we would you know, write a smart contract. um We could then compile this to wasm and then send it to the chain, and then you know see if it worked or not. We could also write tasks, however, um because this particular IDE mine isn't working what I will do just to show you um just to kind of demonstrate for demonstration purposes. I'll just walk you guys to show you what a test would look like right. This is this should be able to install and donate.

B

So again, the contract is very similar here as well right, so we're creating the contact with some entry points. There are two additional entry points here, but again it really doesn't matter, then we've written some other bits of code and then we've basically written a test here to actually execute this and I'll. Show you how it looks like because there's only one test here so if I write make.

A

B

Right this will now run.

B

um This should then it'll take some time, um but it will compile the wasum and then actually run the Watson in the same way that there wasn't would run if you were actually deploying this to a Casper blockchain, and you know we were executing it there, so whatever bugs would have occurred or any runtime errors would have occurred if there were bugs in the contract. The same bug should ideally appear here, and this test should fail.

B

So if this contract is working correctly here, then our tests will pass, and then we would know that our contract, if we deployed it to the Casper chain, would also work in a way that we expected it to that's the beauty of writing tests um because we're a little bit short in time. I wouldn't be able to get get into writing tests today, but what I will show you guys before um I hand it back over to Dylan is our documentation over here, so this contract that I wrote is actually described in Developers.

B

Sure um so, if you go here and use, write, look at a basic smart contract in Rusk you'll see that it is essentially the same contract. And if this document is basically what I I was kind of sped through a lot of things in the short amount of time that I had. um But it the same document talks about the discuss that I was talking about earlier.

B

um But in a lot more detail.

C

B

You can see that we have a full-fledged documentation about how to write on-chain code, the various types of one chain code- again, a lot of us I couldn't get into today, um but please feel free to read this documentation. If you have any issues- or there are things that you're unclear on, um please raise an issue on Casper Network.

B

Yeah, so if you see anything wrong with our documentation or you would like to add to our documentation, please feel free to come here to the issues page and then um raise a ticket here.

B

um Then we will, you know we will triage it, see um and then try to work on it essentially um and right now, my okay, my code is almost get back to the Finish compiling, so let's just give it another. Second, almost there.

B

Oh whoops, it didn't work so, let's see why it didn't work missing argument too. Okay, so.

C

Very interesting, let's.

B

Let's see this will be a nice exercise, so contract installation request. That's fine.

B

Okay, so let's see so it says the missing argument. So basically, what this uh error means is. We were supposed to give it a runtime argument. It didn't get that runtime argument. So now it's complaining at us saying: hey I, expected this one-time argument that wasn't provided to me um so clearly.

C

B

Has gone wrong so let's stop for a second and seemed rare. It could have gone wrong so funds raised. So let's look at this funds phrase because I think that's the one with the missing.

C

C

C

B

Maybe let's look at contracts themselves, maybe we're missing something here: there's one parameter for get donation count. There's one parameter for donate risk is completely empty.

B

This is interesting. Okay, so, let's go to here again. So, let's see, if we're making sure that we're sending everything yep donating account, key donation amount uh-huh. So this is the purse that we got back. So this is the and then you can see that we're doing another transfer over here so we're you know this is how we can donate to the fundraiser contract. Essentially.

C

B

But yeah the test isn't working.

B

B

I believe it's this, it is.

B

Right, so this init function was actually expecting a runtime argument that wasn't needed, um which was causing the test to fill. So if we recompile this, it's still failed excellent, but is it the same error missing argument? ah Wait I, believe I need to do for me, build.

B

B

And it still felt interesting.

B

Let's see systems like first, this was fine.

B

huh Interesting um yeah: let's see you should be able to actually debug this I. Don't know why it's taking so.

C

C

B

First, what we can do to debuff what exactly is failing, we'll start commenting bits out until we see which execution is actually failing. So what we can do is we can go up to here right because that's the where the first request is happening. So now all we're trying to do is to see if we can just install the contract by itself right. So, let's see if we can just install the contract first.

B

Okay, so that part worked so let's start now adding things back and see exactly which part of the code is doing. Okay, so the contact has so now we're making we're going to make a donation request and see if that donation request works. Okay, so let's do that again.

B

ah Okay, so is this missing argument too? Okay? So it's on the donation bit! Okay! So now, let's look at the so we're sending three Arts here to this donation code here. So, let's see if it's getting three arcs if we sent named Arc named okay, so this part looks good and then entry point donate okay, and so let's look at the Donate entry point on the actual contract which is over here. Sorry, okay, so donate it's a donating account key. So maybe we got the name wrong could be.

B

Sometimes you should, even if you get the name wrong that will still um because it's it's looking in a buffer. It's like it's looking in a map of string names to names to actual value. So even if we got the name wrong here, um but we still provided the correct runtime argument, it would still actually fail. So it's worth checking to see if our donate donating account key. Okay, that looks correct on this side.

B

Let's look at donate over here, donating a camp key as well and see as you can see, it has like this thing, donating County to the actual value itself. So if we got this wrong- and this correct, it could still actually um still fail. Essentially um is the point: okay, okay, and so let's look at the entry point definition. Maybe sometimes you can see that over here.

C

C

B

Okay, so the arc seem to be here as well.

B

Let's go back to the test, maybe we missed something in the test. So, let's see, let's help default account. Address session file is donation, sure which is this file over here, and it expected the foundation contract hash, which is a type key. We expected that donating in county and I expected the donation of the map. Okay, let's look at the test again, make sure we've gotten everything right here, so we're giving it the contact.

B

uh I believe this might be the issue because they're sending in a contract cache- and it's expect thing a kite of key. So maybe this is what's going wrong. Okay, so let's just change that bit of coach. This is contract hash. What we're going to say is: let oopsies let contact e, so type key equals contractcash dot. Youtube I'm just going to make this much change.

B

Okay, now, let's see if this works.

B

Oh, it still doesn't work interesting.

B

Aha, ah okay, here see, it's I think it's the same issue here so in our test. I believe this is Andreas okay. So if we made a mistake here of not getting this, this oh no wait. This is the wrong one. Sorry donate sure you can see that this actually fundraiser key. So this is the same point. This is this is the point I was making earlier because we got the name wrong.

B

um It couldn't find the particular runtime argument, so it was like well, whatever you sent to me, I found the things you sent to me, but they weren't what I was looking for, so we're just going to change the string value and see if it still errors out.

B

Okay, let's try it again.

B

C

It still feels interesting.

B

I'm arguing to.

B

C

B

Now, let's look at this so here.

B

B

Okay, so I can, for the life of me figure.

C

B

Happening Here.

C

Donation amount.

A

C

The contract case over here.

B

This is fine screen.rs again, let's just try and make sure that we've got all of our bearings correctly. So this says fundraiser key and this says donating account key and then this is amount, ah so this says amount but.

C

B

We're providing it here in the test is donation amounts. Let's change this to just amount here like that. Now, let's see if this works terminal tests.

B

Foreign, so I'm going to stop pushing my left and pause there, um but that's essentially the basics and thankfully there were errors. So that way, you got to see how the test framework works, or at least how you can go around debugging your tests to make sure that they're working the way that you expect it to right, um but that's a small, deep dive into our testing framework.

B

I guess, um but that's essentially it for me: I'm going to hand it back over to Dylan at this point um so that he can take you guys through building a front tank over the nft and then interacting with the nfg contract as well. That's already done! Thank you.