How to receive a value returned by a Solidity smart contract transacting function?

In Solidity smart contracts, transaction functions (which typically modify state variables) cannot directly return values to external callers because these calls are asynchronous on Ethereum. In other words, when you call a function that modifies the state, you receive only a transaction hash, not the return value of the function execution.

However, there are several ways to indirectly obtain this information:

1. Events

In Solidity, you can define events and trigger them within functions to publish return values as event parameters. External applications can listen for these events and retrieve the necessary values.

Example code:

solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ExampleContract {
    event ReturnValue(address indexed caller, uint256 indexed value);

    function set(uint _value) public {
        // Perform state-changing logic here
        emit ReturnValue(msg.sender, _value);
    }
}

In this example, whenever the set function is called, it triggers a ReturnValue event, which records the caller's address and the passed value.

2. Transaction Receipt

Although the transaction itself does not return values, you can access event logs by examining the transaction receipt after it is processed by miners and added to the blockchain. This can be achieved using frontend JavaScript libraries such as web3.js or ethers.js.

Example code (using web3.js):

javascript
const Web3 = require('web3');
const web3 = new Web3('http://localhost:8545');

const contract = new web3.eth.Contract(abi, contractAddress);
contract.methods.set(123).send({from: account})
.on('receipt', function(receipt){
    // Process the receipt here to retrieve event logs
    console.log(receipt.events.ReturnValue.returnValues);
});

This code demonstrates how to retrieve event return values by listening for the receipt after sending a transaction.

3. Calls and Transactions Separation

Sometimes, you can place the logic that needs to return values in a read-only function, separate from the actual state-modifying transaction function. First, call the read-only function to predict the result, then execute the actual transaction.

Example code:

solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract PredictionContract {
    uint public value;

    // Read-only function to predict result
    function predictNewValue(uint _increment) public view returns (uint) {
        return value + _increment;
    }

    // Actual transaction function
    function incrementValue(uint _increment) public {
        value += _increment;
    }
}

Through these methods, you can effectively retrieve the required return values or state information from Solidity smart contracts.