fix(contracts): fix zappify bugs for fully public contracts

Author: lydiagarms

src/boilerplate/contract/solidity/nodes/ContractBoilerplateGenerator.ts

@@ -115,67 +115,67 @@ class ContractBoilerplateGenerator {
       let params : any[];
       let functionName: string;
 
-      for ([functionName, parameterList] of Object.entries(circuitParams)) {
-        for ([paramtype, params] of Object.entries(parameterList)){
-        const returnpara = {};
-        if(paramtype  === 'returnParameters'){
-          returnpara[ paramtype ] = params;
-          delete parameterList[ paramtype ];
-        }
-        const newList: string[] = [];
-        
-        params?.forEach(circuitParamNode => {
-          switch (circuitParamNode.bpType) {
-            case 'nullification':
-              if (circuitParamNode.isNullified) {
-                newList.push('nullifier');
-              } else {
-                // we use a nullification node for accessed, not nullified, states
-                newList.push('checkNullifier')
-              }
-              break;
-            case 'newCommitment':
-              newList.push(circuitParamNode.bpType);
-              break;
-            case 'oldCommitmentExistence':
-              if (!newList.includes(circuitParamNode.bpType)) newList.push(circuitParamNode.bpType);
-              break;
-            case 'encryption':
-              
-              returnpara['encryptionParameters'] ??= [];
-              returnpara['encryptionParameters'].push(circuitParamNode.bpType);
-              break;
-            case undefined: {
-              if (
-                circuitParamNode.nodeType === 'VariableDeclaration' &&
-                !circuitParamNode.isPrivate &&
-                !newList.some(str => str === circuitParamNode.name)
-              ){
-                if (circuitParamNode.typeName?.members) {
-                  newList.push(...circuitParamNode.typeName.members.map(m => `${circuitParamNode.name}.${m.name}`));
+      if (circuitParams) {
+        for ([functionName, parameterList] of Object.entries(circuitParams)) {
+          for ([paramtype, params] of Object.entries(parameterList)) {
+            const returnpara = {};
+            if (paramtype === 'returnParameters') {
+              returnpara[paramtype] = params;
+              delete parameterList[paramtype];
+            }
+            const newList: string[] = [];
+            params?.forEach(circuitParamNode => {
+              switch (circuitParamNode.bpType) {
+                case 'nullification':
+                  if (circuitParamNode.isNullified) {
+                    newList.push('nullifier');
+                  } else {
+                    // we use a nullification node for accessed, not nullified, states
+                    newList.push('checkNullifier')
+                  }
+                  break;
+                case 'newCommitment':
+                  newList.push(circuitParamNode.bpType);
+                  break;
+                case 'oldCommitmentExistence':
+                  if (!newList.includes(circuitParamNode.bpType)) newList.push(circuitParamNode.bpType);
                   break;
-                } else if (circuitParamNode.typeName?.name.includes(`[`)) {
-                  // TODO arrays of structs/structs of arrays/more robust soln
-                  const arrayLen = circuitParamNode.typeName?.name.match(/(?<=\[)(\d+)(?=\])/);
-                  for (let index = 0; index < +arrayLen[0]; index++) {
-                    newList.push(`${circuitParamNode.name}[${index}]`);
+                case 'encryption':
+                  returnpara['encryptionParameters'] ??= [];
+                  returnpara['encryptionParameters'].push(circuitParamNode.bpType);
+                  break;
+                case undefined:
+                  {
+                  if (
+                    circuitParamNode.nodeType === 'VariableDeclaration' &&
+                    !circuitParamNode.isPrivate &&
+                    !newList.some(str => str === circuitParamNode.name)
+                  ){
+                    if (circuitParamNode.typeName?.members) {
+                      newList.push(...circuitParamNode.typeName.members.map(m => `${circuitParamNode.name}.${m.name}`));
+                      break;
+                    } else if (circuitParamNode.typeName?.name.includes(`[`)) {
+                      // TODO arrays of structs/structs of arrays/more robust soln
+                      const arrayLen = circuitParamNode.typeName?.name.match(/(?<=\[)(\d+)(?=\])/);
+                      for (let index = 0; index < +arrayLen[0]; index++) {
+                        newList.push(`${circuitParamNode.name}[${index}]`);
+                      }
+                      break;
+                    } else newList.push(circuitParamNode.name);
                   }
+                }
+                break;
+
+                default:
                   break;
-                } else newList.push(circuitParamNode.name);
               }
-            }
-            break;
-
-            default:
-              break;
+            });
+            parameterList[ paramtype ] = newList;
+            parameterList = {...parameterList, ...returnpara};    
           }
-        });
-        parameterList[ paramtype ] = newList;
-        parameterList = {...parameterList, ...returnpara};    
+          circuitParams[ functionName ] = parameterList;
+        }
       }
-     circuitParams[ functionName ] = parameterList;
-     
-    }
       const constructorContainsSecret = Object.values(this.scope.bindings).some((binding: any) => binding.node.kind === 'constructor');
       return { nullifiersRequired, oldCommitmentAccessRequired, newCommitmentsRequired, containsAccessedOnlyState, encryptionRequired, constructorContainsSecret, circuitParams, isjoinSplitCommitmentsFunction};
     },

src/boilerplate/contract/solidity/raw/ContractBoilerplateGenerator.ts

@@ -226,34 +226,31 @@ class ContractBoilerplateGenerator {
       ];
       const verifyInputs: string[] = [];
       const joinSplitCommitmentsInputs: string[] = [];
-      for (let [name, _params] of Object.entries(circuitParams)) {
-        if (_params) 
-          for (let [type, _inputs] of Object.entries(_params)) {
-            const counter = {
-              customInputs: 0,
-              newNullifiers: 0,
-              checkNullifiers: 0,
-              newCommitments: 0,
-              encryption: 0,
-            };
-            _inputs?.map(i => verifyInputsMap(type, i, counter));
-           
-
-           
-          }
-          
-          if(_params && !(Object.keys(_params).includes('returnParameters')) &&!(Object.keys(_params).includes('encryptionParameters'))) verifyInput.push(`
-            inputs[k++] = 1;`) 
-      
-        verifyInputs.push(`
-          if (functionId == uint(FunctionNames.${name})) {
-            uint k = 0;
-            ${verifyInput.join('')}
-            
-          }`)
-          verifyInput =[];
+      if (circuitParams) {
+        for (let [name, _params] of Object.entries(circuitParams)) {
+          if (_params) 
+            for (let [type, _inputs] of Object.entries(_params)) {
+              const counter = {
+                customInputs: 0,
+                newNullifiers: 0,
+                checkNullifiers: 0,
+                newCommitments: 0,
+                encryption: 0,
+              };
+              _inputs?.map(i => verifyInputsMap(type, i, counter));
+            }
+            if(_params && !(Object.keys(_params).includes('returnParameters')) &&!(Object.keys(_params).includes('encryptionParameters'))) verifyInput.push(`
+              inputs[k++] = 1;`) 
+        
+          verifyInputs.push(`
+            if (functionId == uint(FunctionNames.${name})) {
+              uint k = 0;
+              ${verifyInput.join('')}
+              
+            }`)
+            verifyInput =[];
+        }
       }
-
       const verification: string[] = [
         `
           bool result = verifier.verify(proof, inputs, vks[functionId]);`,

src/transformers/visitors/toContractVisitor.ts

@@ -170,6 +170,7 @@ export default {
       let returnParameterList: any = {};
       let returnfunctionName: string;
       if (
+        state.circuitParams &&
         Object.entries(state.circuitParams) &&
         Object.entries(state.circuitParams).length !== 0
       ) {