@taquito/michel-codec 10.2.1 → 11.0.1

package/dist/taquito-michel-codec.es5.js

@@ -112,10 +112,11 @@ function __read(o, n) {
     return ar;
 }
 
-function __spreadArray(to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+/** @deprecated */
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
 }
 
 var ScanError = /** @class */ (function (_super) {
@@ -271,17 +272,47 @@ function scan(src, scanComments) {
 var refContract = Symbol("ref_contract");
 var Protocol;
 (function (Protocol) {
+    Protocol["Ps9mPmXa"] = "Ps9mPmXaRzmzk35gbAYNCAw6UXdE2qoABTHbN2oEEc1qM7CwT9P";
+    Protocol["PtCJ7pwo"] = "PtCJ7pwoxe8JasnHY8YonnLYjcVHmhiARPJvqcC6VfHT5s8k8sY";
+    Protocol["PsYLVpVv"] = "PsYLVpVvgbLhAhoqAkMFUo6gudkJ9weNXhUYCiLDzcUpFpkk8Wt";
+    Protocol["PsddFKi3"] = "PsddFKi32cMJ2qPjf43Qv5GDWLDPZb3T3bF6fLKiF5HtvHNU7aP";
     Protocol["Pt24m4xi"] = "Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd";
     Protocol["PsBABY5H"] = "PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU";
     Protocol["PsBabyM1"] = "PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS";
     Protocol["PsCARTHA"] = "PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb";
     Protocol["PsDELPH1"] = "PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo";
+    Protocol["PtEdoTez"] = "PtEdoTezd3RHSC31mpxxo1npxFjoWWcFgQtxapi51Z8TLu6v6Uq";
     Protocol["PtEdo2Zk"] = "PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA";
+    Protocol["PsFLoren"] = "PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i";
     Protocol["PsFLorena"] = "PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i";
+    Protocol["PtGRANAD"] = "PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV";
     Protocol["PtGRANADs"] = "PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV";
     Protocol["PtHangzH"] = "PtHangzHogokSuiMHemCuowEavgYTP8J5qQ9fQS793MHYFpCY3r";
+    Protocol["PtHangz2"] = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx";
+    Protocol["PtIdiaza"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK"; // temporary protocol hash
 })(Protocol || (Protocol = {}));
-var DefaultProtocol = Protocol.PsDELPH1;
+var DefaultProtocol = Protocol.PtGRANAD;
+var protoLevel = {
+    Ps9mPmXaRzmzk35gbAYNCAw6UXdE2qoABTHbN2oEEc1qM7CwT9P: 0,
+    PtCJ7pwoxe8JasnHY8YonnLYjcVHmhiARPJvqcC6VfHT5s8k8sY: 1,
+    PsYLVpVvgbLhAhoqAkMFUo6gudkJ9weNXhUYCiLDzcUpFpkk8Wt: 2,
+    PsddFKi32cMJ2qPjf43Qv5GDWLDPZb3T3bF6fLKiF5HtvHNU7aP: 3,
+    Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd: 4,
+    PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU: 5,
+    PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS: 5,
+    PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb: 6,
+    PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo: 7,
+    PtEdoTezd3RHSC31mpxxo1npxFjoWWcFgQtxapi51Z8TLu6v6Uq: 8,
+    PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA: 8,
+    PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i: 9,
+    PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV: 10,
+    PtHangzHogokSuiMHemCuowEavgYTP8J5qQ9fQS793MHYFpCY3r: 11,
+    PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx: 11,
+    ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK: 12
+};
+function ProtoGreaterOfEqual(a, b) {
+    return protoLevel[a] >= protoLevel[b];
+}
 
 var MacroError = /** @class */ (function (_super) {
     __extends(MacroError, _super);
@@ -324,11 +355,13 @@ function parsePairUnpairExpr(p, expr, annotations, agg) {
     var c = expr[i++];
     switch (c) {
         case "P":
-            var _a = parsePairUnpairExpr(p, expr.slice(i), annotations.slice(ai), agg), r = _a.r, n = _a.n, an = _a.an;
-            lexpr = r;
-            i += n;
-            ai += an;
-            break;
+            {
+                var _a = parsePairUnpairExpr(p, expr.slice(i), annotations.slice(ai), agg), r = _a.r, n = _a.n, an = _a.an;
+                lexpr = r;
+                i += n;
+                ai += an;
+                break;
+            }
         case "A":
             if (ai !== annotations.length) {
                 ann[0] = annotations[ai++];
@@ -345,14 +378,16 @@ function parsePairUnpairExpr(p, expr, annotations, agg) {
     c = expr[i++];
     switch (c) {
         case "P":
-            var _b = parsePairUnpairExpr(p, expr.slice(i), annotations.slice(ai), agg), r = _b.r, n = _b.n, an = _b.an;
-            rexpr = r.map(function (_a) {
-                var _b = __read(_a, 2), v = _b[0], a = _b[1];
-                return [v + 1, a];
-            });
-            i += n;
-            ai += an;
-            break;
+            {
+                var _b = parsePairUnpairExpr(p, expr.slice(i), annotations.slice(ai), agg), r = _b.r, n = _b.n, an = _b.an;
+                rexpr = r.map(function (_a) {
+                    var _b = __read(_a, 2), v = _b[0], a = _b[1];
+                    return [v + 1, a];
+                });
+                i += n;
+                ai += an;
+                break;
+            }
         case "I":
             if (ai !== annotations.length) {
                 ann[1] = annotations[ai++];
@@ -379,7 +414,7 @@ function parseSetMapCadr(p, expr, vann, term) {
                     },
                     { prim: "CDR", annots: ["@%%"] },
                     { prim: "SWAP" },
-                    { prim: "PAIR", annots: __spreadArray(["%@", "%@"], __read(vann)) },
+                    { prim: "PAIR", annots: __spread(["%@", "%@"], vann) },
                 ] : term.a;
         case "D":
             return expr.length > 1 ?
@@ -393,7 +428,7 @@ function parseSetMapCadr(p, expr, vann, term) {
                             ]],
                     },
                     { prim: "CAR", annots: ["@%%"] },
-                    { prim: "PAIR", annots: __spreadArray(["%@", "%@"], __read(vann)) },
+                    { prim: "PAIR", annots: __spread(["%@", "%@"], vann) },
                 ] : term.d;
         default:
             throw new MacroError(p, p.prim + ": unexpected character: " + c);
@@ -617,10 +652,10 @@ function expandMacros(ex, opt) {
     if (pairRe.test(ex.prim)) {
         if (assertArgs$1(ex, 0)) {
             var _a = filterAnnotations(ex.annots), fields = _a.fields, rest_1 = _a.rest;
-            var r_1 = parsePairUnpairExpr(ex, ex.prim.slice(1), fields, function (l, r, top) { return __spreadArray(__spreadArray(__spreadArray([], __read((l || []))), __read((r || []))), [top]); }).r;
+            var r_1 = parsePairUnpairExpr(ex, ex.prim.slice(1), fields, function (l, r, top) { return __spread((l || []), (r || []), [top]); }).r;
             return r_1.map(function (_a, i) {
                 var _b = __read(_a, 2), v = _b[0], a = _b[1];
-                var ann = __spreadArray(__spreadArray([], __read(trimLast(a, null).map(function (v) { return v === null ? "%" : v; }))), __read(((v === 0 && i === r_1.length - 1) ? rest_1 : [])));
+                var ann = __spread(trimLast(a, null).map(function (v) { return v === null ? "%" : v; }), ((v === 0 && i === r_1.length - 1) ? rest_1 : []));
                 var leaf = mkPrim({ prim: "PAIR", annots: ann.length !== 0 ? ann : undefined, });
                 return v === 0 ? leaf : {
                     prim: "DIP",
@@ -631,13 +666,13 @@ function expandMacros(ex, opt) {
     }
     // UNPAPPAIIR macro
     if (unpairRe.test(ex.prim)) {
-        if (proto === Protocol.PtEdo2Zk || proto === Protocol.PsFLorena || proto === Protocol.PtGRANADs || proto === Protocol.PtHangzH) {
+        if (ProtoGreaterOfEqual(proto, Protocol.PtEdo2Zk)) {
             if (ex.prim === "UNPAIR") {
                 return ex;
             }
             if (assertArgs$1(ex, 0)) {
                 // 008_edo: annotations are deprecated
-                var r = parsePairUnpairExpr(ex, ex.prim.slice(3), [], function (l, r, top) { return __spreadArray(__spreadArray([top], __read((r || []))), __read((l || []))); }).r;
+                var r = parsePairUnpairExpr(ex, ex.prim.slice(3), [], function (l, r, top) { return __spread([top], (r || []), (l || [])); }).r;
                 return r.map(function (_a) {
                     var _b = __read(_a, 1), v = _b[0];
                     var leaf = mkPrim({
@@ -651,7 +686,7 @@ function expandMacros(ex, opt) {
             }
         }
         else if (assertArgs$1(ex, 0)) {
-            var r = parsePairUnpairExpr(ex, ex.prim.slice(3), ex.annots || [], function (l, r, top) { return __spreadArray(__spreadArray([top], __read((r || []))), __read((l || []))); }).r;
+            var r = parsePairUnpairExpr(ex, ex.prim.slice(3), ex.annots || [], function (l, r, top) { return __spread([top], (r || []), (l || [])); }).r;
             return r.map(function (_a) {
                 var _b = __read(_a, 2), v = _b[0], a = _b[1];
                 var leaf = [
@@ -672,7 +707,7 @@ function expandMacros(ex, opt) {
     // C[AD]+R macro
     if (cadrRe.test(ex.prim)) {
         if (assertArgs$1(ex, 0)) {
-            var ch_1 = __spreadArray([], __read(ex.prim.slice(1, ex.prim.length - 1)));
+            var ch_1 = __spread(ex.prim.slice(1, ex.prim.length - 1));
             return ch_1.map(function (c, i) {
                 var ann = i === ch_1.length - 1 ? ex.annots : undefined;
                 switch (c) {
@@ -773,7 +808,7 @@ function expandMacros(ex, opt) {
         while (ex.prim[1 + n] === "U") {
             n++;
         }
-        if (proto === Protocol.PtEdo2Zk || proto === Protocol.PsFLorena || proto === Protocol.PtGRANADs || proto === Protocol.PtHangzH) {
+        if (ProtoGreaterOfEqual(proto, Protocol.PtEdo2Zk)) {
             if (n === 1) {
                 return ex;
             }
@@ -853,12 +888,12 @@ var JSONParseError = /** @class */ (function (_super) {
     }
     return JSONParseError;
 }(Error));
-var errEOF = new MichelineParseError(null, 'Unexpected EOF');
+var errEOF = new MichelineParseError(null, "Unexpected EOF");
 function isAnnotation(tok) {
-    return tok.t === Literal.Ident && (tok.v[0] === '@' || tok.v[0] === '%' || tok.v[0] === ':');
+    return tok.t === Literal.Ident && (tok.v[0] === "@" || tok.v[0] === "%" || tok.v[0] === ":");
 }
-var intRe = new RegExp('^-?[0-9]+$');
-var bytesRe = new RegExp('^([0-9a-fA-F]{2})*$');
+var intRe = new RegExp("^-?[0-9]+$");
+var bytesRe = new RegExp("^([0-9a-fA-F]{2})*$");
 /**
  * Converts and validates Michelson expressions between JSON-based Michelson and Micheline
  *
@@ -943,7 +978,7 @@ var Parser = /** @class */ (function () {
                 }
                 break;
             }
-            else if (tok_1.value.t === ')') {
+            else if (tok_1.value.t === ")") {
                 if (!expectBracket) {
                     throw new MichelineParseError(tok_1.value, "unexpected closing bracket");
                 }
@@ -979,7 +1014,7 @@ var Parser = /** @class */ (function () {
             _a);
         for (;;) {
             var t = scanner.next();
-            if (t.done || t.value.t === '}' || t.value.t === ';') {
+            if (t.done || t.value.t === "}" || t.value.t === ";") {
                 return [p, t];
             }
             if (isAnnotation(t.value)) {
@@ -1064,7 +1099,7 @@ var Parser = /** @class */ (function () {
                 return _c = { string: JSON.parse(tok.v) }, _c[sourceReference] = { first: tok.first, last: tok.last }, _c;
             case Literal.Bytes:
                 return _d = { bytes: tok.v.slice(2) }, _d[sourceReference] = { first: tok.first, last: tok.last }, _d;
-            case '{':
+            case "{":
                 return this.parseSequenceExpr(scanner, tok);
             default:
                 return this.parseListExpr(scanner, tok);
@@ -1152,7 +1187,7 @@ var Parser = /** @class */ (function () {
             try {
                 for (var src_1 = __values(src), src_1_1 = src_1.next(); !src_1_1.done; src_1_1 = src_1.next()) {
                     var n = src_1_1.value;
-                    if (n === null || typeof n !== 'object') {
+                    if (n === null || typeof n !== "object") {
                         throw new JSONParseError(n, "unexpected sequence element: " + n);
                     }
                     ret.push(this.parseJSON(n));
@@ -1167,9 +1202,9 @@ var Parser = /** @class */ (function () {
             }
             return ret;
         }
-        else if ('prim' in src) {
+        else if ("prim" in src) {
             var p = src;
-            if (typeof p.prim === 'string' &&
+            if (typeof p.prim === "string" &&
                 (p.annots === undefined || Array.isArray(p.annots)) &&
                 (p.args === undefined || Array.isArray(p.args))) {
                 var ret = {
@@ -1179,7 +1214,7 @@ var Parser = /** @class */ (function () {
                     try {
                         for (var _d = __values(p.annots), _e = _d.next(); !_e.done; _e = _d.next()) {
                             var a = _e.value;
-                            if (typeof a !== 'string') {
+                            if (typeof a !== "string") {
                                 throw new JSONParseError(a, "string expected: " + a);
                             }
                         }
@@ -1198,7 +1233,7 @@ var Parser = /** @class */ (function () {
                     try {
                         for (var _f = __values(p.args), _g = _f.next(); !_g.done; _g = _f.next()) {
                             var a = _g.value;
-                            if (a === null || typeof a !== 'object') {
+                            if (a === null || typeof a !== "object") {
                                 throw new JSONParseError(a, "unexpected argument: " + a);
                             }
                             ret.args.push(this.parseJSON(a));
@@ -1216,20 +1251,20 @@ var Parser = /** @class */ (function () {
             }
             throw new JSONParseError(src, "malformed prim expression: " + src);
         }
-        else if ('string' in src) {
-            if (typeof src.string === 'string') {
+        else if ("string" in src) {
+            if (typeof src.string === "string") {
                 return { string: src.string };
             }
             throw new JSONParseError(src, "malformed string literal: " + src);
         }
-        else if ('int' in src) {
-            if (typeof src.int === 'string' && intRe.test(src.int)) {
+        else if ("int" in src) {
+            if (typeof src.int === "string" && intRe.test(src.int)) {
                 return { int: src.int };
             }
             throw new JSONParseError(src, "malformed int literal: " + src);
         }
-        else if ('bytes' in src) {
-            if (typeof src.bytes === 'string' &&
+        else if ("bytes" in src) {
+            if (typeof src.bytes === "string" &&
                 bytesRe.test(src.bytes)) {
                 return { bytes: src.bytes };
             }
@@ -1477,15 +1512,15 @@ function sha256(msg) {
         throw new Error("sha256: message length is too big: " + msg.length);
     }
     var l = msg.length << 3;
-    var buffer = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(msg)), [
+    var buffer = __spread(msg, [
         0x80
-    ]), __read((new Array(pad).fill(0)))), [
+    ], (new Array(pad).fill(0)), [
         0, 0, 0, 0, (l >> 24) & 0xff, (l >> 16) & 0xff, (l >> 8) & 0xff, l & 0xff,
     ]);
     function ror(x, n) {
         return (x >>> n) | (x << (32 - n));
     }
-    var h = __spreadArray([], __read(H));
+    var h = __spread(H);
     var w = new Array(64);
     var v = new Array(8);
     for (var offset = 0; offset < buffer.length; offset += 64) {
@@ -1619,7 +1654,7 @@ function encodeBase58(src) {
         acc.push(0);
     }
     acc.reverse();
-    return String.fromCharCode.apply(String, __spreadArray([], __read(acc.map(function (v) { return base58alphabetBwd[v] + 49; }))));
+    return String.fromCharCode.apply(String, __spread(acc.map(function (v) { return base58alphabetBwd[v] + 49; })));
 }
 function decodeBase58Check(src) {
     var buffer = decodeBase58(src);
@@ -1639,7 +1674,7 @@ function decodeBase58Check(src) {
 }
 function encodeBase58Check(src) {
     var sum = sha256(sha256(src));
-    return encodeBase58(__spreadArray(__spreadArray([], __read(src)), __read(sum.slice(0, 4))));
+    return encodeBase58(__spread(src, sum.slice(0, 4)));
 }
 
 var MichelsonError = /** @class */ (function (_super) {
@@ -1787,7 +1822,7 @@ function isNatural(x) {
         return false;
     }
 }
-var annRe = /^(@%|@%%|%@|[@:%]([_0-9a-zA-Z][_0-9a-zA-Z\.%@]*)?)$/;
+var annRe = /^(@%|@%%|%@|[@:%]([_0-9a-zA-Z][_0-9a-zA-Z.%@]*)?)$/;
 function unpackAnnotations(p, opt) {
     var e_1, _a;
     if (Array.isArray(p)) {
@@ -1905,7 +1940,7 @@ function encodeTezosID(id, data) {
     if (data.length !== plen) {
         throw new Error("incorrect data length for " + id + ": " + data.length);
     }
-    return encodeBase58Check(__spreadArray(__spreadArray([], __read(p)), __read(data)));
+    return encodeBase58Check(__spread(p, data));
 }
 function unpackComb(id, v) {
     var vv = v;
@@ -1970,6 +2005,7 @@ function hexBytes(bytes) {
 }
 
 // Michelson validator
+var maxViewNameLength = 31;
 var 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,
@@ -1978,13 +2014,13 @@ var noArgInstructionIDs = {
     "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,
+    "TOTAL_VOTING_POWER": true, "TRANSFER_TOKENS": true, "UNIT": true, "VOTING_POWER": true, "XOR": true, "RENAME": true, "OPEN_CHEST": true,
 };
 var 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,
+    "PUSH": true, "RIGHT": true, "SAPLING_EMPTY_STATE": true, "UNPACK": true, "UNPAIR": true, "UPDATE": true, "CAST": true, "VIEW": true,
 });
 var simpleComparableTypeIDs = {
     "unit": true, "never": true, "bool": true, "int": true, "nat": true, "string": true,
@@ -1995,13 +2031,14 @@ var 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,
 });
 var MichelsonValidationError = /** @class */ (function (_super) {
     __extends(MichelsonValidationError, _super);
     /**
-     * @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
+    */
     function MichelsonValidationError(val, message) {
         var _this = _super.call(this, val, message) || this;
         _this.val = val;
@@ -2045,6 +2082,12 @@ function assertIntLiteral(ex) {
     }
     throw new MichelsonValidationError(ex, "int literal expected");
 }
+function assertStringLiteral(ex) {
+    if ("string" in ex) {
+        return true;
+    }
+    throw new MichelsonValidationError(ex, "string literal expected");
+}
 function assertArgs(ex, n) {
     var _a;
     if ((n === 0 && ex.args === undefined) || ((_a = ex.args) === null || _a === void 0 ? void 0 : _a.length) === n) {
@@ -2221,6 +2264,17 @@ function assertMichelsonInstruction(ex) {
                     }
                 }
                 break;
+            case "VIEW":
+                /* istanbul ignore else */
+                if (assertArgs(ex, 2)) {
+                    if (assertStringLiteral(ex.args[0])) {
+                        assertViewNameValid(ex.args[0]);
+                    }
+                    if (assertMichelsonType(ex.args[1])) {
+                        assertMichelsonPushableType(ex.args[1]);
+                    }
+                }
+                break;
             default:
                 throw new MichelsonValidationError(ex, "instruction expected");
         }
@@ -2314,6 +2368,15 @@ function assertMichelsonBigMapStorableType(ex) {
     }
     return true;
 }
+var 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);
+    }
+    if (!viewRe.test(name.string)) {
+        throw new MichelsonValidationError(name, "invalid character(s) in view name: " + name.string);
+    }
+}
 /**
  * Checks if the node is a valid Michelson type expression.
  * This is a type guard function which either returns true of throws an exception.
@@ -2508,33 +2571,57 @@ function assertMichelsonContract(ex) {
     var e_4, _a;
     /* istanbul ignore else */
     if (assertSeq(ex)) {
-        var ent = {};
+        var toplevelSec = {};
+        var views = {};
         try {
             for (var ex_3 = __values(ex), ex_3_1 = ex_3.next(); !ex_3_1.done; ex_3_1 = ex_3.next()) {
                 var sec = ex_3_1.value;
                 if (assertPrim(sec)) {
-                    if (sec.prim !== "code" && sec.prim !== "parameter" && sec.prim !== "storage") {
-                        throw new MichelsonValidationError(ex, "unexpected contract section: " + sec.prim);
-                    }
-                    if (sec.prim in ent) {
-                        throw new MichelsonValidationError(ex, "duplicate contract section: " + sec.prim);
+                    if (sec.prim !== "view") {
+                        if (sec.prim in toplevelSec) {
+                            throw new MichelsonValidationError(ex, "duplicate contract section: " + sec.prim);
+                        }
+                        toplevelSec[sec.prim] = true;
                     }
-                    ent[sec.prim] = true;
                     /* istanbul ignore else */
-                    if (assertArgs(sec, 1)) {
-                        switch (sec.prim) {
-                            case "code":
+                    switch (sec.prim) {
+                        case "code":
+                            if (assertArgs(sec, 1)) {
                                 /* istanbul ignore else */
                                 if (assertSeq(sec.args[0])) {
                                     assertMichelsonInstruction(sec.args[0]);
                                 }
-                                break;
-                            case "parameter":
+                            }
+                            break;
+                        case "parameter":
+                            if (assertArgs(sec, 1)) {
                                 assertMichelsonPassableType(sec.args[0]);
-                                break;
-                            case "storage":
+                            }
+                            break;
+                        case "storage":
+                            if (assertArgs(sec, 1)) {
                                 assertMichelsonStorableType(sec.args[0]);
-                        }
+                            }
+                            break;
+                        case "view":
+                            if (assertArgs(sec, 4)) {
+                                if (assertStringLiteral(sec.args[0])) {
+                                    var name_1 = sec.args[0];
+                                    if (name_1.string in views) {
+                                        throw new MichelsonValidationError(ex, "duplicate view name: " + name_1.string);
+                                    }
+                                    views[name_1.string] = true;
+                                    assertViewNameValid(name_1);
+                                }
+                                assertMichelsonPushableType(sec.args[1]);
+                                assertMichelsonPushableType(sec.args[2]);
+                                if (assertSeq(sec.args[3])) {
+                                    assertMichelsonInstruction(sec.args[3]);
+                                }
+                            }
+                            break;
+                        default:
+                            throw new MichelsonValidationError(ex, "unexpected contract section: " + sec.prim);
                     }
                 }
             }
@@ -2648,10 +2735,10 @@ var primitives = ["parameter", "storage", "code", "False", "Elt", "Left", "None"
     "SHA3", "PAIRING_CHECK", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr", "sapling_state",
     "sapling_transaction", "SAPLING_EMPTY_STATE", "SAPLING_VERIFY_UPDATE", "ticket", "TICKET",
     "READ_TICKET", "SPLIT_TICKET", "JOIN_TICKETS", "GET_AND_UPDATE"];
-var primTags = Object.assign.apply(Object, __spreadArray([{}], __read(primitives.map(function (v, i) {
+var primTags = Object.assign.apply(Object, __spread([{}], primitives.map(function (v, i) {
     var _a;
     return (_a = {}, _a[v] = i, _a);
-}))));
+})));
 var Tag;
 (function (Tag) {
     Tag[Tag["Int"] = 0] = "Int";
@@ -2679,7 +2766,7 @@ var Writer = /** @class */ (function () {
     });
     Writer.prototype.writeBytes = function (val) {
         var _a;
-        (_a = this.buffer).push.apply(_a, __spreadArray([], __read(val.map(function (v) { return v & 0xff; }))));
+        (_a = this.buffer).push.apply(_a, __spread(val.map(function (v) { return v & 0xff; })));
     };
     Writer.prototype.writeUint8 = function (val) {
         var v = val | 0;
@@ -4374,10 +4461,6 @@ function assertDataValidInternal(d, t, ctx) {
                 }
             }
             throw new MichelsonTypeError(t, d, "chain id expected: " + JSON.stringify(d));
-        case "operation":
-            throw new MichelsonTypeError(t, d, "operation type can't be represented as a literal value");
-        case "contract":
-            throw new MichelsonTypeError(t, d, "contract type can't be represented as a literal value");
         // Complex types
         case "option":
             if ("prim" in d) {
@@ -4485,7 +4568,8 @@ function assertDataValidInternal(d, t, ctx) {
             throw new MichelsonTypeError(t, d, "sapling state expected: " + JSON.stringify(d));
         case "ticket":
             assertDataValidInternal(d, {
-                prim: "pair", args: [
+                prim: "pair",
+                args: [
                     { prim: "address" },
                     t.args[0],
                     { prim: "nat" },
@@ -4493,7 +4577,7 @@ function assertDataValidInternal(d, t, ctx) {
             }, ctx);
             return;
         default:
-            throw new MichelsonTypeError(t, d, "unexpected type: " + typeID(t));
+            throw new MichelsonTypeError(t, d, "type " + typeID(t) + " don't have Michelson literal representation");
     }
 }
 function instructionListType(inst, stack, ctx) {
@@ -4581,7 +4665,7 @@ function functionTypeInternal(inst, stack, ctx) {
                 args[_i] = arguments[_i];
             }
             try {
-                return fn.apply(void 0, __spreadArray([], __read(args)));
+                return fn.apply(void 0, __spread(args));
             }
             catch (err) {
                 if (err instanceof MichelsonError) {
@@ -4634,7 +4718,7 @@ function functionTypeInternal(inst, stack, ctx) {
         var tx = tt;
         var t = Array.isArray(tx) ? { prim: "pair", args: tx } : tx;
         var src = argAnn(t);
-        var ann = (a.v !== undefined || a.t !== undefined || a.f !== undefined) ? __spreadArray(__spreadArray(__spreadArray([], __read(((a.v === null ? src.v : a.v) || []))), __read(((a.t === null ? src.t : a.t) || []))), __read(((a.f === null ? src.f : a.f) || []))) : undefined;
+        var ann = (a.v !== undefined || a.t !== undefined || a.f !== undefined) ? __spread(((a.v === null ? src.v : a.v) || []), ((a.t === null ? src.t : a.t) || []), ((a.f === null ? src.f : a.f) || [])) : undefined;
         t.annots; var rest = __rest(t, ["annots"]);
         return __assign(__assign({}, rest), (ann && ann.length !== 0 && { annots: ann }));
     }
@@ -4678,7 +4762,7 @@ function functionTypeInternal(inst, stack, ctx) {
         }
         var right = p.args[1];
         if (isPairType(right)) {
-            return __spreadArray([p.args[0]], __read(getN(right, n, i - 1)));
+            return __spread([p.args[0]], getN(right, n, i - 1));
         }
         else {
             throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": at least " + n + " fields are expected");
@@ -4752,35 +4836,35 @@ function functionTypeInternal(inst, stack, ctx) {
                     if (n === 0) {
                         throw new MichelsonInstructionError(instruction, stack, "DUP 0 is forbidden");
                     }
-                    var s_1 = args(n - 1, null)[0];
-                    if (typeID(s_1) === "ticket") {
+                    var s = args(n - 1, null)[0];
+                    if (typeID(s) === "ticket") {
                         throw new MichelsonInstructionError(instruction, stack, "ticket can't be DUPed");
                     }
-                    return __spreadArray([s_1], __read(stack));
+                    return __spread([s], stack);
                 }
             case "SWAP":
                 {
-                    var s_2 = args(0, null, null);
+                    var s = args(0, null, null);
                     instructionAnn({});
-                    return __spreadArray([s_2[1], s_2[0]], __read(stack.slice(2)));
+                    return __spread([s[1], s[0]], stack.slice(2));
                 }
             case "SOME":
-                return __spreadArray([annotate({ prim: "option", args: [args(0, null)[0]] }, instructionAnn({ t: 1, v: 1 }))], __read(stack.slice(1)));
+                return __spread([annotate({ prim: "option", args: [args(0, null)[0]] }, instructionAnn({ t: 1, v: 1 }))], stack.slice(1));
             case "UNIT":
-                return __spreadArray([annotate({ prim: "unit" }, instructionAnn({ v: 1, t: 1 }))], __read(stack));
+                return __spread([annotate({ prim: "unit" }, instructionAnn({ v: 1, t: 1 }))], stack);
             case "PAIR":
                 {
                     var n = instruction.args ? parseInt(instruction.args[0].int, 10) : 2;
                     if (n < 2) {
                         throw new MichelsonInstructionError(instruction, stack, "PAIR " + n + " is forbidden");
                     }
-                    var s_3 = args.apply(void 0, __spreadArray([0], __read(new Array(n).fill(null))));
+                    var s = args.apply(void 0, __spread([0], new Array(n).fill(null)));
                     var ia_1 = instructionAnn({ f: n, t: 1, v: 1 }, { specialFields: true });
                     var trim_1 = function (s) {
                         var i = s.lastIndexOf(".");
                         return s.slice(i > 0 ? i + 1 : 1);
                     };
-                    var retArgs = s_3.map(function (v, i) {
+                    var retArgs = s.map(function (v, i) {
                         var _a;
                         var va = argAnn(v);
                         var f = ia_1.f && ia_1.f.length > i && ia_1.f[i] !== "%" ?
@@ -4790,12 +4874,12 @@ function functionTypeInternal(inst, stack, ctx) {
                             undefined;
                         return annotate(v, { v: null, t: null, f: f });
                     });
-                    return __spreadArray([
+                    return __spread([
                         annotate({
                             prim: "pair",
                             args: retArgs,
                         }, { t: ia_1.t, v: ia_1.v })
-                    ], __read(stack.slice(n)));
+                    ], stack.slice(n));
                 }
             case "UNPAIR":
                 {
@@ -4803,55 +4887,55 @@ function functionTypeInternal(inst, stack, ctx) {
                     if (n < 2) {
                         throw new MichelsonInstructionError(instruction, stack, "UNPAIR " + n + " is forbidden");
                     }
-                    var s_4 = args(0, ["pair"])[0];
+                    var s_1 = args(0, ["pair"])[0];
                     var ia_2 = instructionAnn({ f: 2, v: 2 }, { specialVar: true });
-                    var fields = getN(s_4, n);
-                    return __spreadArray(__spreadArray([], __read(fields.map(function (field, i) { return annotateField(s_4, field, ia_2, i, i === 0 ? "car" : "cdr"); }))), __read(stack.slice(1)));
+                    var fields = getN(s_1, n);
+                    return __spread(fields.map(function (field, i) { return annotateField(s_1, field, ia_2, i, i === 0 ? "car" : "cdr"); }), stack.slice(1));
                 }
             case "CAR":
             case "CDR":
                 {
-                    var s_5 = unpackComb("pair", args(0, ["pair"])[0]);
-                    var field = s_5.args[instruction.prim === "CAR" ? 0 : 1];
+                    var s = unpackComb("pair", args(0, ["pair"])[0]);
+                    var field = s.args[instruction.prim === "CAR" ? 0 : 1];
                     var ia = instructionAnn({ f: 1, v: 1 }, { specialVar: true });
-                    return __spreadArray([annotateField(s_5, field, ia, 0, instruction.prim.toLocaleLowerCase())], __read(stack.slice(1)));
+                    return __spread([annotateField(s, field, ia, 0, instruction.prim.toLocaleLowerCase())], stack.slice(1));
                 }
             case "CONS":
                 {
-                    var s_6 = args(0, null, ["list"]);
-                    ensureTypesEqual(s_6[0], s_6[1].args[0]);
-                    return __spreadArray([annotateVar({ prim: "list", args: [s_6[1].args[0]] })], __read(stack.slice(2)));
+                    var s = args(0, null, ["list"]);
+                    ensureTypesEqual(s[0], s[1].args[0]);
+                    return __spread([annotateVar({ prim: "list", args: [s[1].args[0]] })], stack.slice(2));
                 }
             case "SIZE":
                 args(0, ["string", "list", "set", "map", "bytes"]);
-                return __spreadArray([annotateVar({ prim: "nat" })], __read(stack.slice(1)));
+                return __spread([annotateVar({ prim: "nat" })], stack.slice(1));
             case "MEM":
                 {
-                    var s_7 = args(0, null, ["set", "map", "big_map"]);
-                    ensureComparableType(s_7[0]);
-                    ensureTypesEqual(s_7[0], s_7[1].args[0]);
-                    return __spreadArray([annotateVar({ prim: "bool" })], __read(stack.slice(2)));
+                    var s = args(0, null, ["set", "map", "big_map"]);
+                    ensureComparableType(s[0]);
+                    ensureTypesEqual(s[0], s[1].args[0]);
+                    return __spread([annotateVar({ prim: "bool" })], stack.slice(2));
                 }
             case "GET":
                 if (instruction.args) {
                     // comb operation
                     var n = parseInt(instruction.args[0].int, 10);
-                    var s_8 = args(0, ["pair"])[0];
-                    return __spreadArray([annotateVar(getNth(s_8, n))], __read(stack.slice(1)));
+                    var s = args(0, ["pair"])[0];
+                    return __spread([annotateVar(getNth(s, n))], stack.slice(1));
                 }
                 else {
                     // map operation
-                    var s_9 = args(0, null, ["map", "big_map"]);
-                    ensureComparableType(s_9[0]);
-                    ensureTypesEqual(s_9[0], s_9[1].args[0]);
-                    return __spreadArray([annotateVar({ prim: "option", args: [s_9[1].args[1]] })], __read(stack.slice(2)));
+                    var s = args(0, null, ["map", "big_map"]);
+                    ensureComparableType(s[0]);
+                    ensureTypesEqual(s[0], s[1].args[0]);
+                    return __spread([annotateVar({ prim: "option", args: [s[1].args[1]] })], stack.slice(2));
                 }
             case "UPDATE":
                 if (instruction.args) {
                     // comb operation
                     var n = parseInt(instruction.args[0].int, 10);
-                    var s_10 = args(0, null, ["pair"]);
-                    return __spreadArray([annotateVar(updateNth(s_10[1], s_10[0], n))], __read(stack.slice(2)));
+                    var s = args(0, null, ["pair"]);
+                    return __spread([annotateVar(updateNth(s[1], s[0], n))], stack.slice(2));
                 }
                 else {
                     // map operation
@@ -4860,94 +4944,94 @@ function functionTypeInternal(inst, stack, ctx) {
                     if (s0[1].prim === "bool") {
                         var s1_1 = args(2, ["set"]);
                         ensureTypesEqual(s0[0], s1_1[0].args[0]);
-                        return __spreadArray([annotateVar({
+                        return __spread([annotateVar({
                                 prim: "set",
                                 args: [annotate(s0[0], { t: null })],
-                            })], __read(stack.slice(3)));
+                            })], stack.slice(3));
                     }
                     var s1 = args(2, ["map", "big_map"]);
                     ensureTypesEqual(s0[0], s1[0].args[0]);
                     if (s1[0].prim === "map") {
-                        return __spreadArray([annotateVar({
+                        return __spread([annotateVar({
                                 prim: "map",
                                 args: [
                                     annotate(s0[0], { t: null }),
                                     annotate(s0[1].args[0], { t: null }),
                                 ],
-                            })], __read(stack.slice(3)));
+                            })], stack.slice(3));
                     }
                     ensureBigMapStorableType(s0[1].args[0]);
-                    return __spreadArray([annotateVar({
+                    return __spread([annotateVar({
                             prim: "big_map",
                             args: [
                                 annotate(s0[0], { t: null }),
                                 annotate(s0[1].args[0], { t: null }),
                             ],
-                        })], __read(stack.slice(3)));
+                        })], stack.slice(3));
                 }
             case "GET_AND_UPDATE":
                 {
                     var ia = instructionAnn({ v: 2 });
-                    var s_11 = args(0, null, ["option"], ["map", "big_map"]);
-                    ensureComparableType(s_11[0]);
-                    ensureTypesEqual(s_11[0], s_11[2].args[0]);
-                    ensureTypesEqual(s_11[1].args[0], s_11[2].args[1]);
+                    var s = args(0, null, ["option"], ["map", "big_map"]);
+                    ensureComparableType(s[0]);
+                    ensureTypesEqual(s[0], s[2].args[0]);
+                    ensureTypesEqual(s[1].args[0], s[2].args[1]);
                     var va = (_c = ia.v) === null || _c === void 0 ? void 0 : _c.map(function (v) { return v !== "@" ? [v] : undefined; });
-                    if (s_11[2].prim === "map") {
-                        return __spreadArray([
-                            annotate({ prim: "option", args: [s_11[2].args[1]] }, { v: va === null || va === void 0 ? void 0 : va[0] }),
+                    if (s[2].prim === "map") {
+                        return __spread([
+                            annotate({ prim: "option", args: [s[2].args[1]] }, { v: va === null || va === void 0 ? void 0 : va[0] }),
                             annotate({
                                 prim: "map",
                                 args: [
-                                    annotate(s_11[0], { t: null }),
-                                    annotate(s_11[1].args[0], { t: null }),
+                                    annotate(s[0], { t: null }),
+                                    annotate(s[1].args[0], { t: null }),
                                 ],
                             }, { v: va === null || va === void 0 ? void 0 : va[1] })
-                        ], __read(stack.slice(3)));
+                        ], stack.slice(3));
                     }
-                    ensureBigMapStorableType(s_11[1].args[0]);
-                    return __spreadArray([
-                        annotate({ prim: "option", args: [s_11[2].args[1]] }, { v: va === null || va === void 0 ? void 0 : va[0] }),
+                    ensureBigMapStorableType(s[1].args[0]);
+                    return __spread([
+                        annotate({ prim: "option", args: [s[2].args[1]] }, { v: va === null || va === void 0 ? void 0 : va[0] }),
                         annotate({
                             prim: "big_map",
                             args: [
-                                annotate(s_11[0], { t: null }),
-                                annotate(s_11[1].args[0], { t: null }),
+                                annotate(s[0], { t: null }),
+                                annotate(s[1].args[0], { t: null }),
                             ],
                         }, { v: va === null || va === void 0 ? void 0 : va[1] })
-                    ], __read(stack.slice(3)));
+                    ], stack.slice(3));
                 }
             case "EXEC":
                 {
-                    var s_12 = args(0, null, ["lambda"]);
-                    ensureTypesEqual(s_12[0], s_12[1].args[0]);
-                    return __spreadArray([annotateVar(s_12[1].args[1])], __read(stack.slice(2)));
+                    var s = args(0, null, ["lambda"]);
+                    ensureTypesEqual(s[0], s[1].args[0]);
+                    return __spread([annotateVar(s[1].args[1])], stack.slice(2));
                 }
             case "APPLY":
                 {
-                    var s_13 = args(0, null, ["lambda"]);
-                    ensureStorableType(s_13[0]);
-                    ensurePushableType(s_13[0]);
-                    if (!isPairType(s_13[1].args[0])) {
-                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": function's argument must be a pair: " + typeID(s_13[1].args[0]));
+                    var s = args(0, null, ["lambda"]);
+                    ensureStorableType(s[0]);
+                    ensurePushableType(s[0]);
+                    if (!isPairType(s[1].args[0])) {
+                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": function's argument must be a pair: " + typeID(s[1].args[0]));
                     }
-                    var pt = s_13[1].args[0];
-                    ensureTypesEqual(s_13[0], typeArgs(pt)[0]);
-                    return __spreadArray([annotateVar({ prim: "lambda", args: [typeArgs(pt)[1], s_13[1].args[1]] })], __read(stack.slice(2)));
+                    var pt = s[1].args[0];
+                    ensureTypesEqual(s[0], typeArgs(pt)[0]);
+                    return __spread([annotateVar({ prim: "lambda", args: [typeArgs(pt)[1], s[1].args[1]] })], stack.slice(2));
                 }
             case "FAILWITH":
                 {
-                    var s_14 = args(0, null)[0];
-                    if (proto === Protocol.PtEdo2Zk || proto === Protocol.PsFLorena || proto === Protocol.PtGRANADs) {
-                        ensurePackableType(s_14);
+                    var s = args(0, null)[0];
+                    if (ProtoGreaterOfEqual(proto, Protocol.PtEdo2Zk)) {
+                        ensurePackableType(s);
                     }
-                    return { failed: s_14 };
+                    return { failed: s };
                 }
             case "NEVER":
                 args(0, ["never"]);
                 return { failed: { prim: "never" } };
             case "RENAME":
-                return __spreadArray([annotateVar(args(0, null)[0])], __read(stack.slice(1)));
+                return __spread([annotateVar(args(0, null)[0])], stack.slice(1));
             case "CONCAT":
                 {
                     var s0 = args(0, ["string", "list", "bytes"]);
@@ -4955,140 +5039,140 @@ function functionTypeInternal(inst, stack, ctx) {
                         if (typeID(s0[0].args[0]) !== "string" && typeID(s0[0].args[0]) !== "bytes") {
                             throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": can't concatenate list of " + typeID(s0[0].args[0]) + "'s");
                         }
-                        return __spreadArray([annotateVar(s0[0].args[0])], __read(stack.slice(1)));
+                        return __spread([annotateVar(s0[0].args[0])], stack.slice(1));
                     }
                     var s1 = args(1, ["string", "bytes"]);
                     if (s0[0].prim !== s1[0].prim) {
                         throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": can't concatenate " + s0[0].prim + " with " + s1[0].prim);
                     }
-                    return __spreadArray([annotateVar(s1[0])], __read(stack.slice(2)));
+                    return __spread([annotateVar(s1[0])], stack.slice(2));
                 }
             case "SLICE":
-                return __spreadArray([annotateVar({ prim: "option", args: [args(0, ["nat"], ["nat"], ["string", "bytes"])[2]] }, "@slice")], __read(stack.slice(3)));
+                return __spread([annotateVar({ prim: "option", args: [args(0, ["nat"], ["nat"], ["string", "bytes"])[2]] }, "@slice")], stack.slice(3));
             case "PACK":
                 {
-                    var s_15 = args(0, null)[0];
-                    ensurePackableType(s_15);
-                    return __spreadArray([annotateVar({ prim: "bytes" }, "@packed")], __read(stack.slice(1)));
+                    var s = args(0, null)[0];
+                    ensurePackableType(s);
+                    return __spread([annotateVar({ prim: "bytes" }, "@packed")], stack.slice(1));
                 }
             case "ADD":
                 {
-                    var s_16 = args(0, ["nat", "int", "timestamp", "mutez", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr"], ["nat", "int", "timestamp", "mutez", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr"]);
-                    if (s_16[0].prim === "nat" && s_16[1].prim === "int" || s_16[0].prim === "int" && s_16[1].prim === "nat") {
-                        return __spreadArray([annotateVar({ prim: "int" })], __read(stack.slice(2)));
+                    var s = args(0, ["nat", "int", "timestamp", "mutez", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr"], ["nat", "int", "timestamp", "mutez", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr"]);
+                    if (s[0].prim === "nat" && s[1].prim === "int" || s[0].prim === "int" && s[1].prim === "nat") {
+                        return __spread([annotateVar({ prim: "int" })], stack.slice(2));
                     }
-                    else if (s_16[0].prim === "int" && s_16[1].prim === "timestamp" || s_16[0].prim === "timestamp" && s_16[1].prim === "int") {
-                        return __spreadArray([annotateVar({ prim: "timestamp" })], __read(stack.slice(2)));
+                    else if (s[0].prim === "int" && s[1].prim === "timestamp" || s[0].prim === "timestamp" && s[1].prim === "int") {
+                        return __spread([annotateVar({ prim: "timestamp" })], stack.slice(2));
                     }
-                    else if ((s_16[0].prim === "int" || s_16[0].prim === "nat" || s_16[0].prim === "mutez" || s_16[0].prim === "bls12_381_g1" || s_16[0].prim === "bls12_381_g2" || s_16[0].prim === "bls12_381_fr") && s_16[0].prim === s_16[1].prim) {
-                        return __spreadArray([annotateVar(s_16[0])], __read(stack.slice(2)));
+                    else if ((s[0].prim === "int" || s[0].prim === "nat" || s[0].prim === "mutez" || s[0].prim === "bls12_381_g1" || s[0].prim === "bls12_381_g2" || s[0].prim === "bls12_381_fr") && s[0].prim === s[1].prim) {
+                        return __spread([annotateVar(s[0])], stack.slice(2));
                     }
-                    throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": can't add " + s_16[0].prim + " to " + s_16[1].prim);
+                    throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": can't add " + s[0].prim + " to " + s[1].prim);
                 }
             case "SUB":
                 {
-                    var s_17 = args(0, ["nat", "int", "timestamp", "mutez"], ["nat", "int", "timestamp", "mutez"]);
-                    if (((s_17[0].prim === "nat" || s_17[0].prim === "int") && (s_17[1].prim === "nat" || s_17[1].prim === "int")) ||
-                        s_17[0].prim === "timestamp" && s_17[1].prim === "timestamp") {
-                        return __spreadArray([annotateVar({ prim: "int" })], __read(stack.slice(2)));
+                    var s = args(0, ["nat", "int", "timestamp", "mutez"], ["nat", "int", "timestamp", "mutez"]);
+                    if (((s[0].prim === "nat" || s[0].prim === "int") && (s[1].prim === "nat" || s[1].prim === "int")) ||
+                        s[0].prim === "timestamp" && s[1].prim === "timestamp") {
+                        return __spread([annotateVar({ prim: "int" })], stack.slice(2));
                     }
-                    else if (s_17[0].prim === "timestamp" && s_17[1].prim === "int") {
-                        return __spreadArray([annotateVar({ prim: "timestamp" })], __read(stack.slice(2)));
+                    else if (s[0].prim === "timestamp" && s[1].prim === "int") {
+                        return __spread([annotateVar({ prim: "timestamp" })], stack.slice(2));
                     }
-                    else if (s_17[0].prim === "mutez" && s_17[1].prim === "mutez") {
-                        return __spreadArray([annotateVar({ prim: "mutez" })], __read(stack.slice(2)));
+                    else if (s[0].prim === "mutez" && s[1].prim === "mutez") {
+                        return __spread([annotateVar({ prim: "mutez" })], stack.slice(2));
                     }
-                    throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": can't subtract " + s_17[0].prim + " from " + s_17[1].prim);
+                    throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": can't subtract " + s[0].prim + " from " + s[1].prim);
                 }
             case "MUL":
                 {
-                    var s_18 = args(0, ["nat", "int", "mutez", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr"], ["nat", "int", "mutez", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr"]);
-                    if (s_18[0].prim === "nat" && s_18[1].prim === "int" || s_18[0].prim === "int" && s_18[1].prim === "nat") {
-                        return __spreadArray([annotateVar({ prim: "int" })], __read(stack.slice(2)));
+                    var s = args(0, ["nat", "int", "mutez", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr"], ["nat", "int", "mutez", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr"]);
+                    if (s[0].prim === "nat" && s[1].prim === "int" || s[0].prim === "int" && s[1].prim === "nat") {
+                        return __spread([annotateVar({ prim: "int" })], stack.slice(2));
                     }
-                    else if (s_18[0].prim === "nat" && s_18[1].prim === "mutez" || s_18[0].prim === "mutez" && s_18[1].prim === "nat") {
-                        return __spreadArray([annotateVar({ prim: "mutez" })], __read(stack.slice(2)));
+                    else if (s[0].prim === "nat" && s[1].prim === "mutez" || s[0].prim === "mutez" && s[1].prim === "nat") {
+                        return __spread([annotateVar({ prim: "mutez" })], stack.slice(2));
                     }
-                    else if ((s_18[0].prim === "bls12_381_g1" || s_18[0].prim === "bls12_381_g2" || s_18[0].prim === "bls12_381_fr") && s_18[1].prim === "bls12_381_fr" ||
-                        (s_18[0].prim === "nat" || s_18[0].prim === "int") && s_18[0].prim === s_18[1].prim) {
-                        return __spreadArray([annotateVar(s_18[0])], __read(stack.slice(2)));
+                    else if ((s[0].prim === "bls12_381_g1" || s[0].prim === "bls12_381_g2" || s[0].prim === "bls12_381_fr") && s[1].prim === "bls12_381_fr" ||
+                        (s[0].prim === "nat" || s[0].prim === "int") && s[0].prim === s[1].prim) {
+                        return __spread([annotateVar(s[0])], stack.slice(2));
                     }
-                    else if ((s_18[0].prim === "nat" || s_18[0].prim === "int") && s_18[1].prim === "bls12_381_fr" ||
-                        (s_18[1].prim === "nat" || s_18[1].prim === "int") && s_18[0].prim === "bls12_381_fr") {
-                        return __spreadArray([annotateVar({ prim: "bls12_381_fr" })], __read(stack.slice(2)));
+                    else if ((s[0].prim === "nat" || s[0].prim === "int") && s[1].prim === "bls12_381_fr" ||
+                        (s[1].prim === "nat" || s[1].prim === "int") && s[0].prim === "bls12_381_fr") {
+                        return __spread([annotateVar({ prim: "bls12_381_fr" })], stack.slice(2));
                     }
-                    throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": can't multiply " + s_18[0].prim + " by " + s_18[1].prim);
+                    throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": can't multiply " + s[0].prim + " by " + s[1].prim);
                 }
             case "EDIV":
                 {
                     var res = function (a, b) { return ({ prim: "option", args: [{ prim: "pair", args: [{ prim: a }, { prim: b }] }] }); };
-                    var s_19 = args(0, ["nat", "int", "mutez"], ["nat", "int", "mutez"]);
-                    if (s_19[0].prim === "nat" && s_19[1].prim === "nat") {
-                        return __spreadArray([annotateVar(res("nat", "nat"))], __read(stack.slice(2)));
+                    var s = args(0, ["nat", "int", "mutez"], ["nat", "int", "mutez"]);
+                    if (s[0].prim === "nat" && s[1].prim === "nat") {
+                        return __spread([annotateVar(res("nat", "nat"))], stack.slice(2));
                     }
-                    else if ((s_19[0].prim === "nat" || s_19[0].prim === "int") && (s_19[1].prim === "nat" || s_19[1].prim === "int")) {
-                        return __spreadArray([annotateVar(res("int", "nat"))], __read(stack.slice(2)));
+                    else if ((s[0].prim === "nat" || s[0].prim === "int") && (s[1].prim === "nat" || s[1].prim === "int")) {
+                        return __spread([annotateVar(res("int", "nat"))], stack.slice(2));
                     }
-                    else if (s_19[0].prim === "mutez" && s_19[1].prim === "nat") {
-                        return __spreadArray([annotateVar(res("mutez", "mutez"))], __read(stack.slice(2)));
+                    else if (s[0].prim === "mutez" && s[1].prim === "nat") {
+                        return __spread([annotateVar(res("mutez", "mutez"))], stack.slice(2));
                     }
-                    else if (s_19[0].prim === "mutez" && s_19[1].prim === "mutez") {
-                        return __spreadArray([annotateVar(res("nat", "mutez"))], __read(stack.slice(2)));
+                    else if (s[0].prim === "mutez" && s[1].prim === "mutez") {
+                        return __spread([annotateVar(res("nat", "mutez"))], stack.slice(2));
                     }
-                    throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": can't euclideally divide " + s_19[0].prim + " by " + s_19[1].prim);
+                    throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": can't euclideally divide " + s[0].prim + " by " + s[1].prim);
                 }
             case "ABS":
                 args(0, ["int"]);
-                return __spreadArray([annotateVar({ prim: "nat" })], __read(stack.slice(1)));
+                return __spread([annotateVar({ prim: "nat" })], stack.slice(1));
             case "ISNAT":
                 args(0, ["int"]);
-                return __spreadArray([annotateVar({ prim: "option", args: [{ prim: "nat" }] })], __read(stack.slice(1)));
+                return __spread([annotateVar({ prim: "option", args: [{ prim: "nat" }] })], stack.slice(1));
             case "INT":
                 args(0, ["nat", "bls12_381_fr"]);
-                return __spreadArray([annotateVar({ prim: "int" })], __read(stack.slice(1)));
+                return __spread([annotateVar({ prim: "int" })], stack.slice(1));
             case "NEG":
                 {
-                    var s_20 = args(0, ["nat", "int", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr"])[0];
-                    if (s_20.prim === "nat" || s_20.prim === "int") {
-                        return __spreadArray([annotateVar({ prim: "int" })], __read(stack.slice(1)));
+                    var s = args(0, ["nat", "int", "bls12_381_g1", "bls12_381_g2", "bls12_381_fr"])[0];
+                    if (s.prim === "nat" || s.prim === "int") {
+                        return __spread([annotateVar({ prim: "int" })], stack.slice(1));
                     }
-                    return __spreadArray([annotateVar(s_20)], __read(stack.slice(1)));
+                    return __spread([annotateVar(s)], stack.slice(1));
                 }
             case "LSL":
             case "LSR":
                 args(0, ["nat"], ["nat"]);
-                return __spreadArray([annotateVar({ prim: "nat" })], __read(stack.slice(2)));
+                return __spread([annotateVar({ prim: "nat" })], stack.slice(2));
             case "OR":
             case "XOR":
                 {
-                    var s_21 = args(0, ["nat", "bool"], ["nat", "bool"]);
-                    if (s_21[0].prim !== s_21[1].prim) {
-                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": both arguments must be of the same type: " + s_21[0].prim + ", " + s_21[1].prim);
+                    var s = args(0, ["nat", "bool"], ["nat", "bool"]);
+                    if (s[0].prim !== s[1].prim) {
+                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": both arguments must be of the same type: " + s[0].prim + ", " + s[1].prim);
                     }
-                    return __spreadArray([annotateVar(s_21[1])], __read(stack.slice(2)));
+                    return __spread([annotateVar(s[1])], stack.slice(2));
                 }
             case "AND":
                 {
-                    var s_22 = args(0, ["nat", "bool", "int"], ["nat", "bool"]);
-                    if ((s_22[0].prim !== "int" || s_22[1].prim !== "nat") && s_22[0].prim !== s_22[1].prim) {
-                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": both arguments must be of the same type: " + s_22[0].prim + ", " + s_22[1].prim);
+                    var s = args(0, ["nat", "bool", "int"], ["nat", "bool"]);
+                    if ((s[0].prim !== "int" || s[1].prim !== "nat") && s[0].prim !== s[1].prim) {
+                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": both arguments must be of the same type: " + s[0].prim + ", " + s[1].prim);
                     }
-                    return __spreadArray([annotateVar(s_22[1])], __read(stack.slice(2)));
+                    return __spread([annotateVar(s[1])], stack.slice(2));
                 }
             case "NOT":
                 {
-                    var s_23 = args(0, ["nat", "bool", "int"])[0];
-                    if (s_23.prim === "bool") {
-                        return __spreadArray([annotateVar({ prim: "bool" })], __read(stack.slice(1)));
+                    var s = args(0, ["nat", "bool", "int"])[0];
+                    if (s.prim === "bool") {
+                        return __spread([annotateVar({ prim: "bool" })], stack.slice(1));
                     }
-                    return __spreadArray([annotateVar({ prim: "int" })], __read(stack.slice(1)));
+                    return __spread([annotateVar({ prim: "int" })], stack.slice(1));
                 }
             case "COMPARE":
                 {
-                    var s_24 = args(0, null, null);
-                    ensureComparableType(s_24[0]);
-                    ensureComparableType(s_24[1]);
-                    return __spreadArray([annotateVar({ prim: "int" })], __read(stack.slice(2)));
+                    var s = args(0, null, null);
+                    ensureComparableType(s[0]);
+                    ensureComparableType(s[1]);
+                    return __spread([annotateVar({ prim: "int" })], stack.slice(2));
                 }
             case "EQ":
             case "NEQ":
@@ -5097,7 +5181,7 @@ function functionTypeInternal(inst, stack, ctx) {
             case "LE":
             case "GE":
                 args(0, ["int"]);
-                return __spreadArray([annotateVar({ prim: "bool" })], __read(stack.slice(1)));
+                return __spread([annotateVar({ prim: "bool" })], stack.slice(1));
             case "SELF":
                 {
                     if ((ctx === null || ctx === void 0 ? void 0 : ctx.contract) === undefined) {
@@ -5108,55 +5192,55 @@ function functionTypeInternal(inst, stack, ctx) {
                     if (ep === null) {
                         throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": contract has no entrypoint " + ep);
                     }
-                    return __spreadArray([annotate({ prim: "contract", args: [ep] }, { v: ia.v ? ia.v : ["@self"] })], __read(stack));
+                    return __spread([annotate({ prim: "contract", args: [ep] }, { v: ia.v ? ia.v : ["@self"] })], stack);
                 }
             case "TRANSFER_TOKENS":
                 {
-                    var s_25 = args(0, null, ["mutez"], ["contract"]);
-                    ensureTypesEqual(s_25[0], s_25[2].args[0]);
-                    return __spreadArray([annotateVar({ prim: "operation" })], __read(stack.slice(3)));
+                    var s = args(0, null, ["mutez"], ["contract"]);
+                    ensureTypesEqual(s[0], s[2].args[0]);
+                    return __spread([annotateVar({ prim: "operation" })], stack.slice(3));
                 }
             case "SET_DELEGATE":
                 {
-                    var s_26 = args(0, ["option"])[0];
-                    if (typeID(s_26.args[0]) !== "key_hash") {
-                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": key hash expected: " + typeID(s_26.args[0]));
+                    var s = args(0, ["option"])[0];
+                    if (typeID(s.args[0]) !== "key_hash") {
+                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": key hash expected: " + typeID(s.args[0]));
                     }
-                    return __spreadArray([annotateVar({ prim: "operation" })], __read(stack.slice(1)));
+                    return __spread([annotateVar({ prim: "operation" })], stack.slice(1));
                 }
             case "IMPLICIT_ACCOUNT":
                 args(0, ["key_hash"]);
-                return __spreadArray([annotateVar({ prim: "contract", args: [{ prim: "unit" }] })], __read(stack.slice(1)));
+                return __spread([annotateVar({ prim: "contract", args: [{ prim: "unit" }] })], stack.slice(1));
             case "NOW":
-                return __spreadArray([annotateVar({ prim: "timestamp" }, "@now")], __read(stack));
+                return __spread([annotateVar({ prim: "timestamp" }, "@now")], stack);
             case "AMOUNT":
-                return __spreadArray([annotateVar({ prim: "mutez" }, "@amount")], __read(stack));
+                return __spread([annotateVar({ prim: "mutez" }, "@amount")], stack);
             case "BALANCE":
-                return __spreadArray([annotateVar({ prim: "mutez" }, "@balance")], __read(stack));
+                return __spread([annotateVar({ prim: "mutez" }, "@balance")], stack);
             case "CHECK_SIGNATURE":
                 args(0, ["key"], ["signature"], ["bytes"]);
-                return __spreadArray([annotateVar({ prim: "bool" })], __read(stack.slice(3)));
+                return __spread([annotateVar({ prim: "bool" })], stack.slice(3));
             case "BLAKE2B":
             case "SHA256":
             case "SHA512":
             case "KECCAK":
             case "SHA3":
                 args(0, ["bytes"]);
-                return __spreadArray([annotateVar({ prim: "bytes" })], __read(stack.slice(1)));
+                return __spread([annotateVar({ prim: "bytes" })], stack.slice(1));
             case "HASH_KEY":
                 args(0, ["key"]);
-                return __spreadArray([annotateVar({ prim: "key_hash" })], __read(stack.slice(1)));
+                return __spread([annotateVar({ prim: "key_hash" })], stack.slice(1));
             case "SOURCE":
-                return __spreadArray([annotateVar({ prim: "address" }, "@source")], __read(stack));
+                return __spread([annotateVar({ prim: "address" }, "@source")], stack);
             case "SENDER":
-                return __spreadArray([annotateVar({ prim: "address" }, "@sender")], __read(stack));
+                return __spread([annotateVar({ prim: "address" }, "@sender")], stack);
             case "ADDRESS":
                 {
-                    var s_27 = args(0, ["contract"])[0];
+                    var s = args(0, ["contract"])[0];
                     var ia = instructionAnn({ v: 1 });
-                    return __spreadArray([
-                        annotate((_a = { prim: "address" }, _a[refContract] = s_27, _a), { v: ia.v ? ia.v : varSuffix(argAnn(s_27), "address") })
-                    ], __read(stack.slice(1)));
+                    return __spread([
+                        annotate((_a = { prim: "address" }, _a[refContract] = s, _a), { v: ia.v ? ia.v : varSuffix(argAnn(s), "address") })
+                    ], stack.slice(1));
                 }
             case "SELF_ADDRESS":
                 {
@@ -5164,10 +5248,10 @@ function functionTypeInternal(inst, stack, ctx) {
                     if ((ctx === null || ctx === void 0 ? void 0 : ctx.contract) !== undefined) {
                         addr[refContract] = { prim: "contract", args: [contractSection(ctx.contract, "parameter").args[0]] };
                     }
-                    return __spreadArray([annotateVar(addr, "@address")], __read(stack));
+                    return __spread([annotateVar(addr, "@address")], stack);
                 }
             case "CHAIN_ID":
-                return __spreadArray([annotateVar({ prim: "chain_id" })], __read(stack));
+                return __spread([annotateVar({ prim: "chain_id" })], stack);
             case "DROP":
                 {
                     instructionAnn({});
@@ -5179,25 +5263,25 @@ function functionTypeInternal(inst, stack, ctx) {
                 {
                     instructionAnn({});
                     var n = parseInt(instruction.args[0].int, 10);
-                    return __spreadArray(__spreadArray([args(n, null)[0]], __read(stack.slice(0, n))), __read(stack.slice(n + 1)));
+                    return __spread([args(n, null)[0]], stack.slice(0, n), stack.slice(n + 1));
                 }
             case "DUG":
                 {
                     instructionAnn({});
                     var n = parseInt(instruction.args[0].int, 10);
-                    return __spreadArray(__spreadArray(__spreadArray([], __read(stack.slice(1, n + 1))), [args(0, null)[0]]), __read(stack.slice(n + 1)));
+                    return __spread(stack.slice(1, n + 1), [args(0, null)[0]], stack.slice(n + 1));
                 }
             case "NONE":
                 assertTypeAnnotationsValid(instruction.args[0]);
-                return __spreadArray([annotate({ prim: "option", args: [instruction.args[0]] }, instructionAnn({ t: 1, v: 1 }))], __read(stack));
+                return __spread([annotate({ prim: "option", args: [instruction.args[0]] }, instructionAnn({ t: 1, v: 1 }))], stack);
             case "LEFT":
             case "RIGHT":
                 {
-                    var s_28 = args(0, null)[0];
+                    var s = args(0, null)[0];
                     var ia = instructionAnn({ f: 2, t: 1, v: 1 }, { specialFields: true });
-                    var va = argAnn(s_28);
+                    var va = argAnn(s);
                     var children = [
-                        annotate(s_28, {
+                        annotate(s, {
                             t: null,
                             v: null,
                             f: ia.f && ia.f.length > 0 && ia.f[0] !== "%" ?
@@ -5211,23 +5295,23 @@ function functionTypeInternal(inst, stack, ctx) {
                             f: ia.f && ia.f.length > 1 && ia.f[1] !== "%" ? ia.f : undefined,
                         }),
                     ];
-                    return __spreadArray([annotate({
+                    return __spread([annotate({
                             prim: "or", args: instruction.prim === "LEFT" ? children : [children[1], children[0]]
-                        }, { t: ia.t, v: ia.v })], __read(stack.slice(1)));
+                        }, { t: ia.t, v: ia.v })], stack.slice(1));
                 }
             case "NIL":
                 assertTypeAnnotationsValid(instruction.args[0]);
-                return __spreadArray([annotate({ prim: "list", args: [instruction.args[0]] }, instructionAnn({ t: 1, v: 1 }))], __read(stack));
+                return __spread([annotate({ prim: "list", args: [instruction.args[0]] }, instructionAnn({ t: 1, v: 1 }))], stack);
             case "UNPACK":
                 args(0, ["bytes"]);
                 assertTypeAnnotationsValid(instruction.args[0]);
-                return __spreadArray([annotateVar({ prim: "option", args: [instruction.args[0]] }, "@unpacked")], __read(stack.slice(1)));
+                return __spread([annotateVar({ prim: "option", args: [instruction.args[0]] }, "@unpacked")], stack.slice(1));
             case "CONTRACT":
                 {
-                    var s_29 = args(0, ["address"])[0];
+                    var s = args(0, ["address"])[0];
                     assertTypeAnnotationsValid(instruction.args[0]);
                     var ia = instructionAnn({ v: 1, f: 1 });
-                    var contract = s_29[refContract];
+                    var contract = s[refContract];
                     if (contract !== undefined) {
                         var ep = contractEntryPoint(contract, (_e = ia.f) === null || _e === void 0 ? void 0 : _e[0]);
                         if (ep === null) {
@@ -5235,51 +5319,53 @@ function functionTypeInternal(inst, stack, ctx) {
                         }
                         ensureTypesEqual(ep, instruction.args[0]);
                     }
-                    return __spreadArray([
-                        annotate({ prim: "option", args: [{ prim: "contract", args: [instruction.args[0]] }] }, { v: ia.v ? ia.v : varSuffix(argAnn(s_29), "contract") })
-                    ], __read(stack.slice(1)));
+                    return __spread([
+                        annotate({ prim: "option", args: [{ prim: "contract", args: [instruction.args[0]] }] }, { v: ia.v ? ia.v : varSuffix(argAnn(s), "contract") })
+                    ], stack.slice(1));
                 }
             case "CAST":
-                instructionAnn({});
-                var s = args(0, null)[0];
-                assertTypeAnnotationsValid(instruction.args[0]);
-                ensureTypesEqual(instruction.args[0], s);
-                return __spreadArray([instruction.args[0]], __read(stack.slice(1)));
+                {
+                    instructionAnn({});
+                    var s = args(0, null)[0];
+                    assertTypeAnnotationsValid(instruction.args[0]);
+                    ensureTypesEqual(instruction.args[0], s);
+                    return __spread([instruction.args[0]], stack.slice(1));
+                }
             case "IF_NONE":
                 {
                     instructionAnn({});
-                    var s_30 = args(0, ["option"])[0];
+                    var s = args(0, ["option"])[0];
                     var tail = stack.slice(1);
                     var br0 = functionTypeInternal(instruction.args[0], tail, ctx);
-                    var br1 = functionTypeInternal(instruction.args[1], __spreadArray([annotate(s_30.args[0], { t: null, v: varSuffix(argAnn(s_30), "some") })], __read(tail)), ctx);
+                    var br1 = functionTypeInternal(instruction.args[1], __spread([annotate(s.args[0], { t: null, v: varSuffix(argAnn(s), "some") })], tail), ctx);
                     return branchType(br0, br1);
                 }
             case "IF_LEFT":
                 {
                     instructionAnn({});
-                    var s_31 = args(0, ["or"])[0];
-                    var va = argAnn(s_31);
-                    var lefta = argAnn(s_31.args[0]);
-                    var righta = argAnn(s_31.args[1]);
+                    var s = args(0, ["or"])[0];
+                    var va = argAnn(s);
+                    var lefta = argAnn(s.args[0]);
+                    var righta = argAnn(s.args[1]);
                     var tail = stack.slice(1);
-                    var br0 = functionTypeInternal(instruction.args[0], __spreadArray([
-                        annotate(s_31.args[0], { t: null, v: varSuffix(va, lefta.f ? lefta.f[0].slice(1) : "left") })
-                    ], __read(tail)), ctx);
-                    var br1 = functionTypeInternal(instruction.args[1], __spreadArray([
-                        annotate(s_31.args[1], { t: null, v: varSuffix(va, righta.f ? righta.f[0].slice(1) : "right") })
-                    ], __read(tail)), ctx);
+                    var br0 = functionTypeInternal(instruction.args[0], __spread([
+                        annotate(s.args[0], { t: null, v: varSuffix(va, lefta.f ? lefta.f[0].slice(1) : "left") })
+                    ], tail), ctx);
+                    var br1 = functionTypeInternal(instruction.args[1], __spread([
+                        annotate(s.args[1], { t: null, v: varSuffix(va, righta.f ? righta.f[0].slice(1) : "right") })
+                    ], tail), ctx);
                     return branchType(br0, br1);
                 }
             case "IF_CONS":
                 {
                     instructionAnn({});
-                    var s_32 = args(0, ["list"])[0];
-                    var va = argAnn(s_32);
+                    var s = args(0, ["list"])[0];
+                    var va = argAnn(s);
                     var tail = stack.slice(1);
-                    var br0 = functionTypeInternal(instruction.args[0], __spreadArray([
-                        annotate(s_32.args[0], { t: null, v: varSuffix(va, "hd") }),
-                        annotate(s_32, { t: null, v: varSuffix(va, "tl") })
-                    ], __read(tail)), ctx);
+                    var br0 = functionTypeInternal(instruction.args[0], __spread([
+                        annotate(s.args[0], { t: null, v: varSuffix(va, "hd") }),
+                        annotate(s, { t: null, v: varSuffix(va, "tl") })
+                    ], tail), ctx);
                     var br1 = functionTypeInternal(instruction.args[1], tail, ctx);
                     return branchType(br0, br1);
                 }
@@ -5294,10 +5380,10 @@ function functionTypeInternal(inst, stack, ctx) {
                 }
             case "MAP":
                 {
-                    var s_33 = args(0, ["list", "map"])[0];
+                    var s = args(0, ["list", "map"])[0];
                     var tail = stack.slice(1);
-                    var elt = s_33.prim === "map" ? { prim: "pair", args: s_33.args } : s_33.args[0];
-                    var body = functionTypeInternal(instruction.args[0], __spreadArray([annotate(elt, { t: null, v: varSuffix(argAnn(s_33), "elt") })], __read(tail)), ctx);
+                    var elt = s.prim === "map" ? { prim: "pair", args: s.args } : s.args[0];
+                    var body = functionTypeInternal(instruction.args[0], __spread([annotate(elt, { t: null, v: varSuffix(argAnn(s), "elt") })], tail), ctx);
                     if ("failed" in body) {
                         return body;
                     }
@@ -5305,18 +5391,18 @@ function functionTypeInternal(inst, stack, ctx) {
                         throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": function must return a value");
                     }
                     ensureStacksEqual(body.slice(1), tail);
-                    if (s_33.prim === "list") {
-                        return __spreadArray([annotateVar({ prim: "list", args: [body[0]] })], __read(tail));
+                    if (s.prim === "list") {
+                        return __spread([annotateVar({ prim: "list", args: [body[0]] })], tail);
                     }
-                    return __spreadArray([annotateVar({ prim: "map", args: [s_33.args[0], body[0]] })], __read(tail));
+                    return __spread([annotateVar({ prim: "map", args: [s.args[0], body[0]] })], tail);
                 }
             case "ITER":
                 {
                     instructionAnn({});
-                    var s_34 = args(0, ["set", "list", "map"])[0];
+                    var s = args(0, ["set", "list", "map"])[0];
                     var tail = stack.slice(1);
-                    var elt = s_34.prim === "map" ? { prim: "pair", args: s_34.args } : s_34.args[0];
-                    var body = functionTypeInternal(instruction.args[0], __spreadArray([annotate(elt, { t: null, v: varSuffix(argAnn(s_34), "elt") })], __read(tail)), ctx);
+                    var elt = s.prim === "map" ? { prim: "pair", args: s.args } : s.args[0];
+                    var body = functionTypeInternal(instruction.args[0], __spread([annotate(elt, { t: null, v: varSuffix(argAnn(s), "elt") })], tail), ctx);
                     if ("failed" in body) {
                         return body;
                     }
@@ -5332,20 +5418,20 @@ function functionTypeInternal(inst, stack, ctx) {
                     if ("failed" in body) {
                         return body;
                     }
-                    ensureStacksEqual(body, __spreadArray([{ prim: "bool" }], __read(tail)));
+                    ensureStacksEqual(body, __spread([{ prim: "bool" }], tail));
                     return tail;
                 }
             case "LOOP_LEFT":
                 {
                     instructionAnn({});
-                    var s_35 = args(0, ["or"])[0];
+                    var s = args(0, ["or"])[0];
                     var tail = stack.slice(1);
-                    var body = functionTypeInternal(instruction.args[0], __spreadArray([annotate(s_35.args[0], { t: null, v: varSuffix(argAnn(s_35), "left") })], __read(tail)), ctx);
+                    var body = functionTypeInternal(instruction.args[0], __spread([annotate(s.args[0], { t: null, v: varSuffix(argAnn(s), "left") })], tail), ctx);
                     if ("failed" in body) {
                         return body;
                     }
-                    ensureStacksEqual(body, __spreadArray([s_35], __read(tail)));
-                    return __spreadArray([annotate(s_35.args[1], { t: null, v: instructionAnn({ v: 1 }).v })], __read(tail));
+                    ensureStacksEqual(body, __spread([s], tail));
+                    return __spread([annotate(s.args[1], { t: null, v: instructionAnn({ v: 1 }).v })], tail);
                 }
             case "DIP":
                 {
@@ -5361,48 +5447,48 @@ function functionTypeInternal(inst, stack, ctx) {
                     if ("failed" in body) {
                         return body;
                     }
-                    return __spreadArray(__spreadArray([], __read(head)), __read(body));
+                    return __spread(head, body);
                 }
             case "CREATE_CONTRACT":
                 {
                     var ia = instructionAnn({ v: 2 });
-                    var s_36 = args(0, ["option"], ["mutez"], null);
-                    if (typeID(s_36[0].args[0]) !== "key_hash") {
-                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": key hash expected: " + typeID(s_36[0].args[0]));
+                    var s = args(0, ["option"], ["mutez"], null);
+                    if (typeID(s[0].args[0]) !== "key_hash") {
+                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": key hash expected: " + typeID(s[0].args[0]));
                     }
-                    if (ensureStorableType(s_36[2])) {
+                    if (ensureStorableType(s[2])) {
                         assertContractValid(instruction.args[0]);
-                        assertScalarTypesEqual(contractSection(instruction.args[0], "storage").args[0], s_36[2]);
+                        assertScalarTypesEqual(contractSection(instruction.args[0], "storage").args[0], s[2]);
                     }
                     var va = (_f = ia.v) === null || _f === void 0 ? void 0 : _f.map(function (v) { return v !== "@" ? [v] : undefined; });
-                    return __spreadArray([
+                    return __spread([
                         annotate({ prim: "operation" }, { v: va === null || va === void 0 ? void 0 : va[0] }),
                         annotate((_b = {
                                 prim: "address"
                             },
                             _b[refContract] = { prim: "contract", args: [contractSection(instruction.args[0], "parameter").args[0]] },
                             _b), { v: va === null || va === void 0 ? void 0 : va[1] })
-                    ], __read(stack.slice(3)));
+                    ], stack.slice(3));
                 }
             case "PUSH":
                 assertTypeAnnotationsValid(instruction.args[0]);
                 assertDataValidInternal(instruction.args[1], instruction.args[0], __assign(__assign({}, ctx), { contract: undefined }));
-                return __spreadArray([annotateVar(instruction.args[0])], __read(stack));
+                return __spread([annotateVar(instruction.args[0])], stack);
             case "EMPTY_SET":
                 assertTypeAnnotationsValid(instruction.args[0]);
                 ensureComparableType(instruction.args[0]);
-                return __spreadArray([annotate({ prim: "set", args: instruction.args }, instructionAnn({ t: 1, v: 1 }))], __read(stack));
+                return __spread([annotate({ prim: "set", args: instruction.args }, instructionAnn({ t: 1, v: 1 }))], stack);
             case "EMPTY_MAP":
                 assertTypeAnnotationsValid(instruction.args[0]);
                 ensureComparableType(instruction.args[0]);
                 assertTypeAnnotationsValid(instruction.args[1]);
-                return __spreadArray([annotate({ prim: "map", args: instruction.args }, instructionAnn({ t: 1, v: 1 }))], __read(stack));
+                return __spread([annotate({ prim: "map", args: instruction.args }, instructionAnn({ t: 1, v: 1 }))], stack);
             case "EMPTY_BIG_MAP":
                 assertTypeAnnotationsValid(instruction.args[0]);
                 ensureComparableType(instruction.args[0]);
                 assertTypeAnnotationsValid(instruction.args[1]);
                 ensureBigMapStorableType(instruction.args[0]);
-                return __spreadArray([annotate({ prim: "big_map", args: instruction.args }, instructionAnn({ t: 1, v: 1 }))], __read(stack));
+                return __spread([annotate({ prim: "big_map", args: instruction.args }, instructionAnn({ t: 1, v: 1 }))], stack);
             case "LAMBDA":
                 {
                     assertTypeAnnotationsValid(instruction.args[0]);
@@ -5415,68 +5501,68 @@ function functionTypeInternal(inst, stack, ctx) {
                         throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": function must return a value");
                     }
                     ensureTypesEqual(instruction.args[1], body[0]);
-                    return __spreadArray([annotateVar({ prim: "lambda", args: [instruction.args[0], instruction.args[1]] })], __read(stack));
+                    return __spread([annotateVar({ prim: "lambda", args: [instruction.args[0], instruction.args[1]] })], stack);
                 }
             case "LEVEL":
-                return __spreadArray([annotateVar({ prim: "nat" }, "@level")], __read(stack));
+                return __spread([annotateVar({ prim: "nat" }, "@level")], stack);
             case "TOTAL_VOTING_POWER":
-                return __spreadArray([annotateVar({ prim: "nat" })], __read(stack));
+                return __spread([annotateVar({ prim: "nat" })], stack);
             case "VOTING_POWER":
                 args(0, ["key_hash"]);
-                return __spreadArray([annotateVar({ prim: "nat" })], __read(stack.slice(1)));
+                return __spread([annotateVar({ prim: "nat" })], stack.slice(1));
             case "TICKET":
                 {
-                    var s_37 = args(0, null, ["nat"])[0];
-                    ensureComparableType(s_37);
-                    return __spreadArray([annotate({ prim: "ticket", args: [s_37] }, instructionAnn({ t: 1, v: 1 }))], __read(stack.slice(2)));
+                    var s = args(0, null, ["nat"])[0];
+                    ensureComparableType(s);
+                    return __spread([annotate({ prim: "ticket", args: [s] }, instructionAnn({ t: 1, v: 1 }))], stack.slice(2));
                 }
             case "JOIN_TICKETS":
                 {
-                    var s_38 = unpackComb("pair", args(0, ["pair"])[0]);
-                    if (typeID(s_38.args[0]) !== "ticket") {
-                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": ticket expected: " + typeID(s_38.args[0]));
+                    var s = unpackComb("pair", args(0, ["pair"])[0]);
+                    if (typeID(s.args[0]) !== "ticket") {
+                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": ticket expected: " + typeID(s.args[0]));
                     }
-                    ensureTypesEqual(s_38.args[0], s_38.args[1]);
-                    return __spreadArray([annotateVar({
+                    ensureTypesEqual(s.args[0], s.args[1]);
+                    return __spread([annotateVar({
                             prim: "option",
-                            args: [annotate(s_38.args[0], { t: null })],
-                        })], __read(stack.slice(1)));
+                            args: [annotate(s.args[0], { t: null })],
+                        })], stack.slice(1));
                 }
             case "SPLIT_TICKET":
                 {
-                    var s_39 = args(0, ["ticket"], ["pair"]);
-                    var p = unpackComb("pair", s_39[1]);
+                    var s = args(0, ["ticket"], ["pair"]);
+                    var p = unpackComb("pair", s[1]);
                     if (typeID(p.args[0]) !== "nat") {
                         throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": nat expected: " + typeID(p.args[0]));
                     }
                     ensureTypesEqual(p.args[0], p.args[1]);
-                    return __spreadArray([annotateVar({
+                    return __spread([annotateVar({
                             prim: "option",
                             args: [{
                                     prim: "pair",
                                     args: [
-                                        annotate(s_39[0], { t: null }),
-                                        annotate(s_39[0], { t: null }),
+                                        annotate(s[0], { t: null }),
+                                        annotate(s[0], { t: null }),
                                     ],
                                 }],
-                        })], __read(stack.slice(2)));
+                        })], stack.slice(2));
                 }
             case "READ_TICKET":
                 {
                     var ia = instructionAnn({ v: 2 });
-                    var s_40 = args(0, ["ticket"])[0];
+                    var s = args(0, ["ticket"])[0];
                     var va = (_g = ia.v) === null || _g === void 0 ? void 0 : _g.map(function (v) { return v !== "@" ? [v] : undefined; });
-                    return __spreadArray([
+                    return __spread([
                         annotate({
                             prim: "pair",
                             args: [
                                 { prim: "address" },
-                                annotate(s_40.args[0], { t: null }),
+                                annotate(s.args[0], { t: null }),
                                 { prim: "nat" },
                             ]
                         }, { v: va === null || va === void 0 ? void 0 : va[0] }),
-                        annotate(s_40, { v: va === null || va === void 0 ? void 0 : va[1], t: null })
-                    ], __read(stack.slice(1)));
+                        annotate(s, { v: va === null || va === void 0 ? void 0 : va[1], t: null })
+                    ], stack.slice(1));
                 }
             case "PAIRING_CHECK":
                 {
@@ -5491,26 +5577,35 @@ function functionTypeInternal(inst, stack, ctx) {
                     if (typeID(c.args[1]) !== "bls12_381_g2") {
                         throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": bls12_381_g2 expected: " + typeID(c.args[1]));
                     }
-                    return __spreadArray([annotateVar({ prim: "bool" })], __read(stack.slice(1)));
+                    return __spread([annotateVar({ prim: "bool" })], stack.slice(1));
                 }
             case "SAPLING_EMPTY_STATE":
-                return __spreadArray([annotate({ prim: "sapling_state", args: [instruction.args[0]] }, instructionAnn({ v: 1, t: 1 }))], __read(stack));
+                return __spread([annotate({ prim: "sapling_state", args: [instruction.args[0]] }, instructionAnn({ v: 1, t: 1 }))], stack);
             case "SAPLING_VERIFY_UPDATE":
                 {
-                    var s_41 = args(0, ["sapling_transaction"], ["sapling_state"]);
-                    if (parseInt(s_41[0].args[0].int, 10) !== parseInt(s_41[1].args[0].int, 10)) {
-                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": sapling memo size mismatch: " + s_41[0].args[0].int + " != " + s_41[1].args[0].int);
+                    var s = args(0, ["sapling_transaction"], ["sapling_state"]);
+                    if (parseInt(s[0].args[0].int, 10) !== parseInt(s[1].args[0].int, 10)) {
+                        throw new MichelsonInstructionError(instruction, stack, instruction.prim + ": sapling memo size mismatch: " + s[0].args[0].int + " != " + s[1].args[0].int);
                     }
-                    return __spreadArray([annotateVar({
+                    return __spread([annotateVar({
                             prim: "option",
                             args: [{
                                     prim: "pair",
                                     args: [
                                         { prim: "int" },
-                                        annotate(s_41[1], { t: null }),
+                                        annotate(s[1], { t: null }),
                                     ],
                                 }],
-                        })], __read(stack.slice(2)));
+                        })], stack.slice(2));
+                }
+            case "OPEN_CHEST":
+                args(0, ["chest_key"], ["chest"], ["nat"]);
+                return __spread([annotateVar({ prim: "or", args: [{ prim: "bytes" }, { prim: "bool" }] })], stack.slice(3));
+            case "VIEW":
+                {
+                    var s = args(0, null, ["address"]);
+                    ensurePushableType(s[0]);
+                    return __spread([annotateVar({ prim: "option", args: [instruction.args[1]] })], stack.slice(2));
                 }
             default:
                 throw new MichelsonError(instruction, "unexpected instruction: " + instruction.prim);
@@ -5545,8 +5640,28 @@ function contractSection(contract, section) {
     }
     throw new MichelsonError(contract, "missing contract section: " + section);
 }
-function isContract(v) {
+function contractViews(contract) {
     var e_9, _a;
+    var views = {};
+    try {
+        for (var contract_2 = __values(contract), contract_2_1 = contract_2.next(); !contract_2_1.done; contract_2_1 = contract_2.next()) {
+            var s = contract_2_1.value;
+            if (s.prim === "view") {
+                views[s.args[0].string] = s;
+            }
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (contract_2_1 && !contract_2_1.done && (_a = contract_2.return)) _a.call(contract_2);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    return views;
+}
+function isContract(v) {
+    var e_10, _a;
     if (Array.isArray(v)) {
         try {
             for (var v_1 = __values(v), v_1_1 = v_1.next(); !v_1_1.done; v_1_1 = v_1.next()) {
@@ -5556,12 +5671,12 @@ function isContract(v) {
                 }
             }
         }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
         finally {
             try {
                 if (v_1_1 && !v_1_1.done && (_a = v_1.return)) _a.call(v_1);
             }
-            finally { if (e_9) throw e_9.error; }
+            finally { if (e_10) throw e_10.error; }
         }
     }
     return false;
@@ -5585,7 +5700,7 @@ function contractEntryPoints(src) {
         var param = contractSection(src, "parameter");
         var ch = contractEntryPoints(param.args[0]);
         var a = unpackAnnotations(param);
-        return a.f ? __spreadArray([[a.f[0], param.args[0]]], __read(ch)) : ch;
+        return a.f ? __spread([[a.f[0], param.args[0]]], ch) : ch;
     }
     if (isOrType(src)) {
         var args_2 = typeArgs(src);
@@ -5593,49 +5708,67 @@ function contractEntryPoints(src) {
             var a = unpackAnnotations(args_2[n]);
             if (typeID(args_2[n]) === "or") {
                 var ch = contractEntryPoints(args_2[n]);
-                return a.f ? __spreadArray([[a.f[0], args_2[n]]], __read(ch)) : ch;
+                return a.f ? __spread([[a.f[0], args_2[n]]], ch) : ch;
             }
             return a.f ? [[a.f[0], args_2[n]]] : [];
         };
-        return __spreadArray(__spreadArray([], __read(getArg(0))), __read(getArg(1)));
+        return __spread(getArg(0), getArg(1));
     }
     return [];
 }
 // Contract validation
 function assertContractValid(contract, ctx) {
+    var e_11, _a;
+    var assertSection = function (parameter, storage, ret, code) {
+        assertTypeAnnotationsValid(parameter, true);
+        assertTypeAnnotationsValid(storage);
+        var arg = {
+            prim: "pair",
+            args: [
+                __assign(__assign({}, parameter), { annots: ["@parameter"] }),
+                __assign(__assign({}, storage), { annots: ["@storage"] }),
+            ]
+        };
+        var out = functionTypeInternal(code, [arg], __assign(__assign({}, ctx), { contract: contract }));
+        if ("failed" in out) {
+            return out;
+        }
+        try {
+            assertStacksEqual(out, [ret]);
+        }
+        catch (err) {
+            if (err instanceof MichelsonError) {
+                throw new MichelsonInstructionError(code, out, err.message);
+            }
+            else {
+                throw err;
+            }
+        }
+        return out;
+    };
     var parameter = contractSection(contract, "parameter").args[0];
-    assertTypeAnnotationsValid(parameter, true);
     var storage = contractSection(contract, "storage").args[0];
-    assertTypeAnnotationsValid(storage);
-    var arg = {
-        "prim": "pair",
-        args: [
-            __assign(__assign({}, parameter), { annots: ["@parameter"] }),
-            __assign(__assign({}, storage), { annots: ["@storage"] }),
-        ]
-    };
     var code = contractSection(contract, "code").args[0];
-    var ret = functionTypeInternal(code, [arg], __assign(__assign({}, ctx), { contract: contract }));
-    if ("failed" in ret) {
-        return ret;
-    }
     var expected = {
-        "prim": "pair",
+        prim: "pair",
         args: [
-            { "prim": "list", args: [{ "prim": "operation" }] },
+            { prim: "list", args: [{ prim: "operation" }] },
             storage,
         ]
     };
+    var ret = assertSection(parameter, storage, expected, code);
     try {
-        assertStacksEqual(ret, [expected]);
-    }
-    catch (err) {
-        if (err instanceof MichelsonError) {
-            throw new MichelsonInstructionError(code, ret, err.message);
+        for (var _b = __values(Object.values(contractViews(contract))), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var view = _c.value;
+            assertSection(view.args[1], storage, view.args[2], view.args[3]);
         }
-        else {
-            throw err;
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
+        finally { if (e_11) throw e_11.error; }
     }
     return ret;
 }
@@ -5645,19 +5778,19 @@ function assertDataValid(d, t, ctx) {
     assertDataValidInternal(d, t, ctx || null);
 }
 function functionType(inst, stack, ctx) {
-    var e_10, _a, e_11, _b;
+    var e_12, _a, e_13, _b;
     try {
         for (var stack_1 = __values(stack), stack_1_1 = stack_1.next(); !stack_1_1.done; stack_1_1 = stack_1.next()) {
             var t = stack_1_1.value;
             assertTypeAnnotationsValid(t);
         }
     }
-    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
     finally {
         try {
             if (stack_1_1 && !stack_1_1.done && (_a = stack_1.return)) _a.call(stack_1);
         }
-        finally { if (e_10) throw e_10.error; }
+        finally { if (e_12) throw e_12.error; }
     }
     if ((ctx === null || ctx === void 0 ? void 0 : ctx.contract) !== undefined) {
         try {
@@ -5667,18 +5800,18 @@ function functionType(inst, stack, ctx) {
                 assertTypeAnnotationsValid(sec);
             }
         }
-        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
         finally {
             try {
                 if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
             }
-            finally { if (e_11) throw e_11.error; }
+            finally { if (e_13) throw e_13.error; }
         }
     }
     return functionTypeInternal(inst, stack, ctx || null);
 }
 function assertTypesEqual(a, b, field) {
-    var e_12, _a, e_13, _b;
+    var e_14, _a, e_15, _b;
     if (field === void 0) { field = false; }
     if (Array.isArray(a)) {
         try {
@@ -5688,12 +5821,12 @@ function assertTypesEqual(a, b, field) {
                 assertTypeAnnotationsValid(v);
             }
         }
-        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
         finally {
             try {
                 if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
             }
-            finally { if (e_12) throw e_12.error; }
+            finally { if (e_14) throw e_14.error; }
         }
         try {
             for (var _e = __values(b), _f = _e.next(); !_f.done; _f = _e.next()) {
@@ -5701,12 +5834,12 @@ function assertTypesEqual(a, b, field) {
                 assertTypeAnnotationsValid(v);
             }
         }
-        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
         finally {
             try {
                 if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
             }
-            finally { if (e_13) throw e_13.error; }
+            finally { if (e_15) throw e_15.error; }
         }
     }
     else {
@@ -5881,10 +6014,10 @@ function formatError(err) {
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 /* tslint:disable */
 var VERSION = {
-    "commitHash": "5711569ffaf481d88ba3251343a1788090b35dd4",
-    "version": "10.2.1"
+    "commitHash": "8d7ecc86ce608bff9ee8c6cf0cd7d795263b8bda",
+    "version": "11.0.1"
 };
 /* tslint:enable */
 
-export { Contract, DefaultProtocol, JSONParseError, MacroError, MichelineParseError, MichelsonError, MichelsonInstructionError, MichelsonTypeError, MichelsonValidationError, Parser, Protocol, VERSION, assertContractValid, assertDataListIfAny, assertDataValid, assertMichelsonBigMapStorableType, assertMichelsonComparableType, assertMichelsonContract, assertMichelsonData, assertMichelsonInstruction, assertMichelsonPackableType, assertMichelsonPassableType, assertMichelsonPushableType, assertMichelsonStorableType, assertMichelsonType, assertTypeAnnotationsValid, assertTypesEqual, contractEntryPoint, contractEntryPoints, contractSection, decodeAddressBytes, decodePublicKeyBytes, decodePublicKeyHashBytes, dummyContract, emitMicheline, formatError, formatStack, functionType, instructionIDs, isContractValid, isDataValid, isInstruction, isMichelsonCode, isMichelsonData, isMichelsonError, isMichelsonScript, isMichelsonType, isTypeAnnotationsValid, isTypeEqual, packData, packDataBytes, refContract, sourceReference, traceDumpFunc, unpackData, unpackDataBytes };
+export { Contract, DefaultProtocol, JSONParseError, MacroError, MichelineParseError, MichelsonError, MichelsonInstructionError, MichelsonTypeError, MichelsonValidationError, Parser, ProtoGreaterOfEqual, Protocol, VERSION, assertContractValid, assertDataListIfAny, assertDataValid, assertMichelsonBigMapStorableType, assertMichelsonComparableType, assertMichelsonContract, assertMichelsonData, assertMichelsonInstruction, assertMichelsonPackableType, assertMichelsonPassableType, assertMichelsonPushableType, assertMichelsonStorableType, assertMichelsonType, assertTypeAnnotationsValid, assertTypesEqual, assertViewNameValid, contractEntryPoint, contractEntryPoints, contractSection, contractViews, decodeAddressBytes, decodePublicKeyBytes, decodePublicKeyHashBytes, dummyContract, emitMicheline, formatError, formatStack, functionType, instructionIDs, isContractValid, isDataValid, isInstruction, isMichelsonCode, isMichelsonData, isMichelsonError, isMichelsonScript, isMichelsonType, isTypeAnnotationsValid, isTypeEqual, packData, packDataBytes, refContract, sourceReference, traceDumpFunc, unpackData, unpackDataBytes };
 //# sourceMappingURL=taquito-michel-codec.es5.js.map