Solidity Contract Design – Mapping a Struct vs Having Two Mappings

contract-designcontract-developmentsolidity

I have a mapping linking a key and a byte32, and I would like to extend it to store something as long as a byte64.

I chose to cut it in half, but what is the best (and lightest) way to store the two parts ? Should I map to a struct like this:

struct b64 {
    bytes32 part1;
    bytes32 part2;
}

mapping (uint256 => b64) public b64s;

Or use two mappings, like this:

mapping (uint256 => bytes32) public b64s_1;
mapping (uint256 => bytes32) public b64s_2;

I'm looking for the lightest solution. The only function making the mapping always writes both parts at the same time so I don't think there will be consistency issues with two mappings.

The first solution is cleaner but if I can save precious gas at every writing with the second one I'll take it.

Best Answer

I tried both, and measured gas for both transactions. I got 107864 with a struct, and 107856 with two mappings.... I'm pretty sure that the two bytes32 take all the gas, and the data structure are negligible in comparison.

So I'm using the cleaner one in my opinion, the struct.

Related Solutions

Solidity Storage – Working with Nested Structs in Contract Design

You can store a struct in a struct.

pragma solidity ^0.4.11;

contract Nest {

  struct IpfsHash {
    bytes32 hash;
    uint hashSize;
  }

  struct Member {
    IpfsHash ipfsHash;
  }

  mapping(uint => Member) members;

  function addMember(uint id, bytes32 hash, uint size) public returns(bool success) {
    members[id].ipfsHash.hash = hash;
    members[id].ipfsHash.hashSize = size;
    return true;
  }

  function getMember(uint id) public constant returns(bytes32 hash, uint hashSize) {
    return(members[id].ipfsHash.hash, members[id].ipfsHash.hashSize);
  }
}

This nesting is a little on the pointless side if there is only one IPFS per Member as I assume is the case. I didn't want to fix too much and drift away from the original question.

Yes, you can nest structs inside structs. Mappings and arrays, too, or even mappings of structs or arrays of structs.

Possibly helpful: struct declarations are only declaring a type not instances of the type.

In terms of coordinating all this to make something useful, have a look at the patterns over here: Are there well-solved and simple storage patterns for Solidity?

If you are looking for a one-to-many (many IPFS per Member), this pattern might be helpful: https://medium.com/@robhitchens/enforcing-referential-integrity-in-ethereum-smart-contracts-a9ab1427ff42

Hope it helps.

How Double Mappings are Indexed in Solidity

As per Documentation . Mapping types are declared as mapping(_KeyType => _ValueType). Here _KeyType can be almost any type except for a mapping, a dynamically sized array, a contract, an enum and a struct. _ValueType can actually be any type, including mappings. It not possible directly make an array of struct as value type. But it is possible for other data types, like :

 mapping (bytes32 => mapping (uint => arrayofdata[index_of_array]) ) public PaymentDetails;

Here I changed the code as solidity support for struct as value type in mapping.

struct PaymentDetail {  
        uint TotalPaid;  
        }

    mapping (bytes32 => mapping (uint => PaymentDetail) ) public PaymentDetails; 

    function addPaymentDetail (bytes32 _Wallet, uint _TokenIndex, uint _Payment) public {
        uint _TotalPaid = PaymentDetails[_Wallet][_TokenIndex].TotalPaid;
        _TotalPaid=_TotalPaid+_Payment;
        PaymentDetails[_Wallet][_TokenIndex].TotalPaid=_TotalPaid;
    }

Best Answer

Related Solutions

Solidity Storage – Working with Nested Structs in Contract Design

How Double Mappings are Indexed in Solidity

Related Topic