@taquito/michel-codec 11.2.0 → 12.0.1

package/dist/lib/michelson-validator.js

@@ -5,37 +5,150 @@ const utils_1 = require("./utils");
 // Michelson validator
 const maxViewNameLength = 31;
 const noArgInstructionIDs = {
-    "ABS": true, "ADD": true, "ADDRESS": true, "AMOUNT": true, "AND": true, "APPLY": true, "BALANCE": true,
-    "BLAKE2B": true, "CAR": true, "CDR": true, "CHAIN_ID": true, "CHECK_SIGNATURE": true, "COMPARE": true, "CONCAT": true, "CONS": true, "EDIV": true,
-    "EQ": true, "EXEC": true, "FAILWITH": true, "GE": true, "GET_AND_UPDATE": true, "GT": true, "HASH_KEY": true, "IMPLICIT_ACCOUNT": true,
-    "INT": true, "ISNAT": true, "JOIN_TICKETS": true, "KECCAK": true, "LE": true, "LEVEL": true, "LSL": true, "LSR": true, "LT": true, "MEM": true, "MUL": true,
-    "NEG": true, "NEQ": true, "NEVER": true, "NOT": true, "NOW": true, "OR": true, "PACK": true, "PAIRING_CHECK": true, "READ_TICKET": true,
-    "SAPLING_VERIFY_UPDATE": true, "SELF": true, "SELF_ADDRESS": true, "SENDER": true, "SET_DELEGATE": true, "SHA256": true, "SHA3": true,
-    "SHA512": true, "SIZE": true, "SLICE": true, "SOME": true, "SOURCE": true, "SPLIT_TICKET": true, "SUB": true, "SWAP": true, "TICKET": true,
-    "TOTAL_VOTING_POWER": true, "TRANSFER_TOKENS": true, "UNIT": true, "VOTING_POWER": true, "XOR": true, "RENAME": true, "OPEN_CHEST": true,
+    ABS: true,
+    ADD: true,
+    ADDRESS: true,
+    AMOUNT: true,
+    AND: true,
+    APPLY: true,
+    BALANCE: true,
+    BLAKE2B: true,
+    CAR: true,
+    CDR: true,
+    CHAIN_ID: true,
+    CHECK_SIGNATURE: true,
+    COMPARE: true,
+    CONCAT: true,
+    CONS: true,
+    EDIV: true,
+    EQ: true,
+    EXEC: true,
+    FAILWITH: true,
+    GE: true,
+    GET_AND_UPDATE: true,
+    GT: true,
+    HASH_KEY: true,
+    IMPLICIT_ACCOUNT: true,
+    INT: true,
+    ISNAT: true,
+    JOIN_TICKETS: true,
+    KECCAK: true,
+    LE: true,
+    LEVEL: true,
+    LSL: true,
+    LSR: true,
+    LT: true,
+    MEM: true,
+    MUL: true,
+    NEG: true,
+    NEQ: true,
+    NEVER: true,
+    NOT: true,
+    NOW: true,
+    OR: true,
+    PACK: true,
+    PAIRING_CHECK: true,
+    READ_TICKET: true,
+    SAPLING_VERIFY_UPDATE: true,
+    SELF: true,
+    SELF_ADDRESS: true,
+    SENDER: true,
+    SET_DELEGATE: true,
+    SHA256: true,
+    SHA3: true,
+    SHA512: true,
+    SIZE: true,
+    SLICE: true,
+    SOME: true,
+    SOURCE: true,
+    SPLIT_TICKET: true,
+    SUB: true,
+    SWAP: true,
+    TICKET: true,
+    TOTAL_VOTING_POWER: true,
+    TRANSFER_TOKENS: true,
+    UNIT: true,
+    VOTING_POWER: true,
+    XOR: true,
+    RENAME: true,
+    OPEN_CHEST: true,
+    SUB_MUTEZ: true,
 };
 exports.instructionIDs = Object.assign({}, noArgInstructionIDs, {
-    "CONTRACT": true, "CREATE_CONTRACT": true, "DIG": true, "DIP": true, "DROP": true,
-    "DUG": true, "DUP": true, "EMPTY_BIG_MAP": true, "EMPTY_MAP": true, "EMPTY_SET": true, "GET": true, "IF": true, "IF_CONS": true, "IF_LEFT": true,
-    "IF_NONE": true, "ITER": true, "LAMBDA": true, "LEFT": true, "LOOP": true, "LOOP_LEFT": true, "MAP": true, "NIL": true, "NONE": true, "PAIR": true,
-    "PUSH": true, "RIGHT": true, "SAPLING_EMPTY_STATE": true, "UNPACK": true, "UNPAIR": true, "UPDATE": true, "CAST": true, "VIEW": true,
+    CONTRACT: true,
+    CREATE_CONTRACT: true,
+    DIG: true,
+    DIP: true,
+    DROP: true,
+    DUG: true,
+    DUP: true,
+    EMPTY_BIG_MAP: true,
+    EMPTY_MAP: true,
+    EMPTY_SET: true,
+    GET: true,
+    IF: true,
+    IF_CONS: true,
+    IF_LEFT: true,
+    IF_NONE: true,
+    ITER: true,
+    LAMBDA: true,
+    LEFT: true,
+    LOOP: true,
+    LOOP_LEFT: true,
+    MAP: true,
+    NIL: true,
+    NONE: true,
+    PAIR: true,
+    PUSH: true,
+    RIGHT: true,
+    SAPLING_EMPTY_STATE: true,
+    UNPACK: true,
+    UNPAIR: true,
+    UPDATE: true,
+    CAST: true,
+    VIEW: true,
 });
 const simpleComparableTypeIDs = {
-    "unit": true, "never": true, "bool": true, "int": true, "nat": true, "string": true,
-    "chain_id": true, "bytes": true, "mutez": true, "key_hash": true, "key": true,
-    "signature": true, "timestamp": true, "address": true,
+    unit: true,
+    never: true,
+    bool: true,
+    int: true,
+    nat: true,
+    string: true,
+    chain_id: true,
+    bytes: true,
+    mutez: true,
+    key_hash: true,
+    key: true,
+    signature: true,
+    timestamp: true,
+    address: true,
 };
 const typeIDs = Object.assign({}, simpleComparableTypeIDs, {
-    "or": true, "pair": true, "set": true, "big_map": true, "contract": true, "lambda": true,
-    "list": true, "map": true, "operation": true, "option": true, "bls12_381_g1": true,
-    "bls12_381_g2": true, "bls12_381_fr": true, "sapling_transaction": true, "sapling_state": true, "ticket": true,
-    "chest_key": true, "chest": true,
+    or: true,
+    pair: true,
+    set: true,
+    big_map: true,
+    contract: true,
+    lambda: true,
+    list: true,
+    map: true,
+    operation: true,
+    option: true,
+    bls12_381_g1: true,
+    bls12_381_g2: true,
+    bls12_381_fr: true,
+    sapling_transaction: true,
+    sapling_state: true,
+    ticket: true,
+    chest_key: true,
+    chest: true,
 });
 class MichelsonValidationError extends utils_1.MichelsonError {
     /**
-    * @param val Value of a node caused the error
-    * @param message An error message
-    */
+     * @param val Value of a node caused the error
+     * @param message An error message
+     */
     constructor(val, message) {
         super(val, message);
         this.val = val;
@@ -44,45 +157,45 @@ class MichelsonValidationError extends utils_1.MichelsonError {
 }
 exports.MichelsonValidationError = MichelsonValidationError;
 function isPrim(ex) {
-    return "prim" in ex;
+    return 'prim' in ex;
 }
 function isPrimOrSeq(ex) {
-    return Array.isArray(ex) || "prim" in ex;
+    return Array.isArray(ex) || 'prim' in ex;
 }
 function assertPrim(ex) {
     if (isPrim(ex)) {
         return true;
     }
-    throw new MichelsonValidationError(ex, "prim expression expected");
+    throw new MichelsonValidationError(ex, 'prim expression expected');
 }
 function assertSeq(ex) {
     if (Array.isArray(ex)) {
         return true;
     }
-    throw new MichelsonValidationError(ex, "sequence expression expected");
+    throw new MichelsonValidationError(ex, 'sequence expression expected');
 }
 function assertPrimOrSeq(ex) {
     if (isPrimOrSeq(ex)) {
         return true;
     }
-    throw new MichelsonValidationError(ex, "prim or sequence expression expected");
+    throw new MichelsonValidationError(ex, 'prim or sequence expression expected');
 }
 function assertNatural(i) {
-    if (i.int[0] === "-") {
-        throw new MichelsonValidationError(i, "natural number expected");
+    if (i.int[0] === '-') {
+        throw new MichelsonValidationError(i, 'natural number expected');
     }
 }
 function assertIntLiteral(ex) {
-    if ("int" in ex) {
+    if ('int' in ex) {
         return true;
     }
-    throw new MichelsonValidationError(ex, "int literal expected");
+    throw new MichelsonValidationError(ex, 'int literal expected');
 }
 function assertStringLiteral(ex) {
-    if ("string" in ex) {
+    if ('string' in ex) {
         return true;
     }
-    throw new MichelsonValidationError(ex, "string literal expected");
+    throw new MichelsonValidationError(ex, 'string literal expected');
 }
 function assertArgs(ex, n) {
     var _a;
@@ -101,7 +214,7 @@ function assertMichelsonInstruction(ex) {
     if (Array.isArray(ex)) {
         for (const n of ex) {
             if (!Array.isArray(n) && !isPrim(n)) {
-                throw new MichelsonValidationError(ex, "sequence or prim expected");
+                throw new MichelsonValidationError(ex, 'sequence or prim expected');
             }
             assertMichelsonInstruction(n);
         }
@@ -113,12 +226,12 @@ function assertMichelsonInstruction(ex) {
             return true;
         }
         switch (ex.prim) {
-            case "DROP":
-            case "PAIR":
-            case "UNPAIR":
-            case "DUP":
-            case "UPDATE":
-            case "GET":
+            case 'DROP':
+            case 'PAIR':
+            case 'UNPAIR':
+            case 'DUP':
+            case 'UPDATE':
+            case 'GET':
                 if (ex.args !== undefined && assertArgs(ex, 1)) {
                     /* istanbul ignore else */
                     if (assertIntLiteral(ex.args[0])) {
@@ -126,9 +239,9 @@ function assertMichelsonInstruction(ex) {
                     }
                 }
                 break;
-            case "DIG":
-            case "DUG":
-            case "SAPLING_EMPTY_STATE":
+            case 'DIG':
+            case 'DUG':
+            case 'SAPLING_EMPTY_STATE':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 1)) {
                     /* istanbul ignore else */
@@ -137,32 +250,32 @@ function assertMichelsonInstruction(ex) {
                     }
                 }
                 break;
-            case "NONE":
-            case "LEFT":
-            case "RIGHT":
-            case "NIL":
-            case "CAST":
+            case 'NONE':
+            case 'LEFT':
+            case 'RIGHT':
+            case 'NIL':
+            case 'CAST':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 1)) {
                     assertMichelsonType(ex.args[0]);
                 }
                 break;
-            case "UNPACK":
+            case 'UNPACK':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 1)) {
                     assertMichelsonPackableType(ex.args[0]);
                 }
                 break;
-            case "CONTRACT":
+            case 'CONTRACT':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 1)) {
                     assertMichelsonPassableType(ex.args[0]);
                 }
                 break;
-            case "IF_NONE":
-            case "IF_LEFT":
-            case "IF_CONS":
-            case "IF":
+            case 'IF_NONE':
+            case 'IF_LEFT':
+            case 'IF_CONS':
+            case 'IF':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 2)) {
                     /* istanbul ignore else */
@@ -175,22 +288,22 @@ function assertMichelsonInstruction(ex) {
                     }
                 }
                 break;
-            case "MAP":
-            case "ITER":
-            case "LOOP":
-            case "LOOP_LEFT":
+            case 'MAP':
+            case 'ITER':
+            case 'LOOP':
+            case 'LOOP_LEFT':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 1)) {
                     assertMichelsonInstruction(ex.args[0]);
                 }
                 break;
-            case "CREATE_CONTRACT":
+            case 'CREATE_CONTRACT':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 1)) {
                     assertMichelsonContract(ex.args[0]);
                 }
                 break;
-            case "DIP":
+            case 'DIP':
                 if (((_a = ex.args) === null || _a === void 0 ? void 0 : _a.length) === 2) {
                     /* istanbul ignore else */
                     if (assertIntLiteral(ex.args[0])) {
@@ -208,37 +321,37 @@ function assertMichelsonInstruction(ex) {
                     }
                 }
                 else {
-                    throw new MichelsonValidationError(ex, "1 or 2 arguments expected");
+                    throw new MichelsonValidationError(ex, '1 or 2 arguments expected');
                 }
                 break;
-            case "PUSH":
+            case 'PUSH':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 2)) {
                     assertMichelsonPushableType(ex.args[0]);
                     assertMichelsonData(ex.args[1]);
                 }
                 break;
-            case "EMPTY_SET":
+            case 'EMPTY_SET':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 1)) {
                     assertMichelsonComparableType(ex.args[0]);
                 }
                 break;
-            case "EMPTY_MAP":
+            case 'EMPTY_MAP':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 2)) {
                     assertMichelsonComparableType(ex.args[0]);
                     assertMichelsonType(ex.args[1]);
                 }
                 break;
-            case "EMPTY_BIG_MAP":
+            case 'EMPTY_BIG_MAP':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 2)) {
                     assertMichelsonComparableType(ex.args[0]);
                     assertMichelsonBigMapStorableType(ex.args[1]);
                 }
                 break;
-            case "LAMBDA":
+            case 'LAMBDA':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 3)) {
                     assertMichelsonType(ex.args[0]);
@@ -249,7 +362,7 @@ function assertMichelsonInstruction(ex) {
                     }
                 }
                 break;
-            case "VIEW":
+            case 'VIEW':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 2)) {
                     if (assertStringLiteral(ex.args[0])) {
@@ -261,7 +374,7 @@ function assertMichelsonInstruction(ex) {
                 }
                 break;
             default:
-                throw new MichelsonValidationError(ex, "instruction expected");
+                throw new MichelsonValidationError(ex, 'instruction expected');
         }
     }
     return true;
@@ -270,7 +383,7 @@ exports.assertMichelsonInstruction = assertMichelsonInstruction;
 function assertMichelsonComparableType(ex) {
     /* istanbul ignore else */
     if (assertPrimOrSeq(ex)) {
-        if (Array.isArray(ex) || ex.prim === "pair" || ex.prim === "or" || ex.prim === "option") {
+        if (Array.isArray(ex) || ex.prim === 'pair' || ex.prim === 'or' || ex.prim === 'option') {
             traverseType(ex, (ex) => assertMichelsonComparableType(ex));
         }
         else if (!Object.prototype.hasOwnProperty.call(simpleComparableTypeIDs, ex.prim)) {
@@ -285,10 +398,10 @@ function assertMichelsonPackableType(ex) {
     if (assertPrimOrSeq(ex)) {
         if (isPrim(ex)) {
             if (!Object.prototype.hasOwnProperty.call(typeIDs, ex.prim) ||
-                ex.prim === "big_map" ||
-                ex.prim === "operation" ||
-                ex.prim === "sapling_state" ||
-                ex.prim === "ticket") {
+                ex.prim === 'big_map' ||
+                ex.prim === 'operation' ||
+                ex.prim === 'sapling_state' ||
+                ex.prim === 'ticket') {
                 throw new MichelsonValidationError(ex, `${ex.prim}: type can't be used inside PACK/UNPACK instructions`);
             }
             traverseType(ex, (ex) => assertMichelsonPackableType(ex));
@@ -302,11 +415,11 @@ function assertMichelsonPushableType(ex) {
     if (assertPrimOrSeq(ex)) {
         if (isPrim(ex)) {
             if (!Object.prototype.hasOwnProperty.call(typeIDs, ex.prim) ||
-                ex.prim === "big_map" ||
-                ex.prim === "operation" ||
-                ex.prim === "sapling_state" ||
-                ex.prim === "ticket" ||
-                ex.prim === "contract") {
+                ex.prim === 'big_map' ||
+                ex.prim === 'operation' ||
+                ex.prim === 'sapling_state' ||
+                ex.prim === 'ticket' ||
+                ex.prim === 'contract') {
                 throw new MichelsonValidationError(ex, `${ex.prim}: type can't be pushed`);
             }
             traverseType(ex, (ex) => assertMichelsonPushableType(ex));
@@ -320,8 +433,8 @@ function assertMichelsonStorableType(ex) {
     if (assertPrimOrSeq(ex)) {
         if (isPrim(ex)) {
             if (!Object.prototype.hasOwnProperty.call(typeIDs, ex.prim) ||
-                ex.prim === "operation" ||
-                ex.prim === "contract") {
+                ex.prim === 'operation' ||
+                ex.prim === 'contract') {
                 throw new MichelsonValidationError(ex, `${ex.prim}: type can't be used as part of a storage`);
             }
             traverseType(ex, (ex) => assertMichelsonStorableType(ex));
@@ -334,8 +447,7 @@ function assertMichelsonPassableType(ex) {
     /* istanbul ignore else */
     if (assertPrimOrSeq(ex)) {
         if (isPrim(ex)) {
-            if (!Object.prototype.hasOwnProperty.call(typeIDs, ex.prim) ||
-                ex.prim === "operation") {
+            if (!Object.prototype.hasOwnProperty.call(typeIDs, ex.prim) || ex.prim === 'operation') {
                 throw new MichelsonValidationError(ex, `${ex.prim}: type can't be used as part of a parameter`);
             }
             traverseType(ex, (ex) => assertMichelsonPassableType(ex));
@@ -349,9 +461,9 @@ function assertMichelsonBigMapStorableType(ex) {
     if (assertPrimOrSeq(ex)) {
         if (isPrim(ex)) {
             if (!Object.prototype.hasOwnProperty.call(typeIDs, ex.prim) ||
-                ex.prim === "big_map" ||
-                ex.prim === "operation" ||
-                ex.prim === "sapling_state") {
+                ex.prim === 'big_map' ||
+                ex.prim === 'operation' ||
+                ex.prim === 'sapling_state') {
                 throw new MichelsonValidationError(ex, `${ex.prim}: type can't be used inside a big_map`);
             }
             traverseType(ex, (ex) => assertMichelsonBigMapStorableType(ex));
@@ -360,7 +472,7 @@ function assertMichelsonBigMapStorableType(ex) {
     return true;
 }
 exports.assertMichelsonBigMapStorableType = assertMichelsonBigMapStorableType;
-const viewRe = new RegExp("^[a-zA-Z0-9_.%@]*$");
+const viewRe = new RegExp('^[a-zA-Z0-9_.%@]*$');
 function assertViewNameValid(name) {
     if (name.string.length > maxViewNameLength) {
         throw new MichelsonValidationError(name, `view name too long: ${name.string}`);
@@ -380,7 +492,7 @@ function assertMichelsonType(ex) {
     if (assertPrimOrSeq(ex)) {
         if (isPrim(ex)) {
             if (!Object.prototype.hasOwnProperty.call(typeIDs, ex.prim)) {
-                throw new MichelsonValidationError(ex, "type expected");
+                throw new MichelsonValidationError(ex, 'type expected');
             }
             traverseType(ex, (ex) => assertMichelsonType(ex));
         }
@@ -389,12 +501,12 @@ function assertMichelsonType(ex) {
 }
 exports.assertMichelsonType = assertMichelsonType;
 function traverseType(ex, cb) {
-    if (Array.isArray(ex) || ex.prim === "pair") {
+    if (Array.isArray(ex) || ex.prim === 'pair') {
         const args = Array.isArray(ex) ? ex : ex.args;
         if (args === undefined || args.length < 2) {
-            throw new MichelsonValidationError(ex, "at least 2 arguments expected");
+            throw new MichelsonValidationError(ex, 'at least 2 arguments expected');
         }
-        args.forEach(a => {
+        args.forEach((a) => {
             if (assertPrimOrSeq(a)) {
                 cb(a);
             }
@@ -402,47 +514,47 @@ function traverseType(ex, cb) {
         return true;
     }
     switch (ex.prim) {
-        case "option":
-        case "list":
+        case 'option':
+        case 'list':
             /* istanbul ignore else */
             if (assertArgs(ex, 1) && assertPrimOrSeq(ex.args[0])) {
                 cb(ex.args[0]);
             }
             break;
-        case "contract":
+        case 'contract':
             /* istanbul ignore else */
             if (assertArgs(ex, 1)) {
                 assertMichelsonPassableType(ex.args[0]);
             }
             break;
-        case "or":
+        case 'or':
             /* istanbul ignore else */
             if (assertArgs(ex, 2) && assertPrimOrSeq(ex.args[0]) && assertPrimOrSeq(ex.args[1])) {
                 cb(ex.args[0]);
                 cb(ex.args[1]);
             }
             break;
-        case "lambda":
+        case 'lambda':
             /* istanbul ignore else */
             if (assertArgs(ex, 2)) {
                 assertMichelsonType(ex.args[0]);
                 assertMichelsonType(ex.args[1]);
             }
             break;
-        case "set":
+        case 'set':
             /* istanbul ignore else */
             if (assertArgs(ex, 1)) {
                 assertMichelsonComparableType(ex.args[0]);
             }
             break;
-        case "map":
+        case 'map':
             /* istanbul ignore else */
             if (assertArgs(ex, 2) && assertPrimOrSeq(ex.args[0]) && assertPrimOrSeq(ex.args[1])) {
                 assertMichelsonComparableType(ex.args[0]);
                 cb(ex.args[1]);
             }
             break;
-        case "big_map":
+        case 'big_map':
             /* istanbul ignore else */
             if (assertArgs(ex, 2) && assertPrimOrSeq(ex.args[0]) && assertPrimOrSeq(ex.args[1])) {
                 assertMichelsonComparableType(ex.args[0]);
@@ -450,14 +562,14 @@ function traverseType(ex, cb) {
                 cb(ex.args[1]);
             }
             break;
-        case "ticket":
+        case 'ticket':
             /* istanbul ignore else */
             if (assertArgs(ex, 1) && assertPrimOrSeq(ex.args[0])) {
                 assertMichelsonComparableType(ex.args[0]);
             }
             break;
-        case "sapling_state":
-        case "sapling_transaction":
+        case 'sapling_state':
+        case 'sapling_transaction':
             if (assertArgs(ex, 1)) {
                 assertIntLiteral(ex.args[0]);
             }
@@ -473,13 +585,13 @@ function traverseType(ex, cb) {
  * @param ex An AST node
  */
 function assertMichelsonData(ex) {
-    if (("int" in ex) || ("string" in ex) || ("bytes" in ex)) {
+    if ('int' in ex || 'string' in ex || 'bytes' in ex) {
         return true;
     }
     if (Array.isArray(ex)) {
         let mapElts = 0;
         for (const n of ex) {
-            if (isPrim(n) && n.prim === "Elt") {
+            if (isPrim(n) && n.prim === 'Elt') {
                 /* istanbul ignore else */
                 if (assertArgs(n, 2)) {
                     assertMichelsonData(n.args[0]);
@@ -498,24 +610,24 @@ function assertMichelsonData(ex) {
     }
     if (isPrim(ex)) {
         switch (ex.prim) {
-            case "Unit":
-            case "True":
-            case "False":
-            case "None":
+            case 'Unit':
+            case 'True':
+            case 'False':
+            case 'None':
                 assertArgs(ex, 0);
                 break;
-            case "Pair":
+            case 'Pair':
                 /* istanbul ignore else */
                 if (ex.args === undefined || ex.args.length < 2) {
-                    throw new MichelsonValidationError(ex, "at least 2 arguments expected");
+                    throw new MichelsonValidationError(ex, 'at least 2 arguments expected');
                 }
                 for (const a of ex.args) {
                     assertMichelsonData(a);
                 }
                 break;
-            case "Left":
-            case "Right":
-            case "Some":
+            case 'Left':
+            case 'Right':
+            case 'Some':
                 /* istanbul ignore else */
                 if (assertArgs(ex, 1)) {
                     assertMichelsonData(ex.args[0]);
@@ -526,12 +638,12 @@ function assertMichelsonData(ex) {
                     assertMichelsonInstruction(ex);
                 }
                 else {
-                    throw new MichelsonValidationError(ex, "data entry or instruction expected");
+                    throw new MichelsonValidationError(ex, 'data entry or instruction expected');
                 }
         }
     }
     else {
-        throw new MichelsonValidationError(ex, "data entry expected");
+        throw new MichelsonValidationError(ex, 'data entry expected');
     }
     return true;
 }
@@ -548,7 +660,7 @@ function assertMichelsonContract(ex) {
         const views = {};
         for (const sec of ex) {
             if (assertPrim(sec)) {
-                if (sec.prim !== "view") {
+                if (sec.prim !== 'view') {
                     if (sec.prim in toplevelSec) {
                         throw new MichelsonValidationError(ex, `duplicate contract section: ${sec.prim}`);
                     }
@@ -556,7 +668,7 @@ function assertMichelsonContract(ex) {
                 }
                 /* istanbul ignore else */
                 switch (sec.prim) {
-                    case "code":
+                    case 'code':
                         if (assertArgs(sec, 1)) {
                             /* istanbul ignore else */
                             if (assertSeq(sec.args[0])) {
@@ -564,17 +676,17 @@ function assertMichelsonContract(ex) {
                             }
                         }
                         break;
-                    case "parameter":
+                    case 'parameter':
                         if (assertArgs(sec, 1)) {
                             assertMichelsonPassableType(sec.args[0]);
                         }
                         break;
-                    case "storage":
+                    case 'storage':
                         if (assertArgs(sec, 1)) {
                             assertMichelsonStorableType(sec.args[0]);
                         }
                         break;
-                    case "view":
+                    case 'view':
                         if (assertArgs(sec, 4)) {
                             if (assertStringLiteral(sec.args[0])) {
                                 const name = sec.args[0];
@@ -665,11 +777,11 @@ function assertDataListIfAny(d) {
         return false;
     }
     for (const v of d) {
-        if ("prim" in v) {
+        if ('prim' in v) {
             if (isInstruction(v)) {
                 throw new utils_1.MichelsonError(d, `Instruction outside of a lambda: ${JSON.stringify(d)}`);
             }
-            else if (v.prim === "Elt") {
+            else if (v.prim === 'Elt') {
                 throw new utils_1.MichelsonError(d, `Elt item outside of a map literal: ${JSON.stringify(d)}`);
             }
         }