@dxos/protocols 2.33.7-dev.c2ba88fb → 2.33.8-dev.6bc74570

package/src/public-key.test.ts

@@ -0,0 +1,73 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { PublicKey } from './public-key';
+
+const KEY_HEX = '2c28f0d08ccc5340aee02655675be5796227a28d27b9704df34b7d8b2d9fddc7';
+
+it('Basic key operations', () => {
+  const publicKey = PublicKey.random().asBuffer();
+
+  expect(PublicKey.bufferize(PublicKey.stringify(publicKey))).toEqual(publicKey);
+
+  expect(() => PublicKey.stringify('not-a-buffer' as any)).toThrowError();
+  expect(() => PublicKey.bufferize('not-a-value-hex-key')).toThrowError();
+  expect(() => PublicKey.bufferize(publicKey as any)).toThrowError();
+});
+
+it('formatting', () => {
+  const key = PublicKey.fromHex(KEY_HEX);
+
+  expect(PublicKey.isPublicKey(key)).toEqual(true);
+  PublicKey.assertValidPublicKey(key);
+
+  expect(key.toHex()).toEqual(KEY_HEX);
+});
+
+it('asBuffer', () => {
+  const key = PublicKey.fromHex(KEY_HEX);
+  const buffer = key.asBuffer();
+
+  expect(buffer).toBeInstanceOf(Buffer);
+
+  expect(Buffer.from(KEY_HEX, 'hex').equals(buffer)).toEqual(true);
+});
+
+it('asUint8Array', () => {
+  const key = PublicKey.fromHex(KEY_HEX);
+
+  const array = key.asUint8Array();
+  expect(array).toBeInstanceOf(Uint8Array);
+  expect(Buffer.from(KEY_HEX, 'hex').equals(Buffer.from(array))).toEqual(true);
+
+  expect(PublicKey.from(Buffer.from(KEY_HEX, 'hex')).asUint8Array()).toBeInstanceOf(Uint8Array);
+});
+
+it('from', () => {
+  expect(PublicKey.from(KEY_HEX).toHex())
+    .toEqual(KEY_HEX);
+
+  expect(PublicKey.from(Buffer.from(KEY_HEX, 'hex')).toHex())
+    .toEqual(KEY_HEX);
+
+  expect(PublicKey.from(new Uint8Array(32)).toHex())
+    .toEqual('0000000000000000000000000000000000000000000000000000000000000000');
+});
+
+it('equals', () => {
+  expect(PublicKey.equals(
+    PublicKey.from(KEY_HEX),
+    PublicKey.from(KEY_HEX)
+  )).toEqual(true);
+
+  expect(PublicKey.equals(
+    PublicKey.random(),
+    PublicKey.random()
+  )).toEqual(false);
+});
+
+it('expect equality', () => {
+  const key = PublicKey.random();
+  expect(key).toEqual(PublicKey.from(key.toHex()));
+});

package/src/public-key.ts

@@ -0,0 +1,201 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import assert from 'assert';
+import randomBytes from 'randombytes';
+import { inspect } from 'util';
+
+export const PUBLIC_KEY_LENGTH = 32;
+export const SECRET_KEY_LENGTH = 64;
+
+/**
+ * The purpose of this class is to assure consistent use of keys throughout the project.
+ * Keys should be maintained as buffers in objects and proto definitions, and converted to hex
+ * strings as late as possible (eg, to log/display).
+ */
+export class PublicKey {
+  /**
+   * Creates new instance of PublicKey automatically determining the input format.
+   */
+  static from (source: PublicKeyLike): PublicKey {
+    if (source instanceof PublicKey) {
+      return source;
+    } else if (source instanceof Buffer) {
+      return new PublicKey(new Uint8Array(source));
+    } else if (source instanceof Uint8Array) {
+      return new PublicKey(source);
+    } else if (typeof source === 'string') {
+      return PublicKey.fromHex(source);
+    } else if ((<any>source).asUint8Array) {
+      return new PublicKey((<any>source).asUint8Array());
+    } else {
+      throw new TypeError(`Unable to create PublicKey from ${source}`);
+    }
+  }
+
+  /**
+   * Creates new instance of PublicKey from hex string.
+   */
+  static fromHex (hex: string) {
+    if (hex.startsWith('0x')) {
+      hex = hex.slice(2);
+    }
+
+    return new PublicKey(new Uint8Array(Buffer.from(hex, 'hex')));
+  }
+
+  static random (): PublicKey {
+    return PublicKey.from(randomBytes(32));
+  }
+
+  /**
+   * Tests if provided values is an instance of PublicKey.
+   */
+  static isPublicKey (value: any): value is PublicKey {
+    return value instanceof PublicKey;
+  }
+
+  /**
+   * Asserts that provided values is an instance of PublicKey.
+   */
+  static assertValidPublicKey (value: any): asserts value is PublicKey {
+    if (!this.isPublicKey(value)) {
+      throw new TypeError('Invalid PublicKey');
+    }
+  }
+
+  /**
+   * Tests two keys for equality.
+   */
+  static equals (left: PublicKeyLike, right: PublicKeyLike) {
+    return PublicKey.from(left).equals(right);
+  }
+
+  /**
+   * @param Hex string representation of key.
+   * @return Key buffer.
+   * @deprecated All keys should be represented as instances of PublicKey.
+   */
+  static bufferize (str: string): Buffer {
+    assert(typeof str === 'string', 'Invalid type');
+    const buffer = Buffer.from(str, 'hex');
+    assert(buffer.length === PUBLIC_KEY_LENGTH || buffer.length === SECRET_KEY_LENGTH,
+      `Invalid key length: ${buffer.length}`);
+    return buffer;
+  }
+
+  /**
+   * @param Public key like data structure (but not PublicKey which should use toString).
+   * @return Hex string representation of key.
+   * @deprecated All keys should be represented as instances of PublicKey.
+   */
+  static stringify (key: Buffer | Uint8Array): string {
+    if (key instanceof PublicKey) {
+      key = key.asBuffer();
+    } else if (key instanceof Uint8Array) {
+      key = Buffer.from(key);
+    }
+
+    assert(key instanceof Buffer, 'Invalid type');
+    return key.toString('hex');
+  }
+
+  constructor (
+    private readonly _value: Uint8Array
+  ) {
+    if (!(_value instanceof Uint8Array)) {
+      throw new TypeError(`Expected Uint8Array, got: ${_value}`);
+    }
+  }
+
+  /**
+   * Return underlying Uint8Array representation.
+   */
+  asUint8Array (): Uint8Array {
+    return this._value;
+  }
+
+  /**
+   * Covert this key to buffer.
+   */
+  asBuffer (): Buffer {
+    return Buffer.from(this._value);
+  }
+
+  /**
+   * Convert this key to hex-encoded string.
+   */
+  toHex (): string {
+    return this.asBuffer().toString('hex');
+  }
+
+  /**
+   * Same as `PublicKey.humanize()`.
+   */
+  toString (): string {
+    return this.toHex();
+  }
+
+  /**
+   * Same as `PublicKey.humanize()`.
+   */
+  toJSON () {
+    return this.toHex();
+  }
+
+  truncate (n = 4) {
+    const key = this.toHex();
+    if (key.length < n * 2 + 2) {
+      return key;
+    }
+
+    return `${key.substring(0, n)}..${key.substring(key.length - n)}`;
+  }
+
+  /**
+   * Used by NodeJS to get textual representation of this object when it's printed with a `console.log` statement.
+   */
+  [inspect.custom] () {
+    return `<PublicKey ${this.truncate()}>`;
+  }
+
+  /**
+   * Test this key for equality with some other key.
+   */
+  equals (other: PublicKeyLike) {
+    const otherConverted = PublicKey.from(other);
+    if (this._value.length !== otherConverted._value.length) {
+      return false;
+    }
+    let equal = true;
+    this._value;
+    for (let i = 0; i < this._value.length; i++) {
+      equal &&= this._value[i] === otherConverted._value[i];
+    }
+    return equal;
+  }
+}
+
+/**
+ * All representations that can be converted to a PublicKey.
+ */
+// TODO(burdon): Remove this.
+export type PublicKeyLike =
+  | PublicKey
+  | Buffer
+  | Uint8Array
+  | string
+
+export const publicKeySubstitutions = {
+  // TODO(dmaretskyi): Rename to dxos.crypto.PublicKey.
+  'dxos.halo.keys.PubKey': {
+    encode: (value: PublicKey) => ({ data: value.asUint8Array() }),
+    decode: (value: any) => PublicKey.from(new Uint8Array(value.data))
+  },
+  // TODO(dmaretskyi): Shouldn't be substitutted to PublicKey.
+  'dxos.halo.keys.PrivKey': {
+    encode: (value: Buffer) => ({ data: new Uint8Array(value) }),
+    decode: (value: any) => PublicKey.from(new Uint8Array(value.data)).asBuffer()
+  }
+};