feat(ethexe): introduce ScaleCodec library for Solidity

ethexe/contracts/test/ScaleCodec/Array.t.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.26;
+
+import {ScaleCodec} from "src/ScaleCodec.sol";
+import "forge-std/Test.sol";
+
+contract TestArrayScaleCodec is Test {
+    function encodeArray(string[5] memory _value) internal pure returns (bytes memory) {
+        bytes[] memory result = new bytes[](5);
+        for (uint256 i = 0; i < 5; i++) {
+            result[i] = ScaleCodec.encodeString(_value[i]);
+        }
+
+        return ScaleCodec.concatBytes(result);
+    }
+
+    function decodeArray(bytes memory _value) internal pure returns (string[5] memory) {
+        string[] memory result = new string[](5);
+
+        uint256 offset = 0;
+
+        for (uint256 i = 0; i < 5; i++) {
+            ScaleCodec.DecodedString memory item = ScaleCodec.decodeString(_value, offset);
+            result[i] = item.value;
+            offset = item.offset;
+        }
+
+        return [result[0], result[1], result[2], result[3], result[4]];
+    }
+
+    function test_arrayEncode() public pure {
+        string[5] memory _array = ["Gear", "is", "awesome", "and", "cool"];
+
+        bytes memory encoded = hex"10476561720869731c617765736f6d650c616e6410636f6f6c";
+
+        assertEq(encodeArray(_array), encoded);
+    }
+
+    function test_arrayDecode() public pure {
+        string[5] memory _array = ["Gear", "is", "awesome", "and", "cool"];
+
+        bytes memory encoded = hex"10476561720869731c617765736f6d650c616e6410636f6f6c";
+
+        string[5] memory decoded = decodeArray(encoded);
+
+        assertEq(decoded[0], _array[0]);
+        assertEq(decoded[1], _array[1]);
+        assertEq(decoded[2], _array[2]);
+        assertEq(decoded[3], _array[3]);
+        assertEq(decoded[4], _array[4]);
+    }
+}

ethexe/contracts/test/ScaleCodec/Bool.t.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.26;
+
+import {ScaleCodec} from "src/ScaleCodec.sol";
+import "forge-std/Test.sol";
+
+contract TestBoolScaleCodec is Test {
+    function test_boolEncodeTrue() public pure {
+        assertEq(ScaleCodec.encodeBool(true), hex"01");
+    }
+
+    function test_boolEncodeFalse() public pure {
+        assertEq(ScaleCodec.encodeBool(false), hex"00");
+    }
+
+    function test_boolDecodeTrue() public pure {
+        assertEq(ScaleCodec.decodeBool(hex"01", 0), true);
+    }
+
+    function test_boolDecodeFalse() public pure {
+        assertEq(ScaleCodec.decodeBool(hex"00", 0), false);
+    }
+}

ethexe/contracts/test/ScaleCodec/Bytes.t.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.26;
+
+import {ScaleCodec} from "src/ScaleCodec.sol";
+import "forge-std/Test.sol";
+
+contract TestBytesScaleCodec is Test {
+    function test_bytesToBytes32() public pure {
+        assertEq(
+            ScaleCodec.bytesToBytes32(hex"050102030401020304010203040102030401020304010203040102030401020304", 1),
+            hex"0102030401020304010203040102030401020304010203040102030401020304"
+        );
+    }
+
+    function test_insertBytes32() public pure {
+        bytes memory _bytes = new bytes(33);
+        _bytes[0] = 0x05;
+        ScaleCodec.insertBytes32To(hex"0102030401020304010203040102030401020304010203040102030401020304", _bytes, 1);
+        assertEq(_bytes, hex"050102030401020304010203040102030401020304010203040102030401020304");
+    }
+
+    function test_insertBytes20() public pure {
+        bytes memory _bytes = new bytes(21);
+        _bytes[0] = 0x05;
+        ScaleCodec.insertBytes32To(hex"0102030401020304010203040102030401020304", _bytes, 1);
+        assertEq(_bytes, hex"050102030401020304010203040102030401020304");
+    }
+}

ethexe/contracts/test/ScaleCodec/Int.t.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.26;
+
+import {ScaleCodec} from "src/ScaleCodec.sol";
+import "forge-std/Test.sol";
+
+contract TestIntScaleCodec is Test {
+    function test_int8EncodeDecode() public pure {
+        assertEq(ScaleCodec.encodeInt8(int8(69)), hex"45");
+
+        bytes memory _bytes = new bytes(2);
+        _bytes[0] = 0x01;
+        ScaleCodec.encodeInt8To(int8(-69), _bytes, 1);
+        assertEq(_bytes, hex"01bb");
+    }
+
+    function test_int8Decode() public pure {
+        assertEq(ScaleCodec.decodeInt8(hex"45", 0), int8(69));
+        assertEq(ScaleCodec.decodeInt8(hex"01bb", 1), int8(-69));
+    }
+
+    function test_int16EncodeDecode() public {
+        assertEq(ScaleCodec.encodeInt16(int16(42)), hex"2a00");
+        assertEq(ScaleCodec.decodeInt16(hex"2a00", 0), int16(42));
+
+        assertEq(ScaleCodec.encodeInt16(int16(-42)), hex"d6ff");
+        assertEq(ScaleCodec.decodeInt16(hex"d6ff", 0), int16(-42));
+    }
+
+    function test_int32EncodeDecode() public pure {
+        assertEq(ScaleCodec.encodeInt32(int32(16777215)), hex"ffffff00");
+        assertEq(ScaleCodec.decodeInt32(hex"ffffff00", 0), int32(16777215));
+
+        assertEq(ScaleCodec.encodeInt32(int32(-16777215)), hex"010000ff");
+        assertEq(ScaleCodec.decodeInt32(hex"010000ff", 0), int32(-16777215));
+    }
+
+    function test_int64EncodeDecode18446744073709() public pure {
+        assertEq(ScaleCodec.encodeInt64(int64(18446744073709)), hex"edb5a0f7c6100000");
+        assertEq(ScaleCodec.decodeInt64(hex"edb5a0f7c6100000", 0), int64(18446744073709));
+
+        assertEq(ScaleCodec.encodeInt64(int64(-18446744073709)), hex"134a5f0839efffff");
+        assertEq(ScaleCodec.decodeInt64(hex"134a5f0839efffff", 0), int64(-18446744073709));
+    }
+
+    function test_int128EncodeDecode() public pure {
+        assertEq(ScaleCodec.encodeInt128(int128(340282366920938463463374607431)), hex"4754408bb92ca5b509fa824b04000000");
+        assertEq(
+            ScaleCodec.decodeInt128(hex"4754408bb92ca5b509fa824b04000000", 0), int128(340282366920938463463374607431)
+        );
+
+        assertEq(
+            ScaleCodec.encodeInt128(int128(-340282366920938463463374607431)), hex"b9abbf7446d35a4af6057db4fbffffff"
+        );
+        assertEq(
+            ScaleCodec.decodeInt128(hex"b9abbf7446d35a4af6057db4fbffffff", 0), int128(-340282366920938463463374607431)
+        );
+    }
+}

ethexe/contracts/test/ScaleCodec/Optional.t.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.26;
+
+import {ScaleCodec} from "src/ScaleCodec.sol";
+import "forge-std/Test.sol";
+
+contract TestOptionalScaleCodec is Test {
+    struct OptionalString {
+        bool isSome;
+        string value;
+    }
+
+    function encodeOptionalString(OptionalString memory _value) internal pure returns (bytes memory) {
+        return ScaleCodec.encodeOptional(
+            ScaleCodec.Optional({
+                isSome: _value.isSome,
+                value: _value.isSome ? ScaleCodec.encodeString(_value.value) : new bytes(0)
+            })
+        );
+    }
+
+    function decodeOptionalString(bytes memory _bytes) internal pure returns (OptionalString memory) {
+        ScaleCodec.Optional memory decoded = ScaleCodec.decodeOptional(_bytes, 0);
+
+        return OptionalString({
+            isSome: decoded.isSome,
+            value: decoded.isSome ? ScaleCodec.decodeString(decoded.value, 0).value : ""
+        });
+    }
+
+    function test_OptionalNoneEncodeDecode() public pure {
+        OptionalString memory _optional = OptionalString({isSome: false, value: ""});
+
+        assertEq(encodeOptionalString(_optional), hex"00");
+
+        OptionalString memory _decoded = decodeOptionalString(hex"00");
+
+        assertEq(_decoded.isSome, false);
+    }
+
+    function test_OptionalSomeEncodeDecode() public pure {
+        OptionalString memory _optional = OptionalString({isSome: true, value: "Gear"});
+
+        assertEq(encodeOptionalString(_optional), hex"011047656172");
+
+        OptionalString memory _decoded = decodeOptionalString(hex"011047656172");
+
+        assertEq(_decoded.isSome, true);
+        assertEq(_decoded.value, "Gear");
+    }
+}

ethexe/contracts/test/ScaleCodec/Result.t.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.26;
+
+import {ScaleCodec} from "src/ScaleCodec.sol";
+import "forge-std/Test.sol";
+
+contract TestResultScaleCodec is Test {
+    struct ResultStringU8 {
+        bool isOk;
+        bool isErr;
+        string ok;
+        uint8 err;
+    }
+
+    function encodeResultStringU8(ResultStringU8 memory _value) internal pure returns (bytes memory) {
+        if (_value.isOk) {
+            return ScaleCodec.encodeResult(
+                ScaleCodec.Result({isOk: true, isErr: false, value: ScaleCodec.encodeString(_value.ok)})
+            );
+        } else {
+            return ScaleCodec.encodeResult(
+                ScaleCodec.Result({isOk: false, isErr: true, value: ScaleCodec.encodeUint8(_value.err)})
+            );
+        }
+    }
+
+    function decodeResultStringU8(bytes memory _value) public pure returns (ResultStringU8 memory) {
+        ScaleCodec.Result memory decoded = ScaleCodec.decodeResult(_value, 0);
+
+        if (decoded.isOk) {
+            return
+                ResultStringU8({isOk: true, isErr: false, ok: ScaleCodec.decodeString(decoded.value, 0).value, err: 0});
+        } else {
+            return ResultStringU8({isOk: false, isErr: true, ok: "", err: ScaleCodec.decodeUint8(decoded.value, 0)});
+        }
+    }
+
+    function test_ResultOkEncodeDecode() public pure {
+        ResultStringU8 memory _result = ResultStringU8({isOk: true, isErr: false, ok: "Gear", err: 0});
+
+        assertEq(encodeResultStringU8(_result), hex"001047656172");
+
+        ResultStringU8 memory _decoded = decodeResultStringU8(hex"001047656172");
+
+        assertEq(_decoded.isOk, true);
+        assertEq(_decoded.ok, "Gear");
+    }
+
+    function test_ResultErrEncodeDecode() public pure {
+        ResultStringU8 memory _result = ResultStringU8({isOk: false, isErr: true, ok: "", err: 1});
+
+        assertEq(encodeResultStringU8(_result), hex"0101");
+
+        ResultStringU8 memory _decoded = decodeResultStringU8(hex"0101");
+
+        assertEq(_decoded.isErr, true);
+        assertEq(_decoded.err, 1);
+    }
+}

ethexe/contracts/test/ScaleCodec/String.t.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.26;
+
+import {ScaleCodec} from "src/ScaleCodec.sol";
+import "forge-std/Test.sol";
+
+contract TestStringScaleCodec is Test {
+    function test_stringEncode() public pure {
+        assertEq(ScaleCodec.encodeString("hello"), hex"1468656c6c6f");
+    }
+
+    function test_stringEncodeTo() public pure {
+        bytes memory _bytes = new bytes(7);
+        _bytes[0] = 0x01;
+
+        string memory _str = "hello";
+        uint256 strLen = ScaleCodec.stringLen(_str);
+        uint8 strLenPrefixLen = ScaleCodec.compactIntLen(strLen);
+        ScaleCodec.encodeCompactIntTo(strLen, strLenPrefixLen, _bytes, 1);
+
+        ScaleCodec.encodeStringTo("hello", strLen, _bytes, 1 + strLenPrefixLen);
+        assertEq(_bytes, hex"011468656c6c6f");
+    }
+
+    function test_stringDecode() public pure {
+        assertEq(ScaleCodec.decodeString(hex"1468656c6c6f", 0).value, "hello");
+    }
+
+    function test_strLen() public pure {
+        assertEq(ScaleCodec.stringLen("hello"), 5);
+    }
+}

ethexe/contracts/test/ScaleCodec/Struct.t.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.26;
+
+import {ScaleCodec} from "src/ScaleCodec.sol";
+import "forge-std/Test.sol";
+
+contract TestStructScaleCodec is Test {
+    struct MyStruct {
+        string name;
+        uint8 age;
+    }
+
+    function encodeMyStruct(string memory _name, uint8 _age) internal pure returns (bytes memory) {
+        MyStruct memory myStruct = MyStruct(_name, _age);
+
+        uint256 totalLen = 0;
+
+        uint256 __nameLen = ScaleCodec.stringLen(myStruct.name);
+        uint8 __namePrefixLen = ScaleCodec.compactIntLen(__nameLen);
+        totalLen += __nameLen + __namePrefixLen;
+
+        totalLen += 1;
+
+        bytes memory _bytes = new bytes(totalLen);
+
+        uint256 offset = 0;
+        ScaleCodec.encodeCompactIntTo(__nameLen, __namePrefixLen, _bytes, 0);
+        offset += __namePrefixLen;
+        ScaleCodec.encodeStringTo(myStruct.name, __nameLen, _bytes, offset);
+        offset += __nameLen;
+        ScaleCodec.encodeUint8To(myStruct.age, _bytes, offset);
+
+        return _bytes;
+    }
+
+    function decodeMyStruct(bytes memory _value) internal pure returns (MyStruct memory) {
+        ScaleCodec.DecodedString memory name = ScaleCodec.decodeString(_value, 0);
+        uint8 age = ScaleCodec.decodeUint8(_value, name.offset);
+
+        return MyStruct(name.value, age);
+    }
+
+    function test_MyStructEncode() public pure {
+        MyStruct memory _myStruct = MyStruct({name: "Gear", age: 3});
+
+        assertEq(encodeMyStruct(_myStruct.name, _myStruct.age), hex"104765617203");
+    }
+
+    function test_MyStructEncodeDecode() public pure {
+        MyStruct memory _decoded = decodeMyStruct(hex"104765617203");
+        assertEq(_decoded.name, "Gear");
+        assertEq(_decoded.age, 3);
+    }
+}