@dxos/keys 0.1.56-main.c19b7cd → 0.1.56-main.c277f68
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 +20 -23
- package/dist/lib/browser/index.mjs.map +3 -3
- package/dist/lib/browser/meta.json +1 -1
- package/dist/lib/node/index.cjs +20 -23
- 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.map +1 -1
- package/package.json +4 -4
- package/src/public-key.ts +5 -4
|
@@ -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,10 +50,7 @@ var PublicKey = class {
|
|
|
50
50
|
return void 0;
|
|
51
51
|
}
|
|
52
52
|
try {
|
|
53
|
-
const key =
|
|
54
|
-
if (key.length !== PUBLIC_KEY_LENGTH && key.length !== SECRET_KEY_LENGTH) {
|
|
55
|
-
return void 0;
|
|
56
|
-
}
|
|
53
|
+
const key = _PublicKey.from(source);
|
|
57
54
|
return key;
|
|
58
55
|
} catch (err) {
|
|
59
56
|
return void 0;
|
|
@@ -67,17 +64,17 @@ var PublicKey = class {
|
|
|
67
64
|
hex = hex.slice(2);
|
|
68
65
|
}
|
|
69
66
|
const buf = Buffer.from(hex, "hex");
|
|
70
|
-
return new
|
|
67
|
+
return new _PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
|
|
71
68
|
}
|
|
72
69
|
/**
|
|
73
70
|
* Creates a new key.
|
|
74
71
|
*/
|
|
75
72
|
static random() {
|
|
76
|
-
return
|
|
73
|
+
return _PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));
|
|
77
74
|
}
|
|
78
75
|
static *randomSequence() {
|
|
79
76
|
for (let i = 0; i < 1e4; i++) {
|
|
80
|
-
yield
|
|
77
|
+
yield _PublicKey.random();
|
|
81
78
|
}
|
|
82
79
|
throw new Error("Too many keys requested");
|
|
83
80
|
}
|
|
@@ -85,7 +82,7 @@ var PublicKey = class {
|
|
|
85
82
|
* Tests if provided values is an instance of PublicKey.
|
|
86
83
|
*/
|
|
87
84
|
static isPublicKey(value) {
|
|
88
|
-
return value instanceof
|
|
85
|
+
return value instanceof _PublicKey;
|
|
89
86
|
}
|
|
90
87
|
/**
|
|
91
88
|
* Asserts that provided values is an instance of PublicKey.
|
|
@@ -99,7 +96,7 @@ var PublicKey = class {
|
|
|
99
96
|
* Tests two keys for equality.
|
|
100
97
|
*/
|
|
101
98
|
static equals(left, right) {
|
|
102
|
-
return
|
|
99
|
+
return _PublicKey.from(left).equals(right);
|
|
103
100
|
}
|
|
104
101
|
/**
|
|
105
102
|
* @param str string representation of key.
|
|
@@ -109,7 +106,7 @@ var PublicKey = class {
|
|
|
109
106
|
static bufferize(str) {
|
|
110
107
|
invariant(typeof str === "string", "Invalid type", {
|
|
111
108
|
F: __dxlog_file,
|
|
112
|
-
L:
|
|
109
|
+
L: 130,
|
|
113
110
|
S: this,
|
|
114
111
|
A: [
|
|
115
112
|
"typeof str === 'string'",
|
|
@@ -125,14 +122,14 @@ var PublicKey = class {
|
|
|
125
122
|
* @deprecated All keys should be represented as instances of PublicKey.
|
|
126
123
|
*/
|
|
127
124
|
static stringify(key) {
|
|
128
|
-
if (key instanceof
|
|
125
|
+
if (key instanceof _PublicKey) {
|
|
129
126
|
key = key.asBuffer();
|
|
130
127
|
} else if (key instanceof Uint8Array) {
|
|
131
128
|
key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);
|
|
132
129
|
}
|
|
133
130
|
invariant(key instanceof Buffer, "Invalid type", {
|
|
134
131
|
F: __dxlog_file,
|
|
135
|
-
L:
|
|
132
|
+
L: 149,
|
|
136
133
|
S: this,
|
|
137
134
|
A: [
|
|
138
135
|
"key instanceof Buffer",
|
|
@@ -161,7 +158,7 @@ var PublicKey = class {
|
|
|
161
158
|
return this.toHex();
|
|
162
159
|
}
|
|
163
160
|
get length() {
|
|
164
|
-
return this._value.
|
|
161
|
+
return this._value.length;
|
|
165
162
|
}
|
|
166
163
|
toHex() {
|
|
167
164
|
return this.asBuffer().toString("hex");
|
|
@@ -253,18 +250,18 @@ var PublicKey = class {
|
|
|
253
250
|
* Test this key for equality with some other key.
|
|
254
251
|
*/
|
|
255
252
|
equals(other) {
|
|
256
|
-
const otherConverted =
|
|
253
|
+
const otherConverted = _PublicKey.from(other);
|
|
257
254
|
if (this._value.length !== otherConverted._value.length) {
|
|
258
255
|
return false;
|
|
259
256
|
}
|
|
260
257
|
let equal = true;
|
|
261
258
|
for (let i = 0; i < this._value.length; i++) {
|
|
262
|
-
equal
|
|
259
|
+
equal &&= this._value[i] === otherConverted._value[i];
|
|
263
260
|
}
|
|
264
261
|
return equal;
|
|
265
262
|
}
|
|
266
263
|
[equalsSymbol](other) {
|
|
267
|
-
if (!
|
|
264
|
+
if (!_PublicKey.isPublicKey(other)) {
|
|
268
265
|
return false;
|
|
269
266
|
}
|
|
270
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 // 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
|
|
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", "key", "
|
|
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,10 +86,7 @@ var PublicKey = class {
|
|
|
86
86
|
return void 0;
|
|
87
87
|
}
|
|
88
88
|
try {
|
|
89
|
-
const key =
|
|
90
|
-
if (key.length !== PUBLIC_KEY_LENGTH && key.length !== SECRET_KEY_LENGTH) {
|
|
91
|
-
return void 0;
|
|
92
|
-
}
|
|
89
|
+
const key = _PublicKey.from(source);
|
|
93
90
|
return key;
|
|
94
91
|
} catch (err) {
|
|
95
92
|
return void 0;
|
|
@@ -103,17 +100,17 @@ var PublicKey = class {
|
|
|
103
100
|
hex = hex.slice(2);
|
|
104
101
|
}
|
|
105
102
|
const buf = Buffer.from(hex, "hex");
|
|
106
|
-
return new
|
|
103
|
+
return new _PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
|
|
107
104
|
}
|
|
108
105
|
/**
|
|
109
106
|
* Creates a new key.
|
|
110
107
|
*/
|
|
111
108
|
static random() {
|
|
112
|
-
return
|
|
109
|
+
return _PublicKey.from((0, import_randombytes.default)(PUBLIC_KEY_LENGTH));
|
|
113
110
|
}
|
|
114
111
|
static *randomSequence() {
|
|
115
112
|
for (let i = 0; i < 1e4; i++) {
|
|
116
|
-
yield
|
|
113
|
+
yield _PublicKey.random();
|
|
117
114
|
}
|
|
118
115
|
throw new Error("Too many keys requested");
|
|
119
116
|
}
|
|
@@ -121,7 +118,7 @@ var PublicKey = class {
|
|
|
121
118
|
* Tests if provided values is an instance of PublicKey.
|
|
122
119
|
*/
|
|
123
120
|
static isPublicKey(value) {
|
|
124
|
-
return value instanceof
|
|
121
|
+
return value instanceof _PublicKey;
|
|
125
122
|
}
|
|
126
123
|
/**
|
|
127
124
|
* Asserts that provided values is an instance of PublicKey.
|
|
@@ -135,7 +132,7 @@ var PublicKey = class {
|
|
|
135
132
|
* Tests two keys for equality.
|
|
136
133
|
*/
|
|
137
134
|
static equals(left, right) {
|
|
138
|
-
return
|
|
135
|
+
return _PublicKey.from(left).equals(right);
|
|
139
136
|
}
|
|
140
137
|
/**
|
|
141
138
|
* @param str string representation of key.
|
|
@@ -145,7 +142,7 @@ var PublicKey = class {
|
|
|
145
142
|
static bufferize(str) {
|
|
146
143
|
(0, import_invariant.invariant)(typeof str === "string", "Invalid type", {
|
|
147
144
|
F: __dxlog_file,
|
|
148
|
-
L:
|
|
145
|
+
L: 130,
|
|
149
146
|
S: this,
|
|
150
147
|
A: [
|
|
151
148
|
"typeof str === 'string'",
|
|
@@ -161,14 +158,14 @@ var PublicKey = class {
|
|
|
161
158
|
* @deprecated All keys should be represented as instances of PublicKey.
|
|
162
159
|
*/
|
|
163
160
|
static stringify(key) {
|
|
164
|
-
if (key instanceof
|
|
161
|
+
if (key instanceof _PublicKey) {
|
|
165
162
|
key = key.asBuffer();
|
|
166
163
|
} else if (key instanceof Uint8Array) {
|
|
167
164
|
key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);
|
|
168
165
|
}
|
|
169
166
|
(0, import_invariant.invariant)(key instanceof Buffer, "Invalid type", {
|
|
170
167
|
F: __dxlog_file,
|
|
171
|
-
L:
|
|
168
|
+
L: 149,
|
|
172
169
|
S: this,
|
|
173
170
|
A: [
|
|
174
171
|
"key instanceof Buffer",
|
|
@@ -197,7 +194,7 @@ var PublicKey = class {
|
|
|
197
194
|
return this.toHex();
|
|
198
195
|
}
|
|
199
196
|
get length() {
|
|
200
|
-
return this._value.
|
|
197
|
+
return this._value.length;
|
|
201
198
|
}
|
|
202
199
|
toHex() {
|
|
203
200
|
return this.asBuffer().toString("hex");
|
|
@@ -289,18 +286,18 @@ var PublicKey = class {
|
|
|
289
286
|
* Test this key for equality with some other key.
|
|
290
287
|
*/
|
|
291
288
|
equals(other) {
|
|
292
|
-
const otherConverted =
|
|
289
|
+
const otherConverted = _PublicKey.from(other);
|
|
293
290
|
if (this._value.length !== otherConverted._value.length) {
|
|
294
291
|
return false;
|
|
295
292
|
}
|
|
296
293
|
let equal = true;
|
|
297
294
|
for (let i = 0; i < this._value.length; i++) {
|
|
298
|
-
equal
|
|
295
|
+
equal &&= this._value[i] === otherConverted._value[i];
|
|
299
296
|
}
|
|
300
297
|
return equal;
|
|
301
298
|
}
|
|
302
299
|
[import_debug.equalsSymbol](other) {
|
|
303
|
-
if (!
|
|
300
|
+
if (!_PublicKey.isPublicKey(other)) {
|
|
304
301
|
return false;
|
|
305
302
|
}
|
|
306
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 // 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
|
|
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", "key", "
|
|
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.c277f68",
|
|
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.c277f68",
|
|
21
|
+
"@dxos/invariant": "0.1.56-main.c277f68",
|
|
22
|
+
"@dxos/node-std": "0.1.56-main.c277f68"
|
|
23
23
|
},
|
|
24
24
|
"devDependencies": {
|
|
25
25
|
"@types/randombytes": "^2.0.0"
|
package/src/public-key.ts
CHANGED
|
@@ -59,9 +59,10 @@ export class PublicKey implements Equatable {
|
|
|
59
59
|
|
|
60
60
|
try {
|
|
61
61
|
const key = PublicKey.from(source);
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
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
|
+
// }
|
|
65
66
|
return key;
|
|
66
67
|
} catch (err: any) {
|
|
67
68
|
return undefined;
|
|
@@ -172,7 +173,7 @@ export class PublicKey implements Equatable {
|
|
|
172
173
|
}
|
|
173
174
|
|
|
174
175
|
get length() {
|
|
175
|
-
return this._value.
|
|
176
|
+
return this._value.length;
|
|
176
177
|
}
|
|
177
178
|
|
|
178
179
|
toHex(): string {
|