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

package/dist/taquito-utils.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-utils.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-utils.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/constants.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @deprecated use PrefixV2 instead, this enum will be removed in the next minor release
+ * @description base58 prefix definition enum
+ */
 export declare enum Prefix {
     TZ1 = "tz1",// ed25519_public_key_hash
     TZ2 = "tz2",// secp256k1_public_key_hash
@@ -41,6 +45,10 @@ export declare enum Prefix {
     SRC1 = "src1",// smart_rollup_commitment
     SH = "sh"
 }
+/**
+ * @deprecated use prefixV2 instead this constant will be removed in the next minor release
+ * @description base58 prefix to bytes mapping
+ */
 export declare const prefix: {
     tz1: Uint8Array;
     tz2: Uint8Array;
@@ -84,6 +92,88 @@ export declare const prefix: {
     src1: Uint8Array;
     sh: Uint8Array;
 };
+/**
+ * @deprecated use payloadLength instead this constant will be removed in the next minor release
+ * @description base58 prefix to payload length mapping
+ */
 export declare const prefixLength: {
     [key: string]: number;
 };
+/**
+ * @description base58 name to prefix mapping
+ */
+export declare enum PrefixV2 {
+    BlockHash = "B",
+    OperationHash = "o",
+    OperationListHash = "Lo",
+    OperationListListHash = "LLo",
+    ProtocolHash = "P",
+    ContextHash = "Co",
+    BlockMetadataHash = "bm",
+    OperationMetadataHash = "r",
+    OperationMetadataListHash = "Lr",
+    OperationMetadataListListHash = "LLr",
+    Ed25519PublicKeyHash = "tz1",
+    Secp256k1PublicKeyHash = "tz2",
+    P256PublicKeyHash = "tz3",
+    ContractHash = "KT1",
+    BlindedPublicKeyHash = "btz1",
+    BLS12_381PublicKeyHash = "tz4",
+    TXRollupAddress = "txr1",
+    ZkRollupHash = "epx1",
+    ScRollupHash = "scr1",
+    SmartRollupHash = "sr1",
+    CryptoboxPublicKeyHash = "id",
+    Ed25519Seed = "edsk",
+    Ed25519PublicKey = "edpk",
+    Secp256k1SecretKey = "spsk",
+    P256SecretKey = "p2sk",
+    BLS12_381SecretKey = "BLsk",
+    ValueHash = "vh",
+    CycleNonce = "nce",
+    ScriptExpr = "expr",
+    InboxHash = "txi",
+    MessageHash = "txm",
+    CommitmentHash = "txc",
+    MessageResultHash = "txmr",
+    MessageResultListHash = "txM",
+    WithdrawListHash = "txw",
+    ScRollupStateHash = "scs1",
+    ScRollupCommitmentHash = "scc1",
+    SmartRollupStateHash = "srs1",
+    SmartRollupCommitmentHash = "src1",
+    Ed25519EncryptedSeed = "edesk",
+    Secp256k1EncryptedSecretKey = "spesk",
+    P256EncryptedSecretKey = "p2esk",
+    BLS12_381EncryptedSecretKey = "BLesk",
+    Secp256k1EncryptedScalar = "seesk",
+    Secp256k1PublicKey = "sppk",
+    P256PublicKey = "p2pk",
+    Secp256k1Scalar = "SSp",
+    Secp256k1Element = "GSp",
+    Ed25519SecretKey = "_edsk",
+    Ed25519Signature = "edsig",
+    Secp256k1Signature = "spsig1",
+    P256Signature = "p2sig",
+    GenericSignature = "sig",
+    ChainID = "Net",
+    SaplingSpendingKey = "sask",
+    EncryptedSaplingSpendingKey = "_sask",
+    SaplingAddress = "zet1",
+    GenericAggregateSignature = "asig",
+    BLS12_381Signature = "BLsig",
+    BLS12_381PublicKey = "BLpk",
+    SlotHeader = "sh"
+}
+/**
+ * @description base58 prefix to bytes mapping
+ */
+export declare const prefixV2: {
+    [key in PrefixV2]: Uint8Array;
+};
+/**
+ * @description base58 prefix to payload length mapping
+ */
+export declare const payloadLength: {
+    [key in PrefixV2]: number;
+};

package/dist/types/errors.d.ts

@@ -1,4 +1,4 @@
-import { ParameterValidationError, UnsupportedActionError } from '@taquito/core';
+import { ParameterValidationError, UnsupportedActionError, ValidationResult } from '@taquito/core';
 export { InvalidAddressError, InvalidBlockHashError, InvalidHexStringError, InvalidMessageError, InvalidKeyError, InvalidPublicKeyError, InvalidSignatureError, InvalidContractAddressError, InvalidChainIdError, InvalidKeyHashError, InvalidOperationHashError, InvalidOperationKindError, DeprecationError, ProhibitedActionError, } from '@taquito/core';
 /**
  *  @category Error
@@ -6,9 +6,8 @@ export { InvalidAddressError, InvalidBlockHashError, InvalidHexStringError, Inva
  */
 export declare class InvalidProtocolHashError extends ParameterValidationError {
     readonly protocolHash: string;
-    readonly errorDetails?: string | undefined;
     name: string;
-    constructor(protocolHash: string, errorDetails?: string | undefined);
+    constructor(protocolHash: string, errorDetails?: string | ValidationResult);
 }
 /**
  *  @category Error

package/dist/types/taquito-utils.d.ts

@@ -3,179 +3,178 @@
  * @module @taquito/utils
  */
 import { Buffer } from 'buffer';
+import { PrefixV2 } from './constants';
 import BigNumber from 'bignumber.js';
 export * from './validators';
 export { VERSION } from './version';
 export { prefix, Prefix, prefixLength } from './constants';
-export { verifySignature, validatePkAndExtractPrefix } from './verify-signature';
+export { PrefixV2, payloadLength } from './constants';
+export { validatePkAndExtractPrefix } from './verify-signature';
+export { verifySignature, BLS12_381_DST, POP_DST } from './verify-signature';
 export * from './errors';
 export { format } from './format';
 /**
- *
- * @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
  */
-export declare function encodeExpr(value: string): string;
+export declare const addressPrefixes: PrefixV2[];
 /**
- *
- * @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
  */
-export declare function encodeOpHash(value: string): string;
+export declare const publicKeyPrefixes: PrefixV2[];
 /**
- *
- * @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 list of prefixes that can be used to decode a public key hash
  */
-export declare function b58cencode(value: string | Uint8Array, prefix: Uint8Array): string;
+export declare const publicKeyHashPrefixes: PrefixV2[];
 /**
- *
- * @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 list of prefixes that can be used to decode a signature
  */
-export declare const b58cdecode: (enc: string, prefixArg: Uint8Array) => Uint8Array;
+export declare const signaturePrefixes: PrefixV2[];
 /**
- *
- * @description Base58 decode a string with predefined prefix
- *
- * @param value Value to base58 decode
+ * @description Decodes Base58 string, looks for known prefix and strips it
+ * @param src Base58 string
+ * @returns Payload and prefix
+ * @example b58DecodeAndCheckPrefix('tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM') // returns [Uint8Array, PrefixV2.Ed25519PublicKeyHash]
+ * @example b58DecodeAndCheckPrefix('tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM', [PrefixV2.Ed25519PublicKeyHash]) // returns [Uint8Array, PrefixV2.Ed25519PublicKeyHash]
+ * @example b58DecodeAndCheckPrefix('tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM', [PrefixV2.Ed25519PublicKeyHash], true) // returns Uint8Array
  */
-export declare function b58decode(payload: string): string;
+export declare function b58DecodeAndCheckPrefix<T extends readonly PrefixV2[]>(src: string, allowed?: T): [Uint8Array, T[number]];
+export declare function b58DecodeAndCheckPrefix<T extends readonly PrefixV2[]>(src: string, allowed: T, payloadOnly: false): [Uint8Array, T[number]];
+export declare function b58DecodeAndCheckPrefix<T extends readonly PrefixV2[]>(src: string, allowed: T, payloadOnly: true): Uint8Array;
 /**
- *
- * @description b58 decode a string without predefined prefix
- * @param value
- * @returns string of bytes
- * @deprecated use b58decode instead
+ * @description Decode a Base58 public key and return its binary representation
+ * @param value Value to decode
+ * @param fmt optional format of the decoded return value, 'hex' or 'array'
+ * @returns string or Uint8Array of bytes
+ * @example b58DecodePublicKey('edpkuNjKKT48xBoT5asPrWdmuM1Yw8D93MwgFgVvtca8jb5pstzaCh') // return '0060842d4ba23a9940ef5dcf4404fdaa430cfaaccb5029fad06cb5ea894e4562ae'
  */
-export declare function b58decodeL2Address(payload: string): string;
+export declare function b58DecodePublicKey(value: string, fmt?: 'hex'): string;
+export declare function b58DecodePublicKey(value: string, fmt: 'array'): Uint8Array;
 /**
- *
- * @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 Decode a Base58 public key hash and return its binary representation
+ * @param value Value to decode
+ * @param fmt optional format of the decoded return value, 'hex' or 'array'
+ * @returns string or Uint8Array of bytes
+ * @example b58DecodePublicKeyHash('tz2MVED1t9Jery77Bwm1m5YhUx8Wp5KWWRQe') // return '0001907d6a7e9f084df840d6e67ffa8db5464f87d4d1'
  */
-export declare function encodePubKey(value: string): string;
+export declare function b58DecodePublicKeyHash(value: string, fmt?: 'hex'): string;
+export declare function b58DecodePublicKeyHash(value: string, fmt: 'array'): Uint8Array;
 /**
- *
- * @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 Decode a Base58 string and assert tz4 type
+ * @param value a bls address(tz4) to decode
+ * @param fmt optional format of the decoded return value, 'hex' or 'array'
+ * @returns string or Uint8Array of bytes
+ * @example b58DecodeBlsAddress('tz4QyWfEiv56CVDATV3DT3CDVhPaMKif2Ce8') // return 'af2dc3c40667abc0e89c0ef40171d22aed08d5eb'
  */
-export declare function encodeAddress(value: string): string;
+export declare function b58DecodeBlsAddress(value: string, fmt?: 'hex'): string;
+export declare function b58DecodeBlsAddress(value: string, fmt: 'array'): Uint8Array;
+/**
+ * @description Decode a Base58 contract ID and return its binary representation
+ * @param value Value to decode
+ * @param fmt optional format of the decoded return value, 'hex' or 'array'
+ * @returns string or Uint8Array of bytes
+ * @example b58DecodeAddress('tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM') // return '0000e96b9f8b19af9c7ffa0c0480e1977b295850961f'
+ */
+export declare function b58DecodeAddress(value: string, fmt?: 'hex'): string;
+export declare function b58DecodeAddress(value: string, fmt: 'array'): Uint8Array;
+/**
+ *  @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'
+ */
+export declare function getPkhfromPk(publicKey: string): 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'
+ */
+export declare function b58Encode(value: string | Uint8Array, pre: PrefixV2): string;
+/**
+ * @description Parse binary public key and return Base58 representation
+ * @param value Binary key data
+ * @returns return prefixed public key
+ * @example encodeKey('02033aba7da4a2e7b5dd9f074555c118829aff16213ea1b65859686bd5fcfeaf3616') // return 'p2pk66xmhjiN7LpfrDGFwpxPtJxkLtPjQ6HUxJbKmRbxSR7RMpamDwi'
+ */
+export declare function encodeKey(value: string | Uint8Array): string;
+/**
+ * @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'
+ */
+export declare function encodeKeyHash(value: string | Uint8Array): string;
+/**
+ * @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'
+ */
+export declare function encodeAddress(value: string | Uint8Array): string;
 /**
- *
  * @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'
  */
-export declare function encodeL2Address(value: string): string;
+export declare function encodeBlsAddress(value: string): string;
 /**
- *
- * @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'
  */
-export declare function encodeKey(value: string): string | undefined;
+export declare function encodeExpr(value: string): string;
 /**
- *
- * @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'
  */
-export declare function encodeKeyHash(value: string): string | undefined;
+export declare function encodeOpHash(value: string): string;
 /**
- *
  * @description Convert an hex string to a Uint8Array
- *
  * @param hex Hex string to convert
  * @throws {@link ValueConversionError}
  */
-export declare const hex2buf: (hex: string) => Uint8Array;
+export declare function hex2buf(hex: string): Uint8Array;
 /**
- *
  * @description Merge 2 buffers together
- *
  * @param b1 First buffer
  * @param b2 Second buffer
  */
-export declare const mergebuf: (b1: Uint8Array, b2: Uint8Array) => Uint8Array;
+export declare function mergebuf(b1: Uint8Array, b2: Uint8Array): Uint8Array;
 /**
- *
  * @description Flatten a michelson json representation to an array
- *
  * @param s michelson json
  */
-export declare const mic2arr: (s: any) => any;
+export declare function mic2arr(s: any): any;
 /**
- *
  * @description Convert a Uint8Array to an hex string
- *
  * @param buffer Uint8Array to convert
  */
-export declare const buf2hex: (buffer: Uint8Array) => string;
+export declare function buf2hex(bytes: ArrayLike<number>): string;
 /**
- *
- *  @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
- */
-export declare const getPkhfromPk: (publicKey: string) => string;
-/**
- *
- * @description Convert a string to bytes
- *
- * @param str String to convert
- * @deprecated use stringToBytes instead, same functionality with a more descriptive name
- */
-export declare function char2Bytes(str: string): string;
-/**
- *
  * @description Convert a string to a byte string representation
- *
  * @param str String to convert
  */
 export declare function stringToBytes(str: string): string;
 /**
- *
- * @description Convert bytes to a string
- *
- * @param str Bytes to convert
- * @deprecated use hexStringToBytes instead, same functionality with a more descriptive name
- */
-export declare function bytes2Char(hex: string): string;
-/**
- *
  * @description Convert byte string representation to string
- *
- * @param str byte string to convert
+ * @param hex byte string to convert
  */
 export declare function bytesToString(hex: string): string;
 /**
- *
  * @description Convert hex string/UintArray/Buffer to bytes
- *
  * @param hex String value to convert to bytes
  */
 export declare function hex2Bytes(hex: string): Buffer;
 /**
- *
  * @description Converts a number or Bignumber to hexadecimal  string
- *
  * @param val The value  that will be converted to a hexadecimal string value
  */
 export declare function toHexBuf(val: number | BigNumber, bitLength?: number): Buffer;
 export declare function numToHexBuffer(val: number | BigNumber, bitLength?: number): Buffer;
 /**
- *
  * @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
@@ -189,3 +188,57 @@ export declare function num2PaddedHex(val: number | BigNumber, bitLength?: numbe
  * @param hex string to strip prefix from
  */
 export declare function stripHexPrefix(hex: string): string;
+export declare function splitAddress(addr: string): [string, string | null];
+export declare function compareArrays(a: ArrayLike<number>, b: ArrayLike<number>): number;
+/**
+ * @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
+ */
+export declare function b58cdecode(enc: string, prefixArg: Uint8Array): Uint8Array;
+/**
+ * @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
+ */
+export declare function b58cencode(value: string | Uint8Array, prefix: Uint8Array): string;
+/**
+ * @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
+ */
+export declare function b58decode(payload: string): string;
+/**
+ * @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
+ */
+export declare function b58decodeL2Address(payload: string): string;
+/**
+ * @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)
+ */
+export declare function encodePubKey(value: string): string;
+/**
+ * @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
+ */
+export declare function encodeL2Address(value: string): string;
+/**
+ * @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
+ */
+export declare function char2Bytes(str: string): string;
+/**
+ * @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
+ */
+export declare function bytes2Char(hex: string): string;

package/dist/types/validators.d.ts

@@ -1,16 +1,23 @@
-import { Prefix } from './constants';
-export declare enum ValidationResult {
-    NO_PREFIX_MATCHED = 0,
-    INVALID_CHECKSUM = 1,
-    INVALID_LENGTH = 2,
-    VALID = 3
-}
-export declare function isValidPrefix(value: unknown): value is Prefix;
+import { PrefixV2 } from './constants';
+import { ValidationResult } from './taquito-utils';
+export { ValidationResult } from '@taquito/core';
+/**
+ * @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
+ * ```
+ */
+export declare function isValidPrefixedValue(value: string, prefixes?: PrefixV2[]): boolean;
 /**
  * @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
  * ```
@@ -26,7 +33,7 @@ export declare function validateAddress(value: string): ValidationResult;
  * @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
  * ```
@@ -42,7 +49,7 @@ export declare function validateChain(value: string): ValidationResult;
  * @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
  * ```
@@ -58,7 +65,7 @@ export declare function validateContractAddress(value: string): ValidationResult
  * @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
  * ```
@@ -74,7 +81,7 @@ export declare function validateKeyHash(value: string): ValidationResult;
  * @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
  * ```
@@ -90,7 +97,7 @@ export declare function validateSignature(value: string): ValidationResult;
  * @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
  * ```
@@ -106,7 +113,7 @@ export declare function validatePublicKey(value: string): ValidationResult;
  * @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
  * ```
@@ -122,7 +129,7 @@ export declare function validateOperation(value: string): ValidationResult;
  * @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
  * ```
@@ -138,7 +145,7 @@ export declare function validateProtocol(value: string): ValidationResult;
  * @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
  * ```
@@ -150,11 +157,16 @@ export declare function validateProtocol(value: string): ValidationResult;
  * ```
  */
 export declare function validateBlock(value: string): ValidationResult;
+/**
+ * @deprecated this function will be removed in the next minor release
+ * @description generates a readable error string from a validation result
+ */
+export declare function invalidDetail(validation: ValidationResult): string;
 /**
  * @description Used to check if a spending key is valid.
- * @returns 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
  *
  */
-export declare function validateSpendingKey(value: any): ValidationResult;
-export declare function invalidDetail(validation: ValidationResult): string;
+export declare function validateSpendingKey(value: string): ValidationResult;
 export declare function validateSmartRollupAddress(value: string): ValidationResult;

package/dist/types/verify-signature.d.ts

@@ -1,12 +1,13 @@
-import { Prefix } from './taquito-utils';
-type PkPrefix = Prefix.EDPK | Prefix.SPPK | Prefix.P2PK | Prefix.BLPK;
+import { PrefixV2 } from './taquito-utils';
+export declare const BLS12_381_DST = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_";
+export declare const POP_DST = "BLS_POP_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_";
 /**
  * @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 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
@@ -19,6 +20,11 @@ type PkPrefix = Prefix.EDPK | Prefix.SPPK | Prefix.P2PK | Prefix.BLPK;
  * ```
  *
  */
-export declare function verifySignature(messageBytes: string, publicKey: string, signature: string, watermark?: Uint8Array): boolean;
+export declare function verifySignature(message: string | Uint8Array, publicKey: string, signature: string, watermark?: Uint8Array, pop?: boolean): boolean;
+type PkPrefix = PrefixV2.Ed25519PublicKey | PrefixV2.Secp256k1PublicKey | PrefixV2.P256PublicKey | PrefixV2.BLS12_381PublicKey;
+/**
+ * @deprecated use b58DecodeAndCheckPrefix instead, this function will be removed in the next minor release
+ * @description validates a public key and extracts the prefix
+ */
 export declare function validatePkAndExtractPrefix(publicKey: string): PkPrefix;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/utils",
-  "version": "22.0.0-beta.0",
+  "version": "23.0.0-RC.0",
   "description": "converts michelson data and types into convenient JS/TS objects",
   "keywords": [
     "tezos",
@@ -62,9 +62,10 @@
     ]
   },
   "dependencies": {
+    "@noble/curves": "^1.9.6",
     "@stablelib/blake2b": "^1.0.1",
     "@stablelib/ed25519": "^1.0.3",
-    "@taquito/core": "^22.0.0-beta.0",
+    "@taquito/core": "^23.0.0-RC.0",
     "@types/bs58check": "^2.1.2",
     "bignumber.js": "^9.1.2",
     "blakejs": "^1.2.1",
@@ -101,5 +102,5 @@
     "ts-toolbelt": "^9.6.0",
     "typescript": "~5.5.4"
   },
-  "gitHead": "239ae96ca142f3f63ecfc7e51731c115c3fe322f"
+  "gitHead": "3bdb33e97e705d1c7090dd83e1b243e6e2a4d768"
 }