Solidity – How to Return an Array of Structs Using Events?

arrayscontract-designeventsstoragestruct

I wan’t my function to spit out an array of structs. I know this is not straightforwardly possible. What is the best way for me to proceed? Should I loop through my array in my function and trigger an event each time to return the arguments of each struct separately? Should I create a large json object by looping through my array and spit it out as a string? Is there a more straightforward way of doing this?

Best Answer

I'm going to suggest a more ethereum-like approach.

You can probably do that with the experimental ABI encoder. As well as stability concerns, there is a serious problem with overall approach. The gas cost of the operation will increase with the size of the array. That will make it impractical or impossible to use if the array grows too large.

In most cases, returning the whole array is wasteful and redundant. You can, and should, emit events for each state change. This means observers, clients and servers, can know the state of the array without even asking. It mitigates the need to return the whole array in most cases.

There are cases where a client or a contract would want to know the contents of an element. An element can be returned in a function with O(1) complexity and a consistent gas cost at any scale, so that's what we should do.

Clients may wish to iterate (for whatever reason). However, the chore of iterating can usually be externalized. Let the client call the O(1) function as many times as necessary. Remember, the blockchain is the source of truth and the evidence of data integrity. It is not a general-purpose computing platform and processing is costly.

The stable ABI can pass structs in/out of functions internally but not externally. Externally, we break the struct down into members.

Storage organization is a challenge, so this might be helpful: Are there well-solved and simple storage patterns for Solidity?

Going with the simplest array idea, I came up with this little example that expresses the suggested approach.

pragma solidity 0.5.1;

contract ArrayOfStructs {

    // just an arbitrary struct layout

    struct Thing {
        uint a;
        bool b;
    }

    // an array of structs

    Thing[] public things; 

    event LogAppendThing(address sender, uint a, bool b);

    // set

    function append(uint _a, bool _b) public {
        Thing memory t = Thing({
            a: _a,
            b: _b
        });
        things.push(t);

        // emit an event

        emit LogAppendThing(msg.sender, _a, _b);
    }

    // "public" in line 14 gives a "free" getter, like

    /*
    function things(uint index) public view returns(uint, bool) {
        return (things[index].a, things[index].b);
    }
    */

    // it can be helpful to give a client a count, so it can know the boundary.

    function thingCount() public view returns(uint count) {
        return things.length;
    }
}

Hope it helps.

Related Solutions

[Ethereum] How to serialize an array of strings in Solidity

This is not going to work in Solidity. The += operator is not implemented for strings, you need to use a library that allows to concatenate strings; I think the most popular is this one. There is an example of how to use concatenation here.

I'm not sure what you're trying to do, but that kind of concatenation is expensive. Wouldn't it be enough to have two methods:

getStringsLength() returns (uint) and getStringByIndex(uint index) returns (string), and retrieve the strings in a loop? You can then do the concatenation outside of the contract (probably cheaper).

Solidity:

string[] myArray;

function getStringsLength() returns (uint) {
    return myArray.length;
}

function getStringByIndex(uint index) returns (string) {
    if (index < myArray.length){
        return myArray[index];
    }
    return "";
}

Solidity-consumer pseudocode:

strings_to_serialize = []
for (int i=0; i<contract.getStringsLength(); i++)
    strings_to_serialize.append(contract.getStringByIndex(i))
# process the strings here

Solidity – How to Filter Through an Array of Structs?

As I understand its possible with followings,

Are there any limitations on how large my original my array

The limitation to contracts' storage is the limitation for this as well - i.e. 2^261 bytes. You may refer this question for contract storage limitation.

number of returned items?

There are two limitations; what solidity has allowed to return from a function which has a good read here and what your client machine used to connect to the ethereum network can handle in it's memory.

because this would only read from the ledger, it should not cost any gas to execute correct

This depends on your requirement. If what you want is just to read without a transaction involved (to display locally or so) it won't cost gas. But although the function is constant, if you need it to be used within a transaction (let's say you call non-constant function and within that function you use this constan function to verify something ) this may still cost gas. A good read regarding this can be found in this question.

code would look like something similar to this, depending on your requirement it may change

MyStruct[] myStructArray;

function checkArray() constant returns(bool[]){ // change on what you need to return

    bool[] checker; // change on what you need to return

    for(uint i = 0; i<myStructArray.length; i++){
        if(myStructArray[i].foo == bar){
            checker[i]=true; //or whatever you want to do if it matches
        }
        else{
            checker[i]=false;
        }
    }
    return checker;
}

Best Answer

Related Solutions

[Ethereum] How to serialize an array of strings in Solidity

Solidity – How to Filter Through an Array of Structs?

Related Topic