Web.js
Detailed Guide by Tanssi
Web3.js is a set of libraries that allow developers to interact with Ethereum nodes using HTTP, IPC, or WebSocket protocols with JavaScript. Parodychain have an Ethereum-like API that is fully compatible with Ethereum-style JSON RPC invocations. Therefore, developers can leverage this compatibility and use the Web3.js library to interact with Parodychain node as if they were doing so on Ethereum. For more information on Web3.js, check out their documentation site.
In this guide, you'll learn how to set up the Web3.js library for Parodychain. Next, to showcase the library in action, you'll use the Web3.js library to send a transaction and deploy a contract on Parodychain.
Note
The examples in this guide are based on a MacOS or Ubuntu 20.04 environment. If you're using Windows, you'll need to adapt them accordingly.
Furthermore, please ensure that you have Node.js and a package manager (such as npm or yarn) installed. To learn how to install Node.js, please check their official documentation.
Also, make sure you've initialized a package.json
file for ES6 modules. You can initialize a default package.json
file using npm by running the following command npm init --yes
.
Checking Prerequisites
For the examples in this guide, you will need to have the following:
An account with funds in the Parodychain
Installing Web3Js
For this guide, you'll need to install the Web3.js library and the Solidity compiler. To install both NPM packages, you can run the following command:
Setting up the Web3 Provider
Throughout this guide, you'll be creating a bunch of scripts that provide different functionality such as sending a transaction, deploying a contract, and interacting with a deployed contract. In most of these scripts you'll need to create an Web3.js provider to interact with the network.
To set up a Web3 provider, you can take the following steps:
Import the
Web3
library.Create the Web3 provider and specify the RPC url. You can configure Web3.js to work with Parodychain.
Save this code snippet as you'll need it for the scripts that are used in the following sections.
Send a Transaction
During this section, you'll be creating a couple of scripts. The first one will be to check the balances of your accounts before trying to send a transaction. The second script will actually send the transaction.
You can also use the balance script to check the account balances after the transaction has been sent.
Check Balances Script
You'll only need one file to check the balances of both addresses before and after the transaction is sent. To get started, you can create a balances.js
file by running:
Next, you will create the script for this file and complete the following steps:
Set up the Web3 provider
Define the
addressFrom
andaddressTo
variablesCreate the asynchronous
balances
function which wraps theweb3.eth.getBalance
methodUse the
web3.eth.getBalance
function to fetch the balances for theaddressFrom
andaddressTo
addresses. You can also leverage theweb3.utils.fromWei
function to transform the balance into a more readable number in PDYLastly, run the
balances
function
To run the script and fetch the account balances, you can run the following command:
If successful, the balances for the origin and receiving address will be displayed in your terminal in ETH.
Send Transaction Script
You'll only need one file to execute a transaction between accounts. For this example, you'll be transferring 1 PDY token from an origin address (from which you hold the private key) to another address. To get started, you can create a transaction.js
file by running:
Next, you will create the script for this file and complete the following steps:
Set up the Web3 provider
Define the
addressFrom
, including theprivateKey
, and theaddressTo
variables. The private key is required to create a wallet instance. Note: This is for example purposes only. Never store your private keys in a JavaScript fileCreate the asynchronous
send
function, which wraps the transaction object, and the sign and send transaction functionsCreate and sign the transaction using the
web3.eth.accounts.signTransaction
function. Pass in thegas
,addressTo
, andvalue
for the transaction along with the sender'sprivateKey
Send the signed transaction using the
web3.eth.sendSignedTransaction
method and pass in the raw transaction. Then useawait
to wait until the transaction is processed and the transaction receipt is returnedLastly, run the
send
function
To run the script, you can run the following command in your terminal:
If the transaction was successful, in your terminal, you'll see the transaction hash has been printed out.
You can also use the balances.js
script to check that the balances for the origin and receiving accounts have changed. The entire workflow would look like this:
Deploy a Contract
The contract you'll be compiling and deploying in the next couple of sections is a simple incrementer contract, arbitrarily named Incrementer.sol
. You can get started by creating a file for the contract:
Next, you can add the Solidity code to the file:
The constructor
function, which runs when the contract is deployed, sets the initial value of the number variable stored on-chain (default is 0). The increment
function adds the _value
provided to the current number, but a transaction needs to be sent, which modifies the stored data. Lastly, the reset
function resets the stored value to zero.
Note
This contract is a simple example for illustration purposes only.
Compile Contract Script
In this section, you'll create a script that uses the Solidity compiler to output the bytecode and interface (ABI) for the Incrementer.sol
contract. To get started, you can create a compile.js
file by running:
Next, you will create the script for this file and complete the following steps:
Import the
fs
andsolc
packagesUsing the
fs.readFileSync
function, you'll read and save the file contents ofIncrementer.sol
tosource
Build the
input
object for the Solidity compiler by specifying thelanguage
,sources
, andsettings
to be usedUsing the
input
object, you can compile the contract usingsolc.compile
Extract the compiled contract file and export it to be used in the deployment script
Deploy Contract Script
With the script for compiling the Incrementer.sol
contract in place, you can then use the results to send a signed transaction that deploys it. To do so, you can create a file for the deployment script called deploy.js
:
Next, you will create the script for this file and complete the following steps:
Import the contract file from
compile.js
Set up the Web3 provider
Define the
addressFrom
, including theprivateKey
, and theaddressTo
variables. The private key is required to create a wallet instance. Note: This is for example purposes only. Never store your private keys in a JavaScript fileSave the
bytecode
andabi
for the compiled contractCreate the asynchronous
deploy
function that will be used to deploy the contractCreate the contract instance using the
web3.eth.Contract
functionCreate the constructor and pass in the
bytecode
and the initial value for the incrementer. For this example, you can set the initial value to5
Create and sign the transaction using the
web3.eth.accounts.signTransaction
function. Pass in thedata
and thegas
for the transaction along with the sender'sprivateKey
Send the signed transaction using the
web3.eth.sendSignedTransaction
method and pass in the raw transaction. Then useawait
to wait until the transaction is processed and the transaction receipt is returnedLastly, run the
deploy
function
To run the script, you can enter the following command into your terminal:
If successful, the contract's address will be displayed in the terminal.
Read Contract Data (Call Methods)
Call methods are the type of interactions that don't modify the contract's storage (change variables), meaning no transaction needs to be sent. They simply read various storage variables of the deployed contract.
To get started, you can create a file and name it get.js
:
Then you can take the following steps to create the script:
Import the
abi
from thecompile.js
fileSet up the Web3 provider
Create the
contractAddress
variable using the address of the deployed contractCreate an instance of the contract using the
web3.eth.Contract
function and passing in theabi
andcontractAddress
Create the asynchronous
get
functionUse the contract instance to call one of the contract's methods and pass in any inputs if necessary. For this example, you will call the
number
method, which doesn't require any inputs. You can useawait
, which will return the value requested once the request promise resolvesLastly, call the
get
function
To run the script, you can enter the following command in your terminal:
If successful, the value will be displayed in the terminal.
Interact with Contract (Send Methods)
Send methods are the type of interactions that modify the contract's storage (change variables), meaning a transaction needs to be signed and sent. In this section, you'll create two scripts: one to increment and one to reset the incrementer. To get started, you can create a file for each script and name them increment.js
and reset.js
:
Open the increment.js
file and take the following steps to create the script:
Import the
abi
from thecompile.js
fileSet up the Web3 provider
Define the
privateKey
for the origin account, thecontractAddress
of the deployed contract, and the_value
to increment by. The private key is required to create a wallet instance. Note: This is for example purposes only. Never store your private keys in a JavaScript fileCreate an instance of the contract using the
web3.eth.Contract
function and passing in theabi
andcontractAddress
Use the contract instance to build the increment transaction using the
methods.increment
function and passing in the_value
as an inputCreate the asynchronous
increment
functionUse the contract instance and the increment transaction you previously created to sign the transaction with the sender's private key. You'll use the
web3.eth.accounts.signTransaction
function and specify theto
address, thedata
, and thegas
for the transactionSend the signed transaction using the
web3.eth.sendSignedTransaction
method and pass in the raw transaction. Then useawait
to wait until the transaction is processed and the transaction receipt is returnedLastly, call the
increment
function
To run the script, you can enter the following command in your terminal:
If successful, the transaction hash will be displayed in the terminal. You can use the get.js
script alongside the increment.js
script to make sure that the value is changing as expected.
Next you can open the reset.js
file and take the following steps to create the script:
Import the
abi
from thecompile.js
fileSet up the Web3 provider
Define the
privateKey
for the origin account and thecontractAddress
of the deployed contract. The private key is required to create a wallet instance. Note: This is for example purposes only. Never store your private keys in a JavaScript fileCreate an instance of the contract using the
web3.eth.Contract
function and passing in theabi
andcontractAddress
Use the contract instance to build the reset transaction using the
methods.reset
functionCreate the asynchronous
reset
functionUse the contract instance and the reset transaction you previously created to sign the transaction with the sender's private key. You'll use the
web3.eth.accounts.signTransaction
function and specify theto
address, thedata
, and thegas
for the transactionSend the signed transaction using the
web3.eth.sendSignedTransaction
method and pass in the raw transaction. Then useawait
to wait until the transaction is processed and the transaction receipt is returnedLastly, call the
reset
function
To run the script, you can enter the following command in your terminal:
If successful, the transaction hash will be displayed in the terminal. You can use the get.js
script alongside the reset.js
script to make sure that the value is changing as expected.
Last updated