What Are Truffle Scripts and How Can We Use Them?

A powerful tool that can be used to seed your local blockchain environments

In test environments, mimicking real-life usage is vital. Imagine we’re creating a DApp that is expecting to cater to tens, hundreds, or even thousands of users. It’s very difficult to mimic that amount of usage on our local blockchain.

Truffle scripts enable us to create custom operations like this that can be called from the command line in our local test environment.

What Are They?

Truffle scripts are JavaScript files that we can create to perform a set of automated tasks. We can do pretty much anything we want inside them so long as we follow the basic structure required by Truffle to execute. Figure 1 shows this:

To run this script, we simply call truffle exec truffle-script.js inside our root directory (provided the script is also there).

Walking Through a Real-Life Example

Let’s suppose that we’ve created the smart contracts for a decentralised ERC20 token exchange where users can exchange ETH for ERC20 tokens and vice versa. In our local test environment, we can’t produce price graphs and data for the front end if there are no users, so we don’t know if it works before deploying. To imitate real usage, we need to seed the contracts in our test environment with dummy data. We can do this with Truffle scripts.

Figure 2 shows us the function definitions for the Exchange contract we’ve created. The implementation is hidden for the sake of simplicity:

We need an easy way to fill our exchange with dummy data so that we can make sure our interface works correctly. For this, we create a seed script.

In our root folder, we create a new directory called scripts. Then we create a new file called seed-exchange.js, copying the code from Figure 1 into it. Let’s test that the script works before continuing. We console log inside the script, as shown in Figure 3, and run truffle exec scripts/seed-exchange.js from the project root in our terminal:

We should see “IT WORKS” appearing in the output.

Depositing, making, and filling orders

The next step is to imitate the actions of users should they decide to trade on our exchange. Using the function definitions from Figure 2, we are going to use accounts provided by our local test environment (Ganache) to deposit funds, then make and fill orders.

There is a little bit of “magic” that Truffle performs under the hood for scripts to work. For our exchange, we need to load the contract instance into memory, which means we need the compiled contract ABI. This is made available to us using the keyword artifacts:

Let’s break down the current state of our script in Figure 4:

• Line 2: Use the artifacts keyword to retrieve the compiled Exchange contract.
• Line 5: A helper function we can use to convert units of ETH into units of Wei.
• Line 11: The entry point to our Truffle script.
• Line 14: Retrieve the accounts available to us.
• Line 17: Create a local instance of our Exchange contract so we can submit transactions to it.
• Line 25: Deposit 2 ETH from user1 to the Exchange.

By running truffle exec scripts/seed-exchange.js, we can see that our script runs as expected and user1 has deposited 2 ETH.

Next Steps

Given that we have a script that begins to mimic real-life usage, see if you can expand on it to mimic order creation, order filling, and withdrawals. Use multiple users from accounts and loops to seed more than one order. Start coding from Line 28 where the //… comment is.

Good luck!

Further Reading

If you’re interested in blockchain development, I write tutorials, walkthroughs, hints, and tips on how to get started and build a portfolio. Check out some of these resources: