ox 1.2.0 → 1.3.1

package/src/core/internal/engine.ts

@@ -19,13 +19,47 @@
  */
 
 /**
- * Hash primitives. One-shot, synchronous, bytes in / bytes out.
+ * Mutable hash state.
+ *
+ * `digestInto` consumes the state. `destroy` is idempotent, and no other method
+ * may be called after the state is consumed or destroyed.
+ *
+ * @internal
+ */
+export type HashState = {
+  /** Clones the current state. */
+  clone(): HashState
+  /** Destroys the state. */
+  destroy(): void
+  /**
+   * Finalizes into `output` and consumes the state.
+   *
+   * A short output throws without consuming the state. A longer output keeps
+   * bytes after the digest unchanged.
+   */
+  digestInto(output: Uint8Array): void
+  /** Absorbs a message chunk. */
+  update(input: Uint8Array): void
+}
+
+/**
+ * Hash primitives. Synchronous, bytes in / bytes out.
  *
  * @internal
  */
 export type Hash = {
   /** BLAKE3, 32-byte digest. */
   blake3?: ((input: Uint8Array) => Uint8Array) | undefined
+  /** Creates a BLAKE3 state. */
+  createBlake3?: (() => HashState) | undefined
+  /** Creates an HMAC-SHA256 state. */
+  createHmacSha256?: ((key: Uint8Array) => HashState) | undefined
+  /** Creates a Keccak256 state. */
+  createKeccak256?: (() => HashState) | undefined
+  /** Creates a RIPEMD-160 state. */
+  createRipemd160?: (() => HashState) | undefined
+  /** Creates a SHA-256 state. */
+  createSha256?: (() => HashState) | undefined
   /** HMAC-SHA256. */
   hmacSha256?:
     | ((key: Uint8Array, message: Uint8Array) => Uint8Array)
@@ -331,7 +365,18 @@ export const primitives = {
     'toMontgomerySecret',
     'verify',
   ],
-  Hash: ['blake3', 'hmacSha256', 'keccak256', 'ripemd160', 'sha256'],
+  Hash: [
+    'blake3',
+    'createBlake3',
+    'createHmacSha256',
+    'createKeccak256',
+    'createRipemd160',
+    'createSha256',
+    'hmacSha256',
+    'keccak256',
+    'ripemd160',
+    'sha256',
+  ],
   Keystore: [
     'aesCtrDecrypt',
     'aesCtrEncrypt',

package/src/core/internal/hash.ts

@@ -3,7 +3,13 @@ import { hmac } from '@noble/hashes/hmac.js'
 import { ripemd160 as noble_ripemd160 } from '@noble/hashes/legacy.js'
 import { sha256 as noble_sha256 } from '@noble/hashes/sha2.js'
 import { keccak_256 as noble_keccak256 } from '@noble/hashes/sha3.js'
-import { type Complete, type Hash, overrides } from './engine.js'
+import type { Hash as NobleHash } from '@noble/hashes/utils.js'
+import {
+  type Complete,
+  type Hash,
+  type HashState,
+  overrides,
+} from './engine.js'
 
 /**
  * Resolvers for the `Hash` slot, and ox's defaults for it, backed by
@@ -16,6 +22,21 @@ import { type Complete, type Hash, overrides } from './engine.js'
 
 const blake3Default: Complete<Hash>['blake3'] = (input) => noble_blake3(input)
 
+const createBlake3Default: Complete<Hash>['createBlake3'] = () =>
+  fromNoble(noble_blake3.create())
+
+const createHmacSha256Default: Complete<Hash>['createHmacSha256'] = (key) =>
+  fromNoble(hmac.create(noble_sha256, key))
+
+const createKeccak256Default: Complete<Hash>['createKeccak256'] = () =>
+  fromNoble(noble_keccak256.create())
+
+const createRipemd160Default: Complete<Hash>['createRipemd160'] = () =>
+  fromNoble(noble_ripemd160.create())
+
+const createSha256Default: Complete<Hash>['createSha256'] = () =>
+  fromNoble(noble_sha256.create())
+
 const hmacSha256Default: Complete<Hash>['hmacSha256'] = (key, message) =>
   hmac(noble_sha256, key, message)
 
@@ -31,6 +52,26 @@ const sha256Default: Complete<Hash>['sha256'] = (input) => noble_sha256(input)
 export const blake3: Complete<Hash>['blake3'] = (input) =>
   (overrides.Hash?.blake3 ?? blake3Default)(input)
 
+/** @internal */
+export const createBlake3: Complete<Hash>['createBlake3'] = () =>
+  (overrides.Hash?.createBlake3 ?? createBlake3Default)()
+
+/** @internal */
+export const createHmacSha256: Complete<Hash>['createHmacSha256'] = (key) =>
+  (overrides.Hash?.createHmacSha256 ?? createHmacSha256Default)(key)
+
+/** @internal */
+export const createKeccak256: Complete<Hash>['createKeccak256'] = () =>
+  (overrides.Hash?.createKeccak256 ?? createKeccak256Default)()
+
+/** @internal */
+export const createRipemd160: Complete<Hash>['createRipemd160'] = () =>
+  (overrides.Hash?.createRipemd160 ?? createRipemd160Default)()
+
+/** @internal */
+export const createSha256: Complete<Hash>['createSha256'] = () =>
+  (overrides.Hash?.createSha256 ?? createSha256Default)()
+
 /** @internal */
 export const hmacSha256: Complete<Hash>['hmacSha256'] = (key, message) =>
   (overrides.Hash?.hmacSha256 ?? hmacSha256Default)(key, message)
@@ -46,3 +87,14 @@ export const ripemd160: Complete<Hash>['ripemd160'] = (input) =>
 /** @internal */
 export const sha256: Complete<Hash>['sha256'] = (input) =>
   (overrides.Hash?.sha256 ?? sha256Default)(input)
+
+function fromNoble<hash extends NobleHash<hash>>(hash: hash): HashState {
+  return {
+    clone: () => fromNoble(hash.clone()),
+    destroy: () => hash.destroy(),
+    digestInto: (output) => hash.digestInto(output),
+    update: (input) => {
+      hash.update(input)
+    },
+  }
+}

package/src/index.ts

@@ -3708,17 +3708,19 @@ export * as ValidatorData from './core/ValidatorData.js'
 export * as Value from './core/Value.js'
 
 /**
- * Utility functions for [NIST P256](https://csrc.nist.gov/csrc/media/events/workshop-on-elliptic-curve-cryptography-standards/documents/papers/session6-adalier-mehmet.pdf) ECDSA cryptography using the [Web Authentication API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API)
+ * Utilities for WebAuthn credentials, credential-bound PRFs, and
+ * [NIST P256](https://csrc.nist.gov/csrc/media/events/workshop-on-elliptic-curve-cryptography-standards/documents/papers/session6-adalier-mehmet.pdf)
+ * signatures.
  *
  * @example
  * ### Creating Credentials
  *
- * Credentials can be created using {@link ox#WebAuthnP256.(createCredential:function)}:
+ * Credentials can be created using {@link ox#WebAuthn.(createCredential:function)}:
  *
  * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * }) // [!code focus]
  * // @log: {
@@ -3727,7 +3729,7 @@ export * as Value from './core/Value.js'
  * // @log:   raw: PublicKeyCredential {},
  * // @log: }
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   credentialId: credential.id,
  *   challenge: '0xdeadbeef'
  * })
@@ -3736,16 +3738,16 @@ export * as Value from './core/Value.js'
  * @example
  * ### Signing Payloads
  *
- * Payloads can be signed using {@link ox#WebAuthnP256.(sign:function)}:
+ * Payloads can be signed using {@link ox#WebAuthn.(sign:function)}:
  *
  * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * })
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   // [!code focus]
  *   credentialId: credential.id, // [!code focus]
  *   challenge: '0xdeadbeef' // [!code focus]
@@ -3765,21 +3767,21 @@ export * as Value from './core/Value.js'
  * @example
  * ### Verifying Signatures
  *
- * Signatures can be verified using {@link ox#WebAuthnP256.(verify:function)}:
+ * Signatures can be verified using {@link ox#WebAuthn.(verify:function)}:
  *
  * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * })
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   credentialId: credential.id,
  *   challenge: '0xdeadbeef'
  * })
  *
- * const result = await WebAuthnP256.verify({
+ * const result = await WebAuthn.verify({
  *   // [!code focus]
  *   metadata, // [!code focus]
  *   challenge: '0xdeadbeef', // [!code focus]
@@ -3791,6 +3793,14 @@ export * as Value from './core/Value.js'
  *
  * @category Crypto
  */
+export * as WebAuthn from './core/WebAuthn.js'
+
+/**
+ * `WebAuthnP256` is deprecated. Use `WebAuthn` instead.
+ *
+ * @deprecated Use `WebAuthn` instead.
+ * @category Crypto
+ */
 export * as WebAuthnP256 from './core/WebAuthnP256.js'
 
 /**

package/src/node/Engine.ts

@@ -24,6 +24,7 @@ export type {
   Eddsa,
   Engine,
   Hash,
+  HashState,
   Keystore,
   Mnemonic,
 } from '../core/Engine.js'

package/src/node/Hash.ts

@@ -1,6 +1,7 @@
 import * as crypto from 'node:crypto'
 import type * as Engine from '../core/Engine.js'
 import type * as Errors from '../core/Errors.js'
+import * as CoreHash from '../core/Hash.js'
 
 export * from '../core/Hash.js'
 
@@ -12,9 +13,11 @@ export * from '../core/Hash.js'
  * which installs every implementation this entrypoint provides. Reach for this
  * to install or hold the `Hash` slot on its own.
  *
- * Node does not provide BLAKE3, and its `sha3-256` is not Ethereum Keccak256, so
- * this engine deliberately omits `blake3` and `keccak256`. Any earlier override
- * remains installed; otherwise Ox uses its default implementation.
+ * Node does not provide BLAKE3, and its `sha3-256` is not Ethereum Keccak256.
+ * Node HMAC states cannot be cloned.
+ *
+ * The engine omits those implementations. Earlier overrides remain installed;
+ * Ox uses its defaults when no override exists.
  *
  * @example
  * ```ts twoslash
@@ -31,6 +34,8 @@ export * from '../core/Hash.js'
  */
 export function engine(): Promise<engine.ReturnType> {
   return Promise.resolve({
+    createRipemd160: () => fromHash(crypto.createHash('ripemd160'), 20),
+    createSha256: () => fromHash(crypto.createHash('sha256'), 32),
     hmacSha256: (key, message) =>
       new Uint8Array(crypto.createHmac('sha256', key).update(message).digest()),
     ripemd160: (input) =>
@@ -42,10 +47,42 @@ export function engine(): Promise<engine.ReturnType> {
 export declare namespace engine {
   /** Every `Hash` primitive this module implements. */
   type ReturnType = {
-    [key in 'hmacSha256' | 'ripemd160' | 'sha256']-?: NonNullable<
-      Engine.Hash[key]
-    >
+    [key in
+      | 'createRipemd160'
+      | 'createSha256'
+      | 'hmacSha256'
+      | 'ripemd160'
+      | 'sha256']-?: NonNullable<Engine.Hash[key]>
   }
 
   type ErrorType = Errors.GlobalErrorType
 }
+
+function fromHash(initial: crypto.Hash, digestSize: number): Engine.HashState {
+  let hash: crypto.Hash | undefined = initial
+
+  const get = () => {
+    if (!hash) throw new CoreHash.HasherDestroyedError()
+    return hash
+  }
+
+  return {
+    clone: () => fromHash(get().copy(), digestSize),
+    destroy: () => {
+      hash = undefined
+    },
+    digestInto: (output) => {
+      const active = get()
+      if (output.length < digestSize)
+        throw new CoreHash.InvalidDigestSizeError({
+          minimum: digestSize,
+          size: output.length,
+        })
+      hash = undefined
+      output.set(active.digest())
+    },
+    update: (input) => {
+      get().update(input)
+    },
+  }
+}

package/src/node/_test/Engine.test-d.ts

@@ -13,6 +13,7 @@ test('install and engine expose the same precise engine', () => {
 })
 
 test('the Node Engine namespace exposes synchronous core operations', () => {
+  expectTypeOf<Engine.HashState>().toEqualTypeOf<CoreEngine.HashState>()
   expectTypeOf(Engine.get).toEqualTypeOf(CoreEngine.get)
   expectTypeOf(Engine.InvalidSlotValueError).toEqualTypeOf(
     CoreEngine.InvalidSlotValueError,

package/src/node/_test/Engine.test.ts

@@ -51,6 +51,8 @@ describe('install', () => {
             "toMontgomerySecret",
           ],
           "Hash": [
+            "createRipemd160",
+            "createSha256",
             "hmacSha256",
             "ripemd160",
             "sha256",

package/src/node/_test/Hash.test-d.ts

@@ -6,6 +6,12 @@ import * as CoreHash from '../../core/Hash.js'
 type Slot = Awaited<ReturnType<typeof NodeHash.engine>>
 
 test('every implemented primitive is present', () => {
+  expectTypeOf<Slot['createRipemd160']>().toEqualTypeOf<
+    () => CoreEngine.HashState
+  >()
+  expectTypeOf<Slot['createSha256']>().toEqualTypeOf<
+    () => CoreEngine.HashState
+  >()
   expectTypeOf<Slot['hmacSha256']>().toEqualTypeOf<
     (key: Uint8Array, message: Uint8Array) => Uint8Array
   >()
@@ -19,6 +25,9 @@ test('every implemented primitive is present', () => {
 
 test('unsupported primitives are absent', () => {
   expectTypeOf<Slot>().not.toHaveProperty('blake3')
+  expectTypeOf<Slot>().not.toHaveProperty('createBlake3')
+  expectTypeOf<Slot>().not.toHaveProperty('createHmacSha256')
+  expectTypeOf<Slot>().not.toHaveProperty('createKeccak256')
   expectTypeOf<Slot>().not.toHaveProperty('keccak256')
 })
 
@@ -28,6 +37,7 @@ test('the result is the raw slot, so `Engine.install` accepts it', () => {
 
 test('the Node namespace exposes the public Hash API', () => {
   expectTypeOf(NodeHash.blake3).toEqualTypeOf(CoreHash.blake3)
+  expectTypeOf(NodeHash.createSha256).toEqualTypeOf(CoreHash.createSha256)
   expectTypeOf(NodeHash.sha256).toEqualTypeOf(CoreHash.sha256)
   expectTypeOf<typeof NodeHash>().not.toHaveProperty('create')
 })

package/src/node/_test/Hash.test.ts

@@ -8,6 +8,8 @@ describe('engine', () => {
 
     expect(Object.keys(engine).sort()).toMatchInlineSnapshot(`
       [
+        "createRipemd160",
+        "createSha256",
         "hmacSha256",
         "ripemd160",
         "sha256",
@@ -98,4 +100,48 @@ describe('engine', () => {
     `)
     expect(sha256(input) === sha256(input)).toMatchInlineSnapshot('false')
   })
+
+  test('behavior: incremental states support chunking and cloning', async () => {
+    const { createRipemd160, createSha256 } = await Hash.engine()
+
+    for (const [create, digest, size] of [
+      [createRipemd160, CoreHash.ripemd160, 20],
+      [createSha256, CoreHash.sha256, 32],
+    ] as const) {
+      const first = create()
+      first.update(Uint8Array.of(0xde, 0xad))
+      const second = first.clone()
+      first.update(Uint8Array.of(0xbe, 0xef))
+      second.update(Uint8Array.of(0xca, 0xfe))
+
+      const firstOutput = new Uint8Array(size)
+      const secondOutput = new Uint8Array(size)
+      first.digestInto(firstOutput)
+      second.digestInto(secondOutput)
+
+      expect(firstOutput).toEqual(digest('0xdeadbeef', { as: 'Bytes' }))
+      expect(secondOutput).toEqual(digest('0xdeadcafe', { as: 'Bytes' }))
+    }
+  })
+
+  test('behavior: incremental states enforce lifecycle and output bounds', async () => {
+    const { createSha256 } = await Hash.engine()
+    const hash = createSha256()
+    hash.update(Uint8Array.of(0xde, 0xad))
+
+    expect(() => hash.digestInto(new Uint8Array(31))).toThrowError(
+      Hash.InvalidDigestSizeError,
+    )
+
+    const output = new Uint8Array(34).fill(0xff)
+    hash.digestInto(output)
+    expect(output.slice(32)).toEqual(Uint8Array.of(0xff, 0xff))
+    expect(() => hash.update(new Uint8Array())).toThrowError(
+      Hash.HasherDestroyedError,
+    )
+    expect(() => {
+      hash.destroy()
+      hash.destroy()
+    }).not.toThrow()
+  })
 })

package/src/tempo/AuthorizationTempo.ts

@@ -219,13 +219,13 @@ export type TupleListSigned = TupleList<true>
  *
  * ```ts twoslash
  * // @noErrors
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  * import {
  *   AuthorizationTempo,
  *   SignatureEnvelope
  * } from 'ox/tempo'
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * })
  *
@@ -235,7 +235,7 @@ export type TupleListSigned = TupleList<true>
  *   nonce: 40n
  * })
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   challenge:
  *     AuthorizationTempo.getSignPayload(authorization),
  *   credentialId: credential.id
@@ -657,13 +657,13 @@ export declare namespace fromTupleList {
  *
  * ```ts twoslash
  * // @noErrors
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  * import {
  *   AuthorizationTempo,
  *   SignatureEnvelope
  * } from 'ox/tempo'
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * })
  *
@@ -676,7 +676,7 @@ export declare namespace fromTupleList {
  * const challenge =
  *   AuthorizationTempo.getSignPayload(authorization) // [!code focus]
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   challenge,
  *   credentialId: credential.id
  * })

package/src/tempo/KeyAuthorization.ts

@@ -366,12 +366,7 @@ export type TokenLimit<bigintType = bigint, numberType = number> = {
  *
  * ```ts twoslash
  * // @noErrors
- * import {
- *   Address,
- *   Value,
- *   WebCryptoP256,
- *   WebAuthnP256
- * } from 'ox'
+ * import { Address, Value, WebCryptoP256, WebAuthn } from 'ox'
  * import {
  *   KeyAuthorization,
  *   SignatureEnvelope
@@ -393,11 +388,11 @@ export type TokenLimit<bigintType = bigint, numberType = number> = {
  *   ]
  * })
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * })
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   challenge: KeyAuthorization.getSignPayload(authorization),
  *   credentialId: credential.id
  * })

package/src/tempo/SignatureEnvelope.ts

@@ -814,7 +814,7 @@ function deserialize_(
  *
  * Accepts either a serialized hex string or an existing signature envelope object.
  * Use this to wrap raw signatures from {@link ox#Secp256k1.(sign:function)}, {@link ox#P256.(sign:function)},
- * {@link ox#WebCryptoP256.(sign:function)}, or {@link ox#WebAuthnP256.(sign:function)} into the envelope format
+ * {@link ox#WebCryptoP256.(sign:function)}, or {@link ox#WebAuthn.(sign:function)} into the envelope format
  * required by Tempo transactions.
  *
  * [Signature Types](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#signature-types)
@@ -893,14 +893,14 @@ function deserialize_(
  *
  * ```ts twoslash
  * // @noErrors
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  * import { SignatureEnvelope } from 'ox/tempo'
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * })
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   challenge: '0xdeadbeef',
  *   credentialId: credential.id
  * })
@@ -1819,18 +1819,18 @@ export declare namespace validate {
  * ```
  *
  * @example
- * ### WebAuthnP256
+ * ### WebAuthn
  *
  * ```ts twoslash
  * import { SignatureEnvelope } from 'ox/tempo'
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * })
  * const payload = '0xdeadbeef'
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   challenge: payload,
  *   credentialId: credential.id
  * })

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.2.0'
+export const version = '1.3.1'

package/src/wasm/Engine.ts

@@ -24,6 +24,7 @@ export type {
   Eddsa,
   Engine,
   Hash,
+  HashState,
   Keystore,
   Mnemonic,
 } from '../core/Engine.js'

package/src/wasm/Hash.ts

@@ -65,6 +65,11 @@ export async function engine(): Promise<engine.ReturnType> {
 
     return {
       blake3: (input) => blake3.hash(blake3Module, input),
+      createBlake3: () => blake3.create(blake3Module),
+      createHmacSha256: (key) => hash.createHmacSha256(module, key),
+      createKeccak256: () => hashes.create(module, 'keccak256'),
+      createRipemd160: () => hashes.create(module, 'ripemd160'),
+      createSha256: () => hashes.create(module, 'sha256'),
       hmacSha256: (key, message) => hash.hmacSha256(module, key, message),
       keccak256: (input) => call('keccak256', input),
       ripemd160: (input) => call('ripemd160', input),
@@ -78,6 +83,11 @@ export declare namespace engine {
   type ReturnType = {
     [key in
       | 'blake3'
+      | 'createBlake3'
+      | 'createHmacSha256'
+      | 'createKeccak256'
+      | 'createRipemd160'
+      | 'createSha256'
       | 'hmacSha256'
       | 'keccak256'
       | 'ripemd160'

package/src/wasm/_test/Engine.test-d.ts

@@ -14,6 +14,7 @@ test('install and engine expose the same precise engine', () => {
 })
 
 test('the WASM Engine namespace exposes synchronous core operations', () => {
+  expectTypeOf<Engine.HashState>().toEqualTypeOf<CoreEngine.HashState>()
   expectTypeOf(Engine.get).toEqualTypeOf(CoreEngine.get)
   expectTypeOf(Engine.InvalidSlotValueError).toEqualTypeOf(
     CoreEngine.InvalidSlotValueError,

package/src/wasm/_test/Engine.test.ts

@@ -75,6 +75,11 @@ describe('install', () => {
           ],
           "Hash": [
             "blake3",
+            "createBlake3",
+            "createHmacSha256",
+            "createKeccak256",
+            "createRipemd160",
+            "createSha256",
             "hmacSha256",
             "keccak256",
             "ripemd160",

package/src/wasm/_test/Hash.browser.test.ts

@@ -27,6 +27,28 @@ describe('engine', () => {
     }
   })
 
+  test('behavior: incremental states clone and cross block boundaries', async () => {
+    const engine = await WasmHash.engine()
+    const prefix = new Uint8Array(137).fill(1)
+    const left = new Uint8Array(1025).fill(2)
+    const right = new Uint8Array(65).fill(3)
+    const state = engine.createBlake3()
+    state.update(prefix.subarray(0, 1))
+    state.update(prefix.subarray(1, 136))
+    state.update(prefix.subarray(136))
+    const clone = state.clone()
+    state.update(left)
+    clone.update(right)
+
+    const output = new Uint8Array(32)
+    state.digestInto(output)
+    expect(output).toEqual(blake3(new Uint8Array([...prefix, ...left])))
+
+    const clonedOutput = new Uint8Array(32)
+    clone.digestInto(clonedOutput)
+    expect(clonedOutput).toEqual(blake3(new Uint8Array([...prefix, ...right])))
+  })
+
   test('behavior: grows memory in a real browser, then hashes a small input', async () => {
     const engine = await WasmHash.engine()
 
@@ -50,6 +72,12 @@ describe('engine', () => {
       expect(Hash.keccak256('0xdeadbeef')).toBe(
         '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1',
       )
+      const state = Hash.createKeccak256()
+      state.update('0xdead')
+      state.update('0xbeef')
+      expect(state.digest()).toBe(
+        '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1',
+      )
     } finally {
       Engine.reset()
     }