ox 1.1.0 → 1.2.0

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

@@ -0,0 +1,220 @@
+import { afterAll, beforeAll, describe, expect, test } from 'vp/test'
+import { kzg as reference } from '../../../test/kzg.js'
+import type * as Bytes from '../../core/Bytes.js'
+import type * as CoreKzg from '../../core/Kzg.js'
+import { mainnet as trustedSetup } from '../../trusted-setups/Setups.js'
+import * as Kzg from '../Kzg.js'
+
+const blob = Uint8Array.from({ length: 131_072 }, (_, index) =>
+  index % 32 === 31 ? index % 251 : 0,
+)
+
+let instance: Kzg.create.ReturnType
+let commitment: Bytes.Bytes
+let cells: readonly Bytes.Bytes[]
+let proofs: readonly Bytes.Bytes[]
+
+beforeAll(async () => {
+  instance = await Kzg.create({ trustedSetup })
+  commitment = instance.blobToKzgCommitment(blob)
+  ;({ cells, proofs } = instance.computeCellsAndKzgProofs(blob))
+}, 120_000)
+
+afterAll(() => {
+  instance.dispose()
+})
+
+describe('create', () => {
+  test('returns the injected Kzg.Kzg boundary', () => {
+    expect(instance satisfies CoreKzg.Kzg).toMatchInlineSnapshot(`
+      {
+        "blobToKzgCommitment": [Function],
+        "computeCells": [Function],
+        "computeCellsAndKzgProofs": [Function],
+        "dispose": [Function],
+        "recoverCellsAndKzgProofs": [Function],
+        "verifyCellKzgProofBatch": [Function],
+      }
+    `)
+  })
+
+  test('compiles concurrently into independently owned instances', async () => {
+    const [first, second] = await Promise.all([
+      Kzg.create({ trustedSetup }),
+      Kzg.create({ trustedSetup }),
+    ])
+
+    first.dispose()
+    expect(() => first.blobToKzgCommitment(blob)).toThrow(Kzg.DisposedError)
+    expect(second.blobToKzgCommitment(blob)).toEqual(commitment)
+    second.dispose()
+    second.dispose()
+    expect(() => second.computeCells(blob)).toThrowErrorMatchingInlineSnapshot(
+      `[Kzg.DisposedError: KZG instance has been disposed.]`,
+    )
+  }, 120_000)
+
+  test('rejects precomputation beyond the memory bound', async () => {
+    await expect(
+      Kzg.create({ precompute: 9, trustedSetup }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Kzg.InvalidPrecomputeError: \`precompute\` must be an integer from 0 through 8. Got 9.]`,
+    )
+  })
+
+  test('rejects malformed trusted setup points', async () => {
+    await expect(
+      Kzg.create({
+        trustedSetup: {
+          ...trustedSetup,
+          g2_monomial: trustedSetup.g2_monomial.slice(1),
+        },
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Kzg.InvalidTrustedSetupError: \`g2_monomial\` must contain exactly 6240 bytes.]`,
+    )
+  })
+
+  test('rejects invalid trusted setup points', async () => {
+    const g1Lagrange = trustedSetup.g1_lagrange.slice()
+    g1Lagrange.fill(0, 0, 48)
+    await expect(
+      Kzg.create({
+        trustedSetup: {
+          ...trustedSetup,
+          g1_lagrange: g1Lagrange,
+        },
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Kzg.InvalidTrustedSetupError: c-kzg rejected the trusted setup.]`,
+    )
+  }, 120_000)
+})
+
+describe('blobToKzgCommitment', () => {
+  test('conformance: matches the independent reference implementation', () => {
+    expect(commitment).toEqual(reference.blobToKzgCommitment(blob))
+  })
+
+  test('rejects a malformed blob', () => {
+    expect(() =>
+      instance.blobToKzgCommitment(new Uint8Array(31)),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Kzg.InvalidInputError: \`blob\` must contain exactly 131072 bytes.]`,
+    )
+  })
+
+  test('reuses setup and scratch state', () => {
+    for (let i = 0; i < 100; i++)
+      expect(instance.blobToKzgCommitment(blob)).toEqual(commitment)
+  })
+})
+
+describe('computeCells', () => {
+  test('conformance: matches the independent reference implementation', () => {
+    expect(instance.computeCells(blob)).toEqual(reference.computeCells(blob))
+  }, 120_000)
+})
+
+describe('computeCellsAndKzgProofs', () => {
+  test('conformance: matches the independent reference implementation', () => {
+    const expected = reference.computeCellsAndKzgProofs(blob)
+    expect(cells).toEqual(expected.cells)
+    expect(proofs).toEqual(expected.proofs)
+  }, 120_000)
+})
+
+describe('recoverCellsAndKzgProofs', () => {
+  test('conformance: matches the independent reference implementation', () => {
+    const indices = cells.map((_, index) => index).filter((index) => index % 2)
+    const partial = cells.filter((_, index) => index % 2)
+    const expected = reference.recoverCellsAndKzgProofs(indices, partial)
+
+    expect(instance.recoverCellsAndKzgProofs(indices, partial)).toEqual(
+      expected,
+    )
+  }, 120_000)
+
+  test('accepts unordered indices', () => {
+    const indices = cells
+      .map((_, index) => index)
+      .filter((index) => index % 2)
+      .reverse()
+    const partial = indices.map((index) => cells[index]!)
+
+    expect(instance.recoverCellsAndKzgProofs(indices, partial)).toEqual({
+      cells,
+      proofs,
+    })
+  }, 120_000)
+
+  test('rejects duplicate indices', () => {
+    expect(() =>
+      instance.recoverCellsAndKzgProofs(
+        Array.from({ length: 64 }, () => 0),
+        cells.slice(0, 64),
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Kzg.InvalidInputError: \`cellIndices\` must not contain duplicate indices.]`,
+    )
+  })
+})
+
+describe('verifyCellKzgProofBatch', () => {
+  const indices = Array.from({ length: 128 }, (_, index) => index)
+
+  test('conformance: matches the independent reference implementation', () => {
+    const commitments = cells.map(() => commitment)
+    expect(
+      instance.verifyCellKzgProofBatch(commitments, indices, cells, proofs),
+    ).toBe(
+      reference.verifyCellKzgProofBatch(commitments, indices, cells, proofs),
+    )
+  }, 120_000)
+
+  test('returns false for a corrupted cell', () => {
+    const corrupted = cells.map((cell, index) => {
+      if (index !== 7) return cell
+      const value = Uint8Array.from(cell)
+      value[0] = value[0]! ^ 1
+      return value
+    })
+    expect(
+      instance.verifyCellKzgProofBatch(
+        cells.map(() => commitment),
+        indices,
+        corrupted,
+        proofs,
+      ),
+    ).toMatchInlineSnapshot('false')
+  })
+
+  test('rejects mismatched input lengths', () => {
+    expect(() =>
+      instance.verifyCellKzgProofBatch(
+        [commitment],
+        [],
+        [cells[0]!],
+        [proofs[0]!],
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Kzg.InvalidInputError: \`commitments\`, \`cellIndices\`, \`cells\`, and \`proofs\` must have the same non-zero length.]`,
+    )
+  })
+})
+
+test('exports', () => {
+  expect(Object.keys(Kzg)).toMatchInlineSnapshot(`
+    [
+      "create",
+      "DisposedError",
+      "InvalidInputError",
+      "InvalidPrecomputeError",
+      "InvalidTrustedSetupError",
+      "MemoryError",
+      "WasmError",
+      "versionedHashVersion",
+      "from",
+    ]
+  `)
+})

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

@@ -0,0 +1,17 @@
+import { expectTypeOf, test } from 'vp/test'
+import type * as Engine from '../../core/Engine.js'
+import * as core_Mnemonic from '../../core/Mnemonic.js'
+import * as Mnemonic from '../Mnemonic.js'
+
+type Slot = Awaited<ReturnType<typeof Mnemonic.engine>>
+
+test('return type exposes Mnemonic.toSeed', () => {
+  expectTypeOf<Slot['toSeed']>().toEqualTypeOf<
+    NonNullable<Engine.Mnemonic['toSeed']>
+  >()
+})
+
+test('the WASM namespace exposes the public Mnemonic API', () => {
+  expectTypeOf(Mnemonic.toSeed).toEqualTypeOf(core_Mnemonic.toSeed)
+  expectTypeOf<typeof Mnemonic>().not.toHaveProperty('create')
+})

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

@@ -0,0 +1,110 @@
+import { mnemonicToSeedSync } from '@scure/bip39'
+import { describe, expect, test } from 'vp/test'
+import { vectors } from '../../../test/vectors/bip39/index.js'
+import * as Mnemonic from '../Mnemonic.js'
+import * as crypto25519 from '../internal/crypto25519.js'
+import { wasmBase64 } from '../internal/crypto25519.wasm.js'
+import * as internal from '../internal/instantiate.js'
+import * as mnemonic_internal from '../internal/mnemonic.js'
+
+describe('engine', () => {
+  test('vectors: matches the official English BIP-39 vector', async () => {
+    const { toSeed } = await Mnemonic.engine()
+
+    expect(
+      toHex(toSeed(vectors.english.mnemonic, vectors.english.passphrase)),
+    ).toBe(vectors.english.seed)
+  })
+
+  test('vectors: matches the official Japanese Unicode BIP-39 vector', async () => {
+    const { toSeed } = await Mnemonic.engine()
+
+    expect(
+      toHex(toSeed(vectors.japanese.mnemonic, vectors.japanese.passphrase)),
+    ).toBe(vectors.japanese.seed)
+  })
+
+  test('behavior: matches NFKD and every supported word count', async () => {
+    const { toSeed } = await Mnemonic.engine()
+
+    for (const count of [12, 15, 18, 21, 24]) {
+      const composed = Array.from({ length: count }, () => 'café').join(' ')
+      const decomposed = Array.from({ length: count }, () => 'cafe\u0301').join(
+        ' ',
+      )
+      expect(toSeed(composed, 'pássphrase')).toEqual(
+        toSeed(decomposed, 'pa\u0301ssphrase'),
+      )
+      expect(toSeed(composed, 'pássphrase')).toEqual(
+        mnemonicToSeedSync(composed, 'pássphrase'),
+      )
+    }
+  })
+
+  test('behavior: rejects the same malformed phrase shapes', async () => {
+    const { toSeed } = await Mnemonic.engine()
+
+    for (const count of [0, 1, 11, 13, 23, 25])
+      expect(() =>
+        toSeed(Array.from({ length: count }, () => 'word').join(' ')),
+      ).toThrowError('Invalid mnemonic')
+    expect(() => toSeed(1 as never)).toThrowError(
+      'invalid mnemonic type: number',
+    )
+  })
+
+  test('behavior: outputs remain owned and staging memory is cleared', async () => {
+    const { toSeed } = await Mnemonic.engine()
+    const seed = toSeed(vectors.english.mnemonic, vectors.japanese.passphrase)
+    const snapshot = seed.slice()
+    toSeed(Array.from({ length: 24 }, () => 'word').join(' '), 'other')
+    expect(seed).toEqual(snapshot)
+
+    const passwordSize = new TextEncoder().encode(
+      vectors.english.mnemonic.normalize('NFKD'),
+    ).length
+    const saltSize = new TextEncoder().encode(
+      `mnemonic${vectors.japanese.passphrase}`.normalize('NFKD'),
+    ).length
+    const module = await crypto25519.load()
+    expect(
+      module
+        .view()
+        .subarray(
+          module.heapBase,
+          module.heapBase + passwordSize + saltSize + 64,
+        )
+        .every((byte) => byte === 0),
+    ).toBe(true)
+  })
+
+  test('behavior: clears password, salt, and output after a late trap', async () => {
+    const module = await internal.instantiate<crypto25519.Exports>(wasmBase64)
+    const vector = vectors.japanese
+    const exports: crypto25519.Exports = {
+      ...module.exports,
+      mnemonic_to_seed(...parameters) {
+        module.exports.mnemonic_to_seed(...parameters)
+        throw new WebAssembly.RuntimeError('forced late trap')
+      },
+    }
+
+    expect(() =>
+      mnemonic_internal.toSeed(
+        { ...module, exports },
+        vector.mnemonic,
+        vector.passphrase,
+      ),
+    ).toThrow(WebAssembly.RuntimeError)
+    expect(
+      module
+        .view()
+        .subarray(module.heapBase)
+        .every((byte) => byte === 0),
+    ).toBe(true)
+  })
+})
+
+function toHex(value: Uint8Array): string {
+  return Buffer.from(value).toString('hex')
+}

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

@@ -19,3 +19,12 @@ test('memmove compares flat-memory offsets rather than C object pointers', () =>
   expect(body).toContain('if ((size_t)d < (size_t)s)')
   expect(body).not.toMatch(/if\s*\(\s*d\s*<\s*s\s*\)/)
 })
+
+test('KZG artifact loads only when create runs', () => {
+  const source = readFileSync(new URL('../Kzg.ts', import.meta.url), 'utf8')
+
+  expect(source).not.toMatch(
+    /^import(?!\s+type\b)[^\n]*['"]\.\/internal\/kzg\.js['"]/m,
+  )
+  expect(source).toContain("await import('./internal/kzg.js')")
+})

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

@@ -0,0 +1,35 @@
+import { expectTypeOf, test } from 'vp/test'
+import type * as Engine from '../../core/Engine.js'
+import * as core_Secp256k1 from '../../core/Secp256k1.js'
+import * as Secp256k1 from '../Secp256k1.js'
+
+type Slot = Awaited<ReturnType<typeof Secp256k1.engine>>
+
+test('return type exposes only deterministic Secp256k1 primitives', () => {
+  expectTypeOf<Slot['getPublicKey']>().toEqualTypeOf<
+    NonNullable<Engine.Ecdsa['getPublicKey']>
+  >()
+  expectTypeOf<Slot['getSharedSecret']>().toEqualTypeOf<
+    NonNullable<Engine.Ecdsa['getSharedSecret']>
+  >()
+  expectTypeOf<Slot['recoverPublicKey']>().toEqualTypeOf<
+    NonNullable<Engine.Ecdsa['recoverPublicKey']>
+  >()
+  expectTypeOf<Slot['sign']>().toEqualTypeOf<
+    NonNullable<Engine.Ecdsa['sign']>
+  >()
+  expectTypeOf<Slot['verify']>().toEqualTypeOf<
+    NonNullable<Engine.Ecdsa['verify']>
+  >()
+  expectTypeOf<Slot>().not.toHaveProperty('randomSecretKey')
+})
+
+test('the WASM namespace exposes the public Secp256k1 API', () => {
+  expectTypeOf(Secp256k1.getPublicKey).toEqualTypeOf(
+    core_Secp256k1.getPublicKey,
+  )
+  expectTypeOf(Secp256k1.randomPrivateKey).toEqualTypeOf(
+    core_Secp256k1.randomPrivateKey,
+  )
+  expectTypeOf<typeof Secp256k1>().not.toHaveProperty('create')
+})