@secondlayer/stacks 6.0.0 → 6.1.1

package/dist/src/utils/index.cjs

@@ -1,73 +1,507 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
 // src/utils/index.ts
 var exports_utils = {};
 __export(exports_utils, {
-  writeUInt8: () => writeUInt8,
-  writeUInt32BE: () => writeUInt32BE,
-  writeUInt16BE: () => writeUInt16BE,
-  without0x: () => without0x,
-  with0x: () => with0x,
-  verifySignature: () => verifySignature,
-  verifyMessageSignature: () => verifyMessageSignature,
-  validateStacksAddress: () => validateStacksAddress,
-  utf8ToBytes: () => utf8ToBytes,
-  uncompressPublicKey: () => uncompressPublicKey,
-  txidFromBytes: () => txidFromBytes,
-  toTwos: () => toTwos,
-  signatureVrsToRsv: () => signatureVrsToRsv,
-  signatureRsvToVrs: () => signatureRsvToVrs,
-  sha512_256: () => import_sha22.sha512_256,
-  sha256: () => import_sha2.sha256,
-  serializeSignature: () => serializeSignature,
-  ripemd160: () => import_legacy.ripemd160,
-  recoverPublicKey: () => recoverPublicKey,
-  recoverAddress: () => recoverAddress,
-  readUInt32BE: () => readUInt32BE,
-  readUInt16BE: () => readUInt16BE,
-  randomBytes: () => randomBytes,
-  publicKeyToAddress: () => publicKeyToAddress,
-  parseUnits: () => parseUnits,
-  parseStx: () => parseStx,
-  parseSignature: () => parseSignature,
-  parsePrincipal: () => parsePrincipal,
-  parseContractId: () => parseContractId,
-  isValidAddress: () => isValidAddress,
-  isCompressedPublicKey: () => isCompressedPublicKey,
-  isClarityName: () => isClarityName,
-  isAddressEqual: () => isAddressEqual,
-  intToHex: () => intToHex,
-  intToBytes: () => intToBytes,
-  intToBigInt: () => intToBigInt,
-  hexToBytes: () => hexToBytes,
-  hashP2PKH: () => hashP2PKH,
-  hash160: () => hash160,
-  getContractAddress: () => getContractAddress,
-  fromTwos: () => fromTwos,
-  formatUnits: () => formatUnits,
-  formatStx: () => formatStx,
-  concatBytes: () => concatBytes,
-  compressPublicKey: () => compressPublicKey,
-  c32addressDecode: () => c32addressDecode,
-  c32address: () => c32address,
-  bytesToUtf8: () => bytesToUtf8,
-  bytesToTwosBigInt: () => bytesToTwosBigInt,
-  bytesToHex: () => bytesToHex,
-  bytesToAscii: () => bytesToAscii,
-  bigIntToBytes: () => bigIntToBytes,
-  asciiToBytes: () => asciiToBytes,
-  addressToVersion: () => addressToVersion,
-  ZERO_ADDRESS: () => ZERO_ADDRESS,
-  TESTNET_ZERO_ADDRESS: () => TESTNET_ZERO_ADDRESS,
-  MIN_I128: () => MIN_I128,
-  MICROSTX_PER_STX: () => MICROSTX_PER_STX,
-  MAX_U128: () => MAX_U128,
-  MAX_I128: () => MAX_I128,
+  AddressVersion: () => AddressVersion,
   CONTRACT_NAME_REGEX: () => CONTRACT_NAME_REGEX,
-  AddressVersion: () => AddressVersion
+  MAX_I128: () => MAX_I128,
+  MAX_U128: () => MAX_U128,
+  MICROSTX_PER_STX: () => MICROSTX_PER_STX,
+  MIN_I128: () => MIN_I128,
+  TESTNET_ZERO_ADDRESS: () => TESTNET_ZERO_ADDRESS,
+  ZERO_ADDRESS: () => ZERO_ADDRESS,
+  addressToVersion: () => addressToVersion,
+  asciiToBytes: () => asciiToBytes,
+  bigIntToBytes: () => bigIntToBytes,
+  bytesToAscii: () => bytesToAscii,
+  bytesToHex: () => bytesToHex,
+  bytesToTwosBigInt: () => bytesToTwosBigInt,
+  bytesToUtf8: () => bytesToUtf8,
+  c32address: () => c32address,
+  c32addressDecode: () => c32addressDecode,
+  compressPublicKey: () => compressPublicKey,
+  concatBytes: () => concatBytes,
+  formatStx: () => formatStx,
+  formatUnits: () => formatUnits,
+  fromTwos: () => fromTwos,
+  getContractAddress: () => getContractAddress,
+  hash160: () => hash160,
+  hashP2PKH: () => hashP2PKH,
+  hexToBytes: () => hexToBytes,
+  intToBigInt: () => intToBigInt,
+  intToBytes: () => intToBytes,
+  intToHex: () => intToHex,
+  isAddressEqual: () => isAddressEqual,
+  isClarityName: () => isClarityName,
+  isCompressedPublicKey: () => isCompressedPublicKey,
+  isValidAddress: () => isValidAddress,
+  parseContractId: () => parseContractId,
+  parsePrincipal: () => parsePrincipal,
+  parseSignature: () => parseSignature,
+  parseStx: () => parseStx,
+  parseUnits: () => parseUnits,
+  publicKeyToAddress: () => publicKeyToAddress,
+  randomBytes: () => randomBytes,
+  readUInt16BE: () => readUInt16BE,
+  readUInt32BE: () => readUInt32BE,
+  recoverAddress: () => recoverAddress,
+  recoverPublicKey: () => recoverPublicKey,
+  ripemd160: () => import_legacy.ripemd160,
+  serializeSignature: () => serializeSignature,
+  sha256: () => import_sha2.sha256,
+  sha512_256: () => import_sha22.sha512_256,
+  signatureRsvToVrs: () => signatureRsvToVrs,
+  signatureVrsToRsv: () => signatureVrsToRsv,
+  toTwos: () => toTwos,
+  txidFromBytes: () => txidFromBytes,
+  uncompressPublicKey: () => uncompressPublicKey,
+  utf8ToBytes: () => utf8ToBytes,
+  validateStacksAddress: () => validateStacksAddress,
+  verifyMessageSignature: () => verifyMessageSignature,
+  verifySignature: () => verifySignature,
+  with0x: () => with0x,
+  without0x: () => without0x,
+  writeUInt16BE: () => writeUInt16BE,
+  writeUInt32BE: () => writeUInt32BE,
+  writeUInt8: () => writeUInt8
 });
 module.exports = __toCommonJS(exports_utils);
 
-// src/utils/signature.ts
+// src/utils/encoding.ts
+var hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const b of bytes) {
+    hex += hexes[b];
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  let h = without0x(hex);
+  if (h.length % 2)
+    h = `0${h}`;
+  const array = new Uint8Array(h.length / 2);
+  for (let i = 0;i < array.length; i++) {
+    const j = i * 2;
+    const byte = Number.parseInt(h.slice(j, j + 2), 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    array[i] = byte;
+  }
+  return array;
+}
+function with0x(value) {
+  return /^0x/i.test(value) ? value : `0x${value}`;
+}
+function without0x(value) {
+  return /^0x/i.test(value) ? value.slice(2) : value;
+}
+function utf8ToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+function bytesToUtf8(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function asciiToBytes(str) {
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0;i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i) & 255;
+  }
+  return bytes;
+}
+function bytesToAscii(bytes) {
+  return String.fromCharCode(...bytes);
+}
+function concatBytes(...arrays) {
+  if (arrays.length === 1)
+    return arrays[0];
+  const length = arrays.reduce((a, arr) => a + arr.length, 0);
+  const result = new Uint8Array(length);
+  let pad = 0;
+  for (const arr of arrays) {
+    result.set(arr, pad);
+    pad += arr.length;
+  }
+  return result;
+}
+function intToBigInt(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "string")
+    return BigInt(value);
+  if (typeof value === "number") {
+    if (!Number.isInteger(value))
+      throw new RangeError("Values of type 'number' must be an integer.");
+    if (value > Number.MAX_SAFE_INTEGER)
+      throw new RangeError(`Values of type 'number' must be <= ${Number.MAX_SAFE_INTEGER}. Use BigInt instead.`);
+    return BigInt(value);
+  }
+  if (value instanceof Uint8Array)
+    return BigInt(`0x${bytesToHex(value)}`);
+  throw new TypeError("Must be a number, bigint, string, or Uint8Array.");
+}
+function intToBytes(value, byteLength) {
+  return bigIntToBytes(intToBigInt(value), byteLength);
+}
+function bigIntToBytes(value, length = 16) {
+  const hex = value.toString(16).padStart(length * 2, "0");
+  return hexToBytes(hex);
+}
+function intToHex(integer, byteLength = 8) {
+  const value = typeof integer === "bigint" ? integer : intToBigInt(integer);
+  return value.toString(16).padStart(byteLength * 2, "0");
+}
+function toTwos(value, width) {
+  const limit = BigInt(1) << width - BigInt(1);
+  if (value < -limit || value > limit - BigInt(1)) {
+    throw new Error(`Unable to represent integer in width: ${width}`);
+  }
+  if (value >= BigInt(0))
+    return value;
+  return value + (BigInt(1) << width);
+}
+function fromTwos(value, width) {
+  if (value & BigInt(1) << width - BigInt(1)) {
+    return value - (BigInt(1) << width);
+  }
+  return value;
+}
+function bytesToTwosBigInt(bytes) {
+  if (bytes.length === 0)
+    return 0n;
+  const hex = bytesToHex(bytes);
+  if (hex.length === 0)
+    return 0n;
+  return fromTwos(BigInt(`0x${hex}`), BigInt(bytes.byteLength * 8));
+}
+function writeUInt32BE(value) {
+  const buf = new Uint8Array(4);
+  buf[0] = value >>> 24 & 255;
+  buf[1] = value >>> 16 & 255;
+  buf[2] = value >>> 8 & 255;
+  buf[3] = value & 255;
+  return buf;
+}
+function readUInt32BE(bytes, offset = 0) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function writeUInt16BE(value) {
+  const buf = new Uint8Array(2);
+  buf[0] = value >>> 8 & 255;
+  buf[1] = value & 255;
+  return buf;
+}
+function readUInt16BE(bytes, offset = 0) {
+  return (bytes[offset] << 8 | bytes[offset + 1]) >>> 0;
+}
+function writeUInt8(value) {
+  return new Uint8Array([value & 255]);
+}
+// src/utils/hash.ts
+var import_legacy = require("@noble/hashes/legacy.js");
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
+function hash160(input) {
+  return import_legacy.ripemd160(import_sha2.sha256(input));
+}
+function txidFromBytes(data) {
+  return bytesToHex(import_sha22.sha512_256(data));
+}
+function hashP2PKH(input) {
+  return bytesToHex(hash160(input));
+}
+// src/utils/c32.ts
 var import_sha23 = require("@noble/hashes/sha2.js");
+var C32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var HEX = "0123456789abcdef";
+function c32normalize(input) {
+  return input.toUpperCase().replace(/O/g, "0").replace(/L|I/g, "1");
+}
+function c32encode(inputHex) {
+  let hex = inputHex;
+  if (hex.length % 2 !== 0)
+    hex = `0${hex}`;
+  hex = hex.toLowerCase();
+  const res = [];
+  let carry = 0;
+  for (let i = hex.length - 1;i >= 0; i--) {
+    if (carry < 4) {
+      const currentCode = HEX.indexOf(hex[i]) >> carry;
+      const nextCode = i !== 0 ? HEX.indexOf(hex[i - 1]) : 0;
+      const nextBits = 1 + carry;
+      const nextLowBits = nextCode % (1 << nextBits) << 5 - nextBits;
+      res.unshift(C32[currentCode + nextLowBits]);
+      carry = nextBits;
+    } else {
+      carry = 0;
+    }
+  }
+  let leadingZeros = 0;
+  while (leadingZeros < res.length && res[leadingZeros] === "0")
+    leadingZeros++;
+  const stripped = res.slice(leadingZeros);
+  const bytes = hexToBytes(hex);
+  let zeroBytesCount = 0;
+  while (zeroBytesCount < bytes.length && bytes[zeroBytesCount] === 0)
+    zeroBytesCount++;
+  const prefix = Array(zeroBytesCount).fill(C32[0]);
+  return [...prefix, ...stripped].join("");
+}
+function c32decode(c32input) {
+  const input = c32normalize(c32input);
+  if (!input.match(`^[${C32}]*$`))
+    throw new Error("Not a c32-encoded string");
+  const zeroPrefix = input.match(`^${C32[0]}*`);
+  const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0]?.length : 0;
+  const res = [];
+  let carry = 0;
+  let carryBits = 0;
+  for (let i = input.length - 1;i >= 0; i--) {
+    if (carryBits === 4) {
+      res.unshift(HEX[carry]);
+      carryBits = 0;
+      carry = 0;
+    }
+    const currentValue = (C32.indexOf(input[i]) << carryBits) + carry;
+    res.unshift(HEX[currentValue % 16]);
+    carryBits += 1;
+    carry = currentValue >> 4;
+    if (carry > 1 << carryBits)
+      throw new Error("Panic error in c32 decoding");
+  }
+  res.unshift(HEX[carry]);
+  if (res.length % 2 === 1)
+    res.unshift("0");
+  let hexLeadingZeros = 0;
+  while (hexLeadingZeros < res.length && res[hexLeadingZeros] === "0")
+    hexLeadingZeros++;
+  let hexStr = res.slice(hexLeadingZeros - hexLeadingZeros % 2).join("");
+  for (let i = 0;i < numLeadingZeroBytes; i++)
+    hexStr = `00${hexStr}`;
+  return hexStr;
+}
+function c32checksum(dataHex) {
+  return bytesToHex(import_sha23.sha256(import_sha23.sha256(hexToBytes(dataHex))).slice(0, 4));
+}
+function c32checkEncode(version, data) {
+  if (version < 0 || version >= 32)
+    throw new Error("Invalid version (must be between 0 and 31)");
+  if (!data.match(/^[0-9a-fA-F]*$/))
+    throw new Error("Invalid data (not a hex string)");
+  let d = data.toLowerCase();
+  if (d.length % 2 !== 0)
+    d = `0${d}`;
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  const checksumHex = c32checksum(`${versionHex}${d}`);
+  return `${C32[version]}${c32encode(`${d}${checksumHex}`)}`;
+}
+function c32checkDecode(c32data) {
+  const normalized = c32normalize(c32data);
+  const dataHex = c32decode(normalized.slice(1));
+  const version = C32.indexOf(normalized[0]);
+  const checksum = dataHex.slice(-8);
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {
+    throw new Error("Invalid c32check string: checksum mismatch");
+  }
+  return [version, dataHex.substring(0, dataHex.length - 8)];
+}
+function c32address(version, hash160hex) {
+  if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {
+    throw new Error("Invalid argument: not a hash160 hex string");
+  }
+  return `S${c32checkEncode(version, hash160hex)}`;
+}
+function c32addressDecode(c32addr) {
+  if (c32addr.length <= 5)
+    throw new Error("Invalid c32 address: invalid length");
+  if (c32addr[0] !== "S")
+    throw new Error('Invalid c32 address: must start with "S"');
+  return c32checkDecode(c32addr.slice(1));
+}
+
+// src/utils/constants.ts
+var MAX_U128 = (1n << 128n) - 1n;
+var MAX_I128 = (1n << 127n) - 1n;
+var MIN_I128 = -(1n << 127n);
+var AddressVersion = {
+  MainnetSingleSig: 22,
+  MainnetMultiSig: 20,
+  TestnetSingleSig: 26,
+  TestnetMultiSig: 21
+};
+var ZERO_ADDRESS = "SP000000000000000000002Q6VF78";
+var TESTNET_ZERO_ADDRESS = "ST000000000000000000002AMW42H";
+var MICROSTX_PER_STX = 1000000n;
+
+// src/utils/address.ts
+function publicKeyToAddress(publicKey, network = "mainnet") {
+  const bytes = typeof publicKey === "string" ? hexToBytes(without0x(publicKey)) : publicKey;
+  const version = network === "mainnet" ? AddressVersion.MainnetSingleSig : AddressVersion.TestnetSingleSig;
+  return c32address(version, bytesToHex(hash160(bytes)));
+}
+var CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/;
+function validateStacksAddress(address) {
+  try {
+    c32addressDecode(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var isValidAddress = validateStacksAddress;
+function parsePrincipal(value) {
+  const parts = value.split(".");
+  if (parts.length > 2)
+    return null;
+  const [address, contractName] = parts;
+  if (!validateStacksAddress(address))
+    return null;
+  if (contractName === undefined)
+    return { address };
+  if (!CONTRACT_NAME_REGEX.test(contractName))
+    return null;
+  return { address, contractName };
+}
+function parseContractId(contractId) {
+  const parsed = parsePrincipal(contractId);
+  if (!parsed?.contractName)
+    throw new Error(`Invalid contract identifier: ${contractId}`);
+  return [parsed.address, parsed.contractName];
+}
+function isClarityName(name) {
+  const regex = /^[a-zA-Z]([a-zA-Z0-9]|[-_!?+<>=/*])*$|^[-+=/*]$|^[<>]=?$/;
+  return regex.test(name) && name.length < 128;
+}
+function isAddressEqual(a, b) {
+  const [versionA, hashA] = c32addressDecode(a);
+  const [versionB, hashB] = c32addressDecode(b);
+  return versionA === versionB && hashA.toLowerCase() === hashB.toLowerCase();
+}
+function addressToVersion(address) {
+  return c32addressDecode(address)[0];
+}
+function getContractAddress(deployer, contractName) {
+  if (!validateStacksAddress(deployer)) {
+    throw new Error(`Invalid deployer address: ${deployer}`);
+  }
+  if (!isClarityName(contractName)) {
+    throw new Error(`Invalid contract name: ${contractName}`);
+  }
+  return `${deployer}.${contractName}`;
+}
+// src/utils/units.ts
+function formatUnits(value, decimals) {
+  let v = BigInt(value);
+  const negative = v < 0n;
+  if (negative)
+    v = -v;
+  const divisor = 10n ** BigInt(decimals);
+  const integer = (v / divisor).toString();
+  let fraction = (v % divisor).toString().padStart(decimals, "0");
+  fraction = fraction.replace(/0+$/, "") || "0";
+  const result = `${integer}.${fraction}`;
+  return negative ? `-${result}` : result;
+}
+var DECIMAL_STRING = /^-?\d+(\.\d+)?$/;
+function parseUnits(value, decimals) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new RangeError(`Cannot parse ${value} as a decimal amount`);
+  }
+  let str = typeof value === "number" ? value.toFixed(decimals) : value.trim();
+  if (!DECIMAL_STRING.test(str)) {
+    throw new RangeError(`Cannot parse "${value}" as a decimal amount: expected digits with an optional fraction, like "1.5"`);
+  }
+  if (typeof value === "number" && Number(str) !== value) {
+    throw new RangeError(`Cannot parse ${value} with ${decimals} decimals: pass the amount as a string to keep every digit`);
+  }
+  const negative = str.startsWith("-");
+  if (negative)
+    str = str.slice(1);
+  const [integer = "", fraction = ""] = str.split(".");
+  if (fraction.length > decimals) {
+    throw new Error(`Too many decimal places: "${value}" has ${fraction.length} decimals, max is ${decimals}`);
+  }
+  const padded = fraction.padEnd(decimals, "0");
+  const result = BigInt(integer + padded);
+  return negative ? -result : result;
+}
+function formatStx(microStx) {
+  return formatUnits(microStx, 6);
+}
+function parseStx(stx) {
+  return parseUnits(stx, 6);
+}
+// src/utils/signature.ts
+var import_sha24 = require("@noble/hashes/sha2.js");
 var import_secp256k1 = require("@noble/secp256k1");
 function parseSignature(hex) {
   const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
@@ -112,11 +546,11 @@ function encodeVarint(n) {
   if (n < 253)
     return new Uint8Array([n]);
   if (n <= 65535) {
-    const buf2 = new Uint8Array(3);
-    buf2[0] = 253;
-    buf2[1] = n & 255;
-    buf2[2] = n >> 8 & 255;
-    return buf2;
+    const buf = new Uint8Array(3);
+    buf[0] = 253;
+    buf[1] = n & 255;
+    buf[2] = n >> 8 & 255;
+    return buf;
   }
   const buf = new Uint8Array(5);
   buf[0] = 254;
@@ -134,7 +568,7 @@ function hashMessage(message, prefix) {
   const messageBytes = typeof message === "string" ? utf8ToBytes(message) : message;
   const prefixBytes = utf8ToBytes(prefix);
   const lengthBytes = encodeVarint(messageBytes.length);
-  return import_sha23.sha256(concatBytes(prefixBytes, lengthBytes, messageBytes));
+  return import_sha24.sha256(concatBytes(prefixBytes, lengthBytes, messageBytes));
 }
 function verifyMessageSignature(message, signature, publicKey) {
   const parsed = parseSignature(signature);
@@ -167,5 +601,5 @@ function randomBytes(length) {
   return import_secp256k12.etc.randomBytes(length ?? 32);
 }
 
-//# debugId=6B87ECBAC9286DEB64756E2164756E21
+//# debugId=C16DEF43F45A071764756E2164756E21
 //# sourceMappingURL=index.cjs.map