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/ACLParams.sol

@@ -0,0 +1,15 @@
+pragma solidity ^0.4.24;
+
+
+contract ACLParams {
+
+    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
+    }
+}

contracts/acl/ACLSyntaxSugar.sol

@@ -4,6 +4,8 @@
 
 pragma solidity ^0.4.24;
 
+import "./ACLParams.sol";
+
 
 contract ACLSyntaxSugar {
     function arr() internal pure returns (uint256[]) {}
@@ -85,18 +87,34 @@ contract ACLSyntaxSugar {
 }
 
 
-contract ACLHelpers {
-    function decodeParamOp(uint256 _x) internal pure returns (uint8 b) {
+contract ACLHelpers is ACLParams {
+
+
+    function decodeParamOp(uint256 _x) public pure returns (uint8 b) {
         return uint8(_x >> (8 * 30));
     }
 
-    function decodeParamId(uint256 _x) internal pure returns (uint8 b) {
+    function decodeParamId(uint256 _x) public pure returns (uint8 b) {
         return uint8(_x >> (8 * 31));
     }
 
-    function decodeParamsList(uint256 _x) internal pure returns (uint32 a, uint32 b, uint32 c) {
+    function decodeParamsList(uint256 _x) public pure returns (uint32 a, uint32 b, uint32 c) {
         a = uint32(_x);
         b = uint32(_x >> (8 * 4));
         c = uint32(_x >> (8 * 8));
     }
+
+    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;
+    }    
 }

contracts/test/TestACLHelpers.sol

@@ -0,0 +1,60 @@
+pragma solidity 0.4.24;
+
+import "./helpers/Assert.sol";
+import "./helpers/ACLHelper.sol";
+import "../acl/ACLSyntaxSugar.sol";
+import "../acl/ACL.sol";
+
+
+contract TestACLHelpers is ACL, ACLHelper {
+
+    function testEncodeParam() public {
+        Param memory param = Param(2, uint8(Op.EQ), 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[](6);
+
+        params[0] = Param(LOGIC_OP_PARAM_ID, uint8(Op.IF_ELSE), encodeIfElse(1, 2, 3));
+        params[1] = Param(LOGIC_OP_PARAM_ID, uint8(Op.AND), encodeOperator(2, 3));   
+        params[2] = Param(2, uint8(Op.EQ), 1);   
+        params[3] = Param(3, uint8(Op.NEQ), 2);                                   
+
+
+        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"); 
+
+        (uint32 id2, uint32 op2, uint32 value2) = decodeParamsList(encodedParam[2]);
+
+        Assert.equal(uint256(params[2].id), uint256(id2), "Encoded id is not equal");
+        Assert.equal(uint256(params[2].op), uint256(op2), "Encoded op is not equal");
+        Assert.equal(uint256(params[2].value), uint256(value2), "Encoded value is not equal");    
+
+        (uint32 id3, uint32 op3, uint32 value3) = decodeParamsList(encodedParam[3]);
+
+        Assert.equal(uint256(params[3].id), uint256(id3), "Encoded id is not equal");
+        Assert.equal(uint256(params[3].op), uint256(op3), "Encoded op is not equal");
+        Assert.equal(uint256(params[3].value), uint256(value3), "Encoded value is not equal");   
+
+    }    
+
+}

test/acl_helpers.js

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