@openclaw/nostr 2026.5.20-beta.2 → 2026.5.22

package/node_modules/@noble/curves/src/utils.ts

@@ -0,0 +1,306 @@
+/**
+ * Hex, bytes and number utilities.
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import {
+  abytes as abytes_,
+  anumber,
+  bytesToHex as bytesToHex_,
+  concatBytes as concatBytes_,
+  hexToBytes as hexToBytes_,
+} from '@noble/hashes/utils.js';
+export {
+  abytes,
+  anumber,
+  bytesToHex,
+  concatBytes,
+  hexToBytes,
+  isBytes,
+  randomBytes,
+} from '@noble/hashes/utils.js';
+const _0n = /* @__PURE__ */ BigInt(0);
+const _1n = /* @__PURE__ */ BigInt(1);
+
+export type CHash = {
+  (message: Uint8Array): Uint8Array;
+  blockLen: number;
+  outputLen: number;
+  create(opts?: { dkLen?: number }): any; // For shake
+};
+export type FHash = (message: Uint8Array) => Uint8Array;
+export function abool(value: boolean, title: string = ''): boolean {
+  if (typeof value !== 'boolean') {
+    const prefix = title && `"${title}" `;
+    throw new Error(prefix + 'expected boolean, got type=' + typeof value);
+  }
+  return value;
+}
+
+// Used in weierstrass, der
+function abignumber(n: number | bigint) {
+  if (typeof n === 'bigint') {
+    if (!isPosBig(n)) throw new Error('positive bigint expected, got ' + n);
+  } else anumber(n);
+  return n;
+}
+
+export function asafenumber(value: number, title: string = ''): void {
+  if (!Number.isSafeInteger(value)) {
+    const prefix = title && `"${title}" `;
+    throw new Error(prefix + 'expected safe integer, got type=' + typeof value);
+  }
+}
+
+export function numberToHexUnpadded(num: number | bigint): string {
+  const hex = abignumber(num).toString(16);
+  return hex.length & 1 ? '0' + hex : hex;
+}
+
+export function hexToNumber(hex: string): bigint {
+  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);
+  return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian
+}
+
+// BE: Big Endian, LE: Little Endian
+export function bytesToNumberBE(bytes: Uint8Array): bigint {
+  return hexToNumber(bytesToHex_(bytes));
+}
+export function bytesToNumberLE(bytes: Uint8Array): bigint {
+  return hexToNumber(bytesToHex_(copyBytes(abytes_(bytes)).reverse()));
+}
+
+export function numberToBytesBE(n: number | bigint, len: number): Uint8Array {
+  anumber(len);
+  n = abignumber(n);
+  const res = hexToBytes_(n.toString(16).padStart(len * 2, '0'));
+  if (res.length !== len) throw new Error('number too large');
+  return res;
+}
+export function numberToBytesLE(n: number | bigint, len: number): Uint8Array {
+  return numberToBytesBE(n, len).reverse();
+}
+// Unpadded, rarely used
+export function numberToVarBytesBE(n: number | bigint): Uint8Array {
+  return hexToBytes_(numberToHexUnpadded(abignumber(n)));
+}
+
+// Compares 2 u8a-s in kinda constant time
+export function equalBytes(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+
+/**
+ * Copies Uint8Array. We can't use u8a.slice(), because u8a can be Buffer,
+ * and Buffer#slice creates mutable copy. Never use Buffers!
+ */
+export function copyBytes(bytes: Uint8Array): Uint8Array {
+  return Uint8Array.from(bytes);
+}
+
+/**
+ * Decodes 7-bit ASCII string to Uint8Array, throws on non-ascii symbols
+ * Should be safe to use for things expected to be ASCII.
+ * Returns exact same result as `TextEncoder` for ASCII or throws.
+ */
+export function asciiToBytes(ascii: string): Uint8Array {
+  return Uint8Array.from(ascii, (c, i) => {
+    const charCode = c.charCodeAt(0);
+    if (c.length !== 1 || charCode > 127) {
+      throw new Error(
+        `string contains non-ASCII character "${ascii[i]}" with code ${charCode} at position ${i}`
+      );
+    }
+    return charCode;
+  });
+}
+
+// Is positive bigint
+const isPosBig = (n: bigint) => typeof n === 'bigint' && _0n <= n;
+
+export function inRange(n: bigint, min: bigint, max: bigint): boolean {
+  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+}
+
+/**
+ * Asserts min <= n < max. NOTE: It's < max and not <= max.
+ * @example
+ * aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)
+ */
+export function aInRange(title: string, n: bigint, min: bigint, max: bigint): void {
+  // Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?
+  // consider P=256n, min=0n, max=P
+  // - a for min=0 would require -1:          `inRange('x', x, -1n, P)`
+  // - b would commonly require subtraction:  `inRange('x', x, 0n, P - 1n)`
+  // - our way is the cleanest:               `inRange('x', x, 0n, P)
+  if (!inRange(n, min, max))
+    throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);
+}
+
+// Bit operations
+
+/**
+ * Calculates amount of bits in a bigint.
+ * Same as `n.toString(2).length`
+ * TODO: merge with nLength in modular
+ */
+export function bitLen(n: bigint): number {
+  let len;
+  for (len = 0; n > _0n; n >>= _1n, len += 1);
+  return len;
+}
+
+/**
+ * Gets single bit at position.
+ * NOTE: first bit position is 0 (same as arrays)
+ * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`
+ */
+export function bitGet(n: bigint, pos: number): bigint {
+  return (n >> BigInt(pos)) & _1n;
+}
+
+/**
+ * Sets single bit at position.
+ */
+export function bitSet(n: bigint, pos: number, value: boolean): bigint {
+  return n | ((value ? _1n : _0n) << BigInt(pos));
+}
+
+/**
+ * Calculate mask for N bits. Not using ** operator with bigints because of old engines.
+ * Same as BigInt(`0b${Array(i).fill('1').join('')}`)
+ */
+export const bitMask = (n: number): bigint => (_1n << BigInt(n)) - _1n;
+
+// DRBG
+
+type Pred<T> = (v: Uint8Array) => T | undefined;
+/**
+ * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
+ * @returns function that will call DRBG until 2nd arg returns something meaningful
+ * @example
+ *   const drbg = createHmacDRBG<Key>(32, 32, hmac);
+ *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined
+ */
+export function createHmacDrbg<T>(
+  hashLen: number,
+  qByteLen: number,
+  hmacFn: (key: Uint8Array, message: Uint8Array) => Uint8Array
+): (seed: Uint8Array, predicate: Pred<T>) => T {
+  anumber(hashLen, 'hashLen');
+  anumber(qByteLen, 'qByteLen');
+  if (typeof hmacFn !== 'function') throw new Error('hmacFn must be a function');
+  const u8n = (len: number): Uint8Array => new Uint8Array(len); // creates Uint8Array
+  const NULL = Uint8Array.of();
+  const byte0 = Uint8Array.of(0x00);
+  const byte1 = Uint8Array.of(0x01);
+  const _maxDrbgIters = 1000;
+
+  // Step B, Step C: set hashLen to 8*ceil(hlen/8)
+  let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
+  let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same
+  let i = 0; // Iterations counter, will throw when over 1000
+  const reset = () => {
+    v.fill(1);
+    k.fill(0);
+    i = 0;
+  };
+  const h = (...msgs: Uint8Array[]) => hmacFn(k, concatBytes_(v, ...msgs)); // hmac(k)(v, ...values)
+  const reseed = (seed: Uint8Array = NULL) => {
+    // HMAC-DRBG reseed() function. Steps D-G
+    k = h(byte0, seed); // k = hmac(k || v || 0x00 || seed)
+    v = h(); // v = hmac(k || v)
+    if (seed.length === 0) return;
+    k = h(byte1, seed); // k = hmac(k || v || 0x01 || seed)
+    v = h(); // v = hmac(k || v)
+  };
+  const gen = () => {
+    // HMAC-DRBG generate() function
+    if (i++ >= _maxDrbgIters) throw new Error('drbg: tried max amount of iterations');
+    let len = 0;
+    const out: Uint8Array[] = [];
+    while (len < qByteLen) {
+      v = h();
+      const sl = v.slice();
+      out.push(sl);
+      len += v.length;
+    }
+    return concatBytes_(...out);
+  };
+  const genUntil = (seed: Uint8Array, pred: Pred<T>): T => {
+    reset();
+    reseed(seed); // Steps D-G
+    let res: T | undefined = undefined; // Step H: grind until k is in [1..n-1]
+    while (!(res = pred(gen()))) reseed();
+    reset();
+    return res;
+  };
+  return genUntil;
+}
+
+export function validateObject(
+  object: Record<string, any>,
+  fields: Record<string, string> = {},
+  optFields: Record<string, string> = {}
+): void {
+  if (!object || typeof object !== 'object') throw new Error('expected valid options object');
+  type Item = keyof typeof object;
+  function checkField(fieldName: Item, expectedType: string, isOpt: boolean) {
+    const val = object[fieldName];
+    if (isOpt && val === undefined) return;
+    const current = typeof val;
+    if (current !== expectedType || val === null)
+      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+  }
+  const iter = (f: typeof fields, isOpt: boolean) =>
+    Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt));
+  iter(fields, false);
+  iter(optFields, true);
+}
+
+/**
+ * throws not implemented error
+ */
+export const notImplemented = (): never => {
+  throw new Error('not implemented');
+};
+
+/**
+ * Memoizes (caches) computation result.
+ * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.
+ */
+export function memoized<T extends object, R, O extends any[]>(
+  fn: (arg: T, ...args: O) => R
+): (arg: T, ...args: O) => R {
+  const map = new WeakMap<T, R>();
+  return (arg: T, ...args: O): R => {
+    const val = map.get(arg);
+    if (val !== undefined) return val;
+    const computed = fn(arg, ...args);
+    map.set(arg, computed);
+    return computed;
+  };
+}
+
+export interface CryptoKeys {
+  lengths: { seed?: number; public?: number; secret?: number };
+  keygen: (seed?: Uint8Array) => { secretKey: Uint8Array; publicKey: Uint8Array };
+  getPublicKey: (secretKey: Uint8Array) => Uint8Array;
+}
+
+/** Generic interface for signatures. Has keygen, sign and verify. */
+export interface Signer extends CryptoKeys {
+  // Interfaces are fun. We cannot just add new fields without copying old ones.
+  lengths: {
+    seed?: number;
+    public?: number;
+    secret?: number;
+    signRand?: number;
+    signature?: number;
+  };
+  sign: (msg: Uint8Array, secretKey: Uint8Array) => Uint8Array;
+  verify: (sig: Uint8Array, msg: Uint8Array, publicKey: Uint8Array) => boolean;
+}

package/node_modules/@noble/curves/src/webcrypto.ts

@@ -0,0 +1,403 @@
+/**
+ * Friendly wrapper over elliptic curves from built-in WebCrypto. Experimental: API may change.
+
+# WebCrypto issues
+
+## No way to get public keys
+
+- Export of raw secret key is prohibited by spec:
+  - https://w3c.github.io/webcrypto/#ecdsa-operations-export-key
+    -> "If format is "raw":" -> "If the [[type]] internal slot of key is not "public",
+       then throw an InvalidAccessError."
+- Import of raw secret keys is prohibited by spec:
+  - https://w3c.github.io/webcrypto/#ecdsa-operations-import-key
+    -> "If format is "raw":" -> "If usages contains a value which is not "verify"
+       then throw a SyntaxError."
+- SPKI (Simple public-key infrastructure) is public-key-only
+- PKCS8 is secret-key-only
+- No way to get public key from secret key, but we convert to jwk and then create it manually, since jwk secret key is priv+pub.
+- Noble supports generating keys for both sign, verify & getSharedSecret,
+  but JWK key includes usage, which forces us to patch it (non-JWK is ok)
+- We have import/export for 'raw', but it doesn't work in Firefox / Safari
+
+## Point encoding
+
+- Raw export of public points returns uncompressed points,
+  but this is implementation specific and not much we can do there.
+- `getSharedSecret` differs for p256, p384, p521:
+  Noble returns 33-byte output (y-parity + x coordinate),
+  while in WebCrypto returns 32-byte output (x coordinate)
+- `getSharedSecret` identical for X25519, X448
+
+## Availability
+
+Node.js additionally supports ed448.
+There seems no reasonable way to check for availability, other than actually calling methods.
+
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
+/** Raw type */
+const TYPE_RAW = 'raw';
+const TYPE_JWK = 'jwk';
+const TYPE_SPKI = 'spki';
+const TYPE_PKCS = 'pkcs8';
+export type WebCryptoFormat =
+  | typeof TYPE_RAW
+  | typeof TYPE_JWK
+  | typeof TYPE_SPKI
+  | typeof TYPE_PKCS;
+/** WebCrypto keys can be in raw, jwk, pkcs8/spki formats. Raw is internal and fragile. */
+export type WebCryptoOpts = {
+  formatSec?: WebCryptoFormat;
+  formatPub?: WebCryptoFormat;
+};
+// default formats
+const dfsec = TYPE_PKCS;
+const dfpub = TYPE_SPKI;
+
+function getSubtle(): any {
+  const s: any = globalThis?.crypto?.subtle;
+  if (typeof s === 'object' && s != null) return s;
+  throw new Error('crypto.subtle must be defined');
+}
+
+function createKeygenA(randomSecretKey: any, getPublicKey: any) {
+  return async function keygenA(_seed?: Uint8Array) {
+    const secretKey = await randomSecretKey();
+    return { secretKey, publicKey: await getPublicKey(secretKey) };
+  };
+}
+
+function hexToBytesUns(hex: string): Uint8Array {
+  return Uint8Array.from(hex.match(/(\w\w)/g)!, (b) => Number.parseInt(b, 16));
+}
+
+// Trying to do generics here creates hell on conversion and usage
+type JsonWebKey = {
+  crv?: string;
+  d?: string;
+  kty?: string;
+  x?: string;
+  y?: string;
+  [key: string]: unknown;
+};
+type Key = JsonWebKey | Uint8Array;
+type CryptoKey = Awaited<ReturnType<typeof crypto.subtle.importKey>>;
+type KeyUsage = 'deriveBits' | 'deriveKey' | 'sign' | 'verify';
+type Algo = string | { name: string; namedCurve: string };
+type SigAlgo = string | { name: string; hash?: { name: string } };
+
+type KeyUtils = {
+  import(key: Key, format?: WebCryptoFormat): Promise<CryptoKey>;
+  export(key: CryptoKey, format?: WebCryptoFormat): Promise<Key>;
+  convert(key: Key, inFormat?: WebCryptoFormat, outFormat?: WebCryptoFormat): Promise<Key>;
+};
+
+function assertType(type: 'private' | 'public', key: any) {
+  if (key.type !== type) throw new Error(`invalid key type, expected ${type}`);
+}
+
+function createKeyUtils(algo: Algo, derive: boolean, keyLen: number, pkcs8header: string) {
+  const secUsage: KeyUsage[] = derive ? ['deriveBits'] : ['sign'];
+  const pubUsage: KeyUsage[] = derive ? [] : ['verify'];
+  // Return Uint8Array instead of ArrayBuffer
+  const arrBufToU8 = (res: Key, format: WebCryptoFormat) =>
+    format === TYPE_JWK ? res : new Uint8Array(res as unknown as ArrayBuffer);
+  const pub: KeyUtils = {
+    async import(key: Key, format: WebCryptoFormat): Promise<CryptoKey> {
+      const keyi: CryptoKey = await getSubtle().importKey(format, key, algo, true, pubUsage);
+      assertType('public', keyi);
+      return keyi;
+    },
+    async export(key: CryptoKey, format: WebCryptoFormat): Promise<Key> {
+      assertType('public', key);
+      const keyi = await getSubtle().exportKey(format, key);
+      return arrBufToU8(keyi, format);
+    },
+    async convert(key: Key, inFormat: WebCryptoFormat, outFormat: WebCryptoFormat): Promise<Key> {
+      return pub.export(await pub.import(key, inFormat), outFormat);
+    },
+  };
+  const priv: KeyUtils = {
+    async import(key: Key, format: WebCryptoFormat): Promise<CryptoKey> {
+      const crypto = getSubtle();
+      let keyi: CryptoKey;
+      if (format === TYPE_RAW) {
+        // Chrome, node, bun, deno: works
+        // Safari, Firefox: Data provided to an operation does not meet requirements
+        // This is the best one can do. JWK can't be used: it contains public key component inside.
+        const k = key as Uint8Array;
+        const head = hexToBytesUns(pkcs8header);
+        const all = new Uint8Array(head.length + k.length);
+        all.set(head, 0);
+        all.set(k, head.length);
+
+        keyi = await crypto.importKey(TYPE_PKCS, all, algo, true, secUsage);
+      } else {
+        // Fix import of ECDSA keys into ECDH, other formats are ok
+        if (derive && format === TYPE_JWK) key = { ...key, key_ops: secUsage };
+        keyi = await crypto.importKey(format, key, algo, true, secUsage);
+      }
+      assertType('private', keyi);
+      return keyi;
+    },
+    async export(key: CryptoKey, format: WebCryptoFormat): Promise<Key> {
+      const crypto = getSubtle();
+      assertType('private', key);
+      if (format === TYPE_RAW) {
+        // scure-base base64urlnopad could have been used, but we can't add more deps.
+        // pkcs8 would be even more fragile
+        const jwk = await crypto.exportKey(TYPE_JWK, key);
+        const base64 = jwk.d.replace(/-/g, '+').replace(/_/g, '/'); // base64url
+        const pad = base64.length % 4 ? '='.repeat(4 - (base64.length % 4)) : ''; // add padding
+        const binary = atob(base64 + pad);
+        // This is not ASCII, and not text: this is only semi-safe with atob output
+        const raw = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+        // Pad key to key len because Bun strips leading zero for P-521 only
+        const res = new Uint8Array(keyLen);
+        res.set(raw, keyLen - raw.length);
+        return res as Key;
+      }
+      const keyi = await crypto.exportKey(format, key);
+      return arrBufToU8(keyi, format);
+    },
+    async convert(key: Key, inFormat: WebCryptoFormat, outFormat: WebCryptoFormat): Promise<Key> {
+      return priv.export(await priv.import(key, inFormat), outFormat);
+    },
+  };
+  async function getPublicKey(secretKey: Key, opts: WebCryptoOpts = {}): Promise<Key> {
+    const fsec = opts.formatSec ?? dfsec;
+    const fpub = opts.formatPub ?? dfpub;
+    // Export to jwk, remove private scalar and then convert to format
+    const jwk = (
+      fsec === TYPE_JWK ? { ...secretKey } : await priv.convert(secretKey, fsec, TYPE_JWK)
+    ) as JsonWebKey;
+    delete jwk.d;
+    jwk.key_ops = pubUsage;
+    if (fpub === TYPE_JWK) return jwk;
+    return pub.convert(jwk, TYPE_JWK, fpub);
+  }
+  async function randomSecretKey(format: WebCryptoFormat = dfsec): Promise<Key> {
+    const keyPair = await getSubtle().generateKey(algo, true, secUsage);
+    return priv.export(keyPair.privateKey, format);
+  }
+  // Key generation could be slow, so we cache result once.
+  let supported: boolean | undefined;
+  return {
+    pub: pub as KeyUtils,
+    priv: priv as KeyUtils,
+    async isSupported(): Promise<boolean> {
+      if (supported !== undefined) return supported;
+      try {
+        const crypto = getSubtle();
+        const key = await crypto.generateKey(algo, true, secUsage);
+        // Deno is broken and generates key for unsupported curves, but then fails on export
+        await priv.export(key.privateKey, TYPE_JWK);
+        // Bun fails on derive for x25519, but not x448
+        if (derive) {
+          await crypto.deriveBits(
+            { name: typeof algo === 'string' ? algo : algo.name, public: key.publicKey },
+            key.privateKey,
+            8
+          );
+        }
+        return (supported = true);
+      } catch (e) {
+        return (supported = false);
+      }
+    },
+    getPublicKey,
+    keygen: createKeygenA(randomSecretKey, getPublicKey),
+    utils: {
+      randomSecretKey,
+      convertPublicKey: pub.convert as KeyUtils['convert'],
+      convertSecretKey: priv.convert as KeyUtils['convert'],
+    },
+  };
+}
+
+function createSigner(keys: ReturnType<typeof createKeyUtils>, algo: SigAlgo): WebCryptoSigner {
+  return {
+    async sign(msgHash: Uint8Array, secretKey: Key, opts: WebCryptoOpts = {}): Promise<Uint8Array> {
+      const key = await keys.priv.import(secretKey, opts.formatSec ?? dfsec);
+      const sig = await getSubtle().sign(algo, key, msgHash);
+      return new Uint8Array(sig);
+    },
+    async verify(
+      signature: Uint8Array,
+      msgHash: Uint8Array,
+      publicKey: Key,
+      opts: WebCryptoOpts = {}
+    ): Promise<boolean> {
+      const key = await keys.pub.import(publicKey, opts.formatPub ?? dfpub);
+      return await getSubtle().verify(algo, key, signature, msgHash);
+    },
+  };
+}
+
+function createECDH(
+  keys: ReturnType<typeof createKeyUtils>,
+  algo: Algo,
+  keyLen: number
+): WebCryptoECDH {
+  return {
+    async getSharedSecret(
+      secretKeyA: Uint8Array,
+      publicKeyB: Uint8Array,
+      opts: WebCryptoOpts = {}
+    ): Promise<Uint8Array> {
+      // if (_isCompressed !== true) throw new Error('WebCrypto only supports compressed keys');
+      const secKey = await keys.priv.import(secretKeyA, opts.formatSec || dfsec);
+      const pubKey = await keys.pub.import(publicKeyB, opts.formatPub || dfpub);
+      const shared = await getSubtle().deriveBits(
+        { name: typeof algo === 'string' ? algo : algo.name, public: pubKey },
+        secKey,
+        8 * keyLen
+      );
+      return new Uint8Array(shared);
+    },
+  };
+}
+
+type WebCryptoBaseCurve = {
+  name: string;
+  isSupported(): Promise<boolean>;
+  keygen(): Promise<{ secretKey: Uint8Array; publicKey: Uint8Array }>;
+  getPublicKey(secretKey: Key, opts?: WebCryptoOpts): Promise<Key>;
+  utils: {
+    randomSecretKey: (format?: WebCryptoFormat) => Promise<Key>;
+    convertSecretKey: (
+      key: Key,
+      inFormat?: WebCryptoFormat,
+      outFormat?: WebCryptoFormat
+    ) => Promise<Key>;
+    convertPublicKey: (
+      key: Key,
+      inFormat?: WebCryptoFormat,
+      outFormat?: WebCryptoFormat
+    ) => Promise<Key>;
+  };
+};
+
+// Specific per-curve methods - no reason to export them; we can't "add" a new curve
+export type WebCryptoSigner = {
+  sign(message: Uint8Array, secretKey: Key, opts?: WebCryptoOpts): Promise<Uint8Array>;
+  verify(
+    signature: Uint8Array,
+    message: Uint8Array,
+    publicKey: Key,
+    opts?: WebCryptoOpts
+  ): Promise<boolean>;
+};
+export type WebCryptoECDH = {
+  getSharedSecret(secA: Uint8Array, pubB: Uint8Array, opts?: WebCryptoOpts): Promise<Uint8Array>;
+};
+export type WebCryptoECDSA = WebCryptoBaseCurve & WebCryptoSigner & WebCryptoECDH;
+export type WebCryptoEdDSA = WebCryptoBaseCurve & WebCryptoSigner;
+export type WebCryptoMontgomery = WebCryptoBaseCurve & WebCryptoECDH;
+
+function wrapECDSA(
+  curve: 'P-256' | 'P-384' | 'P-521',
+  hash: string,
+  keyLen: number,
+  pkcs8header: string
+): WebCryptoECDSA {
+  const ECDH_ALGO = { name: 'ECDH', namedCurve: curve };
+  const keys = createKeyUtils({ name: 'ECDSA', namedCurve: curve }, false, keyLen, pkcs8header);
+  const keysEcdh = createKeyUtils(ECDH_ALGO, true, keyLen, pkcs8header);
+  return Object.freeze({
+    name: curve,
+    isSupported: keys.isSupported,
+    getPublicKey: keys.getPublicKey,
+    keygen: createKeygenA(keys.utils.randomSecretKey, keys.getPublicKey),
+    ...createSigner(keys, { name: 'ECDSA', hash: { name: hash } }),
+    ...createECDH(keysEcdh, ECDH_ALGO, keyLen),
+    utils: keys.utils,
+  });
+}
+
+function wrapEdDSA(
+  curve: 'Ed25519' | 'Ed448',
+  keyLen: number,
+  pkcs8header: string
+): WebCryptoEdDSA {
+  const keys = createKeyUtils(curve, false, keyLen, pkcs8header);
+  return Object.freeze({
+    name: curve,
+    isSupported: keys.isSupported,
+    getPublicKey: keys.getPublicKey,
+    keygen: createKeygenA(keys.utils.randomSecretKey, keys.getPublicKey),
+    ...createSigner(keys, { name: curve }),
+    utils: keys.utils,
+  });
+}
+
+function wrapMontgomery(
+  curve: 'X25519' | 'X448',
+  keyLen: number,
+  pkcs8header: string
+): WebCryptoMontgomery {
+  const keys = createKeyUtils(curve, true, keyLen, pkcs8header);
+  return Object.freeze({
+    name: curve,
+    isSupported: keys.isSupported,
+    getPublicKey: keys.getPublicKey,
+    keygen: createKeygenA(keys.utils.randomSecretKey, keys.getPublicKey),
+    ...createECDH(keys, curve, keyLen),
+    utils: keys.utils,
+  });
+}
+
+/** Friendly wrapper over built-in WebCrypto NIST P-256 (secp256r1). */
+export const p256: WebCryptoECDSA = /* @__PURE__ */ wrapECDSA(
+  'P-256',
+  'SHA-256',
+  32,
+  '3041020100301306072a8648ce3d020106082a8648ce3d030107042730250201010420'
+);
+
+/** Friendly wrapper over built-in WebCrypto NIST P-384 (secp384r1). */
+export const p384: WebCryptoECDSA = /* @__PURE__ */ wrapECDSA(
+  'P-384',
+  'SHA-384',
+  48,
+  '304e020100301006072a8648ce3d020106052b81040022043730350201010430'
+);
+
+/** Friendly wrapper over built-in WebCrypto NIST P-521 (secp521r1). */
+export const p521: WebCryptoECDSA = /* @__PURE__ */ wrapECDSA(
+  'P-521',
+  'SHA-512',
+  66,
+  '3060020100301006072a8648ce3d020106052b81040023044930470201010442'
+);
+
+/** Friendly wrapper over built-in WebCrypto ed25519. */
+export const ed25519: WebCryptoEdDSA = /* @__PURE__ */ wrapEdDSA(
+  'Ed25519',
+  32,
+  '302e020100300506032b657004220420'
+);
+
+/** Friendly wrapper over built-in WebCrypto ed448. */
+export const ed448: WebCryptoEdDSA = /* @__PURE__ */ wrapEdDSA(
+  'Ed448',
+  57,
+  '3047020100300506032b6571043b0439'
+);
+
+/** Friendly wrapper over built-in WebCrypto x25519 (ECDH over Curve25519). */
+export const x25519: WebCryptoMontgomery = /* @__PURE__ */ wrapMontgomery(
+  'X25519',
+  32,
+  '302e020100300506032b656e04220420'
+);
+
+/** Friendly wrapper over built-in WebCrypto x448 (ECDH over Curve448). */
+export const x448: WebCryptoMontgomery = /* @__PURE__ */ wrapMontgomery(
+  'X448',
+  56,
+  '3046020100300506032b656f043a0438'
+);