Merge pull request #238 from EYBlockchain/lydia/incrementation_error

Lydia/incrementation error

src/boilerplate/circuit/zokrates/nodes/BoilerplateGenerator.ts

@@ -181,7 +181,6 @@ class BoilerplateGenerator {
         if (!mappingKeyIndicator.keyPath.isMsg() &&
         (mappingKeyIndicator.keyPath.node.nodeType === 'Literal'|| mappingKeyIndicator.keyPath.isLocalStackVariable() || !mappingKeyIndicator.keyPath.isSecret))
           this.mappingKeyTypeName = 'local';
-
         this.mappingName = this.indicators.name;
         this.name = `${this.mappingName}_${mappingKeyName}`.replaceAll('.', 'dot').replace('[', '_').replace(']', '');
 

src/boilerplate/orchestration/javascript/raw/toOrchestration.ts

@@ -135,8 +135,18 @@ export const generateProofBoilerplate = (node: any) => {
     const msgValueParamAndMappingKey = stateNode.isMapping && (node.parameters.includes('msgValue') || output.join().includes('_msg_stateVarId_key.integer')) && stateNode.stateVarId[1] === 'msg';
 
     const constantMappingKey = stateNode.isMapping && (+stateNode.stateVarId[1] || stateNode.stateVarId[1] === '0');
+
+    // Check if the mapping is already included in the parameters
+    let name: string;
+    let state: any;
+    let isIncluded = false;
+    for ([name, state] of Object.entries(node.privateStates)) {
+      if (stateNode.stateVarId[0] === state.stateVarId[0] && stateName != name && node.parameters.includes(state.stateVarId[1]) ) {
+        isIncluded = true;
+      }
+    }
     const stateVarIdLines =
-      stateNode.isMapping && !node.parameters.includes(stateNode.stateVarId[1]) && !msgSenderParamAndMappingKey && !msgValueParamAndMappingKey && !constantMappingKey
+      stateNode.isMapping && !(node.parameters.includes(stateNode.stateVarId[1])) && !(node.parameters.includes(stateNode.stateVarId[2])) && !isIncluded && !msgSenderParamAndMappingKey && !msgValueParamAndMappingKey && !constantMappingKey
         ? [`\n\t\t\t\t\t\t\t\t${stateName}_stateVarId_key.integer,`]
         : [];
     // we add any extra params the circuit needs

src/codeGenerators/circuit/zokrates/toCircuit.ts

@@ -118,7 +118,6 @@ function codeGenerator(node: any) {
 
     case 'ParameterList': {
       const paramList = CircuitBP.uniqueify(node.parameters.flatMap(codeGenerator));
-
       // we also need to identify and remove duplicate params prefixed with conflicting 'public'/'private' keywords (prioritising 'public')
       const slicedParamList = paramList.map(p =>
         p.replace('public ', '').replace('private ', ''),
@@ -170,7 +169,8 @@ function codeGenerator(node: any) {
 
     case 'Block': {
       const preStatements = CircuitBP.uniqueify(node.preStatements.flatMap(codeGenerator));
-      const statements = CircuitBP.uniqueify(node.statements.flatMap(codeGenerator));
+      // TO DO: We don't remove duplicate statements below because of duplicate statements in the contract. This could cause issues.
+      const statements = node.statements.flatMap(codeGenerator);
       const postStatements = CircuitBP.uniqueify(node.postStatements.flatMap(codeGenerator));
       return [...preStatements, ...statements, ...postStatements].join('\n\n');
     }

src/codeGenerators/contract/solidity/toContract.ts

@@ -143,7 +143,8 @@ function codeGenerator(node: any) {
       const preStatements: string = node.preStatements.flatMap(codeGenerator);
       const statements: string = node.statements.flatMap(codeGenerator);
       const postStatements: string = node.postStatements.flatMap(codeGenerator);
-      return [...preStatements, ...statements, ...postStatements].join('\n');
+      //We have changed the order here so that statements is after poststatements because we need the statements to appear after proof generation. This could cause issues. 
+      return [...preStatements, ...postStatements, ...statements].join('\n');
     }
     case 'ExpressionStatement':{
       return codeGenerator(node.expression);

src/codeGenerators/orchestration/nodejs/toOrchestration.ts

@@ -23,7 +23,8 @@ const getAccessedValue = (name: string) => {
  */
 const getPublicValue = (node: any) => {
   if (node.nodeType !== 'IndexAccess')
-    return `\nlet ${node.name} = generalise(await instance.methods.${codeGenerator(node)}().call());`;
+    // In the _init variable we save the initial value of the variable for use later. 
+    return `\nlet ${node.name} = generalise(await instance.methods.${codeGenerator(node)}().call());\n let ${node.name}_init = ${node.name};`;
   return `\nconst ${node.name} = generalise(await instance.methods.${codeGenerator(node.baseExpression, { lhs: true} )}(${codeGenerator(node.indexExpression, { contractCall: true })}).call());`;
 };
 
@@ -83,7 +84,7 @@ export default function codeGenerator(node: any, options: any = {}): any {
         }
         if (node.declarations[0].isStruct) return `\n let ${codeGenerator(node.declarations[0])} = {}; \n${codeGenerator(node.initialValue)};`;
         return `\nlet ${codeGenerator(node.initialValue)};`;
-      } else if (node.declarations[0].isAccessed && !node.declarations[0].isSecret) {
+      } else if (node.declarations[0].isAccessed && !node.declarations[0].isSecret) { 
         return `${getPublicValue(node.declarations[0])}`
       } else if (node.declarations[0].isAccessed) {
         return `${getAccessedValue(node.declarations[0].name)}`;
@@ -126,16 +127,31 @@ export default function codeGenerator(node: any, options: any = {}): any {
      return " ";
 
     case 'Assignment':
-      if (['+=', '-=', '*='].includes(node.operator)) {
-        return `${codeGenerator(node.leftHandSide, {
-          lhs: true,
-        })} = ${codeGenerator(node.leftHandSide)} ${node.operator.charAt(
-          0,
-        )} ${codeGenerator(node.rightHandSide)}`;
+      // To ensure the left hand side is always a general number, we generalise it here (excluding the initialisation in a for loop). 
+      if (!node.isInitializationAssignment && node.rightHandSide.subType !== 'generalNumber'){
+        if (['+=', '-=', '*='].includes(node.operator)) {
+          return `${codeGenerator(node.leftHandSide, {
+            lhs: true,
+          })} = generalise(${codeGenerator(node.leftHandSide)} ${node.operator.charAt(
+            0,
+          )} ${codeGenerator(node.rightHandSide)})`;
+        }
+        return `${codeGenerator(node.leftHandSide, { lhs: true })} ${
+          node.operator
+        } generalise(${codeGenerator(node.rightHandSide)})`;
+      } else {
+        if (['+=', '-=', '*='].includes(node.operator)) {
+          return `${codeGenerator(node.leftHandSide, {
+            lhs: true,
+          })} = ${codeGenerator(node.leftHandSide)} ${node.operator.charAt(
+            0,
+          )} ${codeGenerator(node.rightHandSide)}`;
+        }
+        return `${codeGenerator(node.leftHandSide, { lhs: true })} ${
+          node.operator
+        } ${codeGenerator(node.rightHandSide)}`;
       }
-      return `${codeGenerator(node.leftHandSide, { lhs: true })} ${
-        node.operator
-      } ${codeGenerator(node.rightHandSide)}`;
+
 
     case 'BinaryOperation':
       return `${codeGenerator(node.leftExpression, { lhs: options.condition })} ${
@@ -192,7 +208,7 @@ export default function codeGenerator(node: any, options: any = {}): any {
 
     case 'UnaryOperation':
       // ++ or -- on a parseInt() does not work
-      return `generalise(${node.subExpression.name}.integer${node.operator})`;
+      return `parseInt(${node.subExpression.name}.integer,10)${node.operator[0]}1`;
 
     case 'Literal':
       return node.value;

src/transformers/visitors/checks/incrementedVisitor.ts

@@ -238,6 +238,7 @@ export default {
       const { operator, leftHandSide, rightHandSide } = node;
       const lhsSecret = !!scope.getReferencedBinding(leftHandSide)?.isSecret;
 
+
       if (['bool', 'address'].includes(leftHandSide.typeDescriptions.typeString)) {
         markParentIncrementation(path, state, false, false, leftHandSide);
         const lhsBinding = scope.getReferencedBinding(leftHandSide)
@@ -272,27 +273,25 @@ export default {
       }
 
       // a *= something, a /= something
-      // OR lhs non-secret - we don't care about those
       if (
         operator === '%=' ||
         operator === '/=' ||
-        operator === '*=' ||
-        !lhsSecret
+        operator === '*=' 
       ) {
         markParentIncrementation(path, state, false, false, leftHandSide);
         return;
       }
 
       // after +=, -=, %=, *=, /=, we can only deal with =
-      if (operator !== '=' && operator !== '+=' && operator !== '-=')
+      if ((operator !== '=' && operator !== '+=' && operator !== '-=')  && lhsSecret)
         throw new TODOError(
           `Operator '${operator}' not yet supported. Please open an issue.`,
           node,
         );
 
       // then, it depends what's on the RHS of the assignment, so we continue
       // we save the LHS node to help us later
-      state.incrementedIdentifier = leftHandSide.baseExpression || leftHandSide;
+      if (lhsSecret) state.incrementedIdentifier = leftHandSide.baseExpression || leftHandSide;
     },
   },