@taquito/local-forging 12.0.2 → 12.1.0

package/dist/taquito-local-forging.umd.js

@@ -50,6 +50,7 @@
       CODEC["OP_REGISTER_GLOBAL_CONSTANT"] = "register_global_constant";
       CODEC["VALUE"] = "value";
       CODEC["MANAGER"] = "manager";
+      CODEC["BLOCK_PAYLOAD_HASH"] = "blockPayloadHash";
   })(exports.CODEC || (exports.CODEC = {}));
   // See https://tezos.gitlab.io/whitedoc/michelson.html#full-grammar
   const opMapping = {
@@ -244,21 +245,117 @@
           result[entrypointMapping[key]] = key;
       });
       return result;
-  })();
-  exports.ProtocolsHash = void 0;
-  (function (ProtocolsHash) {
-      ProtocolsHash["Pt24m4xi"] = "Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd";
-      ProtocolsHash["PsBABY5H"] = "PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU";
-      ProtocolsHash["PsBabyM1"] = "PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS";
-      ProtocolsHash["PsCARTHA"] = "PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb";
-      ProtocolsHash["PsDELPH1"] = "PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo";
-      ProtocolsHash["PtEdo2Zk"] = "PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA";
-      ProtocolsHash["PsFLorena"] = "PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i";
-      ProtocolsHash["PtGRANADs"] = "PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV";
-      ProtocolsHash["PtHangz2"] = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx";
-      ProtocolsHash["PsiThaCa"] = "PsiThaCaT47Zboaw71QWScM8sXeMM7bbQFncK9FLqYc6EKdpjVP";
-      ProtocolsHash["Psithaca2"] = "Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A";
-  })(exports.ProtocolsHash || (exports.ProtocolsHash = {}));
+  })();
+
+  /**
+   *  @category Error
+   *  @description Error that indicates an invalid block hash being passed or used
+   */
+  class InvalidBlockHashError extends Error {
+      constructor(message) {
+          super(message);
+          this.message = message;
+          this.name = 'InvalidBlockHashError';
+      }
+  }
+  /**
+   *  @category Error
+   *  @description Error that indicates an invalid operation schema being passed or used
+   */ class InvalidOperationSchemaError extends Error {
+      constructor(message) {
+          super(message);
+          this.message = message;
+          this.name = 'InvalidOperationSchemaError';
+      }
+  }
+  /**
+   *  @category Error
+   *  @description Error that indicates an entrypoint exceeding maximum size
+   */
+  class OversizedEntryPointError extends Error {
+      constructor(entrypoint) {
+          super(`Oversized entrypoint: ${entrypoint}. The maximum length of entrypoint is ${ENTRYPOINT_MAX_LENGTH}`);
+          this.entrypoint = entrypoint;
+          this.name = 'OversizedEntryPointError';
+      }
+  }
+  /**
+   *  @category Error
+   *  @description Error that indicates an invalid ballot value
+   */
+  class InvalidBallotValueError extends Error {
+      constructor(ballotValue) {
+          super(`The ballot value '${ballotValue}' is invalid`);
+          this.ballotValue = ballotValue;
+          this.name = 'InvalidBallotValueError';
+      }
+  }
+  /**
+   *  @category Error
+   *  @description Error that indicates a failure when trying to decode ballot value
+   */
+  class DecodeBallotValueError extends Error {
+      constructor(ballotValue) {
+          super(`Failed to decode ballot value ${ballotValue}`);
+          this.ballotValue = ballotValue;
+          this.name = 'DecodeBallotValueError';
+      }
+  }
+  /**
+   *  @category Error
+   *  @description Error that indicates an invalid hex string have been passed or used
+   */
+  class InvalidHexStringError extends Error {
+      constructor(hexString) {
+          super(`The hex string '${hexString}' is invalid`);
+          this.hexString = hexString;
+          this.name = 'InvalidHexStringError';
+      }
+  }
+  /**
+   *  @category Error
+   *  @description Error that indicates unexpected Michelson Value being passed or used
+   */
+  class UnexpectedMichelsonValueError extends Error {
+      constructor(value) {
+          super(`Failed to encode michelson value '${value}'`);
+          this.value = value;
+          this.name = 'UnexpectedMichelsonValueError';
+      }
+  }
+  /**
+   *  @category Error
+   *  @description Error that indicates a failure when trying to decode an operation
+   */
+  class OperationDecodingError extends Error {
+      constructor(message) {
+          super(message);
+          this.message = message;
+          this.name = 'OperationDecodingError';
+      }
+  }
+  /**
+   *  @category Error
+   *  @description Error that indicates a failure when trying to encode an operation
+   */
+  class OperationEncodingError extends Error {
+      constructor(message) {
+          super(message);
+          this.message = message;
+          this.name = 'OperationEncodingError';
+      }
+  }
+  /**
+   *  @category Error
+   *  @description Error that indicates an unsupported operation being passed or used
+   */
+  class UnsupportedOperationError extends Error {
+      constructor(op) {
+          super(`The operation '${op}' is unsupported`);
+          this.op = op;
+          this.name = 'UnsupportedOperationError';
+      }
+  }
 
   class Uint8ArrayConsumer {
       constructor(arr, offset = 0) {
@@ -268,11 +365,11 @@
       static fromHexString(hex) {
           const lowHex = hex.toLowerCase();
           if (/^(([a-f]|\d){2})*$/.test(lowHex)) {
-              const arr = new Uint8Array((lowHex.match(/([a-z]|\d){2}/g) || []).map(byte => parseInt(byte, 16)));
+              const arr = new Uint8Array((lowHex.match(/([a-z]|\d){2}/g) || []).map((byte) => parseInt(byte, 16)));
               return new Uint8ArrayConsumer(arr);
           }
           else {
-              throw new Error('Invalid hex string');
+              throw new InvalidHexStringError(lowHex);
           }
       }
       consume(count) {
@@ -331,7 +428,7 @@
       else if (isInt(value)) {
           return intEncoder(value);
       }
-      throw new Error('Unexpected value');
+      throw new UnexpectedMichelsonValueError(value);
   };
   const valueDecoder = (value) => {
       const preamble = value.consume(1);
@@ -361,7 +458,7 @@
   };
   const bytesEncoder = (value) => {
       if (!/^([A-Fa-f0-9]{2})*$/.test(value.bytes)) {
-          throw new Error(`Invalid hex string: ${value.bytes}`);
+          throw new InvalidHexStringError(value.bytes);
       }
       const len = value.bytes.length / 2;
       return `0a${pad(len)}${value.bytes}`;
@@ -471,7 +568,7 @@
       let combPairArgs;
       let combPairAnnots;
       if ((opMapping[op] === 'pair' || opMapping[op] === 'Pair') && argsCount > 2) {
-          combPairArgs = decodeCombPair(value);
+          combPairArgs = decodeCombPair$1(value);
           argsCount = 0;
           combPairAnnots = decodeAnnots(value);
       }
@@ -499,7 +596,7 @@
       value.consume(4);
       return result;
   };
-  const decodeCombPair = (val) => {
+  const decodeCombPair$1 = (val) => {
       const array = new Uint8ArrayConsumer(extractRequiredLen(val));
       const args = [];
       while (array.length() > 0) {
@@ -574,7 +671,7 @@
           case 'pass':
               return '02';
           default:
-              throw new Error(`Invalid ballot value: ${ballot}`);
+              throw new InvalidBallotValueError(ballot);
       }
   };
   const ballotDecoder = (ballot) => {
@@ -587,7 +684,7 @@
           case 0x02:
               return 'pass';
           default:
-              throw new Error(`Unable to decode ballot value ${value[0]}`);
+              throw new DecodeBallotValueError(value[0].toString());
       }
   };
   const delegateEncoder = (val) => {
@@ -652,7 +749,7 @@
           case utils.Prefix.TZ3:
               return '02' + prefixEncoder(utils.Prefix.TZ3)(val);
           default:
-              throw new Error('Invalid public key hash');
+              throw new utils.InvalidKeyHashError(val);
       }
   };
   const publicKeyEncoder = (val) => {
@@ -665,7 +762,7 @@
           case utils.Prefix.P2PK:
               return '02' + prefixEncoder(utils.Prefix.P2PK)(val);
           default:
-              throw new Error('Invalid PK');
+              throw new utils.InvalidPublicKeyError(val);
       }
   };
   const addressEncoder = (val) => {
@@ -678,7 +775,7 @@
           case utils.Prefix.KT1:
               return '01' + prefixEncoder(utils.Prefix.KT1)(val) + '00';
           default:
-              throw new Error('Invalid address');
+              throw new utils.InvalidAddressError(val);
       }
   };
   const publicKeyDecoder = (val) => {
@@ -691,7 +788,7 @@
           case 0x02:
               return prefixDecoder(utils.Prefix.P2PK)(val);
           default:
-              throw new Error('Invalid PK');
+              throw new utils.InvalidPublicKeyError(val.toString());
       }
   };
   const addressDecoder = (val) => {
@@ -705,7 +802,7 @@
               return address;
           }
           default:
-              throw new Error('Invalid Address');
+              throw new utils.InvalidAddressError(val.toString());
       }
   };
   const zarithEncoder = (n) => {
@@ -755,7 +852,7 @@
           const entry = extractRequiredLen(value, 1);
           const entrypoint = Buffer.from(entry).toString('utf8');
           if (entrypoint.length > ENTRYPOINT_MAX_LENGTH) {
-              throw new Error(`Oversized entrypoint: ${entrypoint}. The maximum length of entrypoint is ${ENTRYPOINT_MAX_LENGTH}`);
+              throw new OversizedEntryPointError(entrypoint);
           }
           return entrypoint;
       }
@@ -781,7 +878,7 @@
       }
       else {
           if (entrypoint.length > ENTRYPOINT_MAX_LENGTH) {
-              throw new Error(`Oversized entrypoint: ${entrypoint}. The maximum length of entrypoint is ${ENTRYPOINT_MAX_LENGTH}`);
+              throw new OversizedEntryPointError(entrypoint);
           }
           const value = { string: entrypoint };
           return `ff${valueEncoder(value).slice(8)}`;
@@ -877,23 +974,21 @@
   };
   const operationEncoder = (encoders) => (operation) => {
       if (!(operation.kind in encoders) || !(operation.kind in kindMappingReverse)) {
-          throw new Error(`Unsupported operation kind: ${operation.kind}`);
+          throw new utils.InvalidOperationKindError(operation.kind);
       }
       return kindMappingReverse[operation.kind] + encoders[operation.kind](operation);
   };
   const operationDecoder = (decoders) => (value) => {
       const op = value.consume(1);
       const operationName = kindMapping[op[0]];
+      if (operationName === undefined) {
+          throw new UnsupportedOperationError(op[0].toString());
+      }
       const decodedObj = decoders[operationName](value);
       if (typeof decodedObj !== 'object') {
-          throw new Error('Decoded invalid operation');
-      }
-      if (operationName) {
-          return Object.assign({ kind: operationName }, decodedObj);
-      }
-      else {
-          throw new Error(`Unsupported operation ${op[0]}`);
+          throw new OperationDecodingError('Decoded invalid operation');
       }
+      return Object.assign({ kind: operationName }, decodedObj);
   };
   const schemaEncoder = (encoders) => (schema) => (value) => {
       const keys = Object.keys(schema);
@@ -903,7 +998,7 @@
               const encoder = encoders[valueToEncode[0]];
               const values = value[key];
               if (!Array.isArray(values)) {
-                  throw new Error(`Exepected value to be Array ${JSON.stringify(values)}`);
+                  throw new OperationEncodingError(`Expected value to be Array ${JSON.stringify(values)}`);
               }
               return prev + values.reduce((prevBytes, current) => prevBytes + encoder(current), '');
           }
@@ -924,7 +1019,7 @@
               while (value.length() > 0) {
                   decoded.push(decoder(value));
                   if (lastLength === value.length()) {
-                      throw new Error('Unable to decode value');
+                      throw new OperationDecodingError('Unable to decode value');
                   }
               }
               return Object.assign(Object.assign({}, prev), { [key]: decoded });
@@ -1053,26 +1148,24 @@
   };
   const operationEncoderProto12 = (encoders) => (operation) => {
       if (!(operation.kind in encoders) || !(operation.kind in kindMappingReverseProto12)) {
-          throw new Error(`Unsupported operation kind: ${operation.kind}`);
+          throw new utils.InvalidOperationKindError(operation.kind);
       }
       return kindMappingReverseProto12[operation.kind] + encoders[operation.kind](operation);
   };
   const operationDecoderProto12 = (decoders) => (value) => {
       const op = value.consume(1);
       const operationName = kindMappingProto12[op[0]];
+      if (operationName === undefined) {
+          throw new UnsupportedOperationError(op[0].toString());
+      }
       const decodedObj = decoders[operationName](value);
       if (typeof decodedObj !== 'object') {
-          throw new Error('Decoded invalid operation');
-      }
-      if (operationName) {
-          return Object.assign({ kind: operationName }, decodedObj);
-      }
-      else {
-          throw new Error(`Unsupported operation ${op[0]}`);
+          throw new OperationDecodingError('Decoded invalid operation');
       }
+      return Object.assign({ kind: operationName }, decodedObj);
   };
 
-  const decodersProto12 = Object.assign(Object.assign({}, decoders), { [exports.CODEC.INT16]: int16Decoder, ["blockPayloadHash" /* BLOCK_PAYLOAD_HASH */]: blockPayloadHashDecoder });
+  const decodersProto12 = Object.assign(Object.assign({}, decoders), { [exports.CODEC.INT16]: int16Decoder, [exports.CODEC.BLOCK_PAYLOAD_HASH]: blockPayloadHashDecoder });
   decodersProto12[exports.CODEC.OPERATION] = operationDecoderProto12(decodersProto12);
   decodersProto12[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decodersProto12)(ActivationSchema)(val);
   decodersProto12[exports.CODEC.OP_DELEGATION] = (val) => schemaDecoder(decodersProto12)(DelegationSchema)(val);
@@ -1086,7 +1179,7 @@
   decodersProto12[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decodersProto12)(RegisterGlobalConstantSchema)(val);
   decodersProto12[exports.CODEC.MANAGER] = schemaDecoder(decodersProto12)(ManagerOperationSchema);
 
-  const encodersProto12 = Object.assign(Object.assign({}, encoders), { [exports.CODEC.INT16]: int16Encoder, ["blockPayloadHash" /* BLOCK_PAYLOAD_HASH */]: blockPayloadHashEncoder });
+  const encodersProto12 = Object.assign(Object.assign({}, encoders), { [exports.CODEC.INT16]: int16Encoder, [exports.CODEC.BLOCK_PAYLOAD_HASH]: blockPayloadHashEncoder });
   encodersProto12[exports.CODEC.OPERATION] = operationEncoderProto12(encodersProto12);
   encodersProto12[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encodersProto12)(ActivationSchema)(val);
   encodersProto12[exports.CODEC.OP_DELEGATION] = (val) => schemaEncoder(encodersProto12)(DelegationSchema)(val);
@@ -1100,28 +1193,6 @@
   encodersProto12[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encodersProto12)(RegisterGlobalConstantSchema)(val);
   encodersProto12[exports.CODEC.MANAGER] = schemaEncoder(encodersProto12)(ManagerOperationSchema);
 
-  class InvalidBlockHashError extends Error {
-      constructor(message) {
-          super(message);
-          this.message = message;
-          this.name = 'InvalidBlockHashError';
-      }
-  }
-  class InvalidOperationSchemaError extends Error {
-      constructor(message) {
-          super(message);
-          this.message = message;
-          this.name = 'InvalidOperationSchemaError';
-      }
-  }
-  class InvalidOperationKindError extends Error {
-      constructor(message) {
-          super(message);
-          this.message = message;
-          this.name = 'InvalidOperationKindError';
-      }
-  }
-
   const OperationKindMapping = {
       activate_account: ActivationSchema,
       reveal: RevealSchema,
@@ -1162,16 +1233,264 @@
       return getArrayDifference(cleanKeys, schemaKeys);
   };
 
+  exports.ProtocolsHash = void 0;
+  (function (ProtocolsHash) {
+      ProtocolsHash["Pt24m4xi"] = "Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd";
+      ProtocolsHash["PsBABY5H"] = "PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU";
+      ProtocolsHash["PsBabyM1"] = "PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS";
+      ProtocolsHash["PsCARTHA"] = "PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb";
+      ProtocolsHash["PsDELPH1"] = "PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo";
+      ProtocolsHash["PtEdo2Zk"] = "PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA";
+      ProtocolsHash["PsFLorena"] = "PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i";
+      ProtocolsHash["PtGRANADs"] = "PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV";
+      ProtocolsHash["PtHangz2"] = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx";
+      ProtocolsHash["Psithaca2"] = "Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A";
+      ProtocolsHash["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
+  })(exports.ProtocolsHash || (exports.ProtocolsHash = {}));
+  const protoLevel = {
+      Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd: 4,
+      PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU: 5,
+      PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS: 5,
+      PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb: 6,
+      PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo: 7,
+      PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA: 8,
+      PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i: 9,
+      PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV: 10,
+      PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx: 11,
+      Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A: 12,
+      ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK: 13,
+  };
+  function ProtoInferiorTo(a, b) {
+      return protoLevel[a] < protoLevel[b];
+  }
+
+  const opMappingProto13 = Object.assign(Object.assign({}, opMapping), { '84': 'sapling_transaction_deprecated', '94': 'tx_rollup_l2_address', '95': 'MIN_BLOCK_TIME', '96': 'sapling_transaction' });
+  const opMappingReverseProto13 = (() => {
+      const result = {};
+      Object.keys(opMappingProto13).forEach((key) => {
+          result[opMappingProto13[key]] = key;
+      });
+      return result;
+  })();
+
+  const scriptEncoderProto13 = (script) => {
+      const code = valueEncoderProto13(script.code);
+      const storage = valueEncoderProto13(script.storage);
+      return `${pad(code.length / 2, 8)}${code}${pad(storage.length / 2, 8)}${storage}`;
+  };
+  const scriptDecoderProto13 = (value) => {
+      const code = extractRequiredLen(value);
+      const storage = extractRequiredLen(value);
+      return {
+          code: valueDecoderProto13(new Uint8ArrayConsumer(code)),
+          storage: valueDecoderProto13(new Uint8ArrayConsumer(storage)),
+      };
+  };
+  const valueEncoderProto13 = (value) => {
+      if (Array.isArray(value)) {
+          const encoded = value.map((x) => valueEncoderProto13(x)).join('');
+          const len = encoded.length / 2;
+          return `02${pad(len)}${encoded}`;
+      }
+      else if (isPrim(value)) {
+          return primEncoderProto13(value);
+      }
+      else if (isBytes(value)) {
+          return bytesEncoder(value);
+      }
+      else if (isString(value)) {
+          return stringEncoder(value);
+      }
+      else if (isInt(value)) {
+          return intEncoder(value);
+      }
+      throw new UnexpectedMichelsonValueError('Unexpected value');
+  };
+  const valueDecoderProto13 = (value) => {
+      const preamble = value.consume(1);
+      switch (preamble[0]) {
+          case 0x0a:
+              return bytesDecoder(value);
+          case 0x01:
+              return stringDecoder(value);
+          case 0x00:
+              return intDecoder(value);
+          case 0x02: {
+              const val = new Uint8ArrayConsumer(extractRequiredLen(value));
+              const results = [];
+              while (val.length() > 0) {
+                  results.push(valueDecoderProto13(val));
+              }
+              return results;
+          }
+          default:
+              return primDecoderProto13(value, preamble);
+      }
+  };
+  const primEncoderProto13 = (value) => {
+      const hasAnnot = +Array.isArray(value.annots);
+      const argsCount = Array.isArray(value.args) ? value.args.length : 0;
+      // Specify the number of args max is 3 without annotation
+      const preamble = pad(Math.min(2 * argsCount + hasAnnot + 0x03, 9), 2);
+      const op = opMappingReverseProto13[value.prim];
+      let encodedArgs = (value.args || []).map((arg) => valueEncoderProto13(arg)).join('');
+      const encodedAnnots = Array.isArray(value.annots) ? encodeAnnots(value.annots) : '';
+      if (value.prim === 'LAMBDA' && argsCount) {
+          encodedArgs = pad(encodedArgs.length / 2) + encodedArgs + pad(0);
+      }
+      if ((value.prim === 'pair' || value.prim === 'Pair') && argsCount > 2) {
+          encodedArgs =
+              encodedAnnots === ''
+                  ? pad(encodedArgs.length / 2) + encodedArgs + pad(0)
+                  : pad(encodedArgs.length / 2) + encodedArgs;
+      }
+      if (value.prim === 'view' && value.args) {
+          encodedArgs = pad(encodedArgs.length / 2) + encodedArgs + pad(0);
+      }
+      return `${preamble}${op}${encodedArgs}${encodedAnnots}`;
+  };
+  const primDecoderProto13 = (value, preamble) => {
+      const hasAnnot = (preamble[0] - 0x03) % 2 === 1;
+      let argsCount = Math.floor((preamble[0] - 0x03) / 2);
+      const op = value.consume(1)[0].toString(16).padStart(2, '0');
+      const result = {
+          prim: opMappingProto13[op],
+      };
+      if (opMappingProto13[op] === 'LAMBDA') {
+          value.consume(4);
+      }
+      if (opMappingProto13[op] === 'view') {
+          if (argsCount != 0) {
+              return primViewDecoderProto13(value, result);
+          }
+          else {
+              return result;
+          }
+      }
+      let combPairArgs;
+      let combPairAnnots;
+      if ((opMappingProto13[op] === 'pair' || opMappingProto13[op] === 'Pair') && argsCount > 2) {
+          combPairArgs = decodeCombPair(value);
+          argsCount = 0;
+          combPairAnnots = decodeAnnots(value);
+      }
+      const args = new Array(argsCount).fill(0).map(() => valueDecoderProto13(value));
+      if (opMappingProto13[op] === 'LAMBDA') {
+          value.consume(4);
+      }
+      if (combPairArgs) {
+          result['args'] = combPairArgs;
+      }
+      else if (args.length) {
+          result['args'] = args;
+      }
+      if (combPairAnnots && combPairAnnots[0] !== '') {
+          result['annots'] = combPairAnnots;
+      }
+      else if (hasAnnot) {
+          result['annots'] = decodeAnnots(value);
+      }
+      return result;
+  };
+  const primViewDecoderProto13 = (value, result) => {
+      value.consume(4);
+      result['args'] = new Array(4).fill(0).map(() => valueDecoderProto13(value));
+      value.consume(4);
+      return result;
+  };
+  const decodeCombPair = (val) => {
+      const array = new Uint8ArrayConsumer(extractRequiredLen(val));
+      const args = [];
+      while (array.length() > 0) {
+          args.push(valueDecoderProto13(array));
+      }
+      return args;
+  };
+
+  const parametersDecoderProto13 = (val) => {
+      const preamble = val.consume(1);
+      if (preamble[0] === 0x00) {
+          return;
+      }
+      else {
+          const encodedEntrypoint = entrypointDecoder(val);
+          const params = extractRequiredLen(val);
+          const parameters = valueDecoderProto13(new Uint8ArrayConsumer(params));
+          return {
+              entrypoint: encodedEntrypoint,
+              value: parameters,
+          };
+      }
+  };
+  const valueParameterDecoderProto13 = (val) => {
+      const value = extractRequiredLen(val);
+      return valueDecoderProto13(new Uint8ArrayConsumer(value));
+  };
+  const entrypointEncoderProto13 = (entrypoint) => {
+      if (entrypoint in entrypointMappingReverse) {
+          return `${entrypointMappingReverse[entrypoint]}`;
+      }
+      else {
+          if (entrypoint.length > ENTRYPOINT_MAX_LENGTH) {
+              throw new OversizedEntryPointError(entrypoint);
+          }
+          const value = { string: entrypoint };
+          return `ff${valueEncoderProto13(value).slice(8)}`;
+      }
+  };
+  const parametersEncoderProto13 = (val) => {
+      if (!val || (val.entrypoint === 'default' && 'prim' in val.value && val.value.prim === 'Unit')) {
+          return '00';
+      }
+      const encodedEntrypoint = entrypointEncoderProto13(val.entrypoint);
+      const parameters = valueEncoderProto13(val.value);
+      const length = (parameters.length / 2).toString(16).padStart(8, '0');
+      return `ff${encodedEntrypoint}${length}${parameters}`;
+  };
+  const valueParameterEncoderProto13 = (value) => {
+      const valueEncoded = valueEncoderProto13(value);
+      return `${pad(valueEncoded.length / 2)}${valueEncoded}`;
+  };
+
+  const encodersProto13 = Object.assign(Object.assign({}, encodersProto12), { [exports.CODEC.SCRIPT]: scriptEncoderProto13, [exports.CODEC.PARAMETERS]: parametersEncoderProto13, [exports.CODEC.VALUE]: valueParameterEncoderProto13 });
+  encodersProto13[exports.CODEC.OPERATION] = operationEncoderProto12(encodersProto13);
+  encodersProto13[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encodersProto13)(ActivationSchema)(val);
+  encodersProto13[exports.CODEC.OP_DELEGATION] = (val) => schemaEncoder(encodersProto13)(DelegationSchema)(val);
+  encodersProto13[exports.CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encodersProto13)(TransactionSchema)(val);
+  encodersProto13[exports.CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encodersProto13)(OriginationSchema)(val);
+  encodersProto13[exports.CODEC.OP_BALLOT] = (val) => schemaEncoder(encodersProto13)(BallotSchema)(val);
+  encodersProto13[exports.CODEC.OP_ENDORSEMENT] = (val) => schemaEncoder(encodersProto13)(EndorsementSchemaProto12)(val);
+  encodersProto13[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encodersProto13)(SeedNonceRevelationSchema)(val);
+  encodersProto13[exports.CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encodersProto13)(ProposalsSchema)(val);
+  encodersProto13[exports.CODEC.OP_REVEAL] = (val) => schemaEncoder(encodersProto13)(RevealSchema)(val);
+  encodersProto13[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encodersProto13)(RegisterGlobalConstantSchema)(val);
+  encodersProto13[exports.CODEC.MANAGER] = schemaEncoder(encodersProto13)(ManagerOperationSchema);
+
+  const decodersProto13 = Object.assign(Object.assign({}, decodersProto12), { [exports.CODEC.SCRIPT]: scriptDecoderProto13, [exports.CODEC.PARAMETERS]: parametersDecoderProto13, [exports.CODEC.VALUE]: valueParameterDecoderProto13 });
+  decodersProto13[exports.CODEC.OPERATION] = operationDecoderProto12(decodersProto13);
+  decodersProto13[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decodersProto13)(ActivationSchema)(val);
+  decodersProto13[exports.CODEC.OP_DELEGATION] = (val) => schemaDecoder(decodersProto13)(DelegationSchema)(val);
+  decodersProto13[exports.CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decodersProto13)(TransactionSchema)(val);
+  decodersProto13[exports.CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decodersProto13)(OriginationSchema)(val);
+  decodersProto13[exports.CODEC.OP_BALLOT] = (val) => schemaDecoder(decodersProto13)(BallotSchema)(val);
+  decodersProto13[exports.CODEC.OP_ENDORSEMENT] = (val) => schemaDecoder(decodersProto13)(EndorsementSchemaProto12)(val);
+  decodersProto13[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decodersProto13)(SeedNonceRevelationSchema)(val);
+  decodersProto13[exports.CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decodersProto13)(ProposalsSchema)(val);
+  decodersProto13[exports.CODEC.OP_REVEAL] = (val) => schemaDecoder(decodersProto13)(RevealSchema)(val);
+  decodersProto13[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decodersProto13)(RegisterGlobalConstantSchema)(val);
+  decodersProto13[exports.CODEC.MANAGER] = schemaDecoder(decodersProto13)(ManagerOperationSchema);
+
   // 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"
   };
 
   /**
    * @packageDocumentation
    * @module @taquito/local-forging
    */
+  const PROTOCOL_CURRENT = exports.ProtocolsHash.Psithaca2;
   function getCodec(codec, proto) {
       if (proto === exports.ProtocolsHash.Psithaca2) {
           return {
@@ -1182,7 +1501,7 @@
               },
           };
       }
-      else {
+      else if (ProtoInferiorTo(proto, exports.ProtocolsHash.Psithaca2)) {
           return {
               encoder: encoders[codec],
               decoder: (hex) => {
@@ -1191,9 +1510,18 @@
               },
           };
       }
+      else {
+          return {
+              encoder: encodersProto13[codec],
+              decoder: (hex) => {
+                  const consumer = Uint8ArrayConsumer.fromHexString(hex);
+                  return decodersProto13[codec](consumer);
+              },
+          };
+      }
   }
   class LocalForger {
-      constructor(protocolHash = exports.ProtocolsHash.Psithaca2) {
+      constructor(protocolHash = PROTOCOL_CURRENT) {
           this.protocolHash = protocolHash;
           this.codec = getCodec(exports.CODEC.MANAGER, this.protocolHash);
       }
@@ -1203,7 +1531,7 @@
           }
           for (const content of params.contents) {
               if (!validateOperationKind(content.kind)) {
-                  throw new InvalidOperationKindError(`The operation kind '${content.kind}' does not exist`);
+                  throw new utils.InvalidOperationKindError(content.kind);
               }
               const diff = validateMissingProperty(content);
               if (diff.length === 1) {