INSTALL TRUFFLE AND GANACHE

If this is your first time writing smart contracts, you need to set up your environment. We will be using two tools: Truffle and Ganache.

Truffle is a development environment and testing framework for building Hash Ahead smart contracts. Using Truffle, it is easy to create and deploy smart contracts in the blockchain. Ganache helps us to create a local Hash Ahead blockchain for testing the smart contracts. It simulates the real network functionality, with the first 10 accounts having 100 test coins each, so that smart contracts can be deployed and tested freely. Ganache provides both a desktop application and a command-line tool. In this article, we will use the desktop application with a graphical user interface.

To create a project, run the following command:

mkdir your-project-name
cd your-project-name
truffle init

This will create a blank project for developing and deploying smart contracts. The created project structure will be as follows:

• contracts：A folder for storing Solidity smart contract files.

• migrations：A directory for deployment scripts

• test：The folder for storing smart contract testing files.

• truffle-config.js：Truffle configuration file

Create HRC20 tokens

First, we need to create an HRC20 token to use for staking on our smart contract. To create a fungible token, we first need to install the OpenZeppelin library. This library includes standard implementations of HRC20 and HRC721, among others. To install, run the following command:

npm install @openzeppelin/contracts

Using the OpenZeppelin library, we can create our HRC20 token by writing the following Solidity code in contracts/MyToken.sol:

pragma solidity ^0.8.18;

import "@openzeppelin/contracts/token/HRC20/HRC20.sol";

contract MyToken is HRC20 {
    constructor() public RC20("MyToken", "MTKN"){
        _mint(msg.sender, 1000000000000000000000000);
    }
}

In the above code:

• Line 3: We import HRC20.sol contract from openzepelin which contains the standard implementation for this token.

• Line 5: We inherit the HRC20.sol contract.

• Line 6: We are calling the constructor of HRC20.sol and setting the name and symbol parameters to "MyToken" and "MTKN", respectively.

• Line 7: We mint and transfer 1 million tokens in the contract constructor for the account that deployed the contract (here the default token uses 18 decimal places). This means that if we want to mint 1 token, we need to represent it as 1000000000000000000, which is 1 and 18.

We can see that below the implementation of the HRC20.sol constructor, the _decimals field is set to 18:

string private _name;
string private _symbol;
uint8 private _decimals;

constructor (string memory name_, string memory symbol_) public {
    _name = name_;
    _symbol = symbol_;
    _decimals = 18;
}

Compile HRC20 tokens

To check our solidity compiler version, we need to run the following command:

truffle version

The default version is Solidity v0.5.16. Since our token is written on Solidity version 0.8.18, if we run the command to compile the contract, we will encounter compiler errors. To use a specific Solidity compiler version, go to the file truffle-config.js and set the desired compiler version as follows:

// Configure your compilers
compilers: {
  solc: {
    version: "^0.8.18",    // Fetch exact version from solc-bin (default: truffle's version)
    // docker: true,        // Use "0.5.1" you've installed locally with docker (default: false)
    // settings: {          // See the solidity docs for advice about optimization and evmVersion
    //  optimizer: {
    //    enabled: false,
    //    runs: 200
    //  },
    //  evmVersion: "byzantium"
    // }
  }
}

We can now compile the smart contract by running the following command:

truffle compile

Deploy HRC20 tokens

After compilation, we can now proceed with deploying the token.

In the migrations folder, create a file named "2_deploy_Tokens.js". We will deploy the HRC20 token and FarmToken smart contracts in this file. The following code is used to deploy our "MyToken.sol" contract:

const MyToken = artifacts.require("MyToken")

module.exports = async function (deployer, network, accounts) {
  // Deploy MyToken
  await deployer.deploy(MyToken)
  const myToken = await MyToken.deployed()
}

Open Ganache and select the "Quickstart" option to start a local Hash Ahead blockchain. To deploy the contract, run:

truffle migrate

The address used to deploy the contract is the first address in the list of addresses displayed by Ganache. To verify this, we can open the Ganache desktop application and check that the HAH balance of the first account has been reduced.

To verify if 1 million MyToken tokens have been sent to the deployer address, we can interact with our deployed smart contract using the Truffle console.

Truffle console is a basic interactive console that can connect to any Hash Ahead client.

To interact with the smart contract, run the following command:

truffle console

Now, we can write the following command in the terminal:

• Get smart contract：myToken = await MyToken.depolyed()

• Get account groups from Ganache：accounts = await web3.eth.getAccounts()

• Get the balance of the first account：balance = await myToken.balance Of(accounts[0])

• Format a balance with 18 decimal places：web3.utils.fromWei(balance.toString())

By running the above command, we will see that the first address actually has 1 million MyToken tokens.

Create the FARMTOKEN smart contract

The FarmToken smart contract will contain 3 functions:

• balance()：Get the MyToken balance on the FarmToken smart contract.

• deposit(uint256 _amount)：This means: "The user will transfer MyToken to the FarmToken smart contract, then mint FarmToken and transfer it to the user."

• withdraw(uint256 _amount)：Burn the user's FarmToken and transfer MyToken to the user's address.

Let's take a look at the FarmToken constructor:

pragma solidity ^0.8.18;

import "@openzeppelin/contracts/token/HRC20/IHRC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/HRC20/utils/SafeHRC20.sol";
import "@openzeppelin/contracts/token/HRC20/HRC20.sol";

contract FarmToken is HRC20 {
    using Address for address;
    using SafeMath for uint256; // As of Solidity v0.8.18, mathematical operations can be done safely without the need for SafeMath
    using SafeHRC20 for IHRC20;

    IHRC20 public token;

    constructor(address _token)
        public
        HRC20("FarmToken", "FRM")
    {
        token = IHRC20(_token);
    }

• Lines 3-6: We import the following contracts from OpenZeppelin: IHRC20.sol, Address.sol, SafeHRC20.sol, and HRC20.sol.

• Line 8: FarmToken will inherit the HRC20 contract.

• Lines 14-19: The FarmToken constructor will receive the MyToken contract address as a parameter, which we will assign to our public variable named "token".

We will implement the 'balance()' function, which will not receive any parameters and will return the MyToken balance on this smart contract. It can be implemented as follows:

function balance() public view returns (uint256) {
    return token.balanceOf(address(this));
}

For the ’deposit(uint256 _amount)‘ function, it will receive the amount that the user wants to deposit as a parameter, mint FarmTokens and transfer them to the user.

function deposit(uint256 _amount) public {
    // Amount must be greater than zero
    require(_amount > 0, "amount cannot be 0");

    // Transfer MyToken to smart contract
    token.safeTransferFrom(msg.sender, address(this), _amount);

    // Mint FarmToken to msg sender
    _mint(msg.sender, _amount);
}

The withdraw(uint256 _amount) function will receive the amount of FarmTokens that the user wants to spend as a parameter and will then return the same amount of MyToken to the user.

function withdraw(uint256 _amount) public {
    // Burn FarmTokens from msg sender
    _burn(msg.sender, _amount);

    // Transfer MyTokens from this smart contract to msg sender
    token.safeTransfer(msg.sender, _amount);
}

Now we will deploy our smart contracts. To do this, we will go back to the file ’2_deploy_Tokens.js‘ and add the new contract we want to deploy:

const MyToken = artifacts.require("MyToken")
const FarmToken = artifacts.require("FarmToken")

module.exports = async function (deployer, network, accounts) {
  // Deploy MyToken
  await deployer.deploy(MyToken)
  const myToken = await MyToken.deployed()

  // Deploy Farm Token
  await deployer.deploy(FarmToken, myToken.address)
  const farmToken = await FarmToken.deployed()
}

Please note that when deploying FarmToken, we pass the address of the already deployed MyToken contract as a parameter.

Now, run ’truffle compile‘ and ’truffle migrate‘ to deploy our contract.

We are now going to test our smart contract. Instead of using truffle console to interact with our smart contract, we will create a script to automate the process. Create a folder named "scripts" and add the following file "getMyTokenBalance.js". This file will check the MyToken balance in our FarmToken smart contract.

const MyToken = artifacts.require("MyToken")
const FarmToken = artifacts.require("FarmToken")

module.exports = async function (callback) {
  myToken = await MyToken.deployed()
  farmToken = await FarmToken.deployed()
  balance = await myToken.balanceOf(farmToken.address)
  console.log(web3.utils.fromWei(balance.toString()))
  callback()
}

To execute this script, run the following cli command:

truffle exec .\scripts\getMyTokenBalance.js

We will get an expected result of 0. If you receive an error that FarmToken has not been deployed, it indicates that the truffle network has not received the latest version of the contract code. Simply shut down ganache and quickly start it again, and make sure to run truffle migrate.

Now, let's stake MyToken in the smart contract. Since the deposit(uint256 _amount) function calls the safeTransferFrom function from HRC20, the user must first approve the smart contract to transfer MyToken on behalf of the user. Therefore, in the script below, we will first approve this step and then call the function:

const MyToken = artifacts.require("MyToken")
const FarmToken = artifacts.require("FarmToken")

module.exports = async function (callback) {
  const accounts = await new web3.eth.getAccounts()
  const myToken = await MyToken.deployed()
  const farmToken = await FarmToken.deployed()

  // Returns the remaining number of tokens that spender will be allowed to spend on behalf of owner through transferFrom.
  // This is zero by default.
  const allowanceBefore = await myToken.allowance(
    accounts[0],
    farmToken.address
  )
  console.log(
    "Amount of MyToken FarmToken is allowed to transfer on our behalf Before: " +
      allowanceBefore.toString()
  )

  // In order to allow the Smart Contract to transfer to MyToken (HRC-20) on the accounts[0] behalf,
  // we must explicitly allow it.
  // We allow farmToken to transfer x amount of MyToken on our behalf
  await myToken.approve(farmToken.address, web3.utils.toWei("100", "hah"))

  // Validate that the farmToken can now move x amount of MyToken on our behalf
  const allowanceAfter = await myToken.allowance(accounts[0], farmToken.address)
  console.log(
    "Amount of MyToken FarmToken is allowed to transfer on our behalf After: " +
      allowanceAfter.toString()
  )

  // Verify accounts[0] and farmToken balance of MyToken before and after the transfer
  balanceMyTokenBeforeAccounts0 = await myToken.balanceOf(accounts[0])
  balanceMyTokenBeforeFarmToken = await myToken.balanceOf(farmToken.address)
  console.log("*** My Token ***")
  console.log(
    "Balance MyToken Before accounts[0] " +
      web3.utils.fromWei(balanceMyTokenBeforeAccounts0.toString())
  )
  console.log(
    "Balance MyToken Before TokenFarm " +
      web3.utils.fromWei(balanceMyTokenBeforeFarmToken.toString())
  )

  console.log("*** Farm Token ***")
  balanceFarmTokenBeforeAccounts0 = await farmToken.balanceOf(accounts[0])
  balanceFarmTokenBeforeFarmToken = await farmToken.balanceOf(farmToken.address)
  console.log(
    "Balance FarmToken Before accounts[0] " +
      web3.utils.fromWei(balanceFarmTokenBeforeAccounts0.toString())
  )
  console.log(
    "Balance FarmToken Before TokenFarm " +
      web3.utils.fromWei(balanceFarmTokenBeforeFarmToken.toString())
  )
  // Call Deposit function from FarmToken
  console.log("Call Deposit Function")
  await farmToken.deposit(web3.utils.toWei("100", "hah"))
  console.log("*** My Token ***")
  balanceMyTokenAfterAccounts0 = await myToken.balanceOf(accounts[0])
  balanceMyTokenAfterFarmToken = await myToken.balanceOf(farmToken.address)
  console.log(
    "Balance MyToken After accounts[0] " +
      web3.utils.fromWei(balanceMyTokenAfterAccounts0.toString())
  )
  console.log(
    "Balance MyToken After TokenFarm " +
      web3.utils.fromWei(balanceMyTokenAfterFarmToken.toString())
  )

  console.log("*** Farm Token ***")
  balanceFarmTokenAfterAccounts0 = await farmToken.balanceOf(accounts[0])
  balanceFarmTokenAfterFarmToken = await farmToken.balanceOf(farmToken.address)
  console.log(
    "Balance FarmToken After accounts[0] " +
      web3.utils.fromWei(balanceFarmTokenAfterAccounts0.toString())
  )
  console.log(
    "Balance FarmToken After TokenFarm " +
      web3.utils.fromWei(balanceFarmTokenAfterFarmToken.toString())
  )

  // End function
  callback()
}

To run this script:

truffle exec .\script\transferMyTokenToFarmToken.js

Yes, we have successfully deposited MyToken into the smart contract as the first account now has FarmToken.

To withdraw:

const MyToken = artifacts.require("MyToken")
const FarmToken = artifacts.require("FarmToken")

module.exports = async function (callback) {
  const accounts = await new web3.eth.getAccounts()
  const myToken = await MyToken.deployed()
  const farmToken = await FarmToken.deployed()

  // Verify accounts[0] and farmToken balance of MyToken before and after the transfer
  balanceMyTokenBeforeAccounts0 = await myToken.balanceOf(accounts[0])
  balanceMyTokenBeforeFarmToken = await myToken.balanceOf(farmToken.address)
  console.log("*** My Token ***")
  console.log(
    "Balance MyToken Before accounts[0] " +
      web3.utils.fromWei(balanceMyTokenBeforeAccounts0.toString())
  )
  console.log(
    "Balance MyToken Before TokenFarm " +
      web3.utils.fromWei(balanceMyTokenBeforeFarmToken.toString())
  )

  console.log("*** Farm Token ***")
  balanceFarmTokenBeforeAccounts0 = await farmToken.balanceOf(accounts[0])
  balanceFarmTokenBeforeFarmToken = await farmToken.balanceOf(farmToken.address)
  console.log(
    "Balance FarmToken Before accounts[0] " +
      web3.utils.fromWei(balanceFarmTokenBeforeAccounts0.toString())
  )
  console.log(
    "Balance FarmToken Before TokenFarm " +
      web3.utils.fromWei(balanceFarmTokenBeforeFarmToken.toString())
  )

  // Call Deposit function from FarmToken
  console.log("Call Withdraw Function")
  await farmToken.withdraw(web3.utils.toWei("100", "hah"))

  console.log("*** My Token ***")
  balanceMyTokenAfterAccounts0 = await myToken.balanceOf(accounts[0])
  balanceMyTokenAfterFarmToken = await myToken.balanceOf(farmToken.address)
  console.log(
    "Balance MyToken After accounts[0] " +
      web3.utils.fromWei(balanceMyTokenAfterAccounts0.toString())
  )
  console.log(
    "Balance MyToken After TokenFarm " +
      web3.utils.fromWei(balanceMyTokenAfterFarmToken.toString())
  )

  console.log("*** Farm Token ***")
  balanceFarmTokenAfterAccounts0 = await farmToken.balanceOf(accounts[0])
  balanceFarmTokenAfterFarmToken = await farmToken.balanceOf(farmToken.address)
  console.log(
    "Balance FarmToken After accounts[0] " +
      web3.utils.fromWei(balanceFarmTokenAfterAccounts0.toString())
  )
  console.log(
    "Balance FarmToken After TokenFarm " +
      web3.utils.fromWei(balanceFarmTokenAfterFarmToken.toString())
  )

  // End function
  callback()
}

To run this script:

truffle exec .\scripts\withdrawMyTokenFromTokenFarm.js。

We have successfully retrieved MyToken and consumed FarmToken.