@pezkuwi/wasm-crypto 7.5.8 → 7.5.10

package/test/all/hashing.js

@@ -1,138 +0,0 @@
-// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/* global it */
-
-import { assert, stringToU8a, u8aToHex } from '@pezkuwi/util';
-
-/**
- * @param {*} wasm
- */
-export function blake2bHash (wasm) {
-  it('creates a known blake2b hash', () => {
-    const hash = u8aToHex(wasm.blake2b(stringToU8a('abc'), new Uint8Array(), 64));
-
-    // console.log('\tRES', hash);
-
-    assert(hash === '0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923', 'ERROR: blake2bHash does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function hmacSha256 (wasm) {
-  it('creates a known hmacSha256', () => {
-    const hash = u8aToHex(wasm.hmacSha256(stringToU8a('secret'), stringToU8a('some message')));
-
-    // console.log('\tRES', hash);
-
-    assert(hash === '0xf28a70b41263840e5c059a0a733336e0957efba87902aa8cca11441d4b0c96d7', 'ERROR: hmacSha256 does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function hmacSha512 (wasm) {
-  it('creates a known hmacSha512', () => {
-    const hash = u8aToHex(wasm.hmacSha512(stringToU8a('secret'), stringToU8a('some message')));
-
-    // console.log('\tRES', hash);
-
-    assert(hash === '0x295832e97ed77be75a9fa98029497e4a722c4b9a2f21b39d34f1befa931a39ec520fd24711d6f5c03501384ea66b83066a01a82c57a0460f8cd1f471fcce5841', 'ERROR: hmacSha512 does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function keccak256 (wasm) {
-  it('creates a known keccak256 hash', () => {
-    const hash = u8aToHex(wasm.keccak256(stringToU8a('test value')));
-
-    // console.log('\tRES', hash);
-
-    assert(hash === '0x2d07364b5c231c56ce63d49430e085ea3033c750688ba532b24029124c26ca5e', 'ERROR: keccak256 does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function keccak512 (wasm) {
-  it('creates a known keccak512 hash', () => {
-    const hash = u8aToHex(wasm.keccak512(stringToU8a('test')));
-
-    // console.log('\tRES', hash);
-
-    assert(hash === '0x1e2e9fc2002b002d75198b7503210c05a1baac4560916a3c6d93bcce3a50d7f00fd395bf1647b9abb8d1afcc9c76c289b0c9383ba386a956da4b38934417789e', 'ERROR: keccak512 does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function pbkdf2Hash (wasm) {
-  it('creates a known pbkdf2 hash', () => {
-    const hash = u8aToHex(wasm.pbkdf2(stringToU8a('hello world'), stringToU8a('this is a salt'), 2048));
-
-    // console.log('\tRES', hash);
-
-    assert(hash === '0x5fcbe04f05300a3ecc5c35d18ea0b78f3f6853d2ae5f3fca374f69a7d1f78b5def5c60dae1a568026c7492511e0c53521e8bb6e03a650e1263265fee92722270', 'ERROR: pbkdf2Hash does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function scryptHash (wasm) {
-  it('creates a known scrypt hash', () => {
-    const hash = u8aToHex(wasm.scrypt(stringToU8a('password'), stringToU8a('salt'), 14, 8, 1));
-
-    // console.log('\tRES', hash);
-
-    assert(hash === '0x745731af4484f323968969eda289aeee005b5903ac561e64a5aca121797bf7734ef9fd58422e2e22183bcacba9ec87ba0c83b7a2e788f03ce0da06463433cda6', 'ERROR: scryptHash does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sha256Hash (wasm) {
-  it('creates a known sha256 hash', () => {
-    const hash = u8aToHex(wasm.sha256(stringToU8a('hello world')));
-
-    // console.log('\tRES', hash);
-
-    assert(hash === '0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9', 'ERROR: sha256Hash does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sha512Hash (wasm) {
-  it('creates a known sha512 hash', () => {
-    const hash = u8aToHex(wasm.sha512(stringToU8a('hello world')));
-
-    // console.log('\tRES', hash);
-
-    assert(hash === '0x309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f', 'ERROR: sha512Hash does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function twoxHash (wasm) {
-  it('creates a known twox hash', () => {
-    const hash64 = u8aToHex(wasm.twox(stringToU8a('abc'), 1));
-    const hash256 = u8aToHex(wasm.twox(stringToU8a('abc'), 4));
-
-    // console.log('\t64 ', hash64);
-    // console.log('\t256', hash256);
-
-    assert(hash64 === '0x990977adf52cbc44' && hash256 === '0x990977adf52cbc440889329981caa9bef7da5770b2b8a05303b75d95360dd62b', 'ERROR: twoxHash does not match');
-  });
-}

package/test/all/index.js

@@ -1,126 +0,0 @@
-// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/* global describe */
-
-import { assert } from '@pezkuwi/util';
-
-import * as bip39 from './bip39.js';
-import * as ed25519 from './ed25519.js';
-import * as hashing from './hashing.js';
-import * as secp256k1 from './secp256k1.js';
-import * as sr25519 from './sr25519.js';
-import * as vrf from './vrf.js';
-
-export const tests = {
-  // We place secp256k1 first, this allows the interaction with it in the
-  // hashing (specifically scrypt) test not be an issue (ASM.js only)
-  // https://github.com/pezkuwichain/pezkuwi-wasm/issues/307
-  secp256k1,
-  // eslint-disable-next-line sort-keys
-  bip39,
-  ed25519,
-  hashing,
-  sr25519,
-  vrf
-};
-
-/**
- * @param {string} name
- * @param {*} wasm
- */
-export async function initRun (name, wasm) {
-  const result = await wasm.waitReady();
-
-  console.log(`*** waitReady()=${result} for ${wasm.bridge.type}`);
-
-  assert(name.toLowerCase() === wasm.bridge.type, `Incorrect environment launched, expected ${name.toLowerCase()}, found ${wasm.bridge.type}`);
-
-  return result;
-}
-
-/**
- * @param {string} name
- * @param {*} wasm
- */
-export function runAll (name, wasm) {
-  /** @type {string[]} */
-  const failed = [];
-  let count = 0;
-
-  Object
-    .entries(tests)
-    .forEach(([describeName, tests]) => {
-      describe(describeName, () => {
-        Object
-          .entries(tests)
-          .forEach(([name, test]) => {
-            const timerId = `\t${name}`;
-
-            count++;
-
-            try {
-              console.time(timerId);
-              console.log();
-
-              test(wasm);
-
-              console.timeEnd(timerId);
-            } catch (error) {
-              console.error();
-              console.error(error);
-
-              failed.push(name);
-            }
-          });
-      });
-    });
-
-  if (failed.length) {
-    throw new Error(`\n*** ${name}: FAILED: ${failed.length} of ${count}: ${failed.join(', ')}`);
-  }
-}
-
-/**
- * @param {string} type
- * @param {*} wasm
- */
-export function runUnassisted (type, wasm) {
-  console.log(`\n*** ${type}: Running tests`);
-
-  // For these we are pass-through describe and it handlers
-  // @ts-expect-error We are hacking this, so expect TS to be unhappy...
-  globalThis.describe = (name, fn) => {
-    console.log('\n', name);
-
-    // We expect this to be handled top-level, in the test itself
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    fn();
-  };
-
-  // @ts-expect-error We are hacking this, so expect TS to be unhappy...
-  globalThis.it = (name, fn) => {
-    console.log(`\t${name}`);
-
-    // We expect this to be handled top-level, in the test itself
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    fn();
-  };
-
-  console.time(type);
-
-  initRun(type, wasm)
-    .then(() => {
-      runAll(type, wasm);
-      console.log(`\n*** ${type}: All passed`);
-      console.timeEnd(type);
-      console.log();
-      process.exit(0);
-    })
-    .catch((error) => {
-      console.error(`\n*** ${type}: FAILED:`, error.message, '\n');
-      console.timeEnd(type);
-      console.log();
-      process.exit(-1);
-    });
-}

package/test/all/secp256k1.js

@@ -1,105 +0,0 @@
-// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/* global it */
-
-import { assert, hexToU8a, u8aToHex } from '@pezkuwi/util';
-
-/**
- * @param {*} wasm
- */
-export function secp256k1Compress (wasm) {
-  it('compresses a known publicKey', () => {
-    const pubkey = '0x04b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb1307763fe926c273235fd979a134076d00fd1683cbd35868cb485d4a3a640e52184af';
-    const result = u8aToHex(wasm.secp256k1Compress(hexToU8a(pubkey)));
-
-    // console.log('\tRES', result);
-
-    assert(result === '0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077', 'ERROR: secp256k1Compress does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function secp256k1Expand (wasm) {
-  it('expands a known compressed key', () => {
-    const pubkey = '0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077';
-    const result = u8aToHex(wasm.secp256k1Expand(hexToU8a(pubkey)));
-
-    // console.log('\tRES', result);
-
-    assert(result === '0x04b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb1307763fe926c273235fd979a134076d00fd1683cbd35868cb485d4a3a640e52184af', 'ERROR: secp256k1Expand does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function secp256k1FromSeed1 (wasm) {
-  it('creates a known pair from seed (1)', () => {
-    const seckey = '0x4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae';
-    const result = u8aToHex(wasm.secp256k1FromSeed(hexToU8a(seckey)));
-
-    // console.log('\tRES', result);
-
-    assert(result === '0x4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae03fd8c74f795ced92064b86191cb2772b1e3a0947740aa0a5a6e379592471fd85b', 'ERROR: secp256k1FromSeed does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function secp256k1FromSeed2 (wasm) {
-  it('creates a known pair from seed (2)', () => {
-    // https://github.com/pezkuwichain/pezkuwi-wasm/issues/307
-    const seckey = new Uint8Array([
-      203, 109, 249, 222, 30, 252, 167, 163, 153, 138, 142,
-      173, 78, 2, 21, 157, 95, 169, 156, 62, 13, 79,
-      214, 67, 38, 103, 57, 11, 180, 114, 104, 84
-    ]);
-    const expected = u8aToHex(new Uint8Array([
-      203, 109, 249, 222, 30, 252, 167, 163, 153, 138, 142,
-      173, 78, 2, 21, 157, 95, 169, 156, 62, 13, 79,
-      214, 67, 38, 103, 57, 11, 180, 114, 104, 84, 2,
-      10, 16, 145, 52, 31, 229, 102, 75, 250, 23, 130,
-      213, 224, 71, 121, 104, 144, 104, 201, 22, 176, 76,
-      179, 101, 236, 49, 83, 117, 86, 132, 217, 161
-    ]));
-    const result = u8aToHex(wasm.secp256k1FromSeed(seckey));
-
-    // console.log('\tRES', result);
-
-    assert(result === expected, 'ERROR: secp256k1FromSeed does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function secp256k1Recover (wasm) {
-  it('recovers a publicKey from signature', () => {
-    const sig = '0x7505f2880114da51b3f5d535f8687953c0ab9af4ab81e592eaebebf53b728d2b6dfd9b5bcd70fee412b1f31360e7c2774009305cb84fc50c1d0ff8034dfa5fff';
-    const msg = '0xa30b64ce1eedf409c8afb801d72c05234e64849ea538c15dd3c8cf4ffcf166c9';
-    const result = u8aToHex(wasm.secp256k1Recover(hexToU8a(msg), hexToU8a(sig), 0));
-
-    // console.log('\tRES', result);
-
-    assert(result === '0x028d13da15a02f3a70677339d51b14177ee9b49657662b35e56a9d9dee17db1d30', 'ERROR: secp256k1Recover does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function secp256k1Sign (wasm) {
-  it('creates a known signature', () => {
-    const sec = '0x4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae';
-    const msg = '0x68c731589a583d08b70861683b59ce3dd56284cb2f0da5b6cd83e6641dac3aab';
-    const result = u8aToHex(wasm.secp256k1Sign(hexToU8a(msg), hexToU8a(sec)));
-
-    // console.log('\tRES', result);
-
-    assert(result === '0xdf92f73d9f060cefacf187b5414491cb992998ace017fa48839b5cda3e264ba83b105adec9e9872647a7d8bb28855b45e22805aea3d097953cbb1391f671d13e01', 'ERROR: secp256k1Sign does not match');
-  });
-}

package/test/all/sr25519.js

@@ -1,211 +0,0 @@
-// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/* global it */
-
-import crypto from 'crypto';
-
-import { assert, hexToU8a, stringToU8a, u8aToHex } from '@pezkuwi/util';
-
-/**
- * @internal
- * @param {*} pair
- */
-function extractKeys (pair) {
-  return [pair, pair.slice(64), pair.slice(0, 64)];
-}
-
-/**
- * @internal
- * @param {*} wasm
- */
-function randomPair (wasm) {
-  return extractKeys(wasm.sr25519KeypairFromSeed(crypto.randomBytes(32)));
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519PairFromSeed (wasm) {
-  it('creates a known pair from a known seed', () => {
-    const pair = wasm.sr25519KeypairFromSeed(stringToU8a('12345678901234567890123456789012'));
-
-    // console.log('\tSEC', u8aToHex(pair.slice(0, 64)));
-    // console.log('\tPUB', u8aToHex(pair.slice(64)));
-
-    assert(u8aToHex(pair) === '0xf0106660c3dda23f16daa9ac5b811b963077f5bc0af89f85804f0de8e424f050f98d66f39442506ff947fd911f18c7a7a5da639a63e8d3b4e233f74143d951c1741c08a06f41c596608f6774259bd9043304adfa5d3eea62760bd9be97634d63', 'ERROR: pairFromSeed() does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519DevFromSeed (wasm) {
-  it('creates a known development pair', () => {
-    const pair = wasm.sr25519KeypairFromSeed(hexToU8a('0xfac7959dbfe72f052e5a0c3c8d6530f202b02fd8f9f5ca3580ec8deb7797479e'));
-
-    // console.log('\tSEC', u8aToHex(pair.slice(0, 64)));
-    // console.log('\tPUB', u8aToHex(pair.slice(64)));
-
-    assert(u8aToHex(pair) === '0x28b0ae221c6bb06856b287f60d7ea0d98552ea5a16db16956849aa371db3eb51fd190cce74df356432b410bd64682309d6dedb27c76845daf388557cbac3ca3446ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a', 'ERROR: devFromSeed() does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519VerifyExisting (wasm) {
-  it('verifies a known signature', () => {
-    const PK = hexToU8a('0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d');
-    const MESSAGE = stringToU8a('I hereby verify that I control 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY');
-    const SIGNATURE = hexToU8a('0xb83881d3bd7302981ee1c504fe5b7b394682927131fc0846fd616bb40fa14d02640fd2aca785b4cb57904765c2e4e75f59a7dd30154c209964369912091f6981');
-
-    const isValid = wasm.sr25519Verify(SIGNATURE, MESSAGE, PK);
-
-    // console.log('\tRES', isValid);
-
-    assert(isValid, 'ERROR: Unable to verify signature');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519SignDeterministic (wasm) {
-  it('creates non-deterministic signatures', () => {
-    const [, pk, sk] = randomPair(wasm);
-    const sig1 = u8aToHex(wasm.sr25519Sign(pk, sk, stringToU8a('this is a message')));
-    const sig2 = u8aToHex(wasm.sr25519Sign(pk, sk, stringToU8a('this is a message')));
-
-    // console.log('\tSG1', sig1);
-    // console.log('\tSG2', sig2);
-
-    assert(sig1 !== sig2, 'ERROR: Signatures are deterministic');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519SignAndVerify (wasm) {
-  it('verifies a created signature', () => {
-    const [, pk, sk] = randomPair(wasm);
-    const signature = wasm.sr25519Sign(pk, sk, stringToU8a('this is a message'));
-    const isValid = wasm.sr25519Verify(signature, stringToU8a('this is a message'), pk);
-
-    // console.log('\tSIG', u8aToHex(signature));
-    // console.log('\tRES', isValid);
-
-    assert(isValid, 'ERROR: Unable to verify signature');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519DeriveHard (wasm) {
-  it('derives using a hard path', () => {
-    const [pair] = randomPair(wasm);
-    const derived = wasm.sr25519DeriveKeypairHard(pair, hexToU8a('0x0c666f6f00000000000000000000000000000000000000000000000000000000'));
-
-    // console.log('\tSEC', u8aToHex(derived.slice(0, 64)));
-    // console.log('\tPUB', u8aToHex(derived.slice(64)));
-
-    assert(derived.length === 96, 'Derived key length mismatch');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519DeriveHardKnown (wasm) {
-  it('derives a known hard key', () => {
-    const derived = wasm.sr25519DeriveKeypairHard(hexToU8a('0x28b0ae221c6bb06856b287f60d7ea0d98552ea5a16db16956849aa371db3eb51fd190cce74df356432b410bd64682309d6dedb27c76845daf388557cbac3ca3446ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a'), hexToU8a('0x14416c6963650000000000000000000000000000000000000000000000000000'));
-    const publicKey = u8aToHex(derived.slice(64));
-
-    // console.log('\tSEC', u8aToHex(derived.slice(0, 64)));
-    // console.log('\tPUB', publicKey);
-
-    assert(publicKey === '0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d', 'Unmatched resulting public keys');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519DeriveSoft (wasm) {
-  it('derives using a soft path', () => {
-    const [pair] = randomPair(wasm);
-    const derived = wasm.sr25519DeriveKeypairSoft(pair, hexToU8a('0x0c666f6f00000000000000000000000000000000000000000000000000000000'));
-
-    // console.log('\tSEC', u8aToHex(derived.slice(0, 64)));
-    // console.log('\tPUB', u8aToHex(derived.slice(64)));
-
-    assert(derived.length === 96, 'Derived key length mismatch');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519DeriveSoftKnown (wasm) {
-  it('derives a known soft key', () => {
-    const derived = wasm.sr25519DeriveKeypairSoft(hexToU8a('0x28b0ae221c6bb06856b287f60d7ea0d98552ea5a16db16956849aa371db3eb51fd190cce74df356432b410bd64682309d6dedb27c76845daf388557cbac3ca3446ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a'), hexToU8a('0x0c666f6f00000000000000000000000000000000000000000000000000000000'));
-    const publicKey = u8aToHex(derived.slice(64));
-
-    // console.log('\tSEC', u8aToHex(derived.slice(0, 64)));
-    // console.log('\tPUB', publicKey);
-
-    assert(publicKey === '0x40b9675df90efa6069ff623b0fdfcf706cd47ca7452a5056c7ad58194d23440a', 'Unmatched resulting public keys');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519DeriveSoftPubkey (wasm) {
-  it('derives a known soft publicKey', () => {
-    const derived = u8aToHex(wasm.sr25519DerivePublicSoft(hexToU8a('0x46ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a'), hexToU8a('0x0c666f6f00000000000000000000000000000000000000000000000000000000')));
-
-    // console.log('\tPUB', derived);
-
-    assert(derived === '0x40b9675df90efa6069ff623b0fdfcf706cd47ca7452a5056c7ad58194d23440a', 'Unmatched resulting public keys');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519KeyAgreement (wasm) {
-  it('allows for agreements', () => {
-    const pair1 = wasm.sr25519KeypairFromSeed(hexToU8a('0x3b44c558f9a8f3dc9690d53088558c1ba2529b677e316c6054d1852595b004af'));
-    const pair2 = wasm.sr25519KeypairFromSeed(hexToU8a('0x923b80f79c6981fe756272128ec236eb510ae016dd20bdccbd77a9416b7ab94e'));
-    const [, pk1, sk1] = extractKeys(pair1);
-    const [, pk2, sk2] = extractKeys(pair2);
-
-    assert(u8aToHex(wasm.sr25519Agree(pk1, sk2)) === '0xfa7b90001b790fe42ff78b8cd86f6cf7a7c0a70b72f6b4c771b5d67536450222', 'Unmatched agreement keys');
-    assert(u8aToHex(wasm.sr25519Agree(pk2, sk1)) === '0xfa7b90001b790fe42ff78b8cd86f6cf7a7c0a70b72f6b4c771b5d67536450222', 'Unmatched agreement keys');
-
-    for (let i = 0; i < 256; i++) {
-      const [, pk1, sk1] = randomPair(wasm);
-      const [, pk2, sk2] = randomPair(wasm);
-
-      assert(u8aToHex(wasm.sr25519Agree(pk1, sk2)) === u8aToHex(wasm.sr25519Agree(pk2, sk1)), 'Unmatched agreement keys');
-    }
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function sr25519Benchmark (wasm) {
-  it('runs a verification benchmark', () => {
-    const MESSAGE = stringToU8a('this is a message');
-
-    for (let i = 0; i < 256; i++) {
-      const [, pk, sk] = randomPair(wasm);
-
-      assert(wasm.sr25519Verify(wasm.sr25519Sign(pk, sk, MESSAGE), MESSAGE, pk), 'ERROR: Unable to verify signature');
-    }
-  });
-}

package/test/all/vrf.js

@@ -1,74 +0,0 @@
-// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/* global it */
-
-import crypto from 'crypto';
-
-import { assert, stringToU8a, u8aToHex } from '@pezkuwi/util';
-
-/**
- * @internal
- * @param {*} pair
- */
-function extractKeys (pair) {
-  return [pair, pair.slice(64), pair.slice(0, 64)];
-}
-
-/**
- * @internal
- * @param {*} wasm
- */
-function randomPair (wasm) {
-  return extractKeys(wasm.sr25519KeypairFromSeed(crypto.randomBytes(32)));
-}
-
-/**
- * @param {*} wasm
- */
-export function vrfSignAndVerifyCompat (wasm) {
-  it('can sign and verify (1)', () => {
-    const [, pk, sk] = randomPair(wasm);
-    const outAndProof = wasm.vrfSign(sk, stringToU8a('my VRF context'), stringToU8a('this is a message'), new Uint8Array());
-    const isValid = wasm.vrfVerify(pk, stringToU8a('my VRF context'), stringToU8a('this is a message'), new Uint8Array(), outAndProof);
-
-    // console.log('\tVRF', u8aToHex(outAndProof));
-    // console.log('\tRES', isValid);
-
-    assert(isValid, 'ERROR: Unable to verify VRF output & proof');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function vrfSignAndVerify (wasm) {
-  it('can sign and verify (2)', () => {
-    const [, pk, sk] = randomPair(wasm);
-    const outAndProof = wasm.vrfSign(sk, stringToU8a('my VRF context'), stringToU8a('this is a message'), stringToU8a('extra param'));
-    const isValid = wasm.vrfVerify(pk, stringToU8a('my VRF context'), stringToU8a('this is a message'), stringToU8a('extra param'), outAndProof);
-
-    // console.log('\tVRF', u8aToHex(outAndProof));
-    // console.log('\tRES', isValid);
-
-    assert(isValid, 'ERROR: Unable to verify VRF extra output & proof');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function vrfSignAndVerifyDeterministic (wasm) {
-  it('has non-deterministic outputs', () => {
-    const [,, sk] = randomPair(wasm);
-    const outAndProof1 = wasm.vrfSign(sk, stringToU8a('my VRF context'), stringToU8a('this is a message'), stringToU8a('extra param'));
-    const outAndProof2 = wasm.vrfSign(sk, stringToU8a('my VRF context'), stringToU8a('this is a message'), stringToU8a('extra param'));
-    const sig1 = u8aToHex(outAndProof1.slice(0, 32));
-    const sig2 = u8aToHex(outAndProof2.slice(0, 32));
-
-    // console.log('\tSG1', sig1);
-    // console.log('\tSG2', sig2);
-
-    assert(sig1 === sig2, 'ERROR: VRF extra outputs are non-deterministic');
-  });
-}

package/test/asm.js

@@ -1,10 +0,0 @@
-// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import '@pezkuwi/wasm-crypto/initOnlyAsm';
-
-import * as wasm from '@pezkuwi/wasm-crypto';
-
-import { runUnassisted } from './all/index.js';
-
-runUnassisted('ASM', wasm);