@taquito/michel-codec 12.0.2 → 12.1.0

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

@@ -7,6 +7,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);
@@ -148,6 +152,7 @@
       Protocol["PtHangz2"] = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx";
       Protocol["PsiThaCa"] = "PsiThaCaT47Zboaw71QWScM8sXeMM7bbQFncK9FLqYc6EKdpjVP";
       Protocol["Psithaca2"] = "Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A";
+      Protocol["PtJakarta"] = "PtJakartaiDz69SfDDLXJSiuZqTSeSKRDbKVZC8MNzJnvRjvnGw";
       Protocol["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
   })(exports.Protocol || (exports.Protocol = {}));
   const DefaultProtocol = exports.Protocol.Psithaca2;
@@ -168,8 +173,9 @@
       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];
@@ -178,6 +184,10 @@
       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);
@@ -725,6 +735,10 @@
       return ex;
   }
 
+  /**
+   *  @category Error
+   *  @description Error indicating a failure when parsing Micheline expressions
+   */
   class MichelineParseError extends Error {
       /**
        * @param token A token caused the error
@@ -736,6 +750,10 @@
           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
@@ -1313,13 +1331,35 @@
       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 = [
@@ -1398,7 +1438,7 @@
   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];
   }
@@ -1455,7 +1495,7 @@
   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);
@@ -1464,7 +1504,7 @@
           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;
   }
@@ -1473,6 +1513,88 @@
       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
@@ -1518,7 +1640,7 @@
                   }
                   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);
                   }
@@ -1681,7 +1803,7 @@
   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]);
   }
@@ -1739,7 +1861,7 @@
           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);
       }
@@ -5146,18 +5268,37 @@
                   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, exports.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']);
@@ -5367,7 +5508,7 @@
           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);
@@ -5377,7 +5518,7 @@
           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;
@@ -5388,7 +5529,7 @@
           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;
@@ -5413,7 +5554,7 @@
       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);
       }
@@ -5493,8 +5634,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"
   };
 
   exports.Contract = Contract;