Solidity – Passing Array of Structs to Contract with ABIEncoderV2 in Truffle

arrayssoliditystructtruffle

How do you pass an array of structs from Truffle (javascript) to a smart contract (Solidity)?

There are a few similar questions (like this one and this one) whose answers say you cannot pass a struct to a public function in solidity or are using a version of Solidity before 4.0.19. However, I'm using ABIEncoderV2, where this is not a problem.

I'm getting the following error:

Error: invalid solidity type!: tuple[]

Truffle test suite:

const foo = artifacts.require('./FOO.sol');
it('test', async () => {
    let coordsContract = await foo.new();
    const coord0 = {x: 100, y: 200};
    const coords = [coord0];
    const worked = await coordsContract.loopCoords(coords);
    assert.isTrue(worked);
});

Solidity contract:

pragma solidity ^0.4.23;
pragma experimental ABIEncoderV2;

contract FOO {
    struct Coordinates {
        uint256 x;
        uint256 y;
    }

    function loopCoords(Coordinates[] coords) public returns (bool) {
        for (uint i = 0; i < coords.length; i++) {
            //do stuff
        }
        return true;
    }
}

Best Answer

Problem is you are trying to pass javascript array coords to a solidity function loopCoords. Solidity function is not able to interpret coords as an array and it is interpreting it as a mapping.

I am not sure but I think your problem is how to pass an array as a parameter from javascript web3 to a solidity function You need to pass an argument of loopCoords as the following:

await coordsContract.loopCoords.getData(coords)

Related Solutions

solidity structs – Returning Structs in Solidity’s New Version

Yes we can return structs.

But only in internal function calls.

pragma solidity ^0.4.19;

contract tester{

struct Person
{
    string name;
    uint age;
}

function getSome() public returns (Person a)
{
    Person memory p;
    p.name = "kashish";
    p.age =20;
    return p;
}

function wantSome() public returns (string,uint)
{
     Person memory p2 =getSome();
     return (p2.name,p2.age); // return multiple values like this
}
}

Solidity Arrays – Storing a Dynamic Array of Structs Containing Dynamic Array of Structs

It worked a lot better using a mapping to store the struct.

I used user-supplied keys for random access to the mapped structs and added a list of the keys in case iteration is important.

pragma solidity 0.4.24;

contract Bounties {

    // an unordered list of keys

    bytes32[] public bountyList;

    struct Bounty {
        bool isBounty; // simple collision check
        address issuer;
        uint256 fulfillmentAmount;
        uint256 balance;
        bool bountyOpen;
        Fulfillment[] fulfillments;
        mapping (bytes32 => bool) used;
    }

    struct Fulfillment {
        uint256 fulfillmentAmount;
        address fulfiller;
    }

    // a mapping to the Bounty structs
    mapping(bytes32 => Bounty) public bountyStructs;

    function isBounty(bytes32 key) public view returns(bool isIndeed) {
        return bountyStructs[key].isBounty;
    }

    function newBounty(bytes32 key, address _issuer, uint amount) public payable returns(bool success) {
        require(!isBounty(key)); // no duplicates
        bountyList.push(key);
        bountyStructs[key].isBounty = true;
        bountyStructs[key].issuer = _issuer;
        bountyStructs[key].fulfillmentAmount = amount;
        bountyStructs[key].balance = msg.value;
        bountyStructs[key].bountyOpen = true;
        // no need to initialize the mapping
        // should emit an event here
        return true;
    }

    function appendFulfillment(bytes32 bountyKey) public payable returns(bool success) {
        require(isBounty(bountyKey));
        Fulfillment memory f;
        f.fulfillmentAmount = msg.value;
        f.fulfiller = msg.sender;
        bountyStructs[bountyKey].fulfillments.push(f);
        // should emit an event here.
        return true;
    }

}

Hope it helps.

Best Answer

Related Solutions

solidity structs – Returning Structs in Solidity’s New Version

Solidity Arrays – Storing a Dynamic Array of Structs Containing Dynamic Array of Structs

Related Topic