viem 0.4.0-main.20230418T011420 → 0.4.0-main.20230419T202802

package/dist/types/utils/encoding/toBytes.d.ts

@@ -1,21 +1,125 @@
 import type { ByteArray, Hex } from '../../types/index.js';
 import type { NumberToHexOpts } from './toHex.js';
-/** @description Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array. */
-export declare function toBytes(value: string | bigint | number | boolean | Hex): ByteArray;
+export type ToBytesParameters = {
+    /** Size of the output bytes. */
+    size?: number;
+};
 /**
- * @description Encodes a boolean into a byte array.
+ * Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html
+ * - Example: https://viem.sh/docs/utilities/toBytes.html#usage
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes('Hello world')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes(420)
+ * // Uint8Array([1, 164])
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes(420, { size: 4 })
+ * // Uint8Array([0, 0, 1, 164])
  */
-export declare function boolToBytes(value: boolean): Uint8Array;
+export declare function toBytes(value: string | bigint | number | boolean | Hex, opts?: ToBytesParameters): ByteArray;
+export type BoolToHexOpts = {
+    /** Size of the output bytes. */
+    size?: number;
+};
 /**
- * @description Encodes a hex string into a byte array.
+ * Encodes a boolean into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#booltobytes
+ *
+ * @param value Boolean value to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { boolToBytes } from 'viem'
+ * const data = boolToBytes(true)
+ * // Uint8Array([1])
+ *
+ * @example
+ * import { boolToBytes } from 'viem'
+ * const data = boolToBytes(true, { size: 32 })
+ * // 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, 1])
  */
-export declare function hexToBytes(hex_: Hex): ByteArray;
+export declare function boolToBytes(value: boolean, opts?: BoolToHexOpts): Uint8Array;
+export type HexToBytesOpts = {
+    /** Size of the output bytes. */
+    size?: number;
+};
 /**
- * @description Encodes a number into a byte array.
+ * Encodes a hex string into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#hextobytes
+ *
+ * @param hex Hex string to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { hexToBytes } from 'viem'
+ * const data = hexToBytes('0x48656c6c6f20776f726c6421')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { hexToBytes } from 'viem'
+ * const data = hexToBytes('0x48656c6c6f20776f726c6421', { size: 32 })
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+ */
+export declare function hexToBytes(hex_: Hex, opts?: HexToBytesOpts): ByteArray;
+/**
+ * Encodes a number into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#numbertobytes
+ *
+ * @param value Number to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { numberToBytes } from 'viem'
+ * const data = numberToBytes(420)
+ * // Uint8Array([1, 164])
+ *
+ * @example
+ * import { numberToBytes } from 'viem'
+ * const data = numberToBytes(420, { size: 4 })
+ * // Uint8Array([0, 0, 1, 164])
  */
 export declare function numberToBytes(value: bigint | number, opts?: NumberToHexOpts): Uint8Array;
+export type StringToBytesOpts = {
+    /** Size of the output bytes. */
+    size?: number;
+};
 /**
- * @description Encodes a UTF-8 string into a byte array.
+ * Encodes a UTF-8 string into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#stringtobytes
+ *
+ * @param value String to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { stringToBytes } from 'viem'
+ * const data = stringToBytes('Hello world!')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { stringToBytes } from 'viem'
+ * const data = stringToBytes('Hello world!', { size: 32 })
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
  */
-export declare function stringToBytes(value: string): ByteArray;
+export declare function stringToBytes(value: string, opts?: StringToBytesOpts): ByteArray;
 //# sourceMappingURL=toBytes.d.ts.map

package/dist/types/utils/encoding/toBytes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toBytes.d.ts","sourceRoot":"","sources":["../../../../src/utils/encoding/toBytes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAKjD,iGAAiG;AACjG,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,GAAG,GAC9C,SAAS,CAMX;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,cAIzC;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,GAAG,SAAS,CAe/C;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,cAG3E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAEtD"}
+{"version":3,"file":"toBytes.d.ts","sourceRoot":"","sources":["../../../../src/utils/encoding/toBytes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAA;AAI1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAKjD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,GAAG,EAC/C,IAAI,GAAE,iBAAsB,GAC3B,SAAS,CAMX;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,aAAkB,cAQnE;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,GAAE,cAAmB,GAAG,SAAS,CAsB1E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,cAG3E;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,iBAAsB,GAC3B,SAAS,CAOX"}

package/dist/types/utils/encoding/toHex.d.ts

@@ -1,29 +1,139 @@
 import type { ByteArray, Hex } from '../../types/index.js';
+export type ToHexParameters = {
+    /** The size (in bytes) of the output hex value. */
+    size?: number;
+};
 /**
- * @description Encodes a boolean into a hex string
+ * Encodes a string, number, bigint, or ByteArray into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html
+ * - Example: https://viem.sh/docs/utilities/toHex.html#usage
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex('Hello world')
+ * // '0x48656c6c6f20776f726c6421'
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex(420)
+ * // '0x1a4'
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex('Hello world', { size: 32 })
+ * // '0x48656c6c6f20776f726c64210000000000000000000000000000000000000000'
  */
-export declare function boolToHex(value: boolean): Hex;
+export declare function toHex(value: string | number | bigint | boolean | ByteArray, opts?: ToHexParameters): Hex;
+export type BoolToHexOpts = {
+    /** The size (in bytes) of the output hex value. */
+    size?: number;
+};
 /**
- * @description Encodes a bytes array into a hex string
+ * Encodes a boolean into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#booltohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(true)
+ * // '0x1'
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(false)
+ * // '0x0'
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(true, { size: 32 })
+ * // '0x0000000000000000000000000000000000000000000000000000000000000001'
  */
-export declare function bytesToHex(value: ByteArray): Hex;
+export declare function boolToHex(value: boolean, opts?: BoolToHexOpts): Hex;
+export type BytesToHexOpts = {
+    /** The size (in bytes) of the output hex value. */
+    size?: number;
+};
 /**
- * @description Encodes a string, number, bigint, or ByteArray into a hex string
+ * Encodes a bytes array into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#bytestohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { bytesToHex } from 'viem'
+ * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ * // '0x48656c6c6f20576f726c6421'
+ *
+ * @example
+ * import { bytesToHex } from 'viem'
+ * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]), { size: 32 })
+ * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
  */
-export declare function toHex(value: string | number | bigint | boolean | ByteArray): Hex;
+export declare function bytesToHex(value: ByteArray, opts?: BytesToHexOpts): Hex;
 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;
-    size?: never;
+    /** The size (in bytes) of the output hex value. */
+    size?: number;
 };
 /**
- * @description Encodes a number or bigint into a hex string
+ * Encodes a number or bigint into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#numbertohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { numberToHex } from 'viem'
+ * const data = numberToHex(420)
+ * // '0x1a4'
+ *
+ * @example
+ * import { numberToHex } from 'viem'
+ * const data = numberToHex(420, { size: 32 })
+ * // '0x00000000000000000000000000000000000000000000000000000000000001a4'
  */
 export declare function numberToHex(value_: number | bigint, opts?: NumberToHexOpts): Hex;
+export type StringToHexOpts = {
+    /** The size (in bytes) of the output hex value. */
+    size?: number;
+};
 /**
- * @description Encodes a UTF-8 string into a hex string
+ * Encodes a UTF-8 string into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#stringtohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { stringToHex } from 'viem'
+ * const data = stringToHex('Hello World!')
+ * // '0x48656c6c6f20576f726c6421'
+ *
+ * @example
+ * import { stringToHex } from 'viem'
+ * const data = stringToHex('Hello World!', { size: 32 })
+ * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
  */
-export declare function stringToHex(value_: string): Hex;
+export declare function stringToHex(value_: string, opts?: StringToHexOpts): Hex;
 //# sourceMappingURL=toHex.d.ts.map

package/dist/types/utils/encoding/toHex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toHex.d.ts","sourceRoot":"","sources":["../../../../src/utils/encoding/toHex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAA;AAO1D;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,CAE7C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,GAAG,CAMhD;AAED;;GAEG;AACH,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GACpD,GAAG,CAQL;AAED,MAAM,MAAM,eAAe,GACvB;IAEE,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,MAAM,CAAC,EAAE,KAAK,CAAA;IACd,IAAI,CAAC,EAAE,KAAK,CAAA;CACb,CAAA;AAEL;;GAEG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,IAAI,GAAE,eAAoB,GACzB,GAAG,CAgCL;AAID;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAG/C"}
+{"version":3,"file":"toHex.d.ts","sourceRoot":"","sources":["../../../../src/utils/encoding/toHex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAA;AAQ1D,MAAM,MAAM,eAAe,GAAG;IAC5B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,EACrD,IAAI,GAAE,eAAoB,GACzB,GAAG,CAQL;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,aAAkB,GAAG,GAAG,CAOvE;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,GAAE,cAAmB,GAAG,GAAG,CAY3E;AAED,MAAM,MAAM,eAAe,GACvB;IACE,4DAA4D;IAC5D,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,MAAM,CAAC,EAAE,KAAK,CAAA;IACd,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAEL;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,IAAI,GAAE,eAAoB,GACzB,GAAG,CAgCL;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,GAAG,CAG3E"}

package/package.json

@@ -12,7 +12,7 @@
     "isomorphic-ws": "5.0.0",
     "ws": "8.12.0"
   },
-  "version": "0.4.0-main.20230418T011420",
+  "version": "0.4.0-main.20230419T202802",
   "files": [
     "dist",
     "!dist/**/*.tsbuildinfo",

package/src/errors/encoding.ts

@@ -81,3 +81,12 @@ export class OffsetOutOfBoundsError extends BaseError {
     )
   }
 }
+
+export class SizeOverflowError extends BaseError {
+  override name = 'SizeOverflowError'
+  constructor({ givenSize, maxSize }: { givenSize: number; maxSize: number }) {
+    super(
+      `Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`,
+    )
+  }
+}

package/src/errors/index.ts

@@ -58,6 +58,7 @@ export {
   InvalidHexBooleanError,
   InvalidHexValueError,
   OffsetOutOfBoundsError,
+  SizeOverflowError,
 } from './encoding.js'
 
 export {

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '0.4.0-main.20230418T011420'
+export const version = '0.4.0-main.20230419T202802'

package/src/utils/encoding/fromBytes.ts

@@ -1,8 +1,20 @@
 import { InvalidBytesBooleanError } from '../../errors/index.js'
 import type { ByteArray, Hex } from '../../types/index.js'
-import { hexToBigInt, hexToNumber } from './fromHex.js'
+import { trim } from '../data/trim.js'
+import { assertSize, hexToBigInt, hexToNumber } from './fromHex.js'
 import { bytesToHex } from './toHex.js'
 
+export type FromBytesParameters<
+  TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
+> =
+  | TTo
+  | {
+      /** Size of the bytes. */
+      size?: number
+      /** Type to convert to. */
+      to: TTo
+    }
+
 type FromBytesReturnType<TTo> = TTo extends 'string'
   ? string
   : TTo extends 'hex'
@@ -16,30 +28,106 @@ type FromBytesReturnType<TTo> = TTo extends 'string'
   : never
 
 /**
- * @description Decodes a byte array into a UTF-8 string, hex value, number, bigint or boolean.
+ * Decodes a byte array into a UTF-8 string, hex value, number, bigint or boolean.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html
+ * - Example: https://viem.sh/docs/utilities/fromBytes.html#usage
+ *
+ * @param bytes Byte array to decode.
+ * @param toOrOpts Type to convert to or options.
+ * @returns Decoded value.
+ *
+ * @example
+ * import { fromBytes } from 'viem'
+ * const data = fromBytes(new Uint8Array([1, 164]), 'number')
+ * // 420
+ *
+ * @example
+ * import { fromBytes } from 'viem'
+ * const data = fromBytes(
+ *   new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+ *   'string'
+ * )
+ * // 'Hello world'
  */
 export function fromBytes<
   TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
->(bytes: ByteArray, to: TTo): FromBytesReturnType<TTo> {
-  if (to === 'number') return bytesToNumber(bytes) as FromBytesReturnType<TTo>
-  if (to === 'bigint') return bytesToBigint(bytes) as FromBytesReturnType<TTo>
-  if (to === 'boolean') return bytesToBool(bytes) as FromBytesReturnType<TTo>
-  if (to === 'string') return bytesToString(bytes) as FromBytesReturnType<TTo>
-  return bytesToHex(bytes) as FromBytesReturnType<TTo>
+>(
+  bytes: ByteArray,
+  toOrOpts: FromBytesParameters<TTo>,
+): FromBytesReturnType<TTo> {
+  const opts = typeof toOrOpts === 'string' ? { to: toOrOpts } : toOrOpts
+  const to = opts.to
+
+  if (to === 'number')
+    return bytesToNumber(bytes, opts) as FromBytesReturnType<TTo>
+  if (to === 'bigint')
+    return bytesToBigint(bytes, opts) as FromBytesReturnType<TTo>
+  if (to === 'boolean')
+    return bytesToBool(bytes, opts) as FromBytesReturnType<TTo>
+  if (to === 'string')
+    return bytesToString(bytes, opts) as FromBytesReturnType<TTo>
+  return bytesToHex(bytes, opts) as FromBytesReturnType<TTo>
+}
+
+export type BytesToBigIntOpts = {
+  /** Whether or not the number of a signed representation. */
+  signed?: boolean
+  /** Size of the bytes. */
+  size?: number
 }
 
 /**
- * @description Decodes a byte array into a bigint.
+ * Decodes a byte array into a bigint.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestobigint
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns BigInt value.
+ *
+ * @example
+ * import { bytesToBigint } from 'viem'
+ * const data = bytesToBigint(new Uint8Array([1, 164]))
+ * // 420n
  */
-export function bytesToBigint(bytes: ByteArray): bigint {
-  const hex = bytesToHex(bytes)
+export function bytesToBigint(
+  bytes: ByteArray,
+  opts: BytesToBigIntOpts = {},
+): bigint {
+  if (typeof opts.size !== 'undefined') assertSize(bytes, { size: opts.size })
+  const hex = bytesToHex(bytes, opts)
   return hexToBigInt(hex)
 }
 
+export type BytesToBoolOpts = {
+  /** Size of the bytes. */
+  size?: number
+}
+
 /**
- * @description Decodes a byte array into a boolean.
+ * Decodes a byte array into a boolean.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestobool
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns Boolean value.
+ *
+ * @example
+ * import { bytesToBool } from 'viem'
+ * const data = bytesToBool(new Uint8Array([1]))
+ * // true
  */
-export function bytesToBool(bytes: ByteArray): boolean {
+export function bytesToBool(
+  bytes_: ByteArray,
+  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] > 1)
     throw new InvalidBytesBooleanError(bytes)
   return Boolean(bytes[0])
@@ -47,17 +135,58 @@ export function bytesToBool(bytes: ByteArray): boolean {
 
 export { bytesToHex }
 
+export type BytesToNumberOpts = BytesToBigIntOpts
+
 /**
- * @description Decodes a byte array into a number.
+ * Decodes a byte array into a number.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestonumber
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns Number value.
+ *
+ * @example
+ * import { bytesToNumber } from 'viem'
+ * const data = bytesToNumber(new Uint8Array([1, 164]))
+ * // 420
  */
-export function bytesToNumber(bytes: ByteArray): number {
-  const hex = bytesToHex(bytes)
+export function bytesToNumber(
+  bytes: ByteArray,
+  opts: BytesToNumberOpts = {},
+): number {
+  if (typeof opts.size !== 'undefined') assertSize(bytes, { size: opts.size })
+  const hex = bytesToHex(bytes, opts)
   return hexToNumber(hex)
 }
 
+export type BytesToStringOpts = {
+  /** Size of the bytes. */
+  size?: number
+}
+
 /**
- * @description Decodes a byte array into a UTF-8 string.
+ * Decodes a byte array into a UTF-8 string.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestostring
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns String value.
+ *
+ * @example
+ * import { bytesToString } from 'viem'
+ * const data = bytesToString(new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+ * // 'Hello world'
  */
-export function bytesToString(bytes: ByteArray): string {
+export function bytesToString(
+  bytes_: ByteArray,
+  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)
 }