@taquito/utils 23.0.0-beta.0 → 23.0.0-beta.1

package/dist/taquito-utils.es6.js

@@ -1,15 +1,19 @@
 import { Buffer } from 'buffer';
-import { verify } from '@stablelib/ed25519';
 import { hash } from '@stablelib/blake2b';
-import blake from 'blakejs';
 import bs58check from 'bs58check';
-import { InvalidMessageError, InvalidPublicKeyError, InvalidSignatureError, ParameterValidationError, UnsupportedActionError, InvalidHexStringError } from '@taquito/core';
-export { DeprecationError, InvalidAddressError, InvalidBlockHashError, InvalidChainIdError, InvalidContractAddressError, InvalidHexStringError, InvalidKeyError, InvalidKeyHashError, InvalidMessageError, InvalidOperationHashError, InvalidOperationKindError, InvalidPublicKeyError, InvalidSignatureError, ProhibitedActionError } from '@taquito/core';
 import BigNumber from 'bignumber.js';
-import elliptic from 'elliptic';
 import toBuffer from 'typedarray-to-buffer';
+import { ValidationResult, ParameterValidationError, InvalidPublicKeyError, InvalidSignatureError, InvalidMessageError, UnsupportedActionError, InvalidKeyError, InvalidAddressError, InvalidHexStringError } from '@taquito/core';
+export { DeprecationError, InvalidAddressError, InvalidBlockHashError, InvalidChainIdError, InvalidContractAddressError, InvalidHexStringError, InvalidKeyError, InvalidKeyHashError, InvalidMessageError, InvalidOperationHashError, InvalidOperationKindError, InvalidPublicKeyError, InvalidSignatureError, ProhibitedActionError, ValidationResult } from '@taquito/core';
+import { verify } from '@stablelib/ed25519';
+import elliptic from 'elliptic';
+import { bls12_381 } from '@noble/curves/bls12-381';
 
 // 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
+ */
 var Prefix;
 (function (Prefix) {
     Prefix["TZ1"] = "tz1";
@@ -54,6 +58,10 @@ var Prefix;
     Prefix["SRC1"] = "src1";
     Prefix["SH"] = "sh";
 })(Prefix || (Prefix = {}));
+/**
+ * @deprecated use prefixV2 instead this constant will be removed in the next minor release
+ * @description base58 prefix to bytes mapping
+ */
 const prefix = {
     [Prefix.TZ1]: new Uint8Array([6, 161, 159]),
     [Prefix.TZ2]: new Uint8Array([6, 161, 161]),
@@ -98,6 +106,10 @@ const prefix = {
     [Prefix.SRC1]: new Uint8Array([17, 165, 134, 138]),
     [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 = {
     [Prefix.TZ1]: 20,
     [Prefix.TZ2]: 20,
@@ -125,200 +137,252 @@ const prefixLength = {
     [Prefix.SRC1]: 32,
     [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 = hash(messageBuf, 32);
-    if (pkPrefix === Prefix.EDPK) {
-        return verifyEdSignature(decodedSig, bytesHash, decodedPublicKey);
-    }
-    else if (pkPrefix === Prefix.SPPK) {
-        return verifySpSignature(decodedSig, bytesHash, decodedPublicKey);
-    }
-    else if (pkPrefix === Prefix.P2PK) {
-        return verifyP2Signature(decodedSig, bytesHash, decodedPublicKey);
-    }
-    else {
-        return false;
-    }
-}
-function validateMessageNotEmpty(message) {
-    if (message === '') {
-        throw new InvalidMessageError(message, `can't be empty`);
-    }
-    return message;
-}
-function validatePkAndExtractPrefix(publicKey) {
-    if (publicKey === '') {
-        throw new InvalidPublicKeyError(publicKey, `can't be empty`);
-    }
-    const pkPrefix = publicKey.substring(0, 4);
-    const publicKeyValidation = validatePublicKey(publicKey);
-    if (publicKeyValidation !== ValidationResult.VALID) {
-        throw new 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 !== ValidationResult.VALID) {
-        throw new InvalidSignatureError(signature, invalidDetail(validation));
-    }
-    return signaturePrefix;
-}
-function verifyEdSignature(decodedSig, bytesHash, decodedPublicKey) {
-    try {
-        return 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;
-}
-
+var PrefixV2;
+(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";
+})(PrefixV2 || (PrefixV2 = {}));
 /**
- *  @category Error
- *  @description Error that indicates invalid protocol hash being passed or used
+ * @description base58 prefix to bytes mapping
  */
-class InvalidProtocolHashError extends 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 = {
+    [PrefixV2.BlockHash]: new Uint8Array([1, 52]),
+    [PrefixV2.OperationHash]: new Uint8Array([5, 116]),
+    [PrefixV2.OperationListHash]: new Uint8Array([133, 233]),
+    [PrefixV2.OperationListListHash]: new Uint8Array([29, 159, 109]),
+    [PrefixV2.ProtocolHash]: new Uint8Array([2, 170]),
+    [PrefixV2.ContextHash]: new Uint8Array([79, 199]),
+    [PrefixV2.BlockMetadataHash]: new Uint8Array([234, 249]),
+    [PrefixV2.OperationMetadataHash]: new Uint8Array([5, 183]),
+    [PrefixV2.OperationMetadataListHash]: new Uint8Array([134, 39]),
+    [PrefixV2.OperationMetadataListListHash]: new Uint8Array([29, 159, 182]),
+    [PrefixV2.Ed25519PublicKeyHash]: new Uint8Array([6, 161, 159]),
+    [PrefixV2.Secp256k1PublicKeyHash]: new Uint8Array([6, 161, 161]),
+    [PrefixV2.P256PublicKeyHash]: new Uint8Array([6, 161, 164]),
+    [PrefixV2.ContractHash]: new Uint8Array([2, 90, 121]),
+    [PrefixV2.BlindedPublicKeyHash]: new Uint8Array([1, 2, 49, 223]),
+    [PrefixV2.BLS12_381PublicKeyHash]: new Uint8Array([6, 161, 166]),
+    [PrefixV2.TXRollupAddress]: new Uint8Array([1, 128, 120, 31]),
+    [PrefixV2.ZkRollupHash]: new Uint8Array([1, 23, 224, 125]),
+    [PrefixV2.ScRollupHash]: new Uint8Array([1, 118, 132, 217]),
+    [PrefixV2.SmartRollupHash]: new Uint8Array([6, 124, 117]),
+    [PrefixV2.CryptoboxPublicKeyHash]: new Uint8Array([153, 103]),
+    [PrefixV2.Ed25519Seed]: new Uint8Array([13, 15, 58, 7]),
+    [PrefixV2.Ed25519PublicKey]: new Uint8Array([13, 15, 37, 217]),
+    [PrefixV2.Secp256k1SecretKey]: new Uint8Array([17, 162, 224, 201]),
+    [PrefixV2.P256SecretKey]: new Uint8Array([16, 81, 238, 189]),
+    [PrefixV2.BLS12_381SecretKey]: new Uint8Array([3, 150, 192, 40]),
+    [PrefixV2.ValueHash]: new Uint8Array([1, 106, 242]),
+    [PrefixV2.CycleNonce]: new Uint8Array([69, 220, 169]),
+    [PrefixV2.ScriptExpr]: new Uint8Array([13, 44, 64, 27]),
+    [PrefixV2.InboxHash]: new Uint8Array([79, 148, 196]),
+    [PrefixV2.MessageHash]: new Uint8Array([79, 149, 30]),
+    [PrefixV2.CommitmentHash]: new Uint8Array([79, 148, 17]),
+    [PrefixV2.MessageResultHash]: new Uint8Array([18, 7, 206, 87]),
+    [PrefixV2.MessageResultListHash]: new Uint8Array([79, 146, 82]),
+    [PrefixV2.WithdrawListHash]: new Uint8Array([79, 150, 72]),
+    [PrefixV2.ScRollupStateHash]: new Uint8Array([17, 144, 122, 202]),
+    [PrefixV2.ScRollupCommitmentHash]: new Uint8Array([17, 144, 21, 100]),
+    [PrefixV2.SmartRollupStateHash]: new Uint8Array([17, 165, 235, 240]),
+    [PrefixV2.SmartRollupCommitmentHash]: new Uint8Array([17, 165, 134, 138]),
+    [PrefixV2.Ed25519EncryptedSeed]: new Uint8Array([7, 90, 60, 179, 41]),
+    [PrefixV2.Secp256k1EncryptedSecretKey]: new Uint8Array([9, 237, 241, 174, 150]),
+    [PrefixV2.P256EncryptedSecretKey]: new Uint8Array([9, 48, 57, 115, 171]),
+    [PrefixV2.BLS12_381EncryptedSecretKey]: new Uint8Array([2, 5, 30, 53, 25]),
+    [PrefixV2.Secp256k1EncryptedScalar]: new Uint8Array([1, 131, 36, 86, 248]),
+    [PrefixV2.Secp256k1PublicKey]: new Uint8Array([3, 254, 226, 86]),
+    [PrefixV2.P256PublicKey]: new Uint8Array([3, 178, 139, 127]),
+    [PrefixV2.Secp256k1Scalar]: new Uint8Array([38, 248, 136]),
+    [PrefixV2.Secp256k1Element]: new Uint8Array([5, 92, 0]),
+    [PrefixV2.Ed25519SecretKey]: new Uint8Array([43, 246, 78, 7]),
+    [PrefixV2.Ed25519Signature]: new Uint8Array([9, 245, 205, 134, 18]),
+    [PrefixV2.Secp256k1Signature]: new Uint8Array([13, 115, 101, 19, 63]),
+    [PrefixV2.P256Signature]: new Uint8Array([54, 240, 44, 52]),
+    [PrefixV2.GenericSignature]: new Uint8Array([4, 130, 43]),
+    [PrefixV2.ChainID]: new Uint8Array([87, 82, 0]),
+    [PrefixV2.SaplingSpendingKey]: new Uint8Array([11, 237, 20, 92]),
+    [PrefixV2.EncryptedSaplingSpendingKey]: new Uint8Array([11, 237, 20, 92]),
+    [PrefixV2.SaplingAddress]: new Uint8Array([18, 71, 40, 223]),
+    [PrefixV2.GenericAggregateSignature]: new Uint8Array([2, 75, 234, 101]),
+    [PrefixV2.BLS12_381Signature]: new Uint8Array([40, 171, 64, 207]),
+    [PrefixV2.BLS12_381PublicKey]: new Uint8Array([6, 149, 135, 204]),
+    [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 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 = {
+    [PrefixV2.BlockHash]: 32,
+    [PrefixV2.OperationHash]: 32,
+    [PrefixV2.OperationListHash]: 32,
+    [PrefixV2.OperationListListHash]: 32,
+    [PrefixV2.ProtocolHash]: 32,
+    [PrefixV2.ContextHash]: 32,
+    [PrefixV2.BlockMetadataHash]: 32,
+    [PrefixV2.OperationMetadataHash]: 32,
+    [PrefixV2.OperationMetadataListHash]: 32,
+    [PrefixV2.OperationMetadataListListHash]: 32,
+    [PrefixV2.Ed25519PublicKeyHash]: 20,
+    [PrefixV2.Secp256k1PublicKeyHash]: 20,
+    [PrefixV2.P256PublicKeyHash]: 20,
+    [PrefixV2.ContractHash]: 20,
+    [PrefixV2.BlindedPublicKeyHash]: 20,
+    [PrefixV2.BLS12_381PublicKeyHash]: 20,
+    [PrefixV2.TXRollupAddress]: 20,
+    [PrefixV2.ZkRollupHash]: 20,
+    [PrefixV2.ScRollupHash]: 20,
+    [PrefixV2.SmartRollupHash]: 20,
+    [PrefixV2.CryptoboxPublicKeyHash]: 16,
+    [PrefixV2.Ed25519Seed]: 32,
+    [PrefixV2.Ed25519PublicKey]: 32,
+    [PrefixV2.Secp256k1SecretKey]: 32,
+    [PrefixV2.P256SecretKey]: 32,
+    [PrefixV2.BLS12_381SecretKey]: 32,
+    [PrefixV2.ValueHash]: 32,
+    [PrefixV2.CycleNonce]: 32,
+    [PrefixV2.ScriptExpr]: 32,
+    [PrefixV2.InboxHash]: 32,
+    [PrefixV2.MessageHash]: 32,
+    [PrefixV2.CommitmentHash]: 32,
+    [PrefixV2.MessageResultHash]: 32,
+    [PrefixV2.MessageResultListHash]: 32,
+    [PrefixV2.WithdrawListHash]: 32,
+    [PrefixV2.ScRollupStateHash]: 32,
+    [PrefixV2.ScRollupCommitmentHash]: 32,
+    [PrefixV2.SmartRollupStateHash]: 32,
+    [PrefixV2.SmartRollupCommitmentHash]: 32,
+    [PrefixV2.Ed25519EncryptedSeed]: 56,
+    [PrefixV2.Secp256k1EncryptedSecretKey]: 56,
+    [PrefixV2.P256EncryptedSecretKey]: 56,
+    [PrefixV2.BLS12_381EncryptedSecretKey]: 56,
+    [PrefixV2.Secp256k1EncryptedScalar]: 60,
+    [PrefixV2.Secp256k1PublicKey]: 33,
+    [PrefixV2.P256PublicKey]: 33,
+    [PrefixV2.Secp256k1Scalar]: 33,
+    [PrefixV2.Secp256k1Element]: 33,
+    [PrefixV2.Ed25519SecretKey]: 64,
+    [PrefixV2.Ed25519Signature]: 64,
+    [PrefixV2.Secp256k1Signature]: 64,
+    [PrefixV2.P256Signature]: 64,
+    [PrefixV2.GenericSignature]: 64,
+    [PrefixV2.ChainID]: 4,
+    [PrefixV2.SaplingSpendingKey]: 169,
+    [PrefixV2.EncryptedSaplingSpendingKey]: 193,
+    [PrefixV2.SaplingAddress]: 43,
+    [PrefixV2.GenericAggregateSignature]: 96,
+    [PrefixV2.BLS12_381Signature]: 96,
+    [PrefixV2.BLS12_381PublicKey]: 48,
+    [PrefixV2.SlotHeader]: 48,
+};
 
-var ValidationResult;
-(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";
-})(ValidationResult || (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) === 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 ValidationResult.NO_PREFIX_MATCHED;
-    }
-    const prefixKey = match[0];
-    if (!isValidPrefix(prefixKey)) {
-        return 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 ValidationResult.INVALID_CHECKSUM;
-    }
-    // decodeUnsafe return undefined if decoding fail
-    let decoded = bs58check.decodeUnsafe(value);
-    if (!decoded) {
-        return ValidationResult.INVALID_CHECKSUM;
+    try {
+        b58DecodeAndCheckPrefix(value, prefixes);
     }
-    decoded = decoded.slice(prefix[prefixKey].length);
-    if (decoded.length !== prefixLength[prefixKey]) {
-        return ValidationResult.INVALID_LENGTH;
+    catch (err) {
+        if (err instanceof ParameterValidationError && err.result !== undefined) {
+            return err.result;
+        }
+        return ValidationResult.OTHER;
     }
     return ValidationResult.VALID;
 }
-const implicitPrefix = [Prefix.TZ1, Prefix.TZ2, Prefix.TZ3, Prefix.TZ4];
-const contractPrefix = [Prefix.KT1];
-const signaturePrefix = [Prefix.EDSIG, Prefix.P2SIG, Prefix.SPSIG, Prefix.SIG];
-const pkPrefix = [Prefix.EDPK, Prefix.SPPK, Prefix.P2PK, Prefix.BLPK];
-const operationPrefix = [Prefix.O];
-const protocolPrefix = [Prefix.P];
-const blockPrefix = [Prefix.B];
-const smartRollupPrefix = [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
  * ```
@@ -330,13 +394,14 @@ const smartRollupPrefix = [Prefix.SR1];
  * ```
  */
 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
  * ```
@@ -348,13 +413,13 @@ function validateAddress(value) {
  * ```
  */
 function validateChain(value) {
-    return validatePrefixedValue(value, [Prefix.NET]);
+    return validatePrefixedValue(value, [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
  * ```
@@ -366,13 +431,13 @@ function validateChain(value) {
  * ```
  */
 function validateContractAddress(value) {
-    return validatePrefixedValue(value, contractPrefix);
+    return validatePrefixedValue(value, [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
  * ```
@@ -384,13 +449,13 @@ function validateContractAddress(value) {
  * ```
  */
 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
  * ```
@@ -402,13 +467,13 @@ function validateKeyHash(value) {
  * ```
  */
 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
  * ```
@@ -420,13 +485,13 @@ function validateSignature(value) {
  * ```
  */
 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
  * ```
@@ -438,13 +503,13 @@ function validatePublicKey(value) {
  * ```
  */
 function validateOperation(value) {
-    return validatePrefixedValue(value, operationPrefix);
+    return validatePrefixedValue(value, [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
  * ```
@@ -456,13 +521,13 @@ function validateOperation(value) {
  * ```
  */
 function validateProtocol(value) {
-    return validatePrefixedValue(value, protocolPrefix);
+    return validatePrefixedValue(value, [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
  * ```
@@ -474,16 +539,12 @@ function validateProtocol(value) {
  * ```
  */
 function validateBlock(value) {
-    return validatePrefixedValue(value, blockPrefix);
+    return validatePrefixedValue(value, [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, [Prefix.SASK]);
-}
 function invalidDetail(validation) {
     switch (validation) {
         case ValidationResult.NO_PREFIX_MATCHED:
@@ -496,16 +557,191 @@ function invalidDetail(validation) {
             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, [PrefixV2.SaplingSpendingKey]);
+}
 function validateSmartRollupAddress(value) {
-    return validatePrefixedValue(value, [...smartRollupPrefix]);
+    return validatePrefixedValue(value, [PrefixV2.SmartRollupHash]);
 }
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "7af2138a9e5c5b230c4b4c726f35c2f2e67b721c",
-    "version": "23.0.0-beta.0"
+    "commitHash": "10b3de10de15ae68d47b1fca922d3129d2f79641",
+    "version": "23.0.0-beta.1"
 };
 
+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 ParameterValidationError) {
+                throw new InvalidPublicKeyError(publicKey, err.result);
+            }
+            else {
+                throw err;
+            }
+        }
+    })();
+    const sig = (() => {
+        try {
+            const [sig] = b58DecodeAndCheckPrefix(signature, signaturePrefixes);
+            return sig;
+        }
+        catch (err) {
+            if (err instanceof ParameterValidationError) {
+                throw new 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 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 PrefixV2.P256PublicKey:
+                return verifyP2Signature(sig, msg, pk);
+            case PrefixV2.Secp256k1PublicKey:
+                return verifySpSignature(sig, msg, pk);
+            case 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 InvalidPublicKeyError(publicKey, `can't be empty`);
+    }
+    const pkPrefix = publicKey.substring(0, 4);
+    const publicKeyValidation = validatePublicKey(publicKey);
+    if (publicKeyValidation !== ValidationResult.VALID) {
+        throw new InvalidPublicKeyError(publicKey, invalidDetail(publicKeyValidation));
+    }
+    return pkPrefix;
+}
+function verifyEdSignature(sig, msg, publicKey) {
+    const hash$1 = hash(msg, 32);
+    try {
+        return verify(publicKey, hash$1, 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$1 = hash(msg, 32);
+    try {
+        return key.verify(hash$1, { r, s });
+    }
+    catch (_a) {
+        return false;
+    }
+}
+const bls = 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 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 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) {
@@ -539,222 +775,421 @@ function format(from = 'mutez', to = 'mutez', amount) {
  * 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 = [
+    PrefixV2.P256PublicKeyHash,
+    PrefixV2.Secp256k1PublicKeyHash,
+    PrefixV2.Ed25519PublicKeyHash,
+    PrefixV2.BLS12_381PublicKeyHash,
+    PrefixV2.ContractHash,
+    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 = [
+    PrefixV2.P256PublicKey,
+    PrefixV2.Secp256k1PublicKey,
+    PrefixV2.Ed25519PublicKey,
+    PrefixV2.BLS12_381PublicKey,
+];
+/**
+ * @description list of prefixes that can be used to decode a public key hash
+ */
+const publicKeyHashPrefixes = [
+    PrefixV2.P256PublicKeyHash,
+    PrefixV2.Secp256k1PublicKeyHash,
+    PrefixV2.Ed25519PublicKeyHash,
+    PrefixV2.BLS12_381PublicKeyHash,
+];
+/**
+ * @description list of prefixes that can be used to decode a signature
+ */
+const signaturePrefixes = [
+    PrefixV2.P256Signature,
+    PrefixV2.Secp256k1Signature,
+    PrefixV2.Ed25519Signature,
+    PrefixV2.BLS12_381Signature,
+    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 ParameterValidationError(ValidationResult.INVALID_CHECKSUM);
+                }
+                else {
+                    throw new ParameterValidationError(ValidationResult.INVALID_ENCODING);
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    })();
+    let key;
+    for (key in PrefixV2) {
+        const p = 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 ParameterValidationError(ValidationResult.PREFIX_NOT_ALLOWED);
+            }
+            if (payloadOnly) {
+                return buf.slice(pre.length);
+            }
+            else {
+                return [buf.slice(pre.length), p];
+            }
+        }
+    }
+    throw new ParameterValidationError(ValidationResult.NO_PREFIX_MATCHED);
+}
+function b58DecodePublicKey(value, fmt) {
+    const [data, pre] = b58DecodeAndCheckPrefix(value, publicKeyPrefixes);
+    let tag;
+    switch (pre) {
+        case PrefixV2.Ed25519PublicKey:
+            tag = 0;
+            break;
+        case PrefixV2.Secp256k1PublicKey:
+            tag = 1;
+            break;
+        case PrefixV2.P256PublicKey:
+            tag = 2;
+            break;
+        case PrefixV2.BLS12_381PublicKey:
+            tag = 3;
+            break;
+        default:
+            throw new InvalidKeyError(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 PrefixV2.Ed25519PublicKeyHash:
+            tag = 0;
+            break;
+        case PrefixV2.Secp256k1PublicKeyHash:
+            tag = 1;
+            break;
+        case PrefixV2.P256PublicKeyHash:
+            tag = 2;
+            break;
+        case PrefixV2.BLS12_381PublicKeyHash:
+            tag = 3;
+            break;
+        default:
+            throw new InvalidAddressError(value, 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 !== PrefixV2.BLS12_381PublicKeyHash) {
+        throw new InvalidKeyError(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 === PrefixV2.ContractHash ||
+        pre === PrefixV2.SmartRollupHash ||
+        pre === PrefixV2.ZkRollupHash) {
+        let tag;
+        switch (pre) {
+            case PrefixV2.ContractHash:
+                tag = 1;
+                break;
+            case PrefixV2.SmartRollupHash:
+                tag = 3;
+                break;
+            case PrefixV2.ZkRollupHash:
+                tag = 4;
+                break;
+        }
+        buf[0] = tag;
+        buf.set(data, 1);
+    }
+    else {
+        let tag;
+        switch (pre) {
+            case PrefixV2.Ed25519PublicKeyHash:
+                tag = 0;
+                break;
+            case PrefixV2.Secp256k1PublicKeyHash:
+                tag = 1;
+                break;
+            case PrefixV2.P256PublicKeyHash:
+                tag = 2;
+                break;
+            case PrefixV2.BLS12_381PublicKeyHash:
+                tag = 3;
+                break;
+            default:
+                throw new InvalidAddressError(value, 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.from(value, 'hex')) : value;
-    const n = new Uint8Array(prefix.length + payloadAr.length);
-    n.set(prefix);
-    n.set(payloadAr, prefix.length);
-    return bs58check.encode(Buffer.from(n.buffer));
+function getPkhfromPk(publicKey) {
+    const [key, pre] = b58DecodeAndCheckPrefix(publicKey);
+    let pkhPre;
+    switch (pre) {
+        case PrefixV2.P256PublicKey:
+            pkhPre = PrefixV2.P256PublicKeyHash;
+            break;
+        case PrefixV2.Secp256k1PublicKey:
+            pkhPre = PrefixV2.Secp256k1PublicKeyHash;
+            break;
+        case PrefixV2.Ed25519PublicKey:
+            pkhPre = PrefixV2.Ed25519PublicKeyHash;
+            break;
+        case PrefixV2.BLS12_381PublicKey:
+            pkhPre = PrefixV2.BLS12_381PublicKeyHash;
+            break;
+        default:
+            throw new InvalidPublicKeyError(publicKey, ValidationResult.NO_PREFIX_MATCHED);
+    }
+    const hashed = 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 = PrefixV2.Ed25519PublicKey;
+            break;
+        case 1:
+            pre = PrefixV2.Secp256k1PublicKey;
+            break;
+        case 2:
+            pre = PrefixV2.P256PublicKey;
+            break;
+        case 3:
+            pre = 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)]);
+function encodeKeyHash(value) {
+    let buf;
+    if (typeof value === 'string') {
+        buf = hex2buf(value);
+    }
+    else {
+        buf = value;
+    }
+    let pre;
+    switch (buf[0]) {
+        case 0:
+            pre = PrefixV2.Ed25519PublicKeyHash;
+            break;
+        case 1:
+            pre = PrefixV2.Secp256k1PublicKeyHash;
+            break;
+        case 2:
+            pre = PrefixV2.P256PublicKeyHash;
+            break;
+        case 3:
+            pre = PrefixV2.BLS12_381PublicKeyHash;
+            break;
+        default:
+            throw new Error('invalid address format');
     }
-    return b58cencode(value.substring(2, 42), prefix.KT);
+    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);
+    let buf;
+    if (typeof value === 'string') {
+        buf = hex2buf(value);
+    }
+    else {
+        buf = 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)]);
+    switch (buf[0]) {
+        case 0: // implicit
+            return encodeKeyHash(buf.slice(1));
+        case 1: // contract hash
+            return b58Encode(buf.slice(1, 21), PrefixV2.ContractHash);
+        case 3: // smart rollup hash
+            return b58Encode(buf.slice(1, 21), PrefixV2.SmartRollupHash);
+        case 4: // zk rollup hash
+            return b58Encode(buf.slice(1, 21), PrefixV2.ZkRollupHash);
+        default:
+            throw new Error('invalid address format');
     }
-    return b58cencode(value.substring(2, 42), prefix.KT);
 }
 /**
- *
  * @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, 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 = hash(hex2buf(value), 32);
+    return b58Encode(blakeHash, 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, 167]),
-        };
-        return b58cencode(value.substring(2), pref[value.substring(0, 2)]);
-    }
+function encodeOpHash(value) {
+    const blakeHash = hash(hex2buf(value), 32);
+    return b58Encode(blakeHash, 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 InvalidHexStringError(hex, `: Expecting even number of characters`);
+        throw new InvalidHexStringError(hex, `Expecting even number of characters`);
     }
-    const hexDigits = stripHexPrefix(hex);
-    if (!hexDigits.match(/^([\da-f]{2})*$/gi)) {
-        throw new 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 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 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') {
@@ -767,7 +1202,7 @@ const mic2arr = function me2(s) {
     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 = {
@@ -793,110 +1228,43 @@ const mic2arr = function me2(s) {
         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 Prefix.EDPK:
-            encodingPrefix = prefix[Prefix.TZ1];
-            prefixLen = prefixLength[Prefix.TZ1];
-            break;
-        case Prefix.SPPK:
-            encodingPrefix = prefix[Prefix.TZ2];
-            prefixLen = prefixLength[Prefix.TZ2];
-            break;
-        case Prefix.P2PK:
-            encodingPrefix = prefix[Prefix.TZ3];
-            prefixLen = prefixLength[Prefix.TZ3];
-            break;
-        case Prefix.BLPK:
-            encodingPrefix = prefix[Prefix.TZ4];
-            prefixLen = prefixLength[Prefix.TZ4];
-    }
-    const hashed = 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.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.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.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.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 InvalidHexStringError(hex, `: Expecting even number of characters: 0-9, a-z, A-Z, optionally prefixed with 0x`);
+        throw new InvalidHexStringError(hex, `Expecting even number of characters: 0-9, a-z, A-Z, optionally prefixed with 0x`);
     }
     return 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) {
@@ -906,7 +1274,6 @@ function numToHexBuffer(val, bitLength = 8) {
     return 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
@@ -948,6 +1315,113 @@ function padHexWithZero(hex, targetLength) {
 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 b58DecodeAndCheckPrefix 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.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.from(hex2buf(hex)).toString('utf8');
+}
 
-export { InvalidProtocolHashError, Prefix, VERSION, ValidationResult, ValueConversionError, b58cdecode, b58cencode, b58decode, b58decodeL2Address, buf2hex, bytes2Char, bytesToString, char2Bytes, encodeAddress, encodeExpr, encodeKey, encodeKeyHash, encodeL2Address, encodeOpHash, encodePubKey, format, getPkhfromPk, hex2Bytes, hex2buf, invalidDetail, isValidPrefix, mergebuf, mic2arr, num2PaddedHex, numToHexBuffer, prefix, prefixLength, stringToBytes, stripHexPrefix, toHexBuf, validateAddress, validateBlock, validateChain, validateContractAddress, validateKeyHash, validateOperation, validatePkAndExtractPrefix, validateProtocol, validatePublicKey, validateSignature, validateSmartRollupAddress, validateSpendingKey, verifySignature };
+export { BLS12_381_DST, InvalidProtocolHashError, POP_DST, Prefix, PrefixV2, VERSION, ValueConversionError, addressPrefixes, b58DecodeAddress, b58DecodeAndCheckPrefix, b58DecodeBlsAddress, b58DecodePublicKey, b58DecodePublicKeyHash, b58Encode, b58cdecode, b58cencode, b58decode, b58decodeL2Address, buf2hex, bytes2Char, bytesToString, char2Bytes, compareArrays, encodeAddress, encodeBlsAddress, encodeExpr, encodeKey, encodeKeyHash, encodeL2Address, encodeOpHash, encodePubKey, format, getPkhfromPk, hex2Bytes, hex2buf, invalidDetail, isValidPrefixedValue, mergebuf, mic2arr, num2PaddedHex, numToHexBuffer, payloadLength, prefix, prefixLength, publicKeyHashPrefixes, publicKeyPrefixes, signaturePrefixes, splitAddress, stringToBytes, stripHexPrefix, toHexBuf, validateAddress, validateBlock, validateChain, validateContractAddress, validateKeyHash, validateOperation, validatePkAndExtractPrefix, validateProtocol, validatePublicKey, validateSignature, validateSmartRollupAddress, validateSpendingKey, verifySignature };
 //# sourceMappingURL=taquito-utils.es6.js.map