chedder
Version:
143 lines • 5.14 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.KeyPairEd25519 = exports.KeyPair = exports.PublicKey = exports.KeyType = void 0;
const enums_js_1 = require("./enums.js");
const nacl = __importStar(require("../tweetnacl/sign.js"));
const serialize_js_1 = require("./serialize.js");
/** All supported key types */
var KeyType;
(function (KeyType) {
KeyType[KeyType["ED25519"] = 0] = "ED25519";
})(KeyType = exports.KeyType || (exports.KeyType = {}));
function key_type_to_str(keyType) {
switch (keyType) {
case KeyType.ED25519: return 'ed25519';
default: throw new Error(`Unknown key type ${keyType}`);
}
}
function str_to_key_type(keyType) {
switch (keyType.toLowerCase()) {
case 'ed25519': return KeyType.ED25519;
default: throw new Error(`Unknown key type ${keyType}`);
}
}
/**
* PublicKey representation that has type and bytes of the key.
*/
class PublicKey extends enums_js_1.Assignable {
static from(value) {
if (typeof value === 'string') {
return PublicKey.fromString(value);
}
return value;
}
static fromString(encodedKey) {
const parts = encodedKey.split(':');
if (parts.length === 1) {
return new PublicKey({ keyType: KeyType.ED25519, data: serialize_js_1.base_decode(parts[0]) });
}
else if (parts.length === 2) {
return new PublicKey({ keyType: str_to_key_type(parts[0]), data: serialize_js_1.base_decode(parts[1]) });
}
else {
throw new Error('Invalid encoded key format, must be <curve>:<encoded key>');
}
}
toString() {
return `${key_type_to_str(this.keyType)}:${serialize_js_1.base_encode(this.data)}`;
}
}
exports.PublicKey = PublicKey;
class KeyPair {
/**
* @param curve Name of elliptical curve, case-insensitive
* @returns Random KeyPair based on the curve
*/
static fromRandom(curve) {
switch (curve.toUpperCase()) {
case 'ED25519': return KeyPairEd25519.fromRandom();
default: throw new Error(`Unknown curve ${curve}`);
}
}
static fromString(encodedKey) {
const parts = encodedKey.split(':');
if (parts.length === 1) {
return new KeyPairEd25519(parts[0]);
}
else if (parts.length === 2) {
switch (parts[0].toUpperCase()) {
case 'ED25519': return new KeyPairEd25519(parts[1]);
default: throw new Error(`Unknown curve: ${parts[0]}`);
}
}
else {
throw new Error('Invalid encoded key format, must be <curve>:<encoded key>');
}
}
}
exports.KeyPair = KeyPair;
/**
* This class provides key pair functionality for Ed25519 curve:
* generating key pairs, encoding key pairs, signing and verifying.
*/
class KeyPairEd25519 extends KeyPair {
/**
* Construct an instance of key pair given a secret key.
* It's generally assumed that these are encoded in base58.
* @param {string} secretKey
*/
constructor(secretKey) {
super();
const keyPair = nacl.sign_keyPair_fromSecretKey(serialize_js_1.base_decode(secretKey));
this.publicKey = new PublicKey({ keyType: KeyType.ED25519, data: keyPair.publicKey });
this.secretKey = secretKey;
}
/**
* Generate a new random keypair.
* @example
* const keyRandom = KeyPair.fromRandom();
* keyRandom.publicKey
* // returns [PUBLIC_KEY]
*
* keyRandom.secretKey
* // returns [SECRET_KEY]
*/
static fromRandom() {
const newKeyPair = nacl.sign_keyPair();
return new KeyPairEd25519(serialize_js_1.base_encode(newKeyPair.secretKey));
}
sign(message) {
const signature = nacl.sign_detached(message, serialize_js_1.base_decode(this.secretKey));
return { signature, publicKey: this.publicKey };
}
verify(message, signature) {
return nacl.sign_detached_verify(message, signature, this.publicKey.data);
}
toString() {
return `ed25519:${this.secretKey}`;
}
getPublicKey() {
return this.publicKey;
}
}
exports.KeyPairEd25519 = KeyPairEd25519;
//# sourceMappingURL=key-pair.js.map