tenjin-cli 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/{chunk-F5DZJLU3.js → chunk-BRJHUQSY.js}

@@ -7,6 +7,7 @@ import {
   aoutput,
   clean,
   createHasher,
+  equalBytes,
   rotlBH,
   rotlBL,
   rotlSH,
@@ -15,7 +16,7 @@ import {
   swap32IfBE,
   toBytes,
   u32
-} from "./chunk-CPUZRZ2A.js";
+} from "./chunk-CUWUHTIL.js";
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/data/isHex.js
 function isHex(value, { strict = true } = {}) {
@@ -185,11 +186,11 @@ var AbiConstructorParamsNotFoundError = class extends BaseError {
   }
 };
 var AbiDecodingDataSizeTooSmallError = class extends BaseError {
-  constructor({ data, params, size: size2 }) {
-    super([`Data size of ${size2} bytes is too small for given parameters.`].join("\n"), {
+  constructor({ data, params, size: size4 }) {
+    super([`Data size of ${size4} bytes is too small for given parameters.`].join("\n"), {
       metaMessages: [
         `Params: (${formatAbiParams(params, { includeName: true })})`,
-        `Data:   ${data} (${size2} bytes)`
+        `Data:   ${data} (${size4} bytes)`
       ],
       name: "AbiDecodingDataSizeTooSmallError"
     });
@@ -213,7 +214,7 @@ var AbiDecodingDataSizeTooSmallError = class extends BaseError {
     });
     this.data = data;
     this.params = params;
-    this.size = size2;
+    this.size = size4;
   }
 };
 var AbiDecodingZeroDataError = class extends BaseError {
@@ -378,13 +379,13 @@ var BytesSizeMismatchError = class extends BaseError {
   }
 };
 var DecodeLogDataMismatch = class extends BaseError {
-  constructor({ abiItem, data, params, size: size2 }) {
+  constructor({ abiItem, data, params, size: size4 }) {
     super([
-      `Data size of ${size2} bytes is too small for non-indexed event parameters.`
+      `Data size of ${size4} bytes is too small for non-indexed event parameters.`
     ].join("\n"), {
       metaMessages: [
         `Params: (${formatAbiParams(params, { includeName: true })})`,
-        `Data:   ${data} (${size2} bytes)`
+        `Data:   ${data} (${size4} bytes)`
       ],
       name: "DecodeLogDataMismatch"
     });
@@ -415,7 +416,7 @@ var DecodeLogDataMismatch = class extends BaseError {
     this.abiItem = abiItem;
     this.data = data;
     this.params = params;
-    this.size = size2;
+    this.size = size4;
   }
 };
 var DecodeLogTopicsMismatch = class extends BaseError {
@@ -479,8 +480,8 @@ var InvalidAddressError = class extends BaseError {
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/errors/encoding.js
 var IntegerOutOfRangeError = class extends BaseError {
-  constructor({ max, min, signed, size: size2, value }) {
-    super(`Number "${value}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
+  constructor({ max, min, signed, size: size4, value }) {
+    super(`Number "${value}" is not in safe ${size4 ? `${size4 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
   }
 };
 var InvalidBytesBooleanError = class extends BaseError {
@@ -503,7 +504,7 @@ var SizeOverflowError = class extends BaseError {
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/lru.js
 var LruMap = class extends Map {
-  constructor(size2) {
+  constructor(size4) {
     super();
     Object.defineProperty(this, "maxSize", {
       enumerable: true,
@@ -511,7 +512,7 @@ var LruMap = class extends Map {
       writable: true,
       value: void 0
     });
-    this.maxSize = size2;
+    this.maxSize = size4;
   }
   get(key) {
     const value = super.get(key);
@@ -536,52 +537,52 @@ var LruMap = class extends Map {
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/errors/data.js
 var SliceOffsetOutOfBoundsError = class extends BaseError {
-  constructor({ offset, position, size: size2 }) {
-    super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`, { name: "SliceOffsetOutOfBoundsError" });
+  constructor({ offset, position, size: size4 }) {
+    super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size4}).`, { name: "SliceOffsetOutOfBoundsError" });
   }
 };
 var SizeExceedsPaddingSizeError = class extends BaseError {
-  constructor({ size: size2, targetSize, type }) {
-    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
+  constructor({ size: size4, targetSize, type }) {
+    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size4}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
   }
 };
 var InvalidBytesLengthError = class extends BaseError {
-  constructor({ size: size2, targetSize, type }) {
-    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size2} ${type} long.`, { name: "InvalidBytesLengthError" });
+  constructor({ size: size4, targetSize, type }) {
+    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size4} ${type} long.`, { name: "InvalidBytesLengthError" });
   }
 };
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/data/pad.js
-function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
+function pad(hexOrBytes, { dir, size: size4 = 32 } = {}) {
   if (typeof hexOrBytes === "string")
-    return padHex(hexOrBytes, { dir, size: size2 });
-  return padBytes(hexOrBytes, { dir, size: size2 });
+    return padHex(hexOrBytes, { dir, size: size4 });
+  return padBytes(hexOrBytes, { dir, size: size4 });
 }
-function padHex(hex_, { dir, size: size2 = 32 } = {}) {
-  if (size2 === null)
+function padHex(hex_, { dir, size: size4 = 32 } = {}) {
+  if (size4 === null)
     return hex_;
   const hex = hex_.replace("0x", "");
-  if (hex.length > size2 * 2)
+  if (hex.length > size4 * 2)
     throw new SizeExceedsPaddingSizeError({
       size: Math.ceil(hex.length / 2),
-      targetSize: size2,
+      targetSize: size4,
       type: "hex"
     });
-  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size2 * 2, "0")}`;
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size4 * 2, "0")}`;
 }
-function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
-  if (size2 === null)
+function padBytes(bytes, { dir, size: size4 = 32 } = {}) {
+  if (size4 === null)
     return bytes;
-  if (bytes.length > size2)
+  if (bytes.length > size4)
     throw new SizeExceedsPaddingSizeError({
       size: bytes.length,
-      targetSize: size2,
+      targetSize: size4,
       type: "bytes"
     });
-  const paddedBytes = new Uint8Array(size2);
-  for (let i = 0; i < size2; i++) {
+  const paddedBytes = new Uint8Array(size4);
+  for (let i = 0; i < size4; i++) {
     const padEnd = dir === "right";
-    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+    paddedBytes[padEnd ? i : size4 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
   }
   return paddedBytes;
 }
@@ -606,11 +607,11 @@ function trim(hexOrBytes, { dir = "left" } = {}) {
 }
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/encoding/fromHex.js
-function assertSize(hexOrBytes, { size: size2 }) {
-  if (size(hexOrBytes) > size2)
+function assertSize(hexOrBytes, { size: size4 }) {
+  if (size(hexOrBytes) > size4)
     throw new SizeOverflowError({
       givenSize: size(hexOrBytes),
-      maxSize: size2
+      maxSize: size4
     });
 }
 function hexToBigInt(hex, opts = {}) {
@@ -620,11 +621,11 @@ function hexToBigInt(hex, opts = {}) {
   const value = BigInt(hex);
   if (!signed)
     return value;
-  const size2 = (hex.length - 2) / 2;
-  const max = (1n << BigInt(size2) * 8n - 1n) - 1n;
+  const size4 = (hex.length - 2) / 2;
+  const max = (1n << BigInt(size4) * 8n - 1n) - 1n;
   if (value <= max)
     return value;
-  return value - BigInt(`0x${"f".padStart(size2 * 2, "f")}`) - 1n;
+  return value - BigInt(`0x${"f".padStart(size4 * 2, "f")}`) - 1n;
 }
 function hexToBool(hex_, opts = {}) {
   let hex = hex_;
@@ -685,14 +686,14 @@ function bytesToHex(value, opts = {}) {
   return hex;
 }
 function numberToHex(value_, opts = {}) {
-  const { signed, size: size2 } = opts;
+  const { signed, size: size4 } = opts;
   const value = BigInt(value_);
   let maxValue;
-  if (size2) {
+  if (size4) {
     if (signed)
-      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
+      maxValue = (1n << BigInt(size4) * 8n - 1n) - 1n;
     else
-      maxValue = 2n ** (BigInt(size2) * 8n) - 1n;
+      maxValue = 2n ** (BigInt(size4) * 8n) - 1n;
   } else if (typeof value_ === "number") {
     maxValue = BigInt(Number.MAX_SAFE_INTEGER);
   }
@@ -703,13 +704,13 @@ function numberToHex(value_, opts = {}) {
       max: maxValue ? `${maxValue}${suffix}` : void 0,
       min: `${minValue}${suffix}`,
       signed,
-      size: size2,
+      size: size4,
       value: `${value_}${suffix}`
     });
   }
-  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
-  if (size2)
-    return pad(hex, { size: size2 });
+  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size4 * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size4)
+    return pad(hex, { size: size4 });
   return hex;
 }
 var encoder = /* @__PURE__ */ new TextEncoder();
@@ -1111,10 +1112,10 @@ function prepareParam({ param, value }) {
   }
   if (param.type.startsWith("uint") || param.type.startsWith("int")) {
     const signed = param.type.startsWith("int");
-    const [, , size2 = "256"] = integerRegex.exec(param.type) ?? [];
+    const [, , size4 = "256"] = integerRegex.exec(param.type) ?? [];
     return encodeNumber(value, {
       signed,
-      size: Number(size2)
+      size: Number(size4)
     });
   }
   if (param.type.startsWith("bytes")) {
@@ -1221,16 +1222,16 @@ function encodeBool(value) {
     throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
   return { dynamic: false, encoded: padHex(boolToHex(value)) };
 }
-function encodeNumber(value, { signed, size: size2 = 256 }) {
-  if (typeof size2 === "number") {
-    const max = 2n ** (BigInt(size2) - (signed ? 1n : 0n)) - 1n;
+function encodeNumber(value, { signed, size: size4 = 256 }) {
+  if (typeof size4 === "number") {
+    const max = 2n ** (BigInt(size4) - (signed ? 1n : 0n)) - 1n;
     const min = signed ? -max - 1n : 0n;
     if (value > max || value < min)
       throw new IntegerOutOfRangeError({
         max: max.toString(),
         min: min.toString(),
         signed,
-        size: size2 / 8,
+        size: size4 / 8,
         value: value.toString()
       });
   }
@@ -1907,11 +1908,11 @@ var staticCursor = {
     this.position++;
     return value;
   },
-  readBytes(length, size2) {
+  readBytes(length, size4) {
     this.assertReadLimit();
     this._touch();
     const value = this.inspectBytes(length);
-    this.position += size2 ?? length;
+    this.position += size4 ?? length;
     return value;
   },
   readUint8() {
@@ -1969,6 +1970,685 @@ function createCursor(bytes, { recursiveReadLimit = 8192 } = {}) {
   return cursor;
 }
 
+// node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/version.js
+var version2 = "0.1.1";
+
+// node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/internal/errors.js
+function getVersion() {
+  return version2;
+}
+
+// node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/Errors.js
+var BaseError2 = class _BaseError extends Error {
+  static setStaticOptions(options) {
+    _BaseError.prototype.docsOrigin = options.docsOrigin;
+    _BaseError.prototype.showVersion = options.showVersion;
+    _BaseError.prototype.version = options.version;
+  }
+  constructor(shortMessage, options = {}) {
+    const details = (() => {
+      if (options.cause instanceof _BaseError) {
+        if (options.cause.details)
+          return options.cause.details;
+        if (options.cause.shortMessage)
+          return options.cause.shortMessage;
+      }
+      if (options.cause && "details" in options.cause && typeof options.cause.details === "string")
+        return options.cause.details;
+      if (options.cause?.message)
+        return options.cause.message;
+      return options.details;
+    })();
+    const docsPath = (() => {
+      if (options.cause instanceof _BaseError)
+        return options.cause.docsPath || options.docsPath;
+      return options.docsPath;
+    })();
+    const docsBaseUrl = options.docsOrigin ?? _BaseError.prototype.docsOrigin;
+    const docs = `${docsBaseUrl}${docsPath ?? ""}`;
+    const showVersion = Boolean(options.version ?? _BaseError.prototype.showVersion);
+    const version3 = options.version ?? _BaseError.prototype.version;
+    const message = [
+      shortMessage || "An error occurred.",
+      ...options.metaMessages ? ["", ...options.metaMessages] : [],
+      ...details || docsPath || showVersion ? [
+        "",
+        details ? `Details: ${details}` : void 0,
+        docsPath ? `See: ${docs}` : void 0,
+        showVersion ? `Version: ${version3}` : void 0
+      ] : []
+    ].filter((x) => typeof x === "string").join("\n");
+    super(message, options.cause ? { cause: options.cause } : void 0);
+    Object.defineProperty(this, "details", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "docs", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "docsOrigin", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "docsPath", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "shortMessage", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "showVersion", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "version", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "cause", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "BaseError"
+    });
+    this.cause = options.cause;
+    this.details = details;
+    this.docs = docs;
+    this.docsOrigin = docsBaseUrl;
+    this.docsPath = docsPath;
+    this.shortMessage = shortMessage;
+    this.showVersion = showVersion;
+    this.version = version3;
+  }
+  walk(fn) {
+    return walk2(this, fn);
+  }
+};
+Object.defineProperty(BaseError2, "defaultStaticOptions", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: {
+    docsOrigin: "https://oxlib.sh",
+    showVersion: false,
+    version: `ox@${getVersion()}`
+  }
+});
+(() => {
+  BaseError2.setStaticOptions(BaseError2.defaultStaticOptions);
+})();
+function walk2(err, fn) {
+  if (fn?.(err))
+    return err;
+  if (err && typeof err === "object" && "cause" in err && err.cause)
+    return walk2(err.cause, fn);
+  return fn ? null : err;
+}
+
+// node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/internal/bytes.js
+function assertSize2(bytes, size_) {
+  if (size2(bytes) > size_)
+    throw new SizeOverflowError2({
+      givenSize: size2(bytes),
+      maxSize: size_
+    });
+}
+function assertStartOffset2(value, start) {
+  if (typeof start === "number" && start > 0 && start > size2(value) - 1)
+    throw new SliceOffsetOutOfBoundsError2({
+      offset: start,
+      position: "start",
+      size: size2(value)
+    });
+}
+function assertEndOffset2(value, start, end) {
+  if (typeof start === "number" && typeof end === "number" && size2(value) !== end - start) {
+    throw new SliceOffsetOutOfBoundsError2({
+      offset: end,
+      position: "end",
+      size: size2(value)
+    });
+  }
+}
+var charCodeMap2 = {
+  zero: 48,
+  nine: 57,
+  A: 65,
+  F: 70,
+  a: 97,
+  f: 102
+};
+function charCodeToBase162(char) {
+  if (char >= charCodeMap2.zero && char <= charCodeMap2.nine)
+    return char - charCodeMap2.zero;
+  if (char >= charCodeMap2.A && char <= charCodeMap2.F)
+    return char - (charCodeMap2.A - 10);
+  if (char >= charCodeMap2.a && char <= charCodeMap2.f)
+    return char - (charCodeMap2.a - 10);
+  return void 0;
+}
+function pad2(bytes, options = {}) {
+  const { dir, size: size4 = 32 } = options;
+  if (size4 === 0)
+    return bytes;
+  if (bytes.length > size4)
+    throw new SizeExceedsPaddingSizeError2({
+      size: bytes.length,
+      targetSize: size4,
+      type: "Bytes"
+    });
+  const paddedBytes = new Uint8Array(size4);
+  for (let i = 0; i < size4; i++) {
+    const padEnd = dir === "right";
+    paddedBytes[padEnd ? i : size4 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+  }
+  return paddedBytes;
+}
+function trim2(value, options = {}) {
+  const { dir = "left" } = options;
+  let data = value;
+  let sliceLength = 0;
+  for (let i = 0; i < data.length - 1; i++) {
+    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
+      sliceLength++;
+    else
+      break;
+  }
+  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
+  return data;
+}
+
+// node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/internal/hex.js
+function assertSize3(hex, size_) {
+  if (size3(hex) > size_)
+    throw new SizeOverflowError3({
+      givenSize: size3(hex),
+      maxSize: size_
+    });
+}
+function assertStartOffset3(value, start) {
+  if (typeof start === "number" && start > 0 && start > size3(value) - 1)
+    throw new SliceOffsetOutOfBoundsError3({
+      offset: start,
+      position: "start",
+      size: size3(value)
+    });
+}
+function assertEndOffset3(value, start, end) {
+  if (typeof start === "number" && typeof end === "number" && size3(value) !== end - start) {
+    throw new SliceOffsetOutOfBoundsError3({
+      offset: end,
+      position: "end",
+      size: size3(value)
+    });
+  }
+}
+function pad3(hex_, options = {}) {
+  const { dir, size: size4 = 32 } = options;
+  if (size4 === 0)
+    return hex_;
+  const hex = hex_.replace("0x", "");
+  if (hex.length > size4 * 2)
+    throw new SizeExceedsPaddingSizeError3({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size4,
+      type: "Hex"
+    });
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size4 * 2, "0")}`;
+}
+function trim3(value, options = {}) {
+  const { dir = "left" } = options;
+  let data = value.replace("0x", "");
+  let sliceLength = 0;
+  for (let i = 0; i < data.length - 1; i++) {
+    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
+      sliceLength++;
+    else
+      break;
+  }
+  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
+  if (data === "0")
+    return "0x";
+  if (dir === "right" && data.length % 2 === 1)
+    return `0x${data}0`;
+  return `0x${data}`;
+}
+
+// node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/Json.js
+var bigIntSuffix = "#__bigint";
+function stringify2(value, replacer, space) {
+  return JSON.stringify(value, (key, value2) => {
+    if (typeof replacer === "function")
+      return replacer(key, value2);
+    if (typeof value2 === "bigint")
+      return value2.toString() + bigIntSuffix;
+    return value2;
+  }, space);
+}
+
+// node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/Bytes.js
+var decoder = /* @__PURE__ */ new TextDecoder();
+var encoder3 = /* @__PURE__ */ new TextEncoder();
+function assert(value) {
+  if (value instanceof Uint8Array)
+    return;
+  if (!value)
+    throw new InvalidBytesTypeError(value);
+  if (typeof value !== "object")
+    throw new InvalidBytesTypeError(value);
+  if (!("BYTES_PER_ELEMENT" in value))
+    throw new InvalidBytesTypeError(value);
+  if (value.BYTES_PER_ELEMENT !== 1 || value.constructor.name !== "Uint8Array")
+    throw new InvalidBytesTypeError(value);
+}
+function concat2(...values) {
+  let length = 0;
+  for (const arr of values) {
+    length += arr.length;
+  }
+  const result = new Uint8Array(length);
+  for (let i = 0, index = 0; i < values.length; i++) {
+    const arr = values[i];
+    result.set(arr, index);
+    index += arr.length;
+  }
+  return result;
+}
+function from(value) {
+  if (value instanceof Uint8Array)
+    return value;
+  if (typeof value === "string")
+    return fromHex(value);
+  return fromArray(value);
+}
+function fromArray(value) {
+  return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+function fromHex(value, options = {}) {
+  const { size: size4 } = options;
+  let hex = value;
+  if (size4) {
+    assertSize3(value, size4);
+    hex = padRight(value, size4);
+  }
+  let hexString = hex.slice(2);
+  if (hexString.length % 2)
+    hexString = `0${hexString}`;
+  const length = hexString.length / 2;
+  const bytes = new Uint8Array(length);
+  for (let index = 0, j = 0; index < length; index++) {
+    const nibbleLeft = charCodeToBase162(hexString.charCodeAt(j++));
+    const nibbleRight = charCodeToBase162(hexString.charCodeAt(j++));
+    if (nibbleLeft === void 0 || nibbleRight === void 0) {
+      throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+    }
+    bytes[index] = nibbleLeft << 4 | nibbleRight;
+  }
+  return bytes;
+}
+function fromString(value, options = {}) {
+  const { size: size4 } = options;
+  const bytes = encoder3.encode(value);
+  if (typeof size4 === "number") {
+    assertSize2(bytes, size4);
+    return padRight2(bytes, size4);
+  }
+  return bytes;
+}
+function isEqual(bytesA, bytesB) {
+  return equalBytes(bytesA, bytesB);
+}
+function padRight2(value, size4) {
+  return pad2(value, { dir: "right", size: size4 });
+}
+function random(length) {
+  return crypto.getRandomValues(new Uint8Array(length));
+}
+function size2(value) {
+  return value.length;
+}
+function slice2(value, start, end, options = {}) {
+  const { strict } = options;
+  assertStartOffset2(value, start);
+  const value_ = value.slice(start, end);
+  if (strict)
+    assertEndOffset2(value_, start, end);
+  return value_;
+}
+function toBigInt2(bytes, options = {}) {
+  const { size: size4 } = options;
+  if (typeof size4 !== "undefined")
+    assertSize2(bytes, size4);
+  const hex = fromBytes(bytes, options);
+  return toBigInt(hex, options);
+}
+function toBoolean(bytes, options = {}) {
+  const { size: size4 } = options;
+  let bytes_ = bytes;
+  if (typeof size4 !== "undefined") {
+    assertSize2(bytes_, size4);
+    bytes_ = trimLeft(bytes_);
+  }
+  if (bytes_.length > 1 || bytes_[0] > 1)
+    throw new InvalidBytesBooleanError2(bytes_);
+  return Boolean(bytes_[0]);
+}
+function toHex2(value, options = {}) {
+  return fromBytes(value, options);
+}
+function toNumber2(bytes, options = {}) {
+  const { size: size4 } = options;
+  if (typeof size4 !== "undefined")
+    assertSize2(bytes, size4);
+  const hex = fromBytes(bytes, options);
+  return toNumber(hex, options);
+}
+function toString(bytes, options = {}) {
+  const { size: size4 } = options;
+  let bytes_ = bytes;
+  if (typeof size4 !== "undefined") {
+    assertSize2(bytes_, size4);
+    bytes_ = trimRight(bytes_);
+  }
+  return decoder.decode(bytes_);
+}
+function trimLeft(value) {
+  return trim2(value, { dir: "left" });
+}
+function trimRight(value) {
+  return trim2(value, { dir: "right" });
+}
+function validate(value) {
+  try {
+    assert(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var InvalidBytesBooleanError2 = class extends BaseError2 {
+  constructor(bytes) {
+    super(`Bytes value \`${bytes}\` is not a valid boolean.`, {
+      metaMessages: [
+        "The bytes array must contain a single byte of either a `0` or `1` value."
+      ]
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Bytes.InvalidBytesBooleanError"
+    });
+  }
+};
+var InvalidBytesTypeError = class extends BaseError2 {
+  constructor(value) {
+    super(`Value \`${typeof value === "object" ? stringify2(value) : value}\` of type \`${typeof value}\` is an invalid Bytes value.`, {
+      metaMessages: ["Bytes values must be of type `Bytes`."]
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Bytes.InvalidBytesTypeError"
+    });
+  }
+};
+var SizeOverflowError2 = class extends BaseError2 {
+  constructor({ givenSize, maxSize }) {
+    super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Bytes.SizeOverflowError"
+    });
+  }
+};
+var SliceOffsetOutOfBoundsError2 = class extends BaseError2 {
+  constructor({ offset, position, size: size4 }) {
+    super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size4}\`).`);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Bytes.SliceOffsetOutOfBoundsError"
+    });
+  }
+};
+var SizeExceedsPaddingSizeError2 = class extends BaseError2 {
+  constructor({ size: size4, targetSize, type }) {
+    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size4}\`) exceeds padding size (\`${targetSize}\`).`);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Bytes.SizeExceedsPaddingSizeError"
+    });
+  }
+};
+
+// node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/Hex.js
+var encoder4 = /* @__PURE__ */ new TextEncoder();
+var hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+function assert2(value, options = {}) {
+  const { strict = false } = options;
+  if (!value)
+    throw new InvalidHexTypeError(value);
+  if (typeof value !== "string")
+    throw new InvalidHexTypeError(value);
+  if (strict) {
+    if (!/^0x[0-9a-fA-F]*$/.test(value))
+      throw new InvalidHexValueError(value);
+  }
+  if (!value.startsWith("0x"))
+    throw new InvalidHexValueError(value);
+}
+function concat3(...values) {
+  return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
+}
+function from2(value) {
+  if (value instanceof Uint8Array)
+    return fromBytes(value);
+  if (Array.isArray(value))
+    return fromBytes(new Uint8Array(value));
+  return value;
+}
+function fromBoolean(value, options = {}) {
+  const hex = `0x${Number(value)}`;
+  if (typeof options.size === "number") {
+    assertSize3(hex, options.size);
+    return padLeft(hex, options.size);
+  }
+  return hex;
+}
+function fromBytes(value, options = {}) {
+  let string = "";
+  for (let i = 0; i < value.length; i++)
+    string += hexes2[value[i]];
+  const hex = `0x${string}`;
+  if (typeof options.size === "number") {
+    assertSize3(hex, options.size);
+    return padRight(hex, options.size);
+  }
+  return hex;
+}
+function fromNumber(value, options = {}) {
+  const { signed, size: size4 } = options;
+  const value_ = BigInt(value);
+  let maxValue;
+  if (size4) {
+    if (signed)
+      maxValue = (1n << BigInt(size4) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size4) * 8n) - 1n;
+  } else if (typeof value === "number") {
+    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+  }
+  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+  if (maxValue && value_ > maxValue || value_ < minValue) {
+    const suffix = typeof value === "bigint" ? "n" : "";
+    throw new IntegerOutOfRangeError2({
+      max: maxValue ? `${maxValue}${suffix}` : void 0,
+      min: `${minValue}${suffix}`,
+      signed,
+      size: size4,
+      value: `${value}${suffix}`
+    });
+  }
+  const stringValue = (signed && value_ < 0 ? BigInt.asUintN(size4 * 8, BigInt(value_)) : value_).toString(16);
+  const hex = `0x${stringValue}`;
+  if (size4)
+    return padLeft(hex, size4);
+  return hex;
+}
+function fromString2(value, options = {}) {
+  return fromBytes(encoder4.encode(value), options);
+}
+function padLeft(value, size4) {
+  return pad3(value, { dir: "left", size: size4 });
+}
+function padRight(value, size4) {
+  return pad3(value, { dir: "right", size: size4 });
+}
+function slice3(value, start, end, options = {}) {
+  const { strict } = options;
+  assertStartOffset3(value, start);
+  const value_ = `0x${value.replace("0x", "").slice((start ?? 0) * 2, (end ?? value.length) * 2)}`;
+  if (strict)
+    assertEndOffset3(value_, start, end);
+  return value_;
+}
+function size3(value) {
+  return Math.ceil((value.length - 2) / 2);
+}
+function trimLeft2(value) {
+  return trim3(value, { dir: "left" });
+}
+function toBigInt(hex, options = {}) {
+  const { signed } = options;
+  if (options.size)
+    assertSize3(hex, options.size);
+  const value = BigInt(hex);
+  if (!signed)
+    return value;
+  const size4 = (hex.length - 2) / 2;
+  const max_unsigned = (1n << BigInt(size4) * 8n) - 1n;
+  const max_signed = max_unsigned >> 1n;
+  if (value <= max_signed)
+    return value;
+  return value - max_unsigned - 1n;
+}
+function toNumber(hex, options = {}) {
+  const { signed, size: size4 } = options;
+  if (!signed && !size4)
+    return Number(hex);
+  return Number(toBigInt(hex, options));
+}
+function validate2(value, options = {}) {
+  const { strict = false } = options;
+  try {
+    assert2(value, { strict });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var IntegerOutOfRangeError2 = class extends BaseError2 {
+  constructor({ max, min, signed, size: size4, value }) {
+    super(`Number \`${value}\` is not in safe${size4 ? ` ${size4 * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Hex.IntegerOutOfRangeError"
+    });
+  }
+};
+var InvalidHexTypeError = class extends BaseError2 {
+  constructor(value) {
+    super(`Value \`${typeof value === "object" ? stringify2(value) : value}\` of type \`${typeof value}\` is an invalid hex type.`, {
+      metaMessages: ['Hex types must be represented as `"0x${string}"`.']
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Hex.InvalidHexTypeError"
+    });
+  }
+};
+var InvalidHexValueError = class extends BaseError2 {
+  constructor(value) {
+    super(`Value \`${value}\` is an invalid hex value.`, {
+      metaMessages: [
+        'Hex values must start with `"0x"` and contain only hexadecimal characters (0-9, a-f, A-F).'
+      ]
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Hex.InvalidHexValueError"
+    });
+  }
+};
+var SizeOverflowError3 = class extends BaseError2 {
+  constructor({ givenSize, maxSize }) {
+    super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Hex.SizeOverflowError"
+    });
+  }
+};
+var SliceOffsetOutOfBoundsError3 = class extends BaseError2 {
+  constructor({ offset, position, size: size4 }) {
+    super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size4}\`).`);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Hex.SliceOffsetOutOfBoundsError"
+    });
+  }
+};
+var SizeExceedsPaddingSizeError3 = class extends BaseError2 {
+  constructor({ size: size4, targetSize, type }) {
+    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size4}\`) exceeds padding size (\`${targetSize}\`).`);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "Hex.SizeExceedsPaddingSizeError"
+    });
+  }
+};
+
 export {
   BaseError,
   InvalidBytesBooleanError,
@@ -2053,6 +2733,37 @@ export {
   encodeAbiParameters,
   getArrayComponents,
   stringify,
-  parseAccount
-};
-//# sourceMappingURL=chunk-F5DZJLU3.js.map
+  parseAccount,
+  BaseError2,
+  stringify2,
+  concat3 as concat2,
+  from2 as from,
+  fromBoolean,
+  fromBytes,
+  fromNumber,
+  fromString2 as fromString,
+  padLeft,
+  padRight,
+  slice3 as slice2,
+  size3 as size2,
+  trimLeft2 as trimLeft,
+  toNumber,
+  validate2 as validate,
+  IntegerOutOfRangeError2 as IntegerOutOfRangeError,
+  concat2 as concat3,
+  from as from2,
+  fromHex,
+  fromString as fromString2,
+  isEqual,
+  random,
+  size2 as size3,
+  slice2 as slice3,
+  toBigInt2 as toBigInt,
+  toBoolean,
+  toHex2,
+  toNumber2,
+  toString,
+  trimLeft as trimLeft2,
+  validate as validate2
+};
+//# sourceMappingURL=chunk-BRJHUQSY.js.map