@noble/hashes 2.3.0: sha512_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.sha512_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.sha512_256
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

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:a95dc036254e241671b2ecbf4a59c6757175efcd72e398a4beff1e23893055c2","constraints":{"executionContext":"node"},"contract":["sha512_256 computes a 32-byte (256-bit) digest for Uint8Array message input matching the standard test vector","sha512_256 correctly computes the 32-byte SHA-512/256 digest for empty input","sha512_256 supports incremental hashing via create() updating with multiple Uint8Array chunks","sha512_256 hasher instances support clone() preserving intermediate state for independent digest streams","sha512_256 exposes outputLen of 32 and blockLen of 128 bytes","sha512_256 supports writing directly into a preallocated Uint8Array output buffer via digestInto","sha512_256 rejects non-Uint8Array inputs by throwing TypeError","sha512_256 marks hasher instance as destroyed after digest() rejecting subsequent update or digest calls"],"goal":"verify @noble/hashes.sha512_256 in pkg:npm/%40noble/hashes@2.3.0","kind":"HOW","packages":["pkg:npm/%40noble/hashes@2.3.0"],"schemaVersion":1,"symbols":["@noble/hashes.sha512_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.sha512_256"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-noble-hashes-sha512-256",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-noble-hashes-sha512-256",
      "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-sha512-256",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "license": "MIT-0",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "@noble/hashes": "2.3.0"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify @noble/hashes.sha512_256 in pkg:npm/%40noble/hashes@2.3.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/%40noble/hashes@2.3.0"
  ],
  "symbols": [
    "@noble/hashes.sha512_256"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

import { sha512_256 } from '@noble/hashes/sha2.js';

/**
 * Computes the SHA-512/256 digest for a Uint8Array message.
 *
 * @param {Uint8Array} message - Byte array to hash
 * @returns {Uint8Array} 32-byte SHA-512/256 digest
 */
export function hashSha512_256(message) {
  return sha512_256(message);
}

/**
 * Creates an incremental SHA-512/256 hasher instance.
 *
 * @returns {ReturnType<typeof sha512_256.create>} Hasher instance
 */
export function createSha512_256Hasher() {
  return sha512_256.create();
}

export { sha512_256 };
export default sha512_256;

import assert from 'node:assert/strict';
import { sha512_256, hashSha512_256, createSha512_256Hasher } from '../src/index.mjs';

const encoder = new TextEncoder();
const toHex = (arr) => Buffer.from(arr).toString('hex');

// 1. sha512_256 computes a 32-byte (256-bit) digest for Uint8Array message input matching the standard test vector
{
  const input = encoder.encode('abc');
  const digest = hashSha512_256(input);

  assert.equal(digest instanceof Uint8Array, true);
  assert.equal(digest.length, 32);

  const expectedHex = '53048e2681941ef99b2e29b76b4c7dabe4c2d0c634fc6d46e0e2f13107e7af23';
  assert.equal(toHex(digest), expectedHex);
}

// 2. sha512_256 correctly computes the 32-byte SHA-512/256 digest for empty input
{
  const emptyDigest = sha512_256(new Uint8Array(0));
  assert.equal(emptyDigest.length, 32);

  const expectedEmptyHex = 'c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a';
  assert.equal(toHex(emptyDigest), expectedEmptyHex);
}

// 3. sha512_256 supports incremental hashing via create() updating with multiple Uint8Array chunks
{
  const hasher = createSha512_256Hasher();
  hasher.update(encoder.encode('a'));
  hasher.update(encoder.encode('b'));
  hasher.update(encoder.encode('c'));
  const digest = hasher.digest();

  assert.equal(digest.length, 32);
  const expectedHex = '53048e2681941ef99b2e29b76b4c7dabe4c2d0c634fc6d46e0e2f13107e7af23';
  assert.equal(toHex(digest), expectedHex);
}

// 4. sha512_256 hasher instances support clone() preserving intermediate state for independent digest streams
{
  const baseHasher = sha512_256.create();
  baseHasher.update(encoder.encode('a'));

  const branch1 = baseHasher.clone();
  const branch2 = baseHasher.clone();

  branch1.update(encoder.encode('bc'));
  branch2.update(encoder.encode('bc'));

  const digest1 = branch1.digest();
  const digest2 = branch2.digest();

  assert.deepEqual(digest1, digest2);
  const expectedHex = '53048e2681941ef99b2e29b76b4c7dabe4c2d0c634fc6d46e0e2f13107e7af23';
  assert.equal(toHex(digest1), expectedHex);
}

// 5. sha512_256 exposes outputLen of 32 and blockLen of 128 bytes
{
  assert.equal(sha512_256.outputLen, 32);
  assert.equal(sha512_256.blockLen, 128);
}

// 6. sha512_256 supports writing directly into a preallocated Uint8Array output buffer via digestInto
{
  const hasher = sha512_256.create();
  hasher.update(encoder.encode('abc'));

  const outputBuffer = new Uint8Array(32);
  hasher.digestInto(outputBuffer);

  const expectedHex = '53048e2681941ef99b2e29b76b4c7dabe4c2d0c634fc6d46e0e2f13107e7af23';
  assert.equal(toHex(outputBuffer), expectedHex);
}

// 7. sha512_256 rejects non-Uint8Array inputs by throwing TypeError
{
  assert.throws(() => sha512_256('not bytes'), TypeError);
  assert.throws(() => sha512_256(123), TypeError);
  assert.throws(() => sha512_256(null), TypeError);

  const hasher = sha512_256.create();
  assert.throws(() => hasher.update('string chunk'), TypeError);
}

// 8. sha512_256 marks hasher instance as destroyed after digest() rejecting subsequent update or digest calls
{
  const hasher = sha512_256.create();
  hasher.update(encoder.encode('data'));
  hasher.digest();

  assert.throws(() => hasher.update(encoder.encode('more')), /hash was destroyed/);
  assert.throws(() => hasher.digest(), /hash was destroyed/);

  const hasher2 = sha512_256.create();
  hasher2.destroy();
  assert.throws(() => hasher2.update(encoder.encode('data')), /hash was destroyed/);
}

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