Solidity – How to Convert In-Memory Static Array to Calldata Static Array

arrayscalldatacontract-developmentsoliditysolidity-0.8.x

I have a contract called Erc20Recover in which I have the following function:

pragma solidity >=0.8.0;

contract Erc20Recover {
    function _setNonRecoverableTokens(IErc20[] calldata tokens) public {
        // ...
    }
}

I have another contract called HToken which inherits from Erc20Recover and in whose constructor I attempted to call _setNonRecoverableTokens:

pragma solidity >=0.8.0;

contract HToken is Erc20Recover {
    constructor(underlying) {
        IErc20[1] memory nonRecoverableTokens = [underlying];
        _setNonRecoverableTokens(nonRecoverableTokens);
    }
}

But the code does not compile:

Invalid type for argument in function call. Invalid implicit conversion from contract IErc20[1] memory to contract IErc20[] calldata requested.

How can I turn that in-memory static array into a calldata array? Or, more generally, how can I call _setNonRecoverableTokens?

For context: IErc20 is my implementation of the ERC-20 interface.

Best Answer

It's not possible to copy data from memory to calldata. Calldata, being the cheapest type of storage, is read-only and can only be used for data passed in to a function through the transaction input.

From the Solidity documentation:

As already said, the called contract (which can be the same as the caller) will receive a freshly cleared instance of memory and has access to the call payload - which will be provided in a separate area called the calldata.

As you mentioned in the comments, simply using memory instead of calldata for tokens solves the issue. If you're calling the contract through a transaction, this will simply copy the calldata to the memory.

Related Solutions

Fixing Invalid Implicit Conversion Errors from uint256 to bytes in Solidity

You are getting this error because you are trying to take the keccack256 hash of a uint, which you cannot do, according to the docs. What you must do instead is convert the uint to a bytes.

The code you want is as follows:

function random() private returns(uint){
    uint source = block.difficulty + now;
    bytes memory source_b = toBytes(source);
    return uint(keccak256(source_b));
}

function toBytes(uint256 x) public returns (bytes memory b) {
    b = new bytes(32);
    assembly { mstore(add(b, 32), x) }
}

Solidity Reference Passing – How to Pass By Reference in Solidity

When you declare a parameter as storage you are limiting the function to only accept parameters with that qualifier.

The qualifiers storage, memory and calldata specify where the data is located. You can convert implicitly storage to memory and calldata to memory, but the reverse is not possible.

string public stor = "banana";

function test(string calldata calld) external view {
    string memory memo = "pizza";

    foo(memo, stor);
    foo(calld, stor);  // Creates a copy of calld in memory and passes as parameter
    foo(stor, stor);   // Creates a copy of stor in memory and passes as parameter
    
    foo(memo, stor);
    // foo(memo, memo); // Cannot convert from memory to storage
    // foo(memo, calld); // Cannot convert from calldata to storage
}

function foo(string memory, string storage) internal view {
    
}

/* This fails because you can only use calldata on external functions
function bar(string calldata) internal view {
    
} */

Value types like bool, uintXXX, bytesYY, address, etc. are passed by value. Non-value tyeps like structs, arrays, string are passed by reference.

Functions that are public, internal and private can use types passed by reference but only if they are call from the same contract.
Functions public and external will receive a copy when called by a regular user of from another contract.

I don't know why, but at least since solc 0.3 it wasn't allowed.

Best Answer

Related Solutions

Fixing Invalid Implicit Conversion Errors from uint256 to bytes in Solidity

Solidity Reference Passing – How to Pass By Reference in Solidity

Related Topic