@pezkuwi/util-crypto 14.0.7 → 14.0.11

package/build-deno/nacl/tweetnacl.ts

@@ -0,0 +1,344 @@
+
+/* eslint-disable brace-style,camelcase,comma-spacing,curly,one-var,padding-line-between-statements,space-infix-ops */
+
+
+
+
+
+
+function L32 (x: number, c: number): number { return (x << c) | (x >>> (32 - c)); }
+
+function ld32 (x: Uint8Array, i: number): number {
+  let u = x[i+3] & 0xff;
+  u = (u<<8)|(x[i+2] & 0xff);
+  u = (u<<8)|(x[i+1] & 0xff);
+  return (u<<8)|(x[i+0] & 0xff);
+}
+
+
+function st32 (x: Uint8Array, j: number, u: number): void {
+  for (let i = 0; i < 4; i++) { x[j+i] = u & 255; u >>>= 8; }
+}
+
+
+function vn (x: Uint8Array, xi: number, y: Uint8Array, yi: number, n: number): number {
+  let d = 0;
+  for (let i = 0; i < n; i++) d |= x[xi+i]^y[yi+i];
+  return (1 & ((d - 1) >>> 8)) - 1;
+}
+
+
+
+function core (out: Uint8Array, inp: Uint8Array, k: Uint8Array, c: Uint8Array, h: boolean): void {
+  const w = new Uint32Array(16), x = new Uint32Array(16), y = new Uint32Array(16), t = new Uint32Array(4);
+  let i, j, m;
+
+  for (i = 0; i < 4; i++) {
+    x[5*i] = ld32(c, 4*i);
+    x[1+i] = ld32(k, 4*i);
+    x[6+i] = ld32(inp, 4*i);
+    x[11+i] = ld32(k, 16+4*i);
+  }
+
+  for (i = 0; i < 16; i++) y[i] = x[i];
+
+  for (i = 0; i < 20; i++) {
+    for (j = 0; j < 4; j++) {
+      for (m = 0; m < 4; m++) t[m] = x[(5*j+4*m)%16];
+      t[1] ^= L32((t[0]+t[3])|0, 7);
+      t[2] ^= L32((t[1]+t[0])|0, 9);
+      t[3] ^= L32((t[2]+t[1])|0,13);
+      t[0] ^= L32((t[3]+t[2])|0,18);
+      for (m = 0; m < 4; m++) w[4*j+(j+m)%4] = t[m];
+    }
+    for (m = 0; m < 16; m++) x[m] = w[m];
+  }
+
+  if (h) {
+    for (i = 0; i < 16; i++) x[i] = (x[i] + y[i]) | 0;
+    for (i = 0; i < 4; i++) {
+      x[5*i] = (x[5*i] - ld32(c, 4*i)) | 0;
+      x[6+i] = (x[6+i] - ld32(inp, 4*i)) | 0;
+    }
+    for (i = 0; i < 4; i++) {
+      st32(out,4*i,x[5*i]);
+      st32(out,16+4*i,x[6+i]);
+    }
+  } else {
+    for (i = 0; i < 16; i++) st32(out, 4 * i, (x[i] + y[i]) | 0);
+  }
+}
+
+
+
+const sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
+
+function crypto_stream_salsa20_xor (c: Uint8Array, cpos: number, m: Uint8Array | null, mpos: number, b: number, n: Uint8Array, k: Uint8Array): number {
+  const z = new Uint8Array(16), x = new Uint8Array(64);
+  let u, i;
+  if (!b) return 0;
+  for (i = 0; i < 16; i++) z[i] = 0;
+  for (i = 0; i < 8; i++) z[i] = n[i];
+  while (b >= 64) {
+    core(x, z, k, sigma, false);
+    for (i = 0; i < 64; i++) c[cpos+i] = (m?m[mpos+i]:0) ^ x[i];
+    u = 1;
+    for (i = 8; i < 16; i++) {
+      u = u + (z[i] & 0xff) | 0;
+      z[i] = u & 0xff;
+      u >>>= 8;
+    }
+    b -= 64;
+    cpos += 64;
+    if (m) mpos += 64;
+  }
+  if (b > 0) {
+    core(x, z, k, sigma, false);
+    for (i = 0; i < b; i++) c[cpos+i] = (m?m[mpos+i]:0) ^ x[i];
+  }
+  return 0;
+}
+
+
+
+function crypto_stream_xor (c: Uint8Array, cpos: number, m: Uint8Array | null, mpos: number, d: number, n: Uint8Array, k: Uint8Array): number {
+  const s = new Uint8Array(32);
+  core(s, n, k, sigma, true);
+  return crypto_stream_salsa20_xor(c, cpos, m, mpos, d, n.subarray(16), s);
+}
+
+function add1305 (h: Uint32Array, c: Uint32Array): void {
+  let u = 0;
+  for (let j = 0; j < 17; j++) {
+    u = (u + ((h[j] + c[j]) | 0)) | 0;
+    h[j] = u & 255;
+    u >>>= 8;
+  }
+}
+
+const minusp = new Uint32Array([5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252]);
+
+function crypto_onetimeauth (out: Uint8Array, outpos: number, m: Uint8Array, mpos: number, n: number, k: Uint8Array): number {
+  let i, j, u;
+  const x = new Uint32Array(17), r = new Uint32Array(17), h = new Uint32Array(17), c = new Uint32Array(17), g = new Uint32Array(17);
+  for (j = 0; j < 17; j++) r[j]=h[j]=0;
+  for (j = 0; j < 16; j++) r[j]=k[j];
+  r[3]&=15;
+  r[4]&=252;
+  r[7]&=15;
+  r[8]&=252;
+  r[11]&=15;
+  r[12]&=252;
+  r[15]&=15;
+
+  while (n > 0) {
+    for (j = 0; j < 17; j++) c[j] = 0;
+    for (j = 0; (j < 16) && (j < n); ++j) c[j] = m[mpos+j];
+    c[j] = 1;
+    mpos += j; n -= j;
+    add1305(h,c);
+    for (i = 0; i < 17; i++) {
+      x[i] = 0;
+      for (j = 0; j < 17; j++) x[i] = (x[i] + (h[j] * ((j <= i) ? r[i - j] : ((320 * r[i + 17 - j])|0))) | 0) | 0;
+    }
+    for (i = 0; i < 17; i++) h[i] = x[i];
+    u = 0;
+    for (j = 0; j < 16; j++) {
+      u = (u + h[j]) | 0;
+      h[j] = u & 255;
+      u >>>= 8;
+    }
+    u = (u + h[16]) | 0; h[16] = u & 3;
+    u = (5 * (u >>> 2)) | 0;
+    for (j = 0; j < 16; j++) {
+      u = (u + h[j]) | 0;
+      h[j] = u & 255;
+      u >>>= 8;
+    }
+    u = (u + h[16]) | 0; h[16] = u;
+  }
+
+  for (j = 0; j < 17; j++) g[j] = h[j];
+  add1305(h,minusp);
+  const s = (-(h[16] >>> 7) | 0);
+  for (j = 0; j < 17; j++) h[j] ^= s & (g[j] ^ h[j]);
+
+  for (j = 0; j < 16; j++) c[j] = k[j + 16];
+  c[16] = 0;
+  add1305(h,c);
+  for (j = 0; j < 16; j++) out[outpos+j] = h[j];
+  return 0;
+}
+
+function crypto_onetimeauth_verify (h: Uint8Array, hpos: number, m: Uint8Array, mpos: number, n: number, k: Uint8Array) {
+  const x = new Uint8Array(16);
+  crypto_onetimeauth(x,0,m,mpos,n,k);
+  return vn(h, hpos, x, 0, 16);
+}
+
+function crypto_secretbox (c: Uint8Array, m: Uint8Array, d: number, n: Uint8Array, k: Uint8Array) {
+  if (d < 32) return -1;
+  crypto_stream_xor(c,0,m,0,d,n,k);
+  crypto_onetimeauth(c, 16, c, 32, d - 32, c);
+  for (let i = 0; i < 16; i++) c[i] = 0;
+  return 0;
+}
+
+function crypto_secretbox_open (m: Uint8Array, c: Uint8Array, d: number, n: Uint8Array, k: Uint8Array): number {
+  const x = new Uint8Array(32);
+  if (d < 32) return -1;
+  crypto_stream_xor(x, 0, null, 0, 32, n, k);
+  if (crypto_onetimeauth_verify(c, 16,c, 32,d - 32,x) !== 0) return -1;
+  crypto_stream_xor(m,0,c,0,d,n,k);
+  for (let i = 0; i < 32; i++) m[i] = 0;
+  return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const crypto_secretbox_KEYBYTES = 32;
+const crypto_secretbox_NONCEBYTES = 24;
+const crypto_secretbox_ZEROBYTES = 32;
+const crypto_secretbox_BOXZEROBYTES = 16;
+
+
+
+
+
+function checkLengths (k: Uint8Array, n: Uint8Array): void {
+  if (k.length !== crypto_secretbox_KEYBYTES) throw new Error('bad key size');
+  if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error('bad nonce size');
+}
+
+
+function checkArrayTypes (...args: unknown[]): void {
+  for (let i = 0, count = args.length; i < count; i++) {
+    if (!(args[i] instanceof Uint8Array))
+      throw new TypeError('unexpected type, use Uint8Array');
+  }
+}
+
+
+
+export function naclSecretbox (msg: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array {
+  checkArrayTypes(msg, nonce, key);
+  checkLengths(key, nonce);
+  const m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
+  const c = new Uint8Array(m.length);
+  for (let i = 0; i < msg.length; i++) m[i+crypto_secretbox_ZEROBYTES] = msg[i];
+  crypto_secretbox(c, m, m.length, nonce, key);
+  return c.subarray(crypto_secretbox_BOXZEROBYTES);
+}
+
+export function naclSecretboxOpen (box: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array | null {
+  checkArrayTypes(box, nonce, key);
+  checkLengths(key, nonce);
+  const c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
+  const m = new Uint8Array(c.length);
+  for (let i = 0; i < box.length; i++) c[i+crypto_secretbox_BOXZEROBYTES] = box[i];
+  if (c.length < 32) return null;
+  if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0) return null;
+  return m.subarray(crypto_secretbox_ZEROBYTES);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/build-deno/networks.ts

@@ -0,0 +1,2 @@
+
+export { allNetworks, availableNetworks, selectableNetworks } from 'https://deno.land/x/pezkuwi/networks/mod.ts';

package/build-deno/packageDetect.ts

@@ -0,0 +1,10 @@
+
+
+import { packageInfo as netInfo } from 'https://deno.land/x/pezkuwi/networks/packageInfo.ts';
+import { detectPackage } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import { packageInfo as utilInfo } from 'https://deno.land/x/pezkuwi/util/packageInfo.ts';
+import { packageInfo as randomInfo } from 'https://deno.land/x/pezkuwi/x-randomvalues/mod.ts';
+
+import { packageInfo } from './packageInfo.ts';
+
+detectPackage(packageInfo, null, [netInfo, randomInfo, utilInfo]);

package/build-deno/packageInfo.ts

@@ -0,0 +1,3 @@
+
+
+export const packageInfo = { name: '@pezkuwi/util-crypto', path: new URL(import.meta.url).pathname, type: 'deno', version: '14.0.10' };

package/build-deno/pbkdf2/encode.ts

@@ -0,0 +1,27 @@
+
+import { pbkdf2 as pbkdf2Js } from 'https://esm.sh/@noble/hashes@1.3.3/pbkdf2.js';
+import { sha512 } from 'https://esm.sh/@noble/hashes@1.3.3/sha512.js';
+
+import { hasBigInt, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import { isReady, pbkdf2 } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
+
+import { randomAsU8a } from '../random/asU8a.ts';
+
+interface Result {
+  password: Uint8Array;
+  rounds: number;
+  salt: Uint8Array;
+}
+
+export function pbkdf2Encode (passphrase?: string | Uint8Array, salt: Uint8Array = randomAsU8a(), rounds = 2048, onlyJs?: boolean): Result {
+  const u8aPass = u8aToU8a(passphrase);
+  const u8aSalt = u8aToU8a(salt);
+
+  return {
+    password: !hasBigInt || (!onlyJs && isReady())
+      ? pbkdf2(u8aPass, u8aSalt, rounds)
+      : pbkdf2Js(sha512, u8aPass, u8aSalt, { c: rounds, dkLen: 64 }),
+    rounds,
+    salt
+  };
+}

package/build-deno/pbkdf2/index.ts

@@ -0,0 +1,2 @@
+
+export { pbkdf2Encode } from './encode.ts';

package/build-deno/random/asNumber.ts

@@ -0,0 +1,26 @@
+
+import { BN, hexToBn } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { randomAsHex } from './asU8a.ts';
+
+const BN_53 = new BN(0b11111111111111111111111111111111111111111111111111111);
+
+/**
+ * @name randomAsNumber
+ * @summary Creates a random number from random bytes.
+ * @description
+ * Returns a random number generated from the secure bytes.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { randomAsNumber } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
+ *
+ * randomAsNumber(); // => <random number>
+ * ```
+ */
+export function randomAsNumber (): number {
+  return hexToBn(
+    randomAsHex(8)
+  ).and(BN_53).toNumber();
+}

package/build-deno/random/asU8a.ts

@@ -0,0 +1,28 @@
+
+import { getRandomValues } from 'https://deno.land/x/pezkuwi/x-randomvalues/mod.ts';
+
+import { createAsHex } from '../helpers.ts';
+
+/**
+ * @name randomAsU8a
+ * @summary Creates a Uint8Array filled with random bytes.
+ * @description
+ * Returns a `Uint8Array` with the specified (optional) length filled with random bytes.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { randomAsU8a } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
+ *
+ * randomAsU8a(); // => Uint8Array([...])
+ * ```
+ */
+export function randomAsU8a (length = 32): Uint8Array {
+  return getRandomValues(new Uint8Array(length));
+}
+
+/**
+ * @name randomAsHex
+ * @description Creates a hex string filled with random bytes.
+ */
+export const randomAsHex = /*#__PURE__*/ createAsHex(randomAsU8a);

package/build-deno/random/index.ts

@@ -0,0 +1,7 @@
+
+/**
+ * @summary Returns a sequence of secure random bytes in a variety of formats
+ */
+
+export { randomAsNumber } from './asNumber.ts';
+export { randomAsHex, randomAsU8a } from './asU8a.ts';

package/build-deno/scrypt/defaults.ts

@@ -0,0 +1,17 @@
+
+import type { ScryptParams } from './types.ts';
+
+export const ALLOWED_PARAMS: ScryptParams[] = [
+  { N: 1 << 13, p: 10, r: 8 },
+  { N: 1 << 14, p: 5, r: 8 },
+  { N: 1 << 15, p: 3, r: 8 },
+  { N: 1 << 15, p: 1, r: 8 },
+  { N: 1 << 16, p: 2, r: 8 },
+  { N: 1 << 17, p: 1, r: 8 }
+];
+
+export const DEFAULT_PARAMS: ScryptParams = {
+  N: 1 << 17,
+  p: 1,
+  r: 8
+};

package/build-deno/scrypt/encode.ts

@@ -0,0 +1,28 @@
+
+import type { ScryptParams } from './types.ts';
+
+import { scrypt as scryptJs } from 'https://esm.sh/@noble/hashes@1.3.3/scrypt.js';
+
+import { hasBigInt, objectSpread, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import { isReady, scrypt } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
+
+import { randomAsU8a } from '../random/asU8a.ts';
+import { DEFAULT_PARAMS } from './defaults.ts';
+
+interface Result {
+  params: ScryptParams,
+  password: Uint8Array;
+  salt: Uint8Array;
+}
+
+export function scryptEncode (passphrase?: string | Uint8Array, salt = randomAsU8a(), params = DEFAULT_PARAMS, onlyJs?: boolean): Result {
+  const u8a = u8aToU8a(passphrase);
+
+  return {
+    params,
+    password: !hasBigInt || (!onlyJs && isReady())
+      ? scrypt(u8a, salt, Math.log2(params.N), params.r, params.p)
+      : scryptJs(u8a, salt, objectSpread({ dkLen: 64 }, params)),
+    salt
+  };
+}

package/build-deno/scrypt/fromU8a.ts

@@ -0,0 +1,42 @@
+
+import type { ScryptParams } from './types.ts';
+
+import { u8aToBn } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { BN_LE_OPTS } from '../bn.ts';
+import { ALLOWED_PARAMS } from './defaults.ts';
+
+interface Result {
+  params: ScryptParams,
+  salt: Uint8Array;
+}
+
+export function scryptFromU8a (data: Uint8Array): Result {
+  if (!(data instanceof Uint8Array)) {
+    throw new Error('Expected input to be a Uint8Array');
+  }
+
+  // Ensure the input is exactly 44 bytes: 32 for salt + 3 * 4 for N, p, r
+  if (data.length < 32 + 12) {
+    throw new Error(`Invalid input length: expected 44 bytes, found ${data.length}`);
+  }
+
+  const salt = data.subarray(0, 32);
+  const N = u8aToBn(data.subarray(32, 36), BN_LE_OPTS).toNumber();
+  const p = u8aToBn(data.subarray(36, 40), BN_LE_OPTS).toNumber();
+  const r = u8aToBn(data.subarray(40, 44), BN_LE_OPTS).toNumber();
+
+  if (N > (1 << 20) || p > 4 || r > 16) {
+    throw new Error('Scrypt parameters exceed safe limits');
+  }
+
+  const isAllowed = ALLOWED_PARAMS.some((preset) =>
+    preset.N === N && preset.p === p && preset.r === r
+  );
+
+  if (!isAllowed) {
+    throw new Error('Invalid injected scrypt params found');
+  }
+
+  return { params: { N, p, r }, salt };
+}

package/build-deno/scrypt/index.ts

@@ -0,0 +1,4 @@
+
+export { scryptEncode } from './encode.ts';
+export { scryptFromU8a } from './fromU8a.ts';
+export { scryptToU8a } from './toU8a.ts';

package/build-deno/scrypt/toU8a.ts

@@ -0,0 +1,15 @@
+
+import type { ScryptParams } from './types.ts';
+
+import { bnToU8a, u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { BN_LE_32_OPTS } from '../bn.ts';
+
+export function scryptToU8a (salt: Uint8Array, { N, p, r }: ScryptParams): Uint8Array {
+  return u8aConcat(
+    salt,
+    bnToU8a(N, BN_LE_32_OPTS),
+    bnToU8a(p, BN_LE_32_OPTS),
+    bnToU8a(r, BN_LE_32_OPTS)
+  );
+}

package/build-deno/scrypt/types.ts

@@ -0,0 +1,7 @@
+
+/** The params that control scrypt generation */
+export interface ScryptParams {
+  N: number;
+  p: number;
+  r: number;
+}

package/build-deno/secp256k1/compress.ts

@@ -0,0 +1,19 @@
+
+import { secp256k1 } from 'https://esm.sh/@noble/curves@1.3.0/secp256k1.js';
+
+import { hasBigInt } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import { isReady, secp256k1Compress as wasm } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
+
+export function secp256k1Compress (publicKey: Uint8Array, onlyJs?: boolean): Uint8Array {
+  if (![33, 65].includes(publicKey.length)) {
+    throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
+  }
+
+  if (publicKey.length === 33) {
+    return publicKey;
+  }
+
+  return !hasBigInt || (!onlyJs && isReady())
+    ? wasm(publicKey)
+    : secp256k1.ProjectivePoint.fromHex(publicKey).toRawBytes(true);
+}

package/build-deno/secp256k1/deriveHard.ts

@@ -0,0 +1,15 @@
+
+import { compactAddLength, isU8a, stringToU8a, u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { blake2AsU8a } from '../blake2/asU8a.ts';
+
+const HDKD = compactAddLength(stringToU8a('Secp256k1HDKD'));
+
+export function secp256k1DeriveHard (seed: Uint8Array, chainCode: Uint8Array): Uint8Array {
+  if (!isU8a(chainCode) || chainCode.length !== 32) {
+    throw new Error('Invalid chainCode passed to derive');
+  }
+
+  // NOTE This is specific to the Substrate HDD derivation, so always use the blake2 hasher
+  return blake2AsU8a(u8aConcat(HDKD, seed, chainCode), 256);
+}

package/build-deno/secp256k1/expand.ts

@@ -0,0 +1,28 @@
+
+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, secp256k1Expand as wasm } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
+
+import { BN_BE_256_OPTS } from '../bn.ts';
+
+export function secp256k1Expand (publicKey: Uint8Array, onlyJs?: boolean): Uint8Array {
+  if (![33, 65].includes(publicKey.length)) {
+    throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
+  }
+
+  if (publicKey.length === 65) {
+    return publicKey.subarray(1);
+  }
+
+  if (!hasBigInt || (!onlyJs && isReady())) {
+    return wasm(publicKey).subarray(1);
+  }
+
+  const { px, py } = secp256k1.ProjectivePoint.fromHex(publicKey);
+
+  return u8aConcat(
+    bnToU8a(px, BN_BE_256_OPTS),
+    bnToU8a(py, BN_BE_256_OPTS)
+  );
+}

package/build-deno/secp256k1/hasher.ts

@@ -0,0 +1,11 @@
+
+import type { HashType } from './types.ts';
+
+import { blake2AsU8a } from '../blake2/index.ts';
+import { keccakAsU8a } from '../keccak/index.ts';
+
+export function hasher (hashType: HashType, data: Uint8Array | string, onlyJs?: boolean): Uint8Array {
+  return hashType === 'keccak'
+    ? keccakAsU8a(data, undefined, onlyJs)
+    : blake2AsU8a(data, undefined, undefined, onlyJs);
+}

package/build-deno/secp256k1/index.ts

@@ -0,0 +1,8 @@
+
+export { secp256k1Compress } from './compress.ts';
+export { secp256k1Expand } from './expand.ts';
+export { secp256k1PairFromSeed } from './pair/fromSeed.ts';
+export { secp256k1Recover } from './recover.ts';
+export { secp256k1Sign } from './sign.ts';
+export { secp256k1PrivateKeyTweakAdd } from './tweakAdd.ts';
+export { secp256k1Verify } from './verify.ts';