ethereum solidity: from concatenated hexadecimal strings to uint64[]

Question

I want my API to return an array of uint64 to my on-chain contract.

I tried 2 response formats for my API:

1. The array of uint64 itself (BN string here, but I need it in true uint64 not strings in my contract):

{"data":["629343835796877311","629343835797458943","629343835797471231"]}

2. concatenated hexadecimal strings (a new value every 16 chars):

{"data":"08bbe0e25e412fff08bbe0e25e4a0fff08bbe0e25e4a3fff"}

I discarded using the first approach because having ["629343835796877311","629343835797458943","629343835797471231"] as bytes is actually difficult to extract. I might be wrong! Maybe there is a base64 approach to encode and decode the data back into solidity data types, maybe?

I will use the second approach bellow.

Chainlink will pass the response as bytes memory _data:

  function fulfill(bytes32 _requestId, bytes memory _data)
    public
    recordChainlinkFulfillment(_requestId)
  {
      data = string(_data);
  }

Those bytes memory _data are successfully received and converted to a string (in storage data). The string value looks like this

08bbe0e25e412fff08bbe0e25e4a0fff08bbe0e25e4a3fff ...

In this example each 16 chars represent a uint64 number. The first one: 08bbe0e25e412fff is 629343835796877311 for instance.

In solidity, I need to split the string each 16 chars and then convert it into their uint64 value. I could use the bytes memory _data instead of the string(_data) if the code would be simpler or consume less gas. I am not sure

Please I need help with this I have been struggling. Thanks

Answer 1

I got this contract working

COMMENTS:

the method hexBytesToInt is going to get a string representing hexa value like ffa0 for instance and return it's decimal value.

the method getSlice is just going to slice a string. In my case I have a new hexa value every 16 chars so I need to slice (0,16) than (16,32) etc...

the method hexStringToIntArray is managing the increments to slice every 16 chars and call the hexBytesToInt to transform the hex string in uint.

If you really want to dig into this solution, you are better off starting by understanding the test cases.

pragma solidity >=0.4.22 <0.8.11;

contract Serializer {

    function hexStringToIntArray(string memory s) public pure returns (uint64[] memory) {
        uint size = bytes(s).length / 16;
        uint64[] memory result = new uint64[](size);
        for (uint i = 0; i< size; i++) {
            string memory strSlice = getSlice(i*16, (i+1)*16, s);
            result[i] = hexStringToInt(strSlice);
        }
        return result;
    }

    function getSlice(uint startIndex, uint endIndex, string memory str) public pure returns (string memory) {
        bytes memory strBytes = bytes(str);
        bytes memory result = new bytes(endIndex-startIndex);
        for(uint i = startIndex; i < endIndex; i++) {
            result[i-startIndex] = strBytes[i];
        }
        return string(result);
    }

    function hexBytesToInt(bytes memory ss) public pure returns (uint64){
        uint64 val = 0;
        uint8 a = uint8(97); // a
        uint8 zero = uint8(48); //0
        uint8 nine = uint8(57); //9
        uint8 A = uint8(65); //A
        uint8 F = uint8(70); //F
        uint8 f = uint8(102); //f
        for (uint i=0; i<ss.length; ++i) {
            uint8 byt = uint8(ss[i]);
            if (byt >= zero && byt <= nine) byt = byt - zero;
            else if (byt >= a && byt <= f) byt = byt - a + 10;
            else if (byt >= A && byt <= F) byt = byt - A + 10;
            val = (val << 4) | (byt & 0xF);
        }
        return val;
    }

    function hexStringToInt(string memory s) public pure returns (uint64) {
        bytes memory ss = bytes(s);
        uint64 val = hexBytesToInt(ss);
        return val;
    }
}

the tests:

const Serializer = artifacts.require("Serializer");
const truffleAssert = require("truffle-assertions");
const fs = require("fs");
const { readLines } = require("./utils.js");
const BN = web3.utils.BN;

contract("Serializer", (accounts) => {
  const [deployerAddress, tokenHolderOneAddress, tokenHolderTwoAddress] = accounts;

  it("hexStringToInt", async () => {
    let s = await Serializer.deployed();
    let result = await s.hexStringToInt.call("08bbe0e25e412fff");
    let expected = new BN("629343835796877311");
    assert.equal(result.toString(10), expected.toString(10));
    result = await s.hexStringToInt.call("08bbe0e25e4a0fff");
    expected = new BN("629343835797458943");
    assert.equal(result.toString(10), expected.toString(10));
    result = await s.hexStringToInt.call("08bbe0e25e4a3fff");
    expected = new BN("629343835797471231");
    assert.equal(result.toString(10), expected.toString(10));
  });
  it("getSlice1", async () => {
    let s = await Serializer.deployed();
    let result = await s.getSlice.call(0, 16, "08bbe0e25e412fff08bbe0e25e4a0fff08bbe0e25e4a3fff");
    let expected = "08bbe0e25e412fff";
    assert.equal(result, expected);
  });
  it("getSlice2", async () => {
    let s = await Serializer.deployed();
    const result = await s.getSlice.call(16, 32, "08bbe0e25e412fff08bbe0e25e4a0fff08bbe0e25e4a3fff");
    const expected = "08bbe0e25e4a0fff";
    assert.equal(result, expected);
  });
  it("getSlice3", async () => {
    let s = await Serializer.deployed();
    const result = await s.getSlice.call(32, 48, "08bbe0e25e412fff08bbe0e25e4a0fff08bbe0e25e4a3fff");
    const expected = "08bbe0e25e4a3fff";
    assert.equal(result, expected);
  });
  it("hexStringToIntArray", async () => {
    let s = await Serializer.deployed();
    let result = await s.hexStringToIntArray.call("08bbe0e25e412fff08bbe0e25e4a0fff08bbe0e25e4a3fff");
    console.log(result);
    let expected = [
      new BN("629343835796877311").toString(),
      new BN("629343835797458943").toString(),
      new BN("629343835797471231").toString(),
    ];
    const resultS = result.map((x) => x.toString());
    assert.deepEqual(resultS, expected);
  });
});