@pezkuwi/util-crypto 14.0.6 → 14.0.7

package/build-deno/secp256k1/pair/fromSeed.ts

@@ -1,40 +0,0 @@
-
-import type { Keypair } from '../../types.ts';
-
-import { secp256k1 } from 'https://esm.sh/@noble/curves@1.3.0/secp256k1.js';
-
-import { hasBigInt, u8aEmpty } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { isReady, secp256k1FromSeed } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-/**
- * @name secp256k1PairFromSeed
- * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
- */
-export function secp256k1PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keypair {
-  if (seed.length !== 32) {
-    throw new Error('Expected valid 32-byte private key as a seed');
-  }
-
-  if (!hasBigInt || (!onlyJs && isReady())) {
-    const full = secp256k1FromSeed(seed);
-    const publicKey = full.slice(32);
-
-    // There is an issue with the secp256k1 when running in an ASM.js environment where
-    // it seems that the lazy static section yields invalid results on the _first_ run.
-    // If this happens, fail outright, we cannot allow invalid return values
-    // https://github.com/polkadot-js/wasm/issues/307
-    if (u8aEmpty(publicKey)) {
-      throw new Error('Invalid publicKey generated from WASM interface');
-    }
-
-    return {
-      publicKey,
-      secretKey: full.slice(0, 32)
-    };
-  }
-
-  return {
-    publicKey: secp256k1.getPublicKey(seed, true),
-    secretKey: seed
-  };
-}

package/build-deno/secp256k1/recover.ts

@@ -1,34 +0,0 @@
-
-import type { HashType } from './types.ts';
-
-import { secp256k1 } from 'https://esm.sh/@noble/curves@1.3.0/secp256k1.js';
-
-import { hasBigInt, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { isReady, secp256k1Recover as wasm } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { secp256k1Compress } from './compress.ts';
-import { secp256k1Expand } from './expand.ts';
-
-/**
- * @name secp256k1Recover
- * @description Recovers a publicKey from the supplied signature
- */
-export function secp256k1Recover (msgHash: string | Uint8Array, signature: string | Uint8Array, recovery: number, hashType: HashType = 'blake2', onlyJs?: boolean): Uint8Array {
-  const sig = u8aToU8a(signature).subarray(0, 64);
-  const msg = u8aToU8a(msgHash);
-  const publicKey = !hasBigInt || (!onlyJs && isReady())
-    ? wasm(msg, sig, recovery)
-    : secp256k1.Signature
-      .fromCompact(sig)
-      .addRecoveryBit(recovery)
-      .recoverPublicKey(msg)
-      .toRawBytes();
-
-  if (!publicKey) {
-    throw new Error('Unable to recover publicKey from signature');
-  }
-
-  return hashType === 'keccak'
-    ? secp256k1Expand(publicKey, onlyJs)
-    : secp256k1Compress(publicKey, onlyJs);
-}

package/build-deno/secp256k1/sign.ts

@@ -1,35 +0,0 @@
-
-import type { Keypair } from '../types.ts';
-import type { HashType } from './types.ts';
-
-import { secp256k1 } from 'https://esm.sh/@noble/curves@1.3.0/secp256k1.js';
-
-import { bnToU8a, hasBigInt, u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { isReady, secp256k1Sign as wasm } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { BN_BE_256_OPTS } from '../bn.ts';
-import { hasher } from './hasher.ts';
-
-/**
- * @name secp256k1Sign
- * @description Returns message signature of `message`, using the supplied pair
- */
-export function secp256k1Sign (message: Uint8Array | string, { secretKey }: Partial<Keypair>, hashType: HashType = 'blake2', onlyJs?: boolean): Uint8Array {
-  if (secretKey?.length !== 32) {
-    throw new Error('Expected valid secp256k1 secretKey, 32-bytes');
-  }
-
-  const data = hasher(hashType, message, onlyJs);
-
-  if (!hasBigInt || (!onlyJs && isReady())) {
-    return wasm(data, secretKey);
-  }
-
-  const signature = secp256k1.sign(data, secretKey, { lowS: true });
-
-  return u8aConcat(
-    bnToU8a(signature.r, BN_BE_256_OPTS),
-    bnToU8a(signature.s, BN_BE_256_OPTS),
-    new Uint8Array([signature.recovery || 0])
-  );
-}

package/build-deno/secp256k1/tweakAdd.ts

@@ -1,61 +0,0 @@
-
-import { _0n, BN, bnToU8a, hasBigInt, isU8a, nToU8a, u8aToBigInt } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { BigInt } from 'https://deno.land/x/pezkuwi/x-bigint/mod.ts';
-
-import { BN_BE_256_OPTS, BN_BE_OPTS } from '../bn.ts';
-
-const N = 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141'.replace(/ /g, '');
-const N_BI = BigInt(`0x${N}`);
-const N_BN = new BN(N, 'hex');
-
-function addBi (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
-  let res = u8aToBigInt(tweak, BN_BE_OPTS);
-
-  if (res >= N_BI) {
-    throw new Error('Tweak parameter is out of range');
-  }
-
-  res += u8aToBigInt(seckey, BN_BE_OPTS);
-
-  if (res >= N_BI) {
-    res -= N_BI;
-  }
-
-  if (res === _0n) {
-    throw new Error('Invalid resulting private key');
-  }
-
-  return nToU8a(res, BN_BE_256_OPTS);
-}
-
-function addBn (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
-  const res = new BN(tweak);
-
-  if (res.cmp(N_BN) >= 0) {
-    throw new Error('Tweak parameter is out of range');
-  }
-
-  res.iadd(new BN(seckey));
-
-  if (res.cmp(N_BN) >= 0) {
-    res.isub(N_BN);
-  }
-
-  if (res.isZero()) {
-    throw new Error('Invalid resulting private key');
-  }
-
-  return bnToU8a(res, BN_BE_256_OPTS);
-}
-
-export function secp256k1PrivateKeyTweakAdd (seckey: Uint8Array, tweak: Uint8Array, onlyBn?: boolean): Uint8Array {
-  if (!isU8a(seckey) || seckey.length !== 32) {
-    throw new Error('Expected seckey to be an Uint8Array with length 32');
-  } else if (!isU8a(tweak) || tweak.length !== 32) {
-    throw new Error('Expected tweak to be an Uint8Array with length 32');
-  }
-
-  return !hasBigInt || onlyBn
-    ? addBn(seckey, tweak)
-    : addBi(seckey, tweak);
-}

package/build-deno/secp256k1/types.ts

@@ -1,2 +0,0 @@
-
-export type HashType = 'blake2' | 'keccak';

package/build-deno/secp256k1/verify.ts

@@ -1,30 +0,0 @@
-
-import type { HashType } from './types.ts';
-
-import { u8aEq, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { hasher } from './hasher.ts';
-import { secp256k1Recover } from './recover.ts';
-
-/**
- * @name secp256k1Verify
- * @description Verifies the signature of `message`, using the supplied pair
- */
-export function secp256k1Verify (msgHash: string | Uint8Array, signature: string | Uint8Array, address: string | Uint8Array, hashType: HashType = 'blake2', onlyJs?: boolean): boolean {
-  const sig = u8aToU8a(signature);
-
-  if (sig.length !== 65) {
-    throw new Error(`Expected signature with 65 bytes, ${sig.length} found instead`);
-  }
-
-  const publicKey = secp256k1Recover(hasher(hashType, msgHash), sig, sig[64], hashType, onlyJs);
-  const signerAddr = hasher(hashType, publicKey, onlyJs);
-  const inputAddr = u8aToU8a(address);
-
-  // for Ethereum (keccak) the last 20 bytes is the address
-  return u8aEq(publicKey, inputAddr) || (
-    hashType === 'keccak'
-      ? u8aEq(signerAddr.slice(-20), inputAddr.slice(-20))
-      : u8aEq(signerAddr, inputAddr)
-  );
-}

package/build-deno/sha/asU8a.ts

@@ -1,28 +0,0 @@
-
-import { sha256 as sha256Js } from 'https://esm.sh/@noble/hashes@1.3.3/sha256.js';
-import { sha512 as sha512Js } from 'https://esm.sh/@noble/hashes@1.3.3/sha512.js';
-
-import { sha256, sha512 } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { createBitHasher, createDualHasher } from '../helpers.ts';
-
-/**
- * @name shaAsU8a
- * @summary Creates a sha Uint8Array from the input.
- */
-export const shaAsU8a = /*#__PURE__*/ createDualHasher(
-  { 256: sha256, 512: sha512 },
-  { 256: sha256Js, 512: sha512Js }
-);
-
-/**
- * @name sha256AsU8a
- * @summary Creates a sha256 Uint8Array from the input.
- */
-export const sha256AsU8a = /*#__PURE__*/ createBitHasher(256, shaAsU8a);
-
-/**
- * @name sha512AsU8a
- * @summary Creates a sha512 Uint8Array from the input.
- */
-export const sha512AsU8a = /*#__PURE__*/ createBitHasher(512, shaAsU8a);

package/build-deno/sha/index.ts

@@ -1,6 +0,0 @@
-
-/**
- * @summary Implements Sha-256/512 hashing functions for a variety of input and outputs
- */
-
-export { sha256AsU8a, sha512AsU8a, shaAsU8a } from './asU8a.ts';

package/build-deno/signature/index.ts

@@ -1,6 +0,0 @@
-
-/**
- * @summary Utilities for working with signatures
- */
-
-export { signatureVerify } from './verify.ts';

package/build-deno/signature/verify.ts

@@ -1,112 +0,0 @@
-
-import type { KeypairType, VerifyResult } from '../types.ts';
-
-import { u8aIsWrapped, u8aToU8a, u8aUnwrapBytes, u8aWrapBytes } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { decodeAddress } from '../address/decode.ts';
-import { ed25519Verify } from '../ed25519/verify.ts';
-import { secp256k1Verify } from '../secp256k1/verify.ts';
-import { sr25519Verify } from '../sr25519/verify.ts';
-
-interface VerifyInput {
-  message: Uint8Array;
-  publicKey: Uint8Array;
-  signature: Uint8Array;
-}
-
-type Verifier = [KeypairType, (message: Uint8Array | string, signature: Uint8Array, publicKey: Uint8Array) => boolean];
-
-type VerifyFn = (result: VerifyResult, input: VerifyInput) => VerifyResult;
-
-const secp256k1VerifyHasher = (hashType: 'blake2' | 'keccak') =>
-  (message: Uint8Array | string, signature: Uint8Array, publicKey: Uint8Array) =>
-    secp256k1Verify(message, signature, publicKey, hashType, true);
-
-const VERIFIERS_ECDSA: Verifier[] = [
-  ['ecdsa', secp256k1VerifyHasher('blake2')],
-  ['ethereum', secp256k1VerifyHasher('keccak')]
-];
-
-const VERIFIERS: Verifier[] = [
-  ['ed25519', ed25519Verify],
-  ['sr25519', sr25519Verify]
-];
-
-function verifyDetect (result: VerifyResult, { message, publicKey, signature }: VerifyInput, verifiers = [...VERIFIERS, ...VERIFIERS_ECDSA]): VerifyResult {
-  result.isValid = verifiers.some(([crypto, verify]): boolean => {
-    try {
-      if (verify(message, signature, publicKey)) {
-        result.crypto = crypto;
-
-        return true;
-      }
-    } catch {
-      // do nothing, result.isValid still set to false
-    }
-
-    return false;
-  });
-
-  return result;
-}
-
-function verifyMultisig (result: VerifyResult, { message, publicKey, signature }: VerifyInput): VerifyResult {
-  if (![0, 1, 2].includes(signature[0]) || ![65, 66].includes(signature.length)) {
-    throw new Error(`Unknown crypto type, expected signature prefix [0..2], found ${signature[0]}`);
-  }
-
-  // If the signature is 66 bytes it must be an ecdsa signature
-  // containing: prefix [1 byte] + signature [65] bytes.
-  // Remove the and then verify
-  if (signature.length === 66) {
-    result = verifyDetect(result, { message, publicKey, signature: signature.subarray(1) }, VERIFIERS_ECDSA);
-  } else {
-    // The signature contains 65 bytes which is either
-    // - A ed25519 or sr25519 signature [1 byte prefix + 64 bytes]
-    // - An ecdsa signature [65 bytes]
-    result = verifyDetect(result, { message, publicKey, signature: signature.subarray(1) }, VERIFIERS);
-
-    if (!result.isValid) {
-      result = verifyDetect(result, { message, publicKey, signature }, VERIFIERS_ECDSA);
-    }
-
-    // If both failed, explicitly set crypto to 'none'
-    if (!result.isValid) {
-      result.crypto = 'none';
-    }
-  }
-
-  return result;
-}
-
-function getVerifyFn (signature: Uint8Array): VerifyFn {
-  return [0, 1, 2].includes(signature[0]) && [65, 66].includes(signature.length)
-    ? verifyMultisig
-    : verifyDetect;
-}
-
-export function signatureVerify (message: string | Uint8Array, signature: string | Uint8Array, addressOrPublicKey: string | Uint8Array): VerifyResult {
-  const signatureU8a = u8aToU8a(signature);
-
-  if (![64, 65, 66].includes(signatureU8a.length)) {
-    throw new Error(`Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
-  }
-
-  const publicKey = decodeAddress(addressOrPublicKey);
-  const input = { message: u8aToU8a(message), publicKey, signature: signatureU8a };
-  const result: VerifyResult = { crypto: 'none', isValid: false, isWrapped: u8aIsWrapped(input.message, true), publicKey };
-  const isWrappedBytes = u8aIsWrapped(input.message, false);
-  const verifyFn = getVerifyFn(signatureU8a);
-
-  verifyFn(result, input);
-
-  if (result.crypto !== 'none' || (result.isWrapped && !isWrappedBytes)) {
-    return result;
-  }
-
-  input.message = isWrappedBytes
-    ? u8aUnwrapBytes(input.message)
-    : u8aWrapBytes(input.message);
-
-  return verifyFn(result, input);
-}

package/build-deno/sr25519/agreement.ts

@@ -1,21 +0,0 @@
-
-import { getSharedSecret } from 'https://esm.sh/@scure/sr25519@0.2.0';
-
-import { u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-/**
- * @name sr25519Agreement
- * @description Key agreement between other's public key and self secret key
- */
-export function sr25519Agreement (secretKey: string | Uint8Array, publicKey: string | Uint8Array): Uint8Array {
-  const secretKeyU8a = u8aToU8a(secretKey);
-  const publicKeyU8a = u8aToU8a(publicKey);
-
-  if (publicKeyU8a.length !== 32) {
-    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
-  } else if (secretKeyU8a.length !== 64) {
-    throw new Error(`Invalid secretKey, received ${secretKeyU8a.length} bytes, expected 64`);
-  }
-
-  return getSharedSecret(secretKeyU8a, publicKeyU8a);
-}

package/build-deno/sr25519/derive.ts

@@ -1,19 +0,0 @@
-
-import type { Keypair } from '../types.ts';
-
-import * as sr25519 from 'https://esm.sh/@scure/sr25519@0.2.0';
-
-import { isU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-export function createDeriveFn (derive: (pair: Uint8Array, cc: Uint8Array) => Uint8Array): (keypair: Keypair, chainCode: Uint8Array) => Keypair {
-  return (keypair: Keypair, chainCode: Uint8Array): Keypair => {
-    if (!isU8a(chainCode) || chainCode.length !== 32) {
-      throw new Error('Invalid chainCode passed to derive');
-    }
-
-    const secretKey = derive(keypair.secretKey, chainCode);
-    const publicKey = sr25519.getPublicKey(secretKey);
-
-    return { publicKey, secretKey };
-  };
-}

package/build-deno/sr25519/deriveHard.ts

@@ -1,6 +0,0 @@
-
-import * as sr25519 from 'https://esm.sh/@scure/sr25519@0.2.0';
-
-import { createDeriveFn } from './derive.ts';
-
-export const sr25519DeriveHard = /*#__PURE__*/ createDeriveFn(sr25519.HDKD.secretHard);

package/build-deno/sr25519/derivePublic.ts

@@ -1,16 +0,0 @@
-
-import * as sr25519 from 'https://esm.sh/@scure/sr25519@0.2.0';
-
-import { isU8a, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-export function sr25519DerivePublic (publicKey: string | Uint8Array, chainCode: Uint8Array): Uint8Array {
-  const publicKeyU8a = u8aToU8a(publicKey);
-
-  if (!isU8a(chainCode) || chainCode.length !== 32) {
-    throw new Error('Invalid chainCode passed to derive');
-  } else if (publicKeyU8a.length !== 32) {
-    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
-  }
-
-  return sr25519.HDKD.publicSoft(publicKeyU8a, chainCode);
-}

package/build-deno/sr25519/deriveSoft.ts

@@ -1,6 +0,0 @@
-
-import * as sr25519 from 'https://esm.sh/@scure/sr25519@0.2.0';
-
-import { createDeriveFn } from './derive.ts';
-
-export const sr25519DeriveSoft = /*#__PURE__*/ createDeriveFn(sr25519.HDKD.secretSoft);

package/build-deno/sr25519/index.ts

@@ -1,10 +0,0 @@
-
-export { sr25519Agreement } from './agreement.ts';
-export { sr25519DeriveHard } from './deriveHard.ts';
-export { sr25519DerivePublic } from './derivePublic.ts';
-export { sr25519DeriveSoft } from './deriveSoft.ts';
-export { sr25519PairFromSeed } from './pair/fromSeed.ts';
-export { sr25519Sign } from './sign.ts';
-export { sr25519Verify } from './verify.ts';
-export { sr25519VrfSign } from './vrfSign.ts';
-export { sr25519VrfVerify } from './vrfVerify.ts';

package/build-deno/sr25519/pair/fromSeed.ts

@@ -1,26 +0,0 @@
-
-import type { Keypair } from '../../types.ts';
-
-import * as sr25519 from 'https://esm.sh/@scure/sr25519@0.2.0';
-
-import { u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-/**
- * @name sr25519PairFromSeed
- * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
- */
-export function sr25519PairFromSeed (seed: string | Uint8Array): Keypair {
-  const seedU8a = u8aToU8a(seed);
-
-  if (seedU8a.length !== 32) {
-    throw new Error(`Expected a seed matching 32 bytes, found ${seedU8a.length}`);
-  }
-
-  const sec = sr25519.secretFromSeed(seedU8a);
-  const pub = sr25519.getPublicKey(sec);
-
-  return {
-    publicKey: pub,
-    secretKey: sec
-  };
-}

package/build-deno/sr25519/pair/fromU8a.ts

@@ -1,21 +0,0 @@
-
-import type { Keypair } from '../../types.ts';
-
-import { u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-const SEC_LEN = 64;
-const PUB_LEN = 32;
-const TOT_LEN = SEC_LEN + PUB_LEN;
-
-export function sr25519PairFromU8a (full: string | Uint8Array): Keypair {
-  const fullU8a = u8aToU8a(full);
-
-  if (fullU8a.length !== TOT_LEN) {
-    throw new Error(`Expected keypair with ${TOT_LEN} bytes, found ${fullU8a.length}`);
-  }
-
-  return {
-    publicKey: fullU8a.slice(SEC_LEN, TOT_LEN),
-    secretKey: fullU8a.slice(0, SEC_LEN)
-  };
-}

package/build-deno/sr25519/pair/toU8a.ts

@@ -1,8 +0,0 @@
-
-import type { Keypair } from '../../types.ts';
-
-import { u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-export function sr25519KeypairToU8a ({ publicKey, secretKey }: Keypair): Uint8Array {
-  return u8aConcat(secretKey, publicKey).slice();
-}

package/build-deno/sr25519/sign.ts

@@ -1,20 +0,0 @@
-
-import type { Keypair } from '../types.ts';
-
-import * as sr25519 from 'https://esm.sh/@scure/sr25519@0.2.0';
-
-import { u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-/**
- * @name sr25519Sign
- * @description Returns message signature of `message`, using the supplied pair
- */
-export function sr25519Sign (message: string | Uint8Array, { publicKey, secretKey }: Partial<Keypair>): Uint8Array {
-  if (publicKey?.length !== 32) {
-    throw new Error('Expected a valid publicKey, 32-bytes');
-  } else if (secretKey?.length !== 64) {
-    throw new Error('Expected a valid secretKey, 64-bytes');
-  }
-
-  return sr25519.sign(secretKey, u8aToU8a(message));
-}

package/build-deno/sr25519/verify.ts

@@ -1,21 +0,0 @@
-
-import * as sr25519 from 'https://esm.sh/@scure/sr25519@0.2.0';
-
-import { u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-/**
- * @name sr25519Verify
- * @description Verifies the signature of `message`, using the supplied pair
- */
-export function sr25519Verify (message: string | Uint8Array, signature: string | Uint8Array, publicKey: string | Uint8Array): boolean {
-  const publicKeyU8a = u8aToU8a(publicKey);
-  const signatureU8a = u8aToU8a(signature);
-
-  if (publicKeyU8a.length !== 32) {
-    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
-  } else if (signatureU8a.length !== 64) {
-    throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
-  }
-
-  return sr25519.verify(u8aToU8a(message), signatureU8a, publicKeyU8a);
-}

package/build-deno/sr25519/vrfSign.ts

@@ -1,22 +0,0 @@
-
-import type { Keypair } from '../types.ts';
-
-import { randomBytes } from 'https://esm.sh/@noble/hashes@1.3.3/utils.js';
-import * as sr25519 from 'https://esm.sh/@scure/sr25519@0.2.0';
-
-import { u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-const EMPTY_U8A = new Uint8Array();
-
-/**
- * @name sr25519VrfSign
- * @description Sign with sr25519 vrf signing (deterministic)
- */
-export function sr25519VrfSign (message: string | Uint8Array, { secretKey }: Partial<Keypair>, context: string | Uint8Array = EMPTY_U8A, extra: string | Uint8Array = EMPTY_U8A): Uint8Array {
-  if (secretKey?.length !== 64) {
-    throw new Error('Invalid secretKey, expected 64-bytes');
-  }
-
-  return sr25519.vrf.sign(u8aToU8a(message), secretKey, u8aToU8a(context), u8aToU8a(extra), randomBytes);
-  // return vrfSign(secretKey, u8aToU8a(context), u8aToU8a(message), u8aToU8a(extra));
-}

package/build-deno/sr25519/vrfVerify.ts

@@ -1,23 +0,0 @@
-
-import * as sr25519 from 'https://esm.sh/@scure/sr25519@0.2.0';
-
-import { u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-const EMPTY_U8A = new Uint8Array();
-
-/**
- * @name sr25519VrfVerify
- * @description Verify with sr25519 vrf verification
- */
-export function sr25519VrfVerify (message: string | Uint8Array, signOutput: string | Uint8Array, publicKey: string | Uint8Array, context: string | Uint8Array = EMPTY_U8A, extra: string | Uint8Array = EMPTY_U8A): boolean {
-  const publicKeyU8a = u8aToU8a(publicKey);
-  const proofU8a = u8aToU8a(signOutput);
-
-  if (publicKeyU8a.length !== 32) {
-    throw new Error('Invalid publicKey, expected 32-bytes');
-  } else if (proofU8a.length !== 96) {
-    throw new Error('Invalid vrfSign output, expected 96 bytes');
-  }
-
-  return sr25519.vrf.verify(u8aToU8a(message), proofU8a, publicKeyU8a, u8aToU8a(context), u8aToU8a(extra));
-}

package/build-deno/test/index.ts

@@ -1,4 +0,0 @@
-
-export { perf, perfCmp } from 'https://deno.land/x/pezkuwi/util/test/index.ts';
-
-export { perfWasm } from './performance.ts';

package/build-deno/test/performance.ts

@@ -1,15 +0,0 @@
-
-import { arrayRange } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { perf, perfCmp } from 'https://deno.land/x/pezkuwi/util/test/index.ts';
-
-import { randomAsU8a } from '../index.ts';
-
-type ExecFn = (input: Uint8Array, onlyJs: boolean) => unknown;
-
-const GENERATED = arrayRange(256).map(() => [randomAsU8a()]);
-
-export function perfWasm (name: string, count: number, exec: ExecFn, inputs = GENERATED): void {
-  perfCmp(name, ['WebAssembly', 'JavaScript'], count, inputs, exec);
-}
-
-export { perf, perfCmp };

package/build-deno/types.ts

@@ -1,31 +0,0 @@
-
-export * from './address/types.ts';
-export * from './json/types.ts';
-
-export interface Keypair {
-  /** The publicKey for this pair */
-  publicKey: Uint8Array;
-  /** The secretKey for this pair */
-  secretKey: Uint8Array;
-}
-
-export interface Seedpair {
-  /** The publicKey for this pair */
-  publicKey: Uint8Array;
-  /** The seed used to construct the pair */
-  seed: Uint8Array;
-}
-
-/** The supported types of pairs */
-export type KeypairType = 'ed25519' | 'sr25519' | 'ecdsa' | 'ethereum';
-
-export interface VerifyResult {
-  /** The detected crypto interface, or 'none' if not detected */
-  crypto: 'none' | KeypairType;
-  /** The validity for this result, false if invalid */
-  isValid: boolean;
-  /** Flag to indicate if the passed data was wrapped in <Bytes>...</Bytes> */
-  isWrapped: boolean;
-  /** The extracted publicKey */
-  publicKey: Uint8Array;
-}