@noble/hashes 2.3.0: bytesToHex

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.bytesToHex 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.bytesToHex

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:4880f6aaf81047b170bf5d75a38507bdfd123e7e1b86620ac24038c8cdfbbb0d","contract":["bytesToHex converts Uint8Array byte sequences into lowercase hexadecimal strings with two characters per byte","bytesToHex returns an empty string when given an empty Uint8Array","bytesToHex operates correctly on Uint8Array subarrays and offset buffer views","bytesToHex rejects non-Uint8Array inputs by throwing TypeError"],"goal":"verify @noble/hashes.bytesToHex in pkg:npm/%40noble/hashes@2.3.0","kind":"HOW","packages":["pkg:npm/%40noble/hashes@2.3.0"],"schemaVersion":1,"symbols":["@noble/hashes.bytesToHex"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","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.bytesToHex"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-noble-hashes-bytes-to-hex",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-noble-hashes-bytes-to-hex",
      "version": "1.0.0",
      "license": "MIT-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-bytes-to-hex",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "license": "MIT-0",
  "dependencies": {
    "@noble/hashes": "2.3.0"
  }
}

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

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

export { bytesToHex };

/**
 * Converts a Uint8Array byte sequence to a lowercase hexadecimal string.
 * @param {Uint8Array} bytes
 * @returns {string}
 */
export function toHex(bytes) {
  return bytesToHex(bytes);
}

/**
 * Encodes a string into UTF-8 bytes and converts to hexadecimal.
 * @param {string} str
 * @returns {string}
 */
export function stringToHex(str) {
  const encoder = new TextEncoder();
  return bytesToHex(encoder.encode(str));
}

import assert from 'node:assert/strict';
import { bytesToHex, toHex, stringToHex } from '../src/index.mjs';

// 1. bytesToHex converts Uint8Array byte sequences into lowercase hexadecimal strings with two characters per byte
{
  const bytes = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
  assert.equal(bytesToHex(bytes), 'deadbeef');
  assert.equal(toHex(bytes), 'deadbeef');

  const paddedBytes = new Uint8Array([0x00, 0x01, 0x0a, 0x0f, 0x10, 0xff]);
  assert.equal(bytesToHex(paddedBytes), '00010a0f10ff');
  assert.equal(toHex(paddedBytes), '00010a0f10ff');

  assert.equal(stringToHex('hello'), '68656c6c6f');
}

// 2. bytesToHex returns an empty string when given an empty Uint8Array
{
  const emptyBytes = new Uint8Array(0);
  assert.equal(bytesToHex(emptyBytes), '');
  assert.equal(toHex(emptyBytes), '');
  assert.equal(stringToHex(''), '');
}

// 3. bytesToHex operates correctly on Uint8Array subarrays and offset buffer views
{
  const buffer = new ArrayBuffer(8);
  const view = new Uint8Array(buffer, 2, 4);
  view[0] = 0x12;
  view[1] = 0x34;
  view[2] = 0x56;
  view[3] = 0x78;
  assert.equal(bytesToHex(view), '12345678');
  assert.equal(toHex(view), '12345678');

  const sub = new Uint8Array([0xaa, 0xbb, 0xcc, 0xdd]).subarray(1, 3);
  assert.equal(bytesToHex(sub), 'bbcc');
  assert.equal(toHex(sub), 'bbcc');
}

// 4. bytesToHex rejects non-Uint8Array inputs by throwing TypeError
{
  assert.throws(() => bytesToHex('not bytes'), TypeError);
  assert.throws(() => bytesToHex(null), TypeError);
  assert.throws(() => bytesToHex(undefined), TypeError);
  assert.throws(() => bytesToHex([1, 2, 3]), TypeError);
  assert.throws(() => bytesToHex(12345), TypeError);
  assert.throws(() => bytesToHex({}), TypeError);

  assert.throws(() => toHex('not bytes'), TypeError);
  assert.throws(() => toHex(null), TypeError);
}

console.log('All contract tests passed successfully.');