@noble/hashes 2.3.0: keccak_256

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

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:1a601ba546f128a3f49f6424f667a016cc2b334d5ec8c67059dfa95d754ef071","contract":["keccak_256 is exported as a callable function from @noble/hashes/sha3.js","keccak_256 strictly requires Uint8Array inputs and throws TypeError on string inputs","keccak_256 produces exact 32-byte digest matching standard Keccak-256 test vectors for empty, ASCII, and multi-block byte inputs","keccak_256 exposes outputLen as 32 bytes and blockLen as 136 bytes","keccak_256.create supports incremental streaming hash updates via update and digest with Uint8Array inputs","keccak_256 incremental hash instance supports clone to independently branch hash computation","keccak_256 incremental hash instance supports digestInto to write digest into pre-allocated Uint8Array","keccak_256 incremental hash instance supports destroy which cleans state and prevents further updates","module wrapper helpers hashKeccak256, hashKeccak256Hex, and hashChunksHex accept string and Uint8Array inputs to compute correct digests"],"goal":"verify @noble/hashes.keccak_256 in pkg:npm/%40noble/hashes@2.3.0","kind":"HOW","packages":["pkg:npm/%40noble/hashes@2.3.0"],"schemaVersion":1,"symbols":["@noble/hashes.keccak_256"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","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.keccak_256"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-noble-hashes-keccak256",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-noble-hashes-keccak256",
      "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-keccak256",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "description": "Clean-room code sample for @noble/hashes keccak_256",
  "main": "src/index.js",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "@noble/hashes": "2.3.0"
  },
  "license": "MIT-0"
}

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

import { keccak_256 } from '@noble/hashes/sha3.js';
import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';

/**
 * Normalizes input to Uint8Array, encoding strings as UTF-8.
 * In @noble/hashes v2, functions strictly require Uint8Array inputs.
 * @param {string | Uint8Array} input
 * @returns {Uint8Array}
 */
export function toBytes(input) {
  if (typeof input === 'string') {
    return utf8ToBytes(input);
  }
  return input;
}

/**
 * Computes the Keccak-256 hash of a string or Uint8Array and returns the raw 32-byte Uint8Array digest.
 * @param {string | Uint8Array} input
 * @returns {Uint8Array}
 */
export function hashKeccak256(input) {
  return keccak_256(toBytes(input));
}

/**
 * Computes the Keccak-256 hash of a string or Uint8Array and returns a lowercase hex string.
 * @param {string | Uint8Array} input
 * @returns {string}
 */
export function hashKeccak256Hex(input) {
  return bytesToHex(keccak_256(toBytes(input)));
}

/**
 * Creates an incremental Keccak-256 hasher.
 * @returns {ReturnType<typeof keccak_256.create>}
 */
export function createKeccak256Hasher() {
  return keccak_256.create();
}

/**
 * Computes Keccak-256 hash over an array of sequential chunks.
 * @param {Array<string | Uint8Array>} chunks
 * @returns {string}
 */
export function hashChunksHex(chunks) {
  const hasher = keccak_256.create();
  for (const chunk of chunks) {
    hasher.update(toBytes(chunk));
  }
  return bytesToHex(hasher.digest());
}

export { keccak_256, bytesToHex, utf8ToBytes };

import assert from 'node:assert/strict';
import { keccak_256 as directKeccak256 } from '@noble/hashes/sha3.js';
import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';
import {
  keccak_256,
  toBytes,
  hashKeccak256,
  hashKeccak256Hex,
  createKeccak256Hasher,
  hashChunksHex,
} from '../src/index.js';

// 1. keccak_256 is exported as a callable function from @noble/hashes/sha3.js
assert.equal(typeof directKeccak256, 'function', 'keccak_256 must be a function');
assert.equal(typeof keccak_256, 'function', 're-exported keccak_256 must be a function');

// 2. keccak_256 strictly requires Uint8Array inputs and throws TypeError on string inputs
{
  assert.throws(
    () => directKeccak256('string-input'),
    {
      name: 'TypeError',
      message: /expected Uint8Array/,
    },
    'keccak_256 must throw TypeError when given a string'
  );
  assert.throws(
    () => {
      const hasher = directKeccak256.create();
      hasher.update('string-input');
    },
    {
      name: 'TypeError',
      message: /expected Uint8Array/,
    },
    'hasher.update must throw TypeError when given a string'
  );
}

// 3. keccak_256 produces exact 32-byte digest matching standard Keccak-256 test vectors for empty, ASCII, and multi-block byte inputs
{
  const emptyBytes = new Uint8Array(0);
  const emptyDigest = directKeccak256(emptyBytes);
  assert.equal(emptyDigest.length, 32, 'Empty input digest length must be 32 bytes');
  assert.equal(
    bytesToHex(emptyDigest),
    'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470',
    'Empty input digest must match Keccak-256 vector'
  );

  const abcBytes = utf8ToBytes('abc');
  const abcDigest = directKeccak256(abcBytes);
  assert.equal(abcDigest.length, 32, 'abc digest length must be 32 bytes');
  assert.equal(
    bytesToHex(abcDigest),
    '4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45',
    'abc digest must match Keccak-256 vector'
  );

  const foxMsg = 'The quick brown fox jumps over the lazy dog';
  const foxDigest = directKeccak256(utf8ToBytes(foxMsg));
  assert.equal(foxDigest.length, 32, 'fox digest length must be 32 bytes');
  assert.equal(
    bytesToHex(foxDigest),
    '4d741b6f1eb29cb2a9b9911c82f56fa8d73b04959d3d9d222895df6c0b28aa15',
    'fox message digest must match Keccak-256 vector'
  );
}

// 4. keccak_256 exposes outputLen as 32 bytes and blockLen as 136 bytes
assert.equal(directKeccak256.outputLen, 32, 'keccak_256.outputLen must be 32 bytes');
assert.equal(directKeccak256.blockLen, 136, 'keccak_256.blockLen must be 136 bytes');

// 5. keccak_256.create supports incremental streaming hash updates via update and digest with Uint8Array inputs
{
  const hasher = directKeccak256.create();
  hasher.update(utf8ToBytes('The quick '));
  hasher.update(utf8ToBytes('brown fox '));
  hasher.update(utf8ToBytes('jumps over the lazy dog'));
  const digestHex = bytesToHex(hasher.digest());
  assert.equal(
    digestHex,
    '4d741b6f1eb29cb2a9b9911c82f56fa8d73b04959d3d9d222895df6c0b28aa15',
    'Incremental keccak_256 stream must match expected multi-part digest'
  );
}

// 6. keccak_256 incremental hash instance supports clone to independently branch hash computation
{
  const base = directKeccak256.create();
  base.update(utf8ToBytes('common prefix: '));
  const branchA = base.clone();
  const branchB = base.clone();
  branchA.update(utf8ToBytes('action_alpha'));
  branchB.update(utf8ToBytes('action_beta'));

  assert.equal(
    bytesToHex(branchA.digest()),
    bytesToHex(directKeccak256(utf8ToBytes('common prefix: action_alpha'))),
    'Cloned branch A must compute independent digest'
  );
  assert.equal(
    bytesToHex(branchB.digest()),
    bytesToHex(directKeccak256(utf8ToBytes('common prefix: action_beta'))),
    'Cloned branch B must compute independent digest'
  );
}

// 7. keccak_256 incremental hash instance supports digestInto to write digest into pre-allocated Uint8Array
{
  const outBuf = new Uint8Array(32);
  const hasher = directKeccak256.create();
  hasher.update(utf8ToBytes('abc'));
  hasher.digestInto(outBuf);
  assert.equal(
    bytesToHex(outBuf),
    '4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45',
    'digestInto must write digest into target Uint8Array buffer'
  );
}

// 8. keccak_256 incremental hash instance supports destroy which cleans state and prevents further updates
{
  const hasher = directKeccak256.create();
  hasher.update(utf8ToBytes('sensitive data'));
  hasher.destroy();
  assert.throws(
    () => hasher.update(utf8ToBytes('more data')),
    /destroyed/,
    'Calling update after destroy must throw'
  );
}

// 9. module wrapper helpers hashKeccak256, hashKeccak256Hex, and hashChunksHex accept string and Uint8Array inputs to compute correct digests
{
  const rawFromStr = hashKeccak256('abc');
  const rawFromBytes = hashKeccak256(utf8ToBytes('abc'));
  assert(rawFromStr instanceof Uint8Array, 'hashKeccak256 must return Uint8Array');
  assert.equal(rawFromStr.length, 32, 'hashKeccak256 length must be 32');
  assert.equal(bytesToHex(rawFromStr), bytesToHex(rawFromBytes), 'String and byte input must produce identical hash');

  assert.equal(
    hashKeccak256Hex('abc'),
    '4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45',
    'hashKeccak256Hex must return correct lowercase hex string'
  );

  const chunksHex = hashChunksHex(['The quick ', 'brown fox ', utf8ToBytes('jumps over the lazy dog')]);
  assert.equal(
    chunksHex,
    '4d741b6f1eb29cb2a9b9911c82f56fa8d73b04959d3d9d222895df6c0b28aa15',
    'hashChunksHex must match expected multi-part digest'
  );
}

console.log('All @noble/hashes.keccak_256 contract assertions passed.');