@dxos/crypto 0.6.12 → 0.6.13-main.041e8aa

package/dist/lib/browser/index.mjs

@@ -97,23 +97,41 @@ import { verify as verify2 } from "#hypercore-crypto";
 var getSignatureValidator = (publicKey) => (message, signature) => verify2(message, signature, PublicKey2.bufferize(publicKey));
 
 // packages/common/crypto/src/verify.ts
-var verifySignature = async (key, message, signature) => {
+var verifySignature = async (key, message, signature, algorithm = {
+  name: "ECDSA",
+  namedCurve: "P-256"
+}) => {
   let publicKey;
   try {
-    publicKey = await subtleCrypto.importKey("raw", key.asUint8Array(), {
-      name: "ECDSA",
-      namedCurve: "P-256"
-    }, true, [
+    publicKey = await subtleCrypto.importKey("raw", key.asUint8Array(), algorithm, true, [
       "verify"
     ]);
   } catch {
     return false;
   }
   return subtleCrypto.verify({
-    name: "ECDSA",
+    name: algorithm.name,
     hash: "SHA-256"
   }, publicKey, signature, message);
 };
+var ed25519Signature = async (secretKey, message) => {
+  const curve = "Ed25519";
+  const privateKeyJwk = {
+    kty: "OKP",
+    crv: curve,
+    x: Buffer.from(secretKey.subarray(32)).toString("base64url"),
+    d: Buffer.from(secretKey.subarray(0, 32)).toString("base64url")
+  };
+  const key = await subtleCrypto.importKey("jwk", privateKeyJwk, {
+    name: curve
+  }, true, [
+    "sign"
+  ]);
+  return new Uint8Array(await subtleCrypto.sign({
+    name: curve,
+    hash: "SHA-256"
+  }, key, message));
+};
 
 // packages/common/crypto/src/uuid.ts
 var randomUUID = () => {
@@ -124,6 +142,7 @@ export {
   createId,
   createKeyPair,
   discoveryKey,
+  ed25519Signature,
   getSignatureValidator,
   randomBytes,
   randomUUID,

package/dist/lib/browser/index.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/keys.ts", "../../../src/browser/subtle.ts", "../../../src/validator.ts", "../../../src/verify.ts", "../../../src/uuid.ts"],
-  "sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { invariant } from '@dxos/invariant';\nimport { type KeyPair, PublicKey, type PublicKeyLike, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH } from '@dxos/keys';\n\nimport crypto from '#hypercore-crypto';\n\nexport const SIGNATURE_LENGTH = 64;\n\n/**\n * @deprecated\n */\n// TODO(burdon): Remove.\nexport const createId = (): string => PublicKey.stringify(randomBytes(32));\n\nexport const createKeyPair = (seed?: Buffer): KeyPair => {\n  if (seed) {\n    invariant(seed.length >= 32, 'Seedphrase too sort. Expecting length of 32.');\n    return crypto.keyPair(seed.slice(0, 32));\n  }\n\n  // TODO(burdon): Enable seed for debugging.\n  return crypto.keyPair();\n};\n\n// TODO(burdon): Buffer.\nexport const validateKeyPair = (publicKey: PublicKey, secretKey: Buffer) =>\n  crypto.validateKeyPair({ publicKey: publicKey.asBuffer(), secretKey });\n\n// TODO(dmaretskyi): Slicing because webcrypto keys are too long.\nexport const discoveryKey = (key: PublicKeyLike): Buffer =>\n  crypto.discoveryKey(PublicKey.from(key).asBuffer().slice(1));\n\n/**\n * Return random bytes of length.\n * @param [length=32]\n * @return {Buffer}\n */\nexport const randomBytes = (length = 32): Buffer => crypto.randomBytes(length);\n\n/**\n * Sign the contents of message with secret_key\n * @param {Buffer} message\n * @param {Buffer} secretKey\n * @returns {Buffer} signature\n */\nexport const sign = (message: Buffer, secretKey: Buffer): Buffer => {\n  invariant(Buffer.isBuffer(message));\n  invariant(Buffer.isBuffer(secretKey) && secretKey.length === SECRET_KEY_LENGTH);\n\n  return crypto.sign(message, secretKey);\n};\n\n/**\n * Verifies the signature against the message and public_key.\n * @param {Buffer} message\n * @param {Buffer} publicKey\n * @param {Buffer} signature\n * @return {boolean}\n */\nexport const verify = (message: Buffer, signature: Buffer, publicKey: Buffer): boolean => {\n  invariant(Buffer.isBuffer(message));\n  invariant(Buffer.isBuffer(signature) && signature.length === SIGNATURE_LENGTH);\n  invariant(Buffer.isBuffer(publicKey) && publicKey.length === PUBLIC_KEY_LENGTH);\n\n  return crypto.verify(message, signature, publicKey);\n};\n", "//\n// Copyright 2022 DXOS.org\n//\n\n// Replacement implementation for the browser (see package.json).\n\nexport const subtleCrypto = crypto.subtle;\n\nexport const webcrypto = crypto;\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport { PublicKey } from '@dxos/keys';\n\nimport { verify } from '#hypercore-crypto';\n\n/**\n * Generator for signature validation function.\n * @param {String} publicKey\n */\nexport const getSignatureValidator = (publicKey: string) => (message: Buffer, signature: Buffer) =>\n  verify(message, signature, PublicKey.bufferize(publicKey));\n", "//\n// Copyright 2022 DXOS.org\n//\n\nimport { type PublicKey } from '@dxos/keys';\n\nimport { subtleCrypto } from './subtle';\n\n/**\n * Verify a signature with the given key.\n */\nexport const verifySignature = async (key: PublicKey, message: Uint8Array, signature: Uint8Array): Promise<boolean> => {\n  let publicKey!: CryptoKey;\n\n  try {\n    publicKey = await subtleCrypto.importKey(\n      'raw',\n      key.asUint8Array(),\n      {\n        name: 'ECDSA',\n        namedCurve: 'P-256',\n      },\n      true,\n      ['verify'],\n    );\n  } catch {\n    return false;\n  }\n\n  return subtleCrypto.verify(\n    {\n      name: 'ECDSA',\n      hash: 'SHA-256',\n    },\n    publicKey,\n    signature,\n    message,\n  );\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { webcrypto } from './subtle';\n\nexport const randomUUID = (): string => {\n  return webcrypto.randomUUID();\n};\n"],
-  "mappings": ";;;;;;;;;;AAIA,SAASA,iBAAiB;AAC1B,SAAuBC,WAA+BC,mBAAmBC,yBAAyB;AAElG,OAAOC,aAAY;;AAEZ,IAAMC,mBAAmB;AAMzB,IAAMC,WAAW,MAAcL,UAAUM,UAAUC,YAAY,EAAA,CAAA;AAE/D,IAAMC,gBAAgB,CAACC,SAAAA;AAC5B,MAAIA,MAAM;AACRV,cAAUU,KAAKC,UAAU,IAAI,gDAAA;;;;;;;;;AAC7B,WAAOP,QAAOQ,QAAQF,KAAKG,MAAM,GAAG,EAAA,CAAA;EACtC;AAGA,SAAOT,QAAOQ,QAAO;AACvB;AAGO,IAAME,kBAAkB,CAACC,WAAsBC,cACpDZ,QAAOU,gBAAgB;EAAEC,WAAWA,UAAUE,SAAQ;EAAID;AAAU,CAAA;AAG/D,IAAME,eAAe,CAACC,QAC3Bf,QAAOc,aAAajB,UAAUmB,KAAKD,GAAAA,EAAKF,SAAQ,EAAGJ,MAAM,CAAA,CAAA;AAOpD,IAAML,cAAc,CAACG,SAAS,OAAeP,QAAOI,YAAYG,MAAAA;AAQhE,IAAMU,OAAO,CAACC,SAAiBN,cAAAA;AACpChB,YAAUuB,OAAOC,SAASF,OAAAA,GAAAA,QAAAA;;;;;;;;;AAC1BtB,YAAUuB,OAAOC,SAASR,SAAAA,KAAcA,UAAUL,WAAWR,mBAAAA,QAAAA;;;;;;;;;AAE7D,SAAOC,QAAOiB,KAAKC,SAASN,SAAAA;AAC9B;AASO,IAAMS,SAAS,CAACH,SAAiBI,WAAmBX,cAAAA;AACzDf,YAAUuB,OAAOC,SAASF,OAAAA,GAAAA,QAAAA;;;;;;;;;AAC1BtB,YAAUuB,OAAOC,SAASE,SAAAA,KAAcA,UAAUf,WAAWN,kBAAAA,QAAAA;;;;;;;;;AAC7DL,YAAUuB,OAAOC,SAAST,SAAAA,KAAcA,UAAUJ,WAAWT,mBAAAA,QAAAA;;;;;;;;;AAE7D,SAAOE,QAAOqB,OAAOH,SAASI,WAAWX,SAAAA;AAC3C;;;AC9DO,IAAMY,eAAeC,OAAOC;AAE5B,IAAMC,YAAYF;;;ACJzB,SAASG,aAAAA,kBAAiB;AAE1B,SAASC,UAAAA,eAAc;AAMhB,IAAMC,wBAAwB,CAACC,cAAsB,CAACC,SAAiBC,cAC5EC,QAAOF,SAASC,WAAWE,WAAUC,UAAUL,SAAAA,CAAAA;;;ACF1C,IAAMM,kBAAkB,OAAOC,KAAgBC,SAAqBC,cAAAA;AACzE,MAAIC;AAEJ,MAAI;AACFA,gBAAY,MAAMC,aAAaC,UAC7B,OACAL,IAAIM,aAAY,GAChB;MACEC,MAAM;MACNC,YAAY;IACd,GACA,MACA;MAAC;KAAS;EAEd,QAAQ;AACN,WAAO;EACT;AAEA,SAAOJ,aAAaK,OAClB;IACEF,MAAM;IACNG,MAAM;EACR,GACAP,WACAD,WACAD,OAAAA;AAEJ;;;AChCO,IAAMU,aAAa,MAAA;AACxB,SAAOC,UAAUD,WAAU;AAC7B;",
-  "names": ["invariant", "PublicKey", "PUBLIC_KEY_LENGTH", "SECRET_KEY_LENGTH", "crypto", "SIGNATURE_LENGTH", "createId", "stringify", "randomBytes", "createKeyPair", "seed", "length", "keyPair", "slice", "validateKeyPair", "publicKey", "secretKey", "asBuffer", "discoveryKey", "key", "from", "sign", "message", "Buffer", "isBuffer", "verify", "signature", "subtleCrypto", "crypto", "subtle", "webcrypto", "PublicKey", "verify", "getSignatureValidator", "publicKey", "message", "signature", "verify", "PublicKey", "bufferize", "verifySignature", "key", "message", "signature", "publicKey", "subtleCrypto", "importKey", "asUint8Array", "name", "namedCurve", "verify", "hash", "randomUUID", "webcrypto"]
+  "sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { invariant } from '@dxos/invariant';\nimport { type KeyPair, PublicKey, type PublicKeyLike, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH } from '@dxos/keys';\n\nimport crypto from '#hypercore-crypto';\n\nexport const SIGNATURE_LENGTH = 64;\n\n/**\n * @deprecated\n */\n// TODO(burdon): Remove.\nexport const createId = (): string => PublicKey.stringify(randomBytes(32));\n\nexport const createKeyPair = (seed?: Buffer): KeyPair => {\n  if (seed) {\n    invariant(seed.length >= 32, 'Seedphrase too sort. Expecting length of 32.');\n    return crypto.keyPair(seed.slice(0, 32));\n  }\n\n  // TODO(burdon): Enable seed for debugging.\n  return crypto.keyPair();\n};\n\n// TODO(burdon): Buffer.\nexport const validateKeyPair = (publicKey: PublicKey, secretKey: Buffer) =>\n  crypto.validateKeyPair({ publicKey: publicKey.asBuffer(), secretKey });\n\n// TODO(dmaretskyi): Slicing because webcrypto keys are too long.\nexport const discoveryKey = (key: PublicKeyLike): Buffer =>\n  crypto.discoveryKey(PublicKey.from(key).asBuffer().slice(1));\n\n/**\n * Return random bytes of length.\n * @param [length=32]\n * @return {Buffer}\n */\nexport const randomBytes = (length = 32): Buffer => crypto.randomBytes(length);\n\n/**\n * Sign the contents of message with secret_key\n * @param {Buffer} message\n * @param {Buffer} secretKey\n * @returns {Buffer} signature\n */\nexport const sign = (message: Buffer, secretKey: Buffer): Buffer => {\n  invariant(Buffer.isBuffer(message));\n  invariant(Buffer.isBuffer(secretKey) && secretKey.length === SECRET_KEY_LENGTH);\n\n  return crypto.sign(message, secretKey);\n};\n\n/**\n * Verifies the signature against the message and public_key.\n * @param {Buffer} message\n * @param {Buffer} publicKey\n * @param {Buffer} signature\n * @return {boolean}\n */\nexport const verify = (message: Buffer, signature: Buffer, publicKey: Buffer): boolean => {\n  invariant(Buffer.isBuffer(message));\n  invariant(Buffer.isBuffer(signature) && signature.length === SIGNATURE_LENGTH);\n  invariant(Buffer.isBuffer(publicKey) && publicKey.length === PUBLIC_KEY_LENGTH);\n\n  return crypto.verify(message, signature, publicKey);\n};\n", "//\n// Copyright 2022 DXOS.org\n//\n\n// Replacement implementation for the browser (see package.json).\n\nexport const subtleCrypto = crypto.subtle;\n\nexport const webcrypto = crypto;\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport { PublicKey } from '@dxos/keys';\n\nimport { verify } from '#hypercore-crypto';\n\n/**\n * Generator for signature validation function.\n * @param {String} publicKey\n */\nexport const getSignatureValidator = (publicKey: string) => (message: Buffer, signature: Buffer) =>\n  verify(message, signature, PublicKey.bufferize(publicKey));\n", "//\n// Copyright 2022 DXOS.org\n//\n\nimport { type PublicKey } from '@dxos/keys';\n\nimport { subtleCrypto } from './subtle';\n\n/**\n * Verify a signature with the given key.\n */\nexport const verifySignature = async (\n  key: PublicKey,\n  message: Uint8Array,\n  signature: Uint8Array,\n  algorithm: { name: string; namedCurve?: string } = { name: 'ECDSA', namedCurve: 'P-256' },\n): Promise<boolean> => {\n  let publicKey!: CryptoKey;\n\n  try {\n    publicKey = await subtleCrypto.importKey('raw', key.asUint8Array(), algorithm, true, ['verify']);\n  } catch {\n    return false;\n  }\n\n  return subtleCrypto.verify(\n    {\n      name: algorithm.name,\n      hash: 'SHA-256',\n    },\n    publicKey,\n    signature,\n    message,\n  );\n};\n\n/**\n * Creates an Ed25519 (libsodium keypair format) signature.\n */\nexport const ed25519Signature = async (secretKey: Uint8Array, message: Uint8Array): Promise<Uint8Array> => {\n  const curve = 'Ed25519';\n  const privateKeyJwk = {\n    kty: 'OKP',\n    crv: curve,\n    x: Buffer.from(secretKey.subarray(32)).toString('base64url'),\n    d: Buffer.from(secretKey.subarray(0, 32)).toString('base64url'),\n  };\n  const key = await subtleCrypto.importKey('jwk', privateKeyJwk, { name: curve }, true, ['sign']);\n  return new Uint8Array(await subtleCrypto.sign({ name: curve, hash: 'SHA-256' }, key, message));\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { webcrypto } from './subtle';\n\nexport const randomUUID = (): string => {\n  return webcrypto.randomUUID();\n};\n"],
+  "mappings": ";;;;;;;;;;AAIA,SAASA,iBAAiB;AAC1B,SAAuBC,WAA+BC,mBAAmBC,yBAAyB;AAElG,OAAOC,aAAY;;AAEZ,IAAMC,mBAAmB;AAMzB,IAAMC,WAAW,MAAcL,UAAUM,UAAUC,YAAY,EAAA,CAAA;AAE/D,IAAMC,gBAAgB,CAACC,SAAAA;AAC5B,MAAIA,MAAM;AACRV,cAAUU,KAAKC,UAAU,IAAI,gDAAA;;;;;;;;;AAC7B,WAAOP,QAAOQ,QAAQF,KAAKG,MAAM,GAAG,EAAA,CAAA;EACtC;AAGA,SAAOT,QAAOQ,QAAO;AACvB;AAGO,IAAME,kBAAkB,CAACC,WAAsBC,cACpDZ,QAAOU,gBAAgB;EAAEC,WAAWA,UAAUE,SAAQ;EAAID;AAAU,CAAA;AAG/D,IAAME,eAAe,CAACC,QAC3Bf,QAAOc,aAAajB,UAAUmB,KAAKD,GAAAA,EAAKF,SAAQ,EAAGJ,MAAM,CAAA,CAAA;AAOpD,IAAML,cAAc,CAACG,SAAS,OAAeP,QAAOI,YAAYG,MAAAA;AAQhE,IAAMU,OAAO,CAACC,SAAiBN,cAAAA;AACpChB,YAAUuB,OAAOC,SAASF,OAAAA,GAAAA,QAAAA;;;;;;;;;AAC1BtB,YAAUuB,OAAOC,SAASR,SAAAA,KAAcA,UAAUL,WAAWR,mBAAAA,QAAAA;;;;;;;;;AAE7D,SAAOC,QAAOiB,KAAKC,SAASN,SAAAA;AAC9B;AASO,IAAMS,SAAS,CAACH,SAAiBI,WAAmBX,cAAAA;AACzDf,YAAUuB,OAAOC,SAASF,OAAAA,GAAAA,QAAAA;;;;;;;;;AAC1BtB,YAAUuB,OAAOC,SAASE,SAAAA,KAAcA,UAAUf,WAAWN,kBAAAA,QAAAA;;;;;;;;;AAC7DL,YAAUuB,OAAOC,SAAST,SAAAA,KAAcA,UAAUJ,WAAWT,mBAAAA,QAAAA;;;;;;;;;AAE7D,SAAOE,QAAOqB,OAAOH,SAASI,WAAWX,SAAAA;AAC3C;;;AC9DO,IAAMY,eAAeC,OAAOC;AAE5B,IAAMC,YAAYF;;;ACJzB,SAASG,aAAAA,kBAAiB;AAE1B,SAASC,UAAAA,eAAc;AAMhB,IAAMC,wBAAwB,CAACC,cAAsB,CAACC,SAAiBC,cAC5EC,QAAOF,SAASC,WAAWE,WAAUC,UAAUL,SAAAA,CAAAA;;;ACF1C,IAAMM,kBAAkB,OAC7BC,KACAC,SACAC,WACAC,YAAmD;EAAEC,MAAM;EAASC,YAAY;AAAQ,MAAC;AAEzF,MAAIC;AAEJ,MAAI;AACFA,gBAAY,MAAMC,aAAaC,UAAU,OAAOR,IAAIS,aAAY,GAAIN,WAAW,MAAM;MAAC;KAAS;EACjG,QAAQ;AACN,WAAO;EACT;AAEA,SAAOI,aAAaG,OAClB;IACEN,MAAMD,UAAUC;IAChBO,MAAM;EACR,GACAL,WACAJ,WACAD,OAAAA;AAEJ;AAKO,IAAMW,mBAAmB,OAAOC,WAAuBZ,YAAAA;AAC5D,QAAMa,QAAQ;AACd,QAAMC,gBAAgB;IACpBC,KAAK;IACLC,KAAKH;IACLI,GAAGC,OAAOC,KAAKP,UAAUQ,SAAS,EAAA,CAAA,EAAKC,SAAS,WAAA;IAChDC,GAAGJ,OAAOC,KAAKP,UAAUQ,SAAS,GAAG,EAAA,CAAA,EAAKC,SAAS,WAAA;EACrD;AACA,QAAMtB,MAAM,MAAMO,aAAaC,UAAU,OAAOO,eAAe;IAAEX,MAAMU;EAAM,GAAG,MAAM;IAAC;GAAO;AAC9F,SAAO,IAAIU,WAAW,MAAMjB,aAAakB,KAAK;IAAErB,MAAMU;IAAOH,MAAM;EAAU,GAAGX,KAAKC,OAAAA,CAAAA;AACvF;;;AC3CO,IAAMyB,aAAa,MAAA;AACxB,SAAOC,UAAUD,WAAU;AAC7B;",
+  "names": ["invariant", "PublicKey", "PUBLIC_KEY_LENGTH", "SECRET_KEY_LENGTH", "crypto", "SIGNATURE_LENGTH", "createId", "stringify", "randomBytes", "createKeyPair", "seed", "length", "keyPair", "slice", "validateKeyPair", "publicKey", "secretKey", "asBuffer", "discoveryKey", "key", "from", "sign", "message", "Buffer", "isBuffer", "verify", "signature", "subtleCrypto", "crypto", "subtle", "webcrypto", "PublicKey", "verify", "getSignatureValidator", "publicKey", "message", "signature", "verify", "PublicKey", "bufferize", "verifySignature", "key", "message", "signature", "algorithm", "name", "namedCurve", "publicKey", "subtleCrypto", "importKey", "asUint8Array", "verify", "hash", "ed25519Signature", "secretKey", "curve", "privateKeyJwk", "kty", "crv", "x", "Buffer", "from", "subarray", "toString", "d", "Uint8Array", "sign", "randomUUID", "webcrypto"]
 }

package/dist/lib/browser/meta.json

@@ -1 +1 @@
-{"inputs":{"inject-globals:@inject-globals":{"bytes":384,"imports":[{"path":"@dxos/node-std/inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/keys.ts":{"bytes":8453,"imports":[{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true},{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/signer.ts":{"bytes":810,"imports":[{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/browser/subtle.ts":{"bytes":925,"imports":[{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/validator.ts":{"bytes":1519,"imports":[{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true},{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/verify.ts":{"bytes":2511,"imports":[{"path":"packages/common/crypto/src/browser/subtle.ts","kind":"import-statement","original":"./subtle"},{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/uuid.ts":{"bytes":821,"imports":[{"path":"packages/common/crypto/src/browser/subtle.ts","kind":"import-statement","original":"./subtle"},{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/index.ts":{"bytes":909,"imports":[{"path":"packages/common/crypto/src/keys.ts","kind":"import-statement","original":"./keys"},{"path":"packages/common/crypto/src/signer.ts","kind":"import-statement","original":"./signer"},{"path":"packages/common/crypto/src/browser/subtle.ts","kind":"import-statement","original":"./subtle"},{"path":"packages/common/crypto/src/validator.ts","kind":"import-statement","original":"./validator"},{"path":"packages/common/crypto/src/verify.ts","kind":"import-statement","original":"./verify"},{"path":"packages/common/crypto/src/uuid.ts","kind":"import-statement","original":"./uuid"},{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"}},"outputs":{"packages/common/crypto/dist/lib/browser/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":6150},"packages/common/crypto/dist/lib/browser/index.mjs":{"imports":[{"path":"@dxos/node-std/inject-globals","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"exports":["SIGNATURE_LENGTH","createId","createKeyPair","discoveryKey","getSignatureValidator","randomBytes","randomUUID","sign","subtleCrypto","validateKeyPair","verify","verifySignature","webcrypto"],"entryPoint":"packages/common/crypto/src/index.ts","inputs":{"inject-globals:@inject-globals":{"bytesInOutput":79},"packages/common/crypto/src/keys.ts":{"bytesInOutput":2241},"packages/common/crypto/src/index.ts":{"bytesInOutput":0},"packages/common/crypto/src/browser/subtle.ts":{"bytesInOutput":58},"packages/common/crypto/src/validator.ts":{"bytesInOutput":238},"packages/common/crypto/src/verify.ts":{"bytesInOutput":387},"packages/common/crypto/src/uuid.ts":{"bytesInOutput":61}},"bytes":3594}}}
+{"inputs":{"inject-globals:@inject-globals":{"bytes":324,"imports":[{"path":"@dxos/node-std/inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/keys.ts":{"bytes":8453,"imports":[{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true},{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/signer.ts":{"bytes":810,"imports":[{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/browser/subtle.ts":{"bytes":925,"imports":[{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/validator.ts":{"bytes":1519,"imports":[{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true},{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/verify.ts":{"bytes":4811,"imports":[{"path":"packages/common/crypto/src/browser/subtle.ts","kind":"import-statement","original":"./subtle"},{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/uuid.ts":{"bytes":821,"imports":[{"path":"packages/common/crypto/src/browser/subtle.ts","kind":"import-statement","original":"./subtle"},{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/index.ts":{"bytes":909,"imports":[{"path":"packages/common/crypto/src/keys.ts","kind":"import-statement","original":"./keys"},{"path":"packages/common/crypto/src/signer.ts","kind":"import-statement","original":"./signer"},{"path":"packages/common/crypto/src/browser/subtle.ts","kind":"import-statement","original":"./subtle"},{"path":"packages/common/crypto/src/validator.ts","kind":"import-statement","original":"./validator"},{"path":"packages/common/crypto/src/verify.ts","kind":"import-statement","original":"./verify"},{"path":"packages/common/crypto/src/uuid.ts","kind":"import-statement","original":"./uuid"},{"path":"@inject-globals","kind":"import-statement","external":true}],"format":"esm"}},"outputs":{"packages/common/crypto/dist/lib/browser/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":7375},"packages/common/crypto/dist/lib/browser/index.mjs":{"imports":[{"path":"@dxos/node-std/inject-globals","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"exports":["SIGNATURE_LENGTH","createId","createKeyPair","discoveryKey","ed25519Signature","getSignatureValidator","randomBytes","randomUUID","sign","subtleCrypto","validateKeyPair","verify","verifySignature","webcrypto"],"entryPoint":"packages/common/crypto/src/index.ts","inputs":{"inject-globals:@inject-globals":{"bytesInOutput":79},"packages/common/crypto/src/keys.ts":{"bytesInOutput":2241},"packages/common/crypto/src/index.ts":{"bytesInOutput":0},"packages/common/crypto/src/browser/subtle.ts":{"bytesInOutput":58},"packages/common/crypto/src/validator.ts":{"bytesInOutput":238},"packages/common/crypto/src/verify.ts":{"bytesInOutput":908},"packages/common/crypto/src/uuid.ts":{"bytesInOutput":61}},"bytes":4135}}}

package/dist/lib/node/index.cjs

@@ -32,6 +32,7 @@ __export(node_exports, {
   createId: () => createId,
   createKeyPair: () => createKeyPair,
   discoveryKey: () => discoveryKey,
+  ed25519Signature: () => ed25519Signature,
   getSignatureValidator: () => getSignatureValidator,
   randomBytes: () => randomBytes,
   randomUUID: () => randomUUID,
@@ -127,23 +128,41 @@ var verify = (message, signature, publicKey) => {
 var subtleCrypto = nodeCrypto.webcrypto.subtle;
 var webcrypto2 = nodeCrypto.webcrypto;
 var getSignatureValidator = (publicKey) => (message, signature) => (0, import_hypercore_crypto2.verify)(message, signature, import_keys2.PublicKey.bufferize(publicKey));
-var verifySignature = async (key, message, signature) => {
+var verifySignature = async (key, message, signature, algorithm = {
+  name: "ECDSA",
+  namedCurve: "P-256"
+}) => {
   let publicKey;
   try {
-    publicKey = await subtleCrypto.importKey("raw", key.asUint8Array(), {
-      name: "ECDSA",
-      namedCurve: "P-256"
-    }, true, [
+    publicKey = await subtleCrypto.importKey("raw", key.asUint8Array(), algorithm, true, [
       "verify"
     ]);
   } catch {
     return false;
   }
   return subtleCrypto.verify({
-    name: "ECDSA",
+    name: algorithm.name,
     hash: "SHA-256"
   }, publicKey, signature, message);
 };
+var ed25519Signature = async (secretKey, message) => {
+  const curve = "Ed25519";
+  const privateKeyJwk = {
+    kty: "OKP",
+    crv: curve,
+    x: Buffer.from(secretKey.subarray(32)).toString("base64url"),
+    d: Buffer.from(secretKey.subarray(0, 32)).toString("base64url")
+  };
+  const key = await subtleCrypto.importKey("jwk", privateKeyJwk, {
+    name: curve
+  }, true, [
+    "sign"
+  ]);
+  return new Uint8Array(await subtleCrypto.sign({
+    name: curve,
+    hash: "SHA-256"
+  }, key, message));
+};
 var randomUUID = () => {
   return webcrypto2.randomUUID();
 };
@@ -153,6 +172,7 @@ var randomUUID = () => {
   createId,
   createKeyPair,
   discoveryKey,
+  ed25519Signature,
   getSignatureValidator,
   randomBytes,
   randomUUID,

package/dist/lib/node/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/keys.ts", "../../../src/subtle.ts", "../../../src/validator.ts", "../../../src/verify.ts", "../../../src/uuid.ts"],
-  "sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { invariant } from '@dxos/invariant';\nimport { type KeyPair, PublicKey, type PublicKeyLike, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH } from '@dxos/keys';\n\nimport crypto from '#hypercore-crypto';\n\nexport const SIGNATURE_LENGTH = 64;\n\n/**\n * @deprecated\n */\n// TODO(burdon): Remove.\nexport const createId = (): string => PublicKey.stringify(randomBytes(32));\n\nexport const createKeyPair = (seed?: Buffer): KeyPair => {\n  if (seed) {\n    invariant(seed.length >= 32, 'Seedphrase too sort. Expecting length of 32.');\n    return crypto.keyPair(seed.slice(0, 32));\n  }\n\n  // TODO(burdon): Enable seed for debugging.\n  return crypto.keyPair();\n};\n\n// TODO(burdon): Buffer.\nexport const validateKeyPair = (publicKey: PublicKey, secretKey: Buffer) =>\n  crypto.validateKeyPair({ publicKey: publicKey.asBuffer(), secretKey });\n\n// TODO(dmaretskyi): Slicing because webcrypto keys are too long.\nexport const discoveryKey = (key: PublicKeyLike): Buffer =>\n  crypto.discoveryKey(PublicKey.from(key).asBuffer().slice(1));\n\n/**\n * Return random bytes of length.\n * @param [length=32]\n * @return {Buffer}\n */\nexport const randomBytes = (length = 32): Buffer => crypto.randomBytes(length);\n\n/**\n * Sign the contents of message with secret_key\n * @param {Buffer} message\n * @param {Buffer} secretKey\n * @returns {Buffer} signature\n */\nexport const sign = (message: Buffer, secretKey: Buffer): Buffer => {\n  invariant(Buffer.isBuffer(message));\n  invariant(Buffer.isBuffer(secretKey) && secretKey.length === SECRET_KEY_LENGTH);\n\n  return crypto.sign(message, secretKey);\n};\n\n/**\n * Verifies the signature against the message and public_key.\n * @param {Buffer} message\n * @param {Buffer} publicKey\n * @param {Buffer} signature\n * @return {boolean}\n */\nexport const verify = (message: Buffer, signature: Buffer, publicKey: Buffer): boolean => {\n  invariant(Buffer.isBuffer(message));\n  invariant(Buffer.isBuffer(signature) && signature.length === SIGNATURE_LENGTH);\n  invariant(Buffer.isBuffer(publicKey) && publicKey.length === PUBLIC_KEY_LENGTH);\n\n  return crypto.verify(message, signature, publicKey);\n};\n", "//\n// Copyright 2022 DXOS.org\n//\n\nimport * as nodeCrypto from 'node:crypto';\n\nexport const subtleCrypto = nodeCrypto.webcrypto.subtle;\n\nexport const webcrypto = nodeCrypto.webcrypto;\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport { PublicKey } from '@dxos/keys';\n\nimport { verify } from '#hypercore-crypto';\n\n/**\n * Generator for signature validation function.\n * @param {String} publicKey\n */\nexport const getSignatureValidator = (publicKey: string) => (message: Buffer, signature: Buffer) =>\n  verify(message, signature, PublicKey.bufferize(publicKey));\n", "//\n// Copyright 2022 DXOS.org\n//\n\nimport { type PublicKey } from '@dxos/keys';\n\nimport { subtleCrypto } from './subtle';\n\n/**\n * Verify a signature with the given key.\n */\nexport const verifySignature = async (key: PublicKey, message: Uint8Array, signature: Uint8Array): Promise<boolean> => {\n  let publicKey!: CryptoKey;\n\n  try {\n    publicKey = await subtleCrypto.importKey(\n      'raw',\n      key.asUint8Array(),\n      {\n        name: 'ECDSA',\n        namedCurve: 'P-256',\n      },\n      true,\n      ['verify'],\n    );\n  } catch {\n    return false;\n  }\n\n  return subtleCrypto.verify(\n    {\n      name: 'ECDSA',\n      hash: 'SHA-256',\n    },\n    publicKey,\n    signature,\n    message,\n  );\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { webcrypto } from './subtle';\n\nexport const randomUUID = (): string => {\n  return webcrypto.randomUUID();\n};\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,uBAA0B;AAC1B,kBAAkG;AAElG,8BAAmB;ACHnB,iBAA4B;ACA5B,IAAAA,eAA0B;AAE1B,IAAAC,2BAAuB;;AFGhB,IAAMC,mBAAmB;AAMzB,IAAMC,WAAW,MAAcC,sBAAUC,UAAUC,YAAY,EAAA,CAAA;AAE/D,IAAMC,gBAAgB,CAACC,SAAAA;AAC5B,MAAIA,MAAM;AACRC,oCAAUD,KAAKE,UAAU,IAAI,gDAAA;;;;;;;;;AAC7B,WAAOC,wBAAAA,QAAOC,QAAQJ,KAAKK,MAAM,GAAG,EAAA,CAAA;EACtC;AAGA,SAAOF,wBAAAA,QAAOC,QAAO;AACvB;AAGO,IAAME,kBAAkB,CAACC,WAAsBC,cACpDL,wBAAAA,QAAOG,gBAAgB;EAAEC,WAAWA,UAAUE,SAAQ;EAAID;AAAU,CAAA;AAG/D,IAAME,eAAe,CAACC,QAC3BR,wBAAAA,QAAOO,aAAad,sBAAUgB,KAAKD,GAAAA,EAAKF,SAAQ,EAAGJ,MAAM,CAAA,CAAA;AAOpD,IAAMP,cAAc,CAACI,SAAS,OAAeC,wBAAAA,QAAOL,YAAYI,MAAAA;AAQhE,IAAMW,OAAO,CAACC,SAAiBN,cAAAA;AACpCP,kCAAUc,OAAOC,SAASF,OAAAA,GAAAA,QAAAA;;;;;;;;;AAC1Bb,kCAAUc,OAAOC,SAASR,SAAAA,KAAcA,UAAUN,WAAWe,+BAAAA,QAAAA;;;;;;;;;AAE7D,SAAOd,wBAAAA,QAAOU,KAAKC,SAASN,SAAAA;AAC9B;AASO,IAAMU,SAAS,CAACJ,SAAiBK,WAAmBZ,cAAAA;AACzDN,kCAAUc,OAAOC,SAASF,OAAAA,GAAAA,QAAAA;;;;;;;;;AAC1Bb,kCAAUc,OAAOC,SAASG,SAAAA,KAAcA,UAAUjB,WAAWR,kBAAAA,QAAAA;;;;;;;;;AAC7DO,kCAAUc,OAAOC,SAAST,SAAAA,KAAcA,UAAUL,WAAWkB,+BAAAA,QAAAA;;;;;;;;;AAE7D,SAAOjB,wBAAAA,QAAOe,OAAOJ,SAASK,WAAWZ,SAAAA;AAC3C;AC9DO,IAAMc,eAA0BC,WAAAA,UAAUC;AAE1C,IAAMD,aAAuBA,WAAAA;ACI7B,IAAME,wBAAwB,CAACjB,cAAsB,CAACO,SAAiBK,kBAC5ED,yBAAAA,QAAOJ,SAASK,WAAWvB,aAAAA,UAAU6B,UAAUlB,SAAAA,CAAAA;ACF1C,IAAMmB,kBAAkB,OAAOf,KAAgBG,SAAqBK,cAAAA;AACzE,MAAIZ;AAEJ,MAAI;AACFA,gBAAY,MAAMc,aAAaM,UAC7B,OACAhB,IAAIiB,aAAY,GAChB;MACEC,MAAM;MACNC,YAAY;IACd,GACA,MACA;MAAC;KAAS;EAEd,QAAQ;AACN,WAAO;EACT;AAEA,SAAOT,aAAaH,OAClB;IACEW,MAAM;IACNE,MAAM;EACR,GACAxB,WACAY,WACAL,OAAAA;AAEJ;AChCO,IAAMkB,aAAa,MAAA;AACxB,SAAOV,WAAUU,WAAU;AAC7B;",
-  "names": ["import_keys", "import_hypercore_crypto", "SIGNATURE_LENGTH", "createId", "PublicKey", "stringify", "randomBytes", "createKeyPair", "seed", "invariant", "length", "crypto", "keyPair", "slice", "validateKeyPair", "publicKey", "secretKey", "asBuffer", "discoveryKey", "key", "from", "sign", "message", "Buffer", "isBuffer", "SECRET_KEY_LENGTH", "verify", "signature", "PUBLIC_KEY_LENGTH", "subtleCrypto", "webcrypto", "subtle", "getSignatureValidator", "bufferize", "verifySignature", "importKey", "asUint8Array", "name", "namedCurve", "hash", "randomUUID"]
+  "sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { invariant } from '@dxos/invariant';\nimport { type KeyPair, PublicKey, type PublicKeyLike, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH } from '@dxos/keys';\n\nimport crypto from '#hypercore-crypto';\n\nexport const SIGNATURE_LENGTH = 64;\n\n/**\n * @deprecated\n */\n// TODO(burdon): Remove.\nexport const createId = (): string => PublicKey.stringify(randomBytes(32));\n\nexport const createKeyPair = (seed?: Buffer): KeyPair => {\n  if (seed) {\n    invariant(seed.length >= 32, 'Seedphrase too sort. Expecting length of 32.');\n    return crypto.keyPair(seed.slice(0, 32));\n  }\n\n  // TODO(burdon): Enable seed for debugging.\n  return crypto.keyPair();\n};\n\n// TODO(burdon): Buffer.\nexport const validateKeyPair = (publicKey: PublicKey, secretKey: Buffer) =>\n  crypto.validateKeyPair({ publicKey: publicKey.asBuffer(), secretKey });\n\n// TODO(dmaretskyi): Slicing because webcrypto keys are too long.\nexport const discoveryKey = (key: PublicKeyLike): Buffer =>\n  crypto.discoveryKey(PublicKey.from(key).asBuffer().slice(1));\n\n/**\n * Return random bytes of length.\n * @param [length=32]\n * @return {Buffer}\n */\nexport const randomBytes = (length = 32): Buffer => crypto.randomBytes(length);\n\n/**\n * Sign the contents of message with secret_key\n * @param {Buffer} message\n * @param {Buffer} secretKey\n * @returns {Buffer} signature\n */\nexport const sign = (message: Buffer, secretKey: Buffer): Buffer => {\n  invariant(Buffer.isBuffer(message));\n  invariant(Buffer.isBuffer(secretKey) && secretKey.length === SECRET_KEY_LENGTH);\n\n  return crypto.sign(message, secretKey);\n};\n\n/**\n * Verifies the signature against the message and public_key.\n * @param {Buffer} message\n * @param {Buffer} publicKey\n * @param {Buffer} signature\n * @return {boolean}\n */\nexport const verify = (message: Buffer, signature: Buffer, publicKey: Buffer): boolean => {\n  invariant(Buffer.isBuffer(message));\n  invariant(Buffer.isBuffer(signature) && signature.length === SIGNATURE_LENGTH);\n  invariant(Buffer.isBuffer(publicKey) && publicKey.length === PUBLIC_KEY_LENGTH);\n\n  return crypto.verify(message, signature, publicKey);\n};\n", "//\n// Copyright 2022 DXOS.org\n//\n\nimport * as nodeCrypto from 'node:crypto';\n\nexport const subtleCrypto = nodeCrypto.webcrypto.subtle;\n\nexport const webcrypto = nodeCrypto.webcrypto;\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport { PublicKey } from '@dxos/keys';\n\nimport { verify } from '#hypercore-crypto';\n\n/**\n * Generator for signature validation function.\n * @param {String} publicKey\n */\nexport const getSignatureValidator = (publicKey: string) => (message: Buffer, signature: Buffer) =>\n  verify(message, signature, PublicKey.bufferize(publicKey));\n", "//\n// Copyright 2022 DXOS.org\n//\n\nimport { type PublicKey } from '@dxos/keys';\n\nimport { subtleCrypto } from './subtle';\n\n/**\n * Verify a signature with the given key.\n */\nexport const verifySignature = async (\n  key: PublicKey,\n  message: Uint8Array,\n  signature: Uint8Array,\n  algorithm: { name: string; namedCurve?: string } = { name: 'ECDSA', namedCurve: 'P-256' },\n): Promise<boolean> => {\n  let publicKey!: CryptoKey;\n\n  try {\n    publicKey = await subtleCrypto.importKey('raw', key.asUint8Array(), algorithm, true, ['verify']);\n  } catch {\n    return false;\n  }\n\n  return subtleCrypto.verify(\n    {\n      name: algorithm.name,\n      hash: 'SHA-256',\n    },\n    publicKey,\n    signature,\n    message,\n  );\n};\n\n/**\n * Creates an Ed25519 (libsodium keypair format) signature.\n */\nexport const ed25519Signature = async (secretKey: Uint8Array, message: Uint8Array): Promise<Uint8Array> => {\n  const curve = 'Ed25519';\n  const privateKeyJwk = {\n    kty: 'OKP',\n    crv: curve,\n    x: Buffer.from(secretKey.subarray(32)).toString('base64url'),\n    d: Buffer.from(secretKey.subarray(0, 32)).toString('base64url'),\n  };\n  const key = await subtleCrypto.importKey('jwk', privateKeyJwk, { name: curve }, true, ['sign']);\n  return new Uint8Array(await subtleCrypto.sign({ name: curve, hash: 'SHA-256' }, key, message));\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { webcrypto } from './subtle';\n\nexport const randomUUID = (): string => {\n  return webcrypto.randomUUID();\n};\n"],
+  "mappings": "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",
+  "names": ["import_keys", "import_hypercore_crypto", "SIGNATURE_LENGTH", "createId", "PublicKey", "stringify", "randomBytes", "createKeyPair", "seed", "invariant", "length", "crypto", "keyPair", "slice", "validateKeyPair", "publicKey", "secretKey", "asBuffer", "discoveryKey", "key", "from", "sign", "message", "Buffer", "isBuffer", "SECRET_KEY_LENGTH", "verify", "signature", "PUBLIC_KEY_LENGTH", "subtleCrypto", "webcrypto", "subtle", "getSignatureValidator", "bufferize", "verifySignature", "algorithm", "name", "namedCurve", "importKey", "asUint8Array", "hash", "ed25519Signature", "curve", "privateKeyJwk", "kty", "crv", "x", "subarray", "toString", "d", "Uint8Array", "randomUUID"]
 }

package/dist/lib/node/meta.json

@@ -1 +1 @@
-{"inputs":{"packages/common/crypto/src/keys.ts":{"bytes":8453,"imports":[{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/signer.ts":{"bytes":810,"imports":[],"format":"esm"},"packages/common/crypto/src/subtle.ts":{"bytes":978,"imports":[{"path":"node:crypto","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/validator.ts":{"bytes":1519,"imports":[{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/verify.ts":{"bytes":2511,"imports":[{"path":"packages/common/crypto/src/subtle.ts","kind":"import-statement","original":"./subtle"}],"format":"esm"},"packages/common/crypto/src/uuid.ts":{"bytes":821,"imports":[{"path":"packages/common/crypto/src/subtle.ts","kind":"import-statement","original":"./subtle"}],"format":"esm"},"packages/common/crypto/src/index.ts":{"bytes":909,"imports":[{"path":"packages/common/crypto/src/keys.ts","kind":"import-statement","original":"./keys"},{"path":"packages/common/crypto/src/signer.ts","kind":"import-statement","original":"./signer"},{"path":"packages/common/crypto/src/subtle.ts","kind":"import-statement","original":"./subtle"},{"path":"packages/common/crypto/src/validator.ts","kind":"import-statement","original":"./validator"},{"path":"packages/common/crypto/src/verify.ts","kind":"import-statement","original":"./verify"},{"path":"packages/common/crypto/src/uuid.ts","kind":"import-statement","original":"./uuid"}],"format":"esm"}},"outputs":{"packages/common/crypto/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":6164},"packages/common/crypto/dist/lib/node/index.cjs":{"imports":[{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true},{"path":"node:crypto","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"exports":["SIGNATURE_LENGTH","createId","createKeyPair","discoveryKey","getSignatureValidator","randomBytes","randomUUID","sign","subtleCrypto","validateKeyPair","verify","verifySignature","webcrypto"],"entryPoint":"packages/common/crypto/src/index.ts","inputs":{"packages/common/crypto/src/keys.ts":{"bytesInOutput":2233},"packages/common/crypto/src/index.ts":{"bytesInOutput":0},"packages/common/crypto/src/subtle.ts":{"bytesInOutput":130},"packages/common/crypto/src/validator.ts":{"bytesInOutput":238},"packages/common/crypto/src/verify.ts":{"bytesInOutput":387},"packages/common/crypto/src/uuid.ts":{"bytesInOutput":62}},"bytes":3517}}}
+{"inputs":{"packages/common/crypto/src/keys.ts":{"bytes":8453,"imports":[{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/signer.ts":{"bytes":810,"imports":[],"format":"esm"},"packages/common/crypto/src/subtle.ts":{"bytes":978,"imports":[{"path":"node:crypto","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/validator.ts":{"bytes":1519,"imports":[{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/verify.ts":{"bytes":4811,"imports":[{"path":"packages/common/crypto/src/subtle.ts","kind":"import-statement","original":"./subtle"}],"format":"esm"},"packages/common/crypto/src/uuid.ts":{"bytes":821,"imports":[{"path":"packages/common/crypto/src/subtle.ts","kind":"import-statement","original":"./subtle"}],"format":"esm"},"packages/common/crypto/src/index.ts":{"bytes":909,"imports":[{"path":"packages/common/crypto/src/keys.ts","kind":"import-statement","original":"./keys"},{"path":"packages/common/crypto/src/signer.ts","kind":"import-statement","original":"./signer"},{"path":"packages/common/crypto/src/subtle.ts","kind":"import-statement","original":"./subtle"},{"path":"packages/common/crypto/src/validator.ts","kind":"import-statement","original":"./validator"},{"path":"packages/common/crypto/src/verify.ts","kind":"import-statement","original":"./verify"},{"path":"packages/common/crypto/src/uuid.ts","kind":"import-statement","original":"./uuid"}],"format":"esm"}},"outputs":{"packages/common/crypto/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":7389},"packages/common/crypto/dist/lib/node/index.cjs":{"imports":[{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true},{"path":"node:crypto","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"exports":["SIGNATURE_LENGTH","createId","createKeyPair","discoveryKey","ed25519Signature","getSignatureValidator","randomBytes","randomUUID","sign","subtleCrypto","validateKeyPair","verify","verifySignature","webcrypto"],"entryPoint":"packages/common/crypto/src/index.ts","inputs":{"packages/common/crypto/src/keys.ts":{"bytesInOutput":2233},"packages/common/crypto/src/index.ts":{"bytesInOutput":0},"packages/common/crypto/src/subtle.ts":{"bytesInOutput":130},"packages/common/crypto/src/validator.ts":{"bytesInOutput":238},"packages/common/crypto/src/verify.ts":{"bytesInOutput":908},"packages/common/crypto/src/uuid.ts":{"bytesInOutput":62}},"bytes":4058}}}

package/dist/lib/node-esm/index.mjs

@@ -0,0 +1,150 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// packages/common/crypto/src/keys.ts
+import { invariant } from "@dxos/invariant";
+import { PublicKey, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH } from "@dxos/keys";
+import crypto from "#hypercore-crypto";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/crypto/src/keys.ts";
+var SIGNATURE_LENGTH = 64;
+var createId = () => PublicKey.stringify(randomBytes(32));
+var createKeyPair = (seed) => {
+  if (seed) {
+    invariant(seed.length >= 32, "Seedphrase too sort. Expecting length of 32.", {
+      F: __dxlog_file,
+      L: 20,
+      S: void 0,
+      A: [
+        "seed.length >= 32",
+        "'Seedphrase too sort. Expecting length of 32.'"
+      ]
+    });
+    return crypto.keyPair(seed.slice(0, 32));
+  }
+  return crypto.keyPair();
+};
+var validateKeyPair = (publicKey, secretKey) => crypto.validateKeyPair({
+  publicKey: publicKey.asBuffer(),
+  secretKey
+});
+var discoveryKey = (key) => crypto.discoveryKey(PublicKey.from(key).asBuffer().slice(1));
+var randomBytes = (length = 32) => crypto.randomBytes(length);
+var sign = (message, secretKey) => {
+  invariant(Buffer.isBuffer(message), void 0, {
+    F: __dxlog_file,
+    L: 50,
+    S: void 0,
+    A: [
+      "Buffer.isBuffer(message)",
+      ""
+    ]
+  });
+  invariant(Buffer.isBuffer(secretKey) && secretKey.length === SECRET_KEY_LENGTH, void 0, {
+    F: __dxlog_file,
+    L: 51,
+    S: void 0,
+    A: [
+      "Buffer.isBuffer(secretKey) && secretKey.length === SECRET_KEY_LENGTH",
+      ""
+    ]
+  });
+  return crypto.sign(message, secretKey);
+};
+var verify = (message, signature, publicKey) => {
+  invariant(Buffer.isBuffer(message), void 0, {
+    F: __dxlog_file,
+    L: 64,
+    S: void 0,
+    A: [
+      "Buffer.isBuffer(message)",
+      ""
+    ]
+  });
+  invariant(Buffer.isBuffer(signature) && signature.length === SIGNATURE_LENGTH, void 0, {
+    F: __dxlog_file,
+    L: 65,
+    S: void 0,
+    A: [
+      "Buffer.isBuffer(signature) && signature.length === SIGNATURE_LENGTH",
+      ""
+    ]
+  });
+  invariant(Buffer.isBuffer(publicKey) && publicKey.length === PUBLIC_KEY_LENGTH, void 0, {
+    F: __dxlog_file,
+    L: 66,
+    S: void 0,
+    A: [
+      "Buffer.isBuffer(publicKey) && publicKey.length === PUBLIC_KEY_LENGTH",
+      ""
+    ]
+  });
+  return crypto.verify(message, signature, publicKey);
+};
+
+// packages/common/crypto/src/subtle.ts
+import * as nodeCrypto from "node:crypto";
+var subtleCrypto = nodeCrypto.webcrypto.subtle;
+var webcrypto2 = nodeCrypto.webcrypto;
+
+// packages/common/crypto/src/validator.ts
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { verify as verify2 } from "#hypercore-crypto";
+var getSignatureValidator = (publicKey) => (message, signature) => verify2(message, signature, PublicKey2.bufferize(publicKey));
+
+// packages/common/crypto/src/verify.ts
+var verifySignature = async (key, message, signature, algorithm = {
+  name: "ECDSA",
+  namedCurve: "P-256"
+}) => {
+  let publicKey;
+  try {
+    publicKey = await subtleCrypto.importKey("raw", key.asUint8Array(), algorithm, true, [
+      "verify"
+    ]);
+  } catch {
+    return false;
+  }
+  return subtleCrypto.verify({
+    name: algorithm.name,
+    hash: "SHA-256"
+  }, publicKey, signature, message);
+};
+var ed25519Signature = async (secretKey, message) => {
+  const curve = "Ed25519";
+  const privateKeyJwk = {
+    kty: "OKP",
+    crv: curve,
+    x: Buffer.from(secretKey.subarray(32)).toString("base64url"),
+    d: Buffer.from(secretKey.subarray(0, 32)).toString("base64url")
+  };
+  const key = await subtleCrypto.importKey("jwk", privateKeyJwk, {
+    name: curve
+  }, true, [
+    "sign"
+  ]);
+  return new Uint8Array(await subtleCrypto.sign({
+    name: curve,
+    hash: "SHA-256"
+  }, key, message));
+};
+
+// packages/common/crypto/src/uuid.ts
+var randomUUID = () => {
+  return webcrypto2.randomUUID();
+};
+export {
+  SIGNATURE_LENGTH,
+  createId,
+  createKeyPair,
+  discoveryKey,
+  ed25519Signature,
+  getSignatureValidator,
+  randomBytes,
+  randomUUID,
+  sign,
+  subtleCrypto,
+  validateKeyPair,
+  verify,
+  verifySignature,
+  webcrypto2 as webcrypto
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/node-esm/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/keys.ts", "../../../src/subtle.ts", "../../../src/validator.ts", "../../../src/verify.ts", "../../../src/uuid.ts"],
+  "sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { invariant } from '@dxos/invariant';\nimport { type KeyPair, PublicKey, type PublicKeyLike, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH } from '@dxos/keys';\n\nimport crypto from '#hypercore-crypto';\n\nexport const SIGNATURE_LENGTH = 64;\n\n/**\n * @deprecated\n */\n// TODO(burdon): Remove.\nexport const createId = (): string => PublicKey.stringify(randomBytes(32));\n\nexport const createKeyPair = (seed?: Buffer): KeyPair => {\n  if (seed) {\n    invariant(seed.length >= 32, 'Seedphrase too sort. Expecting length of 32.');\n    return crypto.keyPair(seed.slice(0, 32));\n  }\n\n  // TODO(burdon): Enable seed for debugging.\n  return crypto.keyPair();\n};\n\n// TODO(burdon): Buffer.\nexport const validateKeyPair = (publicKey: PublicKey, secretKey: Buffer) =>\n  crypto.validateKeyPair({ publicKey: publicKey.asBuffer(), secretKey });\n\n// TODO(dmaretskyi): Slicing because webcrypto keys are too long.\nexport const discoveryKey = (key: PublicKeyLike): Buffer =>\n  crypto.discoveryKey(PublicKey.from(key).asBuffer().slice(1));\n\n/**\n * Return random bytes of length.\n * @param [length=32]\n * @return {Buffer}\n */\nexport const randomBytes = (length = 32): Buffer => crypto.randomBytes(length);\n\n/**\n * Sign the contents of message with secret_key\n * @param {Buffer} message\n * @param {Buffer} secretKey\n * @returns {Buffer} signature\n */\nexport const sign = (message: Buffer, secretKey: Buffer): Buffer => {\n  invariant(Buffer.isBuffer(message));\n  invariant(Buffer.isBuffer(secretKey) && secretKey.length === SECRET_KEY_LENGTH);\n\n  return crypto.sign(message, secretKey);\n};\n\n/**\n * Verifies the signature against the message and public_key.\n * @param {Buffer} message\n * @param {Buffer} publicKey\n * @param {Buffer} signature\n * @return {boolean}\n */\nexport const verify = (message: Buffer, signature: Buffer, publicKey: Buffer): boolean => {\n  invariant(Buffer.isBuffer(message));\n  invariant(Buffer.isBuffer(signature) && signature.length === SIGNATURE_LENGTH);\n  invariant(Buffer.isBuffer(publicKey) && publicKey.length === PUBLIC_KEY_LENGTH);\n\n  return crypto.verify(message, signature, publicKey);\n};\n", "//\n// Copyright 2022 DXOS.org\n//\n\nimport * as nodeCrypto from 'node:crypto';\n\nexport const subtleCrypto = nodeCrypto.webcrypto.subtle;\n\nexport const webcrypto = nodeCrypto.webcrypto;\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport { PublicKey } from '@dxos/keys';\n\nimport { verify } from '#hypercore-crypto';\n\n/**\n * Generator for signature validation function.\n * @param {String} publicKey\n */\nexport const getSignatureValidator = (publicKey: string) => (message: Buffer, signature: Buffer) =>\n  verify(message, signature, PublicKey.bufferize(publicKey));\n", "//\n// Copyright 2022 DXOS.org\n//\n\nimport { type PublicKey } from '@dxos/keys';\n\nimport { subtleCrypto } from './subtle';\n\n/**\n * Verify a signature with the given key.\n */\nexport const verifySignature = async (\n  key: PublicKey,\n  message: Uint8Array,\n  signature: Uint8Array,\n  algorithm: { name: string; namedCurve?: string } = { name: 'ECDSA', namedCurve: 'P-256' },\n): Promise<boolean> => {\n  let publicKey!: CryptoKey;\n\n  try {\n    publicKey = await subtleCrypto.importKey('raw', key.asUint8Array(), algorithm, true, ['verify']);\n  } catch {\n    return false;\n  }\n\n  return subtleCrypto.verify(\n    {\n      name: algorithm.name,\n      hash: 'SHA-256',\n    },\n    publicKey,\n    signature,\n    message,\n  );\n};\n\n/**\n * Creates an Ed25519 (libsodium keypair format) signature.\n */\nexport const ed25519Signature = async (secretKey: Uint8Array, message: Uint8Array): Promise<Uint8Array> => {\n  const curve = 'Ed25519';\n  const privateKeyJwk = {\n    kty: 'OKP',\n    crv: curve,\n    x: Buffer.from(secretKey.subarray(32)).toString('base64url'),\n    d: Buffer.from(secretKey.subarray(0, 32)).toString('base64url'),\n  };\n  const key = await subtleCrypto.importKey('jwk', privateKeyJwk, { name: curve }, true, ['sign']);\n  return new Uint8Array(await subtleCrypto.sign({ name: curve, hash: 'SHA-256' }, key, message));\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { webcrypto } from './subtle';\n\nexport const randomUUID = (): string => {\n  return webcrypto.randomUUID();\n};\n"],
+  "mappings": "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",
+  "names": ["invariant", "PublicKey", "PUBLIC_KEY_LENGTH", "SECRET_KEY_LENGTH", "crypto", "SIGNATURE_LENGTH", "createId", "stringify", "randomBytes", "createKeyPair", "seed", "length", "keyPair", "slice", "validateKeyPair", "publicKey", "secretKey", "asBuffer", "discoveryKey", "key", "from", "sign", "message", "Buffer", "isBuffer", "verify", "signature", "nodeCrypto", "subtleCrypto", "webcrypto", "subtle", "PublicKey", "verify", "getSignatureValidator", "publicKey", "message", "signature", "verify", "PublicKey", "bufferize", "verifySignature", "key", "message", "signature", "algorithm", "name", "namedCurve", "publicKey", "subtleCrypto", "importKey", "asUint8Array", "verify", "hash", "ed25519Signature", "secretKey", "curve", "privateKeyJwk", "kty", "crv", "x", "Buffer", "from", "subarray", "toString", "d", "Uint8Array", "sign", "randomUUID", "webcrypto"]
+}

package/dist/lib/node-esm/meta.json

@@ -0,0 +1 @@
+{"inputs":{"packages/common/crypto/src/keys.ts":{"bytes":8453,"imports":[{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/signer.ts":{"bytes":810,"imports":[],"format":"esm"},"packages/common/crypto/src/subtle.ts":{"bytes":978,"imports":[{"path":"node:crypto","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/validator.ts":{"bytes":1519,"imports":[{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"format":"esm"},"packages/common/crypto/src/verify.ts":{"bytes":4811,"imports":[{"path":"packages/common/crypto/src/subtle.ts","kind":"import-statement","original":"./subtle"}],"format":"esm"},"packages/common/crypto/src/uuid.ts":{"bytes":821,"imports":[{"path":"packages/common/crypto/src/subtle.ts","kind":"import-statement","original":"./subtle"}],"format":"esm"},"packages/common/crypto/src/index.ts":{"bytes":909,"imports":[{"path":"packages/common/crypto/src/keys.ts","kind":"import-statement","original":"./keys"},{"path":"packages/common/crypto/src/signer.ts","kind":"import-statement","original":"./signer"},{"path":"packages/common/crypto/src/subtle.ts","kind":"import-statement","original":"./subtle"},{"path":"packages/common/crypto/src/validator.ts","kind":"import-statement","original":"./validator"},{"path":"packages/common/crypto/src/verify.ts","kind":"import-statement","original":"./verify"},{"path":"packages/common/crypto/src/uuid.ts","kind":"import-statement","original":"./uuid"}],"format":"esm"}},"outputs":{"packages/common/crypto/dist/lib/node-esm/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":7391},"packages/common/crypto/dist/lib/node-esm/index.mjs":{"imports":[{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true},{"path":"node:crypto","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"#hypercore-crypto","kind":"import-statement","external":true}],"exports":["SIGNATURE_LENGTH","createId","createKeyPair","discoveryKey","ed25519Signature","getSignatureValidator","randomBytes","randomUUID","sign","subtleCrypto","validateKeyPair","verify","verifySignature","webcrypto"],"entryPoint":"packages/common/crypto/src/index.ts","inputs":{"packages/common/crypto/src/keys.ts":{"bytesInOutput":2233},"packages/common/crypto/src/index.ts":{"bytesInOutput":0},"packages/common/crypto/src/subtle.ts":{"bytesInOutput":130},"packages/common/crypto/src/validator.ts":{"bytesInOutput":238},"packages/common/crypto/src/verify.ts":{"bytesInOutput":908},"packages/common/crypto/src/uuid.ts":{"bytesInOutput":62}},"bytes":4151}}}

package/dist/types/src/verify.d.ts

@@ -2,5 +2,12 @@ import { type PublicKey } from '@dxos/keys';
 /**
  * Verify a signature with the given key.
  */
-export declare const verifySignature: (key: PublicKey, message: Uint8Array, signature: Uint8Array) => Promise<boolean>;
+export declare const verifySignature: (key: PublicKey, message: Uint8Array, signature: Uint8Array, algorithm?: {
+    name: string;
+    namedCurve?: string;
+}) => Promise<boolean>;
+/**
+ * Creates an Ed25519 (libsodium keypair format) signature.
+ */
+export declare const ed25519Signature: (secretKey: Uint8Array, message: Uint8Array) => Promise<Uint8Array>;
 //# sourceMappingURL=verify.d.ts.map

package/dist/types/src/verify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/verify.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAI5C;;GAEG;AACH,eAAO,MAAM,eAAe,QAAe,SAAS,WAAW,UAAU,aAAa,UAAU,KAAG,OAAO,CAAC,OAAO,CA2BjH,CAAC"}
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/verify.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAI5C;;GAEG;AACH,eAAO,MAAM,eAAe,QACrB,SAAS,WACL,UAAU,aACR,UAAU,cACV;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,KAC/C,OAAO,CAAC,OAAO,CAkBjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,cAAqB,UAAU,WAAW,UAAU,KAAG,OAAO,CAAC,UAAU,CAUrG,CAAC"}

package/dist/types/src/verify.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Verify a signature with the given key.
+ */
+export {};
+//# sourceMappingURL=verify.test.d.ts.map

package/dist/types/src/verify.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.test.d.ts","sourceRoot":"","sources":["../../../src/verify.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/crypto",
-  "version": "0.6.12",
+  "version": "0.6.13-main.041e8aa",
   "description": "Basic cross-platform crypto utils.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,7 +8,7 @@
   "author": "DXOS.org",
   "imports": {
     "#hypercore-crypto": {
-      "workerd": "./hypercore-crypto-stub.js",
+      "workerd": "./hypercore-crypto-stub.mjs",
       "default": "hypercore-crypto"
     }
   },
@@ -16,7 +16,8 @@
     ".": {
       "browser": "./dist/lib/browser/index.mjs",
       "node": {
-        "default": "./dist/lib/node/index.cjs"
+        "require": "./dist/lib/node/index.cjs",
+        "default": "./dist/lib/node-esm/index.mjs"
       },
       "types": "./dist/types/src/index.d.ts"
     }
@@ -31,17 +32,16 @@
   "files": [
     "dist",
     "src",
-    "./hypercore-crypto-stub.js"
+    "./hypercore-crypto-stub.mjs"
   ],
   "dependencies": {
     "hypercore-crypto": "^2.3.0",
-    "@dxos/invariant": "0.6.12",
-    "@dxos/node-std": "0.6.12",
-    "@dxos/keys": "0.6.12"
+    "@dxos/invariant": "0.6.13-main.041e8aa",
+    "@dxos/keys": "0.6.13-main.041e8aa",
+    "@dxos/node-std": "0.6.13-main.041e8aa"
   },
   "devDependencies": {
-    "@types/crypto-js": "~4.0.2",
-    "@types/node": "^18.11.9"
+    "@types/node": "^22.7.4"
   },
   "publishConfig": {
     "access": "public"

package/src/keys.test.ts

@@ -2,9 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-import { expect } from 'chai';
-
-import { test } from '@dxos/test';
+import { describe, test, expect } from 'vitest';
 
 import { createId, createKeyPair, randomBytes, sign, verify } from './keys';
 

package/src/verify.test.ts

@@ -0,0 +1,26 @@
+/**
+ * Verify a signature with the given key.
+ */
+//
+// Copyright 2024 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { PublicKey } from '@dxos/keys';
+
+import { createKeyPair } from './keys';
+import { ed25519Signature, verifySignature } from './verify';
+
+describe('verify', () => {
+  test('keypair conversion', async () => {
+    const keypair = createKeyPair();
+    const message = Buffer.from('hello');
+    const signature = await ed25519Signature(keypair.secretKey, message);
+    expect(
+      await verifySignature(PublicKey.from(keypair.publicKey), message, signature, {
+        name: 'Ed25519',
+      }),
+    ).toBeTruthy();
+  });
+});

package/src/verify.ts

@@ -9,27 +9,23 @@ import { subtleCrypto } from './subtle';
 /**
  * Verify a signature with the given key.
  */
-export const verifySignature = async (key: PublicKey, message: Uint8Array, signature: Uint8Array): Promise<boolean> => {
+export const verifySignature = async (
+  key: PublicKey,
+  message: Uint8Array,
+  signature: Uint8Array,
+  algorithm: { name: string; namedCurve?: string } = { name: 'ECDSA', namedCurve: 'P-256' },
+): Promise<boolean> => {
   let publicKey!: CryptoKey;
 
   try {
-    publicKey = await subtleCrypto.importKey(
-      'raw',
-      key.asUint8Array(),
-      {
-        name: 'ECDSA',
-        namedCurve: 'P-256',
-      },
-      true,
-      ['verify'],
-    );
+    publicKey = await subtleCrypto.importKey('raw', key.asUint8Array(), algorithm, true, ['verify']);
   } catch {
     return false;
   }
 
   return subtleCrypto.verify(
     {
-      name: 'ECDSA',
+      name: algorithm.name,
       hash: 'SHA-256',
     },
     publicKey,
@@ -37,3 +33,18 @@ export const verifySignature = async (key: PublicKey, message: Uint8Array, signa
     message,
   );
 };
+
+/**
+ * Creates an Ed25519 (libsodium keypair format) signature.
+ */
+export const ed25519Signature = async (secretKey: Uint8Array, message: Uint8Array): Promise<Uint8Array> => {
+  const curve = 'Ed25519';
+  const privateKeyJwk = {
+    kty: 'OKP',
+    crv: curve,
+    x: Buffer.from(secretKey.subarray(32)).toString('base64url'),
+    d: Buffer.from(secretKey.subarray(0, 32)).toString('base64url'),
+  };
+  const key = await subtleCrypto.importKey('jwk', privateKeyJwk, { name: curve }, true, ['sign']);
+  return new Uint8Array(await subtleCrypto.sign({ name: curve, hash: 'SHA-256' }, key, message));
+};