Introduction¶
Web3.js is a set of libraries that allow developers to interact with Ethereum nodes using HTTP, IPC, or WebSocket protocols with JavaScript. Moonbeam has an Ethereum-like API available 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 a Moonbeam node as if they were doing so on Ethereum.
In this guide, you'll learn how to use the Web3.js library to send a transaction and deploy a contract on Moonbase Alpha. This guide can be adapted for Moonbeam, Moonriver, or a Moonbeam development node.
Checking Prerequisites¶
For the examples in this guide, you will need to have the following:
- An account with funds. You can get DEV tokens for testing on Moonbase Alpha once every 24 hours from the Moonbase Alpha Faucet
- To test out the examples in this guide on Moonbeam or Moonriver, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers
Note
The examples in this guide assume you have a MacOS or Ubuntu 22.04-based environment and will need to be adapted accordingly for Windows.
Installing Web3.js¶
To get started, you'll need to start a basic JavaScript project. First, create a directory to store all of the files you'll be creating throughout this guide, and initialize the project with the following command:
mkdir web3-examples && cd web3-examples && npm init --y
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:
npm install web3 solc@0.8.0
yarn add web3 solc@0.8.0
Setup Web3.js with Moonbeam¶
You can configure Web3.js to work with any of the Moonbeam networks. To configure your project for Moonbeam or Moonriver, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers.
The simplest way to get started with each of the networks is as follows:
const { Web3 } = require('web3');// Create Web3 instanceconst web3 = new Web3('INSERT_RPC_API_ENDPOINT'); // Insert your RPC URL here
const { Web3 } = require('web3');// Create Web3 instanceconst web3 = new Web3('INSERT_RPC_API_ENDPOINT'); // Insert your RPC URL here
const { Web3 } = require('web3');// Create Web3 instanceconst web3 = new Web3('https://rpc.api.moonbase.moonbeam.network');
const { Web3 } = require('web3');// Create Web3 instanceconst web3 = new Web3('http://127.0.0.1:9944');
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:
touch balances.js
Next, you will create the script for this file and complete the following steps:
- Set up the Web3 provider
- Define the
addressFrom
andaddressTo
variables - Create the asynchronous
balances
function, which wraps theweb3.eth.getBalance
method - Use 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 DEV - Lastly, run the
balances
function
// 1. Add the Web3 provider logic// {...}// 2. Create address variablesconst addressFrom = 'INSERT_FROM_ADDRESS';const addressTo = 'INSERT_TO_ADDRESS';// 3. Create balances functionconst balances = async () => { // 4. Fetch balance info const balanceFrom = web3.utils.fromWei( await web3.eth.getBalance(addressFrom), 'ether' ); const balanceTo = web3.utils.fromWei( await web3.eth.getBalance(addressTo), 'ether' ); console.log(`The balance of ${addressFrom} is: ${balanceFrom} DEV`); console.log(`The balance of ${addressTo} is: ${balanceTo} DEV`);};// 5. Call balances functionbalances();
View the complete script
const { Web3 } = require('web3');// 1. Add the Web3 provider logic here:const providerRPC = { development: 'http://localhost:9944', moonbase: 'https://rpc.api.moonbase.moonbeam.network',};const web3 = new Web3(providerRPC.moonbase); // Change to correct network// 2. Create address variablesconst addressFrom = 'INSERT_FROM_ADDRESS';const addressTo = 'INSERT_TO_ADDRESS';// 3. Create balances functionconst balances = async () => { // 4. Fetch balance info const balanceFrom = web3.utils.fromWei(await web3.eth.getBalance(addressFrom), 'ether'); const balanceTo = web3.utils.fromWei(await web3.eth.getBalance(addressTo), 'ether'); console.log(`The balance of ${addressFrom} is: ${balanceFrom} DEV`); console.log(`The balance of ${addressTo} is: ${balanceTo} DEV`);};// 5. Call balances functionbalances();
To run the script and fetch the account balances, you can run the following command:
node balances.js
If successful, the balances for the origin and receiving address will be displayed in your terminal in DEV.
Send Transaction Script¶
You'll only need one file to execute a transaction between accounts. For this example, you'll be transferring 1 DEV 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:
touch transaction.js
Next, you will create the script for this file and complete the following steps:
- Set up the Web3 provider
- Define the
accountFrom
, 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 file - Create the asynchronous
send
function, which wraps the transaction object, and the sign and send transaction functions - Create and sign the transaction using the
web3.eth.accounts.signTransaction
function. Pass in thegas
,addressTo
,value
,gasPrice
, andnonce
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 returned - Lastly, run the
send
function
// 1. Add the Web3 provider logic// {...}// 2. Create account variablesconst accountFrom = { privateKey: 'INSERT_YOUR_PRIVATE_KEY', address: 'INSERT_PUBLIC_ADDRESS_OF_PK',};const addressTo = 'INSERT_TO_ADDRESS'; // Change addressTo// 3. Create send functionconst send = async () => { console.log( `Attempting to send transaction from ${accountFrom.address} to ${addressTo}` ); // 4. Sign transaction with PK const createTransaction = await web3.eth.accounts.signTransaction( { gas: 21000, to: addressTo, value: web3.utils.toWei('1', 'ether'), gasPrice: await web3.eth.getGasPrice(), nonce: await web3.eth.getTransactionCount(accountFrom.address), }, accountFrom.privateKey ); // 5. Send transaction and wait for receipt const createReceipt = await web3.eth.sendSignedTransaction( createTransaction.rawTransaction ); console.log( `Transaction successful with hash: ${createReceipt.transactionHash}` );};// 6. Call send functionsend();
View the complete script
const { Web3 } = require('web3');// 1. Add the Web3 provider logicconst providerRPC = { development: 'http://localhost:9944', moonbase: 'https://rpc.api.moonbase.moonbeam.network',};const web3 = new Web3(providerRPC.moonbase); // Change to correct network// 2. Create account variablesconst accountFrom = { privateKey: 'INSERT_YOUR_PRIVATE_KEY', address: 'INSERT_PUBLIC_ADDRESS_OF_PK',};const addressTo = 'INSERT_TO_ADDRESS';// 3. Create send functionconst send = async () => { console.log( `Attempting to send transaction from ${accountFrom.address} to ${addressTo}` ); // 4. Sign transaction with PK const createTransaction = await web3.eth.accounts.signTransaction( { gas: 21000, to: addressTo, value: web3.utils.toWei('1', 'ether'), gasPrice: await web3.eth.getGasPrice(), nonce: await web3.eth.getTransactionCount(accountFrom.address), }, accountFrom.privateKey ); // 5. Send transaction and wait for receipt const createReceipt = await web3.eth.sendSignedTransaction( createTransaction.rawTransaction ); console.log( `Transaction successful with hash: ${createReceipt.transactionHash}` );};// 6. Call send functionsend();
To run the script, you can run the following command in your terminal:
node transaction.js
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:
node balances.js The balance of 0x3B939FeaD1557C741Ff06492FD0127bd287A421e is: 3603.67979115380310679 DEV The balance of 0xe29A0699e079FeBEe94A02f35C31B026f90F6040 is: 0. DEV node transaction.js Attempting to send transaction from 0x3B939FeaD1557C741Ff06492FD0127bd287A421e to 0xe29A0699e079FeBEe94A02f35C31B026f90F6040 Transaction successful with hash: 0xf1d628ed12c5f40e03e29aa2c23c8c09680ee595c60607c7363a81c0be8ef3cb node balances.js The balance of 0x3B939FeaD1557C741Ff06492FD0127bd287A421e is: 3602.67978852880310679 DEV The balance of 0xe29A0699e079FeBEe94A02f35C31B026f90F6040 is: 1 DEV
Common Errors When Sending Transactions¶
When sending a transaction with Web3.js, it is important that you have all of the required data for the transaction. You'll need to provide the from
address or the nonce
of the sender, the gas
or gasLimit
, and the gasPrice
.
If you do not specify the from
address or the nonce
of the sender, you may receive the following error:
UnableToPopulateNonceError: Invalid value given "UnableToPopulateNonceError". Error: unable to populate nonce, no from address available.
To fix this, simply add either the from
or nonce
field to the transaction object.
If you do not specify the gas correctly, you may receive the following error:
MissingGasError: Invalid value given "gas: 0x5208, gasPrice: undefined, maxPriorityFeePerGas: undefined, maxFeePerGas: undefined". Error: "gas" is missing.
To resolve this error, you'll need to make sure that you've provided a gasPrice
for the transaction. You can use await web3.eth.getGasPrice()
to programmatically get this value.
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:
touch Incrementer.sol
Next, you can add the Solidity code to the file:
// SPDX-License-Identifier: MITpragma solidity ^0.8.0;contract Incrementer { uint256 public number; constructor(uint256 _initialNumber) { number = _initialNumber; } function increment(uint256 _value) public { number = number + _value; } function reset() public { number = 0; }}
The constructor
function, which runs when the contract is deployed, sets the initial value of the number variable stored on-chain (the 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 and does not handle values wrapping around.
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:
touch compile.js
- Import the
fs
andsolc
packages - Using 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 used - Using 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
// 1. Import packagesconst fs = require('fs');const solc = require('solc');// 2. Get path and load contractconst source = fs.readFileSync('Incrementer.sol', 'utf8');// 3. Create input objectconst input = { language: 'Solidity', sources: { 'Incrementer.sol': { content: source, }, }, settings: { outputSelection: { '*': { '*': ['*'], }, }, },};// 4. Compile the contractconst tempFile = JSON.parse(solc.compile(JSON.stringify(input)));const contractFile = tempFile.contracts['Incrementer.sol']['Incrementer'];// 5. Export contract datamodule.exports = contractFile;
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
:
touch 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
accountFrom
, 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 file - Save the
bytecode
andabi
for the compiled contract - Create the asynchronous
deploy
function that will be used to deploy the contract - Create the contract instance using the
web3.eth.Contract
function - Create 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
,gas
,gasPrice
, andnonce
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 returned - Lastly, run the
deploy
function
// 1. Import the contract fileconst contractFile = require('./compile');// 2. Add the Web3 provider logic// {...}// 3. Create address variablesconst accountFrom = { privateKey: 'INSERT_YOUR_PRIVATE_KEY', address: 'INSERT_PUBLIC_ADDRESS_OF_PK',};// 4. Get the bytecode and APIconst bytecode = contractFile.evm.bytecode.object;const abi = contractFile.abi;// 5. Create deploy functionconst deploy = async () => { console.log(`Attempting to deploy from account ${accountFrom.address}`); // 6. Create contract instance const incrementer = new web3.eth.Contract(abi); // 7. Create constructor transaction const incrementerTx = incrementer.deploy({ data: bytecode, arguments: [5], }); // 8. Sign transaction with PK const createTransaction = await web3.eth.accounts.signTransaction( { data: incrementerTx.encodeABI(), gas: await incrementerTx.estimateGas(), gasPrice: await web3.eth.getGasPrice(), nonce: await web3.eth.getTransactionCount(accountFrom.address), }, accountFrom.privateKey ); // 9. Send transaction and wait for receipt const createReceipt = await web3.eth.sendSignedTransaction( createTransaction.rawTransaction ); console.log(`Contract deployed at address: ${createReceipt.contractAddress}`);};// 10. Call deploy functiondeploy();
View the complete script
// 1. Import web3 and the contract fileconst { Web3 } = require('web3');const contractFile = require('./compile');// 2. Add the Web3 provider logicconst providerRPC = { development: 'http://localhost:9944', moonbase: 'https://rpc.api.moonbase.moonbeam.network',};const web3 = new Web3(providerRPC.moonbase); // Change to correct network// 3. Create address variablesconst accountFrom = { privateKey: 'INSERT_YOUR_PRIVATE_KEY', address: 'INSERT_PUBLIC_ADDRESS_OF_PK',};// 4. Get the bytecode and APIconst bytecode = contractFile.evm.bytecode.object;const abi = contractFile.abi;// 5. Create deploy functionconst deploy = async () => { console.log(`Attempting to deploy from account ${accountFrom.address}`); // 6. Create contract instance const incrementer = new web3.eth.Contract(abi); // 7. Create constructor transaction const incrementerTx = incrementer.deploy({ data: bytecode, arguments: [5], }); // 8. Sign transaction with PK const createTransaction = await web3.eth.accounts.signTransaction( { data: incrementerTx.encodeABI(), gas: await incrementerTx.estimateGas(), gasPrice: await web3.eth.getGasPrice(), nonce: await web3.eth.getTransactionCount(accountFrom.address), }, accountFrom.privateKey ); // 9. Send transaction and wait for receipt const createReceipt = await web3.eth.sendSignedTransaction( createTransaction.rawTransaction ); console.log(`Contract deployed at address: ${createReceipt.contractAddress}`);};// 10. Call deploy functiondeploy();
To run the script, you can enter the following command into your terminal:
node deploy.js
If successful, the contract's address will be displayed in the terminal.
node deploy.js Attempting to deploy from account 0x3B939FeaD1557C741Ff06492FD0127bd287A421e Contract deployed at address: 0x6dcb33a7f6235e74fd553b50c96f900707142892
Read Contract Data (Call Methods)¶
Call methods are the type of interaction that doesn'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
:
touch get.js
Then you can take the following steps to create the script:
- Import the
abi
from thecompile.js
file - Set up the Web3 provider
- Create the
contractAddress
variable using the address of the deployed contract - Create an instance of the contract using the
web3.eth.Contract
function and passing in theabi
andcontractAddress
- Create the asynchronous
get
function - Use 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 resolves - Lastly, call the
get
function
// 1. Import the contract ABIconst { abi } = require('./compile');// 2. Add the Web3 provider logic// {...}// 3. Create address variablesconst contractAddress = 'INSERT_CONTRACT_ADDRESS';// 4. Create contract instanceconst incrementer = new web3.eth.Contract(abi, contractAddress);// 5. Create get functionconst get = async () => { console.log(`Making a call to contract at address: ${contractAddress}`); // 6. Call contract const data = await incrementer.methods.number().call(); console.log(`The current number stored is: ${data}`);};// 7. Call get functionget();
View the complete script
// 1. Import Web3js and the contract ABIconst { Web3 } = require('web3');const { abi } = require('./compile');// 2. Add the Web3 provider logicconst providerRPC = { development: 'http://localhost:9944', moonbase: 'https://rpc.api.moonbase.moonbeam.network',};const web3 = new Web3(providerRPC.moonbase); // Change to correct network// 3. Create address variablesconst contractAddress = 'INSERT_CONTRACT_ADDRESS';// 4. Create contract instanceconst incrementer = new web3.eth.Contract(abi, contractAddress);// 5. Create get functionconst get = async () => { console.log(`Making a call to contract at address: ${contractAddress}`); // 6. Call contract const data = await incrementer.methods.number().call(); console.log(`The current number stored is: ${data}`);};// 7. Call get functionget();
To run the script, you can enter the following command in your terminal:
node get.js
If successful, the value will be displayed in the terminal.
Interact with Contract (Send Methods)¶
Send methods are the type of interaction that modifies 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
:
touch increment.js reset.js
Open the increment.js
file and take the following steps to create the script:
- Import the
abi
from thecompile.js
file - Set 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 file - Create 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 input - Create the asynchronous
increment
function - Use 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,data
,gas
,gasPrice
, andnonce
for the transaction - 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 returned - Lastly, call the
increment
function
// 1. Import the contract ABIconst { abi } = require('./compile');// 2. Add the Web3 provider logic// {...}// 3. Create variablesconst accountFrom = { privateKey: 'INSERT_YOUR_PRIVATE_KEY', address: 'INSERT_PUBLIC_ADDRESS_OF_PK',};const contractAddress = 'INSERT_CONTRACT_ADDRESS';const _value = 3;// 4. Create contract instanceconst incrementer = new web3.eth.Contract(abi, contractAddress);// 5. Build the increment transactionconst incrementTx = incrementer.methods.increment(_value);// 6. Create increment functionconst increment = async () => { console.log( `Calling the increment by ${_value} function in contract at address: ${contractAddress}` ); // 7. Sign transaction with PK const createTransaction = await web3.eth.accounts.signTransaction( { to: contractAddress, data: incrementTx.encodeABI(), gas: await incrementTx.estimateGas(), gasPrice: await web3.eth.getGasPrice(), nonce: await web3.eth.getTransactionCount(accountFrom.address), }, accountFrom.privateKey ); // 8. Send transaction and wait for receipt const createReceipt = await web3.eth.sendSignedTransaction( createTransaction.rawTransaction ); console.log(`Tx successful with hash: ${createReceipt.transactionHash}`);};// 9. Call increment functionincrement();
View the complete script
// 1. Import Web3js and the contract ABIconst { Web3 } = require('web3');const { abi } = require('./compile');// 2. Add the Web3 provider logicconst providerRPC = { development: 'http://localhost:9944', moonbase: 'https://rpc.api.moonbase.moonbeam.network',};const web3 = new Web3(providerRPC.moonbase); // Change to correct network// 3. Create variablesconst accountFrom = { privateKey: 'INSERT_YOUR_PRIVATE_KEY', address: 'INSERT_PUBLIC_ADDRESS_OF_PK',};const contractAddress = 'INSERT_CONTRACT_ADDRESS';const _value = 3;// 4. Create contract instanceconst incrementer = new web3.eth.Contract(abi, contractAddress);// 5. Build increment transactionconst incrementTx = incrementer.methods.increment(_value);// 6. Create increment functionconst increment = async () => { console.log( `Calling the increment by ${_value} function in contract at address: ${contractAddress}` ); // 7. Sign transaction with PK const createTransaction = await web3.eth.accounts.signTransaction( { to: contractAddress, data: incrementTx.encodeABI(), gas: await incrementTx.estimateGas(), gasPrice: await web3.eth.getGasPrice(), nonce: await web3.eth.getTransactionCount(accountFrom.address), }, accountFrom.privateKey ); // 8. Send transaction and wait for receipt const createReceipt = await web3.eth.sendSignedTransaction( createTransaction.rawTransaction ); console.log(`Tx successful with hash: ${createReceipt.transactionHash}`);};// 9. Call increment functionincrement();
To run the script, you can enter the following command in your terminal:
node increment.js
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 value is changing as expected:
node get.js Making a call to contract at address: 0x6dcb33a7f6235e74fd553b50c96f900707142892 The current number stored is: 5 node increment.js Calling the increment by 3 function in contract at address: 0x6dcb33a7f6235e74fd553b50c96f900707142892 Tx successful with hash: 0xb03d1426376e7efc49d8b6c69aaf91e548578db7fd4a9ba575dbd8030821f6a3 node get.js Making a call to contract at address: 0x6dcb33a7f6235e74fd553b50c96f900707142892 The current number stored is: 8
Next, you can open the reset.js
file and take the following steps to create the script:
- Import the
abi
from thecompile.js
file - Set 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 file - Create 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
function - Create the asynchronous
reset
function - Use 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,data
,gas
,gasPrice
, andnonce
for the transaction - 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 returned - Lastly, call the
reset
function
// 1. Import the contract ABIconst { abi } = require('./compile');// 2. Add the Web3 provider logic// {...}// 3. Create variablesconst accountFrom = { privateKey: 'INSERT_YOUR_PRIVATE_KEY', address: 'INSERT_PUBLIC_ADDRESS_OF_PK',};const contractAddress = 'INSERT_CONTRACT_ADDRESS';// 4. Create a contract instanceconst incrementer = new web3.eth.Contract(abi, contractAddress);// 5. Build reset transactionconst resetTx = incrementer.methods.reset();// 6. Create reset functionconst reset = async () => { console.log( `Calling the reset function in contract at address: ${contractAddress}` ); // 7. Sign transaction with PK const createTransaction = await web3.eth.accounts.signTransaction( { to: contractAddress, data: resetTx.encodeABI(), gas: await resetTx.estimateGas(), gasPrice: await web3.eth.getGasPrice(), nonce: await web3.eth.getTransactionCount(accountFrom.address), }, accountFrom.privateKey ); // 8. Send transaction and wait for receipt const createReceipt = await web3.eth.sendSignedTransaction( createTransaction.rawTransaction ); console.log(`Tx successful with hash: ${createReceipt.transactionHash}`);};// 9. Call reset functionreset();
View the complete script
// 1. Import Web3js and the contract ABIconst { Web3 } = require('web3');const { abi } = require('./compile');// 2. Add the Web3 provider logicconst providerRPC = { development: 'http://localhost:9944', moonbase: 'https://rpc.api.moonbase.moonbeam.network',};const web3 = new Web3(providerRPC.moonbase); // Change to correct network// 3. Create variablesconst accountFrom = { privateKey: 'INSERT_YOUR_PRIVATE_KEY', address: 'INSERT_PUBLIC_ADDRESS_OF_PK',};const contractAddress = 'INSERT_CONTRACT_ADDRESS';// 4. Create contract instanceconst incrementer = new web3.eth.Contract(abi, contractAddress);// 5. Build reset transactionconst resetTx = incrementer.methods.reset();// 6. Create reset functionconst reset = async () => { console.log(`Calling the reset function in contract at address: ${contractAddress}`); // 7. Sign transaction with PK const createTransaction = await web3.eth.accounts.signTransaction( { to: contractAddress, data: resetTx.encodeABI(), gas: await resetTx.estimateGas(), gasPrice: await web3.eth.getGasPrice(), nonce: await web3.eth.getTransactionCount(accountFrom.address), }, accountFrom.privateKey ); // 8. Send transaction and wait for receipt const createReceipt = await web3.eth.sendSignedTransaction(createTransaction.rawTransaction); console.log(`Tx successful with hash: ${createReceipt.transactionHash}`);};// 9. Call reset functionreset();
To run the script, you can enter the following command in your terminal:
node reset.js
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 value is changing as expected:
node get.js Making a call to contract at address: 0x6dcb33a7f6235e74fd553b50c96f900707142892 The current number stored is: 8 node reset.js Calling the reset function in contract at address: 0x6dcb33a7f6235e74fd553b50c96f900707142892 Tx successful with hash: 0x557e908ca4da05d5af50983dbc116fbf8049bb2e86b9ec1e9f7d3f516b8a4c55 node get.js Making a call to contract at address: 0x6dcb33a7f6235e74fd553b50c96f900707142892 The current number stored is: 0
The information presented herein has been provided by third parties and is made available solely for general information purposes. Moonbeam does not endorse any project listed and described on the Moonbeam Doc Website (https://docs.moonbeam.network/). Moonbeam Foundation does not warrant the accuracy, completeness or usefulness of this information. Any reliance you place on such information is strictly at your own risk. Moonbeam Foundation disclaims all liability and responsibility arising from any reliance placed on this information by you or by anyone who may be informed of any of its contents. All statements and/or opinions expressed in these materials are solely the responsibility of the person or entity providing those materials and do not necessarily represent the opinion of Moonbeam Foundation. The information should not be construed as professional or financial advice of any kind. Advice from a suitably qualified professional should always be sought in relation to any particular matter or circ*mstance. The information herein may link to or integrate with other websites operated or content provided by third parties, and such other websites may link to this website. Moonbeam Foundation has no control over any such other websites or their content and will have no liability arising out of or related to such websites or their content. The existence of any such link does not constitute an endorsem*nt of such websites, the content of the websites, or the operators of the websites. These links are being provided to you only as a convenience and you release and hold Moonbeam Foundation harmless from any and all liability arising from your use of this information or the information provided by any third-party website or service.
Last update: July 30, 2024
| Created: March 1, 2022