@dxos/keys 0.1.56-main.e47dfd1 → 0.1.56-main.ed2f871
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 +54 -22
- package/dist/lib/browser/index.mjs.map +3 -3
- package/dist/lib/browser/meta.json +1 -1
- package/dist/lib/node/index.cjs +54 -22
- 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 -4
|
@@ -3,30 +3,39 @@ import "@dxos/node-std/globals";
|
|
|
3
3
|
// packages/common/keys/src/public-key.ts
|
|
4
4
|
import { inspect } from "@dxos/node-std/util";
|
|
5
5
|
import randomBytes from "randombytes";
|
|
6
|
-
import invariant from "tiny-invariant";
|
|
7
6
|
import { truncateKey, devtoolsFormatter, equalsSymbol } from "@dxos/debug";
|
|
7
|
+
import { invariant } from "@dxos/invariant";
|
|
8
|
+
var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/keys/src/public-key.ts";
|
|
8
9
|
var PUBLIC_KEY_LENGTH = 32;
|
|
9
10
|
var SECRET_KEY_LENGTH = 64;
|
|
10
|
-
var PublicKey = class {
|
|
11
|
+
var PublicKey = class _PublicKey {
|
|
11
12
|
/**
|
|
12
13
|
* Creates new instance of PublicKey automatically determining the input format.
|
|
13
14
|
* @param source A Buffer, or Uint8Array, or hex encoded string, or something with an `asUint8Array` method on it
|
|
14
15
|
* @returns PublicKey
|
|
15
16
|
*/
|
|
16
17
|
static from(source) {
|
|
17
|
-
invariant(source
|
|
18
|
-
|
|
18
|
+
invariant(source, void 0, {
|
|
19
|
+
F: __dxlog_file,
|
|
20
|
+
L: 31,
|
|
21
|
+
S: this,
|
|
22
|
+
A: [
|
|
23
|
+
"source",
|
|
24
|
+
""
|
|
25
|
+
]
|
|
26
|
+
});
|
|
27
|
+
if (source instanceof _PublicKey) {
|
|
19
28
|
return source;
|
|
20
29
|
} else if (source instanceof Buffer) {
|
|
21
|
-
return new
|
|
30
|
+
return new _PublicKey(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));
|
|
22
31
|
} else if (source instanceof Uint8Array) {
|
|
23
|
-
return new
|
|
32
|
+
return new _PublicKey(source);
|
|
24
33
|
} else if (source instanceof ArrayBuffer) {
|
|
25
|
-
return new
|
|
34
|
+
return new _PublicKey(new Uint8Array(source));
|
|
26
35
|
} else if (typeof source === "string") {
|
|
27
|
-
return
|
|
36
|
+
return _PublicKey.fromHex(source);
|
|
28
37
|
} else if (source.asUint8Array) {
|
|
29
|
-
return new
|
|
38
|
+
return new _PublicKey(source.asUint8Array());
|
|
30
39
|
} else {
|
|
31
40
|
throw new TypeError(`Unable to create PublicKey from ${source}`);
|
|
32
41
|
}
|
|
@@ -41,8 +50,12 @@ var PublicKey = class {
|
|
|
41
50
|
return void 0;
|
|
42
51
|
}
|
|
43
52
|
try {
|
|
44
|
-
|
|
45
|
-
|
|
53
|
+
const key = _PublicKey.from(source);
|
|
54
|
+
if (key.length !== PUBLIC_KEY_LENGTH && key.length !== SECRET_KEY_LENGTH) {
|
|
55
|
+
return void 0;
|
|
56
|
+
}
|
|
57
|
+
return key;
|
|
58
|
+
} catch (err) {
|
|
46
59
|
return void 0;
|
|
47
60
|
}
|
|
48
61
|
}
|
|
@@ -54,17 +67,17 @@ var PublicKey = class {
|
|
|
54
67
|
hex = hex.slice(2);
|
|
55
68
|
}
|
|
56
69
|
const buf = Buffer.from(hex, "hex");
|
|
57
|
-
return new
|
|
70
|
+
return new _PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
|
|
58
71
|
}
|
|
59
72
|
/**
|
|
60
73
|
* Creates a new key.
|
|
61
74
|
*/
|
|
62
75
|
static random() {
|
|
63
|
-
return
|
|
76
|
+
return _PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));
|
|
64
77
|
}
|
|
65
78
|
static *randomSequence() {
|
|
66
79
|
for (let i = 0; i < 1e4; i++) {
|
|
67
|
-
yield
|
|
80
|
+
yield _PublicKey.random();
|
|
68
81
|
}
|
|
69
82
|
throw new Error("Too many keys requested");
|
|
70
83
|
}
|
|
@@ -72,7 +85,7 @@ var PublicKey = class {
|
|
|
72
85
|
* Tests if provided values is an instance of PublicKey.
|
|
73
86
|
*/
|
|
74
87
|
static isPublicKey(value) {
|
|
75
|
-
return value instanceof
|
|
88
|
+
return value instanceof _PublicKey;
|
|
76
89
|
}
|
|
77
90
|
/**
|
|
78
91
|
* Asserts that provided values is an instance of PublicKey.
|
|
@@ -86,7 +99,7 @@ var PublicKey = class {
|
|
|
86
99
|
* Tests two keys for equality.
|
|
87
100
|
*/
|
|
88
101
|
static equals(left, right) {
|
|
89
|
-
return
|
|
102
|
+
return _PublicKey.from(left).equals(right);
|
|
90
103
|
}
|
|
91
104
|
/**
|
|
92
105
|
* @param str string representation of key.
|
|
@@ -94,7 +107,15 @@ var PublicKey = class {
|
|
|
94
107
|
* @deprecated All keys should be represented as instances of PublicKey.
|
|
95
108
|
*/
|
|
96
109
|
static bufferize(str) {
|
|
97
|
-
invariant(typeof str === "string", "Invalid type"
|
|
110
|
+
invariant(typeof str === "string", "Invalid type", {
|
|
111
|
+
F: __dxlog_file,
|
|
112
|
+
L: 129,
|
|
113
|
+
S: this,
|
|
114
|
+
A: [
|
|
115
|
+
"typeof str === 'string'",
|
|
116
|
+
"'Invalid type'"
|
|
117
|
+
]
|
|
118
|
+
});
|
|
98
119
|
const buffer = Buffer.from(str, "hex");
|
|
99
120
|
return buffer;
|
|
100
121
|
}
|
|
@@ -104,12 +125,20 @@ var PublicKey = class {
|
|
|
104
125
|
* @deprecated All keys should be represented as instances of PublicKey.
|
|
105
126
|
*/
|
|
106
127
|
static stringify(key) {
|
|
107
|
-
if (key instanceof
|
|
128
|
+
if (key instanceof _PublicKey) {
|
|
108
129
|
key = key.asBuffer();
|
|
109
130
|
} else if (key instanceof Uint8Array) {
|
|
110
131
|
key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);
|
|
111
132
|
}
|
|
112
|
-
invariant(key instanceof Buffer, "Invalid type"
|
|
133
|
+
invariant(key instanceof Buffer, "Invalid type", {
|
|
134
|
+
F: __dxlog_file,
|
|
135
|
+
L: 148,
|
|
136
|
+
S: this,
|
|
137
|
+
A: [
|
|
138
|
+
"key instanceof Buffer",
|
|
139
|
+
"'Invalid type'"
|
|
140
|
+
]
|
|
141
|
+
});
|
|
113
142
|
return key.toString("hex");
|
|
114
143
|
}
|
|
115
144
|
/**
|
|
@@ -131,6 +160,9 @@ var PublicKey = class {
|
|
|
131
160
|
toJSON() {
|
|
132
161
|
return this.toHex();
|
|
133
162
|
}
|
|
163
|
+
get length() {
|
|
164
|
+
return this._value.buffer.byteLength - 1;
|
|
165
|
+
}
|
|
134
166
|
toHex() {
|
|
135
167
|
return this.asBuffer().toString("hex");
|
|
136
168
|
}
|
|
@@ -221,18 +253,18 @@ var PublicKey = class {
|
|
|
221
253
|
* Test this key for equality with some other key.
|
|
222
254
|
*/
|
|
223
255
|
equals(other) {
|
|
224
|
-
const otherConverted =
|
|
256
|
+
const otherConverted = _PublicKey.from(other);
|
|
225
257
|
if (this._value.length !== otherConverted._value.length) {
|
|
226
258
|
return false;
|
|
227
259
|
}
|
|
228
260
|
let equal = true;
|
|
229
261
|
for (let i = 0; i < this._value.length; i++) {
|
|
230
|
-
equal
|
|
262
|
+
equal &&= this._value[i] === otherConverted._value[i];
|
|
231
263
|
}
|
|
232
264
|
return equal;
|
|
233
265
|
}
|
|
234
266
|
[equalsSymbol](other) {
|
|
235
|
-
if (!
|
|
267
|
+
if (!_PublicKey.isPublicKey(other)) {
|
|
236
268
|
return false;
|
|
237
269
|
}
|
|
238
270
|
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';\
|
|
5
|
-
"mappings": ";;;AAIA,SAASA,eAAuC;AAChD,OAAOC,iBAAiB;
|
|
6
|
-
"names": ["inspect", "randomBytes", "
|
|
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 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.buffer.byteLength - 1;\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", "length", "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", "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":27455,"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":13068},"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":7172},"packages/common/keys/src/index.ts":{"bytesInOutput":0}},"bytes":7349}}}
|
package/dist/lib/node/index.cjs
CHANGED
|
@@ -39,30 +39,39 @@ module.exports = __toCommonJS(src_exports);
|
|
|
39
39
|
// packages/common/keys/src/public-key.ts
|
|
40
40
|
var import_node_util = require("node:util");
|
|
41
41
|
var import_randombytes = __toESM(require("randombytes"));
|
|
42
|
-
var import_tiny_invariant = __toESM(require("tiny-invariant"));
|
|
43
42
|
var import_debug = require("@dxos/debug");
|
|
43
|
+
var import_invariant = require("@dxos/invariant");
|
|
44
|
+
var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/keys/src/public-key.ts";
|
|
44
45
|
var PUBLIC_KEY_LENGTH = 32;
|
|
45
46
|
var SECRET_KEY_LENGTH = 64;
|
|
46
|
-
var PublicKey = class {
|
|
47
|
+
var PublicKey = class _PublicKey {
|
|
47
48
|
/**
|
|
48
49
|
* Creates new instance of PublicKey automatically determining the input format.
|
|
49
50
|
* @param source A Buffer, or Uint8Array, or hex encoded string, or something with an `asUint8Array` method on it
|
|
50
51
|
* @returns PublicKey
|
|
51
52
|
*/
|
|
52
53
|
static from(source) {
|
|
53
|
-
(0,
|
|
54
|
-
|
|
54
|
+
(0, import_invariant.invariant)(source, void 0, {
|
|
55
|
+
F: __dxlog_file,
|
|
56
|
+
L: 31,
|
|
57
|
+
S: this,
|
|
58
|
+
A: [
|
|
59
|
+
"source",
|
|
60
|
+
""
|
|
61
|
+
]
|
|
62
|
+
});
|
|
63
|
+
if (source instanceof _PublicKey) {
|
|
55
64
|
return source;
|
|
56
65
|
} else if (source instanceof Buffer) {
|
|
57
|
-
return new
|
|
66
|
+
return new _PublicKey(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));
|
|
58
67
|
} else if (source instanceof Uint8Array) {
|
|
59
|
-
return new
|
|
68
|
+
return new _PublicKey(source);
|
|
60
69
|
} else if (source instanceof ArrayBuffer) {
|
|
61
|
-
return new
|
|
70
|
+
return new _PublicKey(new Uint8Array(source));
|
|
62
71
|
} else if (typeof source === "string") {
|
|
63
|
-
return
|
|
72
|
+
return _PublicKey.fromHex(source);
|
|
64
73
|
} else if (source.asUint8Array) {
|
|
65
|
-
return new
|
|
74
|
+
return new _PublicKey(source.asUint8Array());
|
|
66
75
|
} else {
|
|
67
76
|
throw new TypeError(`Unable to create PublicKey from ${source}`);
|
|
68
77
|
}
|
|
@@ -77,8 +86,12 @@ var PublicKey = class {
|
|
|
77
86
|
return void 0;
|
|
78
87
|
}
|
|
79
88
|
try {
|
|
80
|
-
|
|
81
|
-
|
|
89
|
+
const key = _PublicKey.from(source);
|
|
90
|
+
if (key.length !== PUBLIC_KEY_LENGTH && key.length !== SECRET_KEY_LENGTH) {
|
|
91
|
+
return void 0;
|
|
92
|
+
}
|
|
93
|
+
return key;
|
|
94
|
+
} catch (err) {
|
|
82
95
|
return void 0;
|
|
83
96
|
}
|
|
84
97
|
}
|
|
@@ -90,17 +103,17 @@ var PublicKey = class {
|
|
|
90
103
|
hex = hex.slice(2);
|
|
91
104
|
}
|
|
92
105
|
const buf = Buffer.from(hex, "hex");
|
|
93
|
-
return new
|
|
106
|
+
return new _PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
|
|
94
107
|
}
|
|
95
108
|
/**
|
|
96
109
|
* Creates a new key.
|
|
97
110
|
*/
|
|
98
111
|
static random() {
|
|
99
|
-
return
|
|
112
|
+
return _PublicKey.from((0, import_randombytes.default)(PUBLIC_KEY_LENGTH));
|
|
100
113
|
}
|
|
101
114
|
static *randomSequence() {
|
|
102
115
|
for (let i = 0; i < 1e4; i++) {
|
|
103
|
-
yield
|
|
116
|
+
yield _PublicKey.random();
|
|
104
117
|
}
|
|
105
118
|
throw new Error("Too many keys requested");
|
|
106
119
|
}
|
|
@@ -108,7 +121,7 @@ var PublicKey = class {
|
|
|
108
121
|
* Tests if provided values is an instance of PublicKey.
|
|
109
122
|
*/
|
|
110
123
|
static isPublicKey(value) {
|
|
111
|
-
return value instanceof
|
|
124
|
+
return value instanceof _PublicKey;
|
|
112
125
|
}
|
|
113
126
|
/**
|
|
114
127
|
* Asserts that provided values is an instance of PublicKey.
|
|
@@ -122,7 +135,7 @@ var PublicKey = class {
|
|
|
122
135
|
* Tests two keys for equality.
|
|
123
136
|
*/
|
|
124
137
|
static equals(left, right) {
|
|
125
|
-
return
|
|
138
|
+
return _PublicKey.from(left).equals(right);
|
|
126
139
|
}
|
|
127
140
|
/**
|
|
128
141
|
* @param str string representation of key.
|
|
@@ -130,7 +143,15 @@ var PublicKey = class {
|
|
|
130
143
|
* @deprecated All keys should be represented as instances of PublicKey.
|
|
131
144
|
*/
|
|
132
145
|
static bufferize(str) {
|
|
133
|
-
(0,
|
|
146
|
+
(0, import_invariant.invariant)(typeof str === "string", "Invalid type", {
|
|
147
|
+
F: __dxlog_file,
|
|
148
|
+
L: 129,
|
|
149
|
+
S: this,
|
|
150
|
+
A: [
|
|
151
|
+
"typeof str === 'string'",
|
|
152
|
+
"'Invalid type'"
|
|
153
|
+
]
|
|
154
|
+
});
|
|
134
155
|
const buffer = Buffer.from(str, "hex");
|
|
135
156
|
return buffer;
|
|
136
157
|
}
|
|
@@ -140,12 +161,20 @@ var PublicKey = class {
|
|
|
140
161
|
* @deprecated All keys should be represented as instances of PublicKey.
|
|
141
162
|
*/
|
|
142
163
|
static stringify(key) {
|
|
143
|
-
if (key instanceof
|
|
164
|
+
if (key instanceof _PublicKey) {
|
|
144
165
|
key = key.asBuffer();
|
|
145
166
|
} else if (key instanceof Uint8Array) {
|
|
146
167
|
key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);
|
|
147
168
|
}
|
|
148
|
-
(0,
|
|
169
|
+
(0, import_invariant.invariant)(key instanceof Buffer, "Invalid type", {
|
|
170
|
+
F: __dxlog_file,
|
|
171
|
+
L: 148,
|
|
172
|
+
S: this,
|
|
173
|
+
A: [
|
|
174
|
+
"key instanceof Buffer",
|
|
175
|
+
"'Invalid type'"
|
|
176
|
+
]
|
|
177
|
+
});
|
|
149
178
|
return key.toString("hex");
|
|
150
179
|
}
|
|
151
180
|
/**
|
|
@@ -167,6 +196,9 @@ var PublicKey = class {
|
|
|
167
196
|
toJSON() {
|
|
168
197
|
return this.toHex();
|
|
169
198
|
}
|
|
199
|
+
get length() {
|
|
200
|
+
return this._value.buffer.byteLength - 1;
|
|
201
|
+
}
|
|
170
202
|
toHex() {
|
|
171
203
|
return this.asBuffer().toString("hex");
|
|
172
204
|
}
|
|
@@ -257,18 +289,18 @@ var PublicKey = class {
|
|
|
257
289
|
* Test this key for equality with some other key.
|
|
258
290
|
*/
|
|
259
291
|
equals(other) {
|
|
260
|
-
const otherConverted =
|
|
292
|
+
const otherConverted = _PublicKey.from(other);
|
|
261
293
|
if (this._value.length !== otherConverted._value.length) {
|
|
262
294
|
return false;
|
|
263
295
|
}
|
|
264
296
|
let equal = true;
|
|
265
297
|
for (let i = 0; i < this._value.length; i++) {
|
|
266
|
-
equal
|
|
298
|
+
equal &&= this._value[i] === otherConverted._value[i];
|
|
267
299
|
}
|
|
268
300
|
return equal;
|
|
269
301
|
}
|
|
270
302
|
[import_debug.equalsSymbol](other) {
|
|
271
|
-
if (!
|
|
303
|
+
if (!_PublicKey.isPublicKey(other)) {
|
|
272
304
|
return false;
|
|
273
305
|
}
|
|
274
306
|
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';\
|
|
5
|
-
"mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;ACIA,uBAAgD;AAChD,yBAAwB;
|
|
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 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.buffer.byteLength - 1;\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", "length", "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", "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":27455,"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":13205},"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":7343}},"bytes":9215}}}
|
|
@@ -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;
|
|
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;IAwI7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAvInC;;;;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;IAgB9D;;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.ed2f871",
|
|
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
|
-
"
|
|
21
|
-
"@dxos/
|
|
22
|
-
"@dxos/node-std": "0.1.56-main.
|
|
20
|
+
"@dxos/debug": "0.1.56-main.ed2f871",
|
|
21
|
+
"@dxos/invariant": "0.1.56-main.ed2f871",
|
|
22
|
+
"@dxos/node-std": "0.1.56-main.ed2f871"
|
|
23
23
|
},
|
|
24
24
|
"devDependencies": {
|
|
25
25
|
"@types/randombytes": "^2.0.0"
|
package/src/public-key.ts
CHANGED
|
@@ -4,9 +4,9 @@
|
|
|
4
4
|
|
|
5
5
|
import { inspect, InspectOptionsStylized } from 'node:util';
|
|
6
6
|
import randomBytes from 'randombytes';
|
|
7
|
-
import invariant from 'tiny-invariant';
|
|
8
7
|
|
|
9
8
|
import { truncateKey, devtoolsFormatter, DevtoolsFormatter, equalsSymbol, Equatable } from '@dxos/debug';
|
|
9
|
+
import { invariant } from '@dxos/invariant';
|
|
10
10
|
|
|
11
11
|
export const PUBLIC_KEY_LENGTH = 32;
|
|
12
12
|
export const SECRET_KEY_LENGTH = 64;
|
|
@@ -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,12 @@ export class PublicKey implements Equatable {
|
|
|
57
58
|
}
|
|
58
59
|
|
|
59
60
|
try {
|
|
60
|
-
|
|
61
|
-
|
|
61
|
+
const key = PublicKey.from(source);
|
|
62
|
+
if (key.length !== PUBLIC_KEY_LENGTH && key.length !== SECRET_KEY_LENGTH) {
|
|
63
|
+
return undefined;
|
|
64
|
+
}
|
|
65
|
+
return key;
|
|
66
|
+
} catch (err: any) {
|
|
62
67
|
return undefined;
|
|
63
68
|
}
|
|
64
69
|
}
|
|
@@ -81,7 +86,7 @@ export class PublicKey implements Equatable {
|
|
|
81
86
|
*/
|
|
82
87
|
static random(): PublicKey {
|
|
83
88
|
// TODO(burdon): Enable seed for debugging.
|
|
84
|
-
return PublicKey.from(randomBytes(
|
|
89
|
+
return PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));
|
|
85
90
|
}
|
|
86
91
|
|
|
87
92
|
static *randomSequence(): Generator<PublicKey> {
|
|
@@ -166,6 +171,10 @@ export class PublicKey implements Equatable {
|
|
|
166
171
|
return this.toHex();
|
|
167
172
|
}
|
|
168
173
|
|
|
174
|
+
get length() {
|
|
175
|
+
return this._value.buffer.byteLength - 1;
|
|
176
|
+
}
|
|
177
|
+
|
|
169
178
|
toHex(): string {
|
|
170
179
|
return this.asBuffer().toString('hex');
|
|
171
180
|
}
|