@taquito/utils 19.0.2 → 19.1.0-RC.2

package/README.md

@@ -135,15 +135,15 @@ console.log(isValid);
 
 **Conversion between hexadecimal and ASCII strings**
 ```ts
-import { char2Bytes, bytes2Char } from '@taquito/utils';
+import { stringToBytes, bytesToString } from '@taquito/utils';
 
 const url = 'https://storage.googleapis.com/tzip-16/fa2-views.json';
 const hex = '68747470733a2f2f73746f726167652e676f6f676c65617069732e636f6d2f747a69702d31362f6661322d76696577732e6a736f6e';
 
-console.log(char2Bytes(url));
+console.log(stringToBytes(url));
 // output: 68747470733a2f2f73746f726167652e676f6f676c65617069732e636f6d2f747a69702d31362f6661322d76696577732e6a736f6e
 
-console.log(bytes2Char(hex));
+console.log(bytesToString(hex));
 // output: https://storage.googleapis.com/tzip-16/fa2-views.json
 ```
 
@@ -194,12 +194,12 @@ console.log(encodeKey('0060842d4ba23a9940ef5dcf4404fdaa430cfaaccb5029fad06cb5ea8
 
 **Base58 encode an address using a predefined prefix**
 ```ts
-import { encodePubKey } from '@taquito/utils'; 
+import { encodeAddress } from '@taquito/utils'; 
 
-console.log(encodePubKey('0000e96b9f8b19af9c7ffa0c0480e1977b295850961f'));
+console.log(encodeAddress('0000e96b9f8b19af9c7ffa0c0480e1977b295850961f'));
 // output: tz1gvF4cD2dDtqitL3ZTraggSR1Mju2BKFEM
 
-console.log(encodePubKey('01f9b689a478253793bd92357c5e08e5ebcd8db47600'));
+console.log(encodeAddress('01f9b689a478253793bd92357c5e08e5ebcd8db47600'));
 // output: KT1XM8VUFBiM9AC5czWU15fEeE9nmuEYWt3Y
 ```
 

package/dist/lib/taquito-utils.js

@@ -18,7 +18,7 @@ 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.stripHexPrefix = exports.num2PaddedHex = exports.toHexBuf = exports.hex2Bytes = exports.bytes2Char = exports.char2Bytes = exports.getPkhfromPk = exports.buf2hex = exports.mic2arr = exports.mergebuf = exports.hex2buf = exports.encodeKeyHash = exports.encodeKey = exports.encodeL2Address = exports.encodePubKey = exports.b58decodeL2Address = exports.b58decode = exports.b58cdecode = exports.b58cencode = exports.encodeOpHash = exports.encodeExpr = exports.format = exports.validatePkAndExtractPrefix = exports.verifySignature = exports.prefixLength = exports.Prefix = exports.prefix = exports.VERSION = void 0;
+exports.stripHexPrefix = exports.num2PaddedHex = exports.numToHexBuffer = exports.toHexBuf = exports.hex2Bytes = exports.bytesToString = exports.bytes2Char = exports.stringToBytes = exports.char2Bytes = exports.getPkhfromPk = exports.buf2hex = exports.mic2arr = exports.mergebuf = exports.hex2buf = exports.encodeKeyHash = exports.encodeKey = exports.encodeL2Address = exports.encodeAddress = exports.encodePubKey = exports.b58decodeL2Address = exports.b58decode = exports.b58cdecode = exports.b58cencode = exports.encodeOpHash = exports.encodeExpr = exports.format = exports.validatePkAndExtractPrefix = exports.verifySignature = exports.prefixLength = exports.Prefix = exports.prefix = exports.VERSION = void 0;
 /*
  * Some code in this file is originally from sotez and eztz
  * Copyright (c) 2018 Andrew Kishino
@@ -133,6 +133,7 @@ exports.b58decodeL2Address = b58decodeL2Address;
  * @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
  */
 function encodePubKey(value) {
     if (value.substring(0, 2) === '00') {
@@ -146,6 +147,27 @@ function encodePubKey(value) {
     return b58cencode(value.substring(2, 42), constants_1.prefix.KT);
 }
 exports.encodePubKey = encodePubKey;
+/**
+ *
+ * @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
+ */
+function encodeAddress(value) {
+    if (value.substring(0, 2) === '0x') {
+        value = value.slice(2);
+    }
+    if (value.substring(0, 2) === '00') {
+        const pref = {
+            '0000': constants_1.prefix.tz1,
+            '0001': constants_1.prefix.tz2,
+            '0002': constants_1.prefix.tz3,
+        };
+        return b58cencode(value.substring(4), pref[value.substring(0, 4)]);
+    }
+    return b58cencode(value.substring(2, 42), constants_1.prefix.KT);
+}
+exports.encodeAddress = encodeAddress;
 /**
  *
  * @description Base58 encode an address without predefined prefix
@@ -343,21 +365,43 @@ 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');
 }
 exports.char2Bytes = char2Bytes;
+/**
+ *
+ * @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');
+}
+exports.stringToBytes = stringToBytes;
 /**
  *
  * @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');
 }
 exports.bytes2Char = bytes2Char;
+/**
+ *
+ * @description Convert byte string representation to string
+ *
+ * @param str byte string to convert
+ */
+function bytesToString(hex) {
+    return buffer_1.Buffer.from((0, exports.hex2buf)(hex)).toString('utf8');
+}
+exports.bytesToString = bytesToString;
 /**
  *
  * @description Convert hex string/UintArray/Buffer to bytes
@@ -382,6 +426,10 @@ function toHexBuf(val, bitLength = 8) {
     return buffer_1.Buffer.from(num2PaddedHex(val, bitLength), 'hex');
 }
 exports.toHexBuf = toHexBuf;
+function numToHexBuffer(val, bitLength = 8) {
+    return buffer_1.Buffer.from(num2PaddedHex(val, bitLength), 'hex');
+}
+exports.numToHexBuffer = numToHexBuffer;
 /**
  *
  * @description Converts a number or BigNumber to a padded hexadecimal string

package/dist/lib/version.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 exports.VERSION = {
-    "commitHash": "13a12ab7cf442043526745db2bbf4ef3b089c34a",
-    "version": "19.0.2"
+    "commitHash": "1aa9945ea2318318f16f494216a1c09801fa4bf8",
+    "version": "19.1.0-RC.2"
 };

package/dist/taquito-utils.es6.js

@@ -492,8 +492,8 @@ function validateSmartRollupAddress(value) {
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "13a12ab7cf442043526745db2bbf4ef3b089c34a",
-    "version": "19.0.2"
+    "commitHash": "1aa9945ea2318318f16f494216a1c09801fa4bf8",
+    "version": "19.1.0-RC.2"
 };
 
 const TZ_DECIMALS = 6;
@@ -609,6 +609,7 @@ function b58decodeL2Address(payload) {
  * @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
  */
 function encodePubKey(value) {
     if (value.substring(0, 2) === '00') {
@@ -621,6 +622,26 @@ function encodePubKey(value) {
     }
     return b58cencode(value.substring(2, 42), prefix.KT);
 }
+/**
+ *
+ * @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
+ */
+function encodeAddress(value) {
+    if (value.substring(0, 2) === '0x') {
+        value = value.slice(2);
+    }
+    if (value.substring(0, 2) === '00') {
+        const pref = {
+            '0000': prefix.tz1,
+            '0001': prefix.tz2,
+            '0002': prefix.tz3,
+        };
+        return b58cencode(value.substring(4), pref[value.substring(0, 4)]);
+    }
+    return b58cencode(value.substring(2, 42), prefix.KT);
+}
 /**
  *
  * @description Base58 encode an address without predefined prefix
@@ -810,19 +831,39 @@ const getPkhfromPk = (publicKey) => {
  * @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');
 }
+/**
+ *
+ * @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
+ */
+function bytesToString(hex) {
+    return Buffer.from(hex2buf(hex)).toString('utf8');
+}
 /**
  *
  * @description Convert hex string/UintArray/Buffer to bytes
@@ -845,6 +886,9 @@ function hex2Bytes(hex) {
 function toHexBuf(val, bitLength = 8) {
     return Buffer.from(num2PaddedHex(val, bitLength), 'hex');
 }
+function numToHexBuffer(val, bitLength = 8) {
+    return Buffer.from(num2PaddedHex(val, bitLength), 'hex');
+}
 /**
  *
  * @description Converts a number or BigNumber to a padded hexadecimal string
@@ -889,5 +933,5 @@ function stripHexPrefix(hex) {
     return hex.startsWith('0x') ? hex.slice(2) : hex;
 }
 
-export { InvalidProtocolHashError, Prefix, VERSION, ValidationResult, ValueConversionError, b58cdecode, b58cencode, b58decode, b58decodeL2Address, buf2hex, bytes2Char, char2Bytes, encodeExpr, encodeKey, encodeKeyHash, encodeL2Address, encodeOpHash, encodePubKey, format, getPkhfromPk, hex2Bytes, hex2buf, invalidDetail, isValidPrefix, mergebuf, mic2arr, num2PaddedHex, prefix, prefixLength, stripHexPrefix, toHexBuf, validateAddress, validateBlock, validateChain, validateContractAddress, validateKeyHash, validateOperation, validatePkAndExtractPrefix, validateProtocol, validatePublicKey, validateSignature, validateSmartRollupAddress, validateSpendingKey, verifySignature };
+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 };
 //# sourceMappingURL=taquito-utils.es6.js.map

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

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

package/dist/taquito-utils.umd.js

@@ -487,8 +487,8 @@
 
   // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
   const VERSION = {
-      "commitHash": "13a12ab7cf442043526745db2bbf4ef3b089c34a",
-      "version": "19.0.2"
+      "commitHash": "1aa9945ea2318318f16f494216a1c09801fa4bf8",
+      "version": "19.1.0-RC.2"
   };
 
   const TZ_DECIMALS = 6;
@@ -604,6 +604,7 @@
    * @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
    */
   function encodePubKey(value) {
       if (value.substring(0, 2) === '00') {
@@ -616,6 +617,26 @@
       }
       return b58cencode(value.substring(2, 42), prefix.KT);
   }
+  /**
+   *
+   * @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
+   */
+  function encodeAddress(value) {
+      if (value.substring(0, 2) === '0x') {
+          value = value.slice(2);
+      }
+      if (value.substring(0, 2) === '00') {
+          const pref = {
+              '0000': prefix.tz1,
+              '0001': prefix.tz2,
+              '0002': prefix.tz3,
+          };
+          return b58cencode(value.substring(4), pref[value.substring(0, 4)]);
+      }
+      return b58cencode(value.substring(2, 42), prefix.KT);
+  }
   /**
    *
    * @description Base58 encode an address without predefined prefix
@@ -805,19 +826,39 @@
    * @description Convert a string to bytes
    *
    * @param str String to convert
+   * @deprecated use stringToBytes instead, same functionality with a more descriptive name
    */
   function char2Bytes(str) {
       return buffer.Buffer.from(str, 'utf8').toString('hex');
   }
+  /**
+   *
+   * @description Convert a string to a byte string representation
+   *
+   * @param str String to convert
+   */
+  function stringToBytes(str) {
+      return buffer.Buffer.from(str, 'utf8').toString('hex');
+  }
   /**
    *
    * @description Convert bytes to a string
    *
    * @param str Bytes to convert
+   * @deprecated use hexStringToBytes instead, same functionality with a more descriptive name
    */
   function bytes2Char(hex) {
       return buffer.Buffer.from(hex2buf(hex)).toString('utf8');
   }
+  /**
+   *
+   * @description Convert byte string representation to string
+   *
+   * @param str byte string to convert
+   */
+  function bytesToString(hex) {
+      return buffer.Buffer.from(hex2buf(hex)).toString('utf8');
+  }
   /**
    *
    * @description Convert hex string/UintArray/Buffer to bytes
@@ -840,6 +881,9 @@
   function toHexBuf(val, bitLength = 8) {
       return buffer.Buffer.from(num2PaddedHex(val, bitLength), 'hex');
   }
+  function numToHexBuffer(val, bitLength = 8) {
+      return buffer.Buffer.from(num2PaddedHex(val, bitLength), 'hex');
+  }
   /**
    *
    * @description Converts a number or BigNumber to a padded hexadecimal string
@@ -949,7 +993,9 @@
   exports.b58decodeL2Address = b58decodeL2Address;
   exports.buf2hex = buf2hex;
   exports.bytes2Char = bytes2Char;
+  exports.bytesToString = bytesToString;
   exports.char2Bytes = char2Bytes;
+  exports.encodeAddress = encodeAddress;
   exports.encodeExpr = encodeExpr;
   exports.encodeKey = encodeKey;
   exports.encodeKeyHash = encodeKeyHash;
@@ -965,8 +1011,10 @@
   exports.mergebuf = mergebuf;
   exports.mic2arr = mic2arr;
   exports.num2PaddedHex = num2PaddedHex;
+  exports.numToHexBuffer = numToHexBuffer;
   exports.prefix = prefix;
   exports.prefixLength = prefixLength;
+  exports.stringToBytes = stringToBytes;
   exports.stripHexPrefix = stripHexPrefix;
   exports.toHexBuf = toHexBuf;
   exports.validateAddress = validateAddress;

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/taquito-utils.d.ts

@@ -59,8 +59,16 @@ export declare function b58decodeL2Address(payload: string): string;
  * @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
  */
 export declare function encodePubKey(value: string): string;
+/**
+ *
+ * @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
+ */
+export declare function encodeAddress(value: string): string;
 /**
  *
  * @description Base58 encode an address without predefined prefix
@@ -125,15 +133,31 @@ 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
+ */
+export declare function bytesToString(hex: string): string;
 /**
  *
  * @description Convert hex string/UintArray/Buffer to bytes
@@ -148,6 +172,7 @@ export declare function hex2Bytes(hex: string): Buffer;
  * @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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/utils",
-  "version": "19.0.2",
+  "version": "19.1.0-RC.2",
   "description": "converts michelson data and types into convenient JS/TS objects",
   "keywords": [
     "tezos",
@@ -64,7 +64,7 @@
   "dependencies": {
     "@stablelib/blake2b": "^1.0.1",
     "@stablelib/ed25519": "^1.0.3",
-    "@taquito/core": "^19.0.2",
+    "@taquito/core": "^19.1.0-RC.2",
     "@types/bs58check": "^2.1.0",
     "bignumber.js": "^9.1.2",
     "blakejs": "^1.2.1",
@@ -101,5 +101,5 @@
     "ts-toolbelt": "^9.6.0",
     "typescript": "~5.2.2"
   },
-  "gitHead": "ede4790173abf0f153b87fec23a36e1b2b8114e2"
+  "gitHead": "72feb924392ac02aa06f08a9c4f535a876ac57d8"
 }