Ethers.js Solidity – How to Read Public Variable from Contract

dapp-developmentdappsethers.jssolidity

I am trying to read public variable from contract on chain using ethers.js.

Calling the methods work but I could not manage to read public property (without getter).

The methods works like this:

const ethers = require('ethers');
const provider = new ethers.providers.JsonRpcProvider('https://bsc-dataseed1.binance.org:443');

const contract = new ethers.Contract(address, [
    'function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256)',
], provider);

let works = await contract.getMultiplier(5, 10);

However, if I try accessing public property, it doesn't work. In fact, I receive error with the ABI.

const contract = new ethers.Contract(address, [
    'uint256 public totalAllocPoint',
    'PoolInfo[] public poolInfo'
], provider);

Error: unsupported fragment (argument="value", value="uint256 public totalAllocPoint", code=INVALID_ARGUMENT, version=abi/5.2.0)

poolInfo is even different because it needs a parameter.

How can I read totalAllocPoint and poolInfo from the contract?

Shouldn't it be like something like this:

let x = await contract.totalAllocPoint;
let y = await contract.poolInfo(2);

In the docs, unfortunately it only shows how to access methods

Best Answer

actually in solidity docs it's pointing that for each public member variable there will be a getter is defined automatically. In short you'll be able to get basic type public member like this: let x = await contract.totalAllocPoint(); you've been missing parenthesis here.

While you can get array like: let y = await contract.poolInfo(2); if the array length is more than 3 in this case of course.

For mapping types

mapping (address => mapping(uint256 => Order)) public orderByAssetId;
await contract.orderByAssetId(address, id);

To explain it more, if you look into ABI generated from compiling your solidity contract you should be able to see like this:

Defined contract in solidity

contract MasterChef {
...
  uint256 public totalAllocPoint = 0;
...
}

equals to ABI

  {
    "inputs": [],
    "name": "totalAllocPoint",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },

Keep on coding !

With Human-Readable ABI of ethers.js

const contract = new ethers.Contract(contractAddress, [
   'function totalAllocPoint() public view returns (uint256)'
], provider)

await contract.totalAllocPoint()

Related Solutions

Solidity – Accessing Public Variable from Another Contract

You can use the following Code for it:

pragma solidity ^0.4.18;

contract Test {
    uint256 public val = 256;
}


contract Other {

    Test testContract;

    function setAddress(address _address) {
        testContract = Test(_address);            
    }    

    function getVal() constant public returns (uint256) {
        return testContract.val();
    }
}

You need to define a variable which is of type Test. Than you can get the value of val by calling its getter function val() which is automatically generated due to the public keyword.

EDIT:

If you want to make variable val private and only accessible for the Other contract you should provide a getter function like the following:

function getVal() public returns (uint) {
    return val;
}

Now you can set the permissions for getVal() so that only addresses who may access val will have permissions to read it.

Hope it helps.

EDIT 2:

This is a complete code snippet for keeping the variable val private and only allow Other contract to read it:

pragma solidity ^0.4.18;

contract Test {

    address owner;
    uint256 val = 256;
    address otherContract;

    function Test(){
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    modifier onlyOtherContract() {
        require(msg.sender == otherContract);
        _;
    }

    function setOtherContract(address _otherContract) onlyOwner {
        otherContract = _otherContract;
    }

    function getVal() onlyOtherContract returns (uint) {
        return val;
    }
}


contract Other {

    Test testContract;

    function setAddress(address _address) {
        testContract = Test(_address);            
    }    

    function getVal() constant public returns (uint256) {
        return testContract.getVal();
    }
}

Try the following steps:

Deploy Test contract
Deploy Other contract
Set testContract in Other contract with the setAddress function
Set the otherContract variable in the Test contract with the setOtherContract function
Call the getVal function in the Other contract.

Now you can also try to call the getVal function in the Test contract directly and you will see, that your call is reverted. This is because after step 4 only the Other contract is allowed to call getVal.

Kind regards

Ethers.js – Recover Public Key from Contract Deployment via v,r,s Values

This is solved now. There was a tiny bug in the code and in the ethers library that would not correctly return the chainId and calculate the v value. It's fixed now, see here. Many thanks to ricmoo for helping out.

I wrote a gist that correctly recovers the public key given the transaction.

In short:

const tx = await provider.getTransaction(...)
const expandedSig = {
  r: tx.r,
  s: tx.s,
  v: tx.v
}
const signature = ethers.utils.joinSignature(expandedSig)
const txData = {
  gasPrice: tx.gasPrice,
  gasLimit: tx.gasLimit,
  value: tx.value,
  nonce: tx.nonce,
  data: tx.data,
  chainId: tx.chainId,
  to: tx.to // you might need to include this if it's a regular tx and not simply a contract deployment
}
const rsTx = await ethers.utils.resolveProperties(txData)
const raw = ethers.utils.serializeTransaction(rsTx) // returns RLP encoded tx
const msgHash = ethers.utils.keccak256(raw) // as specified by ECDSA
const msgBytes = ethers.utils.arrayify(msgHash) // create binary hash
const recoveredPubKey = ethers.utils.recoverPublicKey(msgBytes, signature)
const recoveredAddress = ethers.utils.recoverAddress(msgBytes, signature)

Best Answer

Related Solutions

Solidity – Accessing Public Variable from Another Contract

Ethers.js – Recover Public Key from Contract Deployment via v,r,s Values

Related Topic