@dxos/keyring 0.8.4-main.fffef41 → 0.9.0

package/package.json

@@ -1,40 +1,44 @@
 {
   "name": "@dxos/keyring",
-  "version": "0.8.4-main.fffef41",
+  "version": "0.9.0",
   "description": "Halo Keyring.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
-  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "FSL-1.1-Apache-2.0",
   "author": "info@dxos.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {}
-  },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@dxos/async": "0.8.4-main.fffef41",
-    "@dxos/codec-protobuf": "0.8.4-main.fffef41",
-    "@dxos/crypto": "0.8.4-main.fffef41",
-    "@dxos/debug": "0.8.4-main.fffef41",
-    "@dxos/invariant": "0.8.4-main.fffef41",
-    "@dxos/keys": "0.8.4-main.fffef41",
-    "@dxos/node-std": "0.8.4-main.fffef41",
-    "@dxos/protocols": "0.8.4-main.fffef41",
-    "@dxos/random-access-storage": "0.8.4-main.fffef41",
-    "@dxos/util": "0.8.4-main.fffef41"
+    "@effect/sql": "0.51.1",
+    "effect": "3.21.3",
+    "@dxos/async": "0.9.0",
+    "@dxos/crypto": "0.9.0",
+    "@dxos/codec-protobuf": "0.9.0",
+    "@dxos/debug": "0.9.0",
+    "@dxos/effect": "0.9.0",
+    "@dxos/invariant": "0.9.0",
+    "@dxos/keys": "0.9.0",
+    "@dxos/util": "0.9.0",
+    "@dxos/node-std": "0.9.0",
+    "@dxos/random-access-storage": "0.9.0",
+    "@dxos/protocols": "0.9.0",
+    "@dxos/sql-sqlite": "0.9.0"
   },
   "devDependencies": {},
   "publishConfig": {

package/src/index.ts

@@ -3,4 +3,5 @@
 //
 
 export * from './keyring';
+export * from './sqlite-keyring';
 export * from './testing';

package/src/keyring.ts

@@ -15,10 +15,20 @@ import { ComplexMap, arrayToBuffer } from '@dxos/util';
 
 const KeyRecord: ProtoCodec<KeyRecord> = schema.getCodecForType('dxos.halo.keyring.KeyRecord');
 
+/**
+ * Shared public API for keyring implementations.
+ */
+export interface KeyringApi extends Signer {
+  readonly keysUpdate: Event;
+  createKey(): Promise<PublicKey>;
+  importKeyPair(keyPair: CryptoKeyPair): Promise<PublicKey>;
+  list(): Promise<KeyRecord[]>;
+}
+
 /**
  * Manages keys.
  */
-export class Keyring implements Signer {
+export class Keyring implements KeyringApi {
   private readonly _keyCache = new ComplexMap<PublicKey, CryptoKeyPair>(PublicKey.hash);
   readonly keysUpdate = new Event();
 

package/src/sqlite-keyring.test.ts

@@ -0,0 +1,66 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as SqlClient from '@effect/sql/SqlClient';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+import { describe, expect, onTestFinished, test } from 'vitest';
+
+import { verifySignature } from '@dxos/crypto';
+import { RuntimeProvider } from '@dxos/effect';
+import { layerMemory as sqliteLayerMemory } from '@dxos/sql-sqlite/platform';
+import * as SqlTransaction from '@dxos/sql-sqlite/SqlTransaction';
+
+import { SqliteKeyring } from './sqlite-keyring';
+
+const makeRuntime = () => {
+  const rt = ManagedRuntime.make(SqlTransaction.layer.pipe(Layer.provideMerge(sqliteLayerMemory)).pipe(Layer.orDie));
+  onTestFinished(() => rt.dispose());
+  return rt.runtimeEffect;
+};
+
+describe('SqliteKeyring', () => {
+  test('creates and verifies key', async () => {
+    const runtime = makeRuntime();
+    const keyring = new SqliteKeyring({ runtime });
+
+    // Run migration
+    await RuntimeProvider.runPromise(runtime)(keyring.migrate);
+
+    // Create key
+    const key = await keyring.createKey();
+    expect(key).toBeDefined();
+
+    // Sign and verify
+    const message = Buffer.from('hello');
+    const signature = await keyring.sign(key, message);
+    expect(await verifySignature(key, message, signature)).toBeTruthy();
+  });
+
+  test('lists keys', async () => {
+    const runtime = makeRuntime();
+    const keyring = new SqliteKeyring({ runtime });
+    await RuntimeProvider.runPromise(runtime)(keyring.migrate);
+
+    for (let i = 0; i < 3; i++) {
+      await keyring.createKey();
+    }
+    const keys = await keyring.list();
+    expect(keys).toHaveLength(3);
+  });
+
+  test('direct sql insert works', async () => {
+    const runtime = makeRuntime();
+    await RuntimeProvider.runPromise(runtime)(
+      Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        yield* sql`CREATE TABLE IF NOT EXISTS test_table (id INTEGER PRIMARY KEY, val TEXT)`;
+        yield* sql`INSERT INTO test_table (val) VALUES (${'hello'})`;
+        const rows = yield* sql<{ val: string }>`SELECT val FROM test_table`;
+        expect(rows[0].val).toBe('hello');
+      }),
+    );
+  });
+});

package/src/sqlite-keyring.ts

@@ -0,0 +1,159 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as SqlClient from '@effect/sql/SqlClient';
+import type * as SqlError from '@effect/sql/SqlError';
+import * as Effect from 'effect/Effect';
+
+import { Event, synchronized } from '@dxos/async';
+import { subtleCrypto } from '@dxos/crypto';
+import { RuntimeProvider } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
+import { PublicKey } from '@dxos/keys';
+import { schema } from '@dxos/protocols/proto';
+import { type KeyRecord } from '@dxos/protocols/proto/dxos/halo/keyring';
+import { SqlTransaction } from '@dxos/sql-sqlite';
+import { ComplexMap, arrayToBuffer } from '@dxos/util';
+
+import { type KeyringApi } from './keyring';
+
+const KeyRecordCodec = schema.getCodecForType('dxos.halo.keyring.KeyRecord');
+
+// SqlTransaction.SqlTransaction is the Tag class exported from the SqlTransaction namespace.
+type SqlTransactionTag = SqlTransaction.SqlTransaction;
+
+export type SqliteKeyringOptions = {
+  runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient | SqlTransactionTag>;
+};
+
+/**
+ * SQLite-backed Keyring.
+ * Stores ECDSA key pairs in the `keyring` table.
+ */
+export class SqliteKeyring implements KeyringApi {
+  readonly #runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient | SqlTransactionTag>;
+  readonly #keyCache = new ComplexMap<PublicKey, CryptoKeyPair>(PublicKey.hash);
+  readonly keysUpdate = new Event();
+
+  constructor({ runtime }: SqliteKeyringOptions) {
+    invariant(subtleCrypto, 'SubtleCrypto not available in this environment.');
+    this.#runtime = runtime;
+  }
+
+  readonly migrate: Effect.Effect<void, SqlError.SqlError, SqlClient.SqlClient | SqlTransactionTag> = Effect.fn(
+    'SqliteKeyring.migrate',
+  )(() =>
+    Effect.gen(function* () {
+      const sql = yield* SqlClient.SqlClient;
+      yield* sql`CREATE TABLE IF NOT EXISTS keyring (
+          public_key TEXT PRIMARY KEY,
+          record BLOB NOT NULL
+        )`;
+    }).pipe(Effect.withSpan('SqliteKeyring.migrate')),
+  )();
+
+  async sign(key: PublicKey, message: Uint8Array): Promise<Uint8Array> {
+    const keyPair = await this._getKey(key);
+    return new Uint8Array(
+      await subtleCrypto.sign(
+        { name: 'ECDSA', hash: 'SHA-256' },
+        keyPair.privateKey,
+        message as Uint8Array<ArrayBuffer>,
+      ),
+    );
+  }
+
+  async createKey(): Promise<PublicKey> {
+    const keyPair = await subtleCrypto.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify']);
+    await this._setKey(keyPair);
+    return keyPairToPublicKey(keyPair);
+  }
+
+  async importKeyPair(keyPair: CryptoKeyPair): Promise<PublicKey> {
+    await this._setKey(keyPair);
+    return keyPairToPublicKey(keyPair);
+  }
+
+  async list(): Promise<KeyRecord[]> {
+    const rows = await RuntimeProvider.runPromise(this.#runtime)(
+      Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        return yield* sql<{ record: Uint8Array }>`SELECT record FROM keyring`;
+      }),
+    );
+    return rows.map((row) => {
+      const record = KeyRecordCodec.decode(row.record);
+      // Never expose private key material to callers.
+      return { publicKey: record.publicKey };
+    });
+  }
+
+  @synchronized
+  private async _getKey(key: PublicKey): Promise<CryptoKeyPair> {
+    if (this.#keyCache.has(key)) {
+      return this.#keyCache.get(key)!;
+    }
+
+    const keyHex = key.toHex();
+    const rows = await RuntimeProvider.runPromise(this.#runtime)(
+      Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        return yield* sql<{ record: Uint8Array }>`SELECT record FROM keyring WHERE public_key = ${keyHex}`;
+      }),
+    );
+
+    if (rows.length === 0) {
+      throw new Error(`Key not found: ${keyHex}`);
+    }
+
+    const record = KeyRecordCodec.decode(rows[0].record);
+    const publicKey = PublicKey.from(record.publicKey);
+    invariant(key.equals(publicKey), 'Corrupted keyring: key mismatch');
+    invariant(record.privateKey, 'Corrupted keyring: missing private key');
+
+    const keyPair: CryptoKeyPair = {
+      publicKey: await subtleCrypto.importKey(
+        'raw',
+        record.publicKey as Uint8Array<ArrayBuffer>,
+        { name: 'ECDSA', namedCurve: 'P-256' },
+        true,
+        ['verify'],
+      ),
+      privateKey: await subtleCrypto.importKey(
+        'pkcs8',
+        record.privateKey as Uint8Array<ArrayBuffer>,
+        { name: 'ECDSA', namedCurve: 'P-256' },
+        true,
+        ['sign'],
+      ),
+    };
+
+    this.#keyCache.set(publicKey, keyPair);
+    return keyPair;
+  }
+
+  @synchronized
+  private async _setKey(keyPair: CryptoKeyPair): Promise<void> {
+    const publicKey = await keyPairToPublicKey(keyPair);
+    this.#keyCache.set(publicKey, keyPair);
+
+    const record: KeyRecord = {
+      publicKey: publicKey.asUint8Array(),
+      privateKey: new Uint8Array(await subtleCrypto.exportKey('pkcs8', keyPair.privateKey)),
+    };
+
+    const keyHex = publicKey.toHex();
+    const encodedRecord = arrayToBuffer(KeyRecordCodec.encode(record));
+    await RuntimeProvider.runPromise(this.#runtime)(
+      Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        yield* sql`INSERT OR REPLACE INTO keyring (public_key, record) VALUES (${keyHex}, ${encodedRecord})`;
+      }),
+    );
+    this.keysUpdate.emit();
+  }
+}
+
+const keyPairToPublicKey = async (keyPair: CryptoKeyPair): Promise<PublicKey> =>
+  PublicKey.from(new Uint8Array(await subtleCrypto.exportKey('raw', keyPair.publicKey)));

package/dist/lib/browser/index.mjs

@@ -1,195 +0,0 @@
-import "@dxos/node-std/globals";
-
-// src/keyring.ts
-import { Event, synchronized } from "@dxos/async";
-import { subtleCrypto } from "@dxos/crypto";
-import { todo } from "@dxos/debug";
-import { invariant } from "@dxos/invariant";
-import { PublicKey } from "@dxos/keys";
-import { schema } from "@dxos/protocols/proto";
-import { StorageType, createStorage } from "@dxos/random-access-storage";
-import { ComplexMap, arrayToBuffer } from "@dxos/util";
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file = "/__w/dxos/dxos/packages/core/halo/keyring/src/keyring.ts";
-var KeyRecord = schema.getCodecForType("dxos.halo.keyring.KeyRecord");
-var Keyring = class {
-  _storage;
-  _keyCache = new ComplexMap(PublicKey.hash);
-  keysUpdate = new Event();
-  constructor(_storage = createStorage({
-    type: StorageType.RAM
-  }).createDirectory("keyring")) {
-    this._storage = _storage;
-    invariant(subtleCrypto, "SubtleCrypto not available in this environment.", {
-      F: __dxlog_file,
-      L: 30,
-      S: this,
-      A: [
-        "subtleCrypto",
-        "'SubtleCrypto not available in this environment.'"
-      ]
-    });
-  }
-  async sign(key, message) {
-    const keyPair = await this._getKey(key);
-    return new Uint8Array(await subtleCrypto.sign({
-      name: "ECDSA",
-      hash: "SHA-256"
-    }, keyPair.privateKey, message));
-  }
-  async createKey() {
-    const keyPair = await subtleCrypto.generateKey({
-      name: "ECDSA",
-      namedCurve: "P-256"
-    }, true, [
-      "sign",
-      "verify"
-    ]);
-    await this._setKey(keyPair);
-    return keyPairToPublicKey(keyPair);
-  }
-  async _getKey(key) {
-    if (!this._keyCache.has(key)) {
-      const file = this._storage.getOrCreateFile(key.toHex());
-      const { size } = await file.stat();
-      if (size === 0) {
-        throw new Error(`Key not found: ${key.toHex()}`);
-      }
-      const recordBytes = await file.read(0, size);
-      await file.close();
-      const record = KeyRecord.decode(recordBytes);
-      const publicKey = PublicKey.from(record.publicKey);
-      invariant(key.equals(publicKey), "Corrupted keyring: Key mismatch", {
-        F: __dxlog_file,
-        L: 77,
-        S: this,
-        A: [
-          "key.equals(publicKey)",
-          "'Corrupted keyring: Key mismatch'"
-        ]
-      });
-      invariant(record.privateKey, "Corrupted keyring: Missing private key", {
-        F: __dxlog_file,
-        L: 78,
-        S: this,
-        A: [
-          "record.privateKey",
-          "'Corrupted keyring: Missing private key'"
-        ]
-      });
-      const keyPair = {
-        publicKey: await subtleCrypto.importKey("raw", record.publicKey, {
-          name: "ECDSA",
-          namedCurve: "P-256"
-        }, true, [
-          "verify"
-        ]),
-        privateKey: await subtleCrypto.importKey("pkcs8", record.privateKey, {
-          name: "ECDSA",
-          namedCurve: "P-256"
-        }, true, [
-          "sign"
-        ])
-      };
-      this._keyCache.set(publicKey, keyPair);
-    }
-    return this._keyCache.get(key);
-  }
-  async _setKey(keyPair) {
-    const publicKey = await keyPairToPublicKey(keyPair);
-    this._keyCache.set(publicKey, keyPair);
-    const record = {
-      publicKey: publicKey.asUint8Array(),
-      privateKey: new Uint8Array(await subtleCrypto.exportKey("pkcs8", keyPair.privateKey))
-    };
-    const file = this._storage.getOrCreateFile(publicKey.toHex());
-    await file.write(0, arrayToBuffer(KeyRecord.encode(record)));
-    await file.close();
-    await file.flush?.();
-    this.keysUpdate.emit();
-  }
-  // TODO(burdon): ???
-  deleteKey(key) {
-    return todo("We need a method to delete a file.");
-  }
-  async list() {
-    const keys = [];
-    for (const path of await this._storage.list()) {
-      const fileName = path.split("/").pop();
-      invariant(fileName, "Invalid file name", {
-        F: __dxlog_file,
-        L: 134,
-        S: this,
-        A: [
-          "fileName",
-          "'Invalid file name'"
-        ]
-      });
-      keys.push({
-        publicKey: PublicKey.fromHex(fileName).asUint8Array()
-      });
-    }
-    return keys;
-  }
-  async importKeyPair(keyPair) {
-    await this._setKey(keyPair);
-    return keyPairToPublicKey(keyPair);
-  }
-};
-_ts_decorate([
-  synchronized
-], Keyring.prototype, "_getKey", null);
-_ts_decorate([
-  synchronized
-], Keyring.prototype, "_setKey", null);
-var keyPairToPublicKey = async (keyPair) => {
-  return PublicKey.from(new Uint8Array(await subtleCrypto.exportKey("raw", keyPair.publicKey)));
-};
-
-// src/testing.ts
-import { subtleCrypto as subtleCrypto2 } from "@dxos/crypto";
-var generateJWKKeyPair = async () => {
-  const keyPair = await subtleCrypto2.generateKey({
-    name: "ECDSA",
-    namedCurve: "P-256"
-  }, true, [
-    "sign",
-    "verify"
-  ]);
-  const privateKeyExported = await subtleCrypto2.exportKey("jwk", keyPair.privateKey);
-  const publicKeyExported = await subtleCrypto2.exportKey("jwk", keyPair.publicKey);
-  const publicKeyBuffer = new Uint8Array(await subtleCrypto2.exportKey("raw", keyPair.publicKey));
-  const publicKeyHex = Array.from(publicKeyBuffer).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-  return {
-    privateKey: privateKeyExported,
-    publicKey: publicKeyExported,
-    publicKeyHex
-  };
-};
-var parseJWKKeyPair = async (privateKey, publicKey) => {
-  return {
-    privateKey: await subtleCrypto2.importKey("jwk", privateKey, {
-      name: "ECDSA",
-      namedCurve: "P-256"
-    }, true, [
-      "sign"
-    ]),
-    publicKey: await subtleCrypto2.importKey("jwk", publicKey, {
-      name: "ECDSA",
-      namedCurve: "P-256"
-    }, true, [
-      "verify"
-    ])
-  };
-};
-export {
-  Keyring,
-  generateJWKKeyPair,
-  parseJWKKeyPair
-};
-//# sourceMappingURL=index.mjs.map

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/keyring.ts", "../../../src/testing.ts"],
-  "sourcesContent": ["//\n// Copyright 2022 DXOS.org\n//\n\nimport { Event, synchronized } from '@dxos/async';\nimport { type ProtoCodec } from '@dxos/codec-protobuf';\nimport { type Signer, subtleCrypto } from '@dxos/crypto';\nimport { todo } from '@dxos/debug';\nimport { invariant } from '@dxos/invariant';\nimport { PublicKey } from '@dxos/keys';\nimport { schema } from '@dxos/protocols/proto';\nimport { type KeyRecord } from '@dxos/protocols/proto/dxos/halo/keyring';\nimport { type Directory, StorageType, createStorage } from '@dxos/random-access-storage';\nimport { ComplexMap, arrayToBuffer } from '@dxos/util';\n\nconst KeyRecord: ProtoCodec<KeyRecord> = schema.getCodecForType('dxos.halo.keyring.KeyRecord');\n\n/**\n * Manages keys.\n */\nexport class Keyring implements Signer {\n  private readonly _keyCache = new ComplexMap<PublicKey, CryptoKeyPair>(PublicKey.hash);\n  readonly keysUpdate = new Event();\n\n  constructor(\n    private readonly _storage: Directory = createStorage({\n      type: StorageType.RAM,\n    }).createDirectory('keyring'),\n  ) {\n    invariant(subtleCrypto, 'SubtleCrypto not available in this environment.');\n  }\n\n  async sign(key: PublicKey, message: Uint8Array): Promise<Uint8Array> {\n    const keyPair = await this._getKey(key);\n\n    return new Uint8Array(\n      await subtleCrypto.sign(\n        {\n          name: 'ECDSA',\n          hash: 'SHA-256',\n        },\n        keyPair.privateKey,\n        message as Uint8Array<ArrayBuffer>,\n      ),\n    );\n  }\n\n  async createKey(): Promise<PublicKey> {\n    const keyPair = await subtleCrypto.generateKey(\n      {\n        name: 'ECDSA',\n        namedCurve: 'P-256',\n      },\n      true,\n      ['sign', 'verify'],\n    );\n\n    await this._setKey(keyPair);\n\n    return keyPairToPublicKey(keyPair);\n  }\n\n  @synchronized\n  private async _getKey(key: PublicKey): Promise<CryptoKeyPair> {\n    if (!this._keyCache.has(key)) {\n      const file = this._storage.getOrCreateFile(key.toHex());\n      const { size } = await file.stat();\n      if (size === 0) {\n        throw new Error(`Key not found: ${key.toHex()}`);\n      }\n\n      const recordBytes = await file.read(0, size);\n      await file.close();\n\n      const record = KeyRecord.decode(recordBytes);\n      const publicKey = PublicKey.from(record.publicKey);\n      invariant(key.equals(publicKey), 'Corrupted keyring: Key mismatch');\n      invariant(record.privateKey, 'Corrupted keyring: Missing private key');\n      const keyPair: CryptoKeyPair = {\n        publicKey: await subtleCrypto.importKey(\n          'raw',\n          record.publicKey as Uint8Array<ArrayBuffer>,\n          {\n            name: 'ECDSA',\n            namedCurve: 'P-256',\n          },\n          true,\n          ['verify'],\n        ),\n        privateKey: await subtleCrypto.importKey(\n          'pkcs8',\n          record.privateKey as Uint8Array<ArrayBuffer>,\n          {\n            name: 'ECDSA',\n            namedCurve: 'P-256',\n          },\n          true,\n          ['sign'],\n        ),\n      };\n\n      this._keyCache.set(publicKey, keyPair);\n    }\n\n    return this._keyCache.get(key)!; // TODO(burdon): Fail if null?\n  }\n\n  @synchronized\n  private async _setKey(keyPair: CryptoKeyPair): Promise<void> {\n    const publicKey = await keyPairToPublicKey(keyPair);\n    this._keyCache.set(publicKey, keyPair);\n\n    const record: KeyRecord = {\n      publicKey: publicKey.asUint8Array(),\n      privateKey: new Uint8Array(await subtleCrypto.exportKey('pkcs8', keyPair.privateKey)),\n    };\n\n    const file = this._storage.getOrCreateFile(publicKey.toHex());\n    await file.write(0, arrayToBuffer(KeyRecord.encode(record)));\n    await file.close();\n    await file.flush?.();\n    this.keysUpdate.emit();\n  }\n\n  // TODO(burdon): ???\n  deleteKey(key: PublicKey): Promise<void> {\n    return todo('We need a method to delete a file.');\n  }\n\n  async list(): Promise<KeyRecord[]> {\n    const keys: KeyRecord[] = [];\n    for (const path of await this._storage.list()) {\n      const fileName = path.split('/').pop(); // get last portion of the path\n      invariant(fileName, 'Invalid file name');\n      keys.push({ publicKey: PublicKey.fromHex(fileName).asUint8Array() });\n    }\n    return keys;\n  }\n\n  async importKeyPair(keyPair: CryptoKeyPair): Promise<PublicKey> {\n    await this._setKey(keyPair);\n    return keyPairToPublicKey(keyPair);\n  }\n}\n\nconst keyPairToPublicKey = async (keyPair: CryptoKeyPair): Promise<PublicKey> => {\n  return PublicKey.from(new Uint8Array(await subtleCrypto.exportKey('raw', keyPair.publicKey)));\n};\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { subtleCrypto } from '@dxos/crypto';\n\nexport type TestKeyPair = {\n  privateKey: JsonWebKey;\n  publicKey: JsonWebKey;\n  publicKeyHex: string;\n};\n\n/**\n * Generate a key pair which for testing purposes.\n * @returns {Promise<TestKeyPair>}\n */\nexport const generateJWKKeyPair = async (): Promise<TestKeyPair> => {\n  const keyPair = await subtleCrypto.generateKey(\n    {\n      name: 'ECDSA',\n      namedCurve: 'P-256',\n    },\n    true,\n    ['sign', 'verify'],\n  );\n\n  const privateKeyExported = await subtleCrypto.exportKey('jwk', keyPair.privateKey);\n  const publicKeyExported = await subtleCrypto.exportKey('jwk', keyPair.publicKey);\n\n  // Convert the public key to hex format\n  const publicKeyBuffer = new Uint8Array(await subtleCrypto.exportKey('raw', keyPair.publicKey));\n  const publicKeyHex = Array.from(publicKeyBuffer)\n    .map((byte) => byte.toString(16).padStart(2, '0'))\n    .join('');\n\n  return {\n    privateKey: privateKeyExported,\n    publicKey: publicKeyExported,\n    publicKeyHex,\n  };\n};\n\n/**\n * Parse a key pair from JWK format.\n */\nexport const parseJWKKeyPair = async (privateKey: JsonWebKey, publicKey: JsonWebKey): Promise<CryptoKeyPair> => {\n  return {\n    privateKey: await subtleCrypto.importKey('jwk', privateKey, { name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign']),\n    publicKey: await subtleCrypto.importKey('jwk', publicKey, { name: 'ECDSA', namedCurve: 'P-256' }, true, ['verify']),\n  };\n};\n"],
-  "mappings": ";;;AAIA,SAASA,OAAOC,oBAAoB;AAEpC,SAAsBC,oBAAoB;AAC1C,SAASC,YAAY;AACrB,SAASC,iBAAiB;AAC1B,SAASC,iBAAiB;AAC1B,SAASC,cAAc;AAEvB,SAAyBC,aAAaC,qBAAqB;AAC3D,SAASC,YAAYC,qBAAqB;;;;;;;;AAE1C,IAAMC,YAAmCL,OAAOM,gBAAgB,6BAAA;AAKzD,IAAMC,UAAN,MAAMA;;EACMC,YAAY,IAAIL,WAAqCJ,UAAUU,IAAI;EAC3EC,aAAa,IAAIhB,MAAAA;EAE1B,YACmBiB,WAAsBT,cAAc;IACnDU,MAAMX,YAAYY;EACpB,CAAA,EAAGC,gBAAgB,SAAA,GACnB;SAHiBH,WAAAA;AAIjBb,cAAUF,cAAc,mDAAA;;;;;;;;;EAC1B;EAEA,MAAMmB,KAAKC,KAAgBC,SAA0C;AACnE,UAAMC,UAAU,MAAM,KAAKC,QAAQH,GAAAA;AAEnC,WAAO,IAAII,WACT,MAAMxB,aAAamB,KACjB;MACEM,MAAM;MACNZ,MAAM;IACR,GACAS,QAAQI,YACRL,OAAAA,CAAAA;EAGN;EAEA,MAAMM,YAAgC;AACpC,UAAML,UAAU,MAAMtB,aAAa4B,YACjC;MACEH,MAAM;MACNI,YAAY;IACd,GACA,MACA;MAAC;MAAQ;KAAS;AAGpB,UAAM,KAAKC,QAAQR,OAAAA;AAEnB,WAAOS,mBAAmBT,OAAAA;EAC5B;EAEA,MACcC,QAAQH,KAAwC;AAC5D,QAAI,CAAC,KAAKR,UAAUoB,IAAIZ,GAAAA,GAAM;AAC5B,YAAMa,OAAO,KAAKlB,SAASmB,gBAAgBd,IAAIe,MAAK,CAAA;AACpD,YAAM,EAAEC,KAAI,IAAK,MAAMH,KAAKI,KAAI;AAChC,UAAID,SAAS,GAAG;AACd,cAAM,IAAIE,MAAM,kBAAkBlB,IAAIe,MAAK,CAAA,EAAI;MACjD;AAEA,YAAMI,cAAc,MAAMN,KAAKO,KAAK,GAAGJ,IAAAA;AACvC,YAAMH,KAAKQ,MAAK;AAEhB,YAAMC,SAASjC,UAAUkC,OAAOJ,WAAAA;AAChC,YAAMK,YAAYzC,UAAU0C,KAAKH,OAAOE,SAAS;AACjD1C,gBAAUkB,IAAI0B,OAAOF,SAAAA,GAAY,mCAAA;;;;;;;;;AACjC1C,gBAAUwC,OAAOhB,YAAY,0CAAA;;;;;;;;;AAC7B,YAAMJ,UAAyB;QAC7BsB,WAAW,MAAM5C,aAAa+C,UAC5B,OACAL,OAAOE,WACP;UACEnB,MAAM;UACNI,YAAY;QACd,GACA,MACA;UAAC;SAAS;QAEZH,YAAY,MAAM1B,aAAa+C,UAC7B,SACAL,OAAOhB,YACP;UACED,MAAM;UACNI,YAAY;QACd,GACA,MACA;UAAC;SAAO;MAEZ;AAEA,WAAKjB,UAAUoC,IAAIJ,WAAWtB,OAAAA;IAChC;AAEA,WAAO,KAAKV,UAAUqC,IAAI7B,GAAAA;EAC5B;EAEA,MACcU,QAAQR,SAAuC;AAC3D,UAAMsB,YAAY,MAAMb,mBAAmBT,OAAAA;AAC3C,SAAKV,UAAUoC,IAAIJ,WAAWtB,OAAAA;AAE9B,UAAMoB,SAAoB;MACxBE,WAAWA,UAAUM,aAAY;MACjCxB,YAAY,IAAIF,WAAW,MAAMxB,aAAamD,UAAU,SAAS7B,QAAQI,UAAU,CAAA;IACrF;AAEA,UAAMO,OAAO,KAAKlB,SAASmB,gBAAgBU,UAAUT,MAAK,CAAA;AAC1D,UAAMF,KAAKmB,MAAM,GAAG5C,cAAcC,UAAU4C,OAAOX,MAAAA,CAAAA,CAAAA;AACnD,UAAMT,KAAKQ,MAAK;AAChB,UAAMR,KAAKqB,QAAK;AAChB,SAAKxC,WAAWyC,KAAI;EACtB;;EAGAC,UAAUpC,KAA+B;AACvC,WAAOnB,KAAK,oCAAA;EACd;EAEA,MAAMwD,OAA6B;AACjC,UAAMC,OAAoB,CAAA;AAC1B,eAAWC,QAAQ,MAAM,KAAK5C,SAAS0C,KAAI,GAAI;AAC7C,YAAMG,WAAWD,KAAKE,MAAM,GAAA,EAAKC,IAAG;AACpC5D,gBAAU0D,UAAU,qBAAA;;;;;;;;;AACpBF,WAAKK,KAAK;QAAEnB,WAAWzC,UAAU6D,QAAQJ,QAAAA,EAAUV,aAAY;MAAG,CAAA;IACpE;AACA,WAAOQ;EACT;EAEA,MAAMO,cAAc3C,SAA4C;AAC9D,UAAM,KAAKQ,QAAQR,OAAAA;AACnB,WAAOS,mBAAmBT,OAAAA;EAC5B;AACF;;;;;;;AAEA,IAAMS,qBAAqB,OAAOT,YAAAA;AAChC,SAAOnB,UAAU0C,KAAK,IAAIrB,WAAW,MAAMxB,aAAamD,UAAU,OAAO7B,QAAQsB,SAAS,CAAA,CAAA;AAC5F;;;AC/IA,SAASsB,gBAAAA,qBAAoB;AAYtB,IAAMC,qBAAqB,YAAA;AAChC,QAAMC,UAAU,MAAMC,cAAaC,YACjC;IACEC,MAAM;IACNC,YAAY;EACd,GACA,MACA;IAAC;IAAQ;GAAS;AAGpB,QAAMC,qBAAqB,MAAMJ,cAAaK,UAAU,OAAON,QAAQO,UAAU;AACjF,QAAMC,oBAAoB,MAAMP,cAAaK,UAAU,OAAON,QAAQS,SAAS;AAG/E,QAAMC,kBAAkB,IAAIC,WAAW,MAAMV,cAAaK,UAAU,OAAON,QAAQS,SAAS,CAAA;AAC5F,QAAMG,eAAeC,MAAMC,KAAKJ,eAAAA,EAC7BK,IAAI,CAACC,SAASA,KAAKC,SAAS,EAAA,EAAIC,SAAS,GAAG,GAAA,CAAA,EAC5CC,KAAK,EAAA;AAER,SAAO;IACLZ,YAAYF;IACZI,WAAWD;IACXI;EACF;AACF;AAKO,IAAMQ,kBAAkB,OAAOb,YAAwBE,cAAAA;AAC5D,SAAO;IACLF,YAAY,MAAMN,cAAaoB,UAAU,OAAOd,YAAY;MAAEJ,MAAM;MAASC,YAAY;IAAQ,GAAG,MAAM;MAAC;KAAO;IAClHK,WAAW,MAAMR,cAAaoB,UAAU,OAAOZ,WAAW;MAAEN,MAAM;MAASC,YAAY;IAAQ,GAAG,MAAM;MAAC;KAAS;EACpH;AACF;",
-  "names": ["Event", "synchronized", "subtleCrypto", "todo", "invariant", "PublicKey", "schema", "StorageType", "createStorage", "ComplexMap", "arrayToBuffer", "KeyRecord", "getCodecForType", "Keyring", "_keyCache", "hash", "keysUpdate", "_storage", "type", "RAM", "createDirectory", "sign", "key", "message", "keyPair", "_getKey", "Uint8Array", "name", "privateKey", "createKey", "generateKey", "namedCurve", "_setKey", "keyPairToPublicKey", "has", "file", "getOrCreateFile", "toHex", "size", "stat", "Error", "recordBytes", "read", "close", "record", "decode", "publicKey", "from", "equals", "importKey", "set", "get", "asUint8Array", "exportKey", "write", "encode", "flush", "emit", "deleteKey", "list", "keys", "path", "fileName", "split", "pop", "push", "fromHex", "importKeyPair", "subtleCrypto", "generateJWKKeyPair", "keyPair", "subtleCrypto", "generateKey", "name", "namedCurve", "privateKeyExported", "exportKey", "privateKey", "publicKeyExported", "publicKey", "publicKeyBuffer", "Uint8Array", "publicKeyHex", "Array", "from", "map", "byte", "toString", "padStart", "join", "parseJWKKeyPair", "importKey"]
-}

package/dist/lib/browser/meta.json

@@ -1 +0,0 @@
-{"inputs":{"src/keyring.ts":{"bytes":16719,"imports":[{"path":"@dxos/async","kind":"import-statement","external":true},{"path":"@dxos/crypto","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"@dxos/protocols/proto","kind":"import-statement","external":true},{"path":"@dxos/random-access-storage","kind":"import-statement","external":true},{"path":"@dxos/util","kind":"import-statement","external":true}],"format":"esm"},"src/testing.ts":{"bytes":5160,"imports":[{"path":"@dxos/crypto","kind":"import-statement","external":true}],"format":"esm"},"src/index.ts":{"bytes":539,"imports":[{"path":"src/keyring.ts","kind":"import-statement","original":"./keyring"},{"path":"src/testing.ts","kind":"import-statement","original":"./testing"}],"format":"esm"}},"outputs":{"dist/lib/browser/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":10614},"dist/lib/browser/index.mjs":{"imports":[{"path":"@dxos/async","kind":"import-statement","external":true},{"path":"@dxos/crypto","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/keys","kind":"import-statement","external":true},{"path":"@dxos/protocols/proto","kind":"import-statement","external":true},{"path":"@dxos/random-access-storage","kind":"import-statement","external":true},{"path":"@dxos/util","kind":"import-statement","external":true},{"path":"@dxos/crypto","kind":"import-statement","external":true}],"exports":["Keyring","generateJWKKeyPair","parseJWKKeyPair"],"entryPoint":"src/index.ts","inputs":{"src/keyring.ts":{"bytesInOutput":4905},"src/index.ts":{"bytesInOutput":0},"src/testing.ts":{"bytesInOutput":1103}},"bytes":6177}}}