@taquito/michel-codec 12.0.2 → 12.1.0

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

@@ -1,6 +1,10 @@
 // Michelson abstract syntax tree types https://tezos.gitlab.io/whitedoc/michelson.html#concrete-syntax
 const sourceReference = Symbol('source_reference');
 
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when performing the scan step when parsing Michelson
+ */
 class ScanError extends Error {
     constructor(src, idx, message) {
         super(message);
@@ -142,6 +146,7 @@ var Protocol;
     Protocol["PtHangz2"] = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx";
     Protocol["PsiThaCa"] = "PsiThaCaT47Zboaw71QWScM8sXeMM7bbQFncK9FLqYc6EKdpjVP";
     Protocol["Psithaca2"] = "Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A";
+    Protocol["PtJakarta"] = "PtJakartaiDz69SfDDLXJSiuZqTSeSKRDbKVZC8MNzJnvRjvnGw";
     Protocol["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
 })(Protocol || (Protocol = {}));
 const DefaultProtocol = Protocol.Psithaca2;
@@ -162,8 +167,9 @@ const protoLevel = {
     PtHangzHogokSuiMHemCuowEavgYTP8J5qQ9fQS793MHYFpCY3r: 11,
     PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx: 11,
     PsiThaCaT47Zboaw71QWScM8sXeMM7bbQFncK9FLqYc6EKdpjVP: 12,
-    Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A: 13,
-    ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK: 14,
+    Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A: 12,
+    PtJakartaiDz69SfDDLXJSiuZqTSeSKRDbKVZC8MNzJnvRjvnGw: 13,
+    ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK: 13,
 };
 function ProtoGreaterOfEqual(a, b) {
     return protoLevel[a] >= protoLevel[b];
@@ -172,6 +178,10 @@ function ProtoInferiorTo(a, b) {
     return protoLevel[a] < protoLevel[b];
 }
 
+/**
+ *  @category Error
+ *  @description Indicates that an error has occurred preventing macros from being expanded in a plain Michelson input
+ */
 class MacroError extends Error {
     constructor(prim, message) {
         super(message);
@@ -719,6 +729,10 @@ function expandGlobalConstants(ex, hashAndValue) {
     return ex;
 }
 
+/**
+ *  @category Error
+ *  @description Error indicating a failure when parsing Micheline expressions
+ */
 class MichelineParseError extends Error {
     /**
      * @param token A token caused the error
@@ -730,6 +744,10 @@ class MichelineParseError extends Error {
         Object.setPrototypeOf(this, MichelineParseError.prototype);
     }
 }
+/**
+ *  @category Error
+ *  @description Error that inidicates a failure when parsing Micheline JSON
+ */
 class JSONParseError extends Error {
     /**
      * @param node A node caused the error
@@ -1307,13 +1325,35 @@ const K = [
     0xbef9a3f7 | 0,
     0xc67178f2 | 0,
 ];
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when decoding a base58 encoding
+ */
+class Base58DecodingError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'Base58DecodingError';
+    }
+}
+/**
+ *  @category Error
+ *  @description
+ */
+class InvalidMessageError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'InvalidMessageError';
+    }
+}
 // https://tools.ietf.org/html/rfc6234
 function sha256(msg) {
     // pad the message
     const r = (msg.length + 9) % 64;
     const pad = r === 0 ? 0 : 64 - r;
     if (msg.length > 268435455) {
-        throw new Error(`sha256: message length is too big: ${msg.length}`);
+        throw new InvalidMessageError(`SHA-256 -- message length is too big: ${msg.length}`);
     }
     const l = msg.length << 3;
     const buffer = [
@@ -1392,7 +1432,7 @@ const base58alphabetBwd = [
 function byteAt(src, i) {
     const c = src.charCodeAt(i) - 49;
     if (c >= base58alphabetFwd.length || base58alphabetFwd[c] === -1) {
-        throw new Error(`Base58 decoding error: unexpected character at position ${i}: ${src[i]}`);
+        throw new Base58DecodingError(`Unexpected character at position ${i}: ${src[i]}`);
     }
     return base58alphabetFwd[c];
 }
@@ -1449,7 +1489,7 @@ function encodeBase58(src) {
 function decodeBase58Check(src) {
     const buffer = decodeBase58(src);
     if (buffer.length < 4) {
-        throw new Error(`Base58Check decoding error: data is too short ${buffer.length}`);
+        throw new Base58DecodingError(`Data is too short ${buffer.length}`);
     }
     const data = buffer.slice(0, buffer.length - 4);
     const sum = buffer.slice(buffer.length - 4);
@@ -1458,7 +1498,7 @@ function decodeBase58Check(src) {
         sum[1] !== computed[1] ||
         sum[2] !== computed[2] ||
         sum[3] !== computed[3]) {
-        throw new Error('Base58Check decoding error: invalid checksum');
+        throw new Base58DecodingError('Invalid checksum');
     }
     return data;
 }
@@ -1467,6 +1507,88 @@ function encodeBase58Check(src) {
     return encodeBase58([...src, ...sum.slice(0, 4)]);
 }
 
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid contract being passed or used
+ */
+class InvalidContractError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'InvalidContractError';
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid type expression being passed or used
+ */
+class InvalidTypeExpressionError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'InvalidTypeExpressionError';
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid data expression being passed or used
+ */
+class InvalidDataExpressionError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'InvalidDataExpressionError';
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid contract entrypoint being referenced or passed
+ */
+class InvalidEntrypointError extends Error {
+    constructor(entrypoint) {
+        super(`Contract has no entrypoint named: '${entrypoint}'`);
+        this.entrypoint = entrypoint;
+        this.name = 'InvalidEntrypointError';
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a failure happening when trying to encode Tezos ID
+ */
+class TezosIdEncodeError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'TezosIdEncodeError';
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a general error happening when trying to create a LongInteger
+ */
+class LongIntegerError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'LongIntegerError';
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a failure occurring when trying to parse a hex byte
+ */
+class HexParseError extends Error {
+    constructor(hexByte) {
+        super(`Unable to parse hex byte: ${hexByte}`);
+        this.hexByte = hexByte;
+        this.name = 'HexParseError';
+    }
+}
+
+/**
+ *  @category Error
+ *  @description Error that indicates a Michelson failure occurring
+ */
 class MichelsonError extends Error {
     /**
      * @param val Value of a AST node caused the error
@@ -1512,7 +1634,7 @@ class LongInteger {
                 }
                 else {
                     if (c < 0x30 || c > 0x39) {
-                        throw new Error(`unexpected character in integer constant: ${arg[i]}`);
+                        throw new LongIntegerError(`unexpected character in integer constant: ${arg[i]}`);
                     }
                     this.append(c - 0x30);
                 }
@@ -1675,7 +1797,7 @@ function checkDecodeTezosID(id, ...types) {
 function encodeTezosID(id, data) {
     const [plen, p] = tezosPrefix[id];
     if (data.length !== plen) {
-        throw new Error(`incorrect data length for ${id}: ${data.length}`);
+        throw new TezosIdEncodeError(`Incorrect data length for ${id}: ${data.length}`);
     }
     return encodeBase58Check([...p, ...data]);
 }
@@ -1733,7 +1855,7 @@ function parseHex(s) {
         const ss = s.slice(i, i + 2);
         const x = parseInt(ss, 16);
         if (Number.isNaN(x)) {
-            throw new Error(`can't parse hex byte: ${ss}`);
+            throw new HexParseError(ss);
         }
         res.push(x);
     }
@@ -5140,18 +5262,37 @@ function functionTypeInternal(inst, stack, ctx) {
                 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 [
-                    annotateVar({
-                        prim: 'option',
-                        args: [
-                            {
-                                prim: 'pair',
-                                args: [{ prim: 'int' }, annotate(s[1], { t: null })],
-                            },
-                        ],
-                    }),
-                    ...stack.slice(2),
-                ];
+                return ProtoInferiorTo(proto, Protocol.PtJakarta)
+                    ? [
+                        annotateVar({
+                            prim: 'option',
+                            args: [
+                                {
+                                    prim: 'pair',
+                                    args: [{ prim: 'int' }, annotate(s[1], { t: null })],
+                                },
+                            ],
+                        }),
+                        ...stack.slice(2),
+                    ]
+                    : [
+                        annotateVar({
+                            prim: 'option',
+                            args: [
+                                {
+                                    prim: 'pair',
+                                    args: [
+                                        { prim: 'bytes' },
+                                        {
+                                            prim: 'pair',
+                                            args: [{ prim: 'int' }, annotate(s[1], { t: null })],
+                                        },
+                                    ],
+                                },
+                            ],
+                        }),
+                        ...stack.slice(2),
+                    ];
             }
             case 'OPEN_CHEST':
                 args(0, ['chest_key'], ['chest'], ['nat']);
@@ -5361,7 +5502,7 @@ class Contract {
         const p = new Parser(opt);
         const expr = typeof src === 'string' ? p.parseScript(src) : p.parseJSON(src);
         if (expr === null) {
-            throw new Error('empty contract');
+            throw new InvalidContractError('empty contract');
         }
         if (assertMichelsonContract(expr)) {
             return new Contract(expr, opt);
@@ -5371,7 +5512,7 @@ class Contract {
         const p = new Parser(opt);
         const expr = typeof src === 'string' ? p.parseScript(src) : p.parseJSON(src);
         if (expr === null) {
-            throw new Error('empty type expression');
+            throw new InvalidTypeExpressionError('empty type expression');
         }
         if (assertMichelsonType(expr) && assertTypeAnnotationsValid(expr)) {
             return expr;
@@ -5382,7 +5523,7 @@ class Contract {
         const p = new Parser(opt);
         const expr = typeof src === 'string' ? p.parseScript(src) : p.parseJSON(src);
         if (expr === null) {
-            throw new Error('empty data expression');
+            throw new InvalidDataExpressionError('empty data expression');
         }
         if (assertMichelsonData(expr)) {
             return expr;
@@ -5407,7 +5548,7 @@ class Contract {
     assertParameterValid(ep, d) {
         const t = this.entryPoint(ep || undefined);
         if (t === null) {
-            throw new Error(`contract has no entrypoint named ${ep}`);
+            throw new InvalidEntrypointError(ep === null || ep === void 0 ? void 0 : ep.toString());
         }
         this.assertDataValid(d, t);
     }
@@ -5487,8 +5628,8 @@ ${err.data
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "5996bf6b665e26de3201cf45884b4a2bb9218e09",
-    "version": "12.0.2"
+    "commitHash": "cbdd0af87e400489076259d065e2d328feb8e1b4",
+    "version": "12.1.0"
 };
 
 export { Contract, DefaultProtocol, JSONParseError, MacroError, MichelineParseError, MichelsonError, MichelsonInstructionError, MichelsonTypeError, MichelsonValidationError, Parser, ProtoGreaterOfEqual, ProtoInferiorTo, 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 };