Solidity Bytes32 – How to Split a Bytes32 Source into Two Halfs and Store in Bytes16

bytesbytes32solidity

I want to split a 32 Byte source: first half in Bytes16 half1; second half in Bytes16 half2. My code works, however only for dynamic array, not with fixed size 16.

pragma solidity ^0.4.8;

contract cut {

    function cutSha(bytes32 source) constant returns (bytes, bytes) {
        bytes memory half1 = new bytes(16);
        bytes memory half2 = new bytes(16);
        for (uint j = 0; j < 16; j++) {
                half1[j] = source[j];
                half2[j] = source[j+16];
        }
        return (half1, half2);
    }
}

Best Answer

It is possible to do this with assembly:

pragma solidity ^0.4.8;

contract c {
    event trace(bytes32 x, bytes16 a, bytes16 b);

    function foo(bytes32 source) {
        bytes16[2] memory y = [bytes16(0), 0];
        assembly {
            mstore(y, source)
            mstore(add(y, 16), source)
        }
        trace(source, y[0], y[1]);
    }
}

For example, converting bytes from the string "what a wonderful world!", produces this after using 2245 gas:

trace[
  "0x77686174206120776f6e64657266756c20776f726c6421000000000000000000",
  "0x77686174206120776f6e64657266756c",
  "0x20776f726c6421000000000000000000"
]

NB: the code relies on the internal data representation that may be subject to change in later versions of Solidity or interfere with Solidity optimizer in an unpredictable ways.

Related Solutions

solidity – How to Return an Array of UINTS from a Struct – Complete Code Example

Your unbounded for loop is an anti-pattern because it will cease to operate at scale when the gas cost exceeds the block gas limit. Ouch.

Break it up into multiple fixed-cost operations. Iteration is the caller's responsibility.

I also noticed you're declaring a storage variable inside a function. Not conventional. Below will give you "free" getters voteList(uint row) and voteStructs[bytes32 key]. The client can 1) get the list length, 2) get the keys one at a time, and 3) get the complete structure for any key.

contract Vote {

  struct VoteStruct {
    bool wasCast;
    // more stuff about votes
  }

  bytes32[] public voteList;
  mapping(bytes32 => VoteStruct) public voteStructs;

  function getVoteCount() public constant returns(uint voteCount) {
    return voteList.length;
  }   
}

In case it helps, there some patterns that combine mappings with key lists over here: Are there well-solved and simple storage patterns for Solidity?

Your snippet refers to a candidatesList and does some computation that you might want the smart contract to tally as the votes come in so you aren't tempted to iterate later.

Hope it helps.

Solidity – Problem Using Created Array from Assembly

The author of the github page that you referenced didn't update the free memory pointer after allocating the memory. Also as Tjaden Hess noted in the comments

return as an opcode and return as a Solidity statement are very different. The opcode causes the entire contract execution to return at that point, with the return value that you designate in memory. The Solidity return just pops off the call frame and returns to the calling function

Below is the correct code:

contract C {
    function f(uint a, uint b) pure public returns (uint[] memory memOffset) {
        assembly {
             // Create an dynamic sized array manually.
             // Don't need to define the data type here as the EVM will prefix it
             memOffset := msize() // Get the highest available block of memory
             mstore(add(memOffset, 0x00), 2) // Set size to 2
             mstore(add(memOffset, 0x20), a) // array[0] = a
             mstore(add(memOffset, 0x40), b) // array[1] = b
             mstore(0x40, add(memOffset, 0x60)) // Update the msize offset to be our memory reference plus the amount of bytes we're using
        }
    }

    function get_f(uint a, uint b) public returns(uint){
        uint[] memory ret = f(a,b);
        return ret[0];
    }
}

I created a pull request to fix this on Github https://github.com/androlo/solidity-workshop/pull/5

Best Answer

Related Solutions

solidity – How to Return an Array of UINTS from a Struct – Complete Code Example

Solidity – Problem Using Created Array from Assembly

Related Topic