Casper Casper Association dApp Developer Series, 20 Jun 2023

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Casper Association dApp Developer Series | #7 | Payable Entrypoints & Smart Contract Withdrawals

Description

In the seventh video of Casper's dApp Developer series, Casper Association Developer Advocate Dylan Ireland demonstrates the implementation of payable entry points, smart contract CSPR storage, and CSPR transfers from contract to account.

Please note that this project has **NOT** been audited.

GitHub repository: https://github.com/dylanireland/dApp-dev-series-7

Ask questions on our Discord: https://discord.com/invite/Q38s3Vh

This is the seventh video of a continuous series that teaches developers how to build dApps on Casper.

Chapters: Timestamps
0:00 - Title

0:10 - Introduction

0:29 - Create New Smart Contract Project

0:50 - Begin Writing Smart Contract

1:45 - The `call` function

2:58 - `deposit` Entrypoint

4:30 - `withdraw` Entrypoint

5:16 - Create Session Code Files

5:43 - Edit Cargo.toml

6:00 - Deposit Session Code

7:28 - Withdraw Session Code

8:14 - Edit Makefile

9:00 - Deploy Script

9:14 - Deposit Script

9:50 - Withdrawal Script

10:08 - Compile Contract & Session Code

10:30 - Generate Keypair

10:50 - Test

12:46 - Outro

A

Hi everyone and welcome back to Casper's app developer Series in today's video, we'll be writing a smart contract with payable entry points which are smart contract functions that have the ability to accept cspr and deny users access if they don't provide sufficient funds. We'll also write an entry point that allows depositors to withdraw the funds. They've deposited start by opening a terminal and navigating to the directory.

A

You'd, like your project, stored, I'll, start from the home directory, create a new Casper Smart contract project by running cargo Casper, and then your project name, I'll name, mine, Bank, contract.

A

Open a file explorer head to your project directory and go to contract, SRC and openmain.rs, delete lines, 19 and 20, and then everything after line 32.

A

Let's import everything we need we'll use the VEC macro to create Vector, arrays and two strings, so we can build string objects from string literals next, we'll use some classes from the Casper contract crate. We need runtime, storage and system, so we can manipulate the session context, blockchain, State and system variables respectively. We also need unwrapp or revert, so we can optionally unwrap objects that might not exist. If they don't exist, we can revert the deploy now import. These types from the Casper types crate we'll be using all these in our project.

A

Now, let's define our own error, so we can debug if we run into issues we'll go through these errors, as we write them into our smart contract. Now, let's write our call function, which is executed, Once Upon deployment of the smart contract.

A

Our contract will have two entry points deposit and withdraw to clear these entry points by creating a new entry points, object and adding the deposit and withdraw entry points. The deposit entry point accepts one argument: purse, which is a reference to the callers funded purse that they'll provide when executing deposit withdraw, has one parameter as well amount, which is the amount that the user wants to withdraw in moats. Now we can create our contracts named Keys which store data under convenient string, references create a new purse and add it to named keys.

A

This will be the purse that the contracts cspr is stored in if the balances dictionary already exists, or another error occurs. We'll revert with the couldn't create balances. Dictionary error now use the new contract function in the storage module to create a new smart contract in the blockchain state, as we create this new contract we'll pass in our entry points and name keys that we defined earlier. Lastly, store your new contracts, contract hash in your accounts named Keys, which will make it convenient to access from the installing account we're now complete with the call function.

A

Let's next write the deposit entry point.

A

First, we'll want to get a reference to the caller's purse that they provided as an argument, then we'll get the account hash of the caller of the entry point, so we can store their New Balance under their account. Now we need a reference to the contracts purse that we created in the call function. We're doing that here and the rest is just unwrapping to the object or reverting with errors.

A

Now we can get the contract purses, balance with system get purse balance, and if we can't, for whatever reason, get the purse's balance we can just revert with couldn't get purse balance. As an example, we can set a minimum deposit restriction in this case. We'll do one cspr and if the balance is too low, then we will revert with deposit too low. As long as the deposit size is sufficient, we can execute system transfer from purse to purse which will transfer the funds from the callers purse to the contracts purse.

A

In the event of an error, we will revert with couldn't transfer from purse to contract purse. Now, let's get a reference to the balances dictionary created in the call function. We'll do this with runtime get key and the rest is just unwrapping or reverting with errors.

A

We can use a match expression to see if the color has an existing balance. If they do, we update their balance. If they don't, we set the initial balance to that which was transferred and if there's an error, we revert with that error. This smart contract now supports cspr deposits.

A

Let's finish by adding the withdrawal entry point, so depositors can extract their funds, create a new function, withdraw start by getting the amount the user would like to withdraw that they provided as an argument we'll also get the caller the contract purse and the balances dictionary, just like we did in the deposit entry point.

A

Just like in deposit, we get the balance of the caller from the balances dictionary. If a balance exists, we check that it's more than or equal to the amount requested to be withdrawn, and if it is, we update the balance and transfer the funds if the balance is instead lower than the amount requested by the caller or no balance exists at all. For that user. We revert with the error: insufficient funds, that's it for the smart contract.

A

Now, let's write session code to interact with it to create a new session code file which will compile to webassembly head to your Project's root directory in the terminal and run cargo new client.

A

This will create a new file main.rs in client, slash, SRC, main.rs and a cargo.com will file in client, slash, cargo.com, delete, main.rs and create two new files. Deposit.Rs and withdraw.rs now open the cargo.toml file. Now add the following data: dependencies is a list of dependencies that our contract will use when compiling and Bin is the binary information.

A

Profile.Release is a list of release. Optimizations now open the deposit.rs file begin the file by writing the rust attributes no standard and no main, which disables the rust standard, library and disables the generation of a main function by the Rus compiler respectively.

A

Now import the Casper contract crate, including the runtime system, and account modules as well as unwrap or revert, then we'll need the Casper types crate with types u512, runtime, orgs, contract, hash and key from here we can create our call function, begin the function by retrieving the amount the user wishes to deposit as a runtime argument, we'll also provide the contract hash of our bank contract as an argument so grab that too.

A

The contract hash is passed in as a key argument, so we use into hash to convert it to a hash and from there build a contract. Hash object out of it. Now, ideally, we don't want to expose our account's main purse for security purposes, so we create a temporary one using system create purse.

A

Then we transfer the proper amount from the caller's main purse to this new purse.

A

Since we need to pass this purse as an argument to our contract, we create a new runtime args object and insert the new person's URF.

A

The only thing left to do is call our contract, which we do by running runtime call contract, passing in the contract, hash, deposit entry point and runtime arguments. That's it for the deposit session code. Let's move on to withdrawal, open your withdraw.rs file and since withdraw.rs is so similar to deposit RS, we'll start by copying, deposit and pasting it in withdraw, delete the creation of the new purse and the transferral as it's not necessary for us to pass a purse to the contract.

A

In this instance, then, in runtime args replace purse with amount and new purse with amount which will tell the contract how much of the colors funds it should withdraw. Finally, in runtime call contract simply replace the deposit entry point with withdraw.

A

We can also delete system and account, as we'll only be using runtime. Our session code is done. Next, we need to adjust our make files, so we can compile the deposit and withdraw session code to webassembly open the make file in the root directory of your project, copy the build contract, Target and paste it below the original, changing the name to build client change, CD contract to CD, client duplicate, the wasm strip, command change, the first file name to deposit.wazum and the second to withdraw.wasm.

A

Finally, we need to write a few shell scripts to deploy the contract as well as deposit and withdraw in your terminal in the root directory of your project, run, touch deploy.sh, deposit.sh and withdraw.sh.

A

Add the executable permission with chmod plus X, now open deploy.sh in your editor, we'll be using the put deploy function in the Casper client. Your command should look like this, be sure to use an online node address in the correct chain. Name, we'll create a new key pair under the keys directory in just a moment now open, deposit.sh and copy your command from deploy.sh.

A

Change your payment amount from 30 cspr to 10 cspr and replace the contract.wasm file in session path with deposit.wazam.

A

Lastly, create another session org amount of type u512. This will be the amount that the caller sends the contract to demonstrate a failed deposit attempt, make the amount 0.1, cspr or 100 million modes. Finally, open withdraw.sh and copy your command from deposit.sh.

A

In this case, we only need to change deposit.wasm to withdraw.wasm and the amount to one cspr for when we do a successful deposit. Now, let's compile the contract and session code head to the root directory of your project in a terminal and then run make prepare then run make build contract.

A

Then run make build client.

A

Before we can deploy our contract, we need a calling account create a new key Pair by running Casper client, Keygen Keys, which will create a key pair in the keys directory. You'll then need to fund this account. If on testnet, you may use the faucet at testnet.cspr.live tools, faucet check out video number three. If you don't remember how to do this, once you have a funded account run deploy.sh.

A

We can check the execution status by copying the deploy hash heading to testnet.cspr.live and pasting.

A

Once the deploy has succeeded head over to your account, go to your name, keys and copy the bank contract hash now head over to deposit.sh and paste the contract hash and go ahead and do the same with withdraw in both deposit.sh and withdraw.sh change. The session path from contract to client.

A

And make sure the amount is 100 million modes in deposit head back to your terminal and run deposit.sh, and remember that this should fail, because our deposit amount is too low copy the deploy, hash and head back to cspr.live and paste it in. As you can see, we get user error 3, which is deposit too low.

A

Let's change our deposit amount to one cspr and try again.

A

Copy and paste in cspr.line now the deposit completes. As expected, we can check our accounts balance by going to view account copying our account hash going to named Keys balances, dictionary and paste. You can see we get one cspr or 1 billion modes. Now our withdraw.sh is already set up to withdraw one cspr. So head back to your terminal and run withdraw.sh.

A

Copy the deploy hash go to cspr.live and paste it in our withdrawal has now succeeded to check our balance, which should be zero. We can go to our account copy. Our account hash, go to balances, dictionary paste it in and we get zero. That's it for this video If. You enjoyed be sure to leave a like And subscribe. If you'd like to see more content, thanks and I'll see you in the next video.