Solidity – How to Call a Smart Contract Function Using Web3 and Infura

infurasolidityweb3js

Imagine having the below code:

pragma solidity ^0.8.9;

contract Message {
    address myMessage;

    function setMessage() public {
        myMessage = msg.sender;
    }
}

Now i know that infura does not support eth_sendTransaction. and i know how to sign the transaction and send it using web3 library.

However my only confusion, how to make the contract call in the transaction itself? i dont want to send any value just make a contract call.

please advise

Best Answer

Using ethers, you need to create the contract using the contracts address + abi and a signer.

import <Your contract deployment address>; 
import <Your contract abi>; 
const connection = await new Web3Modal().connect(); 
const provider = new ethers.providers.Web3Provider(connection); 
const signer = provider.getSigner(); 
const contract = new Contract(contractAddress, contractAbi, signer);

You can then call the contract via :

 await contract.setMessage();

Note I used https://github.com/web3modal/web3modal here, but another way to get a signer can be found in ethers documentation.

Related Solutions

Web3JS – How to Make Smart Contract Calls Using INFURA and NodeJS

First of all INFURA does not allows to send unsigned transactions, so you have to sign them firstly and then pass them to INFURA.

To do this, you have to:

prepare the transaction
sign it
send it (using INFURA)

Please check INFURA documentation.

There is an example below:

const Web3 = require('web3')
const Tx = require('ethereumjs-tx')

// connect to Infura node
const web3 = new Web3(new Web3.providers.HttpProvider('https://mainnet.infura.io/INFURA_KEY'))

// the address that will send the test transaction
const addressFrom = '0x1889EF49cDBaad420EB4D6f04066CA4093088Bbd'
const privKey = 'PRIVATE_KEY'

// the destination address
const addressTo = '0x1463500476a3ADDa33ef1dF530063fE126203186'

// Signs the given transaction data and sends it. Abstracts some of the details 
// of buffering and serializing the transaction for web3.
function sendSigned(txData, cb) {
  const privateKey = new Buffer(config.privKey, 'hex')
  const transaction = new Tx(txData)
  transaction.sign(privateKey)
  const serializedTx = transaction.serialize().toString('hex')
  web3.eth.sendSignedTransaction('0x' + serializedTx, cb)
}

// get the number of transactions sent so far so we can create a fresh nonce
web3.eth.getTransactionCount(addressFrom).then(txCount => {

  // construct the transaction data
  const txData = {
    nonce: web3.utils.toHex(txCount),
    gasLimit: web3.utils.toHex(25000),
    gasPrice: web3.utils.toHex(10e9), // 10 Gwei
    to: addressTo,
    from: addressFrom,
    value: web3.utils.toHex(web3.utils.toWei(123, 'wei'))
  }

  // fire away!
  sendSigned(txData, function(err, result) {
    if (err) return console.log('error', err)
    console.log('sent', result)
  })

})

Solidity – Call Ethereum Smart Contract Function Using Web3.js 1.2.6

Sending a transaction without signing it first is supported only if you unlock your account on the node that you're communicating with beforehand (for example, when you run your tests on Ganache).

On public nodes, this is obviously not feasible (neither would you want it to be, of course).

You'll need to sign the transaction first, and then send the signed-transaction instead.

For example (tested with web3.js v1.2.1):

const Web3 = require("web3");

const NODE_ADDRESS = "YourNodeAddress";
const PRIVATE_KEY  = "0xYourPrivateKey";

async function scan(message) {
    process.stdout.write(message);
    return await new Promise(function(resolve, reject) {
        process.stdin.resume();
        process.stdin.once("data", function(data) {
            process.stdin.pause();
            resolve(data.toString().trim());
        });
    });
}

async function getGasPrice(web3) {
    while (true) {
        const nodeGasPrice = await web3.eth.getGasPrice();
        const userGasPrice = await scan(`Enter gas-price or leave empty to use ${nodeGasPrice}: `);
        if (/^\d+$/.test(userGasPrice))
            return userGasPrice;
        if (userGasPrice == "")
            return nodeGasPrice;
        console.log("Illegal gas-price");
    }
}

async function getTransactionReceipt(web3) {
    while (true) {
        const hash = await scan("Enter transaction-hash or leave empty to retry: ");
        if (/^0x([0-9A-Fa-f]{64})$/.test(hash)) {
            const receipt = await web3.eth.getTransactionReceipt(hash);
            if (receipt)
                return receipt;
            console.log("Invalid transaction-hash");
        }
        else if (hash) {
            console.log("Illegal transaction-hash");
        }
        else {
            return null;
        }
    }
}

async function send(web3, account, transaction) {
    while (true) {
        try {
            const options = {
                to      : transaction._parent._address,
                data    : transaction.encodeABI(),
                gas     : await transaction.estimateGas({from: account.address}),
                gasPrice: await getGasPrice(web3),
            };
            const signed  = await web3.eth.accounts.signTransaction(options, account.privateKey);
            const receipt = await web3.eth.sendSignedTransaction(signed.rawTransaction);
            return receipt;
        }
        catch (error) {
            console.log(error.message);
            const receipt = await getTransactionReceipt(web3);
            if (receipt)
                return receipt;
        }
    }
}

async function run() {
    const web3        = new Web3(NODE_ADDRESS);
    const account     = web3.eth.accounts.privateKeyToAccount(PRIVATE_KEY);
    const contract    = new web3.eth.Contract(abi, data.contractAddr);
    const transaction = contract.methods.signAgreement();
    const receipt     = await send(web3, account, transaction);
    console.log(JSON.stringify(receipt, null, 4));
    if (web3.currentProvider.constructor.name == "WebsocketProvider")
        web3.currentProvider.connection.close();
}

run();

Best Answer

Related Solutions

Web3JS – How to Make Smart Contract Calls Using INFURA and NodeJS

Solidity – Call Ethereum Smart Contract Function Using Web3.js 1.2.6

Related Topic