Given enough eyeballs, all bugs are shallow. ~ Linus’ Law Bugs! Bugs are aliens that creep into a programmer’s code at night when no one is watching and alter the state of a working code. These aliens have only one mission — to frustrate the life of a programmer. How does a programmer kill a bug before he dies of frustration? Yeah, you got it right! By debugging and removing the buggy code. But why would a programmer go into a debugging war without the right tools? If a programmer is going to debug he better do it the right way, using the right tools. If debugging is the process of removing software bugs, then programming must be the process of putting them in. ~ Edsger Dijkstra In smart contract development, like traditional centralized software , bugs creep into the smart contract developer’s code during the development lifecycle of the smart contract. While there are ‘Etherillion’ reasons why smart contracts could be buggy, one thing remains important, all bugs must be removed before the smart contract is deployed on the mainnet, or else, we risk losing funds and ultimately, the credibility of the smart contract. development There are several frameworks for developing smart contracts in solidity. In this article, the focus is on the Truffle Framework. . Smart contract bugs can be hard to find, and error messages can be very obscure. When building smart contracts using Truffle, the Truffle Debugger comes in very handy when it is time to debug a contract. This process of debugging can be tedious to reason about traditionally, and this is where the Truffle Debugger really helps — by allowing us to debug any transactions as long as we have the code and the artifacts of the transaction. Let’s talk briefly about the Truffle Debugger and then take an example to show how this tool can be used. Truffle aims to make a developer’s life easier by providing a development environment, testing framework, and debugging tools for smart contract development This is because when debugging a smart contract, you’re not running the code in real time; instead, you are stepping into the historical execution of that transaction on the blockchain, and mapping that execution onto its associated code. Debugging is a cyclic activity involving execution testing and code correction. Truffle Debugger Truffle Debugger is a command line tool integrated into the Truffle Framework which allows smart contract transactions to be debugged using the smart contract code and transaction artifacts. When the debugger is started, the command line interface provides a list of addresses transacted against or created during the course of the transactions, an initial entry point for the transaction and a list of available commands for using the debugger. Some of the debugger commands are highlighted below: : [o] step over This command evaluates the instructions evaluated by the virtual machine relative to the contract until the next line in the current smart contract file, skipping the functions referenced at the current execution point(if any). : [i] step into This command steps into the function called at the current execution point. : [u] step out This command will have the debugger step out of the current function, to the next line executed right after it. : [n] step next This command steps to the next logical statement or expression in the current function called. : [;] step instruction This command steps through each individual instruction evaluated by the virtual machine. You can check out other commands here Thus far, we have talked about debugging, and the Truffle Debugger, let’s have an example to really drive this home. Debugging a FoodCart smart contract The smart contract below models a simple food cart which allows anyone to add food items to the cart for sale and also allows anyone with enough ether to buy a food item off the cart. This contract is just for the purpose of illustration, and it should not be used in a production environment. Before we start this example, the following are required to follow this example without any issues: Truffle 4.0 or above Solidity compiler version 0.4.24 or above Private blockchain (Ganache CLI v6.1.6 or above) The repository for this article can be found , just in case you want to follow through the debugging process without coding the smart contract. here Step 1: Building the smart contract Let’s start by creating a directory for this project and building the smart contract. At the terminal enter in the following commands: mkdir FoodCart Enter into the folder and create a bare the truffle project. cd FoodCarttruffle init Navigate into the contracts folder and create a smart contract file FoodCart.sol cd contractstouch FoodCart.sol Open your FoodCart project in any IDE of your choice. I will be using Visual Studio code. Why? I really don’t know …lol. 😂. Open the contract and type in the smart contract below: FoodCart.sol Before we proceed any further, let me explain the smart contract above. The FoodCart smart contract can be sectioned into 6 parts: The state variables: The state variables, and store the address of the owner and the count of food items added to the FoodCart respectively. The mapping maps skus to food items. owner skuCount foodItems The enum: The enum is a user-defined data type that holds the state of the food items on the cart. The types listed in the enum are explicitly convertible to and from integers, i.e ( , ). State ForSale = 0 Sold = 1 The events: The events and log the details of the food items that are put on sale or sold. These events can be called by callbacks in javascript and their contents can be used to make using dApps more interactive. ForSale Sold The struct: The struct is a user-defined type which holds the properties of a food item. These properties can be accessed using a dot notation on the struct. FoodItem The function modifiers: The modifiers , , and are functions that automatically check a condition prior to executing the function on which they are applied to. The roles of the function modifiers used in this smart contract are obvious from their names. doesFoodItemExist isFoodItemForSale hasBuyerPaidEnough The functions: The functions , and adds food items to the contract, allows a food item to be bought and allows the details of food item to be viewed respectively. The constructor function initializes the state variable with the address that the contract is deployed on. The anonymous function allows ether to the sent to this contract. addFoodItem buyFoodItem fetchFoodItem owner payable Step 2: Deploying the smart contract Let’s deploy the smart contract on the private . network In your IDE, create a new file called in the folder. Open this file after creating it and add this code: 2_foodcart_migration.js migrations This piece of code will enable the framework to deploy our contract to the private blockchain. FoodCart.sol Open your terminal and navigate into the folder for this project and type this command: truffle develop This command starts a development blockchain with which we can start testing our contract. Running that command should produce this result: The image above shows that a development blockchain has been started on port 9545, test accounts have also been created for use, and the terminal is navigated to a new prompt . truffle(develop)> In the prompt, type the command to compile the contract. The result of the compilation is stored in the build folder of your project directory. truffle(develop)> compile truffle(develop)> compile Running the command should produce this result: compile Finally, let’s migrate the compiled contract to the blockchain for deployment. At the terminal, type the command to migrate the contract to the development blockchain that has been started for us. migrate truffle(develop)> migrate Running the command should produce this result: migrate Step 3: Interacting with the smart contract Let’s interact with our smart contract and get a feel of how it works. We will be adding food items to the food cart, checking the details of food items added to the cart, and also buy food items off the cart with Ether from one of the accounts created for us when we started the development blockchain. Still in the prompt, create a variable and store the instance of the deployed contract in it. truffle(develop)> foodCart truffle(develop)> let foodCart; truffle(develop)> FoodCart.deployed(). ((instance) => { foodCart = instance; }); then In the short code snippet above, we access the deployed contract via the web3 method which returns a promise interface and we pass a function which stores the instance of the deployed contract in the variable. With the instance of the contract stored in the variable, we can access the functions of the contract through the variable. FoodCart .deployed foodCart foodCart foodCart Let’s add some food items to the food cart by running the following code snippets at the prompt. First, let’s add a function that will help us add food items and print the result of the transaction at the console easily. truffle(develop)> The function allows us to easily add food items to the cart by passing the name and price of the food item to the function as arguments when it is called. The function acts as a wrapper for the in the smart contract by making the smart contract calls for us and formating the log output returned from the function call. We can add some food items with the function by running this commands: addFoodItemToCart addFoodItem addFoodItemToCart Now that we have about 3 food items on the the food cart, let’s buy some food items off the cart. Before we can buy a food item, we need to specify what address we will be using to make our purchase, because it is from this address that we can get the funds to buy food items. Recall that when we started our private blockchain, 10 test accounts were created for us and each of these accounts was credited with 100 ether which we can use to buy anything we want, we are rich 🤑🤑. Let’s create a variable to store one of these addresses or accounts so that we can easily call it anytime we want. in ether truffle(develop)> buyerAddress = web3.eth.accounts[1]; truffle(develop)> buyerAddress '0xf17f52151ebef6c7334fad080c5704d77216b732' const Since we have an account (yours will be different), we can add a function to buy food items off the food cart at our prompt. 0xf17f52151ebef6c7334fad080c5704d77216b732 truffle(develop)> The allows us to buy food items off the cart by calling the function with the and of the item. The amount to be paid for the item is taken from the account that was stored in our variable. Let’s buy Fried Rice off the food cart. From our previous transactions, we recall that the sku for Fried Rice is and it’s price is . So at the prompt, we call the function with these values: buyFoodItemFromCart itemSku amount buyerAddress 0 10 wei truffle(develop)> buyFoodItemFromCart From the output, we see that the state of the item is and the is now , indicating that this item is no longer for sale. Sold foodItemExist false Step 4: Debugging errors in the smart contract If you have made it thus far, you deserve a Noble prize for Tenacity 🎖, enjoy the fame it brings. So far, we have seen how the contract should behave. To be able to use the Truffle Debugger feature, we would introduce some errors while interacting with the contract and then use the debugger to debug the error and get it fixed. To debug a transaction, we need to have the hash of the transaction and then run command at the prompt followed by any of the debugger commands until we find out where the transaction failed. debug [transaction hash] truffle(develop)> We will try the following invalid transactions: Try to buy a food item that does not exist Try to pay an amount less than the price of a food item Before we start these transactions, we need to start the in another terminal, but still in the sample project. Open a new terminal, navigate to the FoodCart project and run this command . truffle develop logger truffle develop --log FoodCart $ truffle develop --log You should get this output: Connected to existing Truffle Develop session at http://127.0.0.1:9545/ The logger connects to an existing session at the port specified, listens for transaction events, and logs the output of the transaction which should include items like transaction hash, block number, etc. Let’s go ahead and make the life of our contract a living hell 👹. Invalid Transaction #1: Try to buy a food item that does not exist From our previous transaction where we added food items to cart, we had skus respectively for the 3 food items. We will try to use the sku to buy a food item that does not exist. 0, 1, 2 6 Trying to buy the item as shown in the command above produces the error which does not really tell us what or where the problem came from. Now, this can be a real headache when there’s no debugger. I have spent many hours trying to debug a smart contract without using the debugger and it can drain the last blood out of one. Let’s have a look at log output and see what we have there. UnhandledPromiseRejectionWarning: Error: VM Exception while processing transaction: revert ... The most important content of the log to us is the transaction hash , this will be different from what you have on your machine. With the transaction hash, we can debug the transaction and figure out where the problem is. Let’s debug this transaction. Copy the hash of the transaction from your debugger terminal and run this command: at the prompt. Your output should look like this: 0x90a2ef83e54426848523a4edcf0c9628045e03c69d95f989c5b3b557367c848c debug your-trasanction-hash truffle(develop)> From the image, we see that when the debug command is run, the debugger compiles the contracts, gathers transaction data, fetches the address that was affected and the contract that was deployed at that address, and shows a list of debugger commands that we can use to interact with the debugger. The most interactive command to use at the debugger is the command which steps through all the instructions executed during a transaction one at a time. The command is executed by pressing or , at the keyboard of course. step next step next enter n At the prompt, press enter continuously, following each instruction step until we reach the instruction where the transaction failed. There are steps before we reach the final instruction that halted our transaction - you will have to press enter 9 times to reach the halting instruction. Let’s look at the first 4 steps from this image below: debug(develop:0x90a2ef83...)> 8 From the image, we see that at line , the function was called, but before the execution of the function, the modifier at line was called to check if the food item to be bought exists in the cart. On further inspection, on line , we see that the modifier uses the function to ensure that the property of the food item with the sku given is . Let’s check what happened in the rest of the steps in the image below: 61 buyFoodItem doesFoodItemExist 64 33 require foodItemExist true At last step on line 33 in the image above, we see that the transaction halted because the transaction failed the required condition to be able to buy a food item from the cart. The item that we wanted to buy does not exist. The function throws a exception when a condition to which it is applied to fails. A exception reverts or undoes all changes made to the state in the current call (and all its sub-calls) and also flag an error to the caller. We have been able to successfully debug this code using the Truffle Debugger, and it has been pretty amazing. require state-reverting state-reverting Invalid Transaction #2: Try to pay an amount less than the price of a food item In this transaction, we will try to buy a food item with less amount than the price of the food item. In ‘step 3: Interacting with the smart contract’, we added 3 food items. Let’s try to buy ‘Chicken Pepper Soup’ with sku and price . At the prompt, call the function to buy a food item with less amount than the price. 1 10 wei truffle(develop)> buyFoodItem truffle(develop)> buyFoodItemFromCart(1, 5); truffle(develop)> (node:40269) UnhandledPromiseRejectionWarning: Error: VM Exception while processing transaction: revert Expectedly, this transaction fails, giving a cryptic error message as usual. To debug this transaction, we go to our log terminal and copy the hash of the transaction. On my machine the transaction hash is . With this transaction hash, we shall debug the transaction and figure out where the transaction halted. 0x5dc12d3ac524cfd1e3c0ea9265a155149ff16fcb18f904016a87e83cca5f9a30 truffle(develop)> debug 0x2ad4c056a678f221d761d0bc11f641f6b4e63b3016587acd8b16ccf5295bd4d3 Like we did in the first debugging process, we will use the debugger command to step through the transactions as it is very interactive and shows all the instructions that have been executed until we reach the instruction that halted the transaction. Use to step through the transaction history until you reach the instruction that halted the transaction as shown in the image below: step next enter In the image above, we see that at line 44, the modifier is called before the function is executed, and at line 45, the modifier requires that value sent by the buyer is greater than or equal to the price of the item. However, we know that we flouted this condition hence, it halted our transaction. So if we send the right amount, we will surely buy the food item we need. hasBuyerPaidEnough buyFoodItemFromCart Conclusion In conclusion, the importance of using a debugger while building smart contracts cannot be overemphasized. With a debugger, we can test our modifiers to ensure that our contract behaves appropriately, we can ensure that our contracts are secure by sending malicious transactions to our contract to see how it will behave and properly debug the transaction to see the instructions that have been executed up until the transaction halted, if it did. Most importantly, we can save our most valuable asset which is , by using a debugger whenever we face issues with our smart contracts, instead of fumbling around with our code. time References: Truffle Debugger Debugging and Testing IntelliJ IDEA Debug Tools Originally published at www.mayowatudonu.com .
