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

Previous Meeting

⏯

youtube image

►

From YouTube: Smart India Hackathon Workshop #2 pt. 2 - CEP-78 with Casper JS SDK pt. 2

Description

In part 2 of the second workshop for the Smart India Hackathon, Casper Association Developer Advocate Dylan Ireland expands on what was learned from workshop #1. In workshop #2 you’ll learn how to transfer NFTs, as well as query information like balance of on account, the tokens owned by an account, and the total number of NFTs minted. You will also learn how to build a basic front-end and use the Casper Signer to sign transactions, allowing users to mint and transfer directly from a webpage.

Workshop #1: https://youtu.be/9UvsgpXQVpk
Workshop #2 pt 1: https://youtu.be/R9g1K9ngHmY

Template Repository: https://github.com/casper-ecosystem/sih-workshop-2-template

Complete Repository: https://github.com/casper-ecosystem/sih-workshop-2

Casper JS SDK: https://github.com/casper-ecosystem/casper-js-sdk

0:00 Introduction
0:15 Clone Template Repository
0:40 Changes Made Since Workshop #1
2:25 Writing the Transfer Function
4:34 Create Recipient Keys
5:17 Writing balanceOf Function
8:10 Writing ownerOf Function
9:22 Writing TotalMinted Function
10:20 Writing Test Function
12:57 Running a Test
17:15 Set Contract Hash in server.js
17:40 Review Template JavaScript
18:40 Fix Error and Re-test
20:22 Review Template JavaScript
22:40 Rewrite Mint Function on Front-End
26:25 sendDeploy Function Overview
27:36 sendDeploy Endpoint in server.js
28:47 - receiveAndSendDeploy Function
30:00 Error Resolution
31:45 Successful NFT State Data Retrieval
32:00 Start Server
32:48 Testing Front-End Minting
35:00 Rewrite Transfer Function on Front-End
37:20 Testing Front-End Transfers
38:52 Rewrite ownerOf on Front-End
41:42 Add balanceOf, totalMinted Functions
44:15 Testing State Retrieval Functions
44:15 Testing State Retrieval Functions
45:37 Conclusion

A

Okay, um so yeah we're gonna, look at um deploying some nfts and um entering some entry points and then creating a front end for it so um to uh if you'd like to follow along you're, going to need to uh clone the template repository.

A

So if you were to pull up a terminal window and just uh get cloned and uh that right there so uh just I love this shoe there, because I copied it but um yeah, just sih Workshop 2 template and this will be provided for you, um so we'll just we'll get rid of this. That won't work. Okay, um so back over here, I'm going to show the changes that I made since last time.

A

um So previously in Workshop one. This was index.js. I've changed this to sep78.js and we've created a new cep. 78 class we've changed our import style. That's just a minor change that we've made here um have created a new cep, 78 class with Dynamic methods that we will call from server.js which we'll go over here in a little bit.

A

um So uh what I found last time when I was having trouble, um making transfers uh from uh using nfts that we had minted to certain accounts? um I figured out uh that the problem was, as I was not wrapping this with a key uh which you will need to do so. If you pass a public key in uh it will not work when you are trying to reference it, so you will need to build a key there.

A

That's one thing that you should know: I've also created the put and get deploy command here this this function- um and this is Jay all it does- is just puts the deploy and polls for deployment and then resolves when it gets a response and rejects otherwise um the install and make contracts that we created last time, I've uh wrapped in some promises here, so they will resolve or reject when they are actually complete. And, lastly, I've created a new set contract.

A

Hash function on the cep, 78 object, and all this does is sets the contract instance that we've set up here and sets the contract hash on it. um So with that, knowing that we can go ahead and start writing our new functions um so full first, we'll start with the transfer function. That'll allow us to move nfts from one account to another, so we're going to go ahead and copy our mint function and start there.

A

So, let's just take our mint function here, copy it and paste it in and we're going to change this to transfer and we're going to need a token ID parameter and a recipient.

A

Go ahead and delete the metadata as we're not going to need it and let's delete our runtime arguments and we'll change these, so we're going to need the following three arguments: we're going to need a token ID, a Target key and a source key.

A

The token ID is the ID of the token to be transferred the target Keys the destination account and the source key is the sending account we'll set this up here so token, ID we're going to use CL value, Builder we're going to need a unsigned 64-bit integer, as in token ID for the Target key.

A

Will build a key using our CL value, Builder, it's ACL public key from hex recipient. So what we're doing here is we're um we're taking the hexadecimal public key um we're creating a CL public key from it and from there we're actually creating this key here then the source key.

A

This is our accounts and we're going to use the same account that we did in the first Workshop.

A

Is this dot keys.

A

And, as you can see, that's calling to keys right here, so this dot get keys, which we actually created last time um and it's right there. It's just loading the key pair from a private file there so back to transfer here, um as you can see, if you want to send this nft to someone you're going to need a recipient. So what we'll do is we will just create um some new keys.

A

We have an account that we can send the nft to so we'll just do passport, client, Keygen recipient and that will write to recipient right here, okay and then. Lastly, we can change the deploy entry point to transfer and then we should be good to go okay.

A

um So next we will uh look at some read functions, so we will do balance of first, so we'll get the balance of an account um to do that. We'll just create a new function, called balance of it's going to be an async function of um and we're going to return. New promise like before.

A

We're going to need to make sure that we have a contract hash associated with our contract object and, if not, we want to return or reject out of there. Actually, um then, next, what we'll do is we'll just actually query the contracts dictionary so we'll say this dot, contract, dot, query, contract dictionary.

A

And we will query the balances key.

A

And so for this, we're going to need to pass in the account hash of an account, so we'll do CL public key.

A

um So we're going to do balance of account actually and we're going to assume that somebody's sending in a public key that is a hexadecimal string, so we'll see, see CL public key Dot from hex account and we'll convert this to an account hash string because we're going to need the account hash um and then what we're going to do here is we're actually going to substring by 13 characters.

A

And what we're doing here is we're cutting off account hash, so we're going to cut off this string account hash that is prepended to account hashes in the two account hash string function, um and we want to get rid of this right here. So we're going to cut that off. um You could do this with regular expressions or um or anything else uh to get this account hash word off of here in production. You probably don't just want to substring by 13. You know without checking, but for for this example, it'll be just fine.

A

So once this completes.

A

Responsible function- um and we will resolve with this, but we will parse the integer.

A

As inresponse dot data dot underscore hex, and this is where the hexadecimal value lives, the actual balance of the account and then we'll say it's base 16 and we're going to convert that to an integer, looks good, we'll catch any errors.

A

Okay, um okay, one second, all right now we can all but clone this to get the owner of a function so or rather the owner of an nft. So let's just go ahead and copy this over.

A

uh What we're going to do we're just going to change this to owner of an ID and just like last time we're going to query the contract dictionary, but this time we're going to query token owners and we're actually going to use the token ID that we've passed in here so we'll say token: id.2 string we're going to need it in a string format as the dictionary keys are strings and what this will do is this will return us a buffer array, a byte array of the account hash of the owner of the token ID, so we'll say, buffer Dot from.

A

Switch to ring- and we want a hexadecimal string, okay and then we'll reject the error similar to how we did last time. um So. Lastly, let's look at querying a state key like the total number of tokens minted, um just like previously I'll copy and paste the above function and rename it to Total minted, say total Limited.

A

Let me just remove this because we don't need any parameters there.

A

um So, instead of querying the contract dictionary here we're going to query contract data, we're going to query a name key, so that key will be number of minted tokens, and this is just the total number of ninja tokens and we don't need any arguments here.

A

So, let's see so and then here when we resolve, we just want to parse the end again. We want to parse an integer from a hexadecimal.

A

A

There we go okay, now that we have all these methods set up, let's go ahead and create a test right, so we'll say: async function test.

A

Actually, let's create this outside.

A

Create this at the bottom here initialize under object, so step 78 is equal to a new set 78.

A

Right right so we'll create this recipient, so we'll say NFC recipients and we're going to use FS to read in the public, key so we'll say: read: file sync recipient, slash, public hacks and so Casper client. When so we we generated these Keys here. It'll actually create a public key hex file for you here and that's just the hexadecimal representation of your public key.

A

um So we're just going to pull that in directly here and it's going to rear it in as a buffer. So we need to say two string there. We go now I'll just copy this here and then I'll explain it so.

A

Okay, so um we have some console.logs here, just some basic uh logging stuff, uh so new Step 78 installation contract hash. So this is going to call install contract and, like we built last time in Workshop one, this is going to return us. The contract hash, so that'll just print this out here, um new mint execution.

A

This is going to call sep, 78., mint and it'll return us the response, uh new transfer to the recipient right here, I'm just going to transfer token ID 0, which we are going to Mint right here um to the recipient, the account hash of token ID, 0, we're going to use owner of and send in token ID 0 to get the owner of it, uh the balance of the recipient, which should be one after we execute this transfer, and this is going to execute in order.

A

So um the you know, the next console.log, for example, will not run until these functions run and that's because the await command here so we'll get the balance and then we'll get the total number of minted nfts um with that. So let's just run a test here, we'll save it and we'll run.

A

We will run node .js.

A

Okay, let's see what the error is here cannot find Package, Express, okay, so I forgot to install that so npm install Express. You will need that, but when you uh copy this to follow along when you pull in the repository, I will have had this fixed. So we should be good to go after this.

A

Should just take one of them in here.

A

uh It looks like I didn't, install any of the npm packages, so I actually um I believe I already have Express and all the other ones set up in the package.json, but we'll need all um we'll need all the packages. So we should be good to go here. Actually, okay, we're good to go.

A

A

Is that oh yep, so we did not catch so we're gonna need a catch here.

A

um Contract hash contained- and one moment here so when we install this contract it should actually set the contract hash, which we are doing here.

A

um But let's see why this isn't working so.

A

um One moment and the format that contains the hash prefix.

A

So that actually I, um if I'm not mistaken, that should actually happen.

A

Oh shoot it should work. uh Let me check my other file to see if anything's missing here, if I've done anything wrong.

A

No actually I'm not sure, was isn't working. Just give me one little comments.

A

um We're gonna just do server yeah, okay, yeah, that that was the problem. We need to run sep78.js.

A

That was the issue there. Okay, so this is actually going to take a little bit. So um while this, uh while this executes and we'll come back to this, we're going to open up another terminal window, we're gonna go back to our same directory. So let's go here.

A

Okay, um now, let's open up the file server.js, which I have open right here uh on line 24 right here, we're going to set the contract hash that'll get printed here in just a moment um and then we'll wait for all the other functions to execute too. But we'll come back to those other functions.

A

But we will need the contract hash, which should be printed out here in just a moment uh once it executes on chain and while we're waiting, we can actually just go over here and look at our public key um and yeah here in a moment. This will show up down at the bottom here just to make sure.

A

We do want the workshop key, which this is correct here, so, as you can see the wasm deploy, this has succeeded. um So let's go back and we can get the contract hash, which is right here. So we're just going to take this and paste it in as a string literal um in a production application. You might want to do something else. You know you might want to save it to a database.

A

You might want to pass it directly to this, but in this case we're just going to use this literal here just for um just for ease purposes. So, um okay, now open index.js, um and what we're going to do first is we're going to set this contract hash again. Now we're going to go over the functions that are already here, so we have check and set signer status, set active public key and connect to signer. So first we have check and set signer status.

A

So what this is going to do um is it's going to actually see if the signer is connected, so it's going to use this. uh This method on the signer class is connected. If it is I will say. Yes, it's connected if it's not we'll, say no, and otherwise we'll error out um and I can't show you what that looks like just yet, but I will be able to here in a minute um set active public key.

A

So this is just going to set it on a label that we have on the screen just going to set the connected account, and so that's what this is here. We're going to use this method, get active public key on the signer class, which will get the active public key from within the signer uh and then connect to Sounders is just sending a connection request, so we can hook this to a button which we do in index.html, which I'm actually going to um open here.

A

Oh, it looks like we had an error um here, which we can take a look at here in just a moment, but okay, so, let's actually see really quickly uh what happened here so Newman executed. It looks like this field on a transfer. So let's look at this transfer really quickly um and the target key The, Source key, does look correct.

A

Let's see, um we might just ignore this for now and come back to it at the end, but let me first see.

A

Chrome: um okay, oh okay, wait! Okay, um yeah, as you can see yep! So that's what I did wrong there. This is what I had, um whereas.

A

Whereas this is what we need.

A

Looks like that was the issue um now. What we can do is you can just we can initialize step 78 with a contract hash which we'll do here so we'll take this contract hash.

A

And we will initialize with it and then comment out the installation and the mints and we'll run that again, we'll hope that that works there, okay and we'll wait for that. But we'll go back to index.js here. um So, like I was saying we can connect. This connect assigner function uh to a button which I just didn't index.html, just just some basic HTML here um and that'll- be right here so connect to sign- or we have this button when you click it.

A

It executes this which sends a sign a request, so that'll open the signer and ask us to connect to it. um Lastly, we have some event listeners, so these just listen for changes to the signer State and we can react to those so active keychains. For example. um We can say message.detail is connected. If it is connected, we can set the active public key.

A

We can actually get the public key um and forget the actual, uh the path to get it, but it's I think it's message.detail, Dot Public key, for example, or something of the sort. But what we're going to do uh for this example is we're just going to call set active public key which is going to redo this, so it's going to recheck for the public key and just do a check like that um sign or connected, so when it does connect we'll check and set this under status and then set the public key.

A

um The same thing with disconnection. We're just going to do this. This basic solution here, um so there's that um now, let's actually look at minting an nft from the front end, so we'll copy the mint function from cep. 78.Js.

A

Up here and copy this mint function we're going to make some changes to it on the front end so because, uh in this class, we're actually like initializing it and calling these functions and they're performing the entirety of the logic.

A

um It's going to be very similar in index.js when we do this, but like in a production application where you're just connecting with the back end, for example, you would just want the back end to actually send the deploy, for example, and I'll show you what I mean uh here in a minute when we get to that so I've copied the mint function, I'm going to paste it in here we're going to start by adding the function. Keyword, we're going to need that and we're going to remove this promise.

A

Don't need that and let's just look there. We are okay um from here, we'll start by creating a variable that holds a CL public key representation of the account that we want to Mint our nft to which is going to be our account. The transacting account. So let's get rid of this check and we're going to paste this.

A

So this is meant to we're going to Mint, to this account uh CL public key Dot from hex, and then we're going to use this signer.getactive public key again and so we're going to Mint it to whichever key is active on our front end.

A

um Okay, now we'll change the token owner runtime argument to match so we'll remove this and we went to okay and then, uh in our call entry point, we'll change this up a little bit so we'll remove this public key and we'll say mint to what we just created right here: we'll remove this.network, that's within our class, so we'll just say test, and this is the same one that we're using over here.

A

So if we go look, it's just Casper test right here, okay and then, instead of this dot Keys, now we're just going to pass an empty array. um So there's going to be no signers from the front end here, no signers on this! Actually on this actual function um and we're going to change this to just contract, which is going to be a basic contract instance right here um so yeah there we go foreign.

A

Now we need to convert this deploy object into a Json representation of it, so we can send it to the back end. So right now this is of type deploy. You can imagine this being like this, but we need to convert it to Json, so we'll say, deploy Jason equal to deploy, util we're going to use, deploy, util, which is a very handy file in the Casper JS SDK, which has a lot of great functions.

A

That'll help you out with um with moving data around and converting it so use, deploy to Json pass in or deploy and we'll say our active, we'll just create the variable active key here.

A

We could just create this variable originally and then create mint 2 from it, but whatever it doesn't matter, we'll just create this here, then so we're going to actually remove this dot put and get deployed, and what we're going to do is we're going to call signer DOT sign so I'm going to paste this in and explain it so signer DOT sign.

A

This is using the sine function in the sign or class, and this is going to call a signer and pull up a signature request using our deploy.json and ensuring the active key it'll, pull it up and then we'll be able to assign and send it off.

A

So once it's signed uh this success, this is actually the deploy Json um the sign deploy that is so once it's signed, it'll take our deploy, Json sign it and return it back to here then we'll use, send, deploy and we'll send it to our backend, so we haven't written, send, deploy yet we'll actually write that right now, so I'll just copy it over and explain it okay.

A

So it's going to return a new promise, that's going to resolve once we get an answer from the back end um and as you can see here, um let's see so we yeah. So we use our sign, deploy Json uh that we pass here and we're going to use axios, which I've linked in here from a CDN and axios, is just a uh a library for making HTTP requests.

A

So we're going to use a post request and we're going to call the send deploy endpoint, which we will set up in our server.js here in a minute and pass in our sign, deploy Json as as the the data, the the body and then the headers will say, content type is application Json, because we are passing in Json and then we'll resolve to a response and reject with an error and then, when we do resolve, as you can see here, it's going to alert with our response and it's going to alert on the main screen on the front end.

A

So, on the server end of things, we are going to need a send, deploy endpoint.

A

So we are using Express for this. So if you're not familiar with Express, you can look into Express, but basically we can open up a post endpoint by saying app.post and our app comes from our Express app here so send deploy. um We have our request and our response. uh The sign Jason is the body of the request and then the sign deploy here. This is an actual deploy object in and of itself, like I showed you earlier just like that, um and this we're going to use deploy from Json.

A

So last time we used deploy to Json we're going to use, deploy from Json and we're going to unwrap it, then we're going to actually call our cep, 78 class, so we've set up a a new instance here of cep 78 and we are going to call on the object receive and send deploy, which is going to actually send it off to a node.

A

So if we look at that, um actually we have not created that yet so we'll create that right now, so in cep 78.js within our class, we are going to need a new function, a dynamic function which we'll call receive and send deploy boy.

A

Paste this in here and explain it.

A

Okay, so this is going to return a new promise, like we've been doing uh in the in the previous functions. um If there's no contract hash, we want to fail out um and then we're actually from here we're going to put the deploy um and this put and get deployed which I showed earlier. This just puts the deploy and then pulls for the deployment status right here.

A

So there we go now. We can actually call this cep 78.receive and get deploy, we're going to send the sign, deploy and then we're going to send back to the front end the response or the error. So back on the front end. We will get that and then it will come here and then we'll resolve with that, and then it will alert us. So that's how that'll work?

A

Okay, so now that we've gotten this built out, let's actually test it in the browser. So let's go over here. It looks like we had another error, so we did get the um the account hash or token ID 0. So we were calling owner of okay. So actually we were doing the transfer too. So we're doing a new transfer to this account um and actually what we can find out. If we go here- and we say recipient public key hex and we take our public key.

A

um So it's a transfer to this public key right, um but the actual um okay, I I can actually prove it here in just a second. So the account hash of token ID 0, um all right so the owner of token id0 is this right here, which should actually be the account hash of this public key, because we just transferred it to this public key.

A

um We can verify that by going to cspr.live and we'll paste this in here, and so this was the public key of the recipient account and, as you can see, the account hash is 64 b0 Etc, um and that does match. If we look right here and then the balance of this account is now one and looks like we had another small error here, so I believe that's in the total number of minted nfts, so we had some invalid parameters. So let's take a look at that briefly.

A

Okay, yeah because we need an array of paths, not just the path, so there we are. um This should work just fine now, but we're not going to perform the transfer again we're just going to aquarius. So, let's see so there we go. There's the account hash. The balance of uh this recipient account is now one nft and the total number of minted nfts is one right. So now, let's remove this uh test call and we can now run the server so we'll say: node server.js, so we have an app listening on Port 3000.

A

Let's open this up. Okay, let's keep our console open, so connect to signer that will initiate, assign a request and now we're set up here. So let's see um we are set up.

A

um I should have a listener for this I'm, not exactly sure why it's not working, but if I go over here. um So yes, you can see. Our connected account uh does work here.

A

Okay, now that um now that we've gotten our Mint set up on the back end, let's actually try this. So we have our connected account and we're going to press mint here. So if we take a look, um our signing key, that's our public key. We have the deploy hash time stamp chain, name payment. This is one cspr. It costs about 0.5 cspr, um for this call and then our arguments so token owner, um let's actually see token owner, should be myself, but perhaps that's the hash.

A

A

That doesn't look right. Let me actually, let's just sign this and see Okay so I actually have not printed out the deploy hash, which I would have liked to have done to go and look at the look at the call here, oh okay, that so that was the account hash of this account yeah. So that's that's what that was showing right here, um but once this completes we should get an alert here.

A

So this should take another 20 or so seconds.

A

So in the back end, we're still looking good stupid.

A

Nothing like nothing yet but okay, here we are so it's just succeeded.

A

And as you can see mint right here, so we called the mint function all right, so that works perfectly great. So now let's go back um okay, so let's Now work on our transfer function. So let's take our mint function.

A

Copy it over I will rename it to transfer.

A

Now, let's delete the metadata variable and we'll change mint 2 to from or use of readability and we're going to define the variables token ID and recipient, which will be values that we enter on the front end.

A

Get element by ID token IV Shield that value. So if we go and take a look, this um token ID field right here- we have that right here, so we're going to call this by ID and get the value of it.

A

And similarly we are going to do the same thing for recipient.

A

Transfer to field and we'll see that's the same as right here: okay, so now we're going to alter our arguments um to include the token ID in the recipient. We'll also need an argument. Source key, which will just be our active key, so say token ID.

A

Cl value Builder, Dot, u64.

A

Target key will be key and this will be created from our recipient key.

A

That we will enter on the front end and, lastly, we'll need the source key.

A

The new key um using this from variable that we defined right here. So this is uh this new public key that we've gotten from the the active public key and we're just going to pass that in as our source, key okay and then we'll change. Our call entry point arguments so we'll change this to transfer because we're calling that entry point um we'll change this to from, and then that looks good. So we should be good to go now. So, let's actually save this out head back over here, kill our server and rerun it.

A

And then, if we go over here so we're on this account. So we want token ID one because remember uh using our test that we did in cep 78.js we minted one already and we minted token ID 0.. We already transferred that. So we just minted a new one using this button here, so we're going to transfer token id1 and we're going to transfer it to our recipient.

A

So, like we were looking at earlier, this is the recipient public key, we'll just take that and transfer it here, click transfer um and, as you can see the arguments of the target key, um that's the account hash of the Target and then the account hash of our source key and then token id1 and we're calling transfer and we'll sign that and we'll just wait. Another 30 seconds for this to complete, we'll go over here and keep refreshing and and look at that.

A

Okay, actually, while we wait for this, we can just move on and we can uh we'll go back into index.js. Now we'll look at implementing an owner of function on the front end, so we can get the owner of a token ID. So, on the front end, things are pretty simple: we just need to create a new function in async function, owner of.

A

And we'll say the token ID is similarly to up here, it's just from the owner of field, so in index.html we have this owner of field, and then we can actually look at that. That'll be right here.

A

So now that we have that um we can just make a get request to our back end and we will query the owner of uh endpoints so and and then we'll pass the token ID here as a URL parameter and we're just using it right here. So this is actually going to come back as text, so we don't need to parse this in any way. We can just send this off um and then in server.js we're going to need to open this endpoint.

A

So, let's see so we're going to need a new endpoint and as you can see, unlike this last one we'll just post, this is a get endpoint uh it's just owner of and in here we're going to call cep, 78. owner of which we looked at earlier and we're going to pass in the token ID from the URL parameters um and then so. This will return us the owner and then we'll send this back to the front end or we'll catch the error and send the error back okay.

A

So let's go ahead and test this out. So this did succeed as you can see here, so we can go back. Take a look on this transfer function, succeeded and then we can actually verify that here in a moment by looking at the owner of so, let's see so going back, let's say a killer server restart it make sure we can save. So that was actually a close one. I did not save this.

A

Actually that wasn't necessary I didn't need to restart the server, because this is on the front end. Okay, so owner of token id1 call that and we get the account hash here. So if we look over here, uh not this one right, because this is the one that we minted from, but we take our recipient public key transferred to that up. The account hash right here, 64 b0, will match right here and that's the owner of function.

A

Okay, so, let's see now, while we're here in server.js, we can create some new entry points for the balance of and for the total number of minted nfts. So for balance up, we can just copy owner of place it here and we'll change this to balance of.

A

We'll say const balance is equal to step 78.balance of and instead of token ID, we'll say Hub key and send back the balance.

A

That's all we'll need to do for that, then, for the total minted.

A

Slash total minted and we'll say: cons total is equal to 778.total minted okay and then we don't need to pass in any arguments here.

A

And then we're good to go there. So, let's save that back on the front end, um let's copy and paste the owner of to begin building, the balance of so we'll rename it ounce of, and just like we're doing here with the owner of field in order to do the balance of field which we can see right here and then right here.

A

Okay, um and instead of calling owner of we're, going to call balance of key.

A

And then pass in this public key.

A

Okay, now we're good to go there, let's go ahead and get our total minted function up and running same idea. So let's copy balance of we can remove this because we don't need any arguments, say total minted and then we're just going to call our total minted endpoint.

A

I, don't need this public key and then there we go um now we're good to go. We're going to go ahead and save everything and test it all out.

A

A

So we've tested the mint and transfer so let's go ahead and test balance of so, let's use, let's actually use the the recipient public key, which is this one right here, because we know that the balance of this should be one. So, let's take a public key on this balance of is two: um oh, that that is actually right. So um so, in our test earlier in sep78.js, we transferred to this recipient account for the same recipient account um and then right here we minted and then transferred to this account.

A

So balance of two is correct, um but for example, if we go here and copy our public key, we should get a balance of zero, which is correct. So we do get a balance of zero. That's what we're expecting um and then, of course, owner of um owner of token id1, for example, that's going to be our recipient same with uh to open zero, yep, the recipient and then. Lastly, we have the total minted um this. We have two two total minted nfts.

A

So if we were to Mint another one, we would get a total minted of three um and then the balance of the mentor, which is us right here. This is our public key, would go up by one um and yeah, so that is all um that is all I have as part of uh as part of this workshop. On my end, um if there's any questions, I would love to answer them um uh and if not, uh we will um we will conclude there and then we'll do another Workshop uh soon and uh yeah yep.

A

That is all on mine. So if there's any questions, uh please let me know- um and otherwise we'll conclude here. Thank you all.