Generic transaction decompressor (#180)

.github/workflows/ci.yml

@@ -118,6 +118,22 @@ jobs:
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
 
+  huff-tests:
+    name: Huff tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Install Huff
+        uses: huff-language/huff-toolchain@v2
+        with:
+          version: nightly
+
+      - name: Run tests
+        run: bash ./run_huff_tests.sh
+
   foundry-tests:
     name: Foundry tests
     runs-on: ubuntu-latest
@@ -131,6 +147,11 @@ jobs:
         with:
           version: nightly
 
+      - name: Install Huff
+        uses: huff-language/huff-toolchain@v2
+        with:
+          version: nightly
+
       - name: Run tests
         run: FOUNDRY_FUZZ_RUNS=2048 MAX_ARRAY_LEN=32 forge test -vvv
 
@@ -147,5 +168,10 @@ jobs:
         with:
           version: nightly
 
+      - name: Install Huff
+        uses: huff-language/huff-toolchain@v2
+        with:
+          version: nightly
+
       - name: Run tests
         run: FOUNDRY_FUZZ_RUNS=1024 forge test -vvv

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/foundry-huff"]
+	path = lib/foundry-huff
+	url = https://github.com/huff-language/foundry-huff

contracts/modules/commons/submodules/auth/SequenceBaseSig.sol

@@ -15,13 +15,13 @@ import "../../../../utils/LibOptim.sol";
 library SequenceBaseSig {
   using LibBytesPointer for bytes;
 
-  uint256 private constant FLAG_SIGNATURE = 0;
-  uint256 private constant FLAG_ADDRESS = 1;
-  uint256 private constant FLAG_DYNAMIC_SIGNATURE = 2;
-  uint256 private constant FLAG_NODE = 3;
-  uint256 private constant FLAG_BRANCH = 4;
-  uint256 private constant FLAG_SUBDIGEST = 5;
-  uint256 private constant FLAG_NESTED = 6;
+  uint256 internal constant FLAG_SIGNATURE = 0;
+  uint256 internal constant FLAG_ADDRESS = 1;
+  uint256 internal constant FLAG_DYNAMIC_SIGNATURE = 2;
+  uint256 internal constant FLAG_NODE = 3;
+  uint256 internal constant FLAG_BRANCH = 4;
+  uint256 internal constant FLAG_SUBDIGEST = 5;
+  uint256 internal constant FLAG_NESTED = 6;
 
   error InvalidNestedSignature(bytes32 _hash, address _addr, bytes _signature);
   error InvalidSignatureFlag(uint256 _flag);

contracts/modules/commons/submodules/nonce/SubModuleNonce.sol

@@ -27,4 +27,11 @@ library SubModuleNonce {
       _nonce = uint256(bytes32(_rawNonce) & NONCE_MASK);
     }
   }
+
+  function encodeNonce(uint256 _space, uint256 _nonce) internal pure returns (uint256) {
+    unchecked {
+      // Combine space and nonce
+      return (_space << NONCE_BITS) | _nonce;
+    }
+  }
 }

contracts/utils/LibBytes.sol

@@ -80,4 +80,27 @@ library LibBytes {
       a := shr(224, word)
     }
   }
+
+  function readMBytes4(
+    bytes memory data,
+    uint256 index
+  ) internal pure returns (
+    bytes4 a
+  ) {
+    assembly {
+      let word := mload(add(add(data, 0x20), index))
+      a := and(word, 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000)
+    }
+  }
+
+  function readMBytes32(
+    bytes memory data,
+    uint256 index
+  ) internal pure returns (
+    bytes32 a
+  ) {
+    assembly {
+      a := mload(add(add(data, 0x20), index))
+    }
+  }
 }

contracts/utils/LibBytesPointer.sol

@@ -52,6 +52,20 @@ library LibBytesPointer {
     }
   }
 
+  function readAddress(
+    bytes calldata _data,
+    uint256 _index
+  ) internal pure returns (
+    address a,
+    uint256 newPointer
+  ) {
+    assembly {
+      let word := calldataload(add(_index, _data.offset))
+      a := and(shr(96, word), 0xffffffffffffffffffffffffffffffffffffffff)
+      newPointer := add(_index, 20)
+    }
+  }
+
   /**
    * @notice Returns the uint8 value and the address at the given index in the input data and updates the pointer.
    * @param _data The input data.
@@ -97,6 +111,22 @@ library LibBytesPointer {
     }
   }
 
+  function readUintX(
+    bytes calldata _data,
+    uint256 _bytes,
+    uint256 _index
+  ) internal pure returns (
+    uint256 a,
+    uint256 newPointer
+  ) {
+    assembly {
+      let word := calldataload(add(_index, _data.offset))
+      let shift := sub(256, mul(_bytes, 8))
+      a := and(shr(shift, word), sub(shl(mul(8, _bytes), 1), 1))
+      newPointer := add(_index, _bytes)
+    }
+  }
+
   /**
    * @notice Returns the uint24 value at the given index in the input data and updates the pointer.
    * @param _data The input data.
@@ -139,6 +169,20 @@ library LibBytesPointer {
     }
   }
 
+  function readBytes4(
+    bytes calldata _data,
+    uint256 _pointer
+  ) internal pure returns (
+    bytes4 a,
+    uint256 newPointer
+  ) {
+    assembly {
+      a := calldataload(add(_pointer, _data.offset))
+      a := and(a, 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000)
+      newPointer := add(_pointer, 4)
+    }
+  }
+
   /**
    * @notice Returns the bytes32 value at the given index in the input data and updates the pointer.
    * @param _data The input data.

foundry.toml

@@ -3,3 +3,4 @@ src = 'contracts'
 out = 'foundry_artifacts'
 libs = ["node_modules", "lib"]
 test = 'foundry_test'
+ffi = true