ERC-20 Non-Upgradeable (Hardhat)
Last updated
Last updated
a.
b.
a.
b.
Create a new smart contract project using hardhat.
Install Cube3Protection
and Openzeppelin
interfaces using npm.
Now setup your CubeProtectedErc20.sol
to have a simple unprotected erc20 token implementation:
At this point, we have setup a simple ERC-20 solidity project. Most common interactions with ERC-20 are either transfer
or mint
. The next section will protect these methods using CUBE3 RASP product.
transfer
and mint
methodsImport Cube3Protection
, Ownable
and ERC20
interfaces:
Now run npx hardhat compile
to make sure it compiles successfully.
Add two new methods transferCube3Protected
and mintCube3Protected
:
Looking at our function signatures we can see that both transferCube3Protected
and mintCube3Protected
have an additional parameter called cube3SecurePayload
and uses cube3Protected
modifier, which decodes cube3SecurePayload
and reverts if it finds it malicious. We will see how to fetch the payload later.
Since transfer
is still a public function that can be accessed by anyone, we need to hide it from anyone else other than the admin (deployer) of the contract using onlyOwner
modifier (we won't need to do the same with mint
, because it is not public).
And we are done protecting our contract!
Update hardhat.config.ts file:
Add project files on tsconfig.ts:
Update scripts/deploy.ts file with the following:
Lastly, to deploy Cube3ProtectedErc20
contract, run the following in cmd:
Now since we have our contract protected and deployed, lastly we need to register it with CUBE3.
You will be prompted with the Registration form, add the information:
Give your contract a name (for example Cube3ProtectedToken
)
Add your deployed protected contract address
Select the chain you deployed your contract on
and press Add contract
Initially, your contract Integration Status
will be Pending
until we detect your contract on-chain, eventually it will process and say Not Registered
. Click on your contract to expand it:
Click Reveal Registration Token
and save it somewhere safe, we will use it in the next step.
To register your contract with CUBE3 Protocol on-chain, you will need to call registerIntegrationWithCube3
function on the CUBE3 router contract.
Your deployed contract address
Registration token (the one you saved on the previous registration step)
Function selectors that you wish to protect (you will be able to disable protection later).
To generate function selectors simply run in your console:
Add necessary information and press Write
. Make sure you do the transaction as the deployer of the contract (Admin) otherwise, it will revert.
Registration on both CUBE3 backend and CUBE3 Protocol is now done.
Go back to your RASP dashboard and you will see Integration Status
of your contract to Registered
and function protection On
. If you expand your contract you will be able to see function selectors that are protected.
At this point, you are finished and ready to do your first CUBE3 Protected transaction!
Next, we will be doing CUBE3 protected transactions to our protected smart contract.
Ideally, interacting with your protected smart contract would be in conjunction with the frontend and backend - the user presses a button (i.e. does a transaction to your protected smart contract) which initiates a backend call, frontend receives payload from it, and proceeds to submit it to the blockchain.
But for the sake of simplicity, let's just create a simple nodejs application that executes a transaction on our protected function.
cube3_transaction_executer
nodejs applicationLet's start by creating a nodejs project using typescript.
create src/index.ts
file where we will write our implementation. Initially, add this inside:
From your rasp_erc20_example_non_upgradeable_hardhat
project directory, copy out/Cube3ProtectedErc20.sol/Cube3ProtectedErc20.json
the file and paste it into cube3_transaction_executer/src
the directory. We will need to access your protected contracts ABI
.
Install CUBE3 packages:
First, import all necessary functions, Cube3ProtectedErc20
and setup constants:
The code bellow goes into generatePayload()
function.
At this point, we have an ability to call our protected contract. Let's move to payload generation.
These are the steps:
Pass it into constructCube3Validation
function which will extract the necessary data for payload generation.
In the previous step, we generated the payload for our protected mintCube3Protected
function. Now all that is left is executing the transaction on blockchain.
From the project root directory, in cmd run:
Lastly, you can analyze any protected transaction on the Panorama dashboard:
Extend our Cube3ProtectedErc20
to implement Cube3Protection
and setup the constructor (read more ).
To deploy, we are going to utilize plugin. Run the following cmd:
Head over to and click on Register your contract
For simplicity, to interact CUBE3 router contract - we suggest you to use etherscan. For example, for Sepolia - head over to and select registerIntegrationWithCube3
. You will need to provide:
cube3_transaction_executer
For blockchain interactions, we will use :
To generate a payload, you need to do an HTTP request to CUBE3 validation service. For that, we will use . Let's begin.
For CUBE3 to generate a payload, it needs transaction data. For this, we will need to create a transaction object and pass it to .
For any interaction with a smart contract, we need to create a and objects.
Before we send an HTTP request to CUBE3 validation endpoint, we need to generate transaction data without actually executing the transaction. For this, we are going to utilize ethers to create the transaction object which stores information about the transaction.
Do an HTTP request to CUBE3 validation endpoint using cube3ValidateTransaction
function, which will return us whether this transaction is safe and the payload along with other information (to learn more about what the validation service returns, read more ).
And the transaction receipt will appear. Copy the transaction hash and paste it into etherscan (for example sepolia) on which you should see a successful transaction
To learn more about the transaction dashboard, read .