Simplify generation code and reduce warnings.

Author: murisi

contracts/test/ProtocolAdapterMock.t.sol

@@ -219,13 +219,13 @@ contract ProtocolAdapterMockVerifierTest is Test {
         _mockPa.execute(txn);
     }
 
-    uint256 public constant MAX_ACTION_PARAMS = 4;
+    uint256 public constant MAX_ACTIONS = 4;
     uint256 public constant MAX_RESOURCES = 4;
 
     struct ActionParams {
         Resource[2][MAX_RESOURCES] resources;
-        uint256[MAX_RESOURCES] bijections;
-        uint256 len;
+        uint256[MAX_RESOURCES] bijection;
+        uint256 targetResourcesLen;
     }
 
     function commitment(Resource memory resource) internal pure returns (bytes32 hash) {
@@ -244,15 +244,15 @@ contract ProtocolAdapterMockVerifierTest is Test {
         root = SHA256.EMPTY_HASH;
     }
 
-    function truncate_resources(Resource[2][MAX_RESOURCES] memory resources, uint256 len) public returns (Resource[2][] memory truncatedResources) {
+    function truncateResources(Resource[2][MAX_RESOURCES] memory resources, uint256 len) public pure returns (Resource[2][] memory truncatedResources) {
         truncatedResources = new Resource[2][](len);
         for (uint256 i = 0; i < len; i++) {
             truncatedResources[i][0] = resources[i][0];
             truncatedResources[i][1] = resources[i][1];
         }
     }
 
-    function generateBijection(uint256[MAX_RESOURCES] memory input, uint256 len) public returns (uint256[] memory output) {
+    function generateBijection(uint256[MAX_RESOURCES] memory input, uint256 len) public pure returns (uint256[] memory output) {
         output = new uint256[](len);
         uint256[] memory duplicates = new uint256[](len);
         uint256 duplicateCount = 0;
@@ -275,23 +275,25 @@ contract ProtocolAdapterMockVerifierTest is Test {
         }
     }
 
-    function generate_action(ActionParams memory params) public returns (Action memory action, uint256 totalValueCommitmentRandomness) {
-        Resource[2][] memory truncatedResources = truncate_resources(params.resources, params.len % MAX_RESOURCES);
+    function generateAction(ActionParams memory params) public returns (Action memory action, uint256 totalValueCommitmentRandomness) {
+        Resource[2][] memory truncatedResources = truncateResources(params.resources, params.targetResourcesLen % MAX_RESOURCES);
         action.logicVerifierInputs = new Logic.VerifierInput[](truncatedResources.length * 2);
         action.complianceVerifierInputs = new Compliance.VerifierInput[](truncatedResources.length);
+        // Created empty app data for all the resources
         Logic.AppData memory appData = Logic.AppData({
             resourcePayload: new Logic.ExpirableBlob[](0),
             discoveryPayload: new Logic.ExpirableBlob[](0),
             externalPayload: new Logic.ExpirableBlob[](0),
             applicationPayload: new Logic.ExpirableBlob[](0)
         });
-
-        uint256[] memory bijections = generateBijection(params.bijections, truncatedResources.length);
+        // Match the created and consumed resources
+        uint256[] memory bijection = generateBijection(params.bijection, truncatedResources.length);
         for (uint256 i = 0; i < truncatedResources.length; ++i) {
-            truncatedResources[bijections[i]][1].quantity = truncatedResources[i][0].quantity;
-            truncatedResources[bijections[i]][1].logicRef = truncatedResources[i][0].logicRef;
-            truncatedResources[bijections[i]][1].labelRef = truncatedResources[i][0].labelRef;
+            truncatedResources[bijection[i]][1].quantity = truncatedResources[i][0].quantity;
+            truncatedResources[bijection[i]][1].logicRef = truncatedResources[i][0].logicRef;
+            truncatedResources[bijection[i]][1].labelRef = truncatedResources[i][0].labelRef;
         }
+        // Compute action tree tags and action tree root
         bytes32[] memory actionTreeTags = new bytes32[](2 * truncatedResources.length);
         for (uint256 i = 0; i < truncatedResources.length; ++i) {
             uint256 index = (i * 2);
@@ -300,67 +302,72 @@ contract ProtocolAdapterMockVerifierTest is Test {
             actionTreeTags[index + 1] = commitment(truncatedResources[i][1]);
         }
         bytes32 actionTreeRoot = actionTreeTags.computeRoot();
+        // Create logic and compliance verifier inputs
         totalValueCommitmentRandomness = 0;
-
         for (uint256 i = 0; i < truncatedResources.length; i++) {
-            bytes32 nullifier = nullifier(truncatedResources[i][0], 0);
-            bytes32 commitment = commitment(truncatedResources[i][1]);
-            
+            Resource memory consumedResource = truncatedResources[i][0];
+            Resource memory createdResource = truncatedResources[i][1];
+            bytes32 nf = nullifier(consumedResource, 0);
+            bytes32 cm = commitment(createdResource);
+
+            // Created logic verifier input for a consumed resource
             action.logicVerifierInputs[2*i] = Logic.VerifierInput({
-                tag: nullifier,
-                verifyingKey: truncatedResources[i][0].logicRef,
+                tag: nf,
+                verifyingKey: consumedResource.logicRef,
                 proof: "",
                 appData: appData
             });
             action.logicVerifierInputs[2*i].proof = _mockVerifier.mockProve({
-                imageId: truncatedResources[i][0].logicRef,
+                imageId: consumedResource.logicRef,
                 journalDigest: sha256(action.logicVerifierInputs[2*i].toJournal(actionTreeRoot, true))
             }).seal;
-            
+            // Create logic verifier input for a created resource
             action.logicVerifierInputs[2*i + 1] = Logic.VerifierInput({
-                tag: commitment,
-                verifyingKey: truncatedResources[i][1].logicRef,
+                tag: cm,
+                verifyingKey: createdResource.logicRef,
                 proof: "",
                 appData: appData
             });
             action.logicVerifierInputs[2*i + 1].proof = _mockVerifier.mockProve({
-                imageId: truncatedResources[i][1].logicRef,
+                imageId: createdResource.logicRef,
                 journalDigest: sha256(action.logicVerifierInputs[2*i + 1].toJournal(actionTreeRoot, false))
             }).seal;
-
+            // Create the delta for the consumed resource
             Delta.CurvePoint memory unitDelta = DeltaGen.generateInstance(
                 vm,
                 DeltaGen.InstanceInputs({
-                    kind: kind(truncatedResources[i][0]),
-                    quantity: truncatedResources[i][0].quantity,
+                    kind: kind(consumedResource),
+                    quantity: consumedResource.quantity,
                     consumed: true,
                     valueCommitmentRandomness: 1
                 })
             );
+            // Add the delta for the created resource
             unitDelta = Delta.add(
                 unitDelta,
                 DeltaGen.generateInstance(
                     vm,
                     DeltaGen.InstanceInputs({
-                        kind: kind(truncatedResources[i][1]),
-                        quantity: truncatedResources[i][1].quantity,
+                        kind: kind(createdResource),
+                        quantity: createdResource.quantity,
                         consumed: false,
                         valueCommitmentRandomness: 1
                     })
                 )
             );
             totalValueCommitmentRandomness += 2;
+            // Create the compliance verifier input
             Compliance.Instance memory instance = Compliance.Instance({
                 unitDeltaX: bytes32(unitDelta.x),
                 unitDeltaY: bytes32(unitDelta.y),
                 consumed: Compliance.ConsumedRefs({
-                    nullifier: nullifier,
-                    logicRef: truncatedResources[i][0].logicRef,
+                    nullifier: nf,
+                    logicRef: consumedResource.logicRef,
                     commitmentTreeRoot: initialRoot()
                     }),
                 created: Compliance.CreatedRefs({
-                    commitment: commitment,
-                    logicRef: truncatedResources[i][1].logicRef
+                    commitment: cm,
+                    logicRef: createdResource.logicRef
                     })
                 });
             action.complianceVerifierInputs[i] = Compliance.VerifierInput({
@@ -370,22 +377,21 @@ contract ProtocolAdapterMockVerifierTest is Test {
         }
     }
 
-    function truncate_action_params(ActionParams[MAX_ACTION_PARAMS] memory params, uint256 len) public returns (ActionParams[] memory truncatedParams) {
-        truncatedParams = new ActionParams[](len);
-        for (uint256 i = 0; i < len; i++) {
-            truncatedParams[i] = params[i];
-        }
+    struct TransactionParams {
+        ActionParams[MAX_ACTIONS] actionParams;
+        uint256 targetActionsLen;
     }
 
-    function test_random_transactions(ActionParams[MAX_ACTION_PARAMS] memory actionParams, uint256 actionParamsLen) public {
-        ActionParams[] memory truncatedActionParams = truncate_action_params(actionParams, actionParamsLen % MAX_ACTION_PARAMS);
-        Action[] memory actions = new Action[](truncatedActionParams.length);
+    function generateTransaction(TransactionParams memory params) public returns (Transaction memory txn) {
+        // Generate actions
+        Action[] memory actions = new Action[](params.targetActionsLen % MAX_ACTIONS);
         uint256 totalValueCommitmentRandomness = 0;
         for (uint256 i = 0; i < actions.length; i++) {
             uint256 valueCommitmentRandomness;
-            (actions[i], valueCommitmentRandomness) = generate_action(truncatedActionParams[i]);
+            (actions[i], valueCommitmentRandomness) = generateAction(params.actionParams[i]);
             totalValueCommitmentRandomness += valueCommitmentRandomness;
         }
+        // Generate delta proof
         bytes memory proof = "";
         bytes32[] memory tags = TxGen.collectTags(actions);
         if (tags.length != 0) {
@@ -397,12 +403,16 @@ contract ProtocolAdapterMockVerifierTest is Test {
                 })
             );
         }
-        Transaction memory txn = Transaction({
+        // Generate transaction
+        txn = Transaction({
             actions: actions,
             deltaProof: proof,
             aggregationProof: ""
         });
-        _mockPa.execute(txn);
+    }
+
+    function test_random_transactions_execute(TransactionParams memory params) public {
+        _mockPa.execute(generateTransaction(params));
     }
 
     function test_execute_reverts_on_pre_existing_nullifier() public {