encodeParam and encodeParams functions

contracts/acl/ACL.sol

@@ -15,16 +15,6 @@ contract ACL is IACL, TimeHelpers, AragonApp, ACLHelpers {
     */
     bytes32 public constant CREATE_PERMISSIONS_ROLE = 0x0b719b33c83b8e5d300c521cb8b54ae9bd933996a14bef8c2f4e0285d2d2400a;
 
-    enum Op { NONE, EQ, NEQ, GT, LT, GTE, LTE, RET, NOT, AND, OR, XOR, IF_ELSE } // op types
-
-    struct Param {
-        uint8 id;
-        uint8 op;
-        uint240 value; // even though value is an uint240 it can store addresses
-        // in the case of 32 byte hashes losing 2 bytes precision isn't a huge deal
-        // op and id take less than 1 byte each so it can be kept in 1 sstore
-    }
-
     uint8 internal constant BLOCK_NUMBER_PARAM_ID = 200;
     uint8 internal constant TIMESTAMP_PARAM_ID    = 201;
     // 202 is unused

contracts/acl/ACLSyntaxSugar.sol

@@ -86,6 +86,31 @@ contract ACLSyntaxSugar {
 
 
 contract ACLHelpers {
+
+    enum Op { NONE, EQ, NEQ, GT, LT, GTE, LTE, RET, NOT, AND, OR, XOR, IF_ELSE } // op types
+
+    struct Param {
+        uint8 id;
+        uint8 op;
+        uint240 value; // even though value is an uint240 it can store addresses
+        // in the case of 32 byte hashes losing 2 bytes precision isn't a huge deal
+        // op and id take less than 1 byte each so it can be kept in 1 sstore
+    }
+
+    function encodeParams(Param[] params) internal pure returns (uint256[]) {
+        uint256[] memory encodedParams = new uint256[](params.length);
+
+        for (uint i = 0; i < params.length; i++) {
+            encodedParams[i] = encodeParam(params[i]);
+        }
+
+        return encodedParams;
+    }
+
+    function encodeParam(Param param) internal pure returns (uint256) {
+        return uint256(param.id) << 248 | uint256(param.op) << 240 | param.value;
+    }
+
     function decodeParamOp(uint256 _x) internal pure returns (uint8 b) {
         return uint8(_x >> (8 * 30));
     }

contracts/test/TestACLHelpers.sol

@@ -0,0 +1,56 @@
+pragma solidity 0.4.24;
+
+import "./helpers/Assert.sol";
+import "../acl/ACLSyntaxSugar.sol";
+
+
+contract TestACLHelpers is ACLHelpers {
+
+    function testEncodeParam() public {
+        Param memory param = Param({ 
+            id: 2,
+            op: uint8(Op.EQ),
+            value: 5294967297
+        });
+
+        uint256 encodedParam = encodeParam(param);
+
+        (uint32 id, uint32 op, uint32 value) = decodeParamsList(encodedParam);
+
+        Assert.equal(uint256(param.id), uint256(id), "Encoded id is not equal");
+        Assert.equal(uint256(param.op), uint256(op), "Encoded op is not equal");
+        Assert.equal(uint256(param.value), uint256(value), "Encoded value is not equal");
+    }
+
+    function testEncodeParams() public {
+        Param[] memory params = new Param[](2);
+
+        params[0] = Param({ 
+            id: 1,
+            op: uint8(Op.EQ),
+            value: 5294967297
+        });
+
+        params[1] = Param({ 
+            id: 2,
+            op: uint8(Op.EQ),
+            value: 5294967297
+        });
+
+
+        uint256[] memory encodedParam = encodeParams(params);
+
+        (uint32 id0, uint32 op0, uint32 value0) = decodeParamsList(encodedParam[0]);
+
+        Assert.equal(uint256(params[0].id), uint256(id0), "Encoded id is not equal");
+        Assert.equal(uint256(params[0].op), uint256(op0), "Encoded op is not equal");
+        Assert.equal(uint256(params[0].value), uint256(value0), "Encoded value is not equal");
+
+        (uint32 id1, uint32 op1, uint32 value1) = decodeParamsList(encodedParam[1]);
+
+        Assert.equal(uint256(params[1].id), uint256(id1), "Encoded id is not equal");
+        Assert.equal(uint256(params[1].op), uint256(op1), "Encoded op is not equal");
+        Assert.equal(uint256(params[1].value), uint256(value1), "Encoded value is not equal");        
+    }    
+
+}

test/acl_helpers.js

@@ -0,0 +1,3 @@
+const runSolidityTest = require('./helpers/runSolidityTest')
+
+runSolidityTest('TestACLHelpers')