@noble/hashes 2.3.0: isBytes

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify @noble/hashes.isBytes in pkg:npm/%40noble/hashes@2.3.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/%40noble/hashes@2.3.0
Demonstrate these symbols/APIs:
  - @noble/hashes.isBytes

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:ad4ca0d4306d0983056023f847470ade2851fe7a6b3ff7e312c0f207f396a3f8","contract":["isBytes returns true for Uint8Array and Node.js Buffer instances","isBytes returns false for other TypedArrays such as Uint8ClampedArray, Int8Array, and Uint16Array","isBytes returns false for ArrayBuffer, DataView, plain arrays, objects, primitives, and nullish values","assertBytes returns valid Uint8Array or throws TypeError on non-byte inputs"],"goal":"verify @noble/hashes.isBytes in pkg:npm/%40noble/hashes@2.3.0","kind":"HOW","packages":["pkg:npm/%40noble/hashes@2.3.0"],"schemaVersion":1,"symbols":["@noble/hashes.isBytes"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/%40noble/hashes@2.3.0"],"schemaVersion":1,"subject":"pkg:npm/%40noble/hashes@2.3.0","symbols":["@noble/hashes.isBytes"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-noble-hashes-isbytes",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-noble-hashes-isbytes",
      "version": "1.0.0",
      "dependencies": {
        "@noble/hashes": "2.3.0"
      }
    },
    "node_modules/@noble/hashes": {
      "version": "2.3.0",
      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-2.3.0.tgz",
      "integrity": "sha512-oN+QwyX7VSHotibwubG3kpzbwKrfnyR6OOO+3Nk/53ADL7FmgHHz4TgrbaYKvvOw09u6QTx0oiH1cNCIOuN0CQ==",
      "license": "MIT",
      "engines": {
        "node": ">= 20.19.0"
      },
      "funding": {
        "url": "https://paulmillr.com/funding/"
      }
    }
  }
}

{
  "name": "sample-noble-hashes-isbytes",
  "version": "1.0.0",
  "type": "module",
  "dependencies": {
    "@noble/hashes": "2.3.0"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify @noble/hashes.isBytes in pkg:npm/%40noble/hashes@2.3.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/%40noble/hashes@2.3.0"
  ],
  "symbols": [
    "@noble/hashes.isBytes"
  ]
}

import { isBytes } from '@noble/hashes/utils.js';

export { isBytes };

/**
 * Validates that an input is a Uint8Array or compatible byte sequence.
 * @param {unknown} input
 * @returns {boolean}
 */
export function checkIsBytes(input) {
  return isBytes(input);
}

/**
 * Asserts that the input is a valid Uint8Array byte sequence.
 * @param {unknown} input
 * @param {string} [paramName='input']
 * @returns {Uint8Array}
 * @throws {TypeError}
 */
export function assertBytes(input, paramName = 'input') {
  if (!isBytes(input)) {
    throw new TypeError(`${paramName} must be a Uint8Array`);
  }
  return input;
}

import assert from 'node:assert';
import { isBytes, checkIsBytes, assertBytes } from '../src/index.mjs';

// 1. isBytes returns true for Uint8Array instances
assert.strictEqual(isBytes(new Uint8Array(0)), true);
assert.strictEqual(isBytes(new Uint8Array([1, 2, 3])), true);
assert.strictEqual(isBytes(new Uint8Array(new ArrayBuffer(16), 4, 8)), true);
assert.strictEqual(checkIsBytes(new Uint8Array([0xde, 0xad])), true);

// 2. isBytes returns true for Node.js Buffer instances
assert.strictEqual(isBytes(Buffer.from('test')), true);
assert.strictEqual(isBytes(Buffer.alloc(8)), true);
assert.strictEqual(checkIsBytes(Buffer.from([1, 2, 3])), true);

// 3. isBytes returns false for other TypedArray types
assert.strictEqual(isBytes(new Uint8ClampedArray(4)), false);
assert.strictEqual(isBytes(new Int8Array(4)), false);
assert.strictEqual(isBytes(new Uint16Array(4)), false);
assert.strictEqual(isBytes(new Int16Array(4)), false);
assert.strictEqual(isBytes(new Uint32Array(4)), false);
assert.strictEqual(isBytes(new Int32Array(4)), false);
assert.strictEqual(isBytes(new Float32Array(4)), false);
assert.strictEqual(isBytes(new Float64Array(4)), false);
assert.strictEqual(isBytes(new BigInt64Array(4)), false);

// 4. isBytes returns false for non-view objects, ArrayBuffer, DataView, and arrays
assert.strictEqual(isBytes(new ArrayBuffer(8)), false);
assert.strictEqual(isBytes(new DataView(new ArrayBuffer(8))), false);
assert.strictEqual(isBytes([1, 2, 3]), false);
assert.strictEqual(isBytes({ length: 0 }), false);
assert.strictEqual(isBytes({ constructor: { name: 'Uint8Array' } }), false);

// 5. isBytes returns false for primitives and nullish values
assert.strictEqual(isBytes(null), false);
assert.strictEqual(isBytes(undefined), false);
assert.strictEqual(isBytes(''), false);
assert.strictEqual(isBytes('binary string'), false);
assert.strictEqual(isBytes(123), false);
assert.strictEqual(isBytes(true), false);
assert.strictEqual(isBytes(Symbol('bytes')), false);

// 6. assertBytes succeeds on byte arrays and throws TypeError on invalid inputs
const validBytes = new Uint8Array([42]);
assert.strictEqual(assertBytes(validBytes), validBytes);

assert.throws(
  () => assertBytes('invalid string', 'payload'),
  {
    name: 'TypeError',
    message: 'payload must be a Uint8Array'
  }
);
assert.throws(
  () => assertBytes(null),
  {
    name: 'TypeError',
    message: 'input must be a Uint8Array'
  }
);

console.log('Contract tests passed successfully.');