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

package/dist/lib/taquito-utils.js

@@ -18,26 +18,41 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPkhfromPk = exports.buf2hex = exports.mic2arr = exports.mergebuf = exports.hex2buf = exports.b58cdecode = exports.format = exports.validatePkAndExtractPrefix = exports.verifySignature = exports.prefixLength = exports.Prefix = exports.prefix = exports.VERSION = void 0;
-exports.encodeExpr = encodeExpr;
-exports.encodeOpHash = encodeOpHash;
-exports.b58cencode = b58cencode;
-exports.b58decode = b58decode;
-exports.b58decodeL2Address = b58decodeL2Address;
-exports.encodePubKey = encodePubKey;
-exports.encodeAddress = encodeAddress;
-exports.encodeL2Address = encodeL2Address;
+exports.signaturePrefixes = exports.publicKeyHashPrefixes = exports.publicKeyPrefixes = exports.addressPrefixes = exports.format = exports.POP_DST = exports.BLS12_381_DST = exports.verifySignature = exports.validatePkAndExtractPrefix = exports.payloadLength = exports.PrefixV2 = exports.prefixLength = exports.Prefix = exports.prefix = exports.VERSION = void 0;
+exports.b58DecodeAndCheckPrefix = b58DecodeAndCheckPrefix;
+exports.b58DecodePublicKey = b58DecodePublicKey;
+exports.b58DecodePublicKeyHash = b58DecodePublicKeyHash;
+exports.b58DecodeBlsAddress = b58DecodeBlsAddress;
+exports.b58DecodeAddress = b58DecodeAddress;
+exports.getPkhfromPk = getPkhfromPk;
+exports.b58Encode = b58Encode;
 exports.encodeKey = encodeKey;
 exports.encodeKeyHash = encodeKeyHash;
-exports.char2Bytes = char2Bytes;
+exports.encodeAddress = encodeAddress;
+exports.encodeBlsAddress = encodeBlsAddress;
+exports.encodeExpr = encodeExpr;
+exports.encodeOpHash = encodeOpHash;
+exports.hex2buf = hex2buf;
+exports.mergebuf = mergebuf;
+exports.mic2arr = mic2arr;
+exports.buf2hex = buf2hex;
 exports.stringToBytes = stringToBytes;
-exports.bytes2Char = bytes2Char;
 exports.bytesToString = bytesToString;
 exports.hex2Bytes = hex2Bytes;
 exports.toHexBuf = toHexBuf;
 exports.numToHexBuffer = numToHexBuffer;
 exports.num2PaddedHex = num2PaddedHex;
 exports.stripHexPrefix = stripHexPrefix;
+exports.splitAddress = splitAddress;
+exports.compareArrays = compareArrays;
+exports.b58cdecode = b58cdecode;
+exports.b58cencode = b58cencode;
+exports.b58decode = b58decode;
+exports.b58decodeL2Address = b58decodeL2Address;
+exports.encodePubKey = encodePubKey;
+exports.encodeL2Address = encodeL2Address;
+exports.char2Bytes = char2Bytes;
+exports.bytes2Char = bytes2Char;
 /*
  * Some code in this file is originally from sotez and eztz
  * Copyright (c) 2018 Andrew Kishino
@@ -45,246 +60,448 @@ exports.stripHexPrefix = stripHexPrefix;
  */
 const buffer_1 = require("buffer");
 const constants_1 = require("./constants");
-const verify_signature_1 = require("./verify-signature");
+const constants_2 = require("./constants"); // (deprecated will be removed in the next minor release)
 const blake2b_1 = require("@stablelib/blake2b");
-const blakejs_1 = require("blakejs");
 const bs58check_1 = require("bs58check");
-const errors_1 = require("./errors");
 const bignumber_js_1 = require("bignumber.js");
+const typedarray_to_buffer_1 = require("typedarray-to-buffer");
 const core_1 = require("@taquito/core");
+const validators_1 = require("./validators");
 __exportStar(require("./validators"), exports);
 var version_1 = require("./version");
 Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
-var constants_2 = require("./constants");
-Object.defineProperty(exports, "prefix", { enumerable: true, get: function () { return constants_2.prefix; } });
-Object.defineProperty(exports, "Prefix", { enumerable: true, get: function () { return constants_2.Prefix; } });
-Object.defineProperty(exports, "prefixLength", { enumerable: true, get: function () { return constants_2.prefixLength; } });
+var constants_3 = require("./constants"); // (deprecated will be removed in the next minor release)
+Object.defineProperty(exports, "prefix", { enumerable: true, get: function () { return constants_3.prefix; } });
+Object.defineProperty(exports, "Prefix", { enumerable: true, get: function () { return constants_3.Prefix; } });
+Object.defineProperty(exports, "prefixLength", { enumerable: true, get: function () { return constants_3.prefixLength; } });
+var constants_4 = require("./constants");
+Object.defineProperty(exports, "PrefixV2", { enumerable: true, get: function () { return constants_4.PrefixV2; } });
+Object.defineProperty(exports, "payloadLength", { enumerable: true, get: function () { return constants_4.payloadLength; } });
+var verify_signature_1 = require("./verify-signature"); // (deprecated will be removed in the next minor release)
+Object.defineProperty(exports, "validatePkAndExtractPrefix", { enumerable: true, get: function () { return verify_signature_1.validatePkAndExtractPrefix; } });
 var verify_signature_2 = require("./verify-signature");
 Object.defineProperty(exports, "verifySignature", { enumerable: true, get: function () { return verify_signature_2.verifySignature; } });
-Object.defineProperty(exports, "validatePkAndExtractPrefix", { enumerable: true, get: function () { return verify_signature_2.validatePkAndExtractPrefix; } });
+Object.defineProperty(exports, "BLS12_381_DST", { enumerable: true, get: function () { return verify_signature_2.BLS12_381_DST; } });
+Object.defineProperty(exports, "POP_DST", { enumerable: true, get: function () { return verify_signature_2.POP_DST; } });
 __exportStar(require("./errors"), exports);
 var format_1 = require("./format");
 Object.defineProperty(exports, "format", { enumerable: true, get: function () { return format_1.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
  */
-function encodeExpr(value) {
-    const blakeHash = blakejs_1.default.blake2b((0, exports.hex2buf)(value), undefined, 32);
-    return b58cencode(blakeHash, constants_1.prefix['expr']);
-}
+exports.addressPrefixes = [
+    constants_1.PrefixV2.P256PublicKeyHash,
+    constants_1.PrefixV2.Secp256k1PublicKeyHash,
+    constants_1.PrefixV2.Ed25519PublicKeyHash,
+    constants_1.PrefixV2.BLS12_381PublicKeyHash,
+    constants_1.PrefixV2.ContractHash,
+    constants_1.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 = blakejs_1.default.blake2b((0, exports.hex2buf)(value), undefined, 32);
-    return b58cencode(blakeHash, constants_1.prefix.o);
+exports.publicKeyPrefixes = [
+    constants_1.PrefixV2.P256PublicKey,
+    constants_1.PrefixV2.Secp256k1PublicKey,
+    constants_1.PrefixV2.Ed25519PublicKey,
+    constants_1.PrefixV2.BLS12_381PublicKey,
+];
+/**
+ * @description list of prefixes that can be used to decode a public key hash
+ */
+exports.publicKeyHashPrefixes = [
+    constants_1.PrefixV2.P256PublicKeyHash,
+    constants_1.PrefixV2.Secp256k1PublicKeyHash,
+    constants_1.PrefixV2.Ed25519PublicKeyHash,
+    constants_1.PrefixV2.BLS12_381PublicKeyHash,
+];
+/**
+ * @description list of prefixes that can be used to decode a signature
+ */
+exports.signaturePrefixes = [
+    constants_1.PrefixV2.P256Signature,
+    constants_1.PrefixV2.Secp256k1Signature,
+    constants_1.PrefixV2.Ed25519Signature,
+    constants_1.PrefixV2.BLS12_381Signature,
+    constants_1.PrefixV2.GenericSignature,
+];
+function b58DecodeAndCheckPrefix(src, allowed, payloadOnly) {
+    const buf = (() => {
+        try {
+            return bs58check_1.default.decode(src);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                if (err.message.includes('checksum')) {
+                    throw new core_1.ParameterValidationError(validators_1.ValidationResult.INVALID_CHECKSUM);
+                }
+                else {
+                    throw new core_1.ParameterValidationError(validators_1.ValidationResult.INVALID_ENCODING);
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    })();
+    let key;
+    for (key in constants_1.PrefixV2) {
+        const p = constants_1.PrefixV2[key];
+        const pre = constants_1.prefixV2[p];
+        if (buf.length === pre.length + constants_1.payloadLength[p] &&
+            buf.slice(0, pre.length).every((v, i) => v == pre[i])) {
+            if (allowed !== undefined && allowed.indexOf(p) < 0) {
+                throw new core_1.ParameterValidationError(validators_1.ValidationResult.PREFIX_NOT_ALLOWED);
+            }
+            if (payloadOnly) {
+                return buf.slice(pre.length);
+            }
+            else {
+                return [buf.slice(pre.length), p];
+            }
+        }
+    }
+    throw new core_1.ParameterValidationError(validators_1.ValidationResult.NO_PREFIX_MATCHED);
+}
+function b58DecodePublicKey(value, fmt) {
+    const [data, pre] = b58DecodeAndCheckPrefix(value, exports.publicKeyPrefixes);
+    let tag;
+    switch (pre) {
+        case constants_1.PrefixV2.Ed25519PublicKey:
+            tag = 0;
+            break;
+        case constants_1.PrefixV2.Secp256k1PublicKey:
+            tag = 1;
+            break;
+        case constants_1.PrefixV2.P256PublicKey:
+            tag = 2;
+            break;
+        case constants_1.PrefixV2.BLS12_381PublicKey:
+            tag = 3;
+            break;
+        default:
+            throw new core_1.InvalidKeyError(validators_1.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, exports.publicKeyHashPrefixes);
+    const buf = new Uint8Array(21);
+    let tag;
+    switch (pre) {
+        case constants_1.PrefixV2.Ed25519PublicKeyHash:
+            tag = 0;
+            break;
+        case constants_1.PrefixV2.Secp256k1PublicKeyHash:
+            tag = 1;
+            break;
+        case constants_1.PrefixV2.P256PublicKeyHash:
+            tag = 2;
+            break;
+        case constants_1.PrefixV2.BLS12_381PublicKeyHash:
+            tag = 3;
+            break;
+        default:
+            throw new core_1.InvalidAddressError(value, validators_1.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 !== constants_1.PrefixV2.BLS12_381PublicKeyHash) {
+        throw new core_1.InvalidKeyError(validators_1.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, exports.addressPrefixes);
+    const buf = new Uint8Array(22);
+    if (pre === constants_1.PrefixV2.ContractHash ||
+        pre === constants_1.PrefixV2.SmartRollupHash ||
+        pre === constants_1.PrefixV2.ZkRollupHash) {
+        let tag;
+        switch (pre) {
+            case constants_1.PrefixV2.ContractHash:
+                tag = 1;
+                break;
+            case constants_1.PrefixV2.SmartRollupHash:
+                tag = 3;
+                break;
+            case constants_1.PrefixV2.ZkRollupHash:
+                tag = 4;
+                break;
+        }
+        buf[0] = tag;
+        buf.set(data, 1);
+    }
+    else {
+        let tag;
+        switch (pre) {
+            case constants_1.PrefixV2.Ed25519PublicKeyHash:
+                tag = 0;
+                break;
+            case constants_1.PrefixV2.Secp256k1PublicKeyHash:
+                tag = 1;
+                break;
+            case constants_1.PrefixV2.P256PublicKeyHash:
+                tag = 2;
+                break;
+            case constants_1.PrefixV2.BLS12_381PublicKeyHash:
+                tag = 3;
+                break;
+            default:
+                throw new core_1.InvalidAddressError(value, validators_1.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_1.Buffer.from(value, 'hex')) : value;
-    const n = new Uint8Array(prefix.length + payloadAr.length);
-    n.set(prefix);
-    n.set(payloadAr, prefix.length);
-    return bs58check_1.default.encode(buffer_1.Buffer.from(n.buffer));
+function getPkhfromPk(publicKey) {
+    const [key, pre] = b58DecodeAndCheckPrefix(publicKey);
+    let pkhPre;
+    switch (pre) {
+        case constants_1.PrefixV2.P256PublicKey:
+            pkhPre = constants_1.PrefixV2.P256PublicKeyHash;
+            break;
+        case constants_1.PrefixV2.Secp256k1PublicKey:
+            pkhPre = constants_1.PrefixV2.Secp256k1PublicKeyHash;
+            break;
+        case constants_1.PrefixV2.Ed25519PublicKey:
+            pkhPre = constants_1.PrefixV2.Ed25519PublicKeyHash;
+            break;
+        case constants_1.PrefixV2.BLS12_381PublicKey:
+            pkhPre = constants_1.PrefixV2.BLS12_381PublicKeyHash;
+            break;
+        default:
+            throw new core_1.InvalidPublicKeyError(publicKey, validators_1.ValidationResult.NO_PREFIX_MATCHED);
+    }
+    const hashed = (0, blake2b_1.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_1.default.decode(enc).slice(prefixArg.length);
-exports.b58cdecode = b58cdecode;
+function b58Encode(value, pre) {
+    const data = typeof value === 'string' ? hex2buf(value) : value;
+    const p = constants_1.prefixV2[pre];
+    const n = new Uint8Array(p.length + data.length);
+    n.set(p);
+    n.set(data, p.length);
+    return bs58check_1.default.encode((0, typedarray_to_buffer_1.default)(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_1.default.decode(payload);
-    const prefixMap = {
-        [constants_1.prefix.tz1.toString()]: '0000',
-        [constants_1.prefix.tz2.toString()]: '0001',
-        [constants_1.prefix.tz3.toString()]: '0002',
-        [constants_1.prefix.tz4.toString()]: '0003',
-    };
-    const pref = prefixMap[new Uint8Array(buf.slice(0, 3)).toString()];
-    if (pref) {
-        // tz addresses
-        const hex = (0, exports.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' + (0, exports.buf2hex)(buf.slice(3, 42)) + '00';
+        buf = value;
     }
+    let pre;
+    switch (buf[0]) {
+        case 0:
+            pre = constants_1.PrefixV2.Ed25519PublicKey;
+            break;
+        case 1:
+            pre = constants_1.PrefixV2.Secp256k1PublicKey;
+            break;
+        case 2:
+            pre = constants_1.PrefixV2.P256PublicKey;
+            break;
+        case 3:
+            pre = constants_1.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_1.default.decode(payload);
-    // tz4 address currently
-    return (0, exports.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': constants_1.prefix.tz1,
-            '0001': constants_1.prefix.tz2,
-            '0002': constants_1.prefix.tz3,
-            '0003': constants_1.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;
     }
-    return b58cencode(value.substring(2, 42), constants_1.prefix.KT);
+    let pre;
+    switch (buf[0]) {
+        case 0:
+            pre = constants_1.PrefixV2.Ed25519PublicKeyHash;
+            break;
+        case 1:
+            pre = constants_1.PrefixV2.Secp256k1PublicKeyHash;
+            break;
+        case 2:
+            pre = constants_1.PrefixV2.P256PublicKeyHash;
+            break;
+        case 3:
+            pre = constants_1.PrefixV2.BLS12_381PublicKeyHash;
+            break;
+        default:
+            throw new Error('invalid address format');
+    }
+    return b58Encode(buf.slice(1, 21), pre);
 }
 /**
- *
- * @description Base58 encode an address using predefined prefix (tz1, tz2, tz3, or KT1 without annotation)
- *
- * @param value Address to base58 encode (tz1, tz2, tz3 or KT1). Supports value with or without '0x' prefix
+ * @description Parse binary Contract ID and return Base58 representation
+ * @param value Address to parse (tz1, tz2, tz3, KT1, or sr1).
+ * @example encodeAddress('0000e96b9f8b19af9c7ffa0c0480e1977b295850961f') // return 'tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM'
  */
 function encodeAddress(value) {
-    if (value.substring(0, 2) === '0x') {
-        value = value.slice(2);
+    let buf;
+    if (typeof value === 'string') {
+        buf = hex2buf(value);
+    }
+    else {
+        buf = value;
     }
-    if (value.substring(0, 2) === '00') {
-        const pref = {
-            '0000': constants_1.prefix.tz1,
-            '0001': constants_1.prefix.tz2,
-            '0002': constants_1.prefix.tz3,
-            '0003': constants_1.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), constants_1.PrefixV2.ContractHash);
+        case 3: // smart rollup hash
+            return b58Encode(buf.slice(1, 21), constants_1.PrefixV2.SmartRollupHash);
+        case 4: // zk rollup hash
+            return b58Encode(buf.slice(1, 21), constants_1.PrefixV2.ZkRollupHash);
+        default:
+            throw new Error('invalid address format');
     }
-    return b58cencode(value.substring(2, 42), constants_1.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, constants_1.prefix.tz4);
+function encodeBlsAddress(value) {
+    return b58Encode(value, constants_1.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 = (0, blake2b_1.hash)(hex2buf(value), 32);
+    return b58Encode(blakeHash, constants_1.PrefixV2.ScriptExpr);
 }
 /**
- *
- * @description Base58 encode a key hash according to its prefix
- *
- * @param value Key hash to base58 encode
+ * @description convert a signed operation in hex string to an 'op' prefix + base58 encoded BLAKE2b hash string
+ * @param value signed operation in hex string
+ * @returns return 'op' prefix + base58 encoded BLAKE2b hash
+ * @example encodeOpHash('0f185d8a30061e8134c162dbb7a6c3ab8f5fdb153363ccd6149b49a33481156a6c00b2e19a9e74440d86c59f13dab8a18ff873e889eaa304ab05da13000001f1585a7384f36e45fb43dc37e8ce172bced3e05700ff0000000002002110c033f3a990c2e46a3d6054ecc2f74072aae7a34b5ac4d9ce9edc11c2410a97695682108951786f05b361da03b97245dc9897e1955e08b5b8d9e153b0bdeb0d') // return 'opapqvVXmebRTCFd2GQFydr4tJj3V5QocQuTmuhbatcHm4Seo2t'
  */
-function encodeKeyHash(value) {
-    if (value[0] === '0') {
-        const pref = {
-            '00': new Uint8Array([6, 161, 159]),
-            '01': new Uint8Array([6, 161, 161]),
-            '02': new Uint8Array([6, 161, 164]),
-            '03': new Uint8Array([6, 161, 166]),
-        };
-        return b58cencode(value.substring(2), pref[value.substring(0, 2)]);
-    }
+function encodeOpHash(value) {
+    const blakeHash = (0, blake2b_1.hash)(hex2buf(value), 32);
+    return b58Encode(blakeHash, constants_1.PrefixV2.OperationHash);
 }
 /**
- *
  * @description Convert an hex string to a Uint8Array
- *
  * @param hex Hex string to convert
  * @throws {@link ValueConversionError}
  */
-const hex2buf = (hex) => {
+function hex2buf(hex) {
+    hex = hex.startsWith('0x') ? hex.slice(2) : hex;
     if (hex.length % 2 !== 0) {
-        throw new core_1.InvalidHexStringError(hex, `: Expecting even number of characters`);
+        throw new core_1.InvalidHexStringError(hex, `Expecting even number of characters`);
     }
-    const hexDigits = stripHexPrefix(hex);
-    if (!hexDigits.match(/^([\da-f]{2})*$/gi)) {
-        throw new core_1.InvalidHexStringError(hex, `: Only characters 0-9, a-f and A-F are expected. Optionally, it can be prefixed with '0x'`);
+    if (!hex.match(/^([\da-f]{2})*$/gi)) {
+        throw new core_1.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 errors_1.ValueConversionError(hex, 'Uint8Array');
+    for (let i = 0; i < hex.length; i += 2) {
+        const ss = hex.slice(i, i + 2);
+        const x = parseInt(ss, 16);
+        if (Number.isNaN(x)) {
+            throw new core_1.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;
-};
-exports.hex2buf = hex2buf;
+    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;
-};
-exports.mergebuf = mergebuf;
+}
 /**
- *
  * @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') {
@@ -297,7 +514,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 = {
@@ -323,113 +540,43 @@ const mic2arr = function me2(s) {
         ret = s;
     }
     return ret;
-};
-exports.mic2arr = mic2arr;
+}
 /**
- *
  * @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('');
-};
-exports.buf2hex = buf2hex;
-/**
- *
- *  @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 = (0, verify_signature_1.validatePkAndExtractPrefix)(publicKey);
-    const decoded = (0, exports.b58cdecode)(publicKey, constants_1.prefix[keyPrefix]);
-    switch (keyPrefix) {
-        case constants_1.Prefix.EDPK:
-            encodingPrefix = constants_1.prefix[constants_1.Prefix.TZ1];
-            prefixLen = constants_1.prefixLength[constants_1.Prefix.TZ1];
-            break;
-        case constants_1.Prefix.SPPK:
-            encodingPrefix = constants_1.prefix[constants_1.Prefix.TZ2];
-            prefixLen = constants_1.prefixLength[constants_1.Prefix.TZ2];
-            break;
-        case constants_1.Prefix.P2PK:
-            encodingPrefix = constants_1.prefix[constants_1.Prefix.TZ3];
-            prefixLen = constants_1.prefixLength[constants_1.Prefix.TZ3];
-            break;
-        case constants_1.Prefix.BLPK:
-            encodingPrefix = constants_1.prefix[constants_1.Prefix.TZ4];
-            prefixLen = constants_1.prefixLength[constants_1.Prefix.TZ4];
-    }
-    const hashed = (0, blake2b_1.hash)(decoded, prefixLen);
-    const result = b58cencode(hashed, encodingPrefix);
-    return result;
-};
-exports.getPkhfromPk = getPkhfromPk;
-/**
- *
- * @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_1.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_1.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_1.Buffer.from((0, exports.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_1.Buffer.from((0, exports.hex2buf)(hex)).toString('utf8');
+    return buffer_1.Buffer.from(hex2buf(hex)).toString('utf8');
 }
 /**
- *
  * @description Convert hex string/UintArray/Buffer to bytes
- *
  * @param hex String value to convert to bytes
  */
 function hex2Bytes(hex) {
     const hexDigits = stripHexPrefix(hex);
     if (!hexDigits.match(/^(0x)?([\da-f]{2})*$/gi)) {
-        throw new core_1.InvalidHexStringError(hex, `: Expecting even number of characters: 0-9, a-z, A-Z, optionally prefixed with 0x`);
+        throw new core_1.InvalidHexStringError(hex, `Expecting even number of characters: 0-9, a-z, A-Z, optionally prefixed with 0x`);
     }
     return buffer_1.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) {
@@ -439,7 +586,6 @@ function numToHexBuffer(val, bitLength = 8) {
     return buffer_1.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
@@ -481,3 +627,110 @@ 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_1.default.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_1.default.encode((0, typedarray_to_buffer_1.default)(n));
+}
+/**
+ * @deprecated use b58DecodePublicKey, b58DecodePublicKeyHash, b58DecodeBlsAddress, b58DecodeAddress instead, this function will be removed in the next minor release
+ * @description Base58 decode a string with predefined prefix
+ * @param payload Value to base58 decode
+ */
+function b58decode(payload) {
+    const buf = bs58check_1.default.decode(payload);
+    const prefixMap = {
+        [constants_2.prefix.tz1.toString()]: '0000',
+        [constants_2.prefix.tz2.toString()]: '0001',
+        [constants_2.prefix.tz3.toString()]: '0002',
+        [constants_2.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_1.default.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, constants_2.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_1.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_1.Buffer.from(hex2buf(hex)).toString('utf8');
+}