thirdweb 5.67.1-nightly-9584885f42ba6d7fec7dd4e1b3d7e0b677cf6afc-20241112000327 → 5.67.1-nightly-040e478ad6cf630dedf666eac7abeb668d323666-20241113000339

package/src/utils/encoding/from-bytes.ts

@@ -1,7 +1,5 @@
-import { assertSize } from "./helpers/assert-size.js";
-import type { Hex } from "./helpers/is-hex.js";
-import { trim } from "./helpers/trim.js";
-import { hexToBigInt, hexToNumber, uint8ArrayToHex } from "./hex.js";
+import * as ox__Bytes from "ox/Bytes";
+import { type Hex, uint8ArrayToHex } from "./hex.js";
 
 export type FromBytesParameters<
   TTo extends "string" | "hex" | "bigint" | "number" | "boolean",
@@ -86,17 +84,10 @@ export function bytesToBigInt(
   bytes: Uint8Array,
   opts: BytesToBigIntOpts = {},
 ): bigint {
-  if (typeof opts.size !== "undefined") {
-    assertSize(bytes, { size: opts.size });
-  }
-  const hex = uint8ArrayToHex(bytes, opts);
-  return hexToBigInt(hex, opts);
+  return ox__Bytes.toBigInt(bytes, opts);
 }
 
-export type BytesToBoolOpts = {
-  /** Size of the bytes. */
-  size?: number;
-};
+export type BytesToBoolOpts = ox__Bytes.toBoolean.Options;
 
 /**
  * Converts a byte array to a boolean value.
@@ -117,16 +108,7 @@ export function bytesToBool(
   bytes_: Uint8Array,
   opts: BytesToBoolOpts = {},
 ): boolean {
-  let bytes = bytes_;
-  if (typeof opts.size !== "undefined") {
-    assertSize(bytes, { size: opts.size });
-    bytes = trim(bytes);
-  }
-
-  if (bytes.length > 1 || (bytes[0] && bytes[0] > 1)) {
-    throw new Error(`Invalid boolean representation: ${bytes}`);
-  }
-  return Boolean(bytes[0]);
+  return ox__Bytes.toBoolean(bytes_, opts);
 }
 
 export type BytesToNumberOpts = BytesToBigIntOpts;
@@ -149,17 +131,10 @@ export function bytesToNumber(
   bytes: Uint8Array,
   opts: BytesToNumberOpts = {},
 ): number {
-  if (typeof opts.size !== "undefined") {
-    assertSize(bytes, { size: opts.size });
-  }
-  const hex = uint8ArrayToHex(bytes, opts);
-  return hexToNumber(hex, opts);
+  return ox__Bytes.toNumber(bytes, opts);
 }
 
-export type BytesToStringOpts = {
-  /** Size of the bytes. */
-  size?: number;
-};
+export type BytesToStringOpts = ox__Bytes.toString.Options;
 
 /**
  * Converts an array of bytes to a string using UTF-8 encoding.
@@ -179,10 +154,5 @@ export function bytesToString(
   bytes_: Uint8Array,
   opts: BytesToStringOpts = {},
 ): string {
-  let bytes = bytes_;
-  if (typeof opts.size !== "undefined") {
-    assertSize(bytes, { size: opts.size });
-    bytes = trim(bytes, { dir: "right" });
-  }
-  return new TextDecoder().decode(bytes);
+  return ox__Bytes.toString(bytes_, opts);
 }

package/src/utils/encoding/helpers/byte-size.ts

@@ -1,4 +1,4 @@
-import { type Hex, isHex } from "./is-hex.js";
+import { type Hex, isHex } from "../hex.js";
 
 /**
  * Calculates the byte size of a Hex string or Uint8Array.

package/src/utils/encoding/helpers/concat-hex.ts

@@ -1,4 +1,5 @@
-import type { Hex } from "./is-hex.js";
+import * as ox__Hex from "ox/Hex";
+import type { Hex } from "../hex.js";
 
 /**
  * Concatenates an array of hexadecimal values into a single hexadecimal value.
@@ -8,8 +9,5 @@ import type { Hex } from "./is-hex.js";
  * @utils
  */
 export function concatHex(values: readonly Hex[]): Hex {
-  return `0x${(values as Hex[]).reduce(
-    (acc, x) => acc + x.replace("0x", ""),
-    "",
-  )}`;
+  return ox__Hex.concat(...values);
 }

package/src/utils/encoding/helpers/is-hex.ts

@@ -1,9 +1,7 @@
-export type Hex = `0x${string}`;
+import * as ox__Hex from "ox/Hex";
+import type { Hex } from "../hex.js";
 
-export type IsHexOptions = {
-  /** If set to true, the value must start with "0x" and only contain hexadecimal characters. If set to false, the value can start with "0x" or not. Default is true. */
-  strict?: boolean;
-};
+export type IsHexOptions = ox__Hex.assert.Options;
 
 /**
  * Checks if a value is a valid hexadecimal string.
@@ -22,13 +20,5 @@ export function isHex(
   value: unknown,
   options: IsHexOptions = {},
 ): value is Hex {
-  if (!value) {
-    return false;
-  }
-  if (typeof value !== "string") {
-    return false;
-  }
-  return options.strict
-    ? /^0x[0-9a-fA-F]*$/.test(value)
-    : value.startsWith("0x");
+  return ox__Hex.validate(value, options);
 }

package/src/utils/encoding/hex.ts

@@ -1,51 +1,7 @@
-import { cachedTextDecoder } from "../text-decoder.js";
-import { cachedTextEncoder } from "../text-encoder.js";
-// slightly tweaked re-exports from viem for the moment
-import { assertSize } from "./helpers/assert-size.js";
-import { charCodeToBase16 } from "./helpers/charcode-to-base-16.js";
-import type { Hex } from "./helpers/is-hex.js";
+import * as ox__Hex from "ox/Hex";
+export { isHex, type IsHexOptions } from "./helpers/is-hex.js";
 
-export { type Hex, isHex, type IsHexOptions } from "./helpers/is-hex.js";
-
-type TrimOptions = {
-  dir?: "left" | "right";
-};
-type TrimReturnType<TValue extends Uint8Array | Hex> = TValue extends Hex
-  ? Hex
-  : Uint8Array;
-
-function trim<TValue extends Uint8Array | Hex>(
-  hexOrBytes: TValue,
-  options: TrimOptions = {},
-): TrimReturnType<TValue> {
-  const dir = options.dir || "left";
-  // biome-ignore lint/suspicious/noExplicitAny: TODO: fix any
-  let data: any =
-    typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
-
-  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 (typeof hexOrBytes === "string") {
-    if (data.length === 1 && dir === "right") {
-      data = `${data}0`;
-    }
-    return `0x${
-      data.length % 2 === 1 ? `0${data}` : data
-    }` as TrimReturnType<TValue>;
-  }
-  return data as TrimReturnType<TValue>;
-}
+export type Hex = ox__Hex.Hex;
 
 type PadOptions = {
   dir?: "left" | "right";
@@ -71,25 +27,17 @@ export function padHex(hex_: Hex, options: PadOptions = {}) {
   if (size === null) {
     return hex_;
   }
-  const hex = hex_.replace("0x", "");
-  if (hex.length > size * 2) {
-    throw new Error(`Size overflow: ${Math.ceil(hex.length / 2)} > ${size}`);
+  if (dir === "right") {
+    return ox__Hex.padRight(hex_, size);
   }
-
-  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](
-    size * 2,
-    "0",
-  )}` as Hex;
+  return ox__Hex.padLeft(hex_, size);
 }
 
 //--------------------------------------------------------------------------
 // FROM HEX
 //--------------------------------------------------------------------------
 
-export type HexToStringOpts = {
-  /** Size (in bytes) of the hex value. */
-  size?: number;
-};
+export type HexToStringOpts = ox__Hex.toString.Options;
 
 /**
  * Converts a hexadecimal string to a UTF-8 string.
@@ -105,20 +53,10 @@ export type HexToStringOpts = {
  * @utils
  */
 export function hexToString(hex: Hex, opts: HexToStringOpts = {}): string {
-  let bytes = hexToUint8Array(hex);
-  if (opts.size) {
-    assertSize(bytes, { size: opts.size });
-    bytes = trim(bytes, { dir: "right" });
-  }
-  return cachedTextDecoder().decode(bytes);
+  return ox__Hex.toString(hex, opts);
 }
 
-export type HexToBigIntOpts = {
-  /** Whether or not the number of a signed representation. */
-  signed?: boolean;
-  /** Size (in bytes) of the hex value. */
-  size?: number;
-};
+export type HexToBigIntOpts = ox__Hex.toBigInt.Options;
 
 /**
  * Converts a hexadecimal string to a BigInt.
@@ -134,24 +72,7 @@ export type HexToBigIntOpts = {
  * @utils
  */
 export function hexToBigInt(hex: Hex, opts: HexToBigIntOpts = {}): bigint {
-  const { signed } = opts;
-
-  if (opts.size) {
-    assertSize(hex, { size: opts.size });
-  }
-
-  const value = BigInt(hex);
-  if (!signed) {
-    return value;
-  }
-
-  const size = (hex.length - 2) / 2;
-  const max = (1n << (BigInt(size) * 8n - 1n)) - 1n;
-  if (value <= max) {
-    return value;
-  }
-
-  return value - BigInt(`0x${"f".padStart(size * 2, "f")}`) - 1n;
+  return ox__Hex.toBigInt(hex, opts);
 }
 
 export type HexToNumberOpts = HexToBigIntOpts;
@@ -169,13 +90,10 @@ export type HexToNumberOpts = HexToBigIntOpts;
  * @utils
  */
 export function hexToNumber(hex: Hex, opts: HexToNumberOpts = {}): number {
-  return Number(hexToBigInt(hex, opts));
+  return ox__Hex.toNumber(hex, opts);
 }
 
-export type HexToBoolOpts = {
-  /** Size (in bytes) of the hex value. */
-  size?: number;
-};
+export type HexToBoolOpts = ox__Hex.toBoolean.Options;
 
 /**
  * Converts a hexadecimal string to a boolean value.
@@ -192,24 +110,10 @@ export type HexToBoolOpts = {
  * @utils
  */
 export function hexToBool(hex: Hex, opts: HexToBoolOpts = {}): boolean {
-  if (opts.size) {
-    assertSize(hex, { size: opts.size });
-    // biome-ignore lint/style/noParameterAssign: for perf
-    hex = trim(hex);
-  }
-  if (trim(hex) === "0x00") {
-    return false;
-  }
-  if (trim(hex) === "0x01") {
-    return true;
-  }
-  throw new Error(`Invalid hex boolean: ${hex}`);
+  return ox__Hex.toBoolean(hex, opts);
 }
 
-export type HexToUint8ArrayOpts = {
-  /** Size of the output bytes. */
-  size?: number;
-};
+export type HexToUint8ArrayOpts = ox__Hex.toBytes.Options;
 
 /**
  * Converts a hexadecimal string to a Uint8Array.
@@ -228,28 +132,7 @@ export function hexToUint8Array(
   hex: Hex,
   opts: HexToUint8ArrayOpts = {},
 ): Uint8Array {
-  if (opts.size) {
-    assertSize(hex, { size: opts.size });
-    // biome-ignore lint/style/noParameterAssign: for perf
-    hex = padHex(hex, { dir: "right", size: opts.size });
-  }
-
-  let hexString = hex.slice(2) as string;
-  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 = charCodeToBase16(hexString.charCodeAt(j++));
-    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
-    if (nibbleLeft === undefined || nibbleRight === undefined) {
-      throw new Error(`Invalid hex character: ${hexString}`);
-    }
-    bytes[index] = nibbleLeft * 16 + nibbleRight;
-  }
-  return bytes;
+  return ox__Hex.toBytes(hex, opts);
 }
 
 export type FromHexParameters<
@@ -311,13 +194,7 @@ export function fromHex<
 // TO HEX
 //--------------------------------------------------------------------------
 
-const hexes = /* @__PURE__ */ (() =>
-  Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0")))();
-
-export type BoolToHexOpts = {
-  /** The size (in bytes) of the output hex value. */
-  size?: number;
-};
+export type BoolToHexOpts = ox__Hex.fromBoolean.Options;
 
 /**
  * Converts a boolean value to a hexadecimal string representation.
@@ -333,18 +210,10 @@ export type BoolToHexOpts = {
  * @utils
  */
 export function boolToHex(value: boolean, opts: BoolToHexOpts = {}): Hex {
-  const hex = `0x${Number(value)}` as const;
-  if (typeof opts.size === "number") {
-    assertSize(hex, { size: opts.size });
-    return padHex(hex, { size: opts.size });
-  }
-  return hex;
+  return ox__Hex.fromBoolean(value, opts);
 }
 
-export type Uint8ArrayToHexOpts = {
-  /** The size (in bytes) of the output hex value. */
-  size?: number;
-};
+export type Uint8ArrayToHexOpts = ox__Hex.fromBoolean.Options;
 
 /**
  * Converts an array of bytes to a hexadecimal string.
@@ -363,32 +232,10 @@ export function uint8ArrayToHex(
   value: Uint8Array,
   opts: Uint8ArrayToHexOpts = {},
 ): Hex {
-  let string = "";
-  for (let i = 0; i < value.length; i++) {
-    // biome-ignore lint/style/noNonNullAssertion: we know this is defined
-    string += hexes[value[i]!];
-  }
-  const hex = `0x${string}` as const;
-
-  if (typeof opts.size === "number") {
-    assertSize(hex, { size: opts.size });
-    return padHex(hex, { dir: "right", size: opts.size });
-  }
-  return hex;
+  return ox__Hex.fromBytes(value, opts);
 }
 
-export type NumberToHexOpts =
-  | {
-      /** Whether or not the number of a signed representation. */
-      signed?: boolean;
-      /** The size (in bytes) of the output hex value. */
-      size: number;
-    }
-  | {
-      signed?: never;
-      /** The size (in bytes) of the output hex value. */
-      size?: number;
-    };
+export type NumberToHexOpts = ox__Hex.fromNumber.Options;
 
 /**
  * Converts a number or bigint to a hexadecimal string.
@@ -408,47 +255,10 @@ export function numberToHex(
   value_: number | bigint,
   opts: NumberToHexOpts = {},
 ): Hex {
-  const { signed, size } = opts;
-
-  const value = BigInt(value_);
-
-  let maxValue: bigint | number | undefined;
-  if (size) {
-    if (signed) {
-      maxValue = (1n << (BigInt(size) * 8n - 1n)) - 1n;
-    } else {
-      maxValue = 2n ** (BigInt(size) * 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 Error(
-      `Number "${value_}${suffix}" is not in safe ${
-        size ? `${size * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""
-      }integer range ${
-        maxValue ? `(${minValue} to ${maxValue})` : `(above ${minValue})`
-      }`,
-    );
-  }
-
-  const hex = `0x${(
-    signed && value < 0 ? (1n << BigInt(size * 8)) + BigInt(value) : value
-  ).toString(16)}` as Hex;
-  if (size) {
-    return padHex(hex, { size }) as Hex;
-  }
-  return hex;
+  return ox__Hex.fromNumber(value_, opts);
 }
 
-export type StringToHexOpts = {
-  /** The size (in bytes) of the output hex value. */
-  size?: number;
-};
+export type StringToHexOpts = ox__Hex.fromString.Options;
 
 /**
  * Converts a string to its hexadecimal representation.
@@ -464,8 +274,7 @@ export type StringToHexOpts = {
  * @utils
  */
 export function stringToHex(value_: string, opts: StringToHexOpts = {}): Hex {
-  const value = cachedTextEncoder().encode(value_);
-  return uint8ArrayToHex(value, opts);
+  return ox__Hex.fromString(value_, opts);
 }
 
 export type ToHexParameters = {

package/src/utils/encoding/to-bytes.test.ts

@@ -4,59 +4,11 @@ import {
   boolToBytes,
   hexToBytes,
   numberToBytes,
-  padBytes,
   stringToBytes,
   toBytes,
 } from "./to-bytes.js";
 
 describe("to-bytes.js", () => {
-  describe("padBytes", () => {
-    it("should pad bytes to the left by default to the specified size", () => {
-      const result = padBytes(new Uint8Array([1, 2, 3]), { size: 5 });
-      expect(result).toEqual(new Uint8Array([0, 0, 1, 2, 3]));
-    });
-
-    it('should pad bytes to the right if dir is "right"', () => {
-      const result = padBytes(new Uint8Array([1, 2, 3]), {
-        dir: "right",
-        size: 5,
-      });
-      expect(result).toEqual(new Uint8Array([1, 2, 3, 0, 0]));
-    });
-
-    it("should not pad if the byte array is already the specified size", () => {
-      const result = padBytes(new Uint8Array([1, 2, 3, 4, 5]), { size: 5 });
-      expect(result).toEqual(new Uint8Array([1, 2, 3, 4, 5]));
-    });
-
-    it("should throw an error if the byte array exceeds the specified size", () => {
-      expect(() =>
-        padBytes(new Uint8Array([1, 2, 3, 4, 5, 6]), { size: 5 }),
-      ).toThrow("Size overflow: 6 > 5");
-    });
-
-    it("should return the same byte array if size is null", () => {
-      const bytes = new Uint8Array([1, 2, 3]);
-      const result = padBytes(bytes, { size: null });
-      expect(result).toEqual(bytes);
-    });
-
-    it("should pad to the default size of 32 if size is not specified", () => {
-      const result = padBytes(new Uint8Array([1, 2, 3]));
-      expect(result).toStrictEqual(
-        new Uint8Array([
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-          0, 0, 0, 0, 0, 0, 1, 2, 3,
-        ]),
-      );
-    });
-
-    it("should handle an empty byte array and pad to the specified size", () => {
-      const result = padBytes(new Uint8Array([]), { size: 3 });
-      expect(result).toEqual(new Uint8Array([0, 0, 0]));
-    });
-  });
-
   describe("toBytes", () => {
     it("should convert a number to bytes", () => {
       expect(toBytes(123)).toEqual(new Uint8Array([123]));
@@ -109,7 +61,7 @@ describe("to-bytes.js", () => {
 
     it("should throw an error if the specified size is less than the byte size", () => {
       expect(() => boolToBytes(true, { size: 0 })).toThrow(
-        "Size overflow: 1 > 0",
+        "Size cannot exceed `0` bytes. Given size: `1` bytes.",
       );
     });
 
@@ -151,7 +103,7 @@ describe("to-bytes.js", () => {
 
     it("should throw an error if the hex string exceeds the specified size", () => {
       expect(() => hexToBytes("0x123456", { size: 2 })).toThrow(
-        "Size overflow",
+        "Size cannot exceed `2` bytes. Given size: `3` bytes.",
       );
     });
 
@@ -211,7 +163,7 @@ describe("to-bytes.js", () => {
 
     it("should throw an error if the byte array exceeds the specified size", () => {
       expect(() => stringToBytes("Hello", { size: 3 })).toThrow(
-        "Size overflow: 5 > 3",
+        "Size cannot exceed `3` bytes. Given size: `5` bytes.",
       );
     });
 

package/src/utils/encoding/to-bytes.ts

@@ -1,36 +1,7 @@
-import { cachedTextEncoder } from "../text-encoder.js";
-import { assertSize } from "./helpers/assert-size.js";
-import { charCodeToBase16 } from "./helpers/charcode-to-base-16.js";
-import { type Hex, isHex } from "./helpers/is-hex.js";
-import { type NumberToHexOpts, numberToHex, padHex } from "./hex.js";
-
-type PadOptions = {
-  dir?: "left" | "right";
-  size?: number | null;
-};
-
-/**
- * @internal Exported for test
- */
-export function padBytes(
-  bytes: Uint8Array,
-  { dir, size = 32 }: PadOptions = {},
-) {
-  if (size === null) {
-    return bytes;
-  }
-  if (bytes.length > size) {
-    throw new Error(`Size overflow: ${bytes.length} > ${size}`);
-  }
-  const paddedBytes = new Uint8Array(size);
-  for (let i = 0; i < size; i++) {
-    const padEnd = dir === "right";
-    paddedBytes[padEnd ? i : size - i - 1] =
-      // biome-ignore lint/style/noNonNullAssertion: we know its there
-      bytes[padEnd ? i : bytes.length - i - 1]!;
-  }
-  return paddedBytes;
-}
+import * as ox__Bytes from "ox/Bytes";
+import { isHex } from "./helpers/is-hex.js";
+import type { Hex } from "./hex.js";
+import type { NumberToHexOpts } from "./hex.js";
 
 export type ToBytesParameters = {
   /** Size of the output bytes. */
@@ -68,10 +39,7 @@ export function toBytes(
   }
 }
 
-export type BoolToBytesOpts = {
-  /** Size of the output bytes. */
-  size?: number;
-};
+export type BoolToBytesOpts = ox__Bytes.fromBoolean.Options;
 
 /**
  * Converts a boolean value to a Uint8Array of bytes.
@@ -87,19 +55,10 @@ export type BoolToBytesOpts = {
  * @utils
  */
 export function boolToBytes(value: boolean, opts: BoolToBytesOpts = {}) {
-  const bytes = new Uint8Array(1);
-  bytes[0] = Number(value);
-  if (typeof opts.size === "number") {
-    assertSize(bytes, { size: opts.size });
-    return padBytes(bytes, { size: opts.size });
-  }
-  return bytes;
+  return ox__Bytes.fromBoolean(value, opts);
 }
 
-export type HexToBytesOpts = {
-  /** Size of the output bytes. */
-  size?: number;
-};
+export type HexToBytesOpts = ox__Bytes.fromHex.Options;
 
 /**
  * Converts a hexadecimal string to a Uint8Array of bytes.
@@ -116,32 +75,7 @@ export type HexToBytesOpts = {
  * @utils
  */
 export function hexToBytes(hex_: Hex, opts: HexToBytesOpts = {}): Uint8Array {
-  let hex = hex_;
-  if (opts.size) {
-    assertSize(hex, { size: opts.size });
-    hex = padHex(hex, { dir: "right", size: opts.size });
-  }
-
-  let hexString = hex.slice(2) as string;
-  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 = charCodeToBase16(hexString.charCodeAt(j++));
-    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
-    if (nibbleLeft === undefined || nibbleRight === undefined) {
-      throw new Error(
-        `Invalid byte sequence ("${hexString[j - 2]}${
-          hexString[j - 1]
-        }" in "${hexString}").`,
-      );
-    }
-    bytes[index] = nibbleLeft * 16 + nibbleRight;
-  }
-  return bytes;
+  return ox__Bytes.fromHex(hex_, opts);
 }
 
 /**
@@ -158,8 +92,7 @@ export function hexToBytes(hex_: Hex, opts: HexToBytesOpts = {}): Uint8Array {
  * @utils
  */
 export function numberToBytes(value: bigint | number, opts?: NumberToHexOpts) {
-  const hex = numberToHex(value, opts);
-  return hexToBytes(hex);
+  return ox__Bytes.fromNumber(value, opts);
 }
 
 export type StringToBytesOpts = {
@@ -184,10 +117,5 @@ export function stringToBytes(
   value: string,
   opts: StringToBytesOpts = {},
 ): Uint8Array {
-  const bytes = cachedTextEncoder().encode(value);
-  if (typeof opts.size === "number") {
-    assertSize(bytes, { size: opts.size });
-    return padBytes(bytes, { dir: "right", size: opts.size });
-  }
-  return bytes;
+  return ox__Bytes.fromString(value, opts);
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.67.1-nightly-9584885f42ba6d7fec7dd4e1b3d7e0b677cf6afc-20241112000327";
+export const version = "5.67.1-nightly-040e478ad6cf630dedf666eac7abeb668d323666-20241113000339";