Feat/mega

contracts/libraries/AssemblyLib.sol

@@ -118,6 +118,18 @@ library AssemblyLib {
         }
     }
 
+    /**
+     * @dev There's no explict casting from dynamic to fixed sized bytes, this function
+     * handles it for us.
+     */
+    function toBytes8(bytes memory raw) internal pure returns (bytes8 data) {
+        assembly {
+            data := mload(add(raw, 32))
+            let shift := mul(sub(8, mload(raw)), 8)
+            data := shr(shift, data)
+        }
+    }
+
     /**
      * @dev Safely casts an unsigned 128-bit integer into a signed 128-bit integer.
      * Reverts on overflow.

contracts/libraries/FVMLib.sol

@@ -137,28 +137,43 @@ function decodeCreatePair(bytes calldata data) pure returns (address tokenAsset,
 }
 
 /**
- * @dev Encodes a claim operation
- *      +--------------------------------------------------------------------+
- *      | Description | CLAIM | poolId | power0 | amount0 | power1 | amount1 |
- *      +--------------------------------------------------------------------+
- *      | Size (byte) |   1   |    8   |    1   |    16   |    1   |    16   |
- *      +--------------------------------------------------------------------+
- *      | Index       |   0   |  1 - 9 |    9   | 10 - 26 |   26   | 27 - 43 |
- *      +--------------------------------------------------------------------+
+ * @dev Encodes a claim operation.
+ *
+ *      FIXME: This function is not optimized! Using `encodePacked` is not ideal
+ *      because it preserves all the trailing zeros for each type.
+ *      An improved version should be made to reduce the calldata size.
  */
 function encodeClaim(uint64 poolId, uint128 fee0, uint128 fee1) pure returns (bytes memory data) {
     (uint8 powerFee0, uint128 baseFee0) = AssemblyLib.fromAmount(fee0);
     (uint8 powerFee1, uint128 baseFee1) = AssemblyLib.fromAmount(fee1);
 
-    return abi.encodePacked(CLAIM, poolId, powerFee0, baseFee0, powerFee1, baseFee1);
+    return abi.encodePacked(
+        CLAIM,
+        uint8(10), // pointer to pointer1
+        poolId,
+        uint8(28), // pointer to fee1
+        powerFee0,
+        baseFee0,
+        powerFee1,
+        baseFee1
+    );
 }
 
+/**
+ * @dev Decodes a claim operation
+ */
 function decodeClaim(bytes calldata data) pure returns (uint64 poolId, uint128 fee0, uint128 fee1) {
-    poolId = uint64(bytes8(data[1:9]));
-    fee0 = AssemblyLib.toAmount(data[9:26]);
-    fee1 = AssemblyLib.toAmount(data[26:43]);
+    uint8 pointer0 = uint8(bytes1(data[1]));
+    poolId = uint64(AssemblyLib.toBytes8(data[2:pointer0]));
+    uint8 pointer1 = uint8(bytes1(data[pointer0]));
+    fee0 = AssemblyLib.toAmount(data[pointer0 + 1:pointer1]);
+    fee1 = AssemblyLib.toAmount(data[pointer1:data.length]);
 }
 
+/**
+ * @dev Encodes a create pool operation.
+ *      FIXME: Same issue as `encodeClaim`... This function is not optimized!
+ */
 function encodeCreatePool(
     uint24 pairId,
     address controller,
@@ -170,7 +185,24 @@ function encodeCreatePool(
     uint128 maxPrice,
     uint128 price
 ) pure returns (bytes memory data) {
-    data = abi.encodePacked(CREATE_POOL, pairId, controller, priorityFee, fee, vol, dur, jit, maxPrice, price);
+    (uint8 power0, uint128 base0) = AssemblyLib.fromAmount(maxPrice);
+    (uint8 power1, uint128 base1) = AssemblyLib.fromAmount(price);
+
+    data = abi.encodePacked(
+        CREATE_POOL,
+        pairId,
+        controller,
+        priorityFee,
+        fee,
+        vol,
+        dur,
+        jit,
+        uint8(52),
+        power0,
+        base0,
+        power1,
+        base1
+    );
 }
 
 function decodeCreatePool(bytes calldata data)
@@ -187,20 +219,26 @@ function decodeCreatePool(bytes calldata data)
         uint128 price
     )
 {
-    if (data.length != 66) revert InvalidBytesLength(66, data.length);
+    // if (data.length != 66) revert InvalidBytesLength(66, data.length);
     pairId = uint24(bytes3(data[1:4]));
     controller = address(bytes20(data[4:24]));
     priorityFee = uint16(bytes2(data[24:26]));
     fee = uint16(bytes2(data[26:28]));
     vol = uint16(bytes2(data[28:30]));
     dur = uint16(bytes2(data[30:32]));
     jit = uint16(bytes2(data[32:34]));
-    maxPrice = uint128(bytes16(data[34:50]));
-    price = uint128(bytes16(data[50:]));
+    uint8 pointer0 = uint8(bytes1(data[34]));
+    maxPrice = AssemblyLib.toAmount(data[35:pointer0]);
+    price = AssemblyLib.toAmount(data[pointer0:]);
 }
 
-function encodeAllocate(uint8 useMax, uint64 poolId, uint8 power, uint128 amount) pure returns (bytes memory data) {
-    data = abi.encodePacked(AssemblyLib.pack(bytes1(useMax), ALLOCATE), poolId, power, amount);
+/**
+ * @dev Encodes a allocate operation.
+ *      FIXME: Same issue as `encodeClaim`... This function is not optimized!
+ */
+function encodeAllocate(uint8 useMax, uint64 poolId, uint128 deltaLiquidity) pure returns (bytes memory data) {
+    (uint8 power, uint128 base) = AssemblyLib.fromAmount(deltaLiquidity);
+    data = abi.encodePacked(AssemblyLib.pack(bytes1(useMax), ALLOCATE), poolId, power, base);
 }
 
 function decodeAllocate(bytes calldata data) pure returns (uint8 useMax, uint64 poolId, uint128 deltaLiquidity) {
@@ -211,46 +249,58 @@ function decodeAllocate(bytes calldata data) pure returns (uint8 useMax, uint64
     deltaLiquidity = AssemblyLib.toAmount(data[9:]);
 }
 
-function encodeDeallocate(uint8 useMax, uint64 poolId, uint8 power, uint128 amount) pure returns (bytes memory data) {
-    data = abi.encodePacked(AssemblyLib.pack(bytes1(useMax), DEALLOCATE), poolId, power, amount);
+
+function encodeDeallocate(uint8 useMax, uint64 poolId, uint128 deltaLiquidity) pure returns (bytes memory data) {
+    (uint8 power, uint128 base) = AssemblyLib.fromAmount(deltaLiquidity);
+    data = abi.encodePacked(AssemblyLib.pack(bytes1(useMax), DEALLOCATE), poolId, power, base);
 }
 
 function decodeDeallocate(bytes calldata data) pure returns (uint8 useMax, uint64 poolId, uint128 deltaLiquidity) {
     if (data.length < 9) revert InvalidBytesLength(9, data.length);
     useMax = uint8(data[0] >> 4);
     poolId = uint64(bytes8(data[1:9]));
-    deltaLiquidity = uint128(AssemblyLib.toAmount(data[9:]));
+    deltaLiquidity = AssemblyLib.toAmount(data[9:]);
 }
 
 /**
  * @dev Encodes a swap operation
- *      +-------------------------------------------------------------------------------+
- *      | Description | SWAP | poolId | power0 | amount0 | power1 | amount1 | sellAsset |
- *      +-------------+------+--------+--------+---------+--------+---------+-----------+
- *      | Size (byte) |   1  |    8   |    1   |    16   |    1   |    16   |      1    |
- *      +-------------+------+--------+--------+---------+--------+---------+-----------+
- *      | Index       |   0  |  1 - 9 |    9   | 10 - 26 |    26  | 27 - 43 |     43    |
- *      +-------------------------------------------------------------------------------+
+ *      FIXME: Same issue as `encodeClaim`... This function is not optimized!
  */
 function encodeSwap(
     uint8 useMax,
     uint64 poolId,
-    uint8 power0,
     uint128 amount0,
-    uint8 power1,
     uint128 amount1,
     uint8 sellAsset
 ) pure returns (bytes memory data) {
-    data = abi.encodePacked(AssemblyLib.pack(bytes1(useMax), SWAP), poolId, power0, amount0, power1, amount1, sellAsset);
+    (uint8 power0, uint128 base0) = AssemblyLib.fromAmount(amount0);
+    (uint8 power1, uint128 base1) = AssemblyLib.fromAmount(amount1);
+
+    data = abi.encodePacked(
+        AssemblyLib.pack(bytes1(useMax), SWAP),
+        sellAsset,
+        uint8(11), // pointer to pointer1
+        poolId,
+        uint8(29),
+        power0,
+        base0,
+        power1,
+        base1
+    );
 }
 
+/**
+ * @dev Decodes a swap operation.
+ */
 function decodeSwap(bytes calldata data)
     pure
     returns (uint8 useMax, uint64 poolId, uint128 input, uint128 output, uint8 sellAsset)
 {
     useMax = uint8(data[0] >> 4);
-    poolId = uint64(bytes8(data[1:9]));
-    input = AssemblyLib.toAmount(data[9:26]);
-    output = AssemblyLib.toAmount(data[26:43]);
-    sellAsset = uint8(data[data.length - 1]);
+    sellAsset = uint8(data[1]);
+    uint8 pointer0 = uint8(data[2]);
+    poolId = uint64(AssemblyLib.toBytes8(data[3:pointer0]));
+    uint8 pointer1 = uint8(data[pointer0]);
+    input = AssemblyLib.toAmount(data[pointer0 + 1:pointer1]);
+    output = AssemblyLib.toAmount(data[pointer1:data.length]);
 }

encoder.js

@@ -0,0 +1,58 @@
+function toHex(input) {
+  return input.toString(16).length % 2 == 0 ? input.toString(16) : `0${input.toString(16)}`;
+}
+
+function fromAmount(amount) {
+  let power = 0;
+
+  while (amount % 10n == 0) {
+    amount /= 10n;
+    ++power;
+  }
+
+  console.log(amount, power);
+
+  return `${toHex(power)}${toHex(amount)}`;
+}
+
+function encodeClaim(poolId, fee0, fee1) {
+  let data = '';
+
+  let encodedPoolId = toHex(poolId);
+  let encodedFee0 = fromAmount(fee0);
+  let encodedFee1 = fromAmount(fee1);
+
+  data += toHex(16);
+  data += toHex((data.length + encodedPoolId.length) / 2 + 1);
+  data += encodedPoolId;
+  data += toHex((data.length + encodedFee0.length) / 2 + 1);
+  data += encodedFee0;
+  data += encodedFee1;
+
+  return data;
+}
+
+function encodeSwap(
+  useMax,
+  sellAsset,
+  poolId,
+  amount0,
+  amount1,
+) {
+  let data = '';
+
+  let encodedPoolId = toHex(poolId);
+  let encodedAmount0 = fromAmount(amount0);
+  let encodedAmount1 = fromAmount(amount1);
+
+  data += useMax ? '1' : '0';
+  data += '5';
+  data += sellAsset ? '01' : '00';
+  data += toHex((data.length + encodedPoolId.length) / 2 + 1);
+  data += encodedPoolId;
+  data += toHex((data.length + encodedAmount0.length) / 2 + 1);
+  data += encodedAmount0;
+  data += encodedAmount1;
+
+  return data;
+}

test/Setup.sol

@@ -226,19 +226,19 @@ contract Setup is Test {
     }
 
     modifier allocateSome(uint128 amt) {
-        subject().multiprocess(FVMLib.encodeAllocate(uint8(0), ghost().poolId, 0x0, amt));
+        subject().multiprocess(FVMLib.encodeAllocate(uint8(0), ghost().poolId, amt));
         _;
     }
 
     modifier deallocateSome(uint128 amt) {
-        subject().multiprocess(FVMLib.encodeDeallocate(uint8(0), ghost().poolId, 0x0, amt));
+        subject().multiprocess(FVMLib.encodeDeallocate(uint8(0), ghost().poolId, amt));
         _;
     }
 
     modifier swapSome(uint128 amt, bool sellAsset) {
         uint128 amtOut = subject().getAmountOut(ghost().poolId, sellAsset, amt).safeCastTo128();
         subject().multiprocess(
-            FVM.encodeSwap(uint8(0), ghost().poolId, 0x0, amt, 0x0, amtOut, uint8(sellAsset ? 1 : 0))
+            FVM.encodeSwap(uint8(0), ghost().poolId, amt, amtOut, uint8(sellAsset ? 1 : 0))
         );
         _;
     }
@@ -250,7 +250,7 @@ contract Setup is Test {
             : amtOut - uint256(-amtOutDelta).safeCastTo128();
 
         subject().multiprocess(
-            FVM.encodeSwap(uint8(0), ghost().poolId, 0x0, amt, 0x0, amtOut, uint8(sellAsset ? 1 : 0))
+            FVM.encodeSwap(uint8(0), ghost().poolId, amt, amtOut, uint8(sellAsset ? 1 : 0))
         );
         _;
     }

test/TestAssemblyLib.t.sol

@@ -13,4 +13,35 @@ contract TestAssemblyLib is Test {
             assertEq(base, 5);
         }
     }
+
+    /*
+    FIXME: These tests are not working yet.
+
+    function testFuzz_isBetween(uint256 value, uint256 lower, uint256 upper) public {
+        vm.assume(lower <= upper);
+        bool valid = AssemblyLib.isBetween(value, lower, upper);
+
+        if (lower >= value && value <= upper) {
+            assertTrue(valid);
+        } else {
+            assertFalse(valid);
+        }
+    }
+
+    function testFuzz_addSignedDelta(uint128 input, int128 delta) public {
+        assertEq(
+            AssemblyLib.addSignedDelta(input, delta),
+            delta < 0 ? uint128(-delta) : uint128(delta)
+        );
+    }
+    */
+
+    function testFuzz_separate(uint8 a, uint8 b) public {
+        vm.assume(a <= 15);
+        vm.assume(b <= 15);
+        bytes1 data = AssemblyLib.pack(bytes1(a), bytes1(b));
+        (bytes1 a_, bytes1 b_) = AssemblyLib.separate(data);
+        assertEq(a, uint8(a_));
+        assertEq(b, uint8(b_));
+    }
 }