@dxos/keys 0.5.8 → 0.5.9-main.2d0a5e6

package/dist/lib/browser/index.mjs

@@ -1,3 +1,9 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -5,11 +11,152 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js
+var require_base32_decode = __commonJS({
+  "node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js"(exports, module) {
+    var RFC46482 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    var RFC4648_HEX2 = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+    var CROCKFORD2 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    function readChar(alphabet, char) {
+      var idx = alphabet.indexOf(char);
+      if (idx === -1) {
+        throw new Error("Invalid character found: " + char);
+      }
+      return idx;
+    }
+    module.exports = function base32Decode3(input, variant) {
+      var alphabet;
+      switch (variant) {
+        case "RFC3548":
+        case "RFC4648":
+          alphabet = RFC46482;
+          input = input.replace(/=+$/, "");
+          break;
+        case "RFC4648-HEX":
+          alphabet = RFC4648_HEX2;
+          input = input.replace(/=+$/, "");
+          break;
+        case "Crockford":
+          alphabet = CROCKFORD2;
+          input = input.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1");
+          break;
+        default:
+          throw new Error("Unknown base32 variant: " + variant);
+      }
+      var length = input.length;
+      var bits = 0;
+      var value = 0;
+      var index = 0;
+      var output = new Uint8Array(length * 5 / 8 | 0);
+      for (var i = 0; i < length; i++) {
+        value = value << 5 | readChar(alphabet, input[i]);
+        bits += 5;
+        if (bits >= 8) {
+          output[index++] = value >>> bits - 8 & 255;
+          bits -= 8;
+        }
+      }
+      return output.buffer;
+    };
+  }
+});
+
+// packages/common/keys/src/public-key.ts
+var import_base32_decode = __toESM(require_base32_decode());
+
+// node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js
+function toDataView(data) {
+  if (data instanceof Int8Array || data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
+    return new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (data instanceof ArrayBuffer) {
+    return new DataView(data);
+  }
+  throw new TypeError("Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray");
+}
+
+// node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js
+var RFC4648 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+var RFC4648_HEX = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function base32Encode(data, variant, options) {
+  options = options || {};
+  let alphabet, defaultPadding;
+  switch (variant) {
+    case "RFC3548":
+    case "RFC4648":
+      alphabet = RFC4648;
+      defaultPadding = true;
+      break;
+    case "RFC4648-HEX":
+      alphabet = RFC4648_HEX;
+      defaultPadding = true;
+      break;
+    case "Crockford":
+      alphabet = CROCKFORD;
+      defaultPadding = false;
+      break;
+    default:
+      throw new Error("Unknown base32 variant: " + variant);
+  }
+  const padding = options.padding !== void 0 ? options.padding : defaultPadding;
+  const view = toDataView(data);
+  let bits = 0;
+  let value = 0;
+  let output = "";
+  for (let i = 0; i < view.byteLength; i++) {
+    value = value << 8 | view.getUint8(i);
+    bits += 8;
+    while (bits >= 5) {
+      output += alphabet[value >>> bits - 5 & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0) {
+    output += alphabet[value << 5 - bits & 31];
+  }
+  if (padding) {
+    while (output.length % 8 !== 0) {
+      output += "=";
+    }
+  }
+  return output;
+}
 
 // packages/common/keys/src/public-key.ts
 import { inspect } from "@dxos/node-std/util";
 import { truncateKey, devtoolsFormatter, equalsSymbol } from "@dxos/debug";
 import { invariant } from "@dxos/invariant";
+
+// packages/common/keys/src/random-bytes.ts
+var randomBytes = (length) => {
+  const webCrypto = globalThis.crypto ?? __require("@dxos/node-std/crypto").webcrypto;
+  const bytes = new Uint8Array(length);
+  webCrypto.getRandomValues(bytes);
+  return bytes;
+};
+
+// packages/common/keys/src/public-key.ts
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/keys/src/public-key.ts";
 var PUBLIC_KEY_LENGTH = 32;
 var SECRET_KEY_LENGTH = 64;
@@ -22,7 +169,7 @@ var PublicKey = class _PublicKey {
   static from(source) {
     invariant(source, void 0, {
       F: __dxlog_file,
-      L: 30,
+      L: 34,
       S: this,
       A: [
         "source",
@@ -77,6 +224,9 @@ var PublicKey = class _PublicKey {
   static random() {
     return _PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));
   }
+  static randomOfLength(length) {
+    return _PublicKey.from(randomBytes(length));
+  }
   static *randomSequence() {
     for (let i = 0; i < 1e4; i++) {
       yield _PublicKey.random();
@@ -111,7 +261,7 @@ var PublicKey = class _PublicKey {
   static bufferize(str) {
     invariant(typeof str === "string", "Invalid type", {
       F: __dxlog_file,
-      L: 129,
+      L: 137,
       S: this,
       A: [
         "typeof str === 'string'",
@@ -134,7 +284,7 @@ var PublicKey = class _PublicKey {
     }
     invariant(key instanceof Buffer, "Invalid type", {
       F: __dxlog_file,
-      L: 148,
+      L: 156,
       S: this,
       A: [
         "key instanceof Buffer",
@@ -150,6 +300,18 @@ var PublicKey = class _PublicKey {
   static hash(key) {
     return key.toHex();
   }
+  static fromMultibase32(encoded) {
+    invariant(encoded.startsWith("B"), "Invalid multibase32 encoding", {
+      F: __dxlog_file,
+      L: 169,
+      S: this,
+      A: [
+        "encoded.startsWith('B')",
+        "'Invalid multibase32 encoding'"
+      ]
+    });
+    return new _PublicKey(new Uint8Array((0, import_base32_decode.default)(encoded.slice(1), "RFC4648")));
+  }
   constructor(_value) {
     this._value = _value;
     if (!(_value instanceof Uint8Array)) {
@@ -171,6 +333,9 @@ var PublicKey = class _PublicKey {
   toHex() {
     return this.asBuffer().toString("hex");
   }
+  toMultibase32() {
+    return "B" + base32Encode(this._value, "RFC4648");
+  }
   truncate(length = void 0) {
     return truncateKey(this, length);
   }
@@ -275,15 +440,59 @@ var PublicKey = class _PublicKey {
     return this.equals(other);
   }
 };
-var randomBytes = (length) => {
-  const webCrypto = globalThis.crypto ?? __require("@dxos/node-std/crypto").webcrypto;
-  const bytes = new Uint8Array(length);
-  webCrypto.getRandomValues(bytes);
-  return bytes;
-};
+
+// packages/common/keys/src/space-id.ts
+var import_base32_decode2 = __toESM(require_base32_decode());
+import { invariant as invariant2 } from "@dxos/invariant";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/common/keys/src/space-id.ts";
+var SpaceId = Object.freeze({
+  byteLength: 20,
+  encode: (value) => {
+    invariant2(value instanceof Uint8Array, "Invalid type", {
+      F: __dxlog_file2,
+      L: 22,
+      S: void 0,
+      A: [
+        "value instanceof Uint8Array",
+        "'Invalid type'"
+      ]
+    });
+    invariant2(value.length === SpaceId.byteLength, "Invalid length", {
+      F: __dxlog_file2,
+      L: 23,
+      S: void 0,
+      A: [
+        "value.length === SpaceId.byteLength",
+        "'Invalid length'"
+      ]
+    });
+    return MULTIBASE_PREFIX + base32Encode(value, "RFC4648");
+  },
+  decode: (value) => {
+    invariant2(value.startsWith(MULTIBASE_PREFIX), "Invalid multibase32 encoding", {
+      F: __dxlog_file2,
+      L: 28,
+      S: void 0,
+      A: [
+        "value.startsWith(MULTIBASE_PREFIX)",
+        "'Invalid multibase32 encoding'"
+      ]
+    });
+    return new Uint8Array((0, import_base32_decode2.default)(value.slice(1), "RFC4648"));
+  },
+  isValid: (value) => {
+    return typeof value === "string" && value.startsWith(MULTIBASE_PREFIX) && value.length === ENCODED_LENGTH;
+  },
+  random: () => {
+    return SpaceId.encode(randomBytes(SpaceId.byteLength));
+  }
+});
+var MULTIBASE_PREFIX = "B";
+var ENCODED_LENGTH = 33;
 export {
   PUBLIC_KEY_LENGTH,
   PublicKey,
-  SECRET_KEY_LENGTH
+  SECRET_KEY_LENGTH,
+  SpaceId
 };
 //# sourceMappingURL=index.mjs.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../../../src/public-key.ts"],
-  "sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { inspect, type InspectOptionsStylized } from 'node:util';\n\nimport { truncateKey, devtoolsFormatter, type DevtoolsFormatter, equalsSymbol, type Equatable } from '@dxos/debug';\nimport { invariant } from '@dxos/invariant';\n\nexport const PUBLIC_KEY_LENGTH = 32;\nexport const SECRET_KEY_LENGTH = 64;\n\n/**\n * All representations that can be converted to a PublicKey.\n */\nexport type PublicKeyLike = PublicKey | Buffer | Uint8Array | ArrayBuffer | string;\n\n/**\n * The purpose of this class is to assure consistent use of keys throughout the project.\n * Keys should be maintained as buffers in objects and proto definitions, and converted to hex\n * strings as late as possible (eg, to log/display).\n */\nexport class PublicKey implements Equatable {\n  /**\n   * Creates new instance of PublicKey automatically determining the input format.\n   * @param source A Buffer, or Uint8Array, or hex encoded string, or something with an `asUint8Array` method on it\n   * @returns PublicKey\n   */\n  static from(source: PublicKeyLike): PublicKey {\n    invariant(source);\n    if (source instanceof PublicKey) {\n      return source;\n    } else if (source instanceof Buffer) {\n      return new PublicKey(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));\n    } else if (source instanceof Uint8Array) {\n      return new PublicKey(source);\n    } else if (source instanceof ArrayBuffer) {\n      return new PublicKey(new Uint8Array(source));\n    } else if (typeof source === 'string') {\n      // TODO(burdon): Check length.\n      return PublicKey.fromHex(source);\n    } else if ((<any>source).asUint8Array) {\n      return new PublicKey((<any>source).asUint8Array());\n    } else {\n      throw new TypeError(`Unable to create PublicKey from ${source}`);\n    }\n  }\n\n  /**\n   * Same as `PublicKey.from` but does not throw and instead returns a `{ key: PublicKey }` or `{ error: Error }`\n   * @param source Same PublicKeyLike argument as for `PublicKey.from`\n   * @returns PublicKey\n   */\n  static safeFrom(source?: PublicKeyLike): PublicKey | undefined {\n    if (!source) {\n      return undefined;\n    }\n\n    try {\n      const key = PublicKey.from(source);\n      // TODO(wittjosiah): Space keys don't pass this check.\n      // if (key.length !== PUBLIC_KEY_LENGTH && key.length !== SECRET_KEY_LENGTH) {\n      //   return undefined;\n      // }\n      return key;\n    } catch (err: any) {\n      return undefined;\n    }\n  }\n\n  /**\n   * Creates new instance of PublicKey from hex string.\n   */\n  static fromHex(hex: string) {\n    if (hex.startsWith('0x')) {\n      hex = hex.slice(2);\n    }\n\n    const buf = Buffer.from(hex, 'hex');\n    // TODO(burdon): Test if key.\n    return new PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));\n  }\n\n  /**\n   * Creates a new key.\n   */\n  static random(): PublicKey {\n    // TODO(burdon): Enable seed for debugging.\n    return PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));\n  }\n\n  static *randomSequence(): Generator<PublicKey> {\n    for (let i = 0; i < 1_0000; i++) {\n      // Counter just to protect against infinite loops.\n      yield PublicKey.random();\n    }\n    throw new Error('Too many keys requested');\n  }\n\n  /**\n   * Tests if provided values is an instance of PublicKey.\n   */\n  static isPublicKey(value: any): value is PublicKey {\n    return value instanceof PublicKey;\n  }\n\n  /**\n   * Asserts that provided values is an instance of PublicKey.\n   */\n  static assertValidPublicKey(value: any): asserts value is PublicKey {\n    if (!this.isPublicKey(value)) {\n      throw new TypeError('Invalid PublicKey');\n    }\n  }\n\n  /**\n   * Tests two keys for equality.\n   */\n  static equals(left: PublicKeyLike, right: PublicKeyLike) {\n    return PublicKey.from(left).equals(right);\n  }\n\n  /**\n   * @param str string representation of key.\n   * @return Key buffer.\n   * @deprecated All keys should be represented as instances of PublicKey.\n   */\n  static bufferize(str: string): Buffer {\n    invariant(typeof str === 'string', 'Invalid type');\n    const buffer = Buffer.from(str, 'hex');\n    // invariant(buffer.length === PUBLIC_KEY_LENGTH || buffer.length === SECRET_KEY_LENGTH,\n    //   `Invalid key length: ${buffer.length}`);\n    return buffer;\n  }\n\n  /**\n   * @param key key like data structure (but not PublicKey which should use toString).\n   * @return Hex string representation of key.\n   * @deprecated All keys should be represented as instances of PublicKey.\n   */\n  static stringify(key: Buffer | Uint8Array | ArrayBuffer): string {\n    if (key instanceof PublicKey) {\n      key = key.asBuffer();\n    } else if (key instanceof Uint8Array) {\n      key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);\n    }\n\n    invariant(key instanceof Buffer, 'Invalid type');\n    return key.toString('hex');\n  }\n\n  /**\n   * To be used with ComplexMap and ComplexSet.\n   * Returns a scalar representation for this key.\n   */\n  static hash(key: PublicKey): string {\n    return key.toHex();\n  }\n\n  constructor(private readonly _value: Uint8Array) {\n    if (!(_value instanceof Uint8Array)) {\n      throw new TypeError(`Expected Uint8Array, got: ${_value}`);\n    }\n  }\n\n  toString(): string {\n    return this.toHex();\n  }\n\n  toJSON() {\n    return this.toHex();\n  }\n\n  toJSONL(): string {\n    return this.truncate();\n  }\n\n  get length() {\n    return this._value.length;\n  }\n\n  toHex(): string {\n    return this.asBuffer().toString('hex');\n  }\n\n  truncate(length = undefined) {\n    return truncateKey(this, length);\n  }\n\n  asBuffer(): Buffer {\n    return Buffer.from(this._value.buffer, this._value.byteOffset, this._value.byteLength);\n  }\n\n  asUint8Array(): Uint8Array {\n    return this._value;\n  }\n\n  getInsecureHash(modulo: number) {\n    return Math.abs(this._value.reduce((acc, val) => (acc ^ val) | 0, 0)) % modulo;\n  }\n\n  /**\n   * Used by Node.js to get textual representation of this object when it's printed with a `console.log` statement.\n   */\n  [inspect.custom](depth: number, options: InspectOptionsStylized) {\n    if (!options.colors || typeof process.stdout.hasColors !== 'function' || !process.stdout.hasColors()) {\n      return `<PublicKey ${this.truncate()}>`;\n    }\n\n    const printControlCode = (code: number) => {\n      return `\\x1b[${code}m`;\n    };\n\n    // NOTE: Keep in sync with formatter colors.\n    const colors = [\n      'red',\n      'green',\n      'yellow',\n      'blue',\n      'magenta',\n      'cyan',\n      'redBright',\n      'greenBright',\n      'yellowBright',\n      'blueBright',\n      'magentaBright',\n      'cyanBright',\n      'whiteBright',\n    ];\n    const color = colors[this.getInsecureHash(colors.length)];\n\n    return `PublicKey(${printControlCode(inspect.colors[color]![0])}${this.truncate()}${printControlCode(\n      inspect.colors.reset![0],\n    )})`;\n  }\n\n  get [devtoolsFormatter](): DevtoolsFormatter {\n    return {\n      header: () => {\n        // NOTE: Keep in sync with inspect colors.\n        const colors = [\n          'darkred',\n          'green',\n          'orange',\n          'blue',\n          'darkmagenta',\n          'darkcyan',\n          'red',\n          'green',\n          'orange',\n          'blue',\n          'magenta',\n          'darkcyan',\n          'black',\n        ];\n        const color = colors[this.getInsecureHash(colors.length)];\n\n        return [\n          'span',\n          {},\n          ['span', {}, 'PublicKey('],\n          ['span', { style: `color: ${color};` }, this.truncate()],\n          ['span', {}, ')'],\n        ];\n      },\n    };\n  }\n\n  /**\n   * Test this key for equality with some other key.\n   */\n  equals(other: PublicKeyLike) {\n    const otherConverted = PublicKey.from(other);\n    if (this._value.length !== otherConverted._value.length) {\n      return false;\n    }\n\n    let equal = true;\n    for (let i = 0; i < this._value.length; i++) {\n      equal &&= this._value[i] === otherConverted._value[i];\n    }\n\n    return equal;\n  }\n\n  [equalsSymbol](other: any) {\n    if (!PublicKey.isPublicKey(other)) {\n      return false;\n    }\n\n    return this.equals(other);\n  }\n}\n\nconst randomBytes = (length: number) => {\n  // globalThis.crypto is not available in Node.js when running in vitest even though the documentation says it should be.\n  // eslint-disable-next-line @typescript-eslint/no-var-requires\n  const webCrypto = globalThis.crypto ?? require('node:crypto').webcrypto;\n\n  const bytes = new Uint8Array(length);\n  webCrypto.getRandomValues(bytes);\n  return bytes;\n};\n"],
-  "mappings": ";;;;;;;;;AAIA,SAASA,eAA4C;AAErD,SAASC,aAAaC,mBAA2CC,oBAAoC;AACrG,SAASC,iBAAiB;;AAEnB,IAAMC,oBAAoB;AAC1B,IAAMC,oBAAoB;AAY1B,IAAMC,YAAN,MAAMA,WAAAA;;;;;;EAMX,OAAOC,KAAKC,QAAkC;AAC5CL,cAAUK,QAAAA,QAAAA;;;;;;;;;AACV,QAAIA,kBAAkBF,YAAW;AAC/B,aAAOE;IACT,WAAWA,kBAAkBC,QAAQ;AACnC,aAAO,IAAIH,WAAU,IAAII,WAAWF,OAAOG,QAAQH,OAAOI,YAAYJ,OAAOK,UAAU,CAAA;IACzF,WAAWL,kBAAkBE,YAAY;AACvC,aAAO,IAAIJ,WAAUE,MAAAA;IACvB,WAAWA,kBAAkBM,aAAa;AACxC,aAAO,IAAIR,WAAU,IAAII,WAAWF,MAAAA,CAAAA;IACtC,WAAW,OAAOA,WAAW,UAAU;AAErC,aAAOF,WAAUS,QAAQP,MAAAA;IAC3B,WAAiBA,OAAQQ,cAAc;AACrC,aAAO,IAAIV,WAAgBE,OAAQQ,aAAY,CAAA;IACjD,OAAO;AACL,YAAM,IAAIC,UAAU,mCAAmCT,MAAAA,EAAQ;IACjE;EACF;;;;;;EAOA,OAAOU,SAASV,QAA+C;AAC7D,QAAI,CAACA,QAAQ;AACX,aAAOW;IACT;AAEA,QAAI;AACF,YAAMC,MAAMd,WAAUC,KAAKC,MAAAA;AAK3B,aAAOY;IACT,SAASC,KAAU;AACjB,aAAOF;IACT;EACF;;;;EAKA,OAAOJ,QAAQO,KAAa;AAC1B,QAAIA,IAAIC,WAAW,IAAA,GAAO;AACxBD,YAAMA,IAAIE,MAAM,CAAA;IAClB;AAEA,UAAMC,MAAMhB,OAAOF,KAAKe,KAAK,KAAA;AAE7B,WAAO,IAAIhB,WAAU,IAAII,WAAWe,IAAId,QAAQc,IAAIb,YAAYa,IAAIZ,UAAU,CAAA;EAChF;;;;EAKA,OAAOa,SAAoB;AAEzB,WAAOpB,WAAUC,KAAKoB,YAAYvB,iBAAAA,CAAAA;EACpC;EAEA,QAAQwB,iBAAuC;AAC7C,aAASC,IAAI,GAAGA,IAAI,KAAQA,KAAK;AAE/B,YAAMvB,WAAUoB,OAAM;IACxB;AACA,UAAM,IAAII,MAAM,yBAAA;EAClB;;;;EAKA,OAAOC,YAAYC,OAAgC;AACjD,WAAOA,iBAAiB1B;EAC1B;;;;EAKA,OAAO2B,qBAAqBD,OAAwC;AAClE,QAAI,CAAC,KAAKD,YAAYC,KAAAA,GAAQ;AAC5B,YAAM,IAAIf,UAAU,mBAAA;IACtB;EACF;;;;EAKA,OAAOiB,OAAOC,MAAqBC,OAAsB;AACvD,WAAO9B,WAAUC,KAAK4B,IAAAA,EAAMD,OAAOE,KAAAA;EACrC;;;;;;EAOA,OAAOC,UAAUC,KAAqB;AACpCnC,cAAU,OAAOmC,QAAQ,UAAU,gBAAA;;;;;;;;;AACnC,UAAM3B,SAASF,OAAOF,KAAK+B,KAAK,KAAA;AAGhC,WAAO3B;EACT;;;;;;EAOA,OAAO4B,UAAUnB,KAAgD;AAC/D,QAAIA,eAAed,YAAW;AAC5Bc,YAAMA,IAAIoB,SAAQ;IACpB,WAAWpB,eAAeV,YAAY;AACpCU,YAAMX,OAAOF,KAAKa,IAAIT,QAAQS,IAAIR,YAAYQ,IAAIP,UAAU;IAC9D;AAEAV,cAAUiB,eAAeX,QAAQ,gBAAA;;;;;;;;;AACjC,WAAOW,IAAIqB,SAAS,KAAA;EACtB;;;;;EAMA,OAAOC,KAAKtB,KAAwB;AAClC,WAAOA,IAAIuB,MAAK;EAClB;EAEAC,YAA6BC,QAAoB;SAApBA,SAAAA;AAC3B,QAAI,EAAEA,kBAAkBnC,aAAa;AACnC,YAAM,IAAIO,UAAU,6BAA6B4B,MAAAA,EAAQ;IAC3D;EACF;EAEAJ,WAAmB;AACjB,WAAO,KAAKE,MAAK;EACnB;EAEAG,SAAS;AACP,WAAO,KAAKH,MAAK;EACnB;EAEAI,UAAkB;AAChB,WAAO,KAAKC,SAAQ;EACtB;EAEA,IAAIC,SAAS;AACX,WAAO,KAAKJ,OAAOI;EACrB;EAEAN,QAAgB;AACd,WAAO,KAAKH,SAAQ,EAAGC,SAAS,KAAA;EAClC;EAEAO,SAASC,SAAS9B,QAAW;AAC3B,WAAOnB,YAAY,MAAMiD,MAAAA;EAC3B;EAEAT,WAAmB;AACjB,WAAO/B,OAAOF,KAAK,KAAKsC,OAAOlC,QAAQ,KAAKkC,OAAOjC,YAAY,KAAKiC,OAAOhC,UAAU;EACvF;EAEAG,eAA2B;AACzB,WAAO,KAAK6B;EACd;EAEAK,gBAAgBC,QAAgB;AAC9B,WAAOC,KAAKC,IAAI,KAAKR,OAAOS,OAAO,CAACC,KAAKC,QAASD,MAAMC,MAAO,GAAG,CAAA,CAAA,IAAML;EAC1E;;;;EAKA,CAACpD,QAAQ0D,MAAM,EAAEC,OAAeC,SAAiC;AAC/D,QAAI,CAACA,QAAQC,UAAU,OAAOC,QAAQC,OAAOC,cAAc,cAAc,CAACF,QAAQC,OAAOC,UAAS,GAAI;AACpG,aAAO,cAAc,KAAKf,SAAQ,CAAA;IACpC;AAEA,UAAMgB,mBAAmB,CAACC,SAAAA;AACxB,aAAO,QAAQA,IAAAA;IACjB;AAGA,UAAML,SAAS;MACb;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;;AAEF,UAAMM,QAAQN,OAAO,KAAKV,gBAAgBU,OAAOX,MAAM,CAAA;AAEvD,WAAO,aAAae,iBAAiBjE,QAAQ6D,OAAOM,KAAAA,EAAQ,CAAA,CAAE,CAAA,GAAI,KAAKlB,SAAQ,CAAA,GAAKgB,iBAClFjE,QAAQ6D,OAAOO,MAAO,CAAA,CAAE,CAAA;EAE5B;EAEA,KAAKlE,iBAAAA,IAAwC;AAC3C,WAAO;MACLmE,QAAQ,MAAA;AAEN,cAAMR,SAAS;UACb;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;AAEF,cAAMM,QAAQN,OAAO,KAAKV,gBAAgBU,OAAOX,MAAM,CAAA;AAEvD,eAAO;UACL;UACA,CAAC;UACD;YAAC;YAAQ,CAAC;YAAG;;UACb;YAAC;YAAQ;cAAEoB,OAAO,UAAUH,KAAAA;YAAS;YAAG,KAAKlB,SAAQ;;UACrD;YAAC;YAAQ,CAAC;YAAG;;;MAEjB;IACF;EACF;;;;EAKAd,OAAOoC,OAAsB;AAC3B,UAAMC,iBAAiBjE,WAAUC,KAAK+D,KAAAA;AACtC,QAAI,KAAKzB,OAAOI,WAAWsB,eAAe1B,OAAOI,QAAQ;AACvD,aAAO;IACT;AAEA,QAAIuB,QAAQ;AACZ,aAAS3C,IAAI,GAAGA,IAAI,KAAKgB,OAAOI,QAAQpB,KAAK;AAC3C2C,gBAAU,KAAK3B,OAAOhB,CAAAA,MAAO0C,eAAe1B,OAAOhB,CAAAA;IACrD;AAEA,WAAO2C;EACT;EAEA,CAACtE,YAAAA,EAAcoE,OAAY;AACzB,QAAI,CAAChE,WAAUyB,YAAYuC,KAAAA,GAAQ;AACjC,aAAO;IACT;AAEA,WAAO,KAAKpC,OAAOoC,KAAAA;EACrB;AACF;AAEA,IAAM3C,cAAc,CAACsB,WAAAA;AAGnB,QAAMwB,YAAYC,WAAWC,UAAUC,UAAQ,uBAAA,EAAeC;AAE9D,QAAMC,QAAQ,IAAIpE,WAAWuC,MAAAA;AAC7BwB,YAAUM,gBAAgBD,KAAAA;AAC1B,SAAOA;AACT;",
-  "names": ["inspect", "truncateKey", "devtoolsFormatter", "equalsSymbol", "invariant", "PUBLIC_KEY_LENGTH", "SECRET_KEY_LENGTH", "PublicKey", "from", "source", "Buffer", "Uint8Array", "buffer", "byteOffset", "byteLength", "ArrayBuffer", "fromHex", "asUint8Array", "TypeError", "safeFrom", "undefined", "key", "err", "hex", "startsWith", "slice", "buf", "random", "randomBytes", "randomSequence", "i", "Error", "isPublicKey", "value", "assertValidPublicKey", "equals", "left", "right", "bufferize", "str", "stringify", "asBuffer", "toString", "hash", "toHex", "constructor", "_value", "toJSON", "toJSONL", "truncate", "length", "getInsecureHash", "modulo", "Math", "abs", "reduce", "acc", "val", "custom", "depth", "options", "colors", "process", "stdout", "hasColors", "printControlCode", "code", "color", "reset", "header", "style", "other", "otherConverted", "equal", "webCrypto", "globalThis", "crypto", "require", "webcrypto", "bytes", "getRandomValues"]
+  "sources": ["../../../../../../node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js", "../../../src/public-key.ts", "../../../../../../node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js", "../../../../../../node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js", "../../../src/random-bytes.ts", "../../../src/space-id.ts"],
+  "sourcesContent": ["var RFC4648 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'\nvar RFC4648_HEX = '0123456789ABCDEFGHIJKLMNOPQRSTUV'\nvar CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'\n\nfunction readChar (alphabet, char) {\n  var idx = alphabet.indexOf(char)\n\n  if (idx === -1) {\n    throw new Error('Invalid character found: ' + char)\n  }\n\n  return idx\n}\n\nmodule.exports = function base32Decode (input, variant) {\n  var alphabet\n\n  switch (variant) {\n    case 'RFC3548':\n    case 'RFC4648':\n      alphabet = RFC4648\n      input = input.replace(/=+$/, '')\n      break\n    case 'RFC4648-HEX':\n      alphabet = RFC4648_HEX\n      input = input.replace(/=+$/, '')\n      break\n    case 'Crockford':\n      alphabet = CROCKFORD\n      input = input.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')\n      break\n    default:\n      throw new Error('Unknown base32 variant: ' + variant)\n  }\n\n  var length = input.length\n\n  var bits = 0\n  var value = 0\n\n  var index = 0\n  var output = new Uint8Array((length * 5 / 8) | 0)\n\n  for (var i = 0; i < length; i++) {\n    value = (value << 5) | readChar(alphabet, input[i])\n    bits += 5\n\n    if (bits >= 8) {\n      output[index++] = (value >>> (bits - 8)) & 255\n      bits -= 8\n    }\n  }\n\n  return output.buffer\n}\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport base32Decode from 'base32-decode';\nimport base32Encode from 'base32-encode';\nimport { inspect, type InspectOptionsStylized } from 'node:util';\n\nimport { truncateKey, devtoolsFormatter, type DevtoolsFormatter, equalsSymbol, type Equatable } from '@dxos/debug';\nimport { invariant } from '@dxos/invariant';\n\nimport { randomBytes } from './random-bytes';\n\nexport const PUBLIC_KEY_LENGTH = 32;\nexport const SECRET_KEY_LENGTH = 64;\n\n/**\n * All representations that can be converted to a PublicKey.\n */\nexport type PublicKeyLike = PublicKey | Buffer | Uint8Array | ArrayBuffer | string;\n\n/**\n * The purpose of this class is to assure consistent use of keys throughout the project.\n * Keys should be maintained as buffers in objects and proto definitions, and converted to hex\n * strings as late as possible (eg, to log/display).\n */\nexport class PublicKey implements Equatable {\n  /**\n   * Creates new instance of PublicKey automatically determining the input format.\n   * @param source A Buffer, or Uint8Array, or hex encoded string, or something with an `asUint8Array` method on it\n   * @returns PublicKey\n   */\n  static from(source: PublicKeyLike): PublicKey {\n    invariant(source);\n    if (source instanceof PublicKey) {\n      return source;\n    } else if (source instanceof Buffer) {\n      return new PublicKey(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));\n    } else if (source instanceof Uint8Array) {\n      return new PublicKey(source);\n    } else if (source instanceof ArrayBuffer) {\n      return new PublicKey(new Uint8Array(source));\n    } else if (typeof source === 'string') {\n      // TODO(burdon): Check length.\n      return PublicKey.fromHex(source);\n    } else if ((<any>source).asUint8Array) {\n      return new PublicKey((<any>source).asUint8Array());\n    } else {\n      throw new TypeError(`Unable to create PublicKey from ${source}`);\n    }\n  }\n\n  /**\n   * Same as `PublicKey.from` but does not throw and instead returns a `{ key: PublicKey }` or `{ error: Error }`\n   * @param source Same PublicKeyLike argument as for `PublicKey.from`\n   * @returns PublicKey\n   */\n  static safeFrom(source?: PublicKeyLike): PublicKey | undefined {\n    if (!source) {\n      return undefined;\n    }\n\n    try {\n      const key = PublicKey.from(source);\n      // TODO(wittjosiah): Space keys don't pass this check.\n      // if (key.length !== PUBLIC_KEY_LENGTH && key.length !== SECRET_KEY_LENGTH) {\n      //   return undefined;\n      // }\n      return key;\n    } catch (err: any) {\n      return undefined;\n    }\n  }\n\n  /**\n   * Creates new instance of PublicKey from hex string.\n   */\n  static fromHex(hex: string) {\n    if (hex.startsWith('0x')) {\n      hex = hex.slice(2);\n    }\n\n    const buf = Buffer.from(hex, 'hex');\n    // TODO(burdon): Test if key.\n    return new PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));\n  }\n\n  /**\n   * Creates a new key.\n   */\n  static random(): PublicKey {\n    // TODO(burdon): Enable seed for debugging.\n    return PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));\n  }\n\n  static randomOfLength(length: number): PublicKey {\n    return PublicKey.from(randomBytes(length));\n  }\n\n  static *randomSequence(): Generator<PublicKey> {\n    for (let i = 0; i < 1_0000; i++) {\n      // Counter just to protect against infinite loops.\n      yield PublicKey.random();\n    }\n    throw new Error('Too many keys requested');\n  }\n\n  /**\n   * Tests if provided values is an instance of PublicKey.\n   */\n  static isPublicKey(value: any): value is PublicKey {\n    return value instanceof PublicKey;\n  }\n\n  /**\n   * Asserts that provided values is an instance of PublicKey.\n   */\n  static assertValidPublicKey(value: any): asserts value is PublicKey {\n    if (!this.isPublicKey(value)) {\n      throw new TypeError('Invalid PublicKey');\n    }\n  }\n\n  /**\n   * Tests two keys for equality.\n   */\n  static equals(left: PublicKeyLike, right: PublicKeyLike) {\n    return PublicKey.from(left).equals(right);\n  }\n\n  /**\n   * @param str string representation of key.\n   * @return Key buffer.\n   * @deprecated All keys should be represented as instances of PublicKey.\n   */\n  static bufferize(str: string): Buffer {\n    invariant(typeof str === 'string', 'Invalid type');\n    const buffer = Buffer.from(str, 'hex');\n    // invariant(buffer.length === PUBLIC_KEY_LENGTH || buffer.length === SECRET_KEY_LENGTH,\n    //   `Invalid key length: ${buffer.length}`);\n    return buffer;\n  }\n\n  /**\n   * @param key key like data structure (but not PublicKey which should use toString).\n   * @return Hex string representation of key.\n   * @deprecated All keys should be represented as instances of PublicKey.\n   */\n  static stringify(key: Buffer | Uint8Array | ArrayBuffer): string {\n    if (key instanceof PublicKey) {\n      key = key.asBuffer();\n    } else if (key instanceof Uint8Array) {\n      key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);\n    }\n\n    invariant(key instanceof Buffer, 'Invalid type');\n    return key.toString('hex');\n  }\n\n  /**\n   * To be used with ComplexMap and ComplexSet.\n   * Returns a scalar representation for this key.\n   */\n  static hash(key: PublicKey): string {\n    return key.toHex();\n  }\n\n  static fromMultibase32(encoded: string): PublicKey {\n    invariant(encoded.startsWith('B'), 'Invalid multibase32 encoding');\n\n    return new PublicKey(new Uint8Array(base32Decode(encoded.slice(1), 'RFC4648')));\n  }\n\n  constructor(private readonly _value: Uint8Array) {\n    if (!(_value instanceof Uint8Array)) {\n      throw new TypeError(`Expected Uint8Array, got: ${_value}`);\n    }\n  }\n\n  toString(): string {\n    return this.toHex();\n  }\n\n  toJSON() {\n    return this.toHex();\n  }\n\n  toJSONL(): string {\n    return this.truncate();\n  }\n\n  get length() {\n    return this._value.length;\n  }\n\n  toHex(): string {\n    return this.asBuffer().toString('hex');\n  }\n\n  toMultibase32(): string {\n    return 'B' + base32Encode(this._value, 'RFC4648');\n  }\n\n  truncate(length = undefined) {\n    return truncateKey(this, length);\n  }\n\n  asBuffer(): Buffer {\n    return Buffer.from(this._value.buffer, this._value.byteOffset, this._value.byteLength);\n  }\n\n  asUint8Array(): Uint8Array {\n    return this._value;\n  }\n\n  getInsecureHash(modulo: number) {\n    return Math.abs(this._value.reduce((acc, val) => (acc ^ val) | 0, 0)) % modulo;\n  }\n\n  /**\n   * Used by Node.js to get textual representation of this object when it's printed with a `console.log` statement.\n   */\n  [inspect.custom](depth: number, options: InspectOptionsStylized) {\n    if (!options.colors || typeof process.stdout.hasColors !== 'function' || !process.stdout.hasColors()) {\n      return `<PublicKey ${this.truncate()}>`;\n    }\n\n    const printControlCode = (code: number) => {\n      return `\\x1b[${code}m`;\n    };\n\n    // NOTE: Keep in sync with formatter colors.\n    const colors = [\n      'red',\n      'green',\n      'yellow',\n      'blue',\n      'magenta',\n      'cyan',\n      'redBright',\n      'greenBright',\n      'yellowBright',\n      'blueBright',\n      'magentaBright',\n      'cyanBright',\n      'whiteBright',\n    ];\n    const color = colors[this.getInsecureHash(colors.length)];\n\n    return `PublicKey(${printControlCode(inspect.colors[color]![0])}${this.truncate()}${printControlCode(\n      inspect.colors.reset![0],\n    )})`;\n  }\n\n  get [devtoolsFormatter](): DevtoolsFormatter {\n    return {\n      header: () => {\n        // NOTE: Keep in sync with inspect colors.\n        const colors = [\n          'darkred',\n          'green',\n          'orange',\n          'blue',\n          'darkmagenta',\n          'darkcyan',\n          'red',\n          'green',\n          'orange',\n          'blue',\n          'magenta',\n          'darkcyan',\n          'black',\n        ];\n        const color = colors[this.getInsecureHash(colors.length)];\n\n        return [\n          'span',\n          {},\n          ['span', {}, 'PublicKey('],\n          ['span', { style: `color: ${color};` }, this.truncate()],\n          ['span', {}, ')'],\n        ];\n      },\n    };\n  }\n\n  /**\n   * Test this key for equality with some other key.\n   */\n  equals(other: PublicKeyLike) {\n    const otherConverted = PublicKey.from(other);\n    if (this._value.length !== otherConverted._value.length) {\n      return false;\n    }\n\n    let equal = true;\n    for (let i = 0; i < this._value.length; i++) {\n      equal &&= this._value[i] === otherConverted._value[i];\n    }\n\n    return equal;\n  }\n\n  [equalsSymbol](other: any) {\n    if (!PublicKey.isPublicKey(other)) {\n      return false;\n    }\n\n    return this.equals(other);\n  }\n}\n", "export default function toDataView (data) {\n  if (data instanceof Int8Array || data instanceof Uint8Array || data instanceof Uint8ClampedArray) {\n    return new DataView(data.buffer, data.byteOffset, data.byteLength)\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return new DataView(data)\n  }\n\n  throw new TypeError('Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray')\n}\n", "import toDataView from 'to-data-view'\n\nconst RFC4648 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'\nconst RFC4648_HEX = '0123456789ABCDEFGHIJKLMNOPQRSTUV'\nconst CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'\n\nexport default function base32Encode (data, variant, options) {\n  options = options || {}\n  let alphabet, defaultPadding\n\n  switch (variant) {\n    case 'RFC3548':\n    case 'RFC4648':\n      alphabet = RFC4648\n      defaultPadding = true\n      break\n    case 'RFC4648-HEX':\n      alphabet = RFC4648_HEX\n      defaultPadding = true\n      break\n    case 'Crockford':\n      alphabet = CROCKFORD\n      defaultPadding = false\n      break\n    default:\n      throw new Error('Unknown base32 variant: ' + variant)\n  }\n\n  const padding = (options.padding !== undefined ? options.padding : defaultPadding)\n  const view = toDataView(data)\n\n  let bits = 0\n  let value = 0\n  let output = ''\n\n  for (let i = 0; i < view.byteLength; i++) {\n    value = (value << 8) | view.getUint8(i)\n    bits += 8\n\n    while (bits >= 5) {\n      output += alphabet[(value >>> (bits - 5)) & 31]\n      bits -= 5\n    }\n  }\n\n  if (bits > 0) {\n    output += alphabet[(value << (5 - bits)) & 31]\n  }\n\n  if (padding) {\n    while ((output.length % 8) !== 0) {\n      output += '='\n    }\n  }\n\n  return output\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nexport const randomBytes = (length: number) => {\n  // globalThis.crypto is not available in Node.js when running in vitest even though the documentation says it should be.\n  // eslint-disable-next-line @typescript-eslint/no-var-requires\n  const webCrypto = globalThis.crypto ?? require('node:crypto').webcrypto;\n\n  const bytes = new Uint8Array(length);\n  webCrypto.getRandomValues(bytes);\n  return bytes;\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport base32Decode from 'base32-decode';\nimport base32Encode from 'base32-encode';\n\nimport { invariant } from '@dxos/invariant';\n\nimport { randomBytes } from './random-bytes';\n\n/**\n * A unique identifier for a space.\n * Space keys are generated by creating a keypair, and then taking the first 20 bytes of the SHA-256 hash of the public key and encoding them to multibase RFC4648 base-32 format (prefixed with B, see Multibase Table).\n * @example BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE\n */\nexport type SpaceId = string & { __SpaceId: true };\n\nexport const SpaceId = Object.freeze({\n  byteLength: 20,\n  encode: (value: Uint8Array): SpaceId => {\n    invariant(value instanceof Uint8Array, 'Invalid type');\n    invariant(value.length === SpaceId.byteLength, 'Invalid length');\n\n    return (MULTIBASE_PREFIX + base32Encode(value, 'RFC4648')) as SpaceId;\n  },\n  decode: (value: SpaceId): Uint8Array => {\n    invariant(value.startsWith(MULTIBASE_PREFIX), 'Invalid multibase32 encoding');\n\n    return new Uint8Array(base32Decode(value.slice(1), 'RFC4648'));\n  },\n  isValid: (value: string): value is SpaceId => {\n    return typeof value === 'string' && value.startsWith(MULTIBASE_PREFIX) && value.length === ENCODED_LENGTH;\n  },\n  random: (): SpaceId => {\n    return SpaceId.encode(randomBytes(SpaceId.byteLength));\n  },\n});\n\n/**\n * Denotes RFC4648 base-32 format.\n */\nconst MULTIBASE_PREFIX = 'B';\n\nconst ENCODED_LENGTH = 33;\n"],
+  "mappings": "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",
+  "names": ["RFC4648", "RFC4648_HEX", "CROCKFORD", "base32Decode", "inspect", "truncateKey", "devtoolsFormatter", "equalsSymbol", "invariant", "randomBytes", "length", "webCrypto", "globalThis", "crypto", "require", "webcrypto", "bytes", "Uint8Array", "getRandomValues", "PUBLIC_KEY_LENGTH", "SECRET_KEY_LENGTH", "PublicKey", "from", "source", "invariant", "Buffer", "Uint8Array", "buffer", "byteOffset", "byteLength", "ArrayBuffer", "fromHex", "asUint8Array", "TypeError", "safeFrom", "undefined", "key", "err", "hex", "startsWith", "slice", "buf", "random", "randomBytes", "randomOfLength", "length", "randomSequence", "i", "Error", "isPublicKey", "value", "assertValidPublicKey", "equals", "left", "right", "bufferize", "str", "stringify", "asBuffer", "toString", "hash", "toHex", "fromMultibase32", "encoded", "base32Decode", "constructor", "_value", "toJSON", "toJSONL", "truncate", "toMultibase32", "base32Encode", "truncateKey", "getInsecureHash", "modulo", "Math", "abs", "reduce", "acc", "val", "inspect", "custom", "depth", "options", "colors", "process", "stdout", "hasColors", "printControlCode", "code", "color", "reset", "devtoolsFormatter", "header", "style", "other", "otherConverted", "equal", "equalsSymbol", "import_base32_decode", "invariant", "SpaceId", "Object", "freeze", "byteLength", "encode", "value", "invariant", "Uint8Array", "length", "MULTIBASE_PREFIX", "base32Encode", "decode", "startsWith", "base32Decode", "slice", "isValid", "ENCODED_LENGTH", "random", "randomBytes"]
 }

package/dist/lib/browser/meta.json

@@ -1 +1 @@
-{"inputs":{"packages/common/keys/src/public-key.ts":{"bytes":29335,"imports":[{"path":"@dxos/node-std/util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/node-std/crypto","kind":"require-call","external":true}],"format":"esm"},"packages/common/keys/src/types.ts":{"bytes":673,"imports":[],"format":"esm"},"packages/common/keys/src/index.ts":{"bytes":579,"imports":[{"path":"packages/common/keys/src/public-key.ts","kind":"import-statement","original":"./public-key"},{"path":"packages/common/keys/src/types.ts","kind":"import-statement","original":"./types"}],"format":"esm"}},"outputs":{"packages/common/keys/dist/lib/browser/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":13773},"packages/common/keys/dist/lib/browser/index.mjs":{"imports":[{"path":"@dxos/node-std/util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/node-std/crypto","kind":"require-call","external":true}],"exports":["PUBLIC_KEY_LENGTH","PublicKey","SECRET_KEY_LENGTH"],"entryPoint":"packages/common/keys/src/index.ts","inputs":{"packages/common/keys/src/public-key.ts":{"bytesInOutput":7265},"packages/common/keys/src/index.ts":{"bytesInOutput":0}},"bytes":7778}}}
+{"inputs":{"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js":{"bytes":1217,"imports":[],"format":"cjs"},"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js":{"bytes":410,"imports":[],"format":"esm"},"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js":{"bytes":1266,"imports":[{"path":"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js","kind":"import-statement","original":"to-data-view"}],"format":"esm"},"packages/common/keys/src/random-bytes.ts":{"bytes":1792,"imports":[{"path":"@dxos/node-std/crypto","kind":"require-call","external":true}],"format":"esm"},"packages/common/keys/src/public-key.ts":{"bytes":30143,"imports":[{"path":"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js","kind":"import-statement","original":"base32-decode"},{"path":"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js","kind":"import-statement","original":"base32-encode"},{"path":"@dxos/node-std/util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"packages/common/keys/src/random-bytes.ts","kind":"import-statement","original":"./random-bytes"}],"format":"esm"},"packages/common/keys/src/types.ts":{"bytes":528,"imports":[],"format":"esm"},"packages/common/keys/src/space-id.ts":{"bytes":5162,"imports":[{"path":"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js","kind":"import-statement","original":"base32-decode"},{"path":"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js","kind":"import-statement","original":"base32-encode"},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"packages/common/keys/src/random-bytes.ts","kind":"import-statement","original":"./random-bytes"}],"format":"esm"},"packages/common/keys/src/index.ts":{"bytes":667,"imports":[{"path":"packages/common/keys/src/public-key.ts","kind":"import-statement","original":"./public-key"},{"path":"packages/common/keys/src/types.ts","kind":"import-statement","original":"./types"},{"path":"packages/common/keys/src/space-id.ts","kind":"import-statement","original":"./space-id"}],"format":"esm"}},"outputs":{"packages/common/keys/dist/lib/browser/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":22643},"packages/common/keys/dist/lib/browser/index.mjs":{"imports":[{"path":"@dxos/node-std/util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/node-std/crypto","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true}],"exports":["PUBLIC_KEY_LENGTH","PublicKey","SECRET_KEY_LENGTH","SpaceId"],"entryPoint":"packages/common/keys/src/index.ts","inputs":{"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js":{"bytesInOutput":1554},"packages/common/keys/src/public-key.ts":{"bytesInOutput":7653},"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js":{"bytesInOutput":395},"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js":{"bytesInOutput":1206},"packages/common/keys/src/random-bytes.ts":{"bytesInOutput":214},"packages/common/keys/src/index.ts":{"bytesInOutput":0},"packages/common/keys/src/space-id.ts":{"bytesInOutput":1431}},"bytes":14705}}}

package/dist/lib/node/index.cjs

@@ -20,12 +20,20 @@ var node_exports = {};
 __export(node_exports, {
   PUBLIC_KEY_LENGTH: () => PUBLIC_KEY_LENGTH,
   PublicKey: () => PublicKey,
-  SECRET_KEY_LENGTH: () => SECRET_KEY_LENGTH
+  SECRET_KEY_LENGTH: () => SECRET_KEY_LENGTH,
+  SpaceId: () => SpaceId
 });
 module.exports = __toCommonJS(node_exports);
 var import_node_util = require("node:util");
 var import_debug = require("@dxos/debug");
 var import_invariant = require("@dxos/invariant");
+var import_invariant2 = require("@dxos/invariant");
+var __create = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -33,6 +41,135 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps2(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var require_base32_decode = __commonJS({
+  "node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js"(exports, module2) {
+    var RFC46482 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    var RFC4648_HEX2 = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+    var CROCKFORD2 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    function readChar(alphabet, char) {
+      var idx = alphabet.indexOf(char);
+      if (idx === -1) {
+        throw new Error("Invalid character found: " + char);
+      }
+      return idx;
+    }
+    module2.exports = function base32Decode3(input, variant) {
+      var alphabet;
+      switch (variant) {
+        case "RFC3548":
+        case "RFC4648":
+          alphabet = RFC46482;
+          input = input.replace(/=+$/, "");
+          break;
+        case "RFC4648-HEX":
+          alphabet = RFC4648_HEX2;
+          input = input.replace(/=+$/, "");
+          break;
+        case "Crockford":
+          alphabet = CROCKFORD2;
+          input = input.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1");
+          break;
+        default:
+          throw new Error("Unknown base32 variant: " + variant);
+      }
+      var length = input.length;
+      var bits = 0;
+      var value = 0;
+      var index = 0;
+      var output = new Uint8Array(length * 5 / 8 | 0);
+      for (var i = 0; i < length; i++) {
+        value = value << 5 | readChar(alphabet, input[i]);
+        bits += 5;
+        if (bits >= 8) {
+          output[index++] = value >>> bits - 8 & 255;
+          bits -= 8;
+        }
+      }
+      return output.buffer;
+    };
+  }
+});
+var import_base32_decode = __toESM(require_base32_decode());
+function toDataView(data) {
+  if (data instanceof Int8Array || data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
+    return new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (data instanceof ArrayBuffer) {
+    return new DataView(data);
+  }
+  throw new TypeError("Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray");
+}
+var RFC4648 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+var RFC4648_HEX = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function base32Encode(data, variant, options) {
+  options = options || {};
+  let alphabet, defaultPadding;
+  switch (variant) {
+    case "RFC3548":
+    case "RFC4648":
+      alphabet = RFC4648;
+      defaultPadding = true;
+      break;
+    case "RFC4648-HEX":
+      alphabet = RFC4648_HEX;
+      defaultPadding = true;
+      break;
+    case "Crockford":
+      alphabet = CROCKFORD;
+      defaultPadding = false;
+      break;
+    default:
+      throw new Error("Unknown base32 variant: " + variant);
+  }
+  const padding = options.padding !== void 0 ? options.padding : defaultPadding;
+  const view = toDataView(data);
+  let bits = 0;
+  let value = 0;
+  let output = "";
+  for (let i = 0; i < view.byteLength; i++) {
+    value = value << 8 | view.getUint8(i);
+    bits += 8;
+    while (bits >= 5) {
+      output += alphabet[value >>> bits - 5 & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0) {
+    output += alphabet[value << 5 - bits & 31];
+  }
+  if (padding) {
+    while (output.length % 8 !== 0) {
+      output += "=";
+    }
+  }
+  return output;
+}
+var randomBytes = (length) => {
+  const webCrypto = globalThis.crypto ?? __require("node:crypto").webcrypto;
+  const bytes = new Uint8Array(length);
+  webCrypto.getRandomValues(bytes);
+  return bytes;
+};
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/keys/src/public-key.ts";
 var PUBLIC_KEY_LENGTH = 32;
 var SECRET_KEY_LENGTH = 64;
@@ -45,7 +182,7 @@ var PublicKey = class _PublicKey {
   static from(source) {
     (0, import_invariant.invariant)(source, void 0, {
       F: __dxlog_file,
-      L: 30,
+      L: 34,
       S: this,
       A: [
         "source",
@@ -100,6 +237,9 @@ var PublicKey = class _PublicKey {
   static random() {
     return _PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));
   }
+  static randomOfLength(length) {
+    return _PublicKey.from(randomBytes(length));
+  }
   static *randomSequence() {
     for (let i = 0; i < 1e4; i++) {
       yield _PublicKey.random();
@@ -134,7 +274,7 @@ var PublicKey = class _PublicKey {
   static bufferize(str) {
     (0, import_invariant.invariant)(typeof str === "string", "Invalid type", {
       F: __dxlog_file,
-      L: 129,
+      L: 137,
       S: this,
       A: [
         "typeof str === 'string'",
@@ -157,7 +297,7 @@ var PublicKey = class _PublicKey {
     }
     (0, import_invariant.invariant)(key instanceof Buffer, "Invalid type", {
       F: __dxlog_file,
-      L: 148,
+      L: 156,
       S: this,
       A: [
         "key instanceof Buffer",
@@ -173,6 +313,18 @@ var PublicKey = class _PublicKey {
   static hash(key) {
     return key.toHex();
   }
+  static fromMultibase32(encoded) {
+    (0, import_invariant.invariant)(encoded.startsWith("B"), "Invalid multibase32 encoding", {
+      F: __dxlog_file,
+      L: 169,
+      S: this,
+      A: [
+        "encoded.startsWith('B')",
+        "'Invalid multibase32 encoding'"
+      ]
+    });
+    return new _PublicKey(new Uint8Array((0, import_base32_decode.default)(encoded.slice(1), "RFC4648")));
+  }
   constructor(_value) {
     this._value = _value;
     if (!(_value instanceof Uint8Array)) {
@@ -194,6 +346,9 @@ var PublicKey = class _PublicKey {
   toHex() {
     return this.asBuffer().toString("hex");
   }
+  toMultibase32() {
+    return "B" + base32Encode(this._value, "RFC4648");
+  }
   truncate(length = void 0) {
     return (0, import_debug.truncateKey)(this, length);
   }
@@ -298,16 +453,57 @@ var PublicKey = class _PublicKey {
     return this.equals(other);
   }
 };
-var randomBytes = (length) => {
-  const webCrypto = globalThis.crypto ?? __require("node:crypto").webcrypto;
-  const bytes = new Uint8Array(length);
-  webCrypto.getRandomValues(bytes);
-  return bytes;
-};
+var import_base32_decode2 = __toESM(require_base32_decode());
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/common/keys/src/space-id.ts";
+var SpaceId = Object.freeze({
+  byteLength: 20,
+  encode: (value) => {
+    (0, import_invariant2.invariant)(value instanceof Uint8Array, "Invalid type", {
+      F: __dxlog_file2,
+      L: 22,
+      S: void 0,
+      A: [
+        "value instanceof Uint8Array",
+        "'Invalid type'"
+      ]
+    });
+    (0, import_invariant2.invariant)(value.length === SpaceId.byteLength, "Invalid length", {
+      F: __dxlog_file2,
+      L: 23,
+      S: void 0,
+      A: [
+        "value.length === SpaceId.byteLength",
+        "'Invalid length'"
+      ]
+    });
+    return MULTIBASE_PREFIX + base32Encode(value, "RFC4648");
+  },
+  decode: (value) => {
+    (0, import_invariant2.invariant)(value.startsWith(MULTIBASE_PREFIX), "Invalid multibase32 encoding", {
+      F: __dxlog_file2,
+      L: 28,
+      S: void 0,
+      A: [
+        "value.startsWith(MULTIBASE_PREFIX)",
+        "'Invalid multibase32 encoding'"
+      ]
+    });
+    return new Uint8Array((0, import_base32_decode2.default)(value.slice(1), "RFC4648"));
+  },
+  isValid: (value) => {
+    return typeof value === "string" && value.startsWith(MULTIBASE_PREFIX) && value.length === ENCODED_LENGTH;
+  },
+  random: () => {
+    return SpaceId.encode(randomBytes(SpaceId.byteLength));
+  }
+});
+var MULTIBASE_PREFIX = "B";
+var ENCODED_LENGTH = 33;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PUBLIC_KEY_LENGTH,
   PublicKey,
-  SECRET_KEY_LENGTH
+  SECRET_KEY_LENGTH,
+  SpaceId
 });
 //# sourceMappingURL=index.cjs.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../../../src/public-key.ts"],
-  "sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { inspect, type InspectOptionsStylized } from 'node:util';\n\nimport { truncateKey, devtoolsFormatter, type DevtoolsFormatter, equalsSymbol, type Equatable } from '@dxos/debug';\nimport { invariant } from '@dxos/invariant';\n\nexport const PUBLIC_KEY_LENGTH = 32;\nexport const SECRET_KEY_LENGTH = 64;\n\n/**\n * All representations that can be converted to a PublicKey.\n */\nexport type PublicKeyLike = PublicKey | Buffer | Uint8Array | ArrayBuffer | string;\n\n/**\n * The purpose of this class is to assure consistent use of keys throughout the project.\n * Keys should be maintained as buffers in objects and proto definitions, and converted to hex\n * strings as late as possible (eg, to log/display).\n */\nexport class PublicKey implements Equatable {\n  /**\n   * Creates new instance of PublicKey automatically determining the input format.\n   * @param source A Buffer, or Uint8Array, or hex encoded string, or something with an `asUint8Array` method on it\n   * @returns PublicKey\n   */\n  static from(source: PublicKeyLike): PublicKey {\n    invariant(source);\n    if (source instanceof PublicKey) {\n      return source;\n    } else if (source instanceof Buffer) {\n      return new PublicKey(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));\n    } else if (source instanceof Uint8Array) {\n      return new PublicKey(source);\n    } else if (source instanceof ArrayBuffer) {\n      return new PublicKey(new Uint8Array(source));\n    } else if (typeof source === 'string') {\n      // TODO(burdon): Check length.\n      return PublicKey.fromHex(source);\n    } else if ((<any>source).asUint8Array) {\n      return new PublicKey((<any>source).asUint8Array());\n    } else {\n      throw new TypeError(`Unable to create PublicKey from ${source}`);\n    }\n  }\n\n  /**\n   * Same as `PublicKey.from` but does not throw and instead returns a `{ key: PublicKey }` or `{ error: Error }`\n   * @param source Same PublicKeyLike argument as for `PublicKey.from`\n   * @returns PublicKey\n   */\n  static safeFrom(source?: PublicKeyLike): PublicKey | undefined {\n    if (!source) {\n      return undefined;\n    }\n\n    try {\n      const key = PublicKey.from(source);\n      // TODO(wittjosiah): Space keys don't pass this check.\n      // if (key.length !== PUBLIC_KEY_LENGTH && key.length !== SECRET_KEY_LENGTH) {\n      //   return undefined;\n      // }\n      return key;\n    } catch (err: any) {\n      return undefined;\n    }\n  }\n\n  /**\n   * Creates new instance of PublicKey from hex string.\n   */\n  static fromHex(hex: string) {\n    if (hex.startsWith('0x')) {\n      hex = hex.slice(2);\n    }\n\n    const buf = Buffer.from(hex, 'hex');\n    // TODO(burdon): Test if key.\n    return new PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));\n  }\n\n  /**\n   * Creates a new key.\n   */\n  static random(): PublicKey {\n    // TODO(burdon): Enable seed for debugging.\n    return PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));\n  }\n\n  static *randomSequence(): Generator<PublicKey> {\n    for (let i = 0; i < 1_0000; i++) {\n      // Counter just to protect against infinite loops.\n      yield PublicKey.random();\n    }\n    throw new Error('Too many keys requested');\n  }\n\n  /**\n   * Tests if provided values is an instance of PublicKey.\n   */\n  static isPublicKey(value: any): value is PublicKey {\n    return value instanceof PublicKey;\n  }\n\n  /**\n   * Asserts that provided values is an instance of PublicKey.\n   */\n  static assertValidPublicKey(value: any): asserts value is PublicKey {\n    if (!this.isPublicKey(value)) {\n      throw new TypeError('Invalid PublicKey');\n    }\n  }\n\n  /**\n   * Tests two keys for equality.\n   */\n  static equals(left: PublicKeyLike, right: PublicKeyLike) {\n    return PublicKey.from(left).equals(right);\n  }\n\n  /**\n   * @param str string representation of key.\n   * @return Key buffer.\n   * @deprecated All keys should be represented as instances of PublicKey.\n   */\n  static bufferize(str: string): Buffer {\n    invariant(typeof str === 'string', 'Invalid type');\n    const buffer = Buffer.from(str, 'hex');\n    // invariant(buffer.length === PUBLIC_KEY_LENGTH || buffer.length === SECRET_KEY_LENGTH,\n    //   `Invalid key length: ${buffer.length}`);\n    return buffer;\n  }\n\n  /**\n   * @param key key like data structure (but not PublicKey which should use toString).\n   * @return Hex string representation of key.\n   * @deprecated All keys should be represented as instances of PublicKey.\n   */\n  static stringify(key: Buffer | Uint8Array | ArrayBuffer): string {\n    if (key instanceof PublicKey) {\n      key = key.asBuffer();\n    } else if (key instanceof Uint8Array) {\n      key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);\n    }\n\n    invariant(key instanceof Buffer, 'Invalid type');\n    return key.toString('hex');\n  }\n\n  /**\n   * To be used with ComplexMap and ComplexSet.\n   * Returns a scalar representation for this key.\n   */\n  static hash(key: PublicKey): string {\n    return key.toHex();\n  }\n\n  constructor(private readonly _value: Uint8Array) {\n    if (!(_value instanceof Uint8Array)) {\n      throw new TypeError(`Expected Uint8Array, got: ${_value}`);\n    }\n  }\n\n  toString(): string {\n    return this.toHex();\n  }\n\n  toJSON() {\n    return this.toHex();\n  }\n\n  toJSONL(): string {\n    return this.truncate();\n  }\n\n  get length() {\n    return this._value.length;\n  }\n\n  toHex(): string {\n    return this.asBuffer().toString('hex');\n  }\n\n  truncate(length = undefined) {\n    return truncateKey(this, length);\n  }\n\n  asBuffer(): Buffer {\n    return Buffer.from(this._value.buffer, this._value.byteOffset, this._value.byteLength);\n  }\n\n  asUint8Array(): Uint8Array {\n    return this._value;\n  }\n\n  getInsecureHash(modulo: number) {\n    return Math.abs(this._value.reduce((acc, val) => (acc ^ val) | 0, 0)) % modulo;\n  }\n\n  /**\n   * Used by Node.js to get textual representation of this object when it's printed with a `console.log` statement.\n   */\n  [inspect.custom](depth: number, options: InspectOptionsStylized) {\n    if (!options.colors || typeof process.stdout.hasColors !== 'function' || !process.stdout.hasColors()) {\n      return `<PublicKey ${this.truncate()}>`;\n    }\n\n    const printControlCode = (code: number) => {\n      return `\\x1b[${code}m`;\n    };\n\n    // NOTE: Keep in sync with formatter colors.\n    const colors = [\n      'red',\n      'green',\n      'yellow',\n      'blue',\n      'magenta',\n      'cyan',\n      'redBright',\n      'greenBright',\n      'yellowBright',\n      'blueBright',\n      'magentaBright',\n      'cyanBright',\n      'whiteBright',\n    ];\n    const color = colors[this.getInsecureHash(colors.length)];\n\n    return `PublicKey(${printControlCode(inspect.colors[color]![0])}${this.truncate()}${printControlCode(\n      inspect.colors.reset![0],\n    )})`;\n  }\n\n  get [devtoolsFormatter](): DevtoolsFormatter {\n    return {\n      header: () => {\n        // NOTE: Keep in sync with inspect colors.\n        const colors = [\n          'darkred',\n          'green',\n          'orange',\n          'blue',\n          'darkmagenta',\n          'darkcyan',\n          'red',\n          'green',\n          'orange',\n          'blue',\n          'magenta',\n          'darkcyan',\n          'black',\n        ];\n        const color = colors[this.getInsecureHash(colors.length)];\n\n        return [\n          'span',\n          {},\n          ['span', {}, 'PublicKey('],\n          ['span', { style: `color: ${color};` }, this.truncate()],\n          ['span', {}, ')'],\n        ];\n      },\n    };\n  }\n\n  /**\n   * Test this key for equality with some other key.\n   */\n  equals(other: PublicKeyLike) {\n    const otherConverted = PublicKey.from(other);\n    if (this._value.length !== otherConverted._value.length) {\n      return false;\n    }\n\n    let equal = true;\n    for (let i = 0; i < this._value.length; i++) {\n      equal &&= this._value[i] === otherConverted._value[i];\n    }\n\n    return equal;\n  }\n\n  [equalsSymbol](other: any) {\n    if (!PublicKey.isPublicKey(other)) {\n      return false;\n    }\n\n    return this.equals(other);\n  }\n}\n\nconst randomBytes = (length: number) => {\n  // globalThis.crypto is not available in Node.js when running in vitest even though the documentation says it should be.\n  // eslint-disable-next-line @typescript-eslint/no-var-requires\n  const webCrypto = globalThis.crypto ?? require('node:crypto').webcrypto;\n\n  const bytes = new Uint8Array(length);\n  webCrypto.getRandomValues(bytes);\n  return bytes;\n};\n"],
-  "mappings": "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",
-  "names": ["PUBLIC_KEY_LENGTH", "SECRET_KEY_LENGTH", "PublicKey", "from", "source", "invariant", "Buffer", "Uint8Array", "buffer", "byteOffset", "byteLength", "ArrayBuffer", "fromHex", "asUint8Array", "TypeError", "safeFrom", "undefined", "key", "err", "hex", "startsWith", "slice", "buf", "random", "randomBytes", "randomSequence", "i", "Error", "isPublicKey", "value", "assertValidPublicKey", "equals", "left", "right", "bufferize", "str", "stringify", "asBuffer", "toString", "hash", "toHex", "constructor", "_value", "toJSON", "toJSONL", "truncate", "length", "truncateKey", "getInsecureHash", "modulo", "Math", "abs", "reduce", "acc", "val", "inspect", "custom", "depth", "options", "colors", "process", "stdout", "hasColors", "printControlCode", "code", "color", "reset", "devtoolsFormatter", "header", "style", "other", "otherConverted", "equal", "equalsSymbol", "webCrypto", "globalThis", "crypto", "require", "webcrypto", "bytes", "getRandomValues"]
+  "sources": ["../../../../../../node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js", "../../../src/public-key.ts", "../../../../../../node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js", "../../../../../../node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js", "../../../src/random-bytes.ts", "../../../src/space-id.ts"],
+  "sourcesContent": ["var RFC4648 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'\nvar RFC4648_HEX = '0123456789ABCDEFGHIJKLMNOPQRSTUV'\nvar CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'\n\nfunction readChar (alphabet, char) {\n  var idx = alphabet.indexOf(char)\n\n  if (idx === -1) {\n    throw new Error('Invalid character found: ' + char)\n  }\n\n  return idx\n}\n\nmodule.exports = function base32Decode (input, variant) {\n  var alphabet\n\n  switch (variant) {\n    case 'RFC3548':\n    case 'RFC4648':\n      alphabet = RFC4648\n      input = input.replace(/=+$/, '')\n      break\n    case 'RFC4648-HEX':\n      alphabet = RFC4648_HEX\n      input = input.replace(/=+$/, '')\n      break\n    case 'Crockford':\n      alphabet = CROCKFORD\n      input = input.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')\n      break\n    default:\n      throw new Error('Unknown base32 variant: ' + variant)\n  }\n\n  var length = input.length\n\n  var bits = 0\n  var value = 0\n\n  var index = 0\n  var output = new Uint8Array((length * 5 / 8) | 0)\n\n  for (var i = 0; i < length; i++) {\n    value = (value << 5) | readChar(alphabet, input[i])\n    bits += 5\n\n    if (bits >= 8) {\n      output[index++] = (value >>> (bits - 8)) & 255\n      bits -= 8\n    }\n  }\n\n  return output.buffer\n}\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport base32Decode from 'base32-decode';\nimport base32Encode from 'base32-encode';\nimport { inspect, type InspectOptionsStylized } from 'node:util';\n\nimport { truncateKey, devtoolsFormatter, type DevtoolsFormatter, equalsSymbol, type Equatable } from '@dxos/debug';\nimport { invariant } from '@dxos/invariant';\n\nimport { randomBytes } from './random-bytes';\n\nexport const PUBLIC_KEY_LENGTH = 32;\nexport const SECRET_KEY_LENGTH = 64;\n\n/**\n * All representations that can be converted to a PublicKey.\n */\nexport type PublicKeyLike = PublicKey | Buffer | Uint8Array | ArrayBuffer | string;\n\n/**\n * The purpose of this class is to assure consistent use of keys throughout the project.\n * Keys should be maintained as buffers in objects and proto definitions, and converted to hex\n * strings as late as possible (eg, to log/display).\n */\nexport class PublicKey implements Equatable {\n  /**\n   * Creates new instance of PublicKey automatically determining the input format.\n   * @param source A Buffer, or Uint8Array, or hex encoded string, or something with an `asUint8Array` method on it\n   * @returns PublicKey\n   */\n  static from(source: PublicKeyLike): PublicKey {\n    invariant(source);\n    if (source instanceof PublicKey) {\n      return source;\n    } else if (source instanceof Buffer) {\n      return new PublicKey(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));\n    } else if (source instanceof Uint8Array) {\n      return new PublicKey(source);\n    } else if (source instanceof ArrayBuffer) {\n      return new PublicKey(new Uint8Array(source));\n    } else if (typeof source === 'string') {\n      // TODO(burdon): Check length.\n      return PublicKey.fromHex(source);\n    } else if ((<any>source).asUint8Array) {\n      return new PublicKey((<any>source).asUint8Array());\n    } else {\n      throw new TypeError(`Unable to create PublicKey from ${source}`);\n    }\n  }\n\n  /**\n   * Same as `PublicKey.from` but does not throw and instead returns a `{ key: PublicKey }` or `{ error: Error }`\n   * @param source Same PublicKeyLike argument as for `PublicKey.from`\n   * @returns PublicKey\n   */\n  static safeFrom(source?: PublicKeyLike): PublicKey | undefined {\n    if (!source) {\n      return undefined;\n    }\n\n    try {\n      const key = PublicKey.from(source);\n      // TODO(wittjosiah): Space keys don't pass this check.\n      // if (key.length !== PUBLIC_KEY_LENGTH && key.length !== SECRET_KEY_LENGTH) {\n      //   return undefined;\n      // }\n      return key;\n    } catch (err: any) {\n      return undefined;\n    }\n  }\n\n  /**\n   * Creates new instance of PublicKey from hex string.\n   */\n  static fromHex(hex: string) {\n    if (hex.startsWith('0x')) {\n      hex = hex.slice(2);\n    }\n\n    const buf = Buffer.from(hex, 'hex');\n    // TODO(burdon): Test if key.\n    return new PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));\n  }\n\n  /**\n   * Creates a new key.\n   */\n  static random(): PublicKey {\n    // TODO(burdon): Enable seed for debugging.\n    return PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));\n  }\n\n  static randomOfLength(length: number): PublicKey {\n    return PublicKey.from(randomBytes(length));\n  }\n\n  static *randomSequence(): Generator<PublicKey> {\n    for (let i = 0; i < 1_0000; i++) {\n      // Counter just to protect against infinite loops.\n      yield PublicKey.random();\n    }\n    throw new Error('Too many keys requested');\n  }\n\n  /**\n   * Tests if provided values is an instance of PublicKey.\n   */\n  static isPublicKey(value: any): value is PublicKey {\n    return value instanceof PublicKey;\n  }\n\n  /**\n   * Asserts that provided values is an instance of PublicKey.\n   */\n  static assertValidPublicKey(value: any): asserts value is PublicKey {\n    if (!this.isPublicKey(value)) {\n      throw new TypeError('Invalid PublicKey');\n    }\n  }\n\n  /**\n   * Tests two keys for equality.\n   */\n  static equals(left: PublicKeyLike, right: PublicKeyLike) {\n    return PublicKey.from(left).equals(right);\n  }\n\n  /**\n   * @param str string representation of key.\n   * @return Key buffer.\n   * @deprecated All keys should be represented as instances of PublicKey.\n   */\n  static bufferize(str: string): Buffer {\n    invariant(typeof str === 'string', 'Invalid type');\n    const buffer = Buffer.from(str, 'hex');\n    // invariant(buffer.length === PUBLIC_KEY_LENGTH || buffer.length === SECRET_KEY_LENGTH,\n    //   `Invalid key length: ${buffer.length}`);\n    return buffer;\n  }\n\n  /**\n   * @param key key like data structure (but not PublicKey which should use toString).\n   * @return Hex string representation of key.\n   * @deprecated All keys should be represented as instances of PublicKey.\n   */\n  static stringify(key: Buffer | Uint8Array | ArrayBuffer): string {\n    if (key instanceof PublicKey) {\n      key = key.asBuffer();\n    } else if (key instanceof Uint8Array) {\n      key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);\n    }\n\n    invariant(key instanceof Buffer, 'Invalid type');\n    return key.toString('hex');\n  }\n\n  /**\n   * To be used with ComplexMap and ComplexSet.\n   * Returns a scalar representation for this key.\n   */\n  static hash(key: PublicKey): string {\n    return key.toHex();\n  }\n\n  static fromMultibase32(encoded: string): PublicKey {\n    invariant(encoded.startsWith('B'), 'Invalid multibase32 encoding');\n\n    return new PublicKey(new Uint8Array(base32Decode(encoded.slice(1), 'RFC4648')));\n  }\n\n  constructor(private readonly _value: Uint8Array) {\n    if (!(_value instanceof Uint8Array)) {\n      throw new TypeError(`Expected Uint8Array, got: ${_value}`);\n    }\n  }\n\n  toString(): string {\n    return this.toHex();\n  }\n\n  toJSON() {\n    return this.toHex();\n  }\n\n  toJSONL(): string {\n    return this.truncate();\n  }\n\n  get length() {\n    return this._value.length;\n  }\n\n  toHex(): string {\n    return this.asBuffer().toString('hex');\n  }\n\n  toMultibase32(): string {\n    return 'B' + base32Encode(this._value, 'RFC4648');\n  }\n\n  truncate(length = undefined) {\n    return truncateKey(this, length);\n  }\n\n  asBuffer(): Buffer {\n    return Buffer.from(this._value.buffer, this._value.byteOffset, this._value.byteLength);\n  }\n\n  asUint8Array(): Uint8Array {\n    return this._value;\n  }\n\n  getInsecureHash(modulo: number) {\n    return Math.abs(this._value.reduce((acc, val) => (acc ^ val) | 0, 0)) % modulo;\n  }\n\n  /**\n   * Used by Node.js to get textual representation of this object when it's printed with a `console.log` statement.\n   */\n  [inspect.custom](depth: number, options: InspectOptionsStylized) {\n    if (!options.colors || typeof process.stdout.hasColors !== 'function' || !process.stdout.hasColors()) {\n      return `<PublicKey ${this.truncate()}>`;\n    }\n\n    const printControlCode = (code: number) => {\n      return `\\x1b[${code}m`;\n    };\n\n    // NOTE: Keep in sync with formatter colors.\n    const colors = [\n      'red',\n      'green',\n      'yellow',\n      'blue',\n      'magenta',\n      'cyan',\n      'redBright',\n      'greenBright',\n      'yellowBright',\n      'blueBright',\n      'magentaBright',\n      'cyanBright',\n      'whiteBright',\n    ];\n    const color = colors[this.getInsecureHash(colors.length)];\n\n    return `PublicKey(${printControlCode(inspect.colors[color]![0])}${this.truncate()}${printControlCode(\n      inspect.colors.reset![0],\n    )})`;\n  }\n\n  get [devtoolsFormatter](): DevtoolsFormatter {\n    return {\n      header: () => {\n        // NOTE: Keep in sync with inspect colors.\n        const colors = [\n          'darkred',\n          'green',\n          'orange',\n          'blue',\n          'darkmagenta',\n          'darkcyan',\n          'red',\n          'green',\n          'orange',\n          'blue',\n          'magenta',\n          'darkcyan',\n          'black',\n        ];\n        const color = colors[this.getInsecureHash(colors.length)];\n\n        return [\n          'span',\n          {},\n          ['span', {}, 'PublicKey('],\n          ['span', { style: `color: ${color};` }, this.truncate()],\n          ['span', {}, ')'],\n        ];\n      },\n    };\n  }\n\n  /**\n   * Test this key for equality with some other key.\n   */\n  equals(other: PublicKeyLike) {\n    const otherConverted = PublicKey.from(other);\n    if (this._value.length !== otherConverted._value.length) {\n      return false;\n    }\n\n    let equal = true;\n    for (let i = 0; i < this._value.length; i++) {\n      equal &&= this._value[i] === otherConverted._value[i];\n    }\n\n    return equal;\n  }\n\n  [equalsSymbol](other: any) {\n    if (!PublicKey.isPublicKey(other)) {\n      return false;\n    }\n\n    return this.equals(other);\n  }\n}\n", "export default function toDataView (data) {\n  if (data instanceof Int8Array || data instanceof Uint8Array || data instanceof Uint8ClampedArray) {\n    return new DataView(data.buffer, data.byteOffset, data.byteLength)\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return new DataView(data)\n  }\n\n  throw new TypeError('Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray')\n}\n", "import toDataView from 'to-data-view'\n\nconst RFC4648 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'\nconst RFC4648_HEX = '0123456789ABCDEFGHIJKLMNOPQRSTUV'\nconst CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'\n\nexport default function base32Encode (data, variant, options) {\n  options = options || {}\n  let alphabet, defaultPadding\n\n  switch (variant) {\n    case 'RFC3548':\n    case 'RFC4648':\n      alphabet = RFC4648\n      defaultPadding = true\n      break\n    case 'RFC4648-HEX':\n      alphabet = RFC4648_HEX\n      defaultPadding = true\n      break\n    case 'Crockford':\n      alphabet = CROCKFORD\n      defaultPadding = false\n      break\n    default:\n      throw new Error('Unknown base32 variant: ' + variant)\n  }\n\n  const padding = (options.padding !== undefined ? options.padding : defaultPadding)\n  const view = toDataView(data)\n\n  let bits = 0\n  let value = 0\n  let output = ''\n\n  for (let i = 0; i < view.byteLength; i++) {\n    value = (value << 8) | view.getUint8(i)\n    bits += 8\n\n    while (bits >= 5) {\n      output += alphabet[(value >>> (bits - 5)) & 31]\n      bits -= 5\n    }\n  }\n\n  if (bits > 0) {\n    output += alphabet[(value << (5 - bits)) & 31]\n  }\n\n  if (padding) {\n    while ((output.length % 8) !== 0) {\n      output += '='\n    }\n  }\n\n  return output\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nexport const randomBytes = (length: number) => {\n  // globalThis.crypto is not available in Node.js when running in vitest even though the documentation says it should be.\n  // eslint-disable-next-line @typescript-eslint/no-var-requires\n  const webCrypto = globalThis.crypto ?? require('node:crypto').webcrypto;\n\n  const bytes = new Uint8Array(length);\n  webCrypto.getRandomValues(bytes);\n  return bytes;\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport base32Decode from 'base32-decode';\nimport base32Encode from 'base32-encode';\n\nimport { invariant } from '@dxos/invariant';\n\nimport { randomBytes } from './random-bytes';\n\n/**\n * A unique identifier for a space.\n * Space keys are generated by creating a keypair, and then taking the first 20 bytes of the SHA-256 hash of the public key and encoding them to multibase RFC4648 base-32 format (prefixed with B, see Multibase Table).\n * @example BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE\n */\nexport type SpaceId = string & { __SpaceId: true };\n\nexport const SpaceId = Object.freeze({\n  byteLength: 20,\n  encode: (value: Uint8Array): SpaceId => {\n    invariant(value instanceof Uint8Array, 'Invalid type');\n    invariant(value.length === SpaceId.byteLength, 'Invalid length');\n\n    return (MULTIBASE_PREFIX + base32Encode(value, 'RFC4648')) as SpaceId;\n  },\n  decode: (value: SpaceId): Uint8Array => {\n    invariant(value.startsWith(MULTIBASE_PREFIX), 'Invalid multibase32 encoding');\n\n    return new Uint8Array(base32Decode(value.slice(1), 'RFC4648'));\n  },\n  isValid: (value: string): value is SpaceId => {\n    return typeof value === 'string' && value.startsWith(MULTIBASE_PREFIX) && value.length === ENCODED_LENGTH;\n  },\n  random: (): SpaceId => {\n    return SpaceId.encode(randomBytes(SpaceId.byteLength));\n  },\n});\n\n/**\n * Denotes RFC4648 base-32 format.\n */\nconst MULTIBASE_PREFIX = 'B';\n\nconst ENCODED_LENGTH = 33;\n"],
+  "mappings": "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",
+  "names": ["import_invariant", "module", "RFC4648", "RFC4648_HEX", "CROCKFORD", "base32Decode", "randomBytes", "length", "webCrypto", "globalThis", "crypto", "require", "webcrypto", "bytes", "Uint8Array", "getRandomValues", "PUBLIC_KEY_LENGTH", "SECRET_KEY_LENGTH", "PublicKey", "from", "source", "invariant", "Buffer", "buffer", "byteOffset", "byteLength", "ArrayBuffer", "fromHex", "asUint8Array", "TypeError", "safeFrom", "undefined", "key", "err", "hex", "startsWith", "slice", "buf", "random", "randomOfLength", "randomSequence", "i", "Error", "isPublicKey", "value", "assertValidPublicKey", "equals", "left", "right", "bufferize", "str", "stringify", "asBuffer", "toString", "hash", "toHex", "fromMultibase32", "encoded", "constructor", "_value", "toJSON", "toJSONL", "truncate", "toMultibase32", "base32Encode", "truncateKey", "getInsecureHash", "modulo", "Math", "abs", "reduce", "acc", "val", "inspect", "custom", "depth", "options", "colors", "process", "stdout", "hasColors", "printControlCode", "code", "color", "reset", "devtoolsFormatter", "header", "style", "other", "otherConverted", "equal", "equalsSymbol", "import_base32_decode", "SpaceId", "Object", "freeze", "encode", "MULTIBASE_PREFIX", "decode", "isValid", "ENCODED_LENGTH"]
 }

package/dist/lib/node/meta.json

@@ -1 +1 @@
-{"inputs":{"packages/common/keys/src/public-key.ts":{"bytes":29335,"imports":[{"path":"node:util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"node:crypto","kind":"require-call","external":true}],"format":"esm"},"packages/common/keys/src/types.ts":{"bytes":673,"imports":[],"format":"esm"},"packages/common/keys/src/index.ts":{"bytes":579,"imports":[{"path":"packages/common/keys/src/public-key.ts","kind":"import-statement","original":"./public-key"},{"path":"packages/common/keys/src/types.ts","kind":"import-statement","original":"./types"}],"format":"esm"}},"outputs":{"packages/common/keys/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":13772},"packages/common/keys/dist/lib/node/index.cjs":{"imports":[{"path":"node:util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"node:crypto","kind":"require-call","external":true}],"exports":["PUBLIC_KEY_LENGTH","PublicKey","SECRET_KEY_LENGTH"],"entryPoint":"packages/common/keys/src/index.ts","inputs":{"packages/common/keys/src/public-key.ts":{"bytesInOutput":7245},"packages/common/keys/src/index.ts":{"bytesInOutput":0}},"bytes":7758}}}
+{"inputs":{"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js":{"bytes":1217,"imports":[],"format":"cjs"},"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js":{"bytes":410,"imports":[],"format":"esm"},"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js":{"bytes":1266,"imports":[{"path":"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js","kind":"import-statement","original":"to-data-view"}],"format":"esm"},"packages/common/keys/src/random-bytes.ts":{"bytes":1792,"imports":[{"path":"node:crypto","kind":"require-call","external":true}],"format":"esm"},"packages/common/keys/src/public-key.ts":{"bytes":30143,"imports":[{"path":"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js","kind":"import-statement","original":"base32-decode"},{"path":"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js","kind":"import-statement","original":"base32-encode"},{"path":"node:util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"packages/common/keys/src/random-bytes.ts","kind":"import-statement","original":"./random-bytes"}],"format":"esm"},"packages/common/keys/src/types.ts":{"bytes":528,"imports":[],"format":"esm"},"packages/common/keys/src/space-id.ts":{"bytes":5162,"imports":[{"path":"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js","kind":"import-statement","original":"base32-decode"},{"path":"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js","kind":"import-statement","original":"base32-encode"},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"packages/common/keys/src/random-bytes.ts","kind":"import-statement","original":"./random-bytes"}],"format":"esm"},"packages/common/keys/src/index.ts":{"bytes":667,"imports":[{"path":"packages/common/keys/src/public-key.ts","kind":"import-statement","original":"./public-key"},{"path":"packages/common/keys/src/types.ts","kind":"import-statement","original":"./types"},{"path":"packages/common/keys/src/space-id.ts","kind":"import-statement","original":"./space-id"}],"format":"esm"}},"outputs":{"packages/common/keys/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":22642},"packages/common/keys/dist/lib/node/index.cjs":{"imports":[{"path":"node:util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"node:crypto","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true}],"exports":["PUBLIC_KEY_LENGTH","PublicKey","SECRET_KEY_LENGTH","SpaceId"],"entryPoint":"packages/common/keys/src/index.ts","inputs":{"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js":{"bytesInOutput":1554},"packages/common/keys/src/public-key.ts":{"bytesInOutput":7643},"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js":{"bytesInOutput":395},"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js":{"bytesInOutput":1206},"packages/common/keys/src/random-bytes.ts":{"bytesInOutput":204},"packages/common/keys/src/index.ts":{"bytesInOutput":0},"packages/common/keys/src/space-id.ts":{"bytesInOutput":1431}},"bytes":14685}}}

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

@@ -1,3 +1,4 @@
 export * from './public-key';
 export * from './types';
+export * from './space-id';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC"}

package/dist/types/src/public-key.d.ts

@@ -35,6 +35,7 @@ export declare class PublicKey implements Equatable {
      * Creates a new key.
      */
     static random(): PublicKey;
+    static randomOfLength(length: number): PublicKey;
     static randomSequence(): Generator<PublicKey>;
     /**
      * Tests if provided values is an instance of PublicKey.
@@ -65,12 +66,14 @@ export declare class PublicKey implements Equatable {
      * Returns a scalar representation for this key.
      */
     static hash(key: PublicKey): string;
+    static fromMultibase32(encoded: string): PublicKey;
     constructor(_value: Uint8Array);
     toString(): string;
     toJSON(): string;
     toJSONL(): string;
     get length(): number;
     toHex(): string;
+    toMultibase32(): string;
     truncate(length?: undefined): string;
     asBuffer(): Buffer;
     asUint8Array(): Uint8Array;

package/dist/types/src/public-key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public-key.d.ts","sourceRoot":"","sources":["../../../src/public-key.ts"],"names":[],"mappings":";;AAIA,OAAO,EAAE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,EAAe,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAGnH,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,CAAC;AAEnF;;;;GAIG;AACH,qBAAa,SAAU,YAAW,SAAS;IAyI7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAxInC;;;;OAIG;IACH,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS;IAoB7C;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,SAAS;IAiB9D;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM;IAU1B;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,SAAS;IAK1B,MAAM,CAAE,cAAc,IAAI,SAAS,CAAC,SAAS,CAAC;IAQ9C;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,SAAS;IAIlD;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,KAAK,IAAI,SAAS;IAMnE;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa;IAIvD;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAQrC;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM;IAWhE;;;OAGG;IACH,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM;gBAIN,MAAM,EAAE,UAAU;IAM/C,QAAQ,IAAI,MAAM;IAIlB,MAAM;IAIN,OAAO,IAAI,MAAM;IAIjB,IAAI,MAAM,WAET;IAED,KAAK,IAAI,MAAM;IAIf,QAAQ,CAAC,MAAM,YAAY;IAI3B,QAAQ,IAAI,MAAM;IAIlB,YAAY,IAAI,UAAU;IAI1B,eAAe,CAAC,MAAM,EAAE,MAAM;IAI9B;;OAEG;IACH,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB;IAgC/D,IAAI,CAAC,iBAAiB,CAAC,IAAI,iBAAiB,CA8B3C;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,aAAa;IAc3B,CAAC,YAAY,CAAC,CAAC,KAAK,EAAE,GAAG;CAO1B"}
+{"version":3,"file":"public-key.d.ts","sourceRoot":"","sources":["../../../src/public-key.ts"],"names":[],"mappings":";;AAMA,OAAO,EAAE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,EAAe,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAKnH,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,CAAC;AAEnF;;;;GAIG;AACH,qBAAa,SAAU,YAAW,SAAS;IAmJ7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAlJnC;;;;OAIG;IACH,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS;IAoB7C;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,SAAS;IAiB9D;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM;IAU1B;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,SAAS;IAK1B,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS;IAIhD,MAAM,CAAE,cAAc,IAAI,SAAS,CAAC,SAAS,CAAC;IAQ9C;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,SAAS;IAIlD;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,KAAK,IAAI,SAAS;IAMnE;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa;IAIvD;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAQrC;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM;IAWhE;;;OAGG;IACH,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM;IAInC,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS;gBAMrB,MAAM,EAAE,UAAU;IAM/C,QAAQ,IAAI,MAAM;IAIlB,MAAM;IAIN,OAAO,IAAI,MAAM;IAIjB,IAAI,MAAM,WAET;IAED,KAAK,IAAI,MAAM;IAIf,aAAa,IAAI,MAAM;IAIvB,QAAQ,CAAC,MAAM,YAAY;IAI3B,QAAQ,IAAI,MAAM;IAIlB,YAAY,IAAI,UAAU;IAI1B,eAAe,CAAC,MAAM,EAAE,MAAM;IAI9B;;OAEG;IACH,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB;IAgC/D,IAAI,CAAC,iBAAiB,CAAC,IAAI,iBAAiB,CA8B3C;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,aAAa;IAc3B,CAAC,YAAY,CAAC,CAAC,KAAK,EAAE,GAAG;CAO1B"}

package/dist/types/src/random-bytes.d.ts

@@ -0,0 +1,2 @@
+export declare const randomBytes: (length: number) => Uint8Array;
+//# sourceMappingURL=random-bytes.d.ts.map

package/dist/types/src/random-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-bytes.d.ts","sourceRoot":"","sources":["../../../src/random-bytes.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,WAAY,MAAM,eAQzC,CAAC"}

package/dist/types/src/space-id.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A unique identifier for a space.
+ * Space keys are generated by creating a keypair, and then taking the first 20 bytes of the SHA-256 hash of the public key and encoding them to multibase RFC4648 base-32 format (prefixed with B, see Multibase Table).
+ * @example BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE
+ */
+export type SpaceId = string & {
+    __SpaceId: true;
+};
+export declare const SpaceId: Readonly<{
+    byteLength: 20;
+    encode: (value: Uint8Array) => SpaceId;
+    decode: (value: SpaceId) => Uint8Array;
+    isValid: (value: string) => value is SpaceId;
+    random: () => SpaceId;
+}>;
+//# sourceMappingURL=space-id.d.ts.map

package/dist/types/src/space-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"space-id.d.ts","sourceRoot":"","sources":["../../../src/space-id.ts"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC;AAEnD,eAAO,MAAM,OAAO;;oBAEF,UAAU,KAAG,OAAO;oBAMpB,OAAO,KAAG,UAAU;qBAKnB,MAAM;kBAGX,OAAO;EAGnB,CAAC"}

package/dist/types/src/space-id.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=space-id.test.d.ts.map

package/dist/types/src/space-id.test.d.ts.map

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

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":";AAKA,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":";AAIA,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/keys",
-  "version": "0.5.8",
+  "version": "0.5.9-main.2d0a5e6",
   "description": "Key utils and definitions.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -21,9 +21,13 @@
     "src"
   ],
   "dependencies": {
-    "@dxos/debug": "0.5.8",
-    "@dxos/invariant": "0.5.8",
-    "@dxos/node-std": "0.5.8"
+    "@dxos/invariant": "0.5.9-main.2d0a5e6",
+    "@dxos/node-std": "0.5.9-main.2d0a5e6",
+    "@dxos/debug": "0.5.9-main.2d0a5e6"
+  },
+  "devDependencies": {
+    "base32-decode": "^1.0.0",
+    "base32-encode": "^2.0.0"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -4,3 +4,4 @@
 
 export * from './public-key';
 export * from './types';
+export * from './space-id';

package/src/public-key.test.ts

@@ -60,4 +60,11 @@ describe('PublicKey', () => {
     const key = PublicKey.random();
     expect(PublicKey.equals(key, PublicKey.from(key.toHex()))).to.be.true;
   });
+
+  test('base32', () => {
+    const key = PublicKey.randomOfLength(20); // Space keys will be cut to first 20 bytes of sha-256 hash.
+    const encoded = key.toMultibase32();
+
+    expect(PublicKey.fromMultibase32(encoded).toHex()).to.equal(key.toHex());
+  });
 });

package/src/public-key.ts

@@ -2,11 +2,15 @@
 // Copyright 2020 DXOS.org
 //
 
+import base32Decode from 'base32-decode';
+import base32Encode from 'base32-encode';
 import { inspect, type InspectOptionsStylized } from 'node:util';
 
 import { truncateKey, devtoolsFormatter, type DevtoolsFormatter, equalsSymbol, type Equatable } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 
+import { randomBytes } from './random-bytes';
+
 export const PUBLIC_KEY_LENGTH = 32;
 export const SECRET_KEY_LENGTH = 64;
 
@@ -89,6 +93,10 @@ export class PublicKey implements Equatable {
     return PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));
   }
 
+  static randomOfLength(length: number): PublicKey {
+    return PublicKey.from(randomBytes(length));
+  }
+
   static *randomSequence(): Generator<PublicKey> {
     for (let i = 0; i < 1_0000; i++) {
       // Counter just to protect against infinite loops.
@@ -157,6 +165,12 @@ export class PublicKey implements Equatable {
     return key.toHex();
   }
 
+  static fromMultibase32(encoded: string): PublicKey {
+    invariant(encoded.startsWith('B'), 'Invalid multibase32 encoding');
+
+    return new PublicKey(new Uint8Array(base32Decode(encoded.slice(1), 'RFC4648')));
+  }
+
   constructor(private readonly _value: Uint8Array) {
     if (!(_value instanceof Uint8Array)) {
       throw new TypeError(`Expected Uint8Array, got: ${_value}`);
@@ -183,6 +197,10 @@ export class PublicKey implements Equatable {
     return this.asBuffer().toString('hex');
   }
 
+  toMultibase32(): string {
+    return 'B' + base32Encode(this._value, 'RFC4648');
+  }
+
   truncate(length = undefined) {
     return truncateKey(this, length);
   }
@@ -291,13 +309,3 @@ export class PublicKey implements Equatable {
     return this.equals(other);
   }
 }
-
-const randomBytes = (length: number) => {
-  // globalThis.crypto is not available in Node.js when running in vitest even though the documentation says it should be.
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const webCrypto = globalThis.crypto ?? require('node:crypto').webcrypto;
-
-  const bytes = new Uint8Array(length);
-  webCrypto.getRandomValues(bytes);
-  return bytes;
-};

package/src/random-bytes.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export const randomBytes = (length: number) => {
+  // globalThis.crypto is not available in Node.js when running in vitest even though the documentation says it should be.
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const webCrypto = globalThis.crypto ?? require('node:crypto').webcrypto;
+
+  const bytes = new Uint8Array(length);
+  webCrypto.getRandomValues(bytes);
+  return bytes;
+};

package/src/space-id.test.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect, test } from 'vitest';
+
+import { SpaceId } from './space-id';
+
+test('space-id', () => {
+  const id = SpaceId.random();
+
+  expect(SpaceId.isValid(id)).toBe(true);
+  expect(id.length).toBe(33);
+  const decoded = SpaceId.decode(id);
+  expect(decoded.length).toBe(SpaceId.byteLength);
+  expect(SpaceId.encode(decoded)).toBe(id);
+});

package/src/space-id.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import base32Decode from 'base32-decode';
+import base32Encode from 'base32-encode';
+
+import { invariant } from '@dxos/invariant';
+
+import { randomBytes } from './random-bytes';
+
+/**
+ * A unique identifier for a space.
+ * Space keys are generated by creating a keypair, and then taking the first 20 bytes of the SHA-256 hash of the public key and encoding them to multibase RFC4648 base-32 format (prefixed with B, see Multibase Table).
+ * @example BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE
+ */
+export type SpaceId = string & { __SpaceId: true };
+
+export const SpaceId = Object.freeze({
+  byteLength: 20,
+  encode: (value: Uint8Array): SpaceId => {
+    invariant(value instanceof Uint8Array, 'Invalid type');
+    invariant(value.length === SpaceId.byteLength, 'Invalid length');
+
+    return (MULTIBASE_PREFIX + base32Encode(value, 'RFC4648')) as SpaceId;
+  },
+  decode: (value: SpaceId): Uint8Array => {
+    invariant(value.startsWith(MULTIBASE_PREFIX), 'Invalid multibase32 encoding');
+
+    return new Uint8Array(base32Decode(value.slice(1), 'RFC4648'));
+  },
+  isValid: (value: string): value is SpaceId => {
+    return typeof value === 'string' && value.startsWith(MULTIBASE_PREFIX) && value.length === ENCODED_LENGTH;
+  },
+  random: (): SpaceId => {
+    return SpaceId.encode(randomBytes(SpaceId.byteLength));
+  },
+});
+
+/**
+ * Denotes RFC4648 base-32 format.
+ */
+const MULTIBASE_PREFIX = 'B';
+
+const ENCODED_LENGTH = 33;

package/src/types.ts

@@ -2,7 +2,6 @@
 // Copyright 2022 DXOS.org
 //
 
-// TODO(burdon): Replace with hypercore-crypto type.
 export type KeyPair = {
   publicKey: Buffer;
   secretKey: Buffer;