@taquito/local-forging 22.0.0-beta.0 → 23.0.0-RC.0

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

@@ -60,6 +60,7 @@
       CODEC["BURN_LIMIT"] = "burn_limit";
       CODEC["OP_INCREASE_PAID_STORAGE"] = "increase_paid_storage";
       CODEC["OP_UPDATE_CONSENSUS_KEY"] = "update_consensus_key";
+      CODEC["OP_UPDATE_COMPANION_KEY"] = "update_companion_key";
       CODEC["SIGNATURE_PROOF"] = "signature_proof";
       CODEC["OP_DRAIN_DELEGATE"] = "drain_delegate";
       CODEC["DEPOSITS_LIMIT"] = "deposits_limit";
@@ -231,8 +232,9 @@
       '9b': 'BYTES',
       '9c': 'NAT',
       '9d': 'Ticket',
+      '9e': 'IS_IMPLICIT_ACCOUNT',
   };
-  const opMappingReverse = (() => {
+  const opMappingReverse$1 = (() => {
       const result = {};
       Object.keys(opMapping$1).forEach((key) => {
           result[opMapping$1[key]] = key;
@@ -256,6 +258,7 @@
       0x70: 'set_deposits_limit',
       0x71: 'increase_paid_storage',
       0x72: 'update_consensus_key',
+      0x73: 'update_companion_key',
       0x09: 'drain_delegate',
       0xc8: 'smart_rollup_originate',
       0xc9: 'smart_rollup_add_messages',
@@ -485,73 +488,73 @@
       }
   }
 
-  const isPrim = (value) => {
+  const isPrim$1 = (value) => {
       return 'prim' in value;
   };
-  const isBytes = (value) => {
+  const isBytes$1 = (value) => {
       return 'bytes' in value && typeof value.bytes === 'string';
   };
-  const isString = (value) => {
+  const isString$1 = (value) => {
       return 'string' in value && typeof value.string === 'string';
   };
-  const isInt = (value) => {
+  const isInt$1 = (value) => {
       return 'int' in value && typeof value.int === 'string';
   };
-  const scriptEncoder = (script) => {
-      const code = valueEncoder(script.code);
-      const storage = valueEncoder(script.storage);
+  const scriptEncoder$1 = (script) => {
+      const code = valueEncoder$1(script.code);
+      const storage = valueEncoder$1(script.storage);
       return `${pad(code.length / 2, 8)}${code}${pad(storage.length / 2, 8)}${storage}`;
   };
-  const scriptDecoder = (value) => {
-      const code = extractRequiredLen(value);
-      const storage = extractRequiredLen(value);
+  const scriptDecoder$1 = (value) => {
+      const code = extractRequiredLen$1(value);
+      const storage = extractRequiredLen$1(value);
       return {
-          code: valueDecoder(new Uint8ArrayConsumer(code)),
-          storage: valueDecoder(new Uint8ArrayConsumer(storage)),
+          code: valueDecoder$1(new Uint8ArrayConsumer(code)),
+          storage: valueDecoder$1(new Uint8ArrayConsumer(storage)),
       };
   };
-  const valueEncoder = (value) => {
+  const valueEncoder$1 = (value) => {
       if (Array.isArray(value)) {
-          const encoded = value.map((x) => valueEncoder(x)).join('');
+          const encoded = value.map((x) => valueEncoder$1(x)).join('');
           const len = encoded.length / 2;
           return `02${pad(len)}${encoded}`;
       }
-      else if (isPrim(value)) {
-          return primEncoder(value);
+      else if (isPrim$1(value)) {
+          return primEncoder$1(value);
       }
-      else if (isBytes(value)) {
-          return bytesEncoder(value);
+      else if (isBytes$1(value)) {
+          return bytesEncoder$1(value);
       }
-      else if (isString(value)) {
-          return stringEncoder(value);
+      else if (isString$1(value)) {
+          return stringEncoder$1(value);
       }
-      else if (isInt(value)) {
-          return intEncoder(value);
+      else if (isInt$1(value)) {
+          return intEncoder$1(value);
       }
       throw new UnexpectedMichelsonValueError(JSON.stringify(value));
   };
-  const valueDecoder = (value) => {
+  const valueDecoder$1 = (value) => {
       const preamble = value.consume(1);
       switch (preamble[0]) {
           case 0x0a:
-              return bytesDecoder(value);
+              return bytesDecoder$1(value);
           case 0x01:
-              return stringDecoder(value);
+              return stringDecoder$1(value);
           case 0x00:
-              return intDecoder(value);
+              return intDecoder$1(value);
           case 0x02: {
-              const val = new Uint8ArrayConsumer(extractRequiredLen(value));
+              const val = new Uint8ArrayConsumer(extractRequiredLen$1(value));
               const results = [];
               while (val.length() > 0) {
-                  results.push(valueDecoder(val));
+                  results.push(valueDecoder$1(val));
               }
               return results;
           }
           default:
-              return primDecoder(value, preamble);
+              return primDecoder$1(value, preamble);
       }
   };
-  const extractRequiredLen = (value, bytesLength = 4) => {
+  const extractRequiredLen$1 = (value, bytesLength = 4) => {
       const len = value.consume(bytesLength);
       const valueLen = parseInt(Buffer.from(len).toString('hex'), 16);
       return value.consume(valueLen);
@@ -562,7 +565,7 @@
    * @param bytesLength default 4 bytes for length of variable bytes
    * @returns array of Uint8Array values for each array item
    */
-  const stripLengthPrefixFromBytes = (value, bytesLength = 4) => {
+  const stripLengthPrefixFromBytes$1 = (value, bytesLength = 4) => {
       const ret = [];
       let values = value;
       while (values.length()) {
@@ -573,31 +576,31 @@
       }
       return ret;
   };
-  const bytesEncoder = (value) => {
+  const bytesEncoder$1 = (value) => {
       if (!/^([A-Fa-f0-9]{2})*$/.test(value.bytes)) {
           throw new core.InvalidHexStringError(value.bytes);
       }
       const len = value.bytes.length / 2;
       return `0a${pad(len)}${value.bytes}`;
   };
-  const bytesDecoder = (value) => {
-      const bytes = extractRequiredLen(value);
+  const bytesDecoder$1 = (value) => {
+      const bytes = extractRequiredLen$1(value);
       return {
           bytes: Buffer.from(bytes).toString('hex'),
       };
   };
-  const stringEncoder = (value) => {
+  const stringEncoder$1 = (value) => {
       const str = Buffer.from(value.string, 'utf8').toString('hex');
       const hexLength = str.length / 2;
       return `01${pad(hexLength)}${str}`;
   };
-  const stringDecoder = (value) => {
-      const str = extractRequiredLen(value);
+  const stringDecoder$1 = (value) => {
+      const str = extractRequiredLen$1(value);
       return {
           string: Buffer.from(str).toString('utf8'),
       };
   };
-  const intEncoder = ({ int }) => {
+  const intEncoder$1 = ({ int }) => {
       const num = new BigNumber.BigNumber(int, 10);
       const positiveMark = num.toString(2)[0] === '-' ? '1' : '0';
       const binary = num.toString(2).replace(/-/g, '');
@@ -617,7 +620,7 @@
           .padStart(2, '0'));
       return `00${numHex.join('')}`;
   };
-  const intDecoder = (value) => {
+  const intDecoder$1 = (value) => {
       let c = value.consume(1)[0];
       const hexNumber = [];
       const isNotLastChunkMask = 1 << 7;
@@ -642,14 +645,14 @@
           int: num.toFixed(),
       };
   };
-  const primEncoder = (value) => {
+  const primEncoder$1 = (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 = opMappingReverse[value.prim];
-      let encodedArgs = (value.args || []).map((arg) => valueEncoder(arg)).join('');
-      const encodedAnnots = Array.isArray(value.annots) ? encodeAnnots(value.annots) : '';
+      const op = opMappingReverse$1[value.prim];
+      let encodedArgs = (value.args || []).map((arg) => valueEncoder$1(arg)).join('');
+      const encodedAnnots = Array.isArray(value.annots) ? encodeAnnots$1(value.annots) : '';
       if ((value.prim === 'LAMBDA' || value.prim === 'LAMBDA_REC') && argsCount) {
           encodedArgs = pad(encodedArgs.length / 2) + encodedArgs + pad(0);
       }
@@ -664,7 +667,7 @@
       }
       return `${preamble}${op}${encodedArgs}${encodedAnnots}`;
   };
-  const primDecoder = (value, preamble) => {
+  const primDecoder$1 = (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');
@@ -676,7 +679,7 @@
       }
       if (opMapping$1[op] === 'view') {
           if (argsCount != 0) {
-              return primViewDecoder(value, result);
+              return primViewDecoder$1(value, result);
           }
           else {
               return result;
@@ -685,11 +688,11 @@
       let combPairArgs;
       let combPairAnnots;
       if ((opMapping$1[op] === 'pair' || opMapping$1[op] === 'Pair') && argsCount > 2) {
-          combPairArgs = decodeCombPair(value);
+          combPairArgs = decodeCombPair$1(value);
           argsCount = 0;
-          combPairAnnots = decodeAnnots(value);
+          combPairAnnots = decodeAnnots$1(value);
       }
-      const args = new Array(argsCount).fill(0).map(() => valueDecoder(value));
+      const args = new Array(argsCount).fill(0).map(() => valueDecoder$1(value));
       if (opMapping$1[op] === 'LAMBDA' || opMapping$1[op] === 'LAMBDA_REC') {
           value.consume(4);
       }
@@ -703,25 +706,25 @@
           result['annots'] = combPairAnnots;
       }
       else if (hasAnnot) {
-          result['annots'] = decodeAnnots(value);
+          result['annots'] = decodeAnnots$1(value);
       }
       return result;
   };
-  const primViewDecoder = (value, result) => {
+  const primViewDecoder$1 = (value, result) => {
       value.consume(4);
-      result['args'] = new Array(4).fill(0).map(() => valueDecoder(value));
+      result['args'] = new Array(4).fill(0).map(() => valueDecoder$1(value));
       value.consume(4);
       return result;
   };
-  const decodeCombPair = (val) => {
-      const array = new Uint8ArrayConsumer(extractRequiredLen(val));
+  const decodeCombPair$1 = (val) => {
+      const array = new Uint8ArrayConsumer(extractRequiredLen$1(val));
       const args = [];
       while (array.length() > 0) {
-          args.push(valueDecoder(array));
+          args.push(valueDecoder$1(array));
       }
       return args;
   };
-  const encodeAnnots = (value) => {
+  const encodeAnnots$1 = (value) => {
       const mergedAnnot = value
           .map((x) => {
           return Buffer.from(x, 'utf8').toString('hex');
@@ -730,7 +733,7 @@
       const len = mergedAnnot.length / 2;
       return `${pad(len)}${mergedAnnot}`;
   };
-  const decodeAnnots = (val) => {
+  const decodeAnnots$1 = (val) => {
       const len = val.consume(4);
       const annotLen = parseInt(Buffer.from(len).toString('hex'), 16);
       const restOfAnnot = val.consume(annotLen);
@@ -740,27 +743,28 @@
 
   // https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
   const prefixEncoder$1 = (prefix) => (str) => {
-      return utils.buf2hex(Buffer.from(utils.b58cdecode(str, utils.prefix[prefix])));
+      const [pl] = utils.b58DecodeAndCheckPrefix(str, [prefix]);
+      return utils.buf2hex(pl);
   };
   const prefixDecoder$1 = (pre) => (str) => {
-      const val = str.consume(utils.prefixLength[pre]);
-      return utils.b58cencode(val, utils.prefix[pre]);
+      const val = str.consume(utils.payloadLength[pre]);
+      return utils.b58Encode(val, pre);
   };
-  const tz1Decoder$1 = prefixDecoder$1(utils.Prefix.TZ1);
-  const branchDecoder$1 = prefixDecoder$1(utils.Prefix.B);
+  const tz1Decoder$1 = prefixDecoder$1(utils.PrefixV2.Ed25519PublicKeyHash);
+  const branchDecoder$1 = prefixDecoder$1(utils.PrefixV2.BlockHash);
   const publicKeyHashDecoder$1 = (val) => {
       const prefix = val.consume(1);
       if (prefix[0] === 0x00) {
-          return prefixDecoder$1(utils.Prefix.TZ1)(val);
+          return prefixDecoder$1(utils.PrefixV2.Ed25519PublicKeyHash)(val);
       }
       else if (prefix[0] === 0x01) {
-          return prefixDecoder$1(utils.Prefix.TZ2)(val);
+          return prefixDecoder$1(utils.PrefixV2.Secp256k1PublicKeyHash)(val);
       }
       else if (prefix[0] === 0x02) {
-          return prefixDecoder$1(utils.Prefix.TZ3)(val);
+          return prefixDecoder$1(utils.PrefixV2.P256PublicKeyHash)(val);
       }
       else if (prefix[0] === 0x03) {
-          return prefixDecoder$1(utils.Prefix.TZ4)(val);
+          return prefixDecoder$1(utils.PrefixV2.BLS12_381PublicKeyHash)(val);
       }
   };
   const publicKeyHashesDecoder$1 = (val) => {
@@ -774,14 +778,14 @@
       }
       return publicKeyHashes;
   };
-  const branchEncoder$1 = prefixEncoder$1(utils.Prefix.B);
-  const tz1Encoder$1 = prefixEncoder$1(utils.Prefix.TZ1);
+  const branchEncoder$1 = prefixEncoder$1(utils.PrefixV2.BlockHash);
+  const tz1Encoder$1 = prefixEncoder$1(utils.PrefixV2.Ed25519PublicKeyHash);
   const boolEncoder$1 = (bool) => (bool ? 'ff' : '00');
   const proposalEncoder$1 = (proposal) => {
-      return prefixEncoder$1(utils.Prefix.P)(proposal);
+      return prefixEncoder$1(utils.PrefixV2.ProtocolHash)(proposal);
   };
   const proposalDecoder$1 = (proposal) => {
-      return prefixDecoder$1(utils.Prefix.P)(proposal);
+      return prefixDecoder$1(utils.PrefixV2.ProtocolHash)(proposal);
   };
   const proposalsDecoder$1 = (proposal) => {
       const proposals = [];
@@ -897,19 +901,11 @@
       }
   };
   const publicKeyHashEncoder$1 = (val) => {
-      const pubkeyPrefix = val.substring(0, 3);
-      switch (pubkeyPrefix) {
-          case utils.Prefix.TZ1:
-              return '00' + prefixEncoder$1(utils.Prefix.TZ1)(val);
-          case utils.Prefix.TZ2:
-              return '01' + prefixEncoder$1(utils.Prefix.TZ2)(val);
-          case utils.Prefix.TZ3:
-              return '02' + prefixEncoder$1(utils.Prefix.TZ3)(val);
-          case utils.Prefix.TZ4:
-              return '03' + prefixEncoder$1(utils.Prefix.TZ4)(val);
-          default:
-              throw new utils.InvalidKeyHashError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
-                  ` expecting one for the following "${utils.Prefix.TZ1}", "${utils.Prefix.TZ2}", "${utils.Prefix.TZ3}" or "${utils.Prefix.TZ4}".`);
+      try {
+          return utils.b58DecodePublicKeyHash(val);
+      }
+      catch (err) {
+          throw new core.InvalidKeyHashError(val, err instanceof core.ParameterValidationError ? err.result : undefined);
       }
   };
   const publicKeyHashesEncoder$1 = (val) => {
@@ -925,70 +921,57 @@
       return boolEncoder$1(true) + pad(publicKeyHashes.length / 2) + publicKeyHashes;
   };
   const publicKeyEncoder$1 = (val) => {
-      const pubkeyPrefix = val.substring(0, 4);
-      switch (pubkeyPrefix) {
-          case utils.Prefix.EDPK:
-              return '00' + prefixEncoder$1(utils.Prefix.EDPK)(val);
-          case utils.Prefix.SPPK:
-              return '01' + prefixEncoder$1(utils.Prefix.SPPK)(val);
-          case utils.Prefix.P2PK:
-              return '02' + prefixEncoder$1(utils.Prefix.P2PK)(val);
-          case utils.Prefix.BLPK:
-              return '03' + prefixEncoder$1(utils.Prefix.BLPK)(val);
-          default:
-              throw new utils.InvalidPublicKeyError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
-                  ` expecting one of the following '${utils.Prefix.EDPK}', '${utils.Prefix.SPPK}', '${utils.Prefix.P2PK}' or '${utils.Prefix.BLPK}'.`);
+      try {
+          return utils.b58DecodePublicKey(val);
+      }
+      catch (err) {
+          throw new utils.InvalidPublicKeyError(val, err instanceof core.ParameterValidationError ? err.result : undefined);
       }
   };
   const addressEncoder$1 = (val) => {
-      const pubkeyPrefix = val.substring(0, 3);
-      switch (pubkeyPrefix) {
-          case utils.Prefix.TZ1:
-          case utils.Prefix.TZ2:
-          case utils.Prefix.TZ3:
-          case utils.Prefix.TZ4:
-              return '00' + publicKeyHashEncoder$1(val);
-          case utils.Prefix.KT1:
-              return '01' + prefixEncoder$1(utils.Prefix.KT1)(val) + '00';
-          default:
-              throw new core.InvalidAddressError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
-                  ` expecting one of the following prefix '${utils.Prefix.TZ1}', ${utils.Prefix.TZ2}', '${utils.Prefix.TZ3}', '${utils.Prefix.TZ4}' or '${utils.Prefix.KT1}'.`);
-      }
+      return utils.b58DecodeAddress(val);
   };
   const smartRollupAddressEncoder$1 = (val) => {
-      if (val.substring(0, 3) !== utils.Prefix.SR1) {
-          throw new InvalidSmartRollupAddressError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SR1}'.`);
+      try {
+          return prefixEncoder$1(utils.PrefixV2.SmartRollupHash)(val);
       }
-      return prefixEncoder$1(utils.Prefix.SR1)(val);
-  };
-  const smartContractAddressEncoder$1 = (val) => {
-      const prefix = val.substring(0, 3);
-      if (prefix === utils.Prefix.KT1) {
-          return '01' + prefixEncoder$1(utils.Prefix.KT1)(val) + '00';
+      catch (err) {
+          if (err instanceof core.ParameterValidationError) {
+              throw new InvalidSmartRollupAddressError(val);
+          }
+          else {
+              throw err;
+          }
       }
-      throw new core.InvalidContractAddressError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.KT1}'.`);
   };
+  const smartContractAddressEncoder$1 = (val) => utils.b58DecodeAddress(val);
   const publicKeyDecoder$1 = (val) => {
       const preamble = val.consume(1);
       switch (preamble[0]) {
           case 0x00:
-              return prefixDecoder$1(utils.Prefix.EDPK)(val);
+              return prefixDecoder$1(utils.PrefixV2.Ed25519PublicKey)(val);
           case 0x01:
-              return prefixDecoder$1(utils.Prefix.SPPK)(val);
+              return prefixDecoder$1(utils.PrefixV2.Secp256k1PublicKey)(val);
           case 0x02:
-              return prefixDecoder$1(utils.Prefix.P2PK)(val);
+              return prefixDecoder$1(utils.PrefixV2.P256PublicKey)(val);
           case 0x03:
-              return prefixDecoder$1(utils.Prefix.BLPK)(val);
+              return prefixDecoder$1(utils.PrefixV2.BLS12_381PublicKey)(val);
           default:
-              throw new utils.InvalidPublicKeyError(val.toString(), utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED));
+              throw new utils.InvalidPublicKeyError(undefined, utils.ValidationResult.NO_PREFIX_MATCHED);
       }
   };
   const smartRollupCommitmentHashEncoder$1 = (val) => {
-      const prefix = val.substring(0, 4);
-      if (prefix === utils.Prefix.SRC1) {
-          return prefixEncoder$1(utils.Prefix.SRC1)(val);
+      try {
+          return prefixEncoder$1(utils.PrefixV2.SmartRollupCommitmentHash)(val);
+      }
+      catch (err) {
+          if (err instanceof core.ParameterValidationError) {
+              throw new InvalidSmartRollupCommitmentHashError(val);
+          }
+          else {
+              throw err;
+          }
       }
-      throw new InvalidSmartRollupCommitmentHashError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SRC1}'`);
   };
   const addressDecoder$1 = (val) => {
       const preamble = val.consume(1);
@@ -996,7 +979,7 @@
           case 0x00:
               return publicKeyHashDecoder$1(val);
           case 0x01: {
-              const address = prefixDecoder$1(utils.Prefix.KT1)(val);
+              const address = prefixDecoder$1(utils.PrefixV2.ContractHash)(val);
               val.consume(1);
               return address;
           }
@@ -1005,27 +988,19 @@
       }
   };
   const smartRollupAddressDecoder$1 = (val) => {
-      const address = prefixDecoder$1(utils.Prefix.SR1)(val);
-      if (address.substring(0, 3) !== utils.Prefix.SR1) {
-          throw new InvalidSmartRollupAddressError(address, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SR1}'.`);
-      }
-      return address;
+      return prefixDecoder$1(utils.PrefixV2.SmartRollupHash)(val);
   };
   const smartContractAddressDecoder$1 = (val) => {
       const preamble = val.consume(1);
       if (preamble[0] === 0x01) {
-          const scAddress = prefixDecoder$1(utils.Prefix.KT1)(val);
+          const scAddress = prefixDecoder$1(utils.PrefixV2.ContractHash)(val);
           val.consume(1);
           return scAddress;
       }
-      throw new core.InvalidContractAddressError(val.toString(), utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED));
+      throw new core.InvalidContractAddressError(val.toString(), utils.ValidationResult.NO_PREFIX_MATCHED);
   };
   const smartRollupCommitmentHashDecoder$1 = (val) => {
-      const address = prefixDecoder$1(utils.Prefix.SRC1)(val);
-      if (address.substring(0, 4) !== utils.Prefix.SRC1) {
-          throw new InvalidSmartRollupCommitmentHashError(address, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SRC1}'`);
-      }
-      return address;
+      return prefixDecoder$1(utils.PrefixV2.SmartRollupCommitmentHash)(val);
   };
   const zarithEncoder$1 = (n) => {
       const fn = [];
@@ -1071,7 +1046,7 @@
           return entrypointMapping$1[preamble];
       }
       else {
-          const entry = extractRequiredLen(value, 1);
+          const entry = extractRequiredLen$1(value, 1);
           const entrypoint = Buffer.from(entry).toString('utf8');
           if (entrypoint.length > ENTRYPOINT_MAX_LENGTH$1) {
               throw new OversizedEntryPointError(entrypoint);
@@ -1086,8 +1061,8 @@
       }
       else {
           const encodedEntrypoint = entrypointDecoder$1(val);
-          const params = extractRequiredLen(val);
-          const parameters = valueDecoder(new Uint8ArrayConsumer(params));
+          const params = extractRequiredLen$1(val);
+          const parameters = valueDecoder$1(new Uint8ArrayConsumer(params));
           return {
               entrypoint: encodedEntrypoint,
               value: parameters,
@@ -1103,7 +1078,7 @@
               throw new OversizedEntryPointError(entrypoint);
           }
           const value = { string: entrypoint };
-          return `ff${valueEncoder(value).slice(8)}`;
+          return `ff${valueEncoder$1(value).slice(8)}`;
       }
   };
   const parametersEncoder$1 = (val) => {
@@ -1111,26 +1086,26 @@
           return '00';
       }
       const encodedEntrypoint = entrypointEncoder$1(val.entrypoint);
-      const parameters = valueEncoder(val.value);
+      const parameters = valueEncoder$1(val.value);
       const length = pad(parameters.length / 2);
       return `ff${encodedEntrypoint}${length}${parameters}`;
   };
   const valueParameterEncoder$1 = (value) => {
-      const valueEncoded = valueEncoder(value);
+      const valueEncoded = valueEncoder$1(value);
       return `${pad(valueEncoded.length / 2)}${valueEncoded}`;
   };
   const valueParameterDecoder$1 = (val) => {
-      const value = extractRequiredLen(val);
-      return valueDecoder(new Uint8ArrayConsumer(value));
+      const value = extractRequiredLen$1(val);
+      return valueDecoder$1(new Uint8ArrayConsumer(value));
   };
-  const blockPayloadHashEncoder$1 = prefixEncoder$1(utils.Prefix.VH);
-  const blockPayloadHashDecoder$1 = prefixDecoder$1(utils.Prefix.VH);
+  const blockPayloadHashEncoder$1 = prefixEncoder$1(utils.PrefixV2.ValueHash);
+  const blockPayloadHashDecoder$1 = prefixDecoder$1(utils.PrefixV2.ValueHash);
   const entrypointNameEncoder$1 = (entrypoint) => {
       const value = { string: entrypoint };
-      return `${valueEncoder(value).slice(2)}`;
+      return `${valueEncoder$1(value).slice(2)}`;
   };
   const entrypointNameDecoder$1 = (val) => {
-      const entry = extractRequiredLen(val);
+      const entry = extractRequiredLen$1(val);
       return Buffer.from(entry).toString('utf8');
   };
   const burnLimitEncoder$1 = (val) => {
@@ -1151,50 +1126,53 @@
           return zarithDecoder$1(value);
       }
   };
-  const signatureV1Encoder = (val) => {
-      const signaturePrefix = val.substring(0, 5);
-      switch (signaturePrefix) {
-          case utils.Prefix.EDSIG:
-              return paddedBytesEncoder$1(prefixEncoder$1(utils.Prefix.EDSIG)(val));
-          case utils.Prefix.SPSIG:
-              return paddedBytesEncoder$1(prefixEncoder$1(utils.Prefix.SPSIG)(val));
-          case utils.Prefix.P2SIG:
-              return paddedBytesEncoder$1(prefixEncoder$1(utils.Prefix.P2SIG)(val));
-          case utils.Prefix.BLSIG:
-              return paddedBytesEncoder$1(prefixEncoder$1(utils.Prefix.BLSIG)(val));
-          default:
-              throw new core.InvalidSignatureError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
-                  ` expecting one of the following '${utils.Prefix.EDSIG}', '${utils.Prefix.SPSIG}', '${utils.Prefix.P2SIG}' or '${utils.Prefix.BLSIG}'.`);
+  const signatureV1Encoder$1 = (val) => {
+      try {
+          const [data, pre] = utils.b58DecodeAndCheckPrefix(val, utils.signaturePrefixes);
+          if (pre === utils.PrefixV2.BLS12_381Signature) {
+              return paddedBytesEncoder$1(utils.buf2hex(data));
+          }
+          else {
+              throw new core.ProhibitedActionError('we only support encoding of BLSIG signatures from protocol Seoul');
+          }
+      }
+      catch (err) {
+          if (err instanceof core.ParameterValidationError) {
+              throw new core.InvalidSignatureError(val, err.result);
+          }
+          else {
+              throw err;
+          }
       }
   };
-  const signatureV1Decoder = (val) => {
+  const signatureV1Decoder$1 = (val) => {
       val.consume(4);
       if (val.length().toString() === '96') {
-          return prefixDecoder$1(utils.Prefix.BLSIG)(val);
+          return prefixDecoder$1(utils.PrefixV2.BLS12_381Signature)(val);
       }
       else {
-          throw new core.ProhibitedActionError('currently we only support decoding of BLSIG signatures');
+          throw new core.ProhibitedActionError('we only support decoding of BLSIG signatures');
       }
   };
-  const signatureProofEncoder = (val) => {
+  const signatureProofEncoder$1 = (val) => {
       if (val) {
-          return boolEncoder$1(true) + signatureV1Encoder(val);
+          return boolEncoder$1(true) + signatureV1Encoder$1(val);
       }
       else {
           return boolEncoder$1(false);
       }
   };
-  const signatureProofDecoder = (value) => {
+  const signatureProofDecoder$1 = (value) => {
       const hasProof = boolDecoder$1(value);
       if (hasProof) {
-          return signatureV1Decoder(value);
+          return signatureV1Decoder$1(value);
       }
   };
   const paddedBytesEncoder$1 = (val, paddingLength = 8) => {
       return `${pad(val.length / 2, paddingLength)}${val}`;
   };
   const paddedBytesDecoder$1 = (val) => {
-      const value = extractRequiredLen(val);
+      const value = extractRequiredLen$1(val);
       return Buffer.from(value).toString('hex');
   };
   const smartRollupMessageEncoder$1 = (val) => {
@@ -1204,23 +1182,25 @@
       return `${pad(message.length / 2)}${message}`;
   };
   const smartRollupMessageDecoder$1 = (val) => {
-      const valueArray = extractRequiredLen(val);
-      const ret = stripLengthPrefixFromBytes(new Uint8ArrayConsumer(valueArray));
+      const valueArray = extractRequiredLen$1(val);
+      const ret = stripLengthPrefixFromBytes$1(new Uint8ArrayConsumer(valueArray));
       return ret.map((value) => Buffer.from(value).toString('hex'));
   };
   const dalCommitmentEncoder$1 = (val) => {
-      const prefix = val.substring(0, 2);
-      if (prefix === utils.Prefix.SH) {
-          return prefixEncoder$1(utils.Prefix.SH)(val);
+      try {
+          return prefixEncoder$1(utils.PrefixV2.SlotHeader)(val);
+      }
+      catch (err) {
+          if (err instanceof core.ParameterValidationError) {
+              throw new InvalidDalCommitmentError(val);
+          }
+          else {
+              throw err;
+          }
       }
-      throw new InvalidDalCommitmentError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SH}'`);
   };
   const dalCommitmentDecoder$1 = (val) => {
-      const commitment = prefixDecoder$1(utils.Prefix.SH)(val);
-      if (commitment.substring(0, 2) !== utils.Prefix.SH) {
-          throw new InvalidDalCommitmentError(commitment, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SH}'`);
-      }
-      return commitment;
+      return prefixDecoder$1(utils.PrefixV2.SlotHeader)(val);
   };
   const slotHeaderEncoder$1 = (val) => {
       return pad(val.slot_index, 2) + dalCommitmentEncoder$1(val.commitment) + val.commitment_proof;
@@ -1249,6 +1229,7 @@
       gas_limit: exports.CODEC.ZARITH,
       storage_limit: exports.CODEC.ZARITH,
       public_key: exports.CODEC.PUBLIC_KEY,
+      proof: exports.CODEC.SIGNATURE_PROOF,
   };
   const DelegationSchema$1 = {
       source: exports.CODEC.PKH,
@@ -1345,6 +1326,15 @@
       pk: exports.CODEC.PUBLIC_KEY,
       proof: exports.CODEC.SIGNATURE_PROOF,
   };
+  const UpdateCompanionKeySchema = {
+      source: exports.CODEC.PKH,
+      fee: exports.CODEC.ZARITH,
+      counter: exports.CODEC.ZARITH,
+      gas_limit: exports.CODEC.ZARITH,
+      storage_limit: exports.CODEC.ZARITH,
+      pk: exports.CODEC.PUBLIC_KEY,
+      proof: exports.CODEC.SIGNATURE_PROOF,
+  };
   const DrainDelegateSchema$1 = {
       consensus_key: exports.CODEC.PKH,
       delegate: exports.CODEC.PKH,
@@ -1463,7 +1453,7 @@
       }, {});
   };
 
-  const decoders = {
+  const decoders$1 = {
       [exports.CODEC.SECRET]: (val) => toHexString(val.consume(20)),
       [exports.CODEC.RAW]: (val) => toHexString(val.consume(32)),
       [exports.CODEC.TZ1]: tz1Decoder$1,
@@ -1474,7 +1464,7 @@
       [exports.CODEC.PKH_ARR]: publicKeyHashesDecoder$1,
       [exports.CODEC.DELEGATE]: delegateDecoder$1,
       [exports.CODEC.INT32]: int32Decoder$1,
-      [exports.CODEC.SCRIPT]: scriptDecoder,
+      [exports.CODEC.SCRIPT]: scriptDecoder$1,
       [exports.CODEC.BALLOT_STATEMENT]: ballotDecoder$1,
       [exports.CODEC.PROPOSAL]: proposalDecoder$1,
       [exports.CODEC.PROPOSAL_ARR]: proposalsDecoder$1,
@@ -1489,35 +1479,36 @@
       [exports.CODEC.ENTRYPOINT]: entrypointNameDecoder$1,
       [exports.CODEC.BURN_LIMIT]: burnLimitDecoder$1,
       [exports.CODEC.DEPOSITS_LIMIT]: depositsLimitDecoder$1,
-      [exports.CODEC.SIGNATURE_PROOF]: signatureProofDecoder,
+      [exports.CODEC.SIGNATURE_PROOF]: signatureProofDecoder$1,
       [exports.CODEC.PVM_KIND]: pvmKindDecoder$1,
       [exports.CODEC.PADDED_BYTES]: paddedBytesDecoder$1,
       [exports.CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageDecoder$1,
       [exports.CODEC.SLOT_HEADER]: slotHeaderDecoder$1,
   };
-  decoders[exports.CODEC.OPERATION] = operationDecoder$1(decoders);
-  decoders[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder$1(decoders)(ActivationSchema$1)(val);
-  decoders[exports.CODEC.OP_FAILING_NOOP] = (val) => schemaDecoder$1(decoders)(FailingNoopSchema$1)(val);
-  decoders[exports.CODEC.OP_DELEGATION] = (val) => schemaDecoder$1(decoders)(DelegationSchema$1)(val);
-  decoders[exports.CODEC.OP_TRANSACTION] = (val) => schemaDecoder$1(decoders)(TransactionSchema$1)(val);
-  decoders[exports.CODEC.OP_ORIGINATION] = (val) => schemaDecoder$1(decoders)(OriginationSchema$1)(val);
-  decoders[exports.CODEC.OP_BALLOT] = (val) => schemaDecoder$1(decoders)(BallotSchema$1)(val);
-  decoders[exports.CODEC.OP_ATTESTATION] = (val) => schemaDecoder$1(decoders)(AttestationSchema$1)(val);
-  decoders[exports.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder$1(decoders)(AttestationWithDalSchema$1)(val);
-  decoders[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder$1(decoders)(SeedNonceRevelationSchema$1)(val);
-  decoders[exports.CODEC.OP_PROPOSALS] = (val) => schemaDecoder$1(decoders)(ProposalsSchema$1)(val);
-  decoders[exports.CODEC.OP_REVEAL] = (val) => schemaDecoder$1(decoders)(RevealSchema$1)(val);
-  decoders[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder$1(decoders)(RegisterGlobalConstantSchema$1)(val);
-  decoders[exports.CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder$1(decoders)(TransferTicketSchema$1)(val);
-  decoders[exports.CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder$1(decoders)(IncreasePaidStorageSchema$1)(val);
-  decoders[exports.CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder$1(decoders)(UpdateConsensusKeySchema$1)(val);
-  decoders[exports.CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder$1(decoders)(DrainDelegateSchema$1)(val);
-  decoders[exports.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder$1(decoders)(SmartRollupOriginateSchema$1)(val);
-  decoders[exports.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder$1(decoders)(SmartRollupAddMessagesSchema$1)(val);
-  decoders[exports.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder$1(decoders)(SmartRollupExecuteOutboxMessageSchema$1)(val);
-  decoders[exports.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder$1(decoders)(DalPublishCommitmentSchema$1)(val);
-  decoders[exports.CODEC.MANAGER] = schemaDecoder$1(decoders)(ManagerOperationSchema$1);
-  decoders[exports.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder$1(decoders)(SetDepositsLimitSchema$1)(val);
+  decoders$1[exports.CODEC.OPERATION] = operationDecoder$1(decoders$1);
+  decoders$1[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder$1(decoders$1)(ActivationSchema$1)(val);
+  decoders$1[exports.CODEC.OP_FAILING_NOOP] = (val) => schemaDecoder$1(decoders$1)(FailingNoopSchema$1)(val);
+  decoders$1[exports.CODEC.OP_DELEGATION] = (val) => schemaDecoder$1(decoders$1)(DelegationSchema$1)(val);
+  decoders$1[exports.CODEC.OP_TRANSACTION] = (val) => schemaDecoder$1(decoders$1)(TransactionSchema$1)(val);
+  decoders$1[exports.CODEC.OP_ORIGINATION] = (val) => schemaDecoder$1(decoders$1)(OriginationSchema$1)(val);
+  decoders$1[exports.CODEC.OP_BALLOT] = (val) => schemaDecoder$1(decoders$1)(BallotSchema$1)(val);
+  decoders$1[exports.CODEC.OP_ATTESTATION] = (val) => schemaDecoder$1(decoders$1)(AttestationSchema$1)(val);
+  decoders$1[exports.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder$1(decoders$1)(AttestationWithDalSchema$1)(val);
+  decoders$1[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder$1(decoders$1)(SeedNonceRevelationSchema$1)(val);
+  decoders$1[exports.CODEC.OP_PROPOSALS] = (val) => schemaDecoder$1(decoders$1)(ProposalsSchema$1)(val);
+  decoders$1[exports.CODEC.OP_REVEAL] = (val) => schemaDecoder$1(decoders$1)(RevealSchema$1)(val);
+  decoders$1[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder$1(decoders$1)(RegisterGlobalConstantSchema$1)(val);
+  decoders$1[exports.CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder$1(decoders$1)(TransferTicketSchema$1)(val);
+  decoders$1[exports.CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder$1(decoders$1)(IncreasePaidStorageSchema$1)(val);
+  decoders$1[exports.CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder$1(decoders$1)(UpdateConsensusKeySchema$1)(val);
+  decoders$1[exports.CODEC.OP_UPDATE_COMPANION_KEY] = (val) => schemaDecoder$1(decoders$1)(UpdateCompanionKeySchema)(val);
+  decoders$1[exports.CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder$1(decoders$1)(DrainDelegateSchema$1)(val);
+  decoders$1[exports.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder$1(decoders$1)(SmartRollupOriginateSchema$1)(val);
+  decoders$1[exports.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder$1(decoders$1)(SmartRollupAddMessagesSchema$1)(val);
+  decoders$1[exports.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder$1(decoders$1)(SmartRollupExecuteOutboxMessageSchema$1)(val);
+  decoders$1[exports.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder$1(decoders$1)(DalPublishCommitmentSchema$1)(val);
+  decoders$1[exports.CODEC.MANAGER] = schemaDecoder$1(decoders$1)(ManagerOperationSchema$1);
+  decoders$1[exports.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder$1(decoders$1)(SetDepositsLimitSchema$1)(val);
 
   /*
    * Some code in this file is originally from sotez
@@ -1570,6 +1561,7 @@
       CODEC["BURN_LIMIT"] = "burn_limit";
       CODEC["OP_INCREASE_PAID_STORAGE"] = "increase_paid_storage";
       CODEC["OP_UPDATE_CONSENSUS_KEY"] = "update_consensus_key";
+      CODEC["SIGNATURE_PROOF"] = "signature_proof";
       CODEC["OP_DRAIN_DELEGATE"] = "drain_delegate";
       CODEC["DEPOSITS_LIMIT"] = "deposits_limit";
       CODEC["OP_SET_DEPOSITS_LIMIT"] = "set_deposits_limit";
@@ -1741,7 +1733,7 @@
       '9c': 'NAT',
       '9d': 'Ticket',
   };
-  (() => {
+  const opMappingReverse = (() => {
       const result = {};
       Object.keys(opMapping).forEach((key) => {
           result[opMapping[key]] = key;
@@ -1801,6 +1793,259 @@
       return result;
   })();
 
+  const isPrim = (value) => {
+      return 'prim' in value;
+  };
+  const isBytes = (value) => {
+      return 'bytes' in value && typeof value.bytes === 'string';
+  };
+  const isString = (value) => {
+      return 'string' in value && typeof value.string === 'string';
+  };
+  const isInt = (value) => {
+      return 'int' in value && typeof value.int === 'string';
+  };
+  const scriptEncoder = (script) => {
+      const code = valueEncoder(script.code);
+      const storage = valueEncoder(script.storage);
+      return `${pad(code.length / 2, 8)}${code}${pad(storage.length / 2, 8)}${storage}`;
+  };
+  const scriptDecoder = (value) => {
+      const code = extractRequiredLen(value);
+      const storage = extractRequiredLen(value);
+      return {
+          code: valueDecoder(new Uint8ArrayConsumer(code)),
+          storage: valueDecoder(new Uint8ArrayConsumer(storage)),
+      };
+  };
+  const valueEncoder = (value) => {
+      if (Array.isArray(value)) {
+          const encoded = value.map((x) => valueEncoder(x)).join('');
+          const len = encoded.length / 2;
+          return `02${pad(len)}${encoded}`;
+      }
+      else if (isPrim(value)) {
+          return primEncoder(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(JSON.stringify(value));
+  };
+  const valueDecoder = (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(valueDecoder(val));
+              }
+              return results;
+          }
+          default:
+              return primDecoder(value, preamble);
+      }
+  };
+  const extractRequiredLen = (value, bytesLength = 4) => {
+      const len = value.consume(bytesLength);
+      const valueLen = parseInt(Buffer.from(len).toString('hex'), 16);
+      return value.consume(valueLen);
+  };
+  /**
+   * @description parse bytes into multiple items of an array
+   * @param value Uint8ArrayConsumer class of forged segment to parse
+   * @param bytesLength default 4 bytes for length of variable bytes
+   * @returns array of Uint8Array values for each array item
+   */
+  const stripLengthPrefixFromBytes = (value, bytesLength = 4) => {
+      const ret = [];
+      let values = value;
+      while (values.length()) {
+          const len = values.consume(bytesLength);
+          const valueLen = parseInt(Buffer.from(len).toString('hex'), 16);
+          ret.push(values.consume(valueLen));
+          values = values.slice(valueLen + bytesLength);
+      }
+      return ret;
+  };
+  const bytesEncoder = (value) => {
+      if (!/^([A-Fa-f0-9]{2})*$/.test(value.bytes)) {
+          throw new core.InvalidHexStringError(value.bytes);
+      }
+      const len = value.bytes.length / 2;
+      return `0a${pad(len)}${value.bytes}`;
+  };
+  const bytesDecoder = (value) => {
+      const bytes = extractRequiredLen(value);
+      return {
+          bytes: Buffer.from(bytes).toString('hex'),
+      };
+  };
+  const stringEncoder = (value) => {
+      const str = Buffer.from(value.string, 'utf8').toString('hex');
+      const hexLength = str.length / 2;
+      return `01${pad(hexLength)}${str}`;
+  };
+  const stringDecoder = (value) => {
+      const str = extractRequiredLen(value);
+      return {
+          string: Buffer.from(str).toString('utf8'),
+      };
+  };
+  const intEncoder = ({ int }) => {
+      const num = new BigNumber.BigNumber(int, 10);
+      const positiveMark = num.toString(2)[0] === '-' ? '1' : '0';
+      const binary = num.toString(2).replace(/-/g, '');
+      const pad = binary.length <= 6
+          ? 6
+          : (binary.length - 6) % 7
+              ? binary.length + 7 - ((binary.length - 6) % 7)
+              : binary.length;
+      const splitted = binary.padStart(pad, '0').match(/\d{6,7}/g);
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const reversed = splitted.reverse();
+      reversed[0] = positiveMark + reversed[0];
+      const numHex = reversed.map((x, i) => 
+      // Add one to the last chunk
+      parseInt((i === reversed.length - 1 ? '0' : '1') + x, 2)
+          .toString(16)
+          .padStart(2, '0'));
+      return `00${numHex.join('')}`;
+  };
+  const intDecoder = (value) => {
+      let c = value.consume(1)[0];
+      const hexNumber = [];
+      const isNotLastChunkMask = 1 << 7;
+      while (c & isNotLastChunkMask) {
+          hexNumber.push(c);
+          c = value.consume(1)[0];
+      }
+      hexNumber.push(c);
+      const isNegative = !!((1 << 6) & hexNumber[0]);
+      hexNumber[0] = hexNumber[0] & 0b1111111;
+      const numBin = hexNumber
+          .map((x, i) => x
+          .toString(2)
+          .slice(i === 0 ? -6 : -7)
+          .padStart(i === 0 ? 6 : 7, '0'))
+          .reverse();
+      let num = new BigNumber.BigNumber(numBin.join(''), 2);
+      if (isNegative) {
+          num = num.times(-1);
+      }
+      return {
+          int: num.toFixed(),
+      };
+  };
+  const primEncoder = (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 = opMappingReverse[value.prim];
+      let encodedArgs = (value.args || []).map((arg) => valueEncoder(arg)).join('');
+      const encodedAnnots = Array.isArray(value.annots) ? encodeAnnots(value.annots) : '';
+      if ((value.prim === 'LAMBDA' || value.prim === 'LAMBDA_REC') && 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 primDecoder = (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: opMapping[op],
+      };
+      if (opMapping[op] === 'LAMBDA' || opMapping[op] === 'LAMBDA_REC') {
+          value.consume(4);
+      }
+      if (opMapping[op] === 'view') {
+          if (argsCount != 0) {
+              return primViewDecoder(value, result);
+          }
+          else {
+              return result;
+          }
+      }
+      let combPairArgs;
+      let combPairAnnots;
+      if ((opMapping[op] === 'pair' || opMapping[op] === 'Pair') && argsCount > 2) {
+          combPairArgs = decodeCombPair(value);
+          argsCount = 0;
+          combPairAnnots = decodeAnnots(value);
+      }
+      const args = new Array(argsCount).fill(0).map(() => valueDecoder(value));
+      if (opMapping[op] === 'LAMBDA' || opMapping[op] === 'LAMBDA_REC') {
+          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 primViewDecoder = (value, result) => {
+      value.consume(4);
+      result['args'] = new Array(4).fill(0).map(() => valueDecoder(value));
+      value.consume(4);
+      return result;
+  };
+  const decodeCombPair = (val) => {
+      const array = new Uint8ArrayConsumer(extractRequiredLen(val));
+      const args = [];
+      while (array.length() > 0) {
+          args.push(valueDecoder(array));
+      }
+      return args;
+  };
+  const encodeAnnots = (value) => {
+      const mergedAnnot = value
+          .map((x) => {
+          return Buffer.from(x, 'utf8').toString('hex');
+      })
+          .join('20');
+      const len = mergedAnnot.length / 2;
+      return `${pad(len)}${mergedAnnot}`;
+  };
+  const decodeAnnots = (val) => {
+      const len = val.consume(4);
+      const annotLen = parseInt(Buffer.from(len).toString('hex'), 16);
+      const restOfAnnot = val.consume(annotLen);
+      const restOfAnnotHex = Buffer.from(restOfAnnot).toString('hex');
+      return restOfAnnotHex.split('20').map((x) => Buffer.from(x, 'hex').toString('utf8'));
+  };
+
   // https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
   const prefixEncoder = (prefix) => (str) => {
       return utils.buf2hex(Buffer.from(utils.b58cdecode(str, utils.prefix[prefix])));
@@ -1822,10 +2067,13 @@
       else if (prefix[0] === 0x02) {
           return prefixDecoder(utils.Prefix.TZ3)(val);
       }
+      else if (prefix[0] === 0x03) {
+          return prefixDecoder(utils.Prefix.TZ4)(val);
+      }
   };
   const publicKeyHashesDecoder = (val) => {
       if (!boolDecoder(val)) {
-          return undefined;
+          return;
       }
       const publicKeyHashes = [];
       val.consume(4);
@@ -1993,6 +2241,8 @@
               return '01' + prefixEncoder(utils.Prefix.SPPK)(val);
           case utils.Prefix.P2PK:
               return '02' + prefixEncoder(utils.Prefix.P2PK)(val);
+          case utils.Prefix.BLPK:
+              return '03' + prefixEncoder(utils.Prefix.BLPK)(val);
           default:
               throw new utils.InvalidPublicKeyError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
                   ` expecting one of the following '${utils.Prefix.EDPK}', '${utils.Prefix.SPPK}', '${utils.Prefix.P2PK}' or '${utils.Prefix.BLPK}'.`);
@@ -2035,6 +2285,8 @@
               return prefixDecoder(utils.Prefix.SPPK)(val);
           case 0x02:
               return prefixDecoder(utils.Prefix.P2PK)(val);
+          case 0x03:
+              return prefixDecoder(utils.Prefix.BLPK)(val);
           default:
               throw new utils.InvalidPublicKeyError(val.toString(), utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED));
       }
@@ -2207,6 +2459,45 @@
           return zarithDecoder(value);
       }
   };
+  const signatureV1Encoder = (val) => {
+      const signaturePrefix = val.substring(0, 5);
+      switch (signaturePrefix) {
+          case utils.Prefix.EDSIG:
+              return paddedBytesEncoder(prefixEncoder(utils.Prefix.EDSIG)(val));
+          case utils.Prefix.SPSIG:
+              return paddedBytesEncoder(prefixEncoder(utils.Prefix.SPSIG)(val));
+          case utils.Prefix.P2SIG:
+              return paddedBytesEncoder(prefixEncoder(utils.Prefix.P2SIG)(val));
+          case utils.Prefix.BLSIG:
+              return paddedBytesEncoder(prefixEncoder(utils.Prefix.BLSIG)(val));
+          default:
+              throw new core.InvalidSignatureError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
+                  ` expecting one of the following '${utils.Prefix.EDSIG}', '${utils.Prefix.SPSIG}', '${utils.Prefix.P2SIG}' or '${utils.Prefix.BLSIG}'.`);
+      }
+  };
+  const signatureV1Decoder = (val) => {
+      val.consume(4);
+      if (val.length().toString() === '96') {
+          return prefixDecoder(utils.Prefix.BLSIG)(val);
+      }
+      else {
+          throw new core.ProhibitedActionError('currently we only support decoding of BLSIG signatures');
+      }
+  };
+  const signatureProofEncoder = (val) => {
+      if (val) {
+          return boolEncoder(true) + signatureV1Encoder(val);
+      }
+      else {
+          return boolEncoder(false);
+      }
+  };
+  const signatureProofDecoder = (value) => {
+      const hasProof = boolDecoder(value);
+      if (hasProof) {
+          return signatureV1Decoder(value);
+      }
+  };
   const paddedBytesEncoder = (val, paddingLength = 8) => {
       return `${pad(val.length / 2, paddingLength)}${val}`;
   };
@@ -2360,6 +2651,7 @@
       gas_limit: CODEC.ZARITH,
       storage_limit: CODEC.ZARITH,
       pk: CODEC.PUBLIC_KEY,
+      proof: CODEC.SIGNATURE_PROOF,
   };
   const DrainDelegateSchema = {
       consensus_key: CODEC.PKH,
@@ -2479,7 +2771,7 @@
       }, {});
   };
 
-  const decodersProto021 = {
+  const decoders = {
       [CODEC.SECRET]: (val) => toHexString(val.consume(20)),
       [CODEC.RAW]: (val) => toHexString(val.consume(32)),
       [CODEC.TZ1]: tz1Decoder,
@@ -2505,36 +2797,37 @@
       [CODEC.ENTRYPOINT]: entrypointNameDecoder,
       [CODEC.BURN_LIMIT]: burnLimitDecoder,
       [CODEC.DEPOSITS_LIMIT]: depositsLimitDecoder,
+      [CODEC.SIGNATURE_PROOF]: signatureProofDecoder,
       [CODEC.PVM_KIND]: pvmKindDecoder,
       [CODEC.PADDED_BYTES]: paddedBytesDecoder,
       [CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageDecoder,
       [CODEC.SLOT_HEADER]: slotHeaderDecoder,
   };
-  decodersProto021[CODEC.OPERATION] = operationDecoder(decodersProto021);
-  decodersProto021[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decodersProto021)(ActivationSchema)(val);
-  decodersProto021[CODEC.OP_FAILING_NOOP] = (val) => schemaDecoder(decodersProto021)(FailingNoopSchema)(val);
-  decodersProto021[CODEC.OP_DELEGATION] = (val) => schemaDecoder(decodersProto021)(DelegationSchema)(val);
-  decodersProto021[CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decodersProto021)(TransactionSchema)(val);
-  decodersProto021[CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decodersProto021)(OriginationSchema)(val);
-  decodersProto021[CODEC.OP_BALLOT] = (val) => schemaDecoder(decodersProto021)(BallotSchema)(val);
-  decodersProto021[CODEC.OP_ATTESTATION] = (val) => schemaDecoder(decodersProto021)(AttestationSchema)(val);
-  decodersProto021[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder(decodersProto021)(AttestationWithDalSchema)(val);
-  decodersProto021[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decodersProto021)(SeedNonceRevelationSchema)(val);
-  decodersProto021[CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decodersProto021)(ProposalsSchema)(val);
-  decodersProto021[CODEC.OP_REVEAL] = (val) => schemaDecoder(decodersProto021)(RevealSchema)(val);
-  decodersProto021[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decodersProto021)(RegisterGlobalConstantSchema)(val);
-  decodersProto021[CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder(decodersProto021)(TransferTicketSchema)(val);
-  decodersProto021[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder(decodersProto021)(IncreasePaidStorageSchema)(val);
-  decodersProto021[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder(decodersProto021)(UpdateConsensusKeySchema)(val);
-  decodersProto021[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder(decodersProto021)(DrainDelegateSchema)(val);
-  decodersProto021[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder(decodersProto021)(SmartRollupOriginateSchema)(val);
-  decodersProto021[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder(decodersProto021)(SmartRollupAddMessagesSchema)(val);
-  decodersProto021[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder(decodersProto021)(SmartRollupExecuteOutboxMessageSchema)(val);
-  decodersProto021[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder(decodersProto021)(DalPublishCommitmentSchema)(val);
-  decodersProto021[CODEC.MANAGER] = schemaDecoder(decodersProto021)(ManagerOperationSchema);
-  decodersProto021[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder(decodersProto021)(SetDepositsLimitSchema)(val);
+  decoders[CODEC.OPERATION] = operationDecoder(decoders);
+  decoders[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decoders)(ActivationSchema)(val);
+  decoders[CODEC.OP_FAILING_NOOP] = (val) => schemaDecoder(decoders)(FailingNoopSchema)(val);
+  decoders[CODEC.OP_DELEGATION] = (val) => schemaDecoder(decoders)(DelegationSchema)(val);
+  decoders[CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decoders)(TransactionSchema)(val);
+  decoders[CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decoders)(OriginationSchema)(val);
+  decoders[CODEC.OP_BALLOT] = (val) => schemaDecoder(decoders)(BallotSchema)(val);
+  decoders[CODEC.OP_ATTESTATION] = (val) => schemaDecoder(decoders)(AttestationSchema)(val);
+  decoders[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder(decoders)(AttestationWithDalSchema)(val);
+  decoders[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decoders)(SeedNonceRevelationSchema)(val);
+  decoders[CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decoders)(ProposalsSchema)(val);
+  decoders[CODEC.OP_REVEAL] = (val) => schemaDecoder(decoders)(RevealSchema)(val);
+  decoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decoders)(RegisterGlobalConstantSchema)(val);
+  decoders[CODEC.OP_TRANSFER_TICKET] = (val) => schemaDecoder(decoders)(TransferTicketSchema)(val);
+  decoders[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaDecoder(decoders)(IncreasePaidStorageSchema)(val);
+  decoders[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaDecoder(decoders)(UpdateConsensusKeySchema)(val);
+  decoders[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder(decoders)(DrainDelegateSchema)(val);
+  decoders[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder(decoders)(SmartRollupOriginateSchema)(val);
+  decoders[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder(decoders)(SmartRollupAddMessagesSchema)(val);
+  decoders[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder(decoders)(SmartRollupExecuteOutboxMessageSchema)(val);
+  decoders[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder(decoders)(DalPublishCommitmentSchema)(val);
+  decoders[CODEC.MANAGER] = schemaDecoder(decoders)(ManagerOperationSchema);
+  decoders[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder(decoders)(SetDepositsLimitSchema)(val);
 
-  const encoders = {
+  const encoders$1 = {
       [exports.CODEC.SECRET]: (val) => val,
       [exports.CODEC.RAW]: (val) => val,
       [exports.CODEC.TZ1]: tz1Encoder$1,
@@ -2544,7 +2837,7 @@
       [exports.CODEC.PKH]: publicKeyHashEncoder$1,
       [exports.CODEC.PKH_ARR]: publicKeyHashesEncoder$1,
       [exports.CODEC.DELEGATE]: delegateEncoder$1,
-      [exports.CODEC.SCRIPT]: scriptEncoder,
+      [exports.CODEC.SCRIPT]: scriptEncoder$1,
       [exports.CODEC.BALLOT_STATEMENT]: ballotEncoder$1,
       [exports.CODEC.PROPOSAL]: proposalEncoder$1,
       [exports.CODEC.PROPOSAL_ARR]: proposalsEncoder$1,
@@ -2560,37 +2853,38 @@
       [exports.CODEC.ENTRYPOINT]: entrypointNameEncoder$1,
       [exports.CODEC.BURN_LIMIT]: burnLimitEncoder$1,
       [exports.CODEC.DEPOSITS_LIMIT]: depositsLimitEncoder$1,
-      [exports.CODEC.SIGNATURE_PROOF]: signatureProofEncoder,
+      [exports.CODEC.SIGNATURE_PROOF]: signatureProofEncoder$1,
       [exports.CODEC.PVM_KIND]: pvmKindEncoder$1,
       [exports.CODEC.PADDED_BYTES]: paddedBytesEncoder$1,
       [exports.CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageEncoder$1,
       [exports.CODEC.SLOT_HEADER]: slotHeaderEncoder$1,
   };
-  encoders[exports.CODEC.OPERATION] = operationEncoder$1(encoders);
-  encoders[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder$1(encoders)(ActivationSchema$1)(val);
-  encoders[exports.CODEC.OP_DELEGATION] = (val) => schemaEncoder$1(encoders)(DelegationSchema$1)(val);
-  encoders[exports.CODEC.OP_TRANSACTION] = (val) => schemaEncoder$1(encoders)(TransactionSchema$1)(val);
-  encoders[exports.CODEC.OP_ORIGINATION] = (val) => schemaEncoder$1(encoders)(OriginationSchema$1)(val);
-  encoders[exports.CODEC.OP_BALLOT] = (val) => schemaEncoder$1(encoders)(BallotSchema$1)(val);
-  encoders[exports.CODEC.OP_ATTESTATION] = (val) => schemaEncoder$1(encoders)(AttestationSchema$1)(val);
-  encoders[exports.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder$1(encoders)(AttestationWithDalSchema$1)(val);
-  encoders[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder$1(encoders)(SeedNonceRevelationSchema$1)(val);
-  encoders[exports.CODEC.OP_PROPOSALS] = (val) => schemaEncoder$1(encoders)(ProposalsSchema$1)(val);
-  encoders[exports.CODEC.OP_REVEAL] = (val) => schemaEncoder$1(encoders)(RevealSchema$1)(val);
-  encoders[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder$1(encoders)(RegisterGlobalConstantSchema$1)(val);
-  encoders[exports.CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder$1(encoders)(TransferTicketSchema$1)(val);
-  encoders[exports.CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder$1(encoders)(IncreasePaidStorageSchema$1)(val);
-  encoders[exports.CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder$1(encoders)(UpdateConsensusKeySchema$1)(val);
-  encoders[exports.CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder$1(encoders)(DrainDelegateSchema$1)(val);
-  encoders[exports.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder$1(encoders)(SmartRollupOriginateSchema$1)(val);
-  encoders[exports.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder$1(encoders)(SmartRollupAddMessagesSchema$1)(val);
-  encoders[exports.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder$1(encoders)(SmartRollupExecuteOutboxMessageSchema$1)(val);
-  encoders[exports.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder$1(encoders)(DalPublishCommitmentSchema$1)(val);
-  encoders[exports.CODEC.MANAGER] = schemaEncoder$1(encoders)(ManagerOperationSchema$1);
-  encoders[exports.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder$1(encoders)(SetDepositsLimitSchema$1)(val);
-  encoders[exports.CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder$1(encoders)(FailingNoopSchema$1)(val);
+  encoders$1[exports.CODEC.OPERATION] = operationEncoder$1(encoders$1);
+  encoders$1[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder$1(encoders$1)(ActivationSchema$1)(val);
+  encoders$1[exports.CODEC.OP_DELEGATION] = (val) => schemaEncoder$1(encoders$1)(DelegationSchema$1)(val);
+  encoders$1[exports.CODEC.OP_TRANSACTION] = (val) => schemaEncoder$1(encoders$1)(TransactionSchema$1)(val);
+  encoders$1[exports.CODEC.OP_ORIGINATION] = (val) => schemaEncoder$1(encoders$1)(OriginationSchema$1)(val);
+  encoders$1[exports.CODEC.OP_BALLOT] = (val) => schemaEncoder$1(encoders$1)(BallotSchema$1)(val);
+  encoders$1[exports.CODEC.OP_ATTESTATION] = (val) => schemaEncoder$1(encoders$1)(AttestationSchema$1)(val);
+  encoders$1[exports.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder$1(encoders$1)(AttestationWithDalSchema$1)(val);
+  encoders$1[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder$1(encoders$1)(SeedNonceRevelationSchema$1)(val);
+  encoders$1[exports.CODEC.OP_PROPOSALS] = (val) => schemaEncoder$1(encoders$1)(ProposalsSchema$1)(val);
+  encoders$1[exports.CODEC.OP_REVEAL] = (val) => schemaEncoder$1(encoders$1)(RevealSchema$1)(val);
+  encoders$1[exports.CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder$1(encoders$1)(RegisterGlobalConstantSchema$1)(val);
+  encoders$1[exports.CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder$1(encoders$1)(TransferTicketSchema$1)(val);
+  encoders$1[exports.CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder$1(encoders$1)(IncreasePaidStorageSchema$1)(val);
+  encoders$1[exports.CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder$1(encoders$1)(UpdateConsensusKeySchema$1)(val);
+  encoders$1[exports.CODEC.OP_UPDATE_COMPANION_KEY] = (val) => schemaEncoder$1(encoders$1)(UpdateCompanionKeySchema)(val);
+  encoders$1[exports.CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder$1(encoders$1)(DrainDelegateSchema$1)(val);
+  encoders$1[exports.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder$1(encoders$1)(SmartRollupOriginateSchema$1)(val);
+  encoders$1[exports.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder$1(encoders$1)(SmartRollupAddMessagesSchema$1)(val);
+  encoders$1[exports.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder$1(encoders$1)(SmartRollupExecuteOutboxMessageSchema$1)(val);
+  encoders$1[exports.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder$1(encoders$1)(DalPublishCommitmentSchema$1)(val);
+  encoders$1[exports.CODEC.MANAGER] = schemaEncoder$1(encoders$1)(ManagerOperationSchema$1);
+  encoders$1[exports.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder$1(encoders$1)(SetDepositsLimitSchema$1)(val);
+  encoders$1[exports.CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder$1(encoders$1)(FailingNoopSchema$1)(val);
 
-  const encodersProto021 = {
+  const encoders = {
       [CODEC.SECRET]: (val) => val,
       [CODEC.RAW]: (val) => val,
       [CODEC.TZ1]: tz1Encoder,
@@ -2616,34 +2910,35 @@
       [CODEC.ENTRYPOINT]: entrypointNameEncoder,
       [CODEC.BURN_LIMIT]: burnLimitEncoder,
       [CODEC.DEPOSITS_LIMIT]: depositsLimitEncoder,
+      [CODEC.SIGNATURE_PROOF]: signatureProofEncoder,
       [CODEC.PVM_KIND]: pvmKindEncoder,
       [CODEC.PADDED_BYTES]: paddedBytesEncoder,
       [CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageEncoder,
       [CODEC.SLOT_HEADER]: slotHeaderEncoder,
   };
-  encodersProto021[CODEC.OPERATION] = operationEncoder(encodersProto021);
-  encodersProto021[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encodersProto021)(ActivationSchema)(val);
-  encodersProto021[CODEC.OP_DELEGATION] = (val) => schemaEncoder(encodersProto021)(DelegationSchema)(val);
-  encodersProto021[CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encodersProto021)(TransactionSchema)(val);
-  encodersProto021[CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encodersProto021)(OriginationSchema)(val);
-  encodersProto021[CODEC.OP_BALLOT] = (val) => schemaEncoder(encodersProto021)(BallotSchema)(val);
-  encodersProto021[CODEC.OP_ATTESTATION] = (val) => schemaEncoder(encodersProto021)(AttestationSchema)(val);
-  encodersProto021[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder(encodersProto021)(AttestationWithDalSchema)(val);
-  encodersProto021[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encodersProto021)(SeedNonceRevelationSchema)(val);
-  encodersProto021[CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encodersProto021)(ProposalsSchema)(val);
-  encodersProto021[CODEC.OP_REVEAL] = (val) => schemaEncoder(encodersProto021)(RevealSchema)(val);
-  encodersProto021[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encodersProto021)(RegisterGlobalConstantSchema)(val);
-  encodersProto021[CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder(encodersProto021)(TransferTicketSchema)(val);
-  encodersProto021[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder(encodersProto021)(IncreasePaidStorageSchema)(val);
-  encodersProto021[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder(encodersProto021)(UpdateConsensusKeySchema)(val);
-  encodersProto021[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder(encodersProto021)(DrainDelegateSchema)(val);
-  encodersProto021[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder(encodersProto021)(SmartRollupOriginateSchema)(val);
-  encodersProto021[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder(encodersProto021)(SmartRollupAddMessagesSchema)(val);
-  encodersProto021[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder(encodersProto021)(SmartRollupExecuteOutboxMessageSchema)(val);
-  encodersProto021[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder(encodersProto021)(DalPublishCommitmentSchema)(val);
-  encodersProto021[CODEC.MANAGER] = schemaEncoder(encodersProto021)(ManagerOperationSchema);
-  encodersProto021[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder(encodersProto021)(SetDepositsLimitSchema)(val);
-  encodersProto021[CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder(encodersProto021)(FailingNoopSchema)(val);
+  encoders[CODEC.OPERATION] = operationEncoder(encoders);
+  encoders[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encoders)(ActivationSchema)(val);
+  encoders[CODEC.OP_DELEGATION] = (val) => schemaEncoder(encoders)(DelegationSchema)(val);
+  encoders[CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encoders)(TransactionSchema)(val);
+  encoders[CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encoders)(OriginationSchema)(val);
+  encoders[CODEC.OP_BALLOT] = (val) => schemaEncoder(encoders)(BallotSchema)(val);
+  encoders[CODEC.OP_ATTESTATION] = (val) => schemaEncoder(encoders)(AttestationSchema)(val);
+  encoders[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder(encoders)(AttestationWithDalSchema)(val);
+  encoders[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encoders)(SeedNonceRevelationSchema)(val);
+  encoders[CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encoders)(ProposalsSchema)(val);
+  encoders[CODEC.OP_REVEAL] = (val) => schemaEncoder(encoders)(RevealSchema)(val);
+  encoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encoders)(RegisterGlobalConstantSchema)(val);
+  encoders[CODEC.OP_TRANSFER_TICKET] = (val) => schemaEncoder(encoders)(TransferTicketSchema)(val);
+  encoders[CODEC.OP_INCREASE_PAID_STORAGE] = (val) => schemaEncoder(encoders)(IncreasePaidStorageSchema)(val);
+  encoders[CODEC.OP_UPDATE_CONSENSUS_KEY] = (val) => schemaEncoder(encoders)(UpdateConsensusKeySchema)(val);
+  encoders[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder(encoders)(DrainDelegateSchema)(val);
+  encoders[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder(encoders)(SmartRollupOriginateSchema)(val);
+  encoders[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder(encoders)(SmartRollupAddMessagesSchema)(val);
+  encoders[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder(encoders)(SmartRollupExecuteOutboxMessageSchema)(val);
+  encoders[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder(encoders)(DalPublishCommitmentSchema)(val);
+  encoders[CODEC.MANAGER] = schemaEncoder(encoders)(ManagerOperationSchema);
+  encoders[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder(encoders)(SetDepositsLimitSchema)(val);
+  encoders[CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder(encoders)(FailingNoopSchema)(val);
 
   const OperationKindMapping = {
       activate_account: ActivationSchema$1,
@@ -2660,6 +2955,7 @@
       transfer_ticket: TransferTicketSchema$1,
       increase_paid_storage: IncreasePaidStorageSchema$1,
       update_consensus_key: UpdateConsensusKeySchema$1,
+      update_companion_key: UpdateCompanionKeySchema,
       drain_delegate: DrainDelegateSchema$1,
       set_deposits_limit: SetDepositsLimitSchema$1,
       smart_rollup_originate: SmartRollupOriginateSchema$1,
@@ -2719,6 +3015,7 @@
       ProtocolsHash["PsParisCZ"] = "PsParisCZo7KAh1Z1smVd9ZMZ1HHn5gkzbM94V3PLCpknFWhUAi";
       ProtocolsHash["PsQuebecn"] = "PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg";
       ProtocolsHash["PsRiotuma"] = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7";
+      ProtocolsHash["PtSeouLou"] = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh";
       ProtocolsHash["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
   })(exports.ProtocolsHash || (exports.ProtocolsHash = {}));
   const protoLevel = {
@@ -2743,6 +3040,7 @@
       PsParisCZo7KAh1Z1smVd9ZMZ1HHn5gkzbM94V3PLCpknFWhUAi: 20,
       PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg: 21,
       PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7: 22,
+      PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh: 23,
       ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK: 23,
   };
   function ProtoInferiorTo(a, b) {
@@ -2751,32 +3049,32 @@
 
   // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
   const VERSION = {
-      "commitHash": "f0eb755ed1e0de4d1cd86623df4496f76efd0caf",
-      "version": "22.0.0-beta.0"
+      "commitHash": "13639ef56845fbb7e93bcbd37d3f6d0457b0872b",
+      "version": "23.0.0-RC.0"
   };
 
   /**
    * @packageDocumentation
    * @module @taquito/local-forging
    */
-  const PROTOCOL_CURRENT = exports.ProtocolsHash.PsRiotuma;
+  const PROTOCOL_CURRENT = exports.ProtocolsHash.PtSeouLou;
   function getCodec(codec, _proto) {
-      // use encodersProto021 & decodersProto021 if it's quebec or prior
-      if (_proto === exports.ProtocolsHash.PsQuebecn || ProtoInferiorTo(_proto, exports.ProtocolsHash.PsQuebecn)) {
+      // use encodersProto022 & decodersProto022 if it's rio or prior
+      if (_proto === exports.ProtocolsHash.PsRiotuma || ProtoInferiorTo(_proto, exports.ProtocolsHash.PsRiotuma)) {
           return {
-              encoder: encodersProto021[codec],
+              encoder: encoders[codec],
               decoder: (hex) => {
                   const consumer = Uint8ArrayConsumer.fromHexString(hex);
-                  return decodersProto021[codec](consumer);
+                  return decoders[codec](consumer);
               },
           };
       }
       else {
           return {
-              encoder: encoders[codec],
+              encoder: encoders$1[codec],
               decoder: (hex) => {
                   const consumer = Uint8ArrayConsumer.fromHexString(hex);
-                  return decoders[codec](consumer);
+                  return decoders$1[codec](consumer);
               },
           };
       }
@@ -2797,7 +3095,7 @@
       forge(params) {
           const branchValidation = utils.validateBlock(params.branch);
           if (branchValidation !== utils.ValidationResult.VALID) {
-              throw new core.InvalidBlockHashError(params.branch, utils.invalidDetail(branchValidation));
+              throw new core.InvalidBlockHashError(params.branch, branchValidation);
           }
           for (const content of params.contents) {
               if (!validateOperationKind(content.kind)) {
@@ -2823,6 +3121,12 @@
                   else if (content.kind === 'update_consensus_key' && diff[0] === 'proof') {
                       continue;
                   }
+                  else if (content.kind === 'update_companion_key' && diff[0] === 'proof') {
+                      continue;
+                  }
+                  else if (content.kind === 'reveal' && diff[0] === 'proof') {
+                      continue;
+                  }
                   else {
                       throw new InvalidOperationSchemaError(content, `missing properties "${diff.join(', ')}"`);
                   }
@@ -2843,12 +3147,12 @@
   exports.LocalForger = LocalForger;
   exports.Uint8ArrayConsumer = Uint8ArrayConsumer;
   exports.VERSION = VERSION;
-  exports.decoders = decoders;
-  exports.encoders = encoders;
+  exports.decoders = decoders$1;
+  exports.encoders = encoders$1;
   exports.getCodec = getCodec;
   exports.localForger = localForger;
   exports.opMapping = opMapping$1;
-  exports.opMappingReverse = opMappingReverse;
+  exports.opMappingReverse = opMappingReverse$1;
 
 }));
 //# sourceMappingURL=taquito-local-forging.umd.js.map