@dxos/keys 0.1.56-main.22b76d7 → 0.1.56-main.248f803
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/lib/browser/index.mjs +24 -20
- package/dist/lib/browser/index.mjs.map +3 -3
- package/dist/lib/browser/meta.json +1 -1
- package/dist/lib/node/index.cjs +24 -20
- package/dist/lib/node/index.cjs.map +3 -3
- package/dist/lib/node/meta.json +1 -1
- package/dist/types/src/public-key.d.ts +1 -0
- package/dist/types/src/public-key.d.ts.map +1 -1
- package/package.json +4 -4
- package/src/public-key.ts +13 -3
|
@@ -8,7 +8,7 @@ import { invariant } from "@dxos/invariant";
|
|
|
8
8
|
var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/keys/src/public-key.ts";
|
|
9
9
|
var PUBLIC_KEY_LENGTH = 32;
|
|
10
10
|
var SECRET_KEY_LENGTH = 64;
|
|
11
|
-
var PublicKey = class {
|
|
11
|
+
var PublicKey = class _PublicKey {
|
|
12
12
|
/**
|
|
13
13
|
* Creates new instance of PublicKey automatically determining the input format.
|
|
14
14
|
* @param source A Buffer, or Uint8Array, or hex encoded string, or something with an `asUint8Array` method on it
|
|
@@ -24,18 +24,18 @@ var PublicKey = class {
|
|
|
24
24
|
""
|
|
25
25
|
]
|
|
26
26
|
});
|
|
27
|
-
if (source instanceof
|
|
27
|
+
if (source instanceof _PublicKey) {
|
|
28
28
|
return source;
|
|
29
29
|
} else if (source instanceof Buffer) {
|
|
30
|
-
return new
|
|
30
|
+
return new _PublicKey(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));
|
|
31
31
|
} else if (source instanceof Uint8Array) {
|
|
32
|
-
return new
|
|
32
|
+
return new _PublicKey(source);
|
|
33
33
|
} else if (source instanceof ArrayBuffer) {
|
|
34
|
-
return new
|
|
34
|
+
return new _PublicKey(new Uint8Array(source));
|
|
35
35
|
} else if (typeof source === "string") {
|
|
36
|
-
return
|
|
36
|
+
return _PublicKey.fromHex(source);
|
|
37
37
|
} else if (source.asUint8Array) {
|
|
38
|
-
return new
|
|
38
|
+
return new _PublicKey(source.asUint8Array());
|
|
39
39
|
} else {
|
|
40
40
|
throw new TypeError(`Unable to create PublicKey from ${source}`);
|
|
41
41
|
}
|
|
@@ -50,8 +50,9 @@ var PublicKey = class {
|
|
|
50
50
|
return void 0;
|
|
51
51
|
}
|
|
52
52
|
try {
|
|
53
|
-
|
|
54
|
-
|
|
53
|
+
const key = _PublicKey.from(source);
|
|
54
|
+
return key;
|
|
55
|
+
} catch (err) {
|
|
55
56
|
return void 0;
|
|
56
57
|
}
|
|
57
58
|
}
|
|
@@ -63,17 +64,17 @@ var PublicKey = class {
|
|
|
63
64
|
hex = hex.slice(2);
|
|
64
65
|
}
|
|
65
66
|
const buf = Buffer.from(hex, "hex");
|
|
66
|
-
return new
|
|
67
|
+
return new _PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
|
|
67
68
|
}
|
|
68
69
|
/**
|
|
69
70
|
* Creates a new key.
|
|
70
71
|
*/
|
|
71
72
|
static random() {
|
|
72
|
-
return
|
|
73
|
+
return _PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));
|
|
73
74
|
}
|
|
74
75
|
static *randomSequence() {
|
|
75
76
|
for (let i = 0; i < 1e4; i++) {
|
|
76
|
-
yield
|
|
77
|
+
yield _PublicKey.random();
|
|
77
78
|
}
|
|
78
79
|
throw new Error("Too many keys requested");
|
|
79
80
|
}
|
|
@@ -81,7 +82,7 @@ var PublicKey = class {
|
|
|
81
82
|
* Tests if provided values is an instance of PublicKey.
|
|
82
83
|
*/
|
|
83
84
|
static isPublicKey(value) {
|
|
84
|
-
return value instanceof
|
|
85
|
+
return value instanceof _PublicKey;
|
|
85
86
|
}
|
|
86
87
|
/**
|
|
87
88
|
* Asserts that provided values is an instance of PublicKey.
|
|
@@ -95,7 +96,7 @@ var PublicKey = class {
|
|
|
95
96
|
* Tests two keys for equality.
|
|
96
97
|
*/
|
|
97
98
|
static equals(left, right) {
|
|
98
|
-
return
|
|
99
|
+
return _PublicKey.from(left).equals(right);
|
|
99
100
|
}
|
|
100
101
|
/**
|
|
101
102
|
* @param str string representation of key.
|
|
@@ -105,7 +106,7 @@ var PublicKey = class {
|
|
|
105
106
|
static bufferize(str) {
|
|
106
107
|
invariant(typeof str === "string", "Invalid type", {
|
|
107
108
|
F: __dxlog_file,
|
|
108
|
-
L:
|
|
109
|
+
L: 130,
|
|
109
110
|
S: this,
|
|
110
111
|
A: [
|
|
111
112
|
"typeof str === 'string'",
|
|
@@ -121,14 +122,14 @@ var PublicKey = class {
|
|
|
121
122
|
* @deprecated All keys should be represented as instances of PublicKey.
|
|
122
123
|
*/
|
|
123
124
|
static stringify(key) {
|
|
124
|
-
if (key instanceof
|
|
125
|
+
if (key instanceof _PublicKey) {
|
|
125
126
|
key = key.asBuffer();
|
|
126
127
|
} else if (key instanceof Uint8Array) {
|
|
127
128
|
key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);
|
|
128
129
|
}
|
|
129
130
|
invariant(key instanceof Buffer, "Invalid type", {
|
|
130
131
|
F: __dxlog_file,
|
|
131
|
-
L:
|
|
132
|
+
L: 149,
|
|
132
133
|
S: this,
|
|
133
134
|
A: [
|
|
134
135
|
"key instanceof Buffer",
|
|
@@ -156,6 +157,9 @@ var PublicKey = class {
|
|
|
156
157
|
toJSON() {
|
|
157
158
|
return this.toHex();
|
|
158
159
|
}
|
|
160
|
+
get length() {
|
|
161
|
+
return this._value.length;
|
|
162
|
+
}
|
|
159
163
|
toHex() {
|
|
160
164
|
return this.asBuffer().toString("hex");
|
|
161
165
|
}
|
|
@@ -246,18 +250,18 @@ var PublicKey = class {
|
|
|
246
250
|
* Test this key for equality with some other key.
|
|
247
251
|
*/
|
|
248
252
|
equals(other) {
|
|
249
|
-
const otherConverted =
|
|
253
|
+
const otherConverted = _PublicKey.from(other);
|
|
250
254
|
if (this._value.length !== otherConverted._value.length) {
|
|
251
255
|
return false;
|
|
252
256
|
}
|
|
253
257
|
let equal = true;
|
|
254
258
|
for (let i = 0; i < this._value.length; i++) {
|
|
255
|
-
equal
|
|
259
|
+
equal &&= this._value[i] === otherConverted._value[i];
|
|
256
260
|
}
|
|
257
261
|
return equal;
|
|
258
262
|
}
|
|
259
263
|
[equalsSymbol](other) {
|
|
260
|
-
if (!
|
|
264
|
+
if (!_PublicKey.isPublicKey(other)) {
|
|
261
265
|
return false;
|
|
262
266
|
}
|
|
263
267
|
return this.equals(other);
|
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"version": 3,
|
|
3
3
|
"sources": ["../../../src/public-key.ts"],
|
|
4
|
-
"sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { inspect, InspectOptionsStylized } from 'node:util';\nimport randomBytes from 'randombytes';\n\nimport { truncateKey, devtoolsFormatter, DevtoolsFormatter, equalsSymbol, 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 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
|
|
5
|
-
"mappings": ";;;AAIA,SAASA,eAAuC;AAChD,OAAOC,iBAAiB;AAExB,SAASC,aAAaC,mBAAsCC,oBAA+B;AAC3F,SAASC,iBAAiB;;AAEnB,IAAMC,oBAAoB;AAC1B,IAAMC,oBAAoB;AAY1B,IAAMC,YAAN,MAAMA;;;;;;EAMX,OAAOC,KAAKC,QAAkC;AAC5CL,cAAUK,QAAAA,QAAAA;;;;;;;;;AACV,QAAIA,kBAAkBF,
|
|
6
|
-
"names": ["inspect", "randomBytes", "truncateKey", "devtoolsFormatter", "equalsSymbol", "invariant", "PUBLIC_KEY_LENGTH", "SECRET_KEY_LENGTH", "PublicKey", "from", "source", "Buffer", "Uint8Array", "buffer", "byteOffset", "byteLength", "ArrayBuffer", "fromHex", "asUint8Array", "TypeError", "safeFrom", "undefined", "
|
|
4
|
+
"sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { inspect, InspectOptionsStylized } from 'node:util';\nimport randomBytes from 'randombytes';\n\nimport { truncateKey, devtoolsFormatter, DevtoolsFormatter, equalsSymbol, 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 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"],
|
|
5
|
+
"mappings": "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",
|
|
6
|
+
"names": ["inspect", "randomBytes", "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", "randomSequence", "i", "Error", "isPublicKey", "value", "assertValidPublicKey", "equals", "left", "right", "bufferize", "str", "stringify", "asBuffer", "toString", "hash", "toHex", "constructor", "_value", "toJSON", "length", "truncate", "getInsecureHash", "modulo", "Math", "abs", "reduce", "acc", "val", "custom", "depth", "options", "colors", "process", "stdout", "hasColors", "printControlCode", "code", "color", "reset", "header", "style", "other", "otherConverted", "equal"]
|
|
7
7
|
}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"inputs":{"packages/common/keys/src/public-key.ts":{"bytes":
|
|
1
|
+
{"inputs":{"packages/common/keys/src/public-key.ts":{"bytes":27526,"imports":[{"path":"@dxos/node-std/util","kind":"import-statement","external":true},{"path":"randombytes","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true}],"format":"esm"},"packages/common/keys/src/types.ts":{"bytes":641,"imports":[],"format":"esm"},"packages/common/keys/src/index.ts":{"bytes":547,"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":13032},"packages/common/keys/dist/lib/browser/index.mjs":{"imports":[{"path":"@dxos/node-std/util","kind":"import-statement","external":true},{"path":"randombytes","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","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":7044},"packages/common/keys/src/index.ts":{"bytesInOutput":0}},"bytes":7221}}}
|
package/dist/lib/node/index.cjs
CHANGED
|
@@ -44,7 +44,7 @@ var import_invariant = require("@dxos/invariant");
|
|
|
44
44
|
var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/keys/src/public-key.ts";
|
|
45
45
|
var PUBLIC_KEY_LENGTH = 32;
|
|
46
46
|
var SECRET_KEY_LENGTH = 64;
|
|
47
|
-
var PublicKey = class {
|
|
47
|
+
var PublicKey = class _PublicKey {
|
|
48
48
|
/**
|
|
49
49
|
* Creates new instance of PublicKey automatically determining the input format.
|
|
50
50
|
* @param source A Buffer, or Uint8Array, or hex encoded string, or something with an `asUint8Array` method on it
|
|
@@ -60,18 +60,18 @@ var PublicKey = class {
|
|
|
60
60
|
""
|
|
61
61
|
]
|
|
62
62
|
});
|
|
63
|
-
if (source instanceof
|
|
63
|
+
if (source instanceof _PublicKey) {
|
|
64
64
|
return source;
|
|
65
65
|
} else if (source instanceof Buffer) {
|
|
66
|
-
return new
|
|
66
|
+
return new _PublicKey(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));
|
|
67
67
|
} else if (source instanceof Uint8Array) {
|
|
68
|
-
return new
|
|
68
|
+
return new _PublicKey(source);
|
|
69
69
|
} else if (source instanceof ArrayBuffer) {
|
|
70
|
-
return new
|
|
70
|
+
return new _PublicKey(new Uint8Array(source));
|
|
71
71
|
} else if (typeof source === "string") {
|
|
72
|
-
return
|
|
72
|
+
return _PublicKey.fromHex(source);
|
|
73
73
|
} else if (source.asUint8Array) {
|
|
74
|
-
return new
|
|
74
|
+
return new _PublicKey(source.asUint8Array());
|
|
75
75
|
} else {
|
|
76
76
|
throw new TypeError(`Unable to create PublicKey from ${source}`);
|
|
77
77
|
}
|
|
@@ -86,8 +86,9 @@ var PublicKey = class {
|
|
|
86
86
|
return void 0;
|
|
87
87
|
}
|
|
88
88
|
try {
|
|
89
|
-
|
|
90
|
-
|
|
89
|
+
const key = _PublicKey.from(source);
|
|
90
|
+
return key;
|
|
91
|
+
} catch (err) {
|
|
91
92
|
return void 0;
|
|
92
93
|
}
|
|
93
94
|
}
|
|
@@ -99,17 +100,17 @@ var PublicKey = class {
|
|
|
99
100
|
hex = hex.slice(2);
|
|
100
101
|
}
|
|
101
102
|
const buf = Buffer.from(hex, "hex");
|
|
102
|
-
return new
|
|
103
|
+
return new _PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
|
|
103
104
|
}
|
|
104
105
|
/**
|
|
105
106
|
* Creates a new key.
|
|
106
107
|
*/
|
|
107
108
|
static random() {
|
|
108
|
-
return
|
|
109
|
+
return _PublicKey.from((0, import_randombytes.default)(PUBLIC_KEY_LENGTH));
|
|
109
110
|
}
|
|
110
111
|
static *randomSequence() {
|
|
111
112
|
for (let i = 0; i < 1e4; i++) {
|
|
112
|
-
yield
|
|
113
|
+
yield _PublicKey.random();
|
|
113
114
|
}
|
|
114
115
|
throw new Error("Too many keys requested");
|
|
115
116
|
}
|
|
@@ -117,7 +118,7 @@ var PublicKey = class {
|
|
|
117
118
|
* Tests if provided values is an instance of PublicKey.
|
|
118
119
|
*/
|
|
119
120
|
static isPublicKey(value) {
|
|
120
|
-
return value instanceof
|
|
121
|
+
return value instanceof _PublicKey;
|
|
121
122
|
}
|
|
122
123
|
/**
|
|
123
124
|
* Asserts that provided values is an instance of PublicKey.
|
|
@@ -131,7 +132,7 @@ var PublicKey = class {
|
|
|
131
132
|
* Tests two keys for equality.
|
|
132
133
|
*/
|
|
133
134
|
static equals(left, right) {
|
|
134
|
-
return
|
|
135
|
+
return _PublicKey.from(left).equals(right);
|
|
135
136
|
}
|
|
136
137
|
/**
|
|
137
138
|
* @param str string representation of key.
|
|
@@ -141,7 +142,7 @@ var PublicKey = class {
|
|
|
141
142
|
static bufferize(str) {
|
|
142
143
|
(0, import_invariant.invariant)(typeof str === "string", "Invalid type", {
|
|
143
144
|
F: __dxlog_file,
|
|
144
|
-
L:
|
|
145
|
+
L: 130,
|
|
145
146
|
S: this,
|
|
146
147
|
A: [
|
|
147
148
|
"typeof str === 'string'",
|
|
@@ -157,14 +158,14 @@ var PublicKey = class {
|
|
|
157
158
|
* @deprecated All keys should be represented as instances of PublicKey.
|
|
158
159
|
*/
|
|
159
160
|
static stringify(key) {
|
|
160
|
-
if (key instanceof
|
|
161
|
+
if (key instanceof _PublicKey) {
|
|
161
162
|
key = key.asBuffer();
|
|
162
163
|
} else if (key instanceof Uint8Array) {
|
|
163
164
|
key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);
|
|
164
165
|
}
|
|
165
166
|
(0, import_invariant.invariant)(key instanceof Buffer, "Invalid type", {
|
|
166
167
|
F: __dxlog_file,
|
|
167
|
-
L:
|
|
168
|
+
L: 149,
|
|
168
169
|
S: this,
|
|
169
170
|
A: [
|
|
170
171
|
"key instanceof Buffer",
|
|
@@ -192,6 +193,9 @@ var PublicKey = class {
|
|
|
192
193
|
toJSON() {
|
|
193
194
|
return this.toHex();
|
|
194
195
|
}
|
|
196
|
+
get length() {
|
|
197
|
+
return this._value.length;
|
|
198
|
+
}
|
|
195
199
|
toHex() {
|
|
196
200
|
return this.asBuffer().toString("hex");
|
|
197
201
|
}
|
|
@@ -282,18 +286,18 @@ var PublicKey = class {
|
|
|
282
286
|
* Test this key for equality with some other key.
|
|
283
287
|
*/
|
|
284
288
|
equals(other) {
|
|
285
|
-
const otherConverted =
|
|
289
|
+
const otherConverted = _PublicKey.from(other);
|
|
286
290
|
if (this._value.length !== otherConverted._value.length) {
|
|
287
291
|
return false;
|
|
288
292
|
}
|
|
289
293
|
let equal = true;
|
|
290
294
|
for (let i = 0; i < this._value.length; i++) {
|
|
291
|
-
equal
|
|
295
|
+
equal &&= this._value[i] === otherConverted._value[i];
|
|
292
296
|
}
|
|
293
297
|
return equal;
|
|
294
298
|
}
|
|
295
299
|
[import_debug.equalsSymbol](other) {
|
|
296
|
-
if (!
|
|
300
|
+
if (!_PublicKey.isPublicKey(other)) {
|
|
297
301
|
return false;
|
|
298
302
|
}
|
|
299
303
|
return this.equals(other);
|
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"version": 3,
|
|
3
3
|
"sources": ["../../../src/index.ts", "../../../src/public-key.ts"],
|
|
4
|
-
"sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nexport * from './public-key';\nexport * from './types';\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport { inspect, InspectOptionsStylized } from 'node:util';\nimport randomBytes from 'randombytes';\n\nimport { truncateKey, devtoolsFormatter, DevtoolsFormatter, equalsSymbol, 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 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
|
|
5
|
-
"mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;ACIA,uBAAgD;AAChD,yBAAwB;AAExB,mBAA2F;AAC3F,uBAA0B;;AAEnB,IAAMA,oBAAoB;AAC1B,IAAMC,oBAAoB;AAY1B,IAAMC,YAAN,MAAMA;;;;;;EAMX,OAAOC,KAAKC,QAAkC;AAC5CC,oCAAUD,QAAAA,QAAAA;;;;;;;;;AACV,QAAIA,kBAAkBF,
|
|
6
|
-
"names": ["PUBLIC_KEY_LENGTH", "SECRET_KEY_LENGTH", "PublicKey", "from", "source", "invariant", "Buffer", "Uint8Array", "buffer", "byteOffset", "byteLength", "ArrayBuffer", "fromHex", "asUint8Array", "TypeError", "safeFrom", "undefined", "
|
|
4
|
+
"sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nexport * from './public-key';\nexport * from './types';\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport { inspect, InspectOptionsStylized } from 'node:util';\nimport randomBytes from 'randombytes';\n\nimport { truncateKey, devtoolsFormatter, DevtoolsFormatter, equalsSymbol, 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 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"],
|
|
5
|
+
"mappings": "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",
|
|
6
|
+
"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", "length", "truncate", "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"]
|
|
7
7
|
}
|
package/dist/lib/node/meta.json
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"inputs":{"packages/common/keys/src/public-key.ts":{"bytes":
|
|
1
|
+
{"inputs":{"packages/common/keys/src/public-key.ts":{"bytes":27526,"imports":[{"path":"node:util","kind":"import-statement","external":true},{"path":"randombytes","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true}],"format":"esm"},"packages/common/keys/src/types.ts":{"bytes":641,"imports":[],"format":"esm"},"packages/common/keys/src/index.ts":{"bytes":547,"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":13168},"packages/common/keys/dist/lib/node/index.cjs":{"imports":[{"path":"node:util","kind":"require-call","external":true},{"path":"randombytes","kind":"require-call","external":true},{"path":"@dxos/debug","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"require-call","external":true}],"exports":[],"entryPoint":"packages/common/keys/src/index.ts","inputs":{"packages/common/keys/src/index.ts":{"bytesInOutput":215},"packages/common/keys/src/public-key.ts":{"bytesInOutput":7215}},"bytes":9087}}}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"public-key.d.ts","sourceRoot":"","sources":["../../../src/public-key.ts"],"names":[],"mappings":";;AAIA,OAAO,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAG5D,OAAO,EAAe,iBAAiB,EAAE,iBAAiB,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGzG,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;
|
|
1
|
+
{"version":3,"file":"public-key.d.ts","sourceRoot":"","sources":["../../../src/public-key.ts"],"names":[],"mappings":";;AAIA,OAAO,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAG5D,OAAO,EAAe,iBAAiB,EAAE,iBAAiB,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGzG,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,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"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@dxos/keys",
|
|
3
|
-
"version": "0.1.56-main.
|
|
3
|
+
"version": "0.1.56-main.248f803",
|
|
4
4
|
"description": "Key utils and definitions.",
|
|
5
5
|
"homepage": "https://dxos.org",
|
|
6
6
|
"bugs": "https://github.com/dxos/dxos/issues",
|
|
@@ -17,9 +17,9 @@
|
|
|
17
17
|
],
|
|
18
18
|
"dependencies": {
|
|
19
19
|
"randombytes": "^2.1.0",
|
|
20
|
-
"@dxos/debug": "0.1.56-main.
|
|
21
|
-
"@dxos/invariant": "0.1.56-main.
|
|
22
|
-
"@dxos/node-std": "0.1.56-main.
|
|
20
|
+
"@dxos/debug": "0.1.56-main.248f803",
|
|
21
|
+
"@dxos/invariant": "0.1.56-main.248f803",
|
|
22
|
+
"@dxos/node-std": "0.1.56-main.248f803"
|
|
23
23
|
},
|
|
24
24
|
"devDependencies": {
|
|
25
25
|
"@types/randombytes": "^2.0.0"
|
package/src/public-key.ts
CHANGED
|
@@ -38,6 +38,7 @@ export class PublicKey implements Equatable {
|
|
|
38
38
|
} else if (source instanceof ArrayBuffer) {
|
|
39
39
|
return new PublicKey(new Uint8Array(source));
|
|
40
40
|
} else if (typeof source === 'string') {
|
|
41
|
+
// TODO(burdon): Check length.
|
|
41
42
|
return PublicKey.fromHex(source);
|
|
42
43
|
} else if ((<any>source).asUint8Array) {
|
|
43
44
|
return new PublicKey((<any>source).asUint8Array());
|
|
@@ -57,8 +58,13 @@ export class PublicKey implements Equatable {
|
|
|
57
58
|
}
|
|
58
59
|
|
|
59
60
|
try {
|
|
60
|
-
|
|
61
|
-
|
|
61
|
+
const key = PublicKey.from(source);
|
|
62
|
+
// TODO(wittjosiah): Space keys don't pass this check.
|
|
63
|
+
// if (key.length !== PUBLIC_KEY_LENGTH && key.length !== SECRET_KEY_LENGTH) {
|
|
64
|
+
// return undefined;
|
|
65
|
+
// }
|
|
66
|
+
return key;
|
|
67
|
+
} catch (err: any) {
|
|
62
68
|
return undefined;
|
|
63
69
|
}
|
|
64
70
|
}
|
|
@@ -81,7 +87,7 @@ export class PublicKey implements Equatable {
|
|
|
81
87
|
*/
|
|
82
88
|
static random(): PublicKey {
|
|
83
89
|
// TODO(burdon): Enable seed for debugging.
|
|
84
|
-
return PublicKey.from(randomBytes(
|
|
90
|
+
return PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));
|
|
85
91
|
}
|
|
86
92
|
|
|
87
93
|
static *randomSequence(): Generator<PublicKey> {
|
|
@@ -166,6 +172,10 @@ export class PublicKey implements Equatable {
|
|
|
166
172
|
return this.toHex();
|
|
167
173
|
}
|
|
168
174
|
|
|
175
|
+
get length() {
|
|
176
|
+
return this._value.length;
|
|
177
|
+
}
|
|
178
|
+
|
|
169
179
|
toHex(): string {
|
|
170
180
|
return this.asBuffer().toString('hex');
|
|
171
181
|
}
|