I see no way to obtain the return value of a non-view function (ethers.js)

Question

In a Buidler/Hardhat test I have:

const { expect } = require("chai");

describe("SumOfTokens", function() {
  it("Checks correct transfers", async function() {
    const SumOfTokens = await ethers.getContractFactory("SumOfTokens");
    const sumOfTokens = await SumOfTokens.deploy();

    await sumOfTokens.deployed();

    console.log(await sumOfTokens.newToken());
  });
});

It prints some nonsense instead of the return value (that should be 1) of the external non-view function newToken.

How to obtain the return value of newToken after its call?

Answer 1

The return value of a non-pure non-view function is available only when the function is called and validated on-chain.

When you call such function off-chain (e.g. from an ethers.js script), you need to execute it within a transaction, and the "return value" is the hash of that transaction.

This is because it is unknown when the transaction will be validated and added to the blockchain.

It used to be true that transactions could be removed from the blockchain. However, post-merge, this is no longer the case: once an epoch finalizes, it cannot be reverted.

Here's an example of how to retrieve and decode the data:

  const txData = sumOfTokens.interface.encodeFunctionData("newToken");
  const txResult = await provider.call({
    to: sumOfTokens.address,
    data: txData
  });
  const decodedResult = ethers.utils.defaultAbiCoder.decode("uint256", txResult);

Make sure to define the provider and import ethers. In this example, we assumed the returned 1 is of type 'uint256', so adjust the decoding according to the actual type.

Answer 2

While the return value of a function call executed on-chain cannot be returned off-chain, you can however simulate a function call on-chain to see what that function call would return.

In ethers, you can use callStatic. From ethers' documentation:

Rather than executing the state-change of a transaction, it is possible to ask a node to pretend that a call is not state-changing and return the result.

This does not actually change any state, but is free. This in some cases can be used to determine if a transaction will fail or succeed.

This otherwise functions the same as a Read-Only Method.

In your example, to simulate what sumOfTokens.newToken() would return if executed on-chain, you can do this:

console.log(await sumOfTokens.callStatic.newToken());

Answer 3

Here is an example using Events:

const tx = await contract.transfer(...args); // 100ms
const rc = await tx.wait(); // 0ms, as tx is already confirmed
const event = rc.events.find(event => event.event === 'Transfer');
const [from, to, value] = event.args;   
console.log(from, to, value); 

More info https://ethereum.stackexchange.com/a/119856/92472