@pezkuwi/wasm-crypto 7.5.9 → 7.5.11

package/test/all/bip39.js

@@ -1,86 +0,0 @@
-// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/* global it */
-
-import { assert, u8aToHex } from '@pezkuwi/util';
-
-/**
- * @param {*} wasm
- */
-export function bip39Generate (wasm) {
-  it('generates a bip39 phrase', () => {
-    const res = wasm.bip39Generate(21);
-
-    // console.log('\tPHR', res);
-
-    assert(res.split(' ').length === 21, 'ERROR: Invalid bip39 Phase length');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function bip39GenerateSubsequent (wasm) {
-  it('generates different subsequent mnemonics', () => {
-    const val1 = wasm.bip39Generate(24);
-    const val2 = wasm.bip39Generate(24);
-
-    // console.log('\tVL1', val1);
-    // console.log('\tVL2', val2);
-
-    assert(val1 !== val2, 'ERROR: Subsequent mnemonics are the same');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function bip39Validate (wasm) {
-  it('validates a created mnemonic', () => {
-    const res = wasm.bip39Validate(wasm.bip39Generate(12));
-
-    // console.log('\tVAL', res);
-
-    assert(res, 'ERROR: Invalid bip39 validation');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function bip39ToEntropy (wasm) {
-  it('creates correct entropy for a known mnemonic', () => {
-    const res = u8aToHex(wasm.bip39ToEntropy('legal winner thank year wave sausage worth useful legal winner thank yellow'));
-
-    // console.log('\tENT', res);
-
-    assert(res === '0x7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f', 'ERROR: Invalid bip39 entropy');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function bip39ToMiniSecret (wasm) {
-  it('creates the correct minisecret from a mnemonic', () => {
-    const res = u8aToHex(wasm.bip39ToMiniSecret('legal winner thank year wave sausage worth useful legal winner thank yellow', 'Bizinikiwi'));
-
-    // console.log('\tMIN', res);
-
-    assert(res === '0x4313249608fe8ac10fd5886c92c4579007272cb77c21551ee5b8d60b78041685', 'ERROR: Invalid bip39 mini secret');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function bip39ToSeed (wasm) {
-  it('creates the correct seed for a mnemonic', () => {
-    const res = u8aToHex(wasm.bip39ToSeed('seed sock milk update focus rotate barely fade car face mechanic mercy', ''));
-
-    // console.log('\tSEE', res);
-
-    assert(res === '0x3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a027', 'ERROR: Invalid bip39 mini secret');
-  });
-}

package/test/all/ed25519.js

@@ -1,84 +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(32), pair.slice(0, 32)];
-}
-
-/**
- * @internal
- * @param {*} wasm
- */
-function randomPair (wasm) {
-  return extractKeys(wasm.ed25519KeypairFromSeed(crypto.randomBytes(32)));
-}
-
-/**
- * @param {*} wasm
- */
-export function ed25519PairFromSeed (wasm) {
-  it('creates a known pair from a known seed', () => {
-    const [pair, pk, sk] = extractKeys(wasm.ed25519KeypairFromSeed(stringToU8a('12345678901234567890123456789012')));
-
-    // console.log('\tSEC', u8aToHex(sk));
-    // console.log('\tPUB', u8aToHex(pk));
-
-    assert(u8aToHex(sk) === '0x3132333435363738393031323334353637383930313233343536373839303132', 'Secretkey does not match');
-    assert(u8aToHex(pk) === '0x2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee', 'Public key does not match');
-    assert(u8aToHex(pair) === '0x31323334353637383930313233343536373839303132333435363738393031322f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee', 'ERROR: pairFromSeed() does not match');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function ed25519SignAndVerify (wasm) {
-  it('signs and verifies', () => {
-    const [, pk, sk] = randomPair(wasm);
-    const signature = wasm.ed25519Sign(pk, sk, stringToU8a('this is a message'));
-    const isValid = wasm.ed25519Verify(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 ed25519VerifyExisting (wasm) {
-  it('verifies a known signature', () => {
-    const isValid = wasm.ed25519Verify(hexToU8a('0x90588f3f512496f2dd40571d162e8182860081c74e2085316e7c4396918f07da412ee029978e4dd714057fe973bd9e7d645148bf7b66680d67c93227cde95202'), stringToU8a('this is a message'), hexToU8a('0x2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee'));
-
-    // console.log('\tRES', isValid);
-
-    assert(isValid, 'ERROR: Unable to verify signature');
-  });
-}
-
-/**
- * @param {*} wasm
- */
-export function ed25519Benchmark (wasm) {
-  it('runs a verification benchamark', () => {
-    const MESSAGE = stringToU8a('this is a message');
-
-    for (let i = 0; i < 256; i++) {
-      const [, pk, sk] = randomPair(wasm);
-
-      assert(wasm.ed25519Verify(wasm.ed25519Sign(pk, sk, MESSAGE), MESSAGE, pk), 'ERROR: Unable to verify signature');
-    }
-  });
-}

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');
-  });
-}