@pezkuwi/util-crypto 14.0.7 → 14.0.11

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

@@ -0,0 +1,40 @@
+
+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

@@ -0,0 +1,34 @@
+
+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

@@ -0,0 +1,35 @@
+
+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

@@ -0,0 +1,61 @@
+
+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

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

package/build-deno/secp256k1/verify.ts

@@ -0,0 +1,30 @@
+
+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

@@ -0,0 +1,28 @@
+
+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

@@ -0,0 +1,6 @@
+
+/**
+ * @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

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

package/build-deno/signature/verify.ts

@@ -0,0 +1,112 @@
+
+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

@@ -0,0 +1,21 @@
+
+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

@@ -0,0 +1,19 @@
+
+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

@@ -0,0 +1,6 @@
+
+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

@@ -0,0 +1,16 @@
+
+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

@@ -0,0 +1,6 @@
+
+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

@@ -0,0 +1,10 @@
+
+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

@@ -0,0 +1,26 @@
+
+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

@@ -0,0 +1,21 @@
+
+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

@@ -0,0 +1,8 @@
+
+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

@@ -0,0 +1,20 @@
+
+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

@@ -0,0 +1,21 @@
+
+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

@@ -0,0 +1,22 @@
+
+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

@@ -0,0 +1,23 @@
+
+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

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

package/build-deno/test/performance.ts

@@ -0,0 +1,15 @@
+
+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

@@ -0,0 +1,31 @@
+
+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;
+}