@taquito/utils 22.0.0-beta.0 → 23.0.0-RC.0

package/dist/taquito-utils.umd.js

@@ -1,10 +1,14 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('buffer'), require('@stablelib/ed25519'), require('@stablelib/blake2b'), require('blakejs'), require('bs58check'), require('@taquito/core'), require('bignumber.js'), require('elliptic'), require('typedarray-to-buffer')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'buffer', '@stablelib/ed25519', '@stablelib/blake2b', 'blakejs', 'bs58check', '@taquito/core', 'bignumber.js', 'elliptic', 'typedarray-to-buffer'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoUtils = {}, global.buffer, global.ed25519, global.blake2b, global.blake, global.bs58check, global.core, global.BigNumber, global.elliptic, global.toBuffer));
-})(this, (function (exports, buffer, ed25519, blake2b, blake, bs58check, core, BigNumber, elliptic, toBuffer) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('buffer'), require('@stablelib/blake2b'), require('bs58check'), require('bignumber.js'), require('typedarray-to-buffer'), require('@taquito/core'), require('@stablelib/ed25519'), require('elliptic'), require('@noble/curves/bls12-381')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'buffer', '@stablelib/blake2b', 'bs58check', 'bignumber.js', 'typedarray-to-buffer', '@taquito/core', '@stablelib/ed25519', 'elliptic', '@noble/curves/bls12-381'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoUtils = {}, global.buffer, global.blake2b, global.bs58check, global.BigNumber, global.toBuffer, global.core, global.ed25519, global.elliptic, global.bls12381));
+})(this, (function (exports, buffer, blake2b, bs58check, BigNumber, toBuffer, core, ed25519, elliptic, bls12381) { 'use strict';
 
   // ref https://gitlab.com/tezos/tezos/-/blob/master/src/lib_crypto/base58.ml
+  /**
+   * @deprecated use PrefixV2 instead, this enum will be removed in the next minor release
+   * @description base58 prefix definition enum
+   */
   exports.Prefix = void 0;
   (function (Prefix) {
       Prefix["TZ1"] = "tz1";
@@ -49,6 +53,10 @@
       Prefix["SRC1"] = "src1";
       Prefix["SH"] = "sh";
   })(exports.Prefix || (exports.Prefix = {}));
+  /**
+   * @deprecated use prefixV2 instead this constant will be removed in the next minor release
+   * @description base58 prefix to bytes mapping
+   */
   const prefix = {
       [exports.Prefix.TZ1]: new Uint8Array([6, 161, 159]),
       [exports.Prefix.TZ2]: new Uint8Array([6, 161, 161]),
@@ -93,6 +101,10 @@
       [exports.Prefix.SRC1]: new Uint8Array([17, 165, 134, 138]),
       [exports.Prefix.SH]: new Uint8Array([2, 116, 180]),
   };
+  /**
+   * @deprecated use payloadLength instead this constant will be removed in the next minor release
+   * @description base58 prefix to payload length mapping
+   */
   const prefixLength = {
       [exports.Prefix.TZ1]: 20,
       [exports.Prefix.TZ2]: 20,
@@ -120,200 +132,252 @@
       [exports.Prefix.SRC1]: 32,
       [exports.Prefix.SH]: 48,
   };
-
   /**
-   * @description Verify signature of a payload
-   *
-   * @param messageBytes The forged message including the magic byte (11 for block,
-   *        12 for preattestation, 13 for attestation, 3 for generic, 5 for the PACK format of michelson)
-   * @param publicKey The public key to verify the signature against
-   * @param signature The signature to verify
-   * @returns A boolean indicating if the signature matches
-   * @throws {@link InvalidPublicKeyError} | {@link InvalidSignatureError} | {@link InvalidMessageError}
-   * @example
-   * ```
-   * const message = '03d0c10e3ed11d7c6e3357f6ef335bab9e8f2bd54d0ce20c482e241191a6e4b8ce6c01be917311d9ac46959750e405d57e268e2ed9e174a80794fbd504e12a4a000141eb3781afed2f69679ff2bbe1c5375950b0e40d00ff000000005e05050505050507070100000024747a32526773486e74516b72794670707352466261313652546656503539684b72654a4d07070100000024747a315a6672455263414c42776d4171776f6e525859565142445439426a4e6a42484a750001';
-   * const pk = 'sppk7c7hkPj47yjYFEHX85q46sFJGw6RBrqoVSHwAJAT4e14KJwzoey';
-   * const sig = 'spsig1cdLkp1RLgUHAp13aRFkZ6MQDPp7xCnjAExGL3MBSdMDmT6JgQSX8cufyDgJRM3sinFtiCzLbsyP6d365EHoNevxhT47nx'
-   *
-   * const response = verifySignature(message, pk, sig);
-   * ```
-   *
+   * @description base58 name to prefix mapping
    */
-  function verifySignature(messageBytes, publicKey, signature, watermark) {
-      const pkPrefix = validatePkAndExtractPrefix(publicKey);
-      const sigPrefix = validateSigAndExtractPrefix(signature);
-      const decodedPublicKey = b58cdecode(publicKey, prefix[pkPrefix]);
-      const decodedSig = b58cdecode(signature, prefix[sigPrefix]);
-      let messageBuf = hex2buf(validateMessageNotEmpty(messageBytes));
-      if (typeof watermark !== 'undefined') {
-          messageBuf = mergebuf(watermark, messageBuf);
-      }
-      const bytesHash = blake2b.hash(messageBuf, 32);
-      if (pkPrefix === exports.Prefix.EDPK) {
-          return verifyEdSignature(decodedSig, bytesHash, decodedPublicKey);
-      }
-      else if (pkPrefix === exports.Prefix.SPPK) {
-          return verifySpSignature(decodedSig, bytesHash, decodedPublicKey);
-      }
-      else if (pkPrefix === exports.Prefix.P2PK) {
-          return verifyP2Signature(decodedSig, bytesHash, decodedPublicKey);
-      }
-      else {
-          return false;
-      }
-  }
-  function validateMessageNotEmpty(message) {
-      if (message === '') {
-          throw new core.InvalidMessageError(message, `can't be empty`);
-      }
-      return message;
-  }
-  function validatePkAndExtractPrefix(publicKey) {
-      if (publicKey === '') {
-          throw new core.InvalidPublicKeyError(publicKey, `can't be empty`);
-      }
-      const pkPrefix = publicKey.substring(0, 4);
-      const publicKeyValidation = validatePublicKey(publicKey);
-      if (publicKeyValidation !== exports.ValidationResult.VALID) {
-          throw new core.InvalidPublicKeyError(publicKey, invalidDetail(publicKeyValidation));
-      }
-      return pkPrefix;
-  }
-  function validateSigAndExtractPrefix(signature) {
-      const signaturePrefix = signature.startsWith('sig')
-          ? signature.substring(0, 3)
-          : signature.substring(0, 5);
-      const validation = validateSignature(signature);
-      if (validation !== exports.ValidationResult.VALID) {
-          throw new core.InvalidSignatureError(signature, invalidDetail(validation));
-      }
-      return signaturePrefix;
-  }
-  function verifyEdSignature(decodedSig, bytesHash, decodedPublicKey) {
-      try {
-          return ed25519.verify(decodedPublicKey, bytesHash, decodedSig);
-      }
-      catch (e) {
-          return false;
-      }
-  }
-  function verifySpSignature(decodedSig, bytesHash, decodedPublicKey) {
-      const key = new elliptic.ec('secp256k1').keyFromPublic(decodedPublicKey);
-      return verifySpOrP2Sig(decodedSig, bytesHash, key);
-  }
-  function verifyP2Signature(decodedSig, bytesHash, decodedPublicKey) {
-      const key = new elliptic.ec('p256').keyFromPublic(decodedPublicKey);
-      return verifySpOrP2Sig(decodedSig, bytesHash, key);
-  }
-  function verifySpOrP2Sig(decodedSig, bytesHash, key) {
-      const hexSig = buf2hex(toBuffer(decodedSig));
-      const match = hexSig.match(/([a-f\d]{64})/gi);
-      if (match) {
-          try {
-              const [r, s] = match;
-              return key.verify(bytesHash, { r, s });
-          }
-          catch (e) {
-              return false;
-          }
-      }
-      return false;
-  }
-
+  exports.PrefixV2 = void 0;
+  (function (PrefixV2) {
+      PrefixV2["BlockHash"] = "B";
+      PrefixV2["OperationHash"] = "o";
+      PrefixV2["OperationListHash"] = "Lo";
+      PrefixV2["OperationListListHash"] = "LLo";
+      PrefixV2["ProtocolHash"] = "P";
+      PrefixV2["ContextHash"] = "Co";
+      PrefixV2["BlockMetadataHash"] = "bm";
+      PrefixV2["OperationMetadataHash"] = "r";
+      PrefixV2["OperationMetadataListHash"] = "Lr";
+      PrefixV2["OperationMetadataListListHash"] = "LLr";
+      PrefixV2["Ed25519PublicKeyHash"] = "tz1";
+      PrefixV2["Secp256k1PublicKeyHash"] = "tz2";
+      PrefixV2["P256PublicKeyHash"] = "tz3";
+      PrefixV2["ContractHash"] = "KT1";
+      PrefixV2["BlindedPublicKeyHash"] = "btz1";
+      PrefixV2["BLS12_381PublicKeyHash"] = "tz4";
+      PrefixV2["TXRollupAddress"] = "txr1";
+      PrefixV2["ZkRollupHash"] = "epx1";
+      PrefixV2["ScRollupHash"] = "scr1";
+      PrefixV2["SmartRollupHash"] = "sr1";
+      PrefixV2["CryptoboxPublicKeyHash"] = "id";
+      PrefixV2["Ed25519Seed"] = "edsk";
+      PrefixV2["Ed25519PublicKey"] = "edpk";
+      PrefixV2["Secp256k1SecretKey"] = "spsk";
+      PrefixV2["P256SecretKey"] = "p2sk";
+      PrefixV2["BLS12_381SecretKey"] = "BLsk";
+      PrefixV2["ValueHash"] = "vh";
+      PrefixV2["CycleNonce"] = "nce";
+      PrefixV2["ScriptExpr"] = "expr";
+      PrefixV2["InboxHash"] = "txi";
+      PrefixV2["MessageHash"] = "txm";
+      PrefixV2["CommitmentHash"] = "txc";
+      PrefixV2["MessageResultHash"] = "txmr";
+      PrefixV2["MessageResultListHash"] = "txM";
+      PrefixV2["WithdrawListHash"] = "txw";
+      PrefixV2["ScRollupStateHash"] = "scs1";
+      PrefixV2["ScRollupCommitmentHash"] = "scc1";
+      PrefixV2["SmartRollupStateHash"] = "srs1";
+      PrefixV2["SmartRollupCommitmentHash"] = "src1";
+      PrefixV2["Ed25519EncryptedSeed"] = "edesk";
+      PrefixV2["Secp256k1EncryptedSecretKey"] = "spesk";
+      PrefixV2["P256EncryptedSecretKey"] = "p2esk";
+      PrefixV2["BLS12_381EncryptedSecretKey"] = "BLesk";
+      PrefixV2["Secp256k1EncryptedScalar"] = "seesk";
+      PrefixV2["Secp256k1PublicKey"] = "sppk";
+      PrefixV2["P256PublicKey"] = "p2pk";
+      PrefixV2["Secp256k1Scalar"] = "SSp";
+      PrefixV2["Secp256k1Element"] = "GSp";
+      PrefixV2["Ed25519SecretKey"] = "_edsk";
+      PrefixV2["Ed25519Signature"] = "edsig";
+      PrefixV2["Secp256k1Signature"] = "spsig1";
+      PrefixV2["P256Signature"] = "p2sig";
+      PrefixV2["GenericSignature"] = "sig";
+      PrefixV2["ChainID"] = "Net";
+      PrefixV2["SaplingSpendingKey"] = "sask";
+      PrefixV2["EncryptedSaplingSpendingKey"] = "_sask";
+      PrefixV2["SaplingAddress"] = "zet1";
+      PrefixV2["GenericAggregateSignature"] = "asig";
+      PrefixV2["BLS12_381Signature"] = "BLsig";
+      PrefixV2["BLS12_381PublicKey"] = "BLpk";
+      PrefixV2["SlotHeader"] = "sh";
+  })(exports.PrefixV2 || (exports.PrefixV2 = {}));
   /**
-   *  @category Error
-   *  @description Error that indicates invalid protocol hash being passed or used
+   * @description base58 prefix to bytes mapping
    */
-  class InvalidProtocolHashError extends core.ParameterValidationError {
-      constructor(protocolHash, errorDetails) {
-          super();
-          this.protocolHash = protocolHash;
-          this.errorDetails = errorDetails;
-          this.name = 'InvalidProtocolHashError';
-          this.name = 'InvalidProtocolHashError';
-          this.message = `The protocol hash '${protocolHash}' is invalid`;
-          errorDetails ? (this.message += `: ${errorDetails}`) : null;
-      }
-  }
+  const prefixV2 = {
+      [exports.PrefixV2.BlockHash]: new Uint8Array([1, 52]),
+      [exports.PrefixV2.OperationHash]: new Uint8Array([5, 116]),
+      [exports.PrefixV2.OperationListHash]: new Uint8Array([133, 233]),
+      [exports.PrefixV2.OperationListListHash]: new Uint8Array([29, 159, 109]),
+      [exports.PrefixV2.ProtocolHash]: new Uint8Array([2, 170]),
+      [exports.PrefixV2.ContextHash]: new Uint8Array([79, 199]),
+      [exports.PrefixV2.BlockMetadataHash]: new Uint8Array([234, 249]),
+      [exports.PrefixV2.OperationMetadataHash]: new Uint8Array([5, 183]),
+      [exports.PrefixV2.OperationMetadataListHash]: new Uint8Array([134, 39]),
+      [exports.PrefixV2.OperationMetadataListListHash]: new Uint8Array([29, 159, 182]),
+      [exports.PrefixV2.Ed25519PublicKeyHash]: new Uint8Array([6, 161, 159]),
+      [exports.PrefixV2.Secp256k1PublicKeyHash]: new Uint8Array([6, 161, 161]),
+      [exports.PrefixV2.P256PublicKeyHash]: new Uint8Array([6, 161, 164]),
+      [exports.PrefixV2.ContractHash]: new Uint8Array([2, 90, 121]),
+      [exports.PrefixV2.BlindedPublicKeyHash]: new Uint8Array([1, 2, 49, 223]),
+      [exports.PrefixV2.BLS12_381PublicKeyHash]: new Uint8Array([6, 161, 166]),
+      [exports.PrefixV2.TXRollupAddress]: new Uint8Array([1, 128, 120, 31]),
+      [exports.PrefixV2.ZkRollupHash]: new Uint8Array([1, 23, 224, 125]),
+      [exports.PrefixV2.ScRollupHash]: new Uint8Array([1, 118, 132, 217]),
+      [exports.PrefixV2.SmartRollupHash]: new Uint8Array([6, 124, 117]),
+      [exports.PrefixV2.CryptoboxPublicKeyHash]: new Uint8Array([153, 103]),
+      [exports.PrefixV2.Ed25519Seed]: new Uint8Array([13, 15, 58, 7]),
+      [exports.PrefixV2.Ed25519PublicKey]: new Uint8Array([13, 15, 37, 217]),
+      [exports.PrefixV2.Secp256k1SecretKey]: new Uint8Array([17, 162, 224, 201]),
+      [exports.PrefixV2.P256SecretKey]: new Uint8Array([16, 81, 238, 189]),
+      [exports.PrefixV2.BLS12_381SecretKey]: new Uint8Array([3, 150, 192, 40]),
+      [exports.PrefixV2.ValueHash]: new Uint8Array([1, 106, 242]),
+      [exports.PrefixV2.CycleNonce]: new Uint8Array([69, 220, 169]),
+      [exports.PrefixV2.ScriptExpr]: new Uint8Array([13, 44, 64, 27]),
+      [exports.PrefixV2.InboxHash]: new Uint8Array([79, 148, 196]),
+      [exports.PrefixV2.MessageHash]: new Uint8Array([79, 149, 30]),
+      [exports.PrefixV2.CommitmentHash]: new Uint8Array([79, 148, 17]),
+      [exports.PrefixV2.MessageResultHash]: new Uint8Array([18, 7, 206, 87]),
+      [exports.PrefixV2.MessageResultListHash]: new Uint8Array([79, 146, 82]),
+      [exports.PrefixV2.WithdrawListHash]: new Uint8Array([79, 150, 72]),
+      [exports.PrefixV2.ScRollupStateHash]: new Uint8Array([17, 144, 122, 202]),
+      [exports.PrefixV2.ScRollupCommitmentHash]: new Uint8Array([17, 144, 21, 100]),
+      [exports.PrefixV2.SmartRollupStateHash]: new Uint8Array([17, 165, 235, 240]),
+      [exports.PrefixV2.SmartRollupCommitmentHash]: new Uint8Array([17, 165, 134, 138]),
+      [exports.PrefixV2.Ed25519EncryptedSeed]: new Uint8Array([7, 90, 60, 179, 41]),
+      [exports.PrefixV2.Secp256k1EncryptedSecretKey]: new Uint8Array([9, 237, 241, 174, 150]),
+      [exports.PrefixV2.P256EncryptedSecretKey]: new Uint8Array([9, 48, 57, 115, 171]),
+      [exports.PrefixV2.BLS12_381EncryptedSecretKey]: new Uint8Array([2, 5, 30, 53, 25]),
+      [exports.PrefixV2.Secp256k1EncryptedScalar]: new Uint8Array([1, 131, 36, 86, 248]),
+      [exports.PrefixV2.Secp256k1PublicKey]: new Uint8Array([3, 254, 226, 86]),
+      [exports.PrefixV2.P256PublicKey]: new Uint8Array([3, 178, 139, 127]),
+      [exports.PrefixV2.Secp256k1Scalar]: new Uint8Array([38, 248, 136]),
+      [exports.PrefixV2.Secp256k1Element]: new Uint8Array([5, 92, 0]),
+      [exports.PrefixV2.Ed25519SecretKey]: new Uint8Array([43, 246, 78, 7]),
+      [exports.PrefixV2.Ed25519Signature]: new Uint8Array([9, 245, 205, 134, 18]),
+      [exports.PrefixV2.Secp256k1Signature]: new Uint8Array([13, 115, 101, 19, 63]),
+      [exports.PrefixV2.P256Signature]: new Uint8Array([54, 240, 44, 52]),
+      [exports.PrefixV2.GenericSignature]: new Uint8Array([4, 130, 43]),
+      [exports.PrefixV2.ChainID]: new Uint8Array([87, 82, 0]),
+      [exports.PrefixV2.SaplingSpendingKey]: new Uint8Array([11, 237, 20, 92]),
+      [exports.PrefixV2.EncryptedSaplingSpendingKey]: new Uint8Array([11, 237, 20, 92]),
+      [exports.PrefixV2.SaplingAddress]: new Uint8Array([18, 71, 40, 223]),
+      [exports.PrefixV2.GenericAggregateSignature]: new Uint8Array([2, 75, 234, 101]),
+      [exports.PrefixV2.BLS12_381Signature]: new Uint8Array([40, 171, 64, 207]),
+      [exports.PrefixV2.BLS12_381PublicKey]: new Uint8Array([6, 149, 135, 204]),
+      [exports.PrefixV2.SlotHeader]: new Uint8Array([2, 116, 180]),
+  };
   /**
-   *  @category Error
-   *  @description Error that indicates unable to convert data type from one to another
+   * @description base58 prefix to payload length mapping
    */
-  class ValueConversionError extends core.UnsupportedActionError {
-      constructor(value, desiredType) {
-          super();
-          this.value = value;
-          this.desiredType = desiredType;
-          this.name = 'ValueConversionError';
-          this.message = `Unable to convert ${value} to a ${desiredType}`;
-      }
-  }
+  const payloadLength = {
+      [exports.PrefixV2.BlockHash]: 32,
+      [exports.PrefixV2.OperationHash]: 32,
+      [exports.PrefixV2.OperationListHash]: 32,
+      [exports.PrefixV2.OperationListListHash]: 32,
+      [exports.PrefixV2.ProtocolHash]: 32,
+      [exports.PrefixV2.ContextHash]: 32,
+      [exports.PrefixV2.BlockMetadataHash]: 32,
+      [exports.PrefixV2.OperationMetadataHash]: 32,
+      [exports.PrefixV2.OperationMetadataListHash]: 32,
+      [exports.PrefixV2.OperationMetadataListListHash]: 32,
+      [exports.PrefixV2.Ed25519PublicKeyHash]: 20,
+      [exports.PrefixV2.Secp256k1PublicKeyHash]: 20,
+      [exports.PrefixV2.P256PublicKeyHash]: 20,
+      [exports.PrefixV2.ContractHash]: 20,
+      [exports.PrefixV2.BlindedPublicKeyHash]: 20,
+      [exports.PrefixV2.BLS12_381PublicKeyHash]: 20,
+      [exports.PrefixV2.TXRollupAddress]: 20,
+      [exports.PrefixV2.ZkRollupHash]: 20,
+      [exports.PrefixV2.ScRollupHash]: 20,
+      [exports.PrefixV2.SmartRollupHash]: 20,
+      [exports.PrefixV2.CryptoboxPublicKeyHash]: 16,
+      [exports.PrefixV2.Ed25519Seed]: 32,
+      [exports.PrefixV2.Ed25519PublicKey]: 32,
+      [exports.PrefixV2.Secp256k1SecretKey]: 32,
+      [exports.PrefixV2.P256SecretKey]: 32,
+      [exports.PrefixV2.BLS12_381SecretKey]: 32,
+      [exports.PrefixV2.ValueHash]: 32,
+      [exports.PrefixV2.CycleNonce]: 32,
+      [exports.PrefixV2.ScriptExpr]: 32,
+      [exports.PrefixV2.InboxHash]: 32,
+      [exports.PrefixV2.MessageHash]: 32,
+      [exports.PrefixV2.CommitmentHash]: 32,
+      [exports.PrefixV2.MessageResultHash]: 32,
+      [exports.PrefixV2.MessageResultListHash]: 32,
+      [exports.PrefixV2.WithdrawListHash]: 32,
+      [exports.PrefixV2.ScRollupStateHash]: 32,
+      [exports.PrefixV2.ScRollupCommitmentHash]: 32,
+      [exports.PrefixV2.SmartRollupStateHash]: 32,
+      [exports.PrefixV2.SmartRollupCommitmentHash]: 32,
+      [exports.PrefixV2.Ed25519EncryptedSeed]: 56,
+      [exports.PrefixV2.Secp256k1EncryptedSecretKey]: 56,
+      [exports.PrefixV2.P256EncryptedSecretKey]: 56,
+      [exports.PrefixV2.BLS12_381EncryptedSecretKey]: 56,
+      [exports.PrefixV2.Secp256k1EncryptedScalar]: 60,
+      [exports.PrefixV2.Secp256k1PublicKey]: 33,
+      [exports.PrefixV2.P256PublicKey]: 33,
+      [exports.PrefixV2.Secp256k1Scalar]: 33,
+      [exports.PrefixV2.Secp256k1Element]: 33,
+      [exports.PrefixV2.Ed25519SecretKey]: 64,
+      [exports.PrefixV2.Ed25519Signature]: 64,
+      [exports.PrefixV2.Secp256k1Signature]: 64,
+      [exports.PrefixV2.P256Signature]: 64,
+      [exports.PrefixV2.GenericSignature]: 64,
+      [exports.PrefixV2.ChainID]: 4,
+      [exports.PrefixV2.SaplingSpendingKey]: 169,
+      [exports.PrefixV2.EncryptedSaplingSpendingKey]: 193,
+      [exports.PrefixV2.SaplingAddress]: 43,
+      [exports.PrefixV2.GenericAggregateSignature]: 96,
+      [exports.PrefixV2.BLS12_381Signature]: 96,
+      [exports.PrefixV2.BLS12_381PublicKey]: 48,
+      [exports.PrefixV2.SlotHeader]: 48,
+  };
 
-  exports.ValidationResult = void 0;
-  (function (ValidationResult) {
-      ValidationResult[ValidationResult["NO_PREFIX_MATCHED"] = 0] = "NO_PREFIX_MATCHED";
-      ValidationResult[ValidationResult["INVALID_CHECKSUM"] = 1] = "INVALID_CHECKSUM";
-      ValidationResult[ValidationResult["INVALID_LENGTH"] = 2] = "INVALID_LENGTH";
-      ValidationResult[ValidationResult["VALID"] = 3] = "VALID";
-  })(exports.ValidationResult || (exports.ValidationResult = {}));
-  function isValidPrefix(value) {
-      if (typeof value !== 'string') {
-          return false;
-      }
-      return value in prefix;
+  /**
+   * @description Used to check if a value has one of the allowed prefixes.
+   * @returns true if the value has one of the allowed prefixes, false otherwise
+   * @example
+   * ```
+   * import { isValidPrefixedValue } from '@taquito/utils';
+   * const value = 'tz1L9r8mWmRPndRhuvMCWESLGSVeFzQ9NAWx'
+   * const isValid = isValidPrefixedValue(value, [PrefixV2.Ed25519PublicKeyHash])
+   * console.log(isValid) // true
+   * ```
+   */
+  function isValidPrefixedValue(value, prefixes) {
+      return validatePrefixedValue(value, prefixes) === core.ValidationResult.VALID;
   }
   /**
    * @description This function is called by the validation functions ([[validateAddress]], [[validateChain]], [[validateContractAddress]], [[validateKeyHash]], [[validateSignature]], [[validatePublicKey]]).
-   * Verify if the value has the right prefix or return `NO_PREFIX_MATCHED`,
-   * decode the value using base58 and return `INVALID_CHECKSUM` if it fails,
-   * check if the length of the value matches the prefix type or return `INVALID_LENGTH`.
-   * If all checks pass, return `VALID`.
-   *
+   * Verify if the value can be decoded or return `1` (INVALID_CHECKSUM) / `5` (INVALID_ENCODING), then check if the prefix is valid or allowed or return `0` (NO_PREFIX_MATCHED) / `4` (PREFIX_NOT_ALLOWED)
+   * If all checks pass, return `3` (VALID).
    * @param value Value to validate
    * @param prefixes prefix the value should have
+   * @returns 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+   * @example
+   * ```
+   * import { validatePrefixedValue } from '@taquito/utils';
+   * const value = 'tz1L9r8mWmRPndRhuvMCWESLGSVeFzQ9NAWx'
+   * const validation = validatePrefixedValue(value, [PrefixV2.Ed25519PublicKeyHash])
+   * console.log(validation) // 3
+   * ```
    */
   function validatePrefixedValue(value, prefixes) {
-      const match = new RegExp(`^(${prefixes.join('|')})`).exec(value);
-      if (!match || match.length === 0) {
-          return exports.ValidationResult.NO_PREFIX_MATCHED;
-      }
-      const prefixKey = match[0];
-      if (!isValidPrefix(prefixKey)) {
-          return exports.ValidationResult.NO_PREFIX_MATCHED;
-      }
-      // Check whether annotation exist before starting validation
-      if (value.includes('%')) {
-          value = value.split('%')[0];
-      }
-      const kt1Regex = /^(KT1\w{33})$/;
-      if (!kt1Regex.test(value) && prefixKey === 'KT1') {
-          return exports.ValidationResult.INVALID_CHECKSUM;
-      }
-      // decodeUnsafe return undefined if decoding fail
-      let decoded = bs58check.decodeUnsafe(value);
-      if (!decoded) {
-          return exports.ValidationResult.INVALID_CHECKSUM;
+      try {
+          b58DecodeAndCheckPrefix(value, prefixes);
       }
-      decoded = decoded.slice(prefix[prefixKey].length);
-      if (decoded.length !== prefixLength[prefixKey]) {
-          return exports.ValidationResult.INVALID_LENGTH;
+      catch (err) {
+          if (err instanceof core.ParameterValidationError && err.result !== undefined) {
+              return err.result;
+          }
+          return core.ValidationResult.OTHER;
       }
-      return exports.ValidationResult.VALID;
+      return core.ValidationResult.VALID;
   }
-  const implicitPrefix = [exports.Prefix.TZ1, exports.Prefix.TZ2, exports.Prefix.TZ3, exports.Prefix.TZ4];
-  const contractPrefix = [exports.Prefix.KT1];
-  const signaturePrefix = [exports.Prefix.EDSIG, exports.Prefix.P2SIG, exports.Prefix.SPSIG, exports.Prefix.SIG];
-  const pkPrefix = [exports.Prefix.EDPK, exports.Prefix.SPPK, exports.Prefix.P2PK, exports.Prefix.BLPK];
-  const operationPrefix = [exports.Prefix.O];
-  const protocolPrefix = [exports.Prefix.P];
-  const blockPrefix = [exports.Prefix.B];
-  const smartRollupPrefix = [exports.Prefix.SR1];
   /**
    * @description Used to check if an address or a contract address is valid.
    *
    * @returns
-   * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+   * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
    *
    * @example
    * ```
@@ -325,13 +389,14 @@
    * ```
    */
   function validateAddress(value) {
-      return validatePrefixedValue(value, [...implicitPrefix, ...contractPrefix, ...smartRollupPrefix]);
+      const [addr] = splitAddress(value !== null && value !== void 0 ? value : '');
+      return validatePrefixedValue(addr, addressPrefixes);
   }
   /**
    * @description Used to check if a chain id is valid.
    *
    * @returns
-   * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+   * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
    *
    * @example
    * ```
@@ -343,13 +408,13 @@
    * ```
    */
   function validateChain(value) {
-      return validatePrefixedValue(value, [exports.Prefix.NET]);
+      return validatePrefixedValue(value, [exports.PrefixV2.ChainID]);
   }
   /**
    * @description Used to check if a contract address is valid.
    *
    * @returns
-   * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+   * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
    *
    * @example
    * ```
@@ -361,13 +426,13 @@
    * ```
    */
   function validateContractAddress(value) {
-      return validatePrefixedValue(value, contractPrefix);
+      return validatePrefixedValue(value, [exports.PrefixV2.ContractHash]);
   }
   /**
    * @description Used to check if a key hash is valid.
    *
    * @returns
-   * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+   * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
    *
    * @example
    * ```
@@ -379,13 +444,13 @@
    * ```
    */
   function validateKeyHash(value) {
-      return validatePrefixedValue(value, implicitPrefix);
+      return validatePrefixedValue(value, publicKeyHashPrefixes);
   }
   /**
    * @description Used to check if a signature is valid.
    *
    * @returns
-   * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+   * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
    *
    * @example
    * ```
@@ -397,13 +462,13 @@
    * ```
    */
   function validateSignature(value) {
-      return validatePrefixedValue(value, signaturePrefix);
+      return validatePrefixedValue(value, signaturePrefixes);
   }
   /**
    * @description Used to check if a public key is valid.
    *
    * @returns
-   * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+   * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
    *
    * @example
    * ```
@@ -415,13 +480,13 @@
    * ```
    */
   function validatePublicKey(value) {
-      return validatePrefixedValue(value, pkPrefix);
+      return validatePrefixedValue(value, publicKeyPrefixes);
   }
   /**
    * @description Used to check if an operation hash is valid.
    *
    * @returns
-   * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+   * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
    *
    * @example
    * ```
@@ -433,13 +498,13 @@
    * ```
    */
   function validateOperation(value) {
-      return validatePrefixedValue(value, operationPrefix);
+      return validatePrefixedValue(value, [exports.PrefixV2.OperationHash]);
   }
   /**
    * @description Used to check if a protocol hash is valid.
    *
    * @returns
-   * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+   * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
    *
    * @example
    * ```
@@ -451,13 +516,13 @@
    * ```
    */
   function validateProtocol(value) {
-      return validatePrefixedValue(value, protocolPrefix);
+      return validatePrefixedValue(value, [exports.PrefixV2.ProtocolHash]);
   }
   /**
    * @description Used to check if a block hash is valid.
    *
    * @returns
-   * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+   * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
    *
    * @example
    * ```
@@ -469,38 +534,209 @@
    * ```
    */
   function validateBlock(value) {
-      return validatePrefixedValue(value, blockPrefix);
+      return validatePrefixedValue(value, [exports.PrefixV2.BlockHash]);
   }
   /**
-   * @description Used to check if a spending key is valid.
-   * @returns 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
-   *
+   * @deprecated this function will be removed in the next minor release
+   * @description generates a readable error string from a validation result
    */
-  function validateSpendingKey(value) {
-      return validatePrefixedValue(value, [exports.Prefix.SASK]);
-  }
   function invalidDetail(validation) {
       switch (validation) {
-          case exports.ValidationResult.NO_PREFIX_MATCHED:
+          case core.ValidationResult.NO_PREFIX_MATCHED:
               return 'with unsupported prefix';
-          case exports.ValidationResult.INVALID_CHECKSUM:
+          case core.ValidationResult.INVALID_CHECKSUM:
               return 'failed checksum';
-          case exports.ValidationResult.INVALID_LENGTH:
+          case core.ValidationResult.INVALID_LENGTH:
               return 'with incorrect length';
           default:
               return '';
       }
   }
+  /**
+   * @description Used to check if a spending key is valid.
+   * @returns
+   * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+   *
+   */
+  function validateSpendingKey(value) {
+      return validatePrefixedValue(value, [exports.PrefixV2.SaplingSpendingKey]);
+  }
   function validateSmartRollupAddress(value) {
-      return validatePrefixedValue(value, [...smartRollupPrefix]);
+      return validatePrefixedValue(value, [exports.PrefixV2.SmartRollupHash]);
   }
 
   // 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"
   };
 
+  const BLS12_381_DST = 'BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_';
+  const POP_DST = 'BLS_POP_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_';
+  /**
+   * @description Verify signature of a payload
+   * @param message The forged message including the magic byte (11 for block, 12 for preattestation, 13 for attestation, 3 for generic, 5 for the PACK format of michelson) in string or Uint8Array
+   * @param publicKey The public key to verify the signature against
+   * @param signature The signature to verify
+   * @param watermark Optional if not included in the message
+   * @param pop Optional if verifying proof of possession signature
+   * @returns A boolean indicating if the signature matches
+   * @throws {@link InvalidPublicKeyError} | {@link InvalidSignatureError} | {@link InvalidMessageError}
+   * @example
+   * ```
+   * const message = '03d0c10e3ed11d7c6e3357f6ef335bab9e8f2bd54d0ce20c482e241191a6e4b8ce6c01be917311d9ac46959750e405d57e268e2ed9e174a80794fbd504e12a4a000141eb3781afed2f69679ff2bbe1c5375950b0e40d00ff000000005e05050505050507070100000024747a32526773486e74516b72794670707352466261313652546656503539684b72654a4d07070100000024747a315a6672455263414c42776d4171776f6e525859565142445439426a4e6a42484a750001';
+   * const pk = 'sppk7c7hkPj47yjYFEHX85q46sFJGw6RBrqoVSHwAJAT4e14KJwzoey';
+   * const sig = 'spsig1cdLkp1RLgUHAp13aRFkZ6MQDPp7xCnjAExGL3MBSdMDmT6JgQSX8cufyDgJRM3sinFtiCzLbsyP6d365EHoNevxhT47nx'
+   *
+   * const response = verifySignature(message, pk, sig);
+   * ```
+   *
+   */
+  function verifySignature(message, publicKey, signature, watermark, pop) {
+      const [pk, pre] = (() => {
+          try {
+              return b58DecodeAndCheckPrefix(publicKey, publicKeyPrefixes);
+          }
+          catch (err) {
+              if (err instanceof core.ParameterValidationError) {
+                  throw new core.InvalidPublicKeyError(publicKey, err.result);
+              }
+              else {
+                  throw err;
+              }
+          }
+      })();
+      const sig = (() => {
+          try {
+              const [sig] = b58DecodeAndCheckPrefix(signature, signaturePrefixes);
+              return sig;
+          }
+          catch (err) {
+              if (err instanceof core.ParameterValidationError) {
+                  throw new core.InvalidSignatureError(signature, err.result);
+              }
+              else {
+                  throw err;
+              }
+          }
+      })();
+      let msg;
+      if (typeof message === 'string') {
+          msg = hex2buf(message);
+      }
+      else {
+          msg = message;
+      }
+      if (msg.length === 0) {
+          throw new core.InvalidMessageError(buf2hex(msg), `can't be empty`);
+      }
+      if (typeof watermark !== 'undefined') {
+          msg = mergebuf(watermark, msg);
+      }
+      if (pop) {
+          return verifyBLSPopSignature(sig, msg, pk);
+      }
+      else {
+          switch (pre) {
+              case exports.PrefixV2.P256PublicKey:
+                  return verifyP2Signature(sig, msg, pk);
+              case exports.PrefixV2.Secp256k1PublicKey:
+                  return verifySpSignature(sig, msg, pk);
+              case exports.PrefixV2.Ed25519PublicKey:
+                  return verifyEdSignature(sig, msg, pk);
+              default:
+                  return verifyBLSSignature(sig, msg, pk);
+          }
+      }
+  }
+  /**
+   * @deprecated use b58DecodeAndCheckPrefix instead, this function will be removed in the next minor release
+   * @description validates a public key and extracts the prefix
+   */
+  function validatePkAndExtractPrefix(publicKey) {
+      if (publicKey === '') {
+          throw new core.InvalidPublicKeyError(publicKey, `can't be empty`);
+      }
+      const pkPrefix = publicKey.substring(0, 4);
+      const publicKeyValidation = validatePublicKey(publicKey);
+      if (publicKeyValidation !== core.ValidationResult.VALID) {
+          throw new core.InvalidPublicKeyError(publicKey, invalidDetail(publicKeyValidation));
+      }
+      return pkPrefix;
+  }
+  function verifyEdSignature(sig, msg, publicKey) {
+      const hash = blake2b.hash(msg, 32);
+      try {
+          return ed25519.verify(publicKey, hash, sig);
+      }
+      catch (_a) {
+          return false;
+      }
+  }
+  function verifySpSignature(sig, msg, publicKey) {
+      const key = new elliptic.ec('secp256k1').keyFromPublic(publicKey);
+      return verifySpOrP2Sig(sig, msg, key);
+  }
+  function verifyP2Signature(sig, msg, publicKey) {
+      const key = new elliptic.ec('p256').keyFromPublic(publicKey);
+      return verifySpOrP2Sig(sig, msg, key);
+  }
+  function verifySpOrP2Sig(sig, msg, key) {
+      const r = sig.slice(0, 32);
+      const s = sig.slice(32);
+      const hash = blake2b.hash(msg, 32);
+      try {
+          return key.verify(hash, { r, s });
+      }
+      catch (_a) {
+          return false;
+      }
+  }
+  const bls = bls12381.bls12_381.longSignatures; // AKA MinPK
+  function verifyBLSSignature(sig, msg, publicKey) {
+      try {
+          const point = bls.hash(msg, BLS12_381_DST);
+          return bls.verify(sig, point, publicKey);
+      }
+      catch (_a) {
+          return false;
+      }
+  }
+  function verifyBLSPopSignature(sig, msg, publicKey) {
+      try {
+          const point = bls.hash(msg, POP_DST);
+          return bls.verify(sig, point, publicKey);
+      }
+      catch (_a) {
+          return false;
+      }
+  }
+
+  /**
+   *  @category Error
+   *  @description Error that indicates invalid protocol hash being passed or used
+   */
+  class InvalidProtocolHashError extends core.ParameterValidationError {
+      constructor(protocolHash, errorDetails) {
+          super(`The protocol hash '${protocolHash}' is invalid`, errorDetails);
+          this.protocolHash = protocolHash;
+          this.name = 'InvalidProtocolHashError';
+          this.name = this.constructor.name;
+      }
+  }
+  /**
+   *  @category Error
+   *  @description Error that indicates unable to convert data type from one to another
+   */
+  class ValueConversionError extends core.UnsupportedActionError {
+      constructor(value, desiredType) {
+          super(`Unable to convert ${value} to a ${desiredType}`);
+          this.value = value;
+          this.desiredType = desiredType;
+          this.name = this.constructor.name;
+      }
+  }
+
   const TZ_DECIMALS = 6;
   const MTZ_DECIMALS = 3;
   function getDecimal(format) {
@@ -534,222 +770,421 @@
    * Copyright (c) 2017 Stephen Andrews
    */
   /**
-   *
-   * @description Hash a string using the BLAKE2b algorithm, base58 encode the hash obtained and appends the prefix 'expr' to it
-   *
-   * @param value Value in hex
+   * @description list of prefixes that can be used to decode an address
    */
-  function encodeExpr(value) {
-      const blakeHash = blake.blake2b(hex2buf(value), undefined, 32);
-      return b58cencode(blakeHash, prefix['expr']);
-  }
+  const addressPrefixes = [
+      exports.PrefixV2.P256PublicKeyHash,
+      exports.PrefixV2.Secp256k1PublicKeyHash,
+      exports.PrefixV2.Ed25519PublicKeyHash,
+      exports.PrefixV2.BLS12_381PublicKeyHash,
+      exports.PrefixV2.ContractHash,
+      exports.PrefixV2.SmartRollupHash,
+      // PrefixV2.ZkRollupHash,
+  ];
   /**
-   *
-   * @description Return the operation hash of a signed operation
-   * @param value Value in hex of a signed operation
+   * @description list of prefixes that can be used to decode a public key
    */
-  function encodeOpHash(value) {
-      const blakeHash = blake.blake2b(hex2buf(value), undefined, 32);
-      return b58cencode(blakeHash, prefix.o);
+  const publicKeyPrefixes = [
+      exports.PrefixV2.P256PublicKey,
+      exports.PrefixV2.Secp256k1PublicKey,
+      exports.PrefixV2.Ed25519PublicKey,
+      exports.PrefixV2.BLS12_381PublicKey,
+  ];
+  /**
+   * @description list of prefixes that can be used to decode a public key hash
+   */
+  const publicKeyHashPrefixes = [
+      exports.PrefixV2.P256PublicKeyHash,
+      exports.PrefixV2.Secp256k1PublicKeyHash,
+      exports.PrefixV2.Ed25519PublicKeyHash,
+      exports.PrefixV2.BLS12_381PublicKeyHash,
+  ];
+  /**
+   * @description list of prefixes that can be used to decode a signature
+   */
+  const signaturePrefixes = [
+      exports.PrefixV2.P256Signature,
+      exports.PrefixV2.Secp256k1Signature,
+      exports.PrefixV2.Ed25519Signature,
+      exports.PrefixV2.BLS12_381Signature,
+      exports.PrefixV2.GenericSignature,
+  ];
+  function b58DecodeAndCheckPrefix(src, allowed, payloadOnly) {
+      const buf = (() => {
+          try {
+              return bs58check.decode(src);
+          }
+          catch (err) {
+              if (err instanceof Error) {
+                  if (err.message.includes('checksum')) {
+                      throw new core.ParameterValidationError(core.ValidationResult.INVALID_CHECKSUM);
+                  }
+                  else {
+                      throw new core.ParameterValidationError(core.ValidationResult.INVALID_ENCODING);
+                  }
+              }
+              else {
+                  throw err;
+              }
+          }
+      })();
+      let key;
+      for (key in exports.PrefixV2) {
+          const p = exports.PrefixV2[key];
+          const pre = prefixV2[p];
+          if (buf.length === pre.length + payloadLength[p] &&
+              buf.slice(0, pre.length).every((v, i) => v == pre[i])) {
+              if (allowed !== undefined && allowed.indexOf(p) < 0) {
+                  throw new core.ParameterValidationError(core.ValidationResult.PREFIX_NOT_ALLOWED);
+              }
+              if (payloadOnly) {
+                  return buf.slice(pre.length);
+              }
+              else {
+                  return [buf.slice(pre.length), p];
+              }
+          }
+      }
+      throw new core.ParameterValidationError(core.ValidationResult.NO_PREFIX_MATCHED);
+  }
+  function b58DecodePublicKey(value, fmt) {
+      const [data, pre] = b58DecodeAndCheckPrefix(value, publicKeyPrefixes);
+      let tag;
+      switch (pre) {
+          case exports.PrefixV2.Ed25519PublicKey:
+              tag = 0;
+              break;
+          case exports.PrefixV2.Secp256k1PublicKey:
+              tag = 1;
+              break;
+          case exports.PrefixV2.P256PublicKey:
+              tag = 2;
+              break;
+          case exports.PrefixV2.BLS12_381PublicKey:
+              tag = 3;
+              break;
+          default:
+              throw new core.InvalidKeyError(core.ValidationResult.NO_PREFIX_MATCHED);
+      }
+      const buf = new Uint8Array(data.length + 1);
+      buf[0] = tag;
+      buf.set(data, 1);
+      if (fmt !== undefined && fmt === 'array') {
+          return buf;
+      }
+      else {
+          return buf2hex(buf);
+      }
+  }
+  function b58DecodePublicKeyHash(value, fmt) {
+      const [data, pre] = b58DecodeAndCheckPrefix(value, publicKeyHashPrefixes);
+      const buf = new Uint8Array(21);
+      let tag;
+      switch (pre) {
+          case exports.PrefixV2.Ed25519PublicKeyHash:
+              tag = 0;
+              break;
+          case exports.PrefixV2.Secp256k1PublicKeyHash:
+              tag = 1;
+              break;
+          case exports.PrefixV2.P256PublicKeyHash:
+              tag = 2;
+              break;
+          case exports.PrefixV2.BLS12_381PublicKeyHash:
+              tag = 3;
+              break;
+          default:
+              throw new core.InvalidAddressError(value, core.ValidationResult.NO_PREFIX_MATCHED);
+      }
+      buf[0] = tag;
+      buf.set(data, 1);
+      if (fmt !== undefined && fmt === 'array') {
+          return buf;
+      }
+      else {
+          return buf2hex(buf);
+      }
+  }
+  function b58DecodeBlsAddress(value, fmt) {
+      const [buf, pre] = b58DecodeAndCheckPrefix(value);
+      if (pre !== exports.PrefixV2.BLS12_381PublicKeyHash) {
+          throw new core.InvalidKeyError(core.ValidationResult.NO_PREFIX_MATCHED);
+      }
+      if (fmt !== undefined && fmt === 'array') {
+          return buf;
+      }
+      else {
+          return buf2hex(buf);
+      }
+  }
+  function b58DecodeAddress(value, fmt) {
+      const i = value.indexOf('%');
+      if (i >= 0) {
+          value = value.slice(0, i);
+      }
+      const [data, pre] = b58DecodeAndCheckPrefix(value, addressPrefixes);
+      const buf = new Uint8Array(22);
+      if (pre === exports.PrefixV2.ContractHash ||
+          pre === exports.PrefixV2.SmartRollupHash ||
+          pre === exports.PrefixV2.ZkRollupHash) {
+          let tag;
+          switch (pre) {
+              case exports.PrefixV2.ContractHash:
+                  tag = 1;
+                  break;
+              case exports.PrefixV2.SmartRollupHash:
+                  tag = 3;
+                  break;
+              case exports.PrefixV2.ZkRollupHash:
+                  tag = 4;
+                  break;
+          }
+          buf[0] = tag;
+          buf.set(data, 1);
+      }
+      else {
+          let tag;
+          switch (pre) {
+              case exports.PrefixV2.Ed25519PublicKeyHash:
+                  tag = 0;
+                  break;
+              case exports.PrefixV2.Secp256k1PublicKeyHash:
+                  tag = 1;
+                  break;
+              case exports.PrefixV2.P256PublicKeyHash:
+                  tag = 2;
+                  break;
+              case exports.PrefixV2.BLS12_381PublicKeyHash:
+                  tag = 3;
+                  break;
+              default:
+                  throw new core.InvalidAddressError(value, core.ValidationResult.NO_PREFIX_MATCHED);
+          }
+          buf[0] = 0;
+          buf[1] = tag;
+          buf.set(data, 2);
+      }
+      if (fmt !== undefined && fmt === 'array') {
+          return buf;
+      }
+      else {
+          return buf2hex(buf);
+      }
   }
   /**
-   *
-   * @description Base58 encode a string or a Uint8Array and append a prefix to it
-   *
-   * @param value Value to base58 encode
-   * @param prefix prefix to append to the encoded string
+   *  @description Gets Tezos address (PKH) from Public Key
+   *  @param publicKey Base58 Public Key
+   *  @returns A string of the Tezos address (PKH) that was derived from the given Public Key
+   *  @example getPkhfromPk('edpkuNjKKT48xBoT5asPrWdmuM1Yw8D93MwgFgVvtca8jb5pstzaCh') // return 'tz2MVED1t9Jery77Bwm1m5YhUx8Wp5KWWRQe'
    */
-  function b58cencode(value, prefix) {
-      const payloadAr = typeof value === 'string' ? Uint8Array.from(buffer.Buffer.from(value, 'hex')) : value;
-      const n = new Uint8Array(prefix.length + payloadAr.length);
-      n.set(prefix);
-      n.set(payloadAr, prefix.length);
-      return bs58check.encode(buffer.Buffer.from(n.buffer));
+  function getPkhfromPk(publicKey) {
+      const [key, pre] = b58DecodeAndCheckPrefix(publicKey);
+      let pkhPre;
+      switch (pre) {
+          case exports.PrefixV2.P256PublicKey:
+              pkhPre = exports.PrefixV2.P256PublicKeyHash;
+              break;
+          case exports.PrefixV2.Secp256k1PublicKey:
+              pkhPre = exports.PrefixV2.Secp256k1PublicKeyHash;
+              break;
+          case exports.PrefixV2.Ed25519PublicKey:
+              pkhPre = exports.PrefixV2.Ed25519PublicKeyHash;
+              break;
+          case exports.PrefixV2.BLS12_381PublicKey:
+              pkhPre = exports.PrefixV2.BLS12_381PublicKeyHash;
+              break;
+          default:
+              throw new core.InvalidPublicKeyError(publicKey, core.ValidationResult.NO_PREFIX_MATCHED);
+      }
+      const hashed = blake2b.hash(key, 20);
+      return b58Encode(hashed, pkhPre);
   }
   /**
-   *
-   * @description Base58 decode a string and remove the prefix from it
-   *
-   * @param value Value to base58 decode
-   * @param prefix prefix to remove from the decoded string
+   * @description Add the prefix to a hex string or Uint8Array and Base58 encode it
+   * @param value Value to Base58 encode
+   * @param pre prefix ID to append to the encoded string
+   * @example b58Encode('e96b9f8b19af9c7ffa0c0480e1977b295850961f', PrefixV2.Ed25519PublicKeyHash) // returns 'tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM'
    */
-  const b58cdecode = (enc, prefixArg) => bs58check.decode(enc).slice(prefixArg.length);
+  function b58Encode(value, pre) {
+      const data = typeof value === 'string' ? hex2buf(value) : value;
+      const p = prefixV2[pre];
+      const n = new Uint8Array(p.length + data.length);
+      n.set(p);
+      n.set(data, p.length);
+      return bs58check.encode(toBuffer(n));
+  }
   /**
-   *
-   * @description Base58 decode a string with predefined prefix
-   *
-   * @param value Value to base58 decode
+   * @description Parse binary public key and return Base58 representation
+   * @param value Binary key data
+   * @returns return prefixed public key
+   * @example encodeKey('02033aba7da4a2e7b5dd9f074555c118829aff16213ea1b65859686bd5fcfeaf3616') // return 'p2pk66xmhjiN7LpfrDGFwpxPtJxkLtPjQ6HUxJbKmRbxSR7RMpamDwi'
    */
-  function b58decode(payload) {
-      const buf = bs58check.decode(payload);
-      const prefixMap = {
-          [prefix.tz1.toString()]: '0000',
-          [prefix.tz2.toString()]: '0001',
-          [prefix.tz3.toString()]: '0002',
-          [prefix.tz4.toString()]: '0003',
-      };
-      const pref = prefixMap[new Uint8Array(buf.slice(0, 3)).toString()];
-      if (pref) {
-          // tz addresses
-          const hex = buf2hex(buf.slice(3));
-          return pref + hex;
+  function encodeKey(value) {
+      let buf;
+      if (typeof value === 'string') {
+          buf = hex2buf(value);
       }
       else {
-          // other (kt addresses)
-          return '01' + buf2hex(buf.slice(3, 42)) + '00';
+          buf = value;
       }
+      let pre;
+      switch (buf[0]) {
+          case 0:
+              pre = exports.PrefixV2.Ed25519PublicKey;
+              break;
+          case 1:
+              pre = exports.PrefixV2.Secp256k1PublicKey;
+              break;
+          case 2:
+              pre = exports.PrefixV2.P256PublicKey;
+              break;
+          case 3:
+              pre = exports.PrefixV2.BLS12_381PublicKey;
+              break;
+          default:
+              throw new Error('invalid address format');
+      }
+      return b58Encode(buf.slice(1), pre);
   }
   /**
-   *
-   * @description b58 decode a string without predefined prefix
-   * @param value
-   * @returns string of bytes
-   * @deprecated use b58decode instead
-   */
-  function b58decodeL2Address(payload) {
-      const buf = bs58check.decode(payload);
-      // tz4 address currently
-      return buf2hex(buf.slice(3, 42));
-  }
-  /**
-   *
-   * @description Base58 encode an address using predefined prefix
-   *
-   * @param value Address to base58 encode (tz1, tz2, tz3 or KT1)
-   * @deprecated use encodeAddress instead, same functionality with a more descriptive name
+   * @description Parse binary public key hash and return Base58 representation
+   * @param value Key hash to parse
+   * @returns return prefixed public key hash
+   * @example encodeKeyHash('0001907d6a7e9f084df840d6e67ffa8db5464f87d4d1') // return 'tz2MVED1t9Jery77Bwm1m5YhUx8Wp5KWWRQe'
    */
-  function encodePubKey(value) {
-      if (value.substring(0, 2) === '00') {
-          const pref = {
-              '0000': prefix.tz1,
-              '0001': prefix.tz2,
-              '0002': prefix.tz3,
-              '0003': prefix.tz4,
-          };
-          return b58cencode(value.substring(4), pref[value.substring(0, 4)]);
-      }
-      return b58cencode(value.substring(2, 42), prefix.KT);
+  function encodeKeyHash(value) {
+      let buf;
+      if (typeof value === 'string') {
+          buf = hex2buf(value);
+      }
+      else {
+          buf = value;
+      }
+      let pre;
+      switch (buf[0]) {
+          case 0:
+              pre = exports.PrefixV2.Ed25519PublicKeyHash;
+              break;
+          case 1:
+              pre = exports.PrefixV2.Secp256k1PublicKeyHash;
+              break;
+          case 2:
+              pre = exports.PrefixV2.P256PublicKeyHash;
+              break;
+          case 3:
+              pre = exports.PrefixV2.BLS12_381PublicKeyHash;
+              break;
+          default:
+              throw new Error('invalid address format');
+      }
+      return b58Encode(buf.slice(1, 21), pre);
   }
   /**
-   *
-   * @description Base58 encode an address using predefined prefix (tz1, tz2, tz3, or KT1 without annotation)
-   *
-   * @param value Address to base58 encode (tz1, tz2, tz3 or KT1). Supports value with or without '0x' prefix
+   * @description Parse binary Contract ID and return Base58 representation
+   * @param value Address to parse (tz1, tz2, tz3, KT1, or sr1).
+   * @example encodeAddress('0000e96b9f8b19af9c7ffa0c0480e1977b295850961f') // return 'tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM'
    */
   function encodeAddress(value) {
-      if (value.substring(0, 2) === '0x') {
-          value = value.slice(2);
-      }
-      if (value.substring(0, 2) === '00') {
-          const pref = {
-              '0000': prefix.tz1,
-              '0001': prefix.tz2,
-              '0002': prefix.tz3,
-              '0003': prefix.tz4,
-          };
-          return b58cencode(value.substring(4), pref[value.substring(0, 4)]);
-      }
-      return b58cencode(value.substring(2, 42), prefix.KT);
+      let buf;
+      if (typeof value === 'string') {
+          buf = hex2buf(value);
+      }
+      else {
+          buf = value;
+      }
+      switch (buf[0]) {
+          case 0: // implicit
+              return encodeKeyHash(buf.slice(1));
+          case 1: // contract hash
+              return b58Encode(buf.slice(1, 21), exports.PrefixV2.ContractHash);
+          case 3: // smart rollup hash
+              return b58Encode(buf.slice(1, 21), exports.PrefixV2.SmartRollupHash);
+          case 4: // zk rollup hash
+              return b58Encode(buf.slice(1, 21), exports.PrefixV2.ZkRollupHash);
+          default:
+              throw new Error('invalid address format');
+      }
   }
   /**
-   *
    * @description Base58 encode an address without predefined prefix
    * @param value Address to base58 encode (tz4) hex dec
    * @returns return address
-   * @deprecated use encodeAddress instead
+   * @example encodeBlsAddress('af2dc3c40667abc0e89c0ef40171d22aed08d5eb') // return 'tz4QyWfEiv56CVDATV3DT3CDVhPaMKif2Ce8'
    */
-  function encodeL2Address(value) {
-      return b58cencode(value, prefix.tz4);
+  function encodeBlsAddress(value) {
+      return b58Encode(value, exports.PrefixV2.BLS12_381PublicKeyHash);
   }
   /**
-   *
-   * @description Base58 encode a key according to its prefix
-   *
-   * @param value Key to base58 encode
+   * @description convert a fragment of Michelson code in hex string to an 'expr' prefix + base58 encoded BLAKE2b hash string
+   * @param value a fragment of Michelson code in hex string
+   * @returns return 'expr' prefix + base58 encoded BLAKE2b hash
+   * @example encodeExpr('050a000000160000b2e19a9e74440d86c59f13dab8a18ff873e889ea') // return 'exprv6UsC1sN3Fk2XfgcJCL8NCerP5rCGy1PRESZAqr7L2JdzX55EN'
    */
-  function encodeKey(value) {
-      if (value[0] === '0') {
-          const pref = {
-              '00': new Uint8Array([13, 15, 37, 217]),
-              '01': new Uint8Array([3, 254, 226, 86]),
-              '02': new Uint8Array([3, 178, 139, 127]),
-          };
-          return b58cencode(value.substring(2), pref[value.substring(0, 2)]);
-      }
+  function encodeExpr(value) {
+      const blakeHash = blake2b.hash(hex2buf(value), 32);
+      return b58Encode(blakeHash, exports.PrefixV2.ScriptExpr);
   }
   /**
-   *
-   * @description Base58 encode a key hash according to its prefix
-   *
-   * @param value Key hash to base58 encode
+   * @description convert a signed operation in hex string to an 'op' prefix + base58 encoded BLAKE2b hash string
+   * @param value signed operation in hex string
+   * @returns return 'op' prefix + base58 encoded BLAKE2b hash
+   * @example encodeOpHash('0f185d8a30061e8134c162dbb7a6c3ab8f5fdb153363ccd6149b49a33481156a6c00b2e19a9e74440d86c59f13dab8a18ff873e889eaa304ab05da13000001f1585a7384f36e45fb43dc37e8ce172bced3e05700ff0000000002002110c033f3a990c2e46a3d6054ecc2f74072aae7a34b5ac4d9ce9edc11c2410a97695682108951786f05b361da03b97245dc9897e1955e08b5b8d9e153b0bdeb0d') // return 'opapqvVXmebRTCFd2GQFydr4tJj3V5QocQuTmuhbatcHm4Seo2t'
    */
-  function encodeKeyHash(value) {
-      if (value[0] === '0') {
-          const pref = {
-              '00': new Uint8Array([6, 161, 159]),
-              '01': new Uint8Array([6, 161, 161]),
-              '02': new Uint8Array([6, 161, 164]),
-              '03': new Uint8Array([6, 161, 166]),
-          };
-          return b58cencode(value.substring(2), pref[value.substring(0, 2)]);
-      }
+  function encodeOpHash(value) {
+      const blakeHash = blake2b.hash(hex2buf(value), 32);
+      return b58Encode(blakeHash, exports.PrefixV2.OperationHash);
   }
   /**
-   *
    * @description Convert an hex string to a Uint8Array
-   *
    * @param hex Hex string to convert
    * @throws {@link ValueConversionError}
    */
-  const hex2buf = (hex) => {
+  function hex2buf(hex) {
+      hex = hex.startsWith('0x') ? hex.slice(2) : hex;
       if (hex.length % 2 !== 0) {
-          throw new core.InvalidHexStringError(hex, `: Expecting even number of characters`);
+          throw new core.InvalidHexStringError(hex, `Expecting even number of characters`);
       }
-      const hexDigits = stripHexPrefix(hex);
-      if (!hexDigits.match(/^([\da-f]{2})*$/gi)) {
-          throw new core.InvalidHexStringError(hex, `: Only characters 0-9, a-f and A-F are expected. Optionally, it can be prefixed with '0x'`);
+      if (!hex.match(/^([\da-f]{2})*$/gi)) {
+          throw new core.InvalidHexStringError(hex, `Only characters 0-9, a-f and A-F are expected. Optionally, it can be prefixed with '0x'`);
       }
-      const out = new Uint8Array(hexDigits.length / 2);
+      const res = new Uint8Array(hex.length / 2);
       let j = 0;
-      for (let i = 0; i < hexDigits.length; i += 2) {
-          const v = parseInt(hexDigits.slice(i, i + 2), 16);
-          if (Number.isNaN(v)) {
-              throw new ValueConversionError(hex, 'Uint8Array');
+      for (let i = 0; i < hex.length; i += 2) {
+          const ss = hex.slice(i, i + 2);
+          const x = parseInt(ss, 16);
+          if (Number.isNaN(x)) {
+              throw new core.InvalidHexStringError(hex, `Only characters 0-9, a-f and A-F are expected. Optionally, it can be prefixed with '0x'`);
           }
-          out[j++] = v;
+          res[j++] = x;
       }
-      return out;
-  };
+      return res;
+  }
   /**
-   *
    * @description Merge 2 buffers together
-   *
    * @param b1 First buffer
    * @param b2 Second buffer
    */
-  const mergebuf = (b1, b2) => {
+  function mergebuf(b1, b2) {
       const r = new Uint8Array(b1.length + b2.length);
       r.set(b1);
       r.set(b2, b1.length);
       return r;
-  };
+  }
   /**
-   *
    * @description Flatten a michelson json representation to an array
-   *
    * @param s michelson json
    */
-  const mic2arr = function me2(s) {
+  function mic2arr(s) {
       let ret = [];
       if (Object.prototype.hasOwnProperty.call(s, 'prim')) {
           if (s.prim === 'Pair') {
-              ret.push(me2(s.args[0]));
-              ret = ret.concat(me2(s.args[1]));
+              ret.push(mic2arr(s.args[0]));
+              ret = ret.concat(mic2arr(s.args[1]));
           }
           else if (s.prim === 'Elt') {
               ret = {
-                  key: me2(s.args[0]),
-                  val: me2(s.args[1]),
+                  key: mic2arr(s.args[0]),
+                  val: mic2arr(s.args[1]),
               };
           }
           else if (s.prim === 'True') {
@@ -762,7 +1197,7 @@
       else if (Array.isArray(s)) {
           const sc = s.length;
           for (let i = 0; i < sc; i++) {
-              const n = me2(s[i]);
+              const n = mic2arr(s[i]);
               if (typeof n.key !== 'undefined') {
                   if (Array.isArray(ret)) {
                       ret = {
@@ -788,110 +1223,43 @@
           ret = s;
       }
       return ret;
-  };
+  }
   /**
-   *
    * @description Convert a Uint8Array to an hex string
-   *
    * @param buffer Uint8Array to convert
    */
-  const buf2hex = (buffer) => {
-      const hexParts = [];
-      buffer.forEach((byte) => {
-          const hex = byte.toString(16);
-          const paddedHex = `00${hex}`.slice(-2);
-          hexParts.push(paddedHex);
-      });
-      return hexParts.join('');
-  };
-  /**
-   *
-   *  @description Gets Tezos address (PKH) from Public Key
-   *
-   *  @param publicKey Public Key
-   *  @returns A string of the Tezos address (PKH) that was derived from the given Public Key
-   */
-  const getPkhfromPk = (publicKey) => {
-      let encodingPrefix;
-      let prefixLen;
-      const keyPrefix = validatePkAndExtractPrefix(publicKey);
-      const decoded = b58cdecode(publicKey, prefix[keyPrefix]);
-      switch (keyPrefix) {
-          case exports.Prefix.EDPK:
-              encodingPrefix = prefix[exports.Prefix.TZ1];
-              prefixLen = prefixLength[exports.Prefix.TZ1];
-              break;
-          case exports.Prefix.SPPK:
-              encodingPrefix = prefix[exports.Prefix.TZ2];
-              prefixLen = prefixLength[exports.Prefix.TZ2];
-              break;
-          case exports.Prefix.P2PK:
-              encodingPrefix = prefix[exports.Prefix.TZ3];
-              prefixLen = prefixLength[exports.Prefix.TZ3];
-              break;
-          case exports.Prefix.BLPK:
-              encodingPrefix = prefix[exports.Prefix.TZ4];
-              prefixLen = prefixLength[exports.Prefix.TZ4];
-      }
-      const hashed = blake2b.hash(decoded, prefixLen);
-      const result = b58cencode(hashed, encodingPrefix);
-      return result;
-  };
-  /**
-   *
-   * @description Convert a string to bytes
-   *
-   * @param str String to convert
-   * @deprecated use stringToBytes instead, same functionality with a more descriptive name
-   */
-  function char2Bytes(str) {
-      return buffer.Buffer.from(str, 'utf8').toString('hex');
+  function buf2hex(bytes) {
+      return Array.from(bytes)
+          .map((x) => ((x >> 4) & 0xf).toString(16) + (x & 0xf).toString(16))
+          .join('');
   }
   /**
-   *
    * @description Convert a string to a byte string representation
-   *
    * @param str String to convert
    */
   function stringToBytes(str) {
       return buffer.Buffer.from(str, 'utf8').toString('hex');
   }
   /**
-   *
-   * @description Convert bytes to a string
-   *
-   * @param str Bytes to convert
-   * @deprecated use hexStringToBytes instead, same functionality with a more descriptive name
-   */
-  function bytes2Char(hex) {
-      return buffer.Buffer.from(hex2buf(hex)).toString('utf8');
-  }
-  /**
-   *
    * @description Convert byte string representation to string
-   *
-   * @param str byte string to convert
+   * @param hex byte string to convert
    */
   function bytesToString(hex) {
       return buffer.Buffer.from(hex2buf(hex)).toString('utf8');
   }
   /**
-   *
    * @description Convert hex string/UintArray/Buffer to bytes
-   *
    * @param hex String value to convert to bytes
    */
   function hex2Bytes(hex) {
       const hexDigits = stripHexPrefix(hex);
       if (!hexDigits.match(/^(0x)?([\da-f]{2})*$/gi)) {
-          throw new core.InvalidHexStringError(hex, `: Expecting even number of characters: 0-9, a-z, A-Z, optionally prefixed with 0x`);
+          throw new core.InvalidHexStringError(hex, `Expecting even number of characters: 0-9, a-z, A-Z, optionally prefixed with 0x`);
       }
       return buffer.Buffer.from(hexDigits, 'hex');
   }
   /**
-   *
    * @description Converts a number or Bignumber to hexadecimal  string
-   *
    * @param val The value  that will be converted to a hexadecimal string value
    */
   function toHexBuf(val, bitLength = 8) {
@@ -901,7 +1269,6 @@
       return buffer.Buffer.from(num2PaddedHex(val, bitLength), 'hex');
   }
   /**
-   *
    * @description Converts a number or BigNumber to a padded hexadecimal string
    * @param val The value that will be converted into a padded hexadecimal string value
    * @param bitLength The length of bits
@@ -943,6 +1310,113 @@
   function stripHexPrefix(hex) {
       return hex.startsWith('0x') ? hex.slice(2) : hex;
   }
+  function splitAddress(addr) {
+      const i = addr.indexOf('%');
+      if (i >= 0) {
+          return [addr.slice(0, i), addr.slice(i)];
+      }
+      else {
+          return [addr, null];
+      }
+  }
+  function compareArrays(a, b) {
+      let i = 0;
+      while (i < a.length && i < b.length && a[i] === b[i])
+          i++;
+      const aa = i < a.length ? a[i] : 0;
+      const bb = i < b.length ? b[i] : 0;
+      return aa < bb ? -1 : aa > bb ? 1 : 0;
+  }
+  /**
+   * @deprecated use b58DecodeAndCheckPrefix instead, this function will be removed in the next minor release
+   * @description Base58 decode a string and remove the prefix from it
+   * @param enc Value to base58 decode
+   * @param prefixArg prefix to remove from the decoded string
+   */
+  function b58cdecode(enc, prefixArg) {
+      return bs58check.decode(enc).slice(prefixArg.length);
+  }
+  /**
+   * @deprecated use b58Encode instead, this function will be removed in the next minor release
+   * @description Base58 encode a string or a Uint8Array and append a prefix to it
+   * @param value Value to base58 encode
+   * @param prefix prefix to append to the encoded string
+   */
+  function b58cencode(value, prefix) {
+      const payloadAr = typeof value === 'string' ? hex2buf(value) : value;
+      const n = new Uint8Array(prefix.length + payloadAr.length);
+      n.set(prefix);
+      n.set(payloadAr, prefix.length);
+      return bs58check.encode(toBuffer(n));
+  }
+  /**
+   * @deprecated use b58DecodePublicKey, b58DecodePublicKeyHash, b58DecodeBlsAddress, b58DecodeAddress instead, this function will be removed in the next minor release
+   * @description Base58 decode a string with predefined prefix
+   * @param payload Value to base58 decode
+   */
+  function b58decode(payload) {
+      const buf = bs58check.decode(payload);
+      const prefixMap = {
+          [prefix.tz1.toString()]: '0000',
+          [prefix.tz2.toString()]: '0001',
+          [prefix.tz3.toString()]: '0002',
+          [prefix.tz4.toString()]: '0003',
+      };
+      const pref = prefixMap[new Uint8Array(buf.slice(0, 3)).toString()];
+      if (pref) {
+          // tz addresses
+          const hex = buf2hex(buf.slice(3));
+          return pref + hex;
+      }
+      else {
+          // other (kt addresses)
+          return '01' + buf2hex(buf.slice(3, 42)) + '00';
+      }
+  }
+  /**
+   * @deprecated use b58DecodeBlsAddress instead, this function will be removed in the next minor release
+   * @description b58 decode a string without predefined prefix
+   * @param payload Value to base58 decode
+   * @returns string of bytes
+   */
+  function b58decodeL2Address(payload) {
+      const buf = bs58check.decode(payload);
+      // tz4 address currently
+      return buf2hex(buf.slice(3, 42));
+  }
+  /**
+   * @deprecated use encodeAddress instead, this function will be removed in the next minor release
+   * @description Base58 encode an address using predefined prefix
+   * @param value Address to base58 encode (tz1, tz2, tz3 or KT1)
+   */
+  function encodePubKey(value) {
+      return encodeAddress(value);
+  }
+  /**
+   * @deprecated use encodeBlsAddress instead, this function will be removed in the next minor release
+   * @description Base58 encode an address without predefined prefix
+   * @param value Address to base58 encode (tz4) hex dec
+   * @returns return address
+   */
+  function encodeL2Address(value) {
+      return b58cencode(value, prefix.tz4);
+  }
+  /**
+   * @deprecated use stringToBytes instead, this function will be removed in the next minor release
+   * @description Convert a string to bytes
+   * @param str String to convert
+   */
+  function char2Bytes(str) {
+      return buffer.Buffer.from(str, 'utf8').toString('hex');
+  }
+  /**
+   * @deprecated use bytesToString instead, this function will be removed in the next minor release
+   * @description Convert bytes to a string
+   * @param hex Bytes to convert
+   */
+  function bytes2Char(hex) {
+      return buffer.Buffer.from(hex2buf(hex)).toString('utf8');
+  }
 
   Object.defineProperty(exports, "DeprecationError", {
     enumerable: true,
@@ -1000,9 +1474,22 @@
     enumerable: true,
     get: function () { return core.ProhibitedActionError; }
   });
+  Object.defineProperty(exports, "ValidationResult", {
+    enumerable: true,
+    get: function () { return core.ValidationResult; }
+  });
+  exports.BLS12_381_DST = BLS12_381_DST;
   exports.InvalidProtocolHashError = InvalidProtocolHashError;
+  exports.POP_DST = POP_DST;
   exports.VERSION = VERSION;
   exports.ValueConversionError = ValueConversionError;
+  exports.addressPrefixes = addressPrefixes;
+  exports.b58DecodeAddress = b58DecodeAddress;
+  exports.b58DecodeAndCheckPrefix = b58DecodeAndCheckPrefix;
+  exports.b58DecodeBlsAddress = b58DecodeBlsAddress;
+  exports.b58DecodePublicKey = b58DecodePublicKey;
+  exports.b58DecodePublicKeyHash = b58DecodePublicKeyHash;
+  exports.b58Encode = b58Encode;
   exports.b58cdecode = b58cdecode;
   exports.b58cencode = b58cencode;
   exports.b58decode = b58decode;
@@ -1011,7 +1498,9 @@
   exports.bytes2Char = bytes2Char;
   exports.bytesToString = bytesToString;
   exports.char2Bytes = char2Bytes;
+  exports.compareArrays = compareArrays;
   exports.encodeAddress = encodeAddress;
+  exports.encodeBlsAddress = encodeBlsAddress;
   exports.encodeExpr = encodeExpr;
   exports.encodeKey = encodeKey;
   exports.encodeKeyHash = encodeKeyHash;
@@ -1023,13 +1512,18 @@
   exports.hex2Bytes = hex2Bytes;
   exports.hex2buf = hex2buf;
   exports.invalidDetail = invalidDetail;
-  exports.isValidPrefix = isValidPrefix;
+  exports.isValidPrefixedValue = isValidPrefixedValue;
   exports.mergebuf = mergebuf;
   exports.mic2arr = mic2arr;
   exports.num2PaddedHex = num2PaddedHex;
   exports.numToHexBuffer = numToHexBuffer;
+  exports.payloadLength = payloadLength;
   exports.prefix = prefix;
   exports.prefixLength = prefixLength;
+  exports.publicKeyHashPrefixes = publicKeyHashPrefixes;
+  exports.publicKeyPrefixes = publicKeyPrefixes;
+  exports.signaturePrefixes = signaturePrefixes;
+  exports.splitAddress = splitAddress;
   exports.stringToBytes = stringToBytes;
   exports.stripHexPrefix = stripHexPrefix;
   exports.toHexBuf = toHexBuf;