Solidity – How to Send Array of Structs as Arguments

arrayssoliditystruct

I want to send to my contract an array of currency and its price so it will store it:

pragma solidity ^0.4.24;

contract ExchangeContract {
    enum CurrencyType { USD, TWOKEY, BTC, ETH, DAI, USDT, TUSD, EUR, JPY, GBP}

    mapping(uint256 => CurrencyPrice) public priceByCurrencyType;

    struct Price{
        uint price;
        uint decimals;
    }

    struct CurrencyPrice{
        uint currencyInt;
        Price price;
    }

    function updatePrices(CurrencyPrice[] memory _array) public {
        for(i=0; i<_array.length; i++){
            priceByCurrencyType[_array[0][0]]=_array[0][1];
        }
    }
}

as I saw in the answer here – Passing in an array of complex structs
its suggest to send one at a time and not worry about multiple calls.

So went back to my question, it does not have to be a struct – is there a way to send a bulk of data, structures parse it in the function so it will fit into one call.

Best Answer

This compiles for me:

pragma solidity ^0.4.24;
pragma experimental ABIEncoderV2;

contract ExchangeContract {
  enum CurrencyType { USD, TWOKEY, BTC, ETH, DAI, USDT, TUSD, EUR, JPY, GBP}

  mapping(uint256 => CurrencyPrice) public priceByCurrencyType;

  struct Price{
    uint price;
    uint decimals;
  }

  struct CurrencyPrice{
    uint currencyInt;
    Price price;
  }

  function updatePrices(CurrencyPrice[] memory _array) public {
    for(uint i=0; i<_array.length; i++){
      priceByCurrencyType[_array[0].currencyInt].price=_array[i].price;
    }
  }
}

I had to add pragma experimental ABIEncoderV2; and fix couple of minor mistakes.

Related Solutions

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;
}

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 – How to Filter Through an Array of Structs?

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

Related Topic