Convert uint24 to HEX string in Solidity

Question

I am trying to convert uint24 value of a kind 0x00ff08 to a human readable string with the same characters in Solidity smart contract which I am going to deploy on RSK. In my question about bytes3 to hex string casting I was advised for these purposes to use a function

function uint24tohexstr(uint24 i) public pure returns (string memory) {
        bytes memory o = new bytes(6);
        uint24 mask = 0x00000f;
        o[5] = bytes1(uint8tohexchar(uint8(i & mask)));
        i = i >> 4;
        o[4] = bytes1(uint8tohexchar(uint8(i & mask)));
        i = i >> 4;
        o[3] = bytes1(uint8tohexchar(uint8(i & mask)));
        i = i >> 4;
        o[2] = bytes1(uint8tohexchar(uint8(i & mask)));
        i = i >> 4;
        o[1] = bytes1(uint8tohexchar(uint8(i & mask)));
        i = i >> 4;
        o[0] = bytes1(uint8tohexchar(uint8(i & mask)));
        return string(o);
    }

I wanted to make use of a loop in that function and rewrote it like this

function uint24ToHexStr(uint24 i) public pure returns (string memory) {
        bytes memory o = new bytes(6);
        uint24 mask = 0x00000f; // hex 15
        for(uint k = 5; k >= 0; k -= 1) {
          o[k] = bytes1(uint8ToHexCharCode(uint8(i & mask)));
          i >>= 4;
        }
        return string(o);
    }

But unfortunately this function causes runtime error because on the last iteration unsigned integer k becomes -1. The first thing that crossed my mind was to increase k by one so that

        for(uint k = 6; k >= 1; k -= 1) {
          o[k - 1] = bytes1(uint8ToHexCharCode(uint8(i & mask)));
        }

Can anyone think of a more elegant way to achieve the same result?

selbie · Answer 1 · 2021-09-25T18:22:09.517

3

This line:

for(uint k = 5; k >= 0; k -= 1) {

If k is of type uint, when will k >= 0 ever evaluate to false? (hint: never)

Change k from type uint to int and problem is solved.

    for(int k = 5; k >= 0; k -= 1) {
      o[k] = bytes1(uint8ToHexCharCode(uint8(i & mask)));
      i >>= 4;
    }

Or

    for(uint k = 0; k< 6; k += 1) {
      o[5-k] = bytes1(uint8ToHexCharCode(uint8(i & mask)));
      i >>= 4;
    }

edited Sep 25 '21 at 18:22

answered Sep 25 '21 at 18:16

selbie

100,020
15
103
173

Right, never evaluate to false, but on the last iteration of the loop k becomes -1 that is impossible for uints and causes an error! I am using uints because It seems to me that in the glorious Solidity language array indices are uints :) But your second idea is nice, thanks ! – Aleks Shenshin Sep 25 '21 at 18:28
Oooh, I like the 2nd option! Neat way to use `for` loops while sticking to `uint` for the counter var! – bguiz Sep 26 '21 at 01:05

score 2 · Accepted Answer · answered Sep 26 '21 at 03:47

I like the 2nd option in @selbie's answer; and thought what if we used a different type of loop control structure. A regular while loop would inherit the same "final iteration uint underflow" problem that the for loop has. Switching to a do .. while loop, on the other hand, allows you to shift the evaluation of the condition from being checked before the iteration, to being checked after the iteration. This can be applied to your implementation like so:

    function uint24ToHexStr(uint24 i) public pure returns (string memory) {
        bytes memory o = new bytes(6);
        uint24 mask = 0x00000f; // hex 15
        uint k = 6;
        do {
            k--;
            o[k] = bytes1(uint8ToHexCharCode(uint8(i & mask)));
            i >>= 4;
        } while (k > 0);
        return string(o);
    }

This avoids both the uint underflow, and also does not require k - 1 for array indices within the loop. In terms of gas cost, I would "guesstimate" that it would be close to the original implementation of the same function from the previous question. (but actually try both out and compare to confirm)

score 2 · Answer 3 · answered Sep 26 '21 at 04:30

Alternative answer, also taking some inspiration from @selbie's answer of forward iteration, but instead of reversing the index order, get the target half-byte by switching from a bitwise-and mask to a bit-shift of 5 half-bytes (20 bits). Like so:

   function uint24ToHexStrAlt2(uint24 i) public pure returns (string memory) {
        bytes memory o = new bytes(6);
        uint k = 0;
        do {
            o[k] = bytes1(uint8ToHexCharCode(uint8(i >> 20))); // shift by 5 nibbles instead of mask
            i <<= 4;
            k +=1;
        } while (k < 6);
        return string(o);
    }

Convert uint24 to HEX string in Solidity

3 Answers3