@layerzerolabs/common-encoding-utils 0.2.113 → 0.2.115

package/dist/index.d.ts

@@ -1,20 +1,18 @@
+import type { HexString } from '@layerzerolabs/typescript-utils';
 export * from './byte-codec';
 export * from './uuid';
-export type HexString = `0x${string}`;
 export declare function isBase58(address: string): boolean;
 export declare function isBase64(address: string): boolean;
-export declare function isHexString(value: any, length?: number): value is HexString;
+export declare function isHexString(value: any, length?: number): boolean;
 export declare function hexZeroPad(value: string, length: number): HexString;
 export declare function trim0x(str: string): string;
 export declare function ensure0xPrefixed(str: string): HexString;
 export declare function trimLeadingZeros(hexString: string): HexString;
-export declare function hexToUint8Array(hexString: string): Uint8Array;
 export declare function hexToAscii(hex: string): string;
-export declare function stringToUint8Array(str: string): Uint8Array;
 /**
- * A function to convert hex string to Uint8Array (not prefixed)
- * @param hex hex string
- * @returns Uint8Array
+ * Bytes from a `0x`-prefixed (or bare) hex string. The single canonical hex decoder.
+ * Throws on non-hex and on odd-length input: a dangling half-byte is always a caller bug,
+ * never silently padded or truncated.
  */
 export declare function hexToBytes(hex: string): Uint8Array;
 export declare function bytesToHex(bytes: Uint8Array | ArrayBuffer): string;
@@ -25,23 +23,19 @@ export declare function bytesToHex(bytes: Uint8Array | ArrayBuffer): string;
 export declare function bytesToHexPrefixed(bytes: Uint8Array | ArrayBuffer): HexString;
 /**
  * Big-endian `bigint` from a hex string. Empty hex (`''` / `'0x'`) is `0n`.
- * Replaces the inline `BigInt('0x' + ...)` / `BigInt(\`0x${hex}\`)` idiom.
  */
 export declare function hexToBigInt(hex: string): bigint;
 /**
  * Big-endian `bigint` from bytes. Empty input is `0n`.
- * Replaces the inline `BigInt('0x' + buf.toString('hex'))` idiom.
  */
 export declare function bytesToBigInt(bytes: Uint8Array | ArrayBuffer): bigint;
 /**
  * Big-endian bytes from a non-negative `bigint`, left-padded to `byteLength`. The inverse of
- * `bytesToBigInt`. Throws on a negative value or one too wide for `byteLength` (via `bigIntToHex` /
- * `hexZeroPad`). Replaces the inline `new BN(v).toBuffer('be', n)` / `writeBigUInt*` idiom.
+ * `bytesToBigInt`. Throws on a negative value or one too wide for `byteLength`.
  */
 export declare function bigIntToBytes(value: bigint, byteLength: number): Uint8Array;
 /**
  * `0x`-hex from a non-negative `bigint`, optionally left-padded to `byteLength` bytes.
- * Replaces the inline `'0x' + v.toString(16)` (± `padStart`) idiom.
  * Without `byteLength` the output is minimal and may be odd-length (e.g. `0xabc`), which
  * `hexToBytes` rejects — use `bigIntToBytes(value, byteLength)` when you need bytes.
  */
@@ -52,8 +46,6 @@ export declare function bigIntToHex(value: bigint, byteLength?: number): HexStri
 export declare function numberToHex(value: number, byteLength?: number): HexString;
 /**
  * `number` from a hex string. Throws if the value exceeds `Number.MAX_SAFE_INTEGER`.
- * Replaces the inline `parseInt(hex, 16)` / `Number('0x' + hex)` idiom (which silently
- * lose precision past 2^53).
  */
 export declare function hexToNumber(hex: string): number;
 export declare function bytesToBase64(bytes: Uint8Array | ArrayBuffer): string;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AAEvB,MAAM,MAAM,SAAS,GAAG,KAAK,MAAM,EAAE,CAAC;AAMtC,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,IAAI,SAAS,CAQ3E;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAUnE;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAEvD;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAS7D;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAE7D;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAiB9C;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAI1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAIlD;AAOD,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,MAAM,CAIlE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,SAAS,CAE7E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM/C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,MAAM,CAGrE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,UAAU,CAE3E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAMzE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAMzE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM/C;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,MAAM,CAIrE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAExD;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAsBrD;AAED,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAK3D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAMvD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,MAAM,CAErE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAEpD;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAqBD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,OAAO,SAAM,UAGnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AAQvB,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEjD;AAKD,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAUhE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAoBnE;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAEvD;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAS7D;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAYlD;AAOD,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,MAAM,CAElE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,SAAS,CAE7E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM/C;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,MAAM,CAGrE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,UAAU,CAE3E;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAMzE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAMzE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM/C;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,MAAM,CAErE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAOxD;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAE3D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAMvD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,MAAM,CAErE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAEpD;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAqBD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,OAAO,SAAM,UAGnE"}

package/dist/index.js

@@ -18,16 +18,20 @@ function isHexString(value, length) {
   if (typeof value !== "string" || !value.match(hexStringRegex)) {
     return false;
   }
-  if (length && value.length !== 2 + 2 * length) {
+  if (length && trim0x(value).length !== 2 * length) {
     return false;
   }
   return true;
 }
 __name(isHexString, "isHexString");
 function hexZeroPad(value, length) {
+  if (!Number.isSafeInteger(length) || length < 0) {
+    throw new Error("byteLength must be a non-negative safe integer");
+  }
   if (!isHexString(value)) {
-    throw new Error(`invalid hex string: ${value}`);
+    throw new Error(`invalid hex string (length ${value.length})`);
   }
+  value = ensure0xPrefixed(value);
   if (value.length > 2 * length + 2) {
     throw new Error("value out of range");
   }
@@ -48,37 +52,19 @@ function trimLeadingZeros(hexString) {
   return ensure0xPrefixed(withoutPrefix);
 }
 __name(trimLeadingZeros, "trimLeadingZeros");
-function hexToUint8Array(hexString) {
-  return Uint8Array.from(Buffer.from(trim0x(hexString), "hex"));
-}
-__name(hexToUint8Array, "hexToUint8Array");
 function hexToAscii(hex) {
-  if (!isHexString(hex)) {
-    throw new Error(`Invalid hex string ${hex}`);
-  }
-  let str = "";
-  let i = 0;
-  const l = hex.length;
-  if (hex.startsWith("0x")) {
-    i = 2;
-  }
-  for (; i < l; i += 2) {
-    const code = parseInt(hex.slice(i, i + 2), 16);
-    str += String.fromCharCode(code);
-  }
-  return str;
+  return Array.from(hexToBytes(hex), (b) => String.fromCharCode(b)).join("");
 }
 __name(hexToAscii, "hexToAscii");
-function stringToUint8Array(str) {
-  const value = str.replace(/^0x/i, "");
-  const len = value.length + 1 - (value.length + 1) % 2;
-  return Uint8Array.from(Buffer.from(value.padStart(len, "0"), "hex"));
-}
-__name(stringToUint8Array, "stringToUint8Array");
 function hexToBytes(hex) {
-  const value = hex.replace(/^0x/i, "");
-  const len = value.length + 1 - (value.length + 1) % 2;
-  return Uint8Array.from(Buffer.from(value.padStart(len, "0"), "hex"));
+  if (!isHexString(hex)) {
+    throw new Error(`invalid hex string (length ${hex.length})`);
+  }
+  const body = trim0x(hex);
+  if (body.length % 2 !== 0) {
+    throw new Error(`hex string has an odd length (${body.length})`);
+  }
+  return Uint8Array.from(Buffer.from(body, "hex"));
 }
 __name(hexToBytes, "hexToBytes");
 function asUint8Array(bytes) {
@@ -86,7 +72,7 @@ function asUint8Array(bytes) {
 }
 __name(asUint8Array, "asUint8Array");
 function bytesToHex(bytes) {
-  return Buffer.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes).toString("hex");
+  return Buffer.from(asUint8Array(bytes)).toString("hex");
 }
 __name(bytesToHex, "bytesToHex");
 function bytesToHexPrefixed(bytes) {
@@ -134,34 +120,22 @@ function hexToNumber(hex) {
 }
 __name(hexToNumber, "hexToNumber");
 function bytesToBase64(bytes) {
-  return Buffer.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes).toString("base64");
+  return Buffer.from(asUint8Array(bytes)).toString("base64");
 }
 __name(bytesToBase64, "bytesToBase64");
 function base64ToBytes(base64) {
+  if (!isBase64(base64) || base64.length % 4 !== 0) {
+    throw new Error(`invalid base64 string (length ${base64.length})`);
+  }
   return Uint8Array.from(Buffer.from(base64, "base64"));
 }
 __name(base64ToBytes, "base64ToBytes");
 function hexToBase64(hexString) {
-  const hex = trim0x(hexString);
-  if (!/^[0-9a-fA-F]+$/.test(hex)) {
-    throw new Error(`Invalid hex string: ${hexString}`);
-  }
-  if (hex.length % 2 !== 0) {
-    throw new Error("Hex string must have an even length");
-  }
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-  }
-  const base64String = Buffer.from(bytes).toString("base64");
-  return base64String;
+  return bytesToBase64(hexToBytes(hexString));
 }
 __name(hexToBase64, "hexToBase64");
 function base64ToHex(base64String) {
-  if (!/^[A-Za-z0-9+/=]*$/.test(base64String)) {
-    throw new Error(`Invalid base64 string: ${base64String}`);
-  }
-  return `0x${Buffer.from(base64String, "base64").toString("hex")}`;
+  return bytesToHexPrefixed(base64ToBytes(base64String));
 }
 __name(base64ToHex, "base64ToHex");
 function base58ToBytes(value) {
@@ -209,6 +183,6 @@ function padAlignHex(str, byteSize = 8, padding = "0") {
 }
 __name(padAlignHex, "padAlignHex");
 
-export { base58ToBytes, base58ToHex, base64ToBytes, base64ToHex, bigIntToBytes, bigIntToHex, bytesToBase58, bytesToBase64, bytesToBigInt, bytesToHex, bytesToHexPrefixed, ensure0xPrefixed, hexToAscii, hexToBase58, hexToBase64, hexToBigInt, hexToBytes, hexToNumber, hexToUint8Array, hexZeroPad, isBase58, isBase64, isHexString, numberToHex, padAlignHex, stringToUint8Array, trim0x, trimLeadingZeros };
+export { base58ToBytes, base58ToHex, base64ToBytes, base64ToHex, bigIntToBytes, bigIntToHex, bytesToBase58, bytesToBase64, bytesToBigInt, bytesToHex, bytesToHexPrefixed, ensure0xPrefixed, hexToAscii, hexToBase58, hexToBase64, hexToBigInt, hexToBytes, hexToNumber, hexZeroPad, isBase58, isBase64, isHexString, numberToHex, padAlignHex, trim0x, trimLeadingZeros };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["base58regex","base64regex","hexStringRegex","isBase58","address","test","isBase64","isHexString","value","length","match","hexZeroPad","Error","trim0x","padStart","str","replace","ensure0xPrefixed","trimLeadingZeros","hexString","withoutPrefix","hexToUint8Array","Uint8Array","from","Buffer","hexToAscii","hex","i","l","startsWith","code","parseInt","slice","String","fromCharCode","stringToUint8Array","len","hexToBytes","asUint8Array","bytes","ArrayBuffer","bytesToHex","toString","bytesToHexPrefixed","hexToBigInt","body","BigInt","bytesToBigInt","bigIntToBytes","byteLength","bigIntToHex","undefined","numberToHex","Number","isSafeInteger","hexToNumber","MAX_SAFE_INTEGER","bytesToBase64","base64ToBytes","base64","hexToBase64","substr","base64String","base64ToHex","base58ToBytes","bs58","decode","bytesToBase58","encode","base58ToHex","hexToBase58","padString","left","padding","diff","result","pad","repeat","padLeft","calcByteLength","byteSize","remainder","padAlignHex","trimmed"],"mappings":"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","file":"index.js","sourcesContent":["import bs58 from 'bs58';\n\nexport * from './byte-codec';\nexport * from './uuid';\n\nexport type HexString = `0x${string}`;\n\nconst base58regex = /^[A-HJ-NP-Za-km-z1-9]*$/;\nconst base64regex = /^[A-Za-z0-9+/]*={0,2}$/;\nconst hexStringRegex = /^(0x)?[0-9A-Fa-f]*$/;\n\nexport function isBase58(address: string): boolean {\n    return base58regex.test(address);\n}\n\nexport function isBase64(address: string): boolean {\n    return base64regex.test(address);\n}\n\nexport function isHexString(value: any, length?: number): value is HexString {\n    if (typeof value !== 'string' || !value.match(hexStringRegex)) {\n        return false;\n    }\n    if (length && value.length !== 2 + 2 * length) {\n        return false;\n    }\n    return true;\n}\n\nexport function hexZeroPad(value: string, length: number): HexString {\n    if (!isHexString(value)) {\n        throw new Error(`invalid hex string: ${value}`);\n    }\n\n    if (value.length > 2 * length + 2) {\n        throw new Error('value out of range');\n    }\n\n    return `0x${trim0x(value).padStart(2 * length, '0')}`;\n}\n\nexport function trim0x(str: string): string {\n    return str.replace(/^0x/, '');\n}\n\nexport function ensure0xPrefixed(str: string): HexString {\n    return `0x${trim0x(str)}`;\n}\n\nexport function trimLeadingZeros(hexString: string): HexString {\n    // Remove the '0x' prefix\n    let withoutPrefix = trim0x(hexString);\n\n    // Trim leading zeros\n    withoutPrefix = withoutPrefix.replace(/^0+/, '');\n\n    // Add back the '0x' prefix\n    return ensure0xPrefixed(withoutPrefix);\n}\n\nexport function hexToUint8Array(hexString: string): Uint8Array {\n    return Uint8Array.from(Buffer.from(trim0x(hexString), 'hex'));\n}\n\nexport function hexToAscii(hex: string): string {\n    if (!isHexString(hex)) {\n        throw new Error(`Invalid hex string ${hex}`);\n    }\n\n    let str = '';\n    let i = 0;\n    const l = hex.length;\n    if (hex.startsWith('0x')) {\n        i = 2;\n    }\n    for (; i < l; i += 2) {\n        const code = parseInt(hex.slice(i, i + 2), 16);\n        str += String.fromCharCode(code);\n    }\n\n    return str;\n}\n\nexport function stringToUint8Array(str: string): Uint8Array {\n    const value = str.replace(/^0x/i, '');\n    const len = value.length + 1 - ((value.length + 1) % 2);\n    return Uint8Array.from(Buffer.from(value.padStart(len, '0'), 'hex'));\n}\n\n/**\n * A function to convert hex string to Uint8Array (not prefixed)\n * @param hex hex string\n * @returns Uint8Array\n */\nexport function hexToBytes(hex: string): Uint8Array {\n    const value = hex.replace(/^0x/i, '');\n    const len = value.length + 1 - ((value.length + 1) % 2);\n    return Uint8Array.from(Buffer.from(value.padStart(len, '0'), 'hex'));\n}\n\n// Buffer.from copies a Uint8Array but reinterprets an ArrayBuffer's bytes; normalize to bytes first.\nfunction asUint8Array(bytes: Uint8Array | ArrayBuffer): Uint8Array {\n    return bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes;\n}\n\nexport function bytesToHex(bytes: Uint8Array | ArrayBuffer): string {\n    return Buffer.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes).toString(\n        'hex',\n    );\n}\n\n/**\n * 0x prefixed hex string from Uint8Array\n * @param bytes\n */\nexport function bytesToHexPrefixed(bytes: Uint8Array | ArrayBuffer): HexString {\n    return ensure0xPrefixed(bytesToHex(bytes));\n}\n\n/**\n * Big-endian `bigint` from a hex string. Empty hex (`''` / `'0x'`) is `0n`.\n * Replaces the inline `BigInt('0x' + ...)` / `BigInt(\\`0x${hex}\\`)` idiom.\n */\nexport function hexToBigInt(hex: string): bigint {\n    if (!isHexString(hex)) {\n        throw new Error(`invalid hex string (length ${hex.length})`);\n    }\n    const body = trim0x(hex);\n    return body === '' ? 0n : BigInt(`0x${body}`);\n}\n\n/**\n * Big-endian `bigint` from bytes. Empty input is `0n`.\n * Replaces the inline `BigInt('0x' + buf.toString('hex'))` idiom.\n */\nexport function bytesToBigInt(bytes: Uint8Array | ArrayBuffer): bigint {\n    const hex = bytesToHex(bytes);\n    return hex === '' ? 0n : BigInt(`0x${hex}`);\n}\n\n/**\n * Big-endian bytes from a non-negative `bigint`, left-padded to `byteLength`. The inverse of\n * `bytesToBigInt`. Throws on a negative value or one too wide for `byteLength` (via `bigIntToHex` /\n * `hexZeroPad`). Replaces the inline `new BN(v).toBuffer('be', n)` / `writeBigUInt*` idiom.\n */\nexport function bigIntToBytes(value: bigint, byteLength: number): Uint8Array {\n    return hexToBytes(bigIntToHex(value, byteLength));\n}\n\n/**\n * `0x`-hex from a non-negative `bigint`, optionally left-padded to `byteLength` bytes.\n * Replaces the inline `'0x' + v.toString(16)` (± `padStart`) idiom.\n * Without `byteLength` the output is minimal and may be odd-length (e.g. `0xabc`), which\n * `hexToBytes` rejects — use `bigIntToBytes(value, byteLength)` when you need bytes.\n */\nexport function bigIntToHex(value: bigint, byteLength?: number): HexString {\n    if (value < 0n) {\n        throw new Error('cannot hex-encode a negative value');\n    }\n    const hex = ensure0xPrefixed(value.toString(16));\n    return byteLength === undefined ? hex : hexZeroPad(hex, byteLength);\n}\n\n/**\n * `0x`-hex from a non-negative integer, optionally left-padded to `byteLength` bytes.\n */\nexport function numberToHex(value: number, byteLength?: number): HexString {\n    // isSafeInteger (not isInteger): reject unsafe ints rather than encode a rounded value.\n    if (!Number.isSafeInteger(value) || value < 0) {\n        throw new Error('cannot hex-encode value: expected a non-negative safe integer');\n    }\n    return bigIntToHex(BigInt(value), byteLength);\n}\n\n/**\n * `number` from a hex string. Throws if the value exceeds `Number.MAX_SAFE_INTEGER`.\n * Replaces the inline `parseInt(hex, 16)` / `Number('0x' + hex)` idiom (which silently\n * lose precision past 2^53).\n */\nexport function hexToNumber(hex: string): number {\n    const value = hexToBigInt(hex);\n    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {\n        throw new Error(`hex value exceeds Number.MAX_SAFE_INTEGER (length ${hex.length})`);\n    }\n    return Number(value);\n}\n\nexport function bytesToBase64(bytes: Uint8Array | ArrayBuffer): string {\n    return Buffer.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes).toString(\n        'base64',\n    );\n}\n\nexport function base64ToBytes(base64: string): Uint8Array {\n    return Uint8Array.from(Buffer.from(base64, 'base64'));\n}\n\nexport function hexToBase64(hexString: string): string {\n    const hex = trim0x(hexString);\n    // Validate that the input is a valid hex string\n    if (!/^[0-9a-fA-F]+$/.test(hex)) {\n        throw new Error(`Invalid hex string: ${hexString}`);\n    }\n\n    // Ensure the hex string has an even length\n    if (hex.length % 2 !== 0) {\n        throw new Error('Hex string must have an even length');\n    }\n\n    // Convert hex string to a byte array\n    const bytes = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < hex.length; i += 2) {\n        bytes[i / 2] = parseInt(hex.substr(i, 2), 16);\n    }\n\n    // Convert the byte array to a base64 string\n    const base64String = Buffer.from(bytes).toString('base64');\n\n    return base64String;\n}\n\nexport function base64ToHex(base64String: string): HexString {\n    if (!/^[A-Za-z0-9+/=]*$/.test(base64String)) {\n        throw new Error(`Invalid base64 string: ${base64String}`);\n    }\n    return `0x${Buffer.from(base64String, 'base64').toString('hex')}`;\n}\n\nexport function base58ToBytes(value: string): Uint8Array {\n    if (!isBase58(value)) {\n        // Length only, never the value (consistent with the hex decoders).\n        throw new Error(`invalid base58 string (length ${value.length})`);\n    }\n    return bs58.decode(value);\n}\n\nexport function bytesToBase58(bytes: Uint8Array | ArrayBuffer): string {\n    return bs58.encode(asUint8Array(bytes));\n}\n\nexport function base58ToHex(value: string): HexString {\n    return bytesToHexPrefixed(base58ToBytes(value));\n}\n\nexport function hexToBase58(hex: string): string {\n    return bytesToBase58(hexToBytes(hex));\n}\n\nfunction padString(str: string, length: number, left: boolean, padding = '0') {\n    const diff = length - str.length;\n    let result = str;\n    if (diff > 0) {\n        const pad = padding.repeat(diff);\n        result = left ? pad + str : str + pad;\n    }\n    return result;\n}\n\nfunction padLeft(str: string, length: number, padding = '0') {\n    return padString(str, length, true, padding);\n}\nfunction calcByteLength(str: string, byteSize = 8) {\n    const { length } = str;\n    const remainder = length % byteSize;\n    return remainder ? ((length - remainder) / byteSize) * byteSize + byteSize : length;\n}\n\n/**\n * Pads a hex string on the left so its length is a multiple of `byteSize`.\n * Used to align hex strings.\n * @param str Hex string.\n * @param byteSize Group size to align to, in hex chars (default: 8).\n * @param padding Left-pad character (default: '0').\n * @returns Hex string left-padded to a multiple of `byteSize`.\n */\nexport function padAlignHex(str: string, byteSize = 8, padding = '0') {\n    const trimmed = trim0x(str);\n    return padLeft(trimmed, calcByteLength(trimmed, byteSize), padding);\n}\n"]}
+{"version":3,"sources":["../src/index.ts"],"names":["base58regex","base64regex","hexStringRegex","isBase58","address","test","isBase64","isHexString","value","length","match","trim0x","hexZeroPad","Number","isSafeInteger","Error","ensure0xPrefixed","padStart","str","replace","trimLeadingZeros","hexString","withoutPrefix","hexToAscii","hex","Array","from","hexToBytes","b","String","fromCharCode","join","body","Uint8Array","Buffer","asUint8Array","bytes","ArrayBuffer","bytesToHex","toString","bytesToHexPrefixed","hexToBigInt","BigInt","bytesToBigInt","bigIntToBytes","byteLength","bigIntToHex","undefined","numberToHex","hexToNumber","MAX_SAFE_INTEGER","bytesToBase64","base64ToBytes","base64","hexToBase64","base64ToHex","base64String","base58ToBytes","bs58","decode","bytesToBase58","encode","base58ToHex","hexToBase58","padString","left","padding","diff","result","pad","repeat","padLeft","calcByteLength","byteSize","remainder","padAlignHex","trimmed"],"mappings":"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","file":"index.js","sourcesContent":["import bs58 from 'bs58';\n\nimport type { HexString } from '@layerzerolabs/typescript-utils';\n\nexport * from './byte-codec';\nexport * from './uuid';\n\nconst base58regex = /^[A-HJ-NP-Za-km-z1-9]*$/;\nconst base64regex = /^[A-Za-z0-9+/]*={0,2}$/;\n// Lowercase `0x` prefix only: an uppercase `0X` is a manual-input error, not something any encoder\n// emits, so it's rejected rather than silently accepted. (The body charset matches either case.)\nconst hexStringRegex = /^(0x)?[0-9A-Fa-f]*$/;\n\nexport function isBase58(address: string): boolean {\n    return base58regex.test(address);\n}\n\nexport function isBase64(address: string): boolean {\n    return base64regex.test(address);\n}\n\n// Returns a plain boolean, not a `value is HexString` guard: the regex accepts unprefixed input\n// (e.g. 'deadbeef'), so a true result does not prove the `0x` prefix HexString requires. Callers\n// that need a HexString must run the value through ensure0xPrefixed.\nexport function isHexString(value: any, length?: number): boolean {\n    if (typeof value !== 'string' || !value.match(hexStringRegex)) {\n        return false;\n    }\n    // Measure the body, not the raw string: isHexString accepts unprefixed input, so a raw-length\n    // check would assume a 2-char `0x` and reject e.g. isHexString('deadbeef', 4).\n    if (length && trim0x(value).length !== 2 * length) {\n        return false;\n    }\n    return true;\n}\n\nexport function hexZeroPad(value: string, length: number): HexString {\n    if (!Number.isSafeInteger(length) || length < 0) {\n        // A fractional width (e.g. 1.5) produces odd-length output that hexToBytes would reject,\n        // so reject it here where bigIntToHex / bigIntToBytes / numberToHex all funnel through.\n        throw new Error('byteLength must be a non-negative safe integer');\n    }\n    if (!isHexString(value)) {\n        // Length only, never the value (can be sensitive).\n        throw new Error(`invalid hex string (length ${value.length})`);\n    }\n\n    // Normalize first: isHexString accepts unprefixed input, for which the `2 * length + 2`\n    // check below (which assumes a 2-char `0x`) would under-count by a byte and pass overflow.\n    value = ensure0xPrefixed(value);\n\n    if (value.length > 2 * length + 2) {\n        throw new Error('value out of range');\n    }\n\n    return `0x${trim0x(value).padStart(2 * length, '0')}`;\n}\n\nexport function trim0x(str: string): string {\n    return str.replace(/^0x/, '');\n}\n\nexport function ensure0xPrefixed(str: string): HexString {\n    return `0x${trim0x(str)}`;\n}\n\nexport function trimLeadingZeros(hexString: string): HexString {\n    // Remove the '0x' prefix\n    let withoutPrefix = trim0x(hexString);\n\n    // Trim leading zeros\n    withoutPrefix = withoutPrefix.replace(/^0+/, '');\n\n    // Add back the '0x' prefix\n    return ensure0xPrefixed(withoutPrefix);\n}\n\nexport function hexToAscii(hex: string): string {\n    return Array.from(hexToBytes(hex), (b) => String.fromCharCode(b)).join('');\n}\n\n/**\n * Bytes from a `0x`-prefixed (or bare) hex string. The single canonical hex decoder.\n * Throws on non-hex and on odd-length input: a dangling half-byte is always a caller bug,\n * never silently padded or truncated.\n */\nexport function hexToBytes(hex: string): Uint8Array {\n    if (!isHexString(hex)) {\n        // Length only, never the value (sometimes a private key).\n        throw new Error(`invalid hex string (length ${hex.length})`);\n    }\n    const body = trim0x(hex);\n    if (body.length % 2 !== 0) {\n        throw new Error(`hex string has an odd length (${body.length})`);\n    }\n    // The isHexString guard above is load-bearing: Buffer.from(_, 'hex') silently drops non-hex\n    // characters, so the pure-hex check is what makes this call safe.\n    return Uint8Array.from(Buffer.from(body, 'hex'));\n}\n\n// Buffer.from copies a Uint8Array but reinterprets an ArrayBuffer's bytes; normalize to bytes first.\nfunction asUint8Array(bytes: Uint8Array | ArrayBuffer): Uint8Array {\n    return bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes;\n}\n\nexport function bytesToHex(bytes: Uint8Array | ArrayBuffer): string {\n    return Buffer.from(asUint8Array(bytes)).toString('hex');\n}\n\n/**\n * 0x prefixed hex string from Uint8Array\n * @param bytes\n */\nexport function bytesToHexPrefixed(bytes: Uint8Array | ArrayBuffer): HexString {\n    return ensure0xPrefixed(bytesToHex(bytes));\n}\n\n/**\n * Big-endian `bigint` from a hex string. Empty hex (`''` / `'0x'`) is `0n`.\n */\nexport function hexToBigInt(hex: string): bigint {\n    if (!isHexString(hex)) {\n        throw new Error(`invalid hex string (length ${hex.length})`);\n    }\n    const body = trim0x(hex);\n    return body === '' ? 0n : BigInt(`0x${body}`);\n}\n\n/**\n * Big-endian `bigint` from bytes. Empty input is `0n`.\n */\nexport function bytesToBigInt(bytes: Uint8Array | ArrayBuffer): bigint {\n    const hex = bytesToHex(bytes);\n    return hex === '' ? 0n : BigInt(`0x${hex}`);\n}\n\n/**\n * Big-endian bytes from a non-negative `bigint`, left-padded to `byteLength`. The inverse of\n * `bytesToBigInt`. Throws on a negative value or one too wide for `byteLength`.\n */\nexport function bigIntToBytes(value: bigint, byteLength: number): Uint8Array {\n    return hexToBytes(bigIntToHex(value, byteLength));\n}\n\n/**\n * `0x`-hex from a non-negative `bigint`, optionally left-padded to `byteLength` bytes.\n * Without `byteLength` the output is minimal and may be odd-length (e.g. `0xabc`), which\n * `hexToBytes` rejects — use `bigIntToBytes(value, byteLength)` when you need bytes.\n */\nexport function bigIntToHex(value: bigint, byteLength?: number): HexString {\n    if (value < 0n) {\n        throw new Error('cannot hex-encode a negative value');\n    }\n    const hex = ensure0xPrefixed(value.toString(16));\n    return byteLength === undefined ? hex : hexZeroPad(hex, byteLength);\n}\n\n/**\n * `0x`-hex from a non-negative integer, optionally left-padded to `byteLength` bytes.\n */\nexport function numberToHex(value: number, byteLength?: number): HexString {\n    // isSafeInteger (not isInteger): reject unsafe ints rather than encode a rounded value.\n    if (!Number.isSafeInteger(value) || value < 0) {\n        throw new Error('cannot hex-encode value: expected a non-negative safe integer');\n    }\n    return bigIntToHex(BigInt(value), byteLength);\n}\n\n/**\n * `number` from a hex string. Throws if the value exceeds `Number.MAX_SAFE_INTEGER`.\n */\nexport function hexToNumber(hex: string): number {\n    const value = hexToBigInt(hex);\n    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {\n        throw new Error(`hex value exceeds Number.MAX_SAFE_INTEGER (length ${hex.length})`);\n    }\n    return Number(value);\n}\n\nexport function bytesToBase64(bytes: Uint8Array | ArrayBuffer): string {\n    return Buffer.from(asUint8Array(bytes)).toString('base64');\n}\n\nexport function base64ToBytes(base64: string): Uint8Array {\n    // isBase64 checks the alphabet/padding; the length must also be a multiple of 4, or Buffer.from\n    // silently drops the trailing partial group. Length only, never the value.\n    if (!isBase64(base64) || base64.length % 4 !== 0) {\n        throw new Error(`invalid base64 string (length ${base64.length})`);\n    }\n    return Uint8Array.from(Buffer.from(base64, 'base64'));\n}\n\nexport function hexToBase64(hexString: string): string {\n    // hexToBytes validates the input, so no separate hex check here.\n    return bytesToBase64(hexToBytes(hexString));\n}\n\nexport function base64ToHex(base64String: string): HexString {\n    return bytesToHexPrefixed(base64ToBytes(base64String));\n}\n\nexport function base58ToBytes(value: string): Uint8Array {\n    if (!isBase58(value)) {\n        // Length only, never the value (consistent with the hex decoders).\n        throw new Error(`invalid base58 string (length ${value.length})`);\n    }\n    return bs58.decode(value);\n}\n\nexport function bytesToBase58(bytes: Uint8Array | ArrayBuffer): string {\n    return bs58.encode(asUint8Array(bytes));\n}\n\nexport function base58ToHex(value: string): HexString {\n    return bytesToHexPrefixed(base58ToBytes(value));\n}\n\nexport function hexToBase58(hex: string): string {\n    return bytesToBase58(hexToBytes(hex));\n}\n\nfunction padString(str: string, length: number, left: boolean, padding = '0') {\n    const diff = length - str.length;\n    let result = str;\n    if (diff > 0) {\n        const pad = padding.repeat(diff);\n        result = left ? pad + str : str + pad;\n    }\n    return result;\n}\n\nfunction padLeft(str: string, length: number, padding = '0') {\n    return padString(str, length, true, padding);\n}\nfunction calcByteLength(str: string, byteSize = 8) {\n    const { length } = str;\n    const remainder = length % byteSize;\n    return remainder ? ((length - remainder) / byteSize) * byteSize + byteSize : length;\n}\n\n/**\n * Pads a hex string on the left so its length is a multiple of `byteSize`.\n * Used to align hex strings.\n * @param str Hex string.\n * @param byteSize Group size to align to, in hex chars (default: 8).\n * @param padding Left-pad character (default: '0').\n * @returns Hex string left-padded to a multiple of `byteSize`.\n */\nexport function padAlignHex(str: string, byteSize = 8, padding = '0') {\n    const trimmed = trim0x(str);\n    return padLeft(trimmed, calcByteLength(trimmed, byteSize), padding);\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/common-encoding-utils",
-  "version": "0.2.113",
+  "version": "0.2.115",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -16,13 +16,14 @@
     "dist/**/*"
   ],
   "dependencies": {
-    "bs58": "^5.0.0"
+    "bs58": "^5.0.0",
+    "@layerzerolabs/typescript-utils": "0.2.115"
   },
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.6",
-    "@layerzerolabs/tsup-configuration": "0.2.113",
-    "@layerzerolabs/typescript-configuration": "0.2.113"
+    "@layerzerolabs/typescript-configuration": "0.2.115",
+    "@layerzerolabs/tsup-configuration": "0.2.115"
   },
   "publishConfig": {
     "access": "public",
@@ -33,6 +34,7 @@
       "audit-external",
       "console-pen-test",
       "layerzero-ver",
+      "monorepo-external",
       "onesig-client"
     ]
   },