solidity – Techniques for Bit Packing Return Values in Solidity

solidity

Setting variables like this can pack them into a single slot:

uint128 v1 =1;
uint128 v2 =2;

But does return values also pack in this way? Does

returns (uint128, uint128)

also pack data?

Will experiment it later myself

Best Answer

Setting variables like this can pack them into a single slot

Your example doesn't work, uint is an alias for uint256, so in that specific example both variable use a full slot each. Maybe it was a typo and you meant uint128 ?

But does return values also pack in this way ?

No. Input and outputs are abi encoded (see the documentation), that is, padded to 32 bytes each with some caveats for dynamic types. Thus, the following function would return two 32 bytes values :

function test() public view returns (uint128, uint128) {
  uint128 a = 1;
  uint128 b = 2;

  return (a, b);
}

I hope that answers your question.

Related Solutions

Solidity – Efficient Bit Packing Techniques

In Solidity a bool is stored in 1 byte (8 bits). However, only a single bit is actually used. Under the hood, The hex value of true is 0x01, false is 0x00. Converted to binary these are 00000001 and 00000000 - 7 of the 8 bits are not used.

All reads and writes to storage are handled in 32 byte increments. To reduce gas costs, Solidity tightly packs variables where possible so that they are stored within the same 32 bytes. In the case of your struct you have an address (20 bytes) followed by 2 uint8s (1 byte each) and 2 bools (1 byte each). This is a total of 24 bytes, so Solidity is able to pack the entire struct into a single 32 byte slot. There is no need to optimize further on your end.

The concept you are considering (packing more than one bool within a single byte) is known as a bit field. Bit fields are more efficient in cases where you wish to store a sequence of greater than 32 booleans. Mudit Gupta has written an excellent blog post that explains how to accomplish this via bitshifting:

The easiest way is to take a uint256 variable and use all 256 bits of it to represent individual booleans. To get an individual boolean from a uint256 , use this function:
function getBoolean(
    uint256 _packedBools,
    uint256 _boolNumber
)
    public
    view
    returns (bool)
{
    uint256 flag = (_packedBools >> _boolNumber) & uint256(1);
    return (flag == 1 ? true : false);
}
To set or clear a bool, use:
function setBoolean(
    uint256 _packedBools,
    uint256 _boolNumber,
    bool _value
)
    public
    view
    returns (uint256)
{
    if (_value)
        return _packedBools | uint256(1) << _boolNumber;
    else
        return _packedBools & ~(uint256(1) << _boolNumber);
}
With this technique, you can store 256 booleans in one storage slot. If you try to pack bool normally (like in a struct) then you will only be able to fit 32 bools in one slot. Use this only when you want to store more than 32 booleans.

Solidity – How to Get Return Values When One Contract Calls Another

Between contracts, the return values can always be utilized. So if contract A calls contract B, A gets and can utilize the return values.

You are correct in saying that the return values can't be returned outside the blockchain for a transaction. So function return values are just useful for:

Interaction between different contracts
Interaction inside a contract
In view and pure functions, which are called statically from a local node without a transaction. Or when doing such a static call to any function, but knowing that the state changes are not persisted.

Best Answer

Related Solutions

Solidity – Efficient Bit Packing Techniques

Solidity – How to Get Return Values When One Contract Calls Another

Related Topic